drk: use (de)serialize_async everywhere

bin/drk/src/dao.rs

@@ -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()?;

bin/drk/src/money.rs

@@ -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

bin/drk/src/swap.rs

@@ -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

bin/drk/src/token.rs

@@ -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![])?;

bin/drk/src/transfer.rs

@@ -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![])?;