github/darkfi
1
1
Fork 0
mirror of https://github.com/darkrenaissance/darkfi.git synced 2026-01-10 23:27:56 -05:00
Code Issues Packages Projects Releases Wiki Activity

drk: use (de)serialize_async everywhere

Browse Source
This commit is contained in:
skoupidi
2024-04-12 15:48:20 +03:00
parent d1c11b7cf6
commit fa08a4aeae
5 changed files with 158 additions and 122 deletions
Download Patch File Download Diff File Expand all files Collapse all files

129
bin/drk/src/dao.rs
View File

@@ -51,7 +51,8 @@ use darkfi_sdk::{
ContractCall,
};
use darkfi_serial::{
async_trait, deserialize, serialize, Encodable, SerialDecodable, SerialEncodable,
async_trait, deserialize_async, serialize_async, AsyncEncodable, SerialDecodable,
SerialEncodable,
};
use crate::{
@@ -402,7 +403,13 @@ impl Drk {
*DAO_TREES_TABLE, DAO_TREES_COL_DAOS_TREE, DAO_TREES_COL_PROPOSALS_TREE,
);
self.wallet
.exec_sql(&query, rusqlite::params![serialize(daos_tree), serialize(proposals_tree)])
.exec_sql(
&query,
rusqlite::params![
serialize_async(daos_tree).await,
serialize_async(proposals_tree).await
],
)
.await
}
@@ -420,12 +427,12 @@ impl Drk {
let Value::Blob(ref daos_tree_bytes) = row[0] else {
return Err(Error::ParseFailed("[get_dao_trees] DAO tree bytes parsing failed"))
};
let daos_tree = deserialize(daos_tree_bytes)?;
let daos_tree = deserialize_async(daos_tree_bytes).await?;
let Value::Blob(ref proposals_tree_bytes) = row[1] else {
return Err(Error::ParseFailed("[get_dao_trees] Proposals tree bytes parsing failed"))
};
let proposals_tree = deserialize(proposals_tree_bytes)?;
let proposals_tree = deserialize_async(proposals_tree_bytes).await?;
Ok((daos_tree, proposals_tree))
}
@@ -467,12 +474,12 @@ impl Drk {
let Value::Blob(ref proposer_limit_bytes) = row[2] else {
return Err(Error::ParseFailed("[get_daos] Proposer limit bytes parsing failed"))
};
let proposer_limit = deserialize(proposer_limit_bytes)?;
let proposer_limit = deserialize_async(proposer_limit_bytes).await?;
let Value::Blob(ref quorum_bytes) = row[3] else {
return Err(Error::ParseFailed("[get_daos] Quorum bytes parsing failed"))
};
let quorum = deserialize(quorum_bytes)?;
let quorum = deserialize_async(quorum_bytes).await?;
let Value::Integer(approval_ratio_base) = row[4] else {
return Err(Error::ParseFailed("[get_daos] Approval ratio base parsing failed"))
@@ -491,17 +498,17 @@ impl Drk {
let Value::Blob(ref gov_token_bytes) = row[6] else {
return Err(Error::ParseFailed("[get_daos] Gov token bytes parsing failed"))
};
let gov_token_id = deserialize(gov_token_bytes)?;
let gov_token_id = deserialize_async(gov_token_bytes).await?;
let Value::Blob(ref secret_bytes) = row[7] else {
return Err(Error::ParseFailed("[get_daos] Secret key bytes parsing failed"))
};
let secret_key = deserialize(secret_bytes)?;
let secret_key = deserialize_async(secret_bytes).await?;
let Value::Blob(ref bulla_blind_bytes) = row[8] else {
return Err(Error::ParseFailed("[get_daos] Bulla blind bytes parsing failed"))
};
let bulla_blind = deserialize(bulla_blind_bytes)?;
let bulla_blind = deserialize_async(bulla_blind_bytes).await?;
let Value::Blob(ref leaf_position_bytes) = row[9] else {
return Err(Error::ParseFailed("[get_daos] Leaf position bytes parsing failed"))
@@ -509,14 +516,17 @@ impl Drk {
let leaf_position = if leaf_position_bytes.is_empty() {
None
} else {
Some(deserialize(leaf_position_bytes)?)
Some(deserialize_async(leaf_position_bytes).await?)
};
let Value::Blob(ref tx_hash_bytes) = row[10] else {
return Err(Error::ParseFailed("[get_daos] Transaction hash bytes parsing failed"))
};
let tx_hash =
if tx_hash_bytes.is_empty() { None } else { Some(deserialize(tx_hash_bytes)?) };
let tx_hash = if tx_hash_bytes.is_empty() {
None
} else {
Some(deserialize_async(tx_hash_bytes).await?)
};
let Value::Integer(call_index) = row[11] else {
return Err(Error::ParseFailed("[get_daos] Call index parsing failed"))
@@ -551,7 +561,7 @@ impl Drk {
}
/// Auxiliary function to parse a proposal record row.
fn parse_dao_proposal(&self, dao: &Dao, row: &[Value]) -> Result<DaoProposal> {
async fn parse_dao_proposal(&self, dao: &Dao, row: &[Value]) -> Result<DaoProposal> {
let Value::Integer(id) = row[0] else {
return Err(Error::ParseFailed("[get_dao_proposals] ID parsing failed"))
};
@@ -573,22 +583,22 @@ impl Drk {
"[get_dao_proposals] Recipient bytes bytes parsing failed",
))
};
let recipient = deserialize(recipient_bytes)?;
let recipient = deserialize_async(recipient_bytes).await?;
let Value::Blob(ref amount_bytes) = row[3] else {
return Err(Error::ParseFailed("[get_dao_proposals] Amount bytes parsing failed"))
};
let amount = deserialize(amount_bytes)?;
let amount = deserialize_async(amount_bytes).await?;
let Value::Blob(ref token_id_bytes) = row[4] else {
return Err(Error::ParseFailed("[get_dao_proposals] Token ID bytes parsing failed"))
};
let token_id = deserialize(token_id_bytes)?;
let token_id = deserialize_async(token_id_bytes).await?;
let Value::Blob(ref bulla_blind_bytes) = row[5] else {
return Err(Error::ParseFailed("[get_dao_proposals] Bulla blind bytes parsing failed"))
};
let bulla_blind = deserialize(bulla_blind_bytes)?;
let bulla_blind = deserialize_async(bulla_blind_bytes).await?;
let Value::Blob(ref leaf_position_bytes) = row[6] else {
return Err(Error::ParseFailed("[get_dao_proposals] Leaf position bytes parsing failed"))
@@ -596,7 +606,7 @@ impl Drk {
let leaf_position = if leaf_position_bytes.is_empty() {
None
} else {
Some(deserialize(leaf_position_bytes)?)
Some(deserialize_async(leaf_position_bytes).await?)
};
let Value::Blob(ref money_snapshot_tree_bytes) = row[7] else {
@@ -607,7 +617,7 @@ impl Drk {
let money_snapshot_tree = if money_snapshot_tree_bytes.is_empty() {
None
} else {
Some(deserialize(money_snapshot_tree_bytes)?)
Some(deserialize_async(money_snapshot_tree_bytes).await?)
};
let Value::Blob(ref tx_hash_bytes) = row[8] else {
@@ -615,8 +625,11 @@ impl Drk {
"[get_dao_proposals] Transaction hash bytes parsing failed",
))
};
let tx_hash =
if tx_hash_bytes.is_empty() { None } else { Some(deserialize(tx_hash_bytes)?) };
let tx_hash = if tx_hash_bytes.is_empty() {
None
} else {
Some(deserialize_async(tx_hash_bytes).await?)
};
let Value::Integer(call_index) = row[9] else {
return Err(Error::ParseFailed("[get_dao_proposals] Call index parsing failed"))
@@ -629,8 +642,11 @@ impl Drk {
let Value::Blob(ref vote_id_bytes) = row[10] else {
return Err(Error::ParseFailed("[get_dao_proposals] Vote ID bytes parsing failed"))
};
let vote_id =
if vote_id_bytes.is_empty() { None } else { Some(deserialize(vote_id_bytes)?) };
let vote_id = if vote_id_bytes.is_empty() {
None
} else {
Some(deserialize_async(vote_id_bytes).await?)
};
Ok(DaoProposal {
id,
@@ -675,7 +691,7 @@ impl Drk {
let mut proposals = Vec::with_capacity(rows.len());
for row in rows {
let proposal = self.parse_dao_proposal(dao, &row)?;
let proposal = self.parse_dao_proposal(dao, &row).await?;
proposals.push(proposal);
}
@@ -716,13 +732,13 @@ impl Drk {
match DaoFunction::try_from(data[0])? {
DaoFunction::Mint => {
println!("[apply_tx_dao_data] Found Dao::Mint call");
let params: DaoMintParams = deserialize(&data[1..])?;
let params: DaoMintParams = deserialize_async(&data[1..]).await?;
let tx_hash = if confirm { Some(tx_hash) } else { None };
new_dao_bullas.push((params.dao_bulla, tx_hash, call_idx));
}
DaoFunction::Propose => {
println!("[apply_tx_dao_data] Found Dao::Propose call");
let params: DaoProposeParams = deserialize(&data[1..])?;
let params: DaoProposeParams = deserialize_async(&data[1..]).await?;
let tx_hash = if confirm { Some(tx_hash) } else { None };
// We need to clone the tree here for reproducing the snapshot Merkle root
let money_tree = if confirm { Some(self.get_money_tree().await?) } else { None };
@@ -730,7 +746,7 @@ impl Drk {
}
DaoFunction::Vote => {
println!("[apply_tx_dao_data] Found Dao::Vote call");
let params: DaoVoteParams = deserialize(&data[1..])?;
let params: DaoVoteParams = deserialize_async(&data[1..]).await?;
let tx_hash = if confirm { Some(tx_hash) } else { None };
new_dao_votes.push((params, tx_hash, call_idx));
}
@@ -878,8 +894,8 @@ impl Drk {
.exec_sql(
&query,
rusqlite::params![
serialize(&dao.leaf_position.unwrap()),
serialize(&dao.tx_hash.unwrap()),
serialize_async(&dao.leaf_position.unwrap()).await,
serialize_async(&dao.tx_hash.unwrap()).await,
dao.call_index.unwrap()
],
)
@@ -940,13 +956,13 @@ impl Drk {
&query,
rusqlite::params![
dao.id,
serialize(&proposal.recipient),
serialize(&proposal.amount),
serialize(&proposal.token_id),
serialize(&proposal.bulla_blind),
serialize(&proposal.leaf_position.unwrap()),
serialize(&proposal.money_snapshot_tree.clone().unwrap()),
serialize(&proposal.tx_hash.unwrap()),
serialize_async(&proposal.recipient).await,
serialize_async(&proposal.amount).await,
serialize_async(&proposal.token_id).await,
serialize_async(&proposal.bulla_blind).await,
serialize_async(&proposal.leaf_position.unwrap()).await,
serialize_async(&proposal.money_snapshot_tree.clone().unwrap()).await,
serialize_async(&proposal.tx_hash.unwrap()).await,
proposal.call_index,
],
)
@@ -984,10 +1000,10 @@ impl Drk {
rusqlite::params![
vote.proposal_id,
vote.vote_option as u64,
serialize(&vote.yes_vote_blind),
serialize(&vote.all_vote_value),
serialize(&vote.all_vote_blind),
serialize(&vote.tx_hash.unwrap()),
serialize_async(&vote.yes_vote_blind).await,
serialize_async(&vote.all_vote_value).await,
serialize_async(&vote.all_vote_blind).await,
serialize_async(&vote.tx_hash.unwrap()).await,
vote.call_index.unwrap(),
],
)
@@ -1072,13 +1088,13 @@ impl Drk {
&query,
rusqlite::params![
dao_name,
serialize(&dao_params.proposer_limit),
serialize(&dao_params.quorum),
serialize_async(&dao_params.proposer_limit).await,
serialize_async(&dao_params.quorum).await,
dao_params.approval_ratio_base,
dao_params.approval_ratio_quot,
serialize(&dao_params.gov_token_id),
serialize(&dao_params.secret_key),
serialize(&dao_params.bulla_blind),
serialize_async(&dao_params.gov_token_id).await,
serialize_async(&dao_params.secret_key).await,
serialize_async(&dao_params.bulla_blind).await,
],
)
.await
@@ -1228,7 +1244,7 @@ impl Drk {
let dao = self.get_dao_by_id(dao_id).await?;
// Parse rest of the record
self.parse_dao_proposal(&dao, &row)
self.parse_dao_proposal(&dao, &row).await
}
// Fetch all known DAO proposal votes from the wallet given a proposal ID
@@ -1287,29 +1303,32 @@ impl Drk {
"[get_dao_proposal_votes] Yes vote blind bytes parsing failed",
))
};
let yes_vote_blind = deserialize(yes_vote_blind_bytes)?;
let yes_vote_blind = deserialize_async(yes_vote_blind_bytes).await?;
let Value::Blob(ref all_vote_value_bytes) = row[4] else {
return Err(Error::ParseFailed(
"[get_dao_proposal_votes] All vote value bytes parsing failed",
))
};
let all_vote_value = deserialize(all_vote_value_bytes)?;
let all_vote_value = deserialize_async(all_vote_value_bytes).await?;
let Value::Blob(ref all_vote_blind_bytes) = row[5] else {
return Err(Error::ParseFailed(
"[get_dao_proposal_votes] All vote blind bytes parsing failed",
))
};
let all_vote_blind = deserialize(all_vote_blind_bytes)?;
let all_vote_blind = deserialize_async(all_vote_blind_bytes).await?;
let Value::Blob(ref tx_hash_bytes) = row[6] else {
return Err(Error::ParseFailed(
"[get_dao_proposal_votes] Transaction hash bytes parsing failed",
))
};
let tx_hash =
if tx_hash_bytes.is_empty() { None } else { Some(deserialize(tx_hash_bytes)?) };
let tx_hash = if tx_hash_bytes.is_empty() {
None
} else {
Some(deserialize_async(tx_hash_bytes).await?)
};
let Value::Integer(call_index) = row[7] else {
return Err(Error::ParseFailed("[get_dao_proposal_votes] Call index parsing failed"))
@@ -1373,7 +1392,7 @@ impl Drk {
make_mint_call(&dao_info, &dao.secret_key, &dao_mint_zkbin, &dao_mint_pk)?;
let mut data = vec![DaoFunction::Mint as u8];
params.encode(&mut data)?;
params.encode_async(&mut data).await?;
let call = ContractCall { contract_id: *DAO_CONTRACT_ID, data };
let mut tx_builder = TransactionBuilder::new(ContractCallLeaf { call, proofs }, vec![])?;
let mut tx = tx_builder.build()?;
@@ -1525,7 +1544,7 @@ impl Drk {
}
*/
let proposal_data = vec![];
//proposal_coins.encode(&mut proposal_data).unwrap();
//proposal_coins.encode_async(&mut proposal_data).await.unwrap();
let auth_calls = vec![
DaoAuthCall {
@@ -1585,7 +1604,7 @@ impl Drk {
)?;
let mut data = vec![DaoFunction::Propose as u8];
params.encode(&mut data)?;
params.encode_async(&mut data).await?;
let call = ContractCall { contract_id: *DAO_CONTRACT_ID, data };
let mut tx_builder = TransactionBuilder::new(ContractCallLeaf { call, proofs }, vec![])?;
let mut tx = tx_builder.build()?;
@@ -1729,7 +1748,7 @@ impl Drk {
)?;
let mut data = vec![DaoFunction::Vote as u8];
params.encode(&mut data)?;
params.encode_async(&mut data).await?;
let call = ContractCall { contract_id: *DAO_CONTRACT_ID, data };
let mut tx_builder = TransactionBuilder::new(ContractCallLeaf { call, proofs }, vec![])?;
let mut tx = tx_builder.build()?;

108
bin/drk/src/money.rs
View File

@@ -39,7 +39,7 @@ use darkfi_sdk::{
},
pasta::pallas,
};
use darkfi_serial::{deserialize, serialize};
use darkfi_serial::{deserialize_async, serialize_async};
use crate::{
convert_named_params,
@@ -159,8 +159,8 @@ impl Drk {
&query,
rusqlite::params![
is_default,
serialize(&keypair.public),
serialize(&keypair.secret)
serialize_async(&keypair.public).await,
serialize_async(&keypair.secret).await
],
)
.await?;
@@ -193,7 +193,7 @@ impl Drk {
let Value::Blob(ref key_bytes) = row[0] else {
return Err(Error::ParseFailed("[default_secret] Key bytes parsing failed"))
};
let secret_key: SecretKey = deserialize(key_bytes)?;
let secret_key: SecretKey = deserialize_async(key_bytes).await?;
Ok(secret_key)
}
@@ -220,7 +220,7 @@ impl Drk {
let Value::Blob(ref key_bytes) = row[0] else {
return Err(Error::ParseFailed("[default_address] Key bytes parsing failed"))
};
let public_key: PublicKey = deserialize(key_bytes)?;
let public_key: PublicKey = deserialize_async(key_bytes).await?;
Ok(public_key)
}
@@ -271,12 +271,12 @@ impl Drk {
let Value::Blob(ref key_bytes) = row[2] else {
return Err(Error::ParseFailed("[addresses] Public key bytes parsing failed"))
};
let public_key: PublicKey = deserialize(key_bytes)?;
let public_key: PublicKey = deserialize_async(key_bytes).await?;
let Value::Blob(ref key_bytes) = row[3] else {
return Err(Error::ParseFailed("[addresses] Secret key bytes parsing failed"))
};
let secret_key: SecretKey = deserialize(key_bytes)?;
let secret_key: SecretKey = deserialize_async(key_bytes).await?;
vec.push((key_id, public_key, secret_key, is_default));
}
@@ -308,7 +308,7 @@ impl Drk {
"[get_money_secrets] Secret key bytes parsing failed",
))
};
let secret_key: SecretKey = deserialize(key_bytes)?;
let secret_key: SecretKey = deserialize_async(key_bytes).await?;
secrets.push(secret_key);
}
@@ -332,8 +332,8 @@ impl Drk {
ret.push(PublicKey::from_secret(secret));
let is_default = 0;
let public = serialize(&PublicKey::from_secret(secret));
let secret = serialize(&secret);
let public = serialize_async(&PublicKey::from_secret(secret)).await;
let secret = serialize_async(&secret).await;
let query = format!(
"INSERT INTO {} ({}, {}, {}) VALUES (?1, ?2, ?3);",
@@ -406,7 +406,7 @@ impl Drk {
let Value::Blob(ref coin_bytes) = row[0] else {
return Err(Error::ParseFailed("[get_coins] Coin bytes parsing failed"))
};
let coin: Coin = deserialize(coin_bytes)?;
let coin: Coin = deserialize_async(coin_bytes).await?;
let Value::Integer(is_spent) = row[1] else {
return Err(Error::ParseFailed("[get_coins] Is spent parsing failed"))
@@ -419,53 +419,54 @@ impl Drk {
let Value::Blob(ref value_bytes) = row[2] else {
return Err(Error::ParseFailed("[get_coins] Value bytes parsing failed"))
};
let value: u64 = deserialize(value_bytes)?;
let value: u64 = deserialize_async(value_bytes).await?;
let Value::Blob(ref token_id_bytes) = row[3] else {
return Err(Error::ParseFailed("[get_coins] Token ID bytes parsing failed"))
};
let token_id: TokenId = deserialize(token_id_bytes)?;
let token_id: TokenId = deserialize_async(token_id_bytes).await?;
let Value::Blob(ref spend_hook_bytes) = row[4] else {
return Err(Error::ParseFailed("[get_coins] Spend hook bytes parsing failed"))
};
let spend_hook: pallas::Base = deserialize(spend_hook_bytes)?;
let spend_hook: pallas::Base = deserialize_async(spend_hook_bytes).await?;
let Value::Blob(ref user_data_bytes) = row[5] else {
return Err(Error::ParseFailed("[get_coins] User data bytes parsing failed"))
};
let user_data: pallas::Base = deserialize(user_data_bytes)?;
let user_data: pallas::Base = deserialize_async(user_data_bytes).await?;
let Value::Blob(ref coin_blind_bytes) = row[6] else {
return Err(Error::ParseFailed("[get_coins] Coin blind bytes parsing failed"))
};
let coin_blind: BaseBlind = deserialize(coin_blind_bytes)?;
let coin_blind: BaseBlind = deserialize_async(coin_blind_bytes).await?;
let Value::Blob(ref value_blind_bytes) = row[7] else {
return Err(Error::ParseFailed("[get_coins] Value blind bytes parsing failed"))
};
let value_blind: ScalarBlind = deserialize(value_blind_bytes)?;
let value_blind: ScalarBlind = deserialize_async(value_blind_bytes).await?;
let Value::Blob(ref token_blind_bytes) = row[8] else {
return Err(Error::ParseFailed("[get_coins] Token blind bytes parsing failed"))
};
let token_blind: BaseBlind = deserialize(token_blind_bytes)?;
let token_blind: BaseBlind = deserialize_async(token_blind_bytes).await?;
let Value::Blob(ref secret_bytes) = row[9] else {
return Err(Error::ParseFailed("[get_coins] Secret bytes parsing failed"))
};
let secret: SecretKey = deserialize(secret_bytes)?;
let secret: SecretKey = deserialize_async(secret_bytes).await?;
// TODO: Remove from SQL store, can be derived ondemand
let Value::Blob(ref nullifier_bytes) = row[10] else {
return Err(Error::ParseFailed("[get_coins] Nullifier bytes parsing failed"))
};
let _nullifier: Nullifier = deserialize(nullifier_bytes)?;
let _nullifier: Nullifier = deserialize_async(nullifier_bytes).await?;
let Value::Blob(ref leaf_position_bytes) = row[11] else {
return Err(Error::ParseFailed("[get_coins] Leaf position bytes parsing failed"))
};
let leaf_position: bridgetree::Position = deserialize(leaf_position_bytes)?;
let leaf_position: bridgetree::Position =
deserialize_async(leaf_position_bytes).await?;
let Value::Blob(ref memo) = row[12] else {
return Err(Error::ParseFailed("[get_coins] Memo parsing failed"))
@@ -497,7 +498,10 @@ impl Drk {
*MONEY_ALIASES_TABLE, MONEY_ALIASES_COL_ALIAS, MONEY_ALIASES_COL_TOKEN_ID,
);
self.wallet
.exec_sql(&query, rusqlite::params![serialize(&alias), serialize(&token_id)])
.exec_sql(
&query,
rusqlite::params![serialize_async(&alias).await, serialize_async(&token_id).await],
)
.await
}
@@ -523,7 +527,7 @@ impl Drk {
let Value::Blob(ref alias_bytes) = row[0] else {
return Err(Error::ParseFailed("[get_aliases] Alias bytes parsing failed"))
};
let alias: String = deserialize(alias_bytes)?;
let alias: String = deserialize_async(alias_bytes).await?;
if alias_filter.is_some() && alias_filter.as_ref().unwrap() != &alias {
continue
}
@@ -531,7 +535,7 @@ impl Drk {
let Value::Blob(ref token_id_bytes) = row[1] else {
return Err(Error::ParseFailed("[get_aliases] TokenId bytes parsing failed"))
};
let token_id: TokenId = deserialize(token_id_bytes)?;
let token_id: TokenId = deserialize_async(token_id_bytes).await?;
if token_id_filter.is_some() && token_id_filter.as_ref().unwrap() != &token_id {
continue
}
@@ -566,7 +570,7 @@ impl Drk {
"DELETE FROM {} WHERE {} = ?1;",
*MONEY_ALIASES_TABLE, MONEY_ALIASES_COL_ALIAS,
);
self.wallet.exec_sql(&query, rusqlite::params![serialize(&alias)]).await
self.wallet.exec_sql(&query, rusqlite::params![serialize_async(&alias).await]).await
}
/// Mark a given coin in the wallet as unspent.
@@ -576,7 +580,9 @@ impl Drk {
"UPDATE {} SET {} = ?1 WHERE {} = ?2",
*MONEY_COINS_TABLE, MONEY_COINS_COL_IS_SPENT, MONEY_COINS_COL_COIN,
);
self.wallet.exec_sql(&query, rusqlite::params![is_spend, serialize(&coin.inner())]).await
self.wallet
.exec_sql(&query, rusqlite::params![is_spend, serialize_async(&coin.inner()).await])
.await
}
/// Replace the Money Merkle tree in the wallet.
@@ -588,7 +594,7 @@ impl Drk {
// then we insert the new one
let query =
format!("INSERT INTO {} ({}) VALUES (?1);", *MONEY_TREE_TABLE, MONEY_TREE_COL_TREE,);
self.wallet.exec_sql(&query, rusqlite::params![serialize(tree)]).await
self.wallet.exec_sql(&query, rusqlite::params![serialize_async(tree).await]).await
}
/// Fetch the Money Merkle tree from the wallet.
@@ -606,7 +612,7 @@ impl Drk {
let Value::Blob(ref tree_bytes) = row[0] else {
return Err(Error::ParseFailed("[get_money_tree] Tree bytes parsing failed"))
};
let tree = deserialize(tree_bytes)?;
let tree = deserialize_async(tree_bytes).await?;
Ok(tree)
}
@@ -640,13 +646,13 @@ impl Drk {
}
MoneyFunction::GenesisMintV1 => {
println!("[apply_tx_money_data] Found Money::GenesisMintV1 call");
let params: MoneyGenesisMintParamsV1 = deserialize(&data[1..])?;
let params: MoneyGenesisMintParamsV1 = deserialize_async(&data[1..]).await?;
coins.push(params.output.coin);
notes.push(params.output.note);
}
MoneyFunction::TransferV1 => {
println!("[apply_tx_money_data] Found Money::TransferV1 call");
let params: MoneyTransferParamsV1 = deserialize(&data[1..])?;
let params: MoneyTransferParamsV1 = deserialize_async(&data[1..]).await?;
for input in params.inputs {
nullifiers.push(input.nullifier);
@@ -659,7 +665,7 @@ impl Drk {
}
MoneyFunction::OtcSwapV1 => {
println!("[apply_tx_money_data] Found Money::OtcSwapV1 call");
let params: MoneyTransferParamsV1 = deserialize(&data[1..])?;
let params: MoneyTransferParamsV1 = deserialize_async(&data[1..]).await?;
for input in params.inputs {
nullifiers.push(input.nullifier);
@@ -672,20 +678,20 @@ impl Drk {
}
MoneyFunction::TokenMintV1 => {
println!("[apply_tx_money_data] Found Money::TokenMintV1 call");
let params: MoneyTokenMintParamsV1 = deserialize(&data[1..])?;
let params: MoneyTokenMintParamsV1 = deserialize_async(&data[1..]).await?;
coins.push(params.coin);
// TODO: why is this commented?
//notes.push(output.note);
}
MoneyFunction::TokenFreezeV1 => {
println!("[apply_tx_money_data] Found Money::TokenFreezeV1 call");
let params: MoneyTokenFreezeParamsV1 = deserialize(&data[1..])?;
let params: MoneyTokenFreezeParamsV1 = deserialize_async(&data[1..]).await?;
let token_id = TokenId::derive_public(params.mint_public);
freezes.push(token_id);
}
MoneyFunction::PoWRewardV1 => {
println!("[apply_tx_money_data] Found Money::PoWRewardV1 call");
let params: MoneyPoWRewardParamsV1 = deserialize(&data[1..])?;
let params: MoneyPoWRewardParamsV1 = deserialize_async(&data[1..]).await?;
coins.push(params.output.coin);
notes.push(params.output.note);
}
@@ -753,19 +759,19 @@ impl Drk {
for owncoin in &owncoins {
println!("OwnCoin: {:?}", owncoin.coin);
let params = rusqlite::params![
serialize(&owncoin.coin),
serialize_async(&owncoin.coin).await,
0, // <-- is_spent
serialize(&owncoin.note.value),
serialize(&owncoin.note.token_id),
serialize(&owncoin.note.spend_hook),
serialize(&owncoin.note.user_data),
serialize(&owncoin.note.coin_blind),
serialize(&owncoin.note.value_blind),
serialize(&owncoin.note.token_blind),
serialize(&owncoin.secret),
serialize(&owncoin.nullifier()),
serialize(&owncoin.leaf_position),
serialize(&owncoin.note.memo),
serialize_async(&owncoin.note.value).await,
serialize_async(&owncoin.note.token_id).await,
serialize_async(&owncoin.note.spend_hook).await,
serialize_async(&owncoin.note.user_data).await,
serialize_async(&owncoin.note.coin_blind).await,
serialize_async(&owncoin.note.value_blind).await,
serialize_async(&owncoin.note.token_blind).await,
serialize_async(&owncoin.secret).await,
serialize_async(&owncoin.nullifier()).await,
serialize_async(&owncoin.leaf_position).await,
serialize_async(&owncoin.note.memo).await,
];
if let Err(e) = self.wallet.exec_sql(&query, params).await {
@@ -781,8 +787,10 @@ impl Drk {
*MONEY_TOKENS_TABLE, MONEY_TOKENS_COL_IS_FROZEN, MONEY_TOKENS_COL_TOKEN_ID,
);
if let Err(e) =
self.wallet.exec_sql(&query, rusqlite::params![serialize(&token_id)]).await
if let Err(e) = self
.wallet
.exec_sql(&query, rusqlite::params![serialize_async(&token_id).await])
.await
{
return Err(Error::RusqliteError(format!(
"[apply_tx_money_data] Inserting Money coin failed: {e:?}"
@@ -804,7 +812,9 @@ impl Drk {
*MONEY_COINS_TABLE, MONEY_COINS_COL_IS_SPENT, MONEY_COINS_COL_COIN
);
let is_spent = 1;
self.wallet.exec_sql(&query, rusqlite::params![is_spent, serialize(&coin.inner())]).await
self.wallet
.exec_sql(&query, rusqlite::params![is_spent, serialize_async(&coin.inner()).await])
.await
}
/// Marks all coins in the wallet as spent, if their nullifier is in the given set

19
bin/drk/src/swap.rs
View File

@@ -39,7 +39,9 @@ use darkfi_sdk::{
pasta::pallas,
tx::ContractCall,
};
use darkfi_serial::{async_trait, deserialize, Encodable, SerialDecodable, SerialEncodable};
use darkfi_serial::{
async_trait, deserialize_async, AsyncEncodable, SerialDecodable, SerialEncodable,
};
use super::{money::BALANCE_BASE10_DECIMALS, Drk};
@@ -257,7 +259,7 @@ impl Drk {
];
let mut data = vec![MoneyFunction::OtcSwapV1 as u8];
full_params.encode(&mut data)?;
full_params.encode_async(&mut data).await?;
let call = ContractCall { contract_id: *MONEY_CONTRACT_ID, data };
let mut tx_builder =
TransactionBuilder::new(ContractCallLeaf { call, proofs: full_proofs }, vec![])?;
@@ -277,11 +279,11 @@ impl Drk {
let mut full: Option<Transaction> = None;
let mut half: Option<PartialSwapData> = None;
if let Ok(v) = deserialize(&bytes) {
if let Ok(v) = deserialize_async(&bytes).await {
full = Some(v)
};
match deserialize(&bytes) {
match deserialize_async(&bytes).await {
Ok(v) => half = Some(v),
Err(_) => {
if full.is_none() {
@@ -302,7 +304,8 @@ impl Drk {
return insection_error
}
let params: MoneyTransferParamsV1 = deserialize(&tx.calls[0].data.data[1..])?;
let params: MoneyTransferParamsV1 =
deserialize_async(&tx.calls[0].data.data[1..]).await?;
println!("Parameters:\n{:#?}", params);
if params.inputs.len() != 2 {
@@ -326,7 +329,7 @@ impl Drk {
for secret in &secret_keys {
if let Ok(d_note) = output.note.decrypt::<MoneyNote>(secret) {
let s: SecretKey = deserialize(&d_note.memo)?;
let s: SecretKey = deserialize_async(&d_note.memo).await?;
skey = Some(s);
note = Some(d_note);
println!("Successfully decrypted and found an ephemeral secret");
@@ -429,7 +432,7 @@ impl Drk {
pub async fn sign_swap(&self, tx: &mut Transaction) -> Result<()> {
// We need our secret keys to try and decrypt the note
let secret_keys = self.get_money_secrets().await?;
let params: MoneyTransferParamsV1 = deserialize(&tx.calls[0].data.data[1..])?;
let params: MoneyTransferParamsV1 = deserialize_async(&tx.calls[0].data.data[1..]).await?;
// Our output should be outputs[0] so we try to decrypt that.
let encrypted_note = &params.outputs[0].note;
@@ -439,7 +442,7 @@ impl Drk {
for secret in &secret_keys {
if let Ok(note) = encrypted_note.decrypt::<MoneyNote>(secret) {
let s: SecretKey = deserialize(&note.memo)?;
let s: SecretKey = deserialize_async(&note.memo).await?;
println!("Successfully decrypted and found an ephemeral secret");
skey = Some(s);
break

20
bin/drk/src/token.rs
View File

@@ -43,7 +43,7 @@ use darkfi_sdk::{
pasta::pallas,
tx::ContractCall,
};
use darkfi_serial::{deserialize, serialize, Encodable};
use darkfi_serial::{deserialize_async, serialize_async, AsyncEncodable};
use crate::{
error::WalletDbResult,
@@ -71,7 +71,11 @@ impl Drk {
self.wallet
.exec_sql(
&query,
rusqlite::params![serialize(&mint_authority), serialize(&token_id), is_frozen,],
rusqlite::params![
serialize_async(&mint_authority).await,
serialize_async(&token_id).await,
is_frozen,
],
)
.await
}
@@ -91,12 +95,12 @@ impl Drk {
let Value::Blob(ref auth_bytes) = row[0] else {
return Err(Error::ParseFailed("[list_tokens] Mint authority bytes parsing failed"))
};
let mint_authority = deserialize(auth_bytes)?;
let mint_authority = deserialize_async(auth_bytes).await?;
let Value::Blob(ref token_bytes) = row[1] else {
return Err(Error::ParseFailed("[list_tokens] Token ID bytes parsing failed"))
};
let token_id = deserialize(token_bytes)?;
let token_id = deserialize_async(token_bytes).await?;
let Value::Integer(frozen) = row[2] else {
return Err(Error::ParseFailed("[list_tokens] Is frozen parsing failed"))
@@ -196,7 +200,7 @@ impl Drk {
// Encode and sign the transaction
let mut data = vec![MoneyFunction::TokenMintV1 as u8];
debris.params.encode(&mut data)?;
debris.params.encode_async(&mut data).await?;
let call = ContractCall { contract_id: *MONEY_CONTRACT_ID, data };
let mut tx_builder =
TransactionBuilder::new(ContractCallLeaf { call, proofs: debris.proofs }, vec![])?;
@@ -235,7 +239,7 @@ impl Drk {
};
let mint_debris = builder.build()?;
let mut data = vec![MoneyFunction::TokenMintV1 as u8];
mint_debris.params.encode(&mut data)?;
mint_debris.params.encode_async(&mut data).await?;
let mint_call = ContractCall { contract_id: *MONEY_CONTRACT_ID, data };
let builder = AuthTokenMintCallBuilder {
@@ -247,7 +251,7 @@ impl Drk {
};
let auth_debris = builder.build()?;
let mut data = vec![MoneyFunction::AuthTokenMintV1 as u8];
auth_debris.params.encode(&mut data)?;
auth_debris.params.encode_async(&mut data).await?;
let auth_call = ContractCall { contract_id: *MONEY_CONTRACT_ID, data };
let mut tx = Transaction {
@@ -309,7 +313,7 @@ impl Drk {
// Encode and sign the transaction
let mut data = vec![MoneyFunction::TokenFreezeV1 as u8];
debris.params.encode(&mut data)?;
debris.params.encode_async(&mut data).await?;
let call = ContractCall { contract_id: *MONEY_CONTRACT_ID, data };
let mut tx_builder =
TransactionBuilder::new(ContractCallLeaf { call, proofs: debris.proofs }, vec![])?;

4
bin/drk/src/transfer.rs
View File

@@ -32,7 +32,7 @@ use darkfi_sdk::{
crypto::{contract_id::MONEY_CONTRACT_ID, FuncId, Keypair, PublicKey},
tx::ContractCall,
};
use darkfi_serial::Encodable;
use darkfi_serial::AsyncEncodable;
use crate::{money::BALANCE_BASE10_DECIMALS, Drk};
@@ -110,7 +110,7 @@ impl Drk {
// Encode and sign the transaction
let mut data = vec![MoneyFunction::TransferV1 as u8];
params.encode(&mut data)?;
params.encode_async(&mut data).await?;
let call = ContractCall { contract_id: *MONEY_CONTRACT_ID, data };
let mut tx_builder =
TransactionBuilder::new(ContractCallLeaf { call, proofs: secrets.proofs }, vec![])?;