creating2morrow/neveko
1
0
Fork 0
mirror of https://github.com/creating2morrow/neveko.git synced 2024-12-22 19:49:24 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

clippy patches

Browse source
This commit is contained in:
c2m 2024-09-29 21:58:46 -04:00
parent ca736c487b
commit 967c903f67
12 changed files with 58 additions and 152 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
neveko-core/src/auth.rs
View file

@ -83,7 +83,7 @@ fn update_expiration(f_auth: &Authorization, address: &String) -> Result<Authori
create_token(String::from(address), time), create_token(String::from(address), time),
); );
let db = &DATABASE_LOCK; let db = &DATABASE_LOCK;
let _ = db::DatabaseEnvironment::delete(&db.env, &db.handle, &u_auth.aid.as_bytes().to_vec())?; db::DatabaseEnvironment::delete(&db.env, &db.handle, u_auth.aid.as_bytes())?;
let k = u_auth.aid.as_bytes(); let k = u_auth.aid.as_bytes();
let v = bincode::serialize(&u_auth).unwrap_or_default(); let v = bincode::serialize(&u_auth).unwrap_or_default();
db::write_chunks(&db.env, &db.handle, k, &v)?; db::write_chunks(&db.env, &db.handle, k, &v)?;
@ -128,7 +128,7 @@ pub async fn verify_login(
// update auth with uid // update auth with uid
let u_auth = Authorization::update_uid(f_auth, String::from(&u.uid)); let u_auth = Authorization::update_uid(f_auth, String::from(&u.uid));
let db = &DATABASE_LOCK; let db = &DATABASE_LOCK;
let _ = db::DatabaseEnvironment::delete(&db.env, &db.handle, &u_auth.aid.as_bytes())?; db::DatabaseEnvironment::delete(&db.env, &db.handle, u_auth.aid.as_bytes())?;
let v = bincode::serialize(&u_auth).unwrap_or_default(); let v = bincode::serialize(&u_auth).unwrap_or_default();
db::write_chunks(&db.env, &db.handle, u_auth.aid.as_bytes(), &v)?; db::write_chunks(&db.env, &db.handle, u_auth.aid.as_bytes(), &v)?;
monero::close_wallet(&wallet_name, &wallet_password).await; monero::close_wallet(&wallet_name, &wallet_password).await;

2
neveko-core/src/contact.rs
View file

@ -98,7 +98,7 @@ pub fn delete(cid: &String) -> Result<(), MdbError> {
error!("contact not found"); error!("contact not found");
return Err(MdbError::NotFound); return Err(MdbError::NotFound);
} }
let _ = db::DatabaseEnvironment::delete(&db.env, &db.handle, cid.as_bytes())?; db::DatabaseEnvironment::delete(&db.env, &db.handle, cid.as_bytes())?;
Ok(()) Ok(())
} }

6
neveko-core/src/dispute.rs
View file

@ -134,7 +134,7 @@ pub async fn settle_dispute() -> Result<(), NevekoError> {
if cleared { if cleared {
// index was created but cleared // index was created but cleared
info!("terminating dispute auto-settle thread"); info!("terminating dispute auto-settle thread");
let _ = db::DatabaseEnvironment::delete(&db.env, &db.handle, list_key.as_bytes()) db::DatabaseEnvironment::delete(&db.env, &db.handle, list_key.as_bytes())
.map_err(|_| NevekoError::Database(MdbError::Panic))?; .map_err(|_| NevekoError::Database(MdbError::Panic))?;
return Ok(()); return Ok(());
} }
@ -188,7 +188,7 @@ fn remove_from_auto_settle(did: String) -> Result<(), NevekoError> {
let pre_v_fts = str_r.split(","); let pre_v_fts = str_r.split(",");
let v: Vec<String> = pre_v_fts let v: Vec<String> = pre_v_fts
.map(|s| { .map(|s| {
if s != &did { if s != did {
String::from(s) String::from(s)
} else { } else {
String::new() String::new()
@ -263,5 +263,5 @@ pub async fn trigger_dispute_request(
error!("failed to create dispute"); error!("failed to create dispute");
return Err(NevekoError::Dispute); return Err(NevekoError::Dispute);
} }
Ok(dispute.map_err(|_| NevekoError::Dispute)?) dispute.map_err(|_| NevekoError::Dispute)
} }

2
neveko-core/src/i2p.rs
View file

@ -116,7 +116,7 @@ pub fn get_destination(st: ServerTunnelType) -> Result<String, NevekoError> {
) )
.map_err(|_| NevekoError::Database(MdbError::Panic))?; .map_err(|_| NevekoError::Database(MdbError::Panic))?;
let anon_b32_dest: String = bincode::deserialize(&r_anon_b32_dest[..]).unwrap_or_default(); let anon_b32_dest: String = bincode::deserialize(&r_anon_b32_dest[..]).unwrap_or_default();
let app_b32_dest: String = bincode::deserialize(&&r_app_b32_dest[..]).unwrap_or_default(); let app_b32_dest: String = bincode::deserialize(&r_app_b32_dest[..]).unwrap_or_default();
match st { match st {
ServerTunnelType::App => Ok(app_b32_dest), ServerTunnelType::App => Ok(app_b32_dest),
ServerTunnelType::AnonInbound => Ok(anon_b32_dest), ServerTunnelType::AnonInbound => Ok(anon_b32_dest),

11
neveko-core/src/message.rs
View file

@ -151,7 +151,7 @@ pub async fn rx(m: Json<Message>) -> Result<(), NevekoError> {
async fn parse_multisig_message(mid: String) -> Result<MultisigMessageData, NevekoError> { async fn parse_multisig_message(mid: String) -> Result<MultisigMessageData, NevekoError> {
let d: reqres::DecipheredMessageBody = decipher_body(mid).await?; let d: reqres::DecipheredMessageBody = decipher_body(mid).await?;
let mut bytes = hex::decode(d.body.into_bytes()).unwrap_or_default(); let mut bytes = hex::decode(d.body.into_bytes()).unwrap_or_default();
let decoded = String::from_utf8(bytes).unwrap_or(String::new()); let decoded = String::from_utf8(bytes).unwrap_or_default();
let values = decoded.split(":"); let values = decoded.split(":");
let mut v: Vec<String> = values.map(String::from).collect(); let mut v: Vec<String> = values.map(String::from).collect();
if v.len() != VALID_MSIG_MSG_LENGTH { if v.len() != VALID_MSIG_MSG_LENGTH {
@ -374,7 +374,7 @@ pub async fn decipher_body(mid: String) -> Result<reqres::DecipheredMessageBody,
/// Message deletion /// Message deletion
pub fn delete(mid: &String) -> Result<(), NevekoError> { pub fn delete(mid: &String) -> Result<(), NevekoError> {
let db = &DATABASE_LOCK; let db = &DATABASE_LOCK;
let _ = db::DatabaseEnvironment::delete(&db.env, &db.handle, mid.as_bytes()) db::DatabaseEnvironment::delete(&db.env, &db.handle, mid.as_bytes())
.map_err(|_| NevekoError::Database(MdbError::Panic))?; .map_err(|_| NevekoError::Database(MdbError::Panic))?;
Ok(()) Ok(())
} }
@ -465,7 +465,7 @@ fn remove_from_fts(mid: String) -> Result<(), NevekoError> {
let pre_v_fts = s_r.split(","); let pre_v_fts = s_r.split(",");
let v: Vec<String> = pre_v_fts let v: Vec<String> = pre_v_fts
.map(|s| { .map(|s| {
if s != &mid { if s != mid {
String::from(s) String::from(s)
} else { } else {
String::new() String::new()
@ -509,8 +509,7 @@ pub async fn retry_fts() -> Result<(), NevekoError> {
if cleared { if cleared {
// index was created but cleared // index was created but cleared
info!("terminating retry fts thread"); info!("terminating retry fts thread");
let _ = db::DatabaseEnvironment::delete(&db.env, &db.handle, list_key.as_bytes())
db::DatabaseEnvironment::delete(&db.env, &db.handle, &list_key.as_bytes().to_vec())
.map_err(|_| NevekoError::Database(MdbError::Panic))?; .map_err(|_| NevekoError::Database(MdbError::Panic))?;
break Err(NevekoError::Database(MdbError::NotFound)); break Err(NevekoError::Database(MdbError::NotFound));
} }
@ -689,7 +688,7 @@ pub async fn send_export_info(orid: &String, contact: &String) -> Result<(), Nev
/// multisig info after funding. Once the info is imported /// multisig info after funding. Once the info is imported
/// ///
/// successfully the order needs to be updated to `MultisigComplete`. /// successfully the order needs to be updated to `MultisigComplete`.
pub async fn send_import_info(orid: &String, info: &Vec<String>) -> Result<(), NevekoError> { pub async fn send_import_info(orid: &String, info: &[String]) -> Result<(), NevekoError> {
let wallet_name = String::from(orid); let wallet_name = String::from(orid);
let wallet_password = String::new(); let wallet_password = String::new();
monero::open_wallet(&wallet_name, &wallet_password).await; monero::open_wallet(&wallet_name, &wallet_password).await;

137
neveko-core/src/monero.rs
View file

@ -328,7 +328,7 @@ fn get_monero_location() -> String {
/// Get monero rpc host from the `--monero-rpc-host` cli arg /// Get monero rpc host from the `--monero-rpc-host` cli arg
fn get_rpc_host() -> String { fn get_rpc_host() -> String {
let args = args::Args::parse(); let args = args::Args::parse();
let gui_host = std::env::var(crate::MONERO_WALLET_RPC_HOST).unwrap_or(String::new()); let gui_host = std::env::var(crate::MONERO_WALLET_RPC_HOST).unwrap_or_default();
let rpc = if gui_host.is_empty() { let rpc = if gui_host.is_empty() {
args.monero_rpc_host args.monero_rpc_host
} else { } else {
@ -350,7 +350,7 @@ fn get_rpc_creds() -> RpcLogin {
fn get_rpc_daemon() -> String { fn get_rpc_daemon() -> String {
let args = args::Args::parse(); let args = args::Args::parse();
let gui_host = std::env::var(crate::MONERO_DAEMON_HOST).unwrap_or(String::new()); let gui_host = std::env::var(crate::MONERO_DAEMON_HOST).unwrap_or_default();
if gui_host.is_empty() { if gui_host.is_empty() {
args.monero_rpc_daemon args.monero_rpc_daemon
} else { } else {
@ -378,10 +378,7 @@ pub async fn get_version() -> reqres::XmrRpcVersionResponse {
Ok(response) => { Ok(response) => {
let res = response.json::<reqres::XmrRpcVersionResponse>().await; let res = response.json::<reqres::XmrRpcVersionResponse>().await;
debug!("{} response: {:?}", RpcFields::GetVersion.value(), res); debug!("{} response: {:?}", RpcFields::GetVersion.value(), res);
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_e) => Default::default(), Err(_e) => Default::default(),
} }
@ -417,10 +414,7 @@ pub async fn sign(data: String) -> reqres::XmrRpcSignResponse {
Ok(response) => { Ok(response) => {
let res = response.json::<reqres::XmrRpcSignResponse>().await; let res = response.json::<reqres::XmrRpcSignResponse>().await;
debug!("{} response: {:?}", RpcFields::Sign.value(), res); debug!("{} response: {:?}", RpcFields::Sign.value(), res);
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_e) => Default::default(), Err(_e) => Default::default(),
} }
@ -687,10 +681,7 @@ pub async fn get_balance() -> reqres::XmrRpcBalanceResponse {
Ok(response) => { Ok(response) => {
let res = response.json::<reqres::XmrRpcBalanceResponse>().await; let res = response.json::<reqres::XmrRpcBalanceResponse>().await;
debug!("{} response: {:?}", RpcFields::Balance.value(), res); debug!("{} response: {:?}", RpcFields::Balance.value(), res);
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -761,10 +752,7 @@ pub async fn validate_address(address: &String) -> reqres::XmrRpcValidateAddress
.json::<reqres::XmrRpcValidateAddressResponse>() .json::<reqres::XmrRpcValidateAddressResponse>()
.await; .await;
debug!("{} response: {:?}", RpcFields::ValidateAddress.value(), res); debug!("{} response: {:?}", RpcFields::ValidateAddress.value(), res);
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -795,10 +783,7 @@ pub async fn prepare_wallet() -> reqres::XmrRpcPrepareResponse {
Ok(response) => { Ok(response) => {
let res = response.json::<reqres::XmrRpcPrepareResponse>().await; let res = response.json::<reqres::XmrRpcPrepareResponse>().await;
debug!("{} response: {:?}", RpcFields::Prepare.value(), res); debug!("{} response: {:?}", RpcFields::Prepare.value(), res);
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -829,10 +814,7 @@ pub async fn make_wallet(info: Vec<String>) -> reqres::XmrRpcMakeResponse {
Ok(response) => { Ok(response) => {
let res = response.json::<reqres::XmrRpcMakeResponse>().await; let res = response.json::<reqres::XmrRpcMakeResponse>().await;
debug!("{} response: {:?}", RpcFields::Make.value(), res); debug!("{} response: {:?}", RpcFields::Make.value(), res);
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -857,10 +839,7 @@ pub async fn export_multisig_info() -> reqres::XmrRpcExportResponse {
{ {
Ok(response) => { Ok(response) => {
let res = response.json::<reqres::XmrRpcExportResponse>().await; let res = response.json::<reqres::XmrRpcExportResponse>().await;
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -888,10 +867,7 @@ pub async fn import_multisig_info(info: Vec<String>) -> reqres::XmrRpcImportResp
Ok(response) => { Ok(response) => {
let res = response.json::<reqres::XmrRpcImportResponse>().await; let res = response.json::<reqres::XmrRpcImportResponse>().await;
debug!("{} response: {:?}", RpcFields::Import.value(), res); debug!("{} response: {:?}", RpcFields::Import.value(), res);
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -919,10 +895,7 @@ pub async fn sign_multisig(tx_data_hex: String) -> reqres::XmrRpcSignMultisigRes
Ok(response) => { Ok(response) => {
let res = response.json::<reqres::XmrRpcSignMultisigResponse>().await; let res = response.json::<reqres::XmrRpcSignMultisigResponse>().await;
debug!("{} response: {:?}", RpcFields::SignMultisig.value(), res); debug!("{} response: {:?}", RpcFields::SignMultisig.value(), res);
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -952,10 +925,7 @@ pub async fn submit_multisig(tx_data_hex: String) -> reqres::XmrRpcSubmitMultisi
.json::<reqres::XmrRpcSubmitMultisigResponse>() .json::<reqres::XmrRpcSubmitMultisigResponse>()
.await; .await;
debug!("{} response: {:?}", RpcFields::SubmitMultisig.value(), res); debug!("{} response: {:?}", RpcFields::SubmitMultisig.value(), res);
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -997,10 +967,7 @@ pub async fn exchange_multisig_keys(
RpcFields::ExchangeMultisigKeys.value(), RpcFields::ExchangeMultisigKeys.value(),
res res
); );
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -1034,10 +1001,7 @@ pub async fn check_tx_proof(txp: &proof::TxProof) -> reqres::XmrRpcCheckTxProofR
Ok(response) => { Ok(response) => {
let res = response.json::<reqres::XmrRpcCheckTxProofResponse>().await; let res = response.json::<reqres::XmrRpcCheckTxProofResponse>().await;
debug!("{} response: {:?}", RpcFields::CheckTxProof.value(), res); debug!("{} response: {:?}", RpcFields::CheckTxProof.value(), res);
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -1069,10 +1033,7 @@ pub async fn get_tx_proof(ptxp: proof::TxProof) -> reqres::XmrRpcGetTxProofRespo
Ok(response) => { Ok(response) => {
let res = response.json::<reqres::XmrRpcGetTxProofResponse>().await; let res = response.json::<reqres::XmrRpcGetTxProofResponse>().await;
debug!("{} response: {:?}", RpcFields::GetTxProof.value(), res); debug!("{} response: {:?}", RpcFields::GetTxProof.value(), res);
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -1102,10 +1063,7 @@ pub async fn get_transfer_by_txid(txid: &str) -> reqres::XmrRpcGetTxByIdResponse
Ok(response) => { Ok(response) => {
let res = response.json::<reqres::XmrRpcGetTxByIdResponse>().await; let res = response.json::<reqres::XmrRpcGetTxByIdResponse>().await;
debug!("{} response: {:?}", RpcFields::GetTxById.value(), res); debug!("{} response: {:?}", RpcFields::GetTxById.value(), res);
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -1116,8 +1074,7 @@ pub async fn transfer(d: reqres::Destination) -> reqres::XmrRpcTransferResponse
info!("executing {}", RpcFields::Transfer.value()); info!("executing {}", RpcFields::Transfer.value());
let client = reqwest::Client::new(); let client = reqwest::Client::new();
let host = get_rpc_host(); let host = get_rpc_host();
let mut destinations: Vec<reqres::Destination> = Vec::new(); let destinations = vec![d];
destinations.push(d);
let params: reqres::XmrRpcTransferParams = reqres::XmrRpcTransferParams { let params: reqres::XmrRpcTransferParams = reqres::XmrRpcTransferParams {
account_index: 0, account_index: 0,
destinations, destinations,
@ -1142,10 +1099,7 @@ pub async fn transfer(d: reqres::Destination) -> reqres::XmrRpcTransferResponse
Ok(response) => { Ok(response) => {
let res = response.json::<reqres::XmrRpcTransferResponse>().await; let res = response.json::<reqres::XmrRpcTransferResponse>().await;
debug!("{} response: {:?}", RpcFields::Transfer.value(), res); debug!("{} response: {:?}", RpcFields::Transfer.value(), res);
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -1181,10 +1135,7 @@ pub async fn describe_transfer(multisig_txset: &String) -> reqres::XmrRpcDescrib
RpcFields::DescribeTransfer.value(), RpcFields::DescribeTransfer.value(),
res res
); );
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -1212,10 +1163,7 @@ pub async fn sweep_all(address: String) -> reqres::XmrRpcSweepAllResponse {
Ok(response) => { Ok(response) => {
let res = response.json::<reqres::XmrRpcSweepAllResponse>().await; let res = response.json::<reqres::XmrRpcSweepAllResponse>().await;
debug!("{} response: {:?}", RpcFields::SweepAll.value(), res); debug!("{} response: {:?}", RpcFields::SweepAll.value(), res);
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -1244,10 +1192,7 @@ pub async fn create_address() -> reqres::XmrRpcCreateAddressResponse {
Ok(response) => { Ok(response) => {
let res = response.json::<reqres::XmrRpcCreateAddressResponse>().await; let res = response.json::<reqres::XmrRpcCreateAddressResponse>().await;
debug!("{} response: {:?}", RpcFields::CreateAddress.value(), res); debug!("{} response: {:?}", RpcFields::CreateAddress.value(), res);
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -1273,10 +1218,7 @@ pub async fn refresh() -> reqres::XmrRpcRefreshResponse {
Ok(response) => { Ok(response) => {
let res = response.json::<reqres::XmrRpcRefreshResponse>().await; let res = response.json::<reqres::XmrRpcRefreshResponse>().await;
debug!("{} response: {:?}", RpcFields::Refresh.value(), res); debug!("{} response: {:?}", RpcFields::Refresh.value(), res);
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -1302,10 +1244,7 @@ pub async fn is_multisig() -> reqres::XmrRpcIsMultisigResponse {
Ok(response) => { Ok(response) => {
let res = response.json::<reqres::XmrRpcIsMultisigResponse>().await; let res = response.json::<reqres::XmrRpcIsMultisigResponse>().await;
debug!("{} response: {:?}", RpcFields::IsMultisig.value(), res); debug!("{} response: {:?}", RpcFields::IsMultisig.value(), res);
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -1331,10 +1270,7 @@ pub async fn get_wallet_height() -> reqres::XmrRpcGetHeightResponse {
Ok(response) => { Ok(response) => {
let res = response.json::<reqres::XmrRpcGetHeightResponse>().await; let res = response.json::<reqres::XmrRpcGetHeightResponse>().await;
debug!("{} response: {:?}", RpcFields::GetHeight.value(), res); debug!("{} response: {:?}", RpcFields::GetHeight.value(), res);
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -1363,10 +1299,7 @@ pub async fn query_view_key() -> reqres::XmrRpcQueryKeyResponse {
{ {
Ok(response) => { Ok(response) => {
let res = response.json::<reqres::XmrRpcQueryKeyResponse>().await; let res = response.json::<reqres::XmrRpcQueryKeyResponse>().await;
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -1389,10 +1322,7 @@ pub async fn get_info() -> reqres::XmrDaemonGetInfoResponse {
Ok(response) => { Ok(response) => {
let res = response.json::<reqres::XmrDaemonGetInfoResponse>().await; let res = response.json::<reqres::XmrDaemonGetInfoResponse>().await;
// add debug log here if needed for adding more info to home screen in gui // add debug log here if needed for adding more info to home screen in gui
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -1433,10 +1363,7 @@ pub async fn get_height() -> reqres::XmrDaemonGetHeightResponse {
Ok(response) => { Ok(response) => {
let res = response.json::<reqres::XmrDaemonGetHeightResponse>().await; let res = response.json::<reqres::XmrDaemonGetHeightResponse>().await;
// don't log this one. The fee estimator blows up logs (T_T) // don't log this one. The fee estimator blows up logs (T_T)
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -1479,10 +1406,7 @@ pub async fn get_block(height: u64) -> reqres::XmrDaemonGetBlockResponse {
Ok(response) => { Ok(response) => {
let res = response.json::<reqres::XmrDaemonGetBlockResponse>().await; let res = response.json::<reqres::XmrDaemonGetBlockResponse>().await;
// don't log this one. The fee estimator blows up logs (T_T) // don't log this one. The fee estimator blows up logs (T_T)
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }
@ -1531,10 +1455,7 @@ pub async fn get_transactions(txs_hashes: Vec<String>) -> reqres::XmrDaemonGetTr
.json::<reqres::XmrDaemonGetTransactionsResponse>() .json::<reqres::XmrDaemonGetTransactionsResponse>()
.await; .await;
// don't log this one. The fee estimator blows up logs (T_T) // don't log this one. The fee estimator blows up logs (T_T)
match res { res.unwrap_or_default()
Ok(res) => res,
_ => Default::default(),
}
} }
Err(_) => Default::default(), Err(_) => Default::default(),
} }

19
neveko-core/src/neveko25519.rs
View file

@ -19,6 +19,7 @@ use sha2::{
#[derive(Debug)] #[derive(Debug)]
/// Container for the Neveko Message Keys /// Container for the Neveko Message Keys
#[derive(Default)]
pub struct NevekoMessageKeys { pub struct NevekoMessageKeys {
/// Neveko Message Secret Key /// Neveko Message Secret Key
pub nmsk: [u8; 32], pub nmsk: [u8; 32],
@ -30,16 +31,6 @@ pub struct NevekoMessageKeys {
pub hex_nmpk: String, pub hex_nmpk: String,
} }
impl Default for NevekoMessageKeys {
fn default() -> Self {
NevekoMessageKeys {
nmpk: [0u8; 32],
nmsk: [0u8; 32],
hex_nmpk: String::new(),
hex_nmsk: String::new(),
}
}
}
/// L value as defined at https://eprint.iacr.org/2008/013.pdf /// L value as defined at https://eprint.iacr.org/2008/013.pdf
const CURVE_L: &str = "edd3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010"; const CURVE_L: &str = "edd3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010";
@ -67,13 +58,11 @@ fn hash_to_scalar(s: Vec<&str>) -> Scalar {
hasher.update(&result); hasher.update(&result);
let hash = hasher.finalize().to_owned(); let hash = hasher.finalize().to_owned();
let mut hash_container: [u8; 32] = [0u8; 32]; let mut hash_container: [u8; 32] = [0u8; 32];
let mut index = 0; for (index, byte) in result.as_bytes().iter().enumerate() {
for byte in result.as_bytes() {
if index == hash_container.len() - 1 { if index == hash_container.len() - 1 {
break; break;
} }
hash_container[index] = *byte; hash_container[index] = *byte;
index += 1;
} }
let hash_value = BigInt::from_bytes_le(Sign::Plus, &hash_container); let hash_value = BigInt::from_bytes_le(Sign::Plus, &hash_container);
if hash_value < curve_l_as_big_int() { if hash_value < curve_l_as_big_int() {
@ -92,7 +81,7 @@ fn hash_to_scalar(s: Vec<&str>) -> Scalar {
/// Neveko Message Public Key (NMPK). /// Neveko Message Public Key (NMPK).
pub async fn generate_neveko_message_keys() -> NevekoMessageKeys { pub async fn generate_neveko_message_keys() -> NevekoMessageKeys {
log::info!("generating neveko message keys"); log::info!("generating neveko message keys");
let password = std::env::var(crate::MONERO_WALLET_PASSWORD).unwrap_or(String::new()); let password = std::env::var(crate::MONERO_WALLET_PASSWORD).unwrap_or_default();
let filename = String::from(crate::APP_NAME); let filename = String::from(crate::APP_NAME);
let m_wallet = monero::open_wallet(&filename, &password).await; let m_wallet = monero::open_wallet(&filename, &password).await;
if !m_wallet { if !m_wallet {
@ -126,7 +115,7 @@ pub async fn generate_neveko_message_keys() -> NevekoMessageKeys {
/// ///
/// Pass `None` to encipher parameter to perform deciphering. /// Pass `None` to encipher parameter to perform deciphering.
pub async fn cipher(hex_nmpk: &String, message: String, encipher: Option<String>) -> String { pub async fn cipher(hex_nmpk: &String, message: String, encipher: Option<String>) -> String {
let unwrap_encipher: String = encipher.unwrap_or(String::new()); let unwrap_encipher: String = encipher.unwrap_or_default();
let keys: NevekoMessageKeys = generate_neveko_message_keys().await; let keys: NevekoMessageKeys = generate_neveko_message_keys().await;
// shared secret = nmpk * nmsk // shared secret = nmpk * nmsk
let scalar_nmsk = Scalar::from_bytes_mod_order(keys.nmsk); let scalar_nmsk = Scalar::from_bytes_mod_order(keys.nmsk);

6
neveko-core/src/order.rs
View file

@ -267,10 +267,10 @@ pub fn modify(o: Json<Order>) -> Result<Order, NevekoError> {
} }
let db = &DATABASE_LOCK; let db = &DATABASE_LOCK;
let u_order = Order::update(String::from(&f_order.orid), &o); let u_order = Order::update(String::from(&f_order.orid), &o);
let _ = db::DatabaseEnvironment::delete(&db.env, &db.handle, &u_order.orid.as_bytes()) db::DatabaseEnvironment::delete(&db.env, &db.handle, u_order.orid.as_bytes())
.map_err(|_| NevekoError::Database(MdbError::Panic))?; .map_err(|_| NevekoError::Database(MdbError::Panic))?;
let v = bincode::serialize(&u_order).unwrap_or_default(); let v = bincode::serialize(&u_order).unwrap_or_default();
let _ = db::write_chunks(&db.env, &db.handle, &u_order.orid.as_bytes(), &v) db::write_chunks(&db.env, &db.handle, u_order.orid.as_bytes(), &v)
.map_err(|_| NevekoError::Database(MdbError::Panic))?; .map_err(|_| NevekoError::Database(MdbError::Panic))?;
Ok(u_order) Ok(u_order)
} }
@ -379,7 +379,7 @@ pub async fn validate_order_for_ship(
let mut j_order: Order = find(orid).map_err(|_| NevekoError::Order)?; let mut j_order: Order = find(orid).map_err(|_| NevekoError::Order)?;
let m_product: Product = product::find(&m_order.pid).map_err(|_| NevekoError::Product)?; let m_product: Product = product::find(&m_order.pid).map_err(|_| NevekoError::Product)?;
let price = m_product.price; let price = m_product.price;
let total = price * &m_order.quantity; let total = price * m_order.quantity;
let wallet_password = String::new(); let wallet_password = String::new();
monero::open_wallet(orid, &wallet_password).await; monero::open_wallet(orid, &wallet_password).await;
// check balance and unlock_time // check balance and unlock_time

2
neveko-core/src/product.rs
View file

@ -107,7 +107,7 @@ pub fn modify(p: Json<Product>) -> Result<Product, NevekoError> {
} }
let u_prod = Product::update(f_prod, &p); let u_prod = Product::update(f_prod, &p);
let db = &DATABASE_LOCK; let db = &DATABASE_LOCK;
let _ = db::DatabaseEnvironment::delete(&db.env, &db.handle, u_prod.pid.as_bytes()) db::DatabaseEnvironment::delete(&db.env, &db.handle, u_prod.pid.as_bytes())
.map_err(|_| NevekoError::Database(MdbError::Panic))?; .map_err(|_| NevekoError::Database(MdbError::Panic))?;
let product = bincode::serialize(&u_prod).unwrap_or_default(); let product = bincode::serialize(&u_prod).unwrap_or_default();
let db = &DATABASE_LOCK; let db = &DATABASE_LOCK;

6
neveko-core/src/proof.rs
View file

@ -129,12 +129,12 @@ pub async fn prove_payment(contact: String, txp: &TxProof) -> Result<reqres::Jwp
// cache the jwp for for fts // cache the jwp for for fts
let db = &DATABASE_LOCK; let db = &DATABASE_LOCK;
let k = format!("{}-{}", crate::FTS_JWP_DB_KEY, &contact); let k = format!("{}-{}", crate::FTS_JWP_DB_KEY, &contact);
let _ = db::DatabaseEnvironment::delete(&db.env, &db.handle, k.as_bytes())?; db::DatabaseEnvironment::delete(&db.env, &db.handle, k.as_bytes())?;
db::write_chunks( db::write_chunks(
&db.env, &db.env,
&db.handle, &db.handle,
&k.as_bytes(), k.as_bytes(),
&r.jwp.as_bytes().to_vec(), r.jwp.as_bytes(),
) )
.map_err(|_| NevekoError::Database(MdbError::Panic))?; .map_err(|_| NevekoError::Database(MdbError::Panic))?;
Ok(r) Ok(r)

2
neveko-core/src/user.rs
View file

@ -27,7 +27,7 @@ pub fn create(address: &String) -> Result<User, MdbError> {
let db = &DATABASE_LOCK; let db = &DATABASE_LOCK;
let k = &new_user.uid; let k = &new_user.uid;
let v = bincode::serialize(&new_user).unwrap_or_default(); let v = bincode::serialize(&new_user).unwrap_or_default();
let _ = db::write_chunks(&db.env, &db.handle, k.as_bytes(), &v)?; db::write_chunks(&db.env, &db.handle, k.as_bytes(), &v)?;
Ok(new_user) Ok(new_user)
} }

13
neveko-core/src/utils.rs
View file

@ -219,7 +219,7 @@ pub fn get_app_port() -> u16 {
/// i2p http proxy /// i2p http proxy
pub fn get_i2p_http_proxy() -> String { pub fn get_i2p_http_proxy() -> String {
let args = args::Args::parse(); let args = args::Args::parse();
let advanced_proxy = std::env::var(crate::NEVEKO_I2P_PROXY_HOST).unwrap_or(String::new()); let advanced_proxy = std::env::var(crate::NEVEKO_I2P_PROXY_HOST).unwrap_or_default();
if advanced_proxy.is_empty() { if advanced_proxy.is_empty() {
args.i2p_proxy_host args.i2p_proxy_host
} else { } else {
@ -514,7 +514,7 @@ pub async fn start_up() -> Result<(), NevekoError> {
.map_err(|_| NevekoError::Database(MdbError::Panic))?; .map_err(|_| NevekoError::Database(MdbError::Panic))?;
info!("neveko is starting up"); info!("neveko is starting up");
let _ = reset_i2p_status()?; reset_i2p_status()?;
warn!("monero multisig is experimental and usage of neveko may lead to loss of funds"); warn!("monero multisig is experimental and usage of neveko may lead to loss of funds");
let args = args::Args::parse(); let args = args::Args::parse();
if args.clear_fts { if args.clear_fts {
@ -665,7 +665,7 @@ pub async fn estimate_fee() -> u128 {
let mut count: u64 = 1; let mut count: u64 = 1;
let mut v_fee: Vec<u128> = Vec::new(); let mut v_fee: Vec<u128> = Vec::new();
let mut r_height: reqres::XmrDaemonGetHeightResponse = Default::default(); let mut r_height: reqres::XmrDaemonGetHeightResponse = Default::default();
let remote_var = std::env::var(crate::GUI_REMOTE_NODE).unwrap_or(String::new()); let remote_var = std::env::var(crate::GUI_REMOTE_NODE).unwrap_or_default();
let remote_set = remote_var == *crate::GUI_SET_REMOTE_NODE; let remote_set = remote_var == *crate::GUI_SET_REMOTE_NODE;
if remote_set { if remote_set {
let p_height = monero::p_get_height().await; let p_height = monero::p_get_height().await;
@ -710,16 +710,13 @@ pub async fn estimate_fee() -> u128 {
let fee_split = v1.remove(1); let fee_split = v1.remove(1);
let post_fee_split = fee_split.split(","); let post_fee_split = fee_split.split(",");
let mut v2: Vec<String> = post_fee_split.map(String::from).collect(); let mut v2: Vec<String> = post_fee_split.map(String::from).collect();
let fee: u128 = match v2.remove(0).trim().parse::<u128>() { let fee: u128 = v2.remove(0).trim().parse::<u128>().unwrap_or_default();
Ok(n) => n,
Err(_e) => 0,
};
v_fee.push(fee); v_fee.push(fee);
} }
} }
count += 1; count += 1;
} }
&v_fee.iter().sum::<u128>() / v_fee.len() as u128 v_fee.iter().sum::<u128>() / v_fee.len() as u128
} }
/// Combine the results `estimate_fee()` and `get_balance()` to /// Combine the results `estimate_fee()` and `get_balance()` to