wallet: use serialize and deserialize functions directly wihout wraping

src/wallet/cashierdb.rs

@@ -8,15 +8,16 @@ use sqlx::{
     ConnectOptions, Row, SqlitePool,
 };
 
-use super::wallet_api::WalletApi;
-
 use crate::{
     crypto::{
         keypair::{Keypair, PublicKey, SecretKey},
         merkle_node::MerkleNode,
         types::DrkTokenId,
     },
-    util::NetworkName,
+    util::{
+        serial::{deserialize, serialize},
+        NetworkName,
+    },
     Error::{WalletEmptyPassword, WalletTreeExists},
     Result,
 };
@@ -47,8 +48,6 @@ pub struct CashierDb {
     pub conn: SqlitePool,
 }
 
-impl WalletApi for CashierDb {}
-
 impl CashierDb {
     pub async fn new(path: &str, password: &str) -> Result<CashierDbPtr> {
         debug!("new() Constructor called");
@@ -138,7 +137,7 @@ impl CashierDb {
 
     pub async fn put_main_keys(&self, token_key: &TokenKey, network: &NetworkName) -> Result<()> {
         debug!("Writing main keys into the database");
-        let network = self.get_value_serialized(network)?;
+        let network = serialize(network);
 
         let mut conn = self.conn.acquire().await?;
         sqlx::query(
@@ -158,7 +157,7 @@ impl CashierDb {
 
     pub async fn get_main_keys(&self, network: &NetworkName) -> Result<Vec<TokenKey>> {
         debug!("Returning main keypairs");
-        let network = self.get_value_serialized(network)?;
+        let network = serialize(network);
 
         let mut conn = self.conn.acquire().await?;
 
@@ -199,12 +198,12 @@ impl CashierDb {
         mint_address: String,
     ) -> Result<()> {
         debug!("Writing withdraw keys to database");
-        let public = self.get_value_serialized(d_key_public)?;
-        let secret = self.get_value_serialized(d_key_secret)?;
-        let network = self.get_value_serialized(network)?;
-        let token_id = self.get_value_serialized(token_id)?;
-        let confirm = self.get_value_serialized(&false)?;
-        let mint_address = self.get_value_serialized(&mint_address)?;
+        let public = serialize(d_key_public);
+        let secret = serialize(d_key_secret);
+        let network = serialize(network);
+        let token_id = serialize(token_id);
+        let confirm = serialize(&false);
+        let mint_address = serialize(&mint_address);
 
         let mut conn = self.conn.acquire().await?;
         sqlx::query(
@@ -237,11 +236,11 @@ impl CashierDb {
         mint_address: String,
     ) -> Result<()> {
         debug!("Writing deposit keys to database");
-        let d_key_public = self.get_value_serialized(d_key_public)?;
-        let token_id = self.get_value_serialized(token_id)?;
-        let network = self.get_value_serialized(network)?;
-        let confirm = self.get_value_serialized(&false)?;
-        let mint_address = self.get_value_serialized(&mint_address)?;
+        let d_key_public = serialize(d_key_public);
+        let token_id = serialize(token_id);
+        let network = serialize(network);
+        let confirm = serialize(&false);
+        let mint_address = serialize(&mint_address);
 
         let mut conn = self.conn.acquire().await?;
         sqlx::query(
@@ -266,7 +265,7 @@ impl CashierDb {
 
     pub async fn get_withdraw_private_keys(&self) -> Result<Vec<SecretKey>> {
         debug!("Getting withdraw private keys");
-        let confirm = self.get_value_serialized(&false)?;
+        let confirm = serialize(&false);
 
         let mut conn = self.conn.acquire().await?;
         let rows = sqlx::query(
@@ -279,7 +278,7 @@ impl CashierDb {
 
         let mut secret_keys = vec![];
         for row in rows {
-            let key: SecretKey = self.get_value_deserialized(row.get("d_key_secret"))?;
+            let key: SecretKey = deserialize(row.get("d_key_secret"))?;
             secret_keys.push(key);
         }
 
@@ -291,8 +290,8 @@ impl CashierDb {
         pubkey: &PublicKey,
     ) -> Result<Option<WithdrawToken>> {
         debug!("Get token address by pubkey");
-        let d_key_public = self.get_value_serialized(pubkey)?;
-        let confirm = self.get_value_serialized(&false)?;
+        let d_key_public = serialize(pubkey);
+        let confirm = serialize(&false);
 
         let mut conn = self.conn.acquire().await?;
         let rows = sqlx::query(
@@ -309,9 +308,9 @@ impl CashierDb {
         let mut token_addrs = vec![];
         for row in rows {
             let token_public_key = row.get("token_key_public");
-            let network = self.get_value_deserialized(row.get("network"))?;
-            let token_id = self.get_value_deserialized(row.get("token_id"))?;
-            let mint_address = self.get_value_deserialized(row.get("mint_address"))?;
+            let network = deserialize(row.get("network"))?;
+            let token_id = deserialize(row.get("token_id"))?;
+            let mint_address = deserialize(row.get("mint_address"))?;
 
             token_addrs.push(WithdrawToken { token_public_key, network, token_id, mint_address });
         }
@@ -325,9 +324,9 @@ impl CashierDb {
         network: &NetworkName,
     ) -> Result<Vec<TokenKey>> {
         debug!("Checking for existing dkey");
-        let d_key_public = self.get_value_serialized(d_key_public)?;
-        let network = self.get_value_serialized(network)?;
-        let confirm = self.get_value_serialized(&false)?;
+        let d_key_public = serialize(d_key_public);
+        let network = serialize(network);
+        let confirm = serialize(&false);
 
         let mut conn = self.conn.acquire().await?;
         let rows = sqlx::query(
@@ -359,8 +358,8 @@ impl CashierDb {
         network: &NetworkName,
     ) -> Result<Option<Keypair>> {
         debug!("Checking for existing token address");
-        let confirm = self.get_value_serialized(&false)?;
-        let network = self.get_value_serialized(network)?;
+        let confirm = serialize(&false);
+        let network = serialize(network);
 
         let mut conn = self.conn.acquire().await?;
         let rows = sqlx::query(
@@ -377,8 +376,8 @@ impl CashierDb {
 
         let mut keypairs = vec![];
         for row in rows {
-            let public = self.get_value_deserialized(row.get("d_key_public"))?;
-            let secret = self.get_value_deserialized(row.get("d_key_secret"))?;
+            let public = deserialize(row.get("d_key_public"))?;
+            let secret = deserialize(row.get("d_key_secret"))?;
             keypairs.push(Keypair { public, secret });
         }
 
@@ -391,8 +390,8 @@ impl CashierDb {
         network: &NetworkName,
     ) -> Result<()> {
         debug!("Confirm withdraw keys");
-        let network = self.get_value_serialized(network)?;
-        let confirm = self.get_value_serialized(&true)?;
+        let network = serialize(network);
+        let confirm = serialize(&true);
 
         let mut conn = self.conn.acquire().await?;
         sqlx::query(
@@ -416,9 +415,9 @@ impl CashierDb {
         network: &NetworkName,
     ) -> Result<()> {
         debug!("Confirm deposit keys");
-        let network = self.get_value_serialized(network)?;
-        let confirm = self.get_value_serialized(&true)?;
-        let d_key_public = self.get_value_serialized(d_key_public)?;
+        let network = serialize(network);
+        let confirm = serialize(&true);
+        let d_key_public = serialize(d_key_public);
 
         let mut conn = self.conn.acquire().await?;
         sqlx::query(
@@ -441,8 +440,8 @@ impl CashierDb {
         network: &NetworkName,
     ) -> Result<Vec<DepositToken>> {
         debug!("Checking for existing dkey");
-        let network = self.get_value_serialized(network)?;
-        let confirm = self.get_value_serialized(&false)?;
+        let network = serialize(network);
+        let confirm = serialize(&false);
 
         let mut conn = self.conn.acquire().await?;
         let rows = sqlx::query(
@@ -459,11 +458,11 @@ impl CashierDb {
         let mut keys = vec![];
 
         for row in rows {
-            let drk_public_key = self.get_value_deserialized(row.get("d_key_public"))?;
+            let drk_public_key = deserialize(row.get("d_key_public"))?;
             let secret_key = row.get("token_key_secret");
             let public_key = row.get("token_key_public");
-            let token_id = self.get_value_deserialized(row.get("token_id"))?;
-            let mint_address = self.get_value_deserialized(row.get("mint_address"))?;
+            let token_id = deserialize(row.get("token_id"))?;
+            let mint_address = deserialize(row.get("mint_address"))?;
             keys.push(DepositToken {
                 drk_public_key,
                 token_key: TokenKey { secret_key, public_key },

src/wallet/walletdb.rs

@@ -20,13 +20,14 @@ use crate::{
         types::DrkTokenId,
         OwnCoin, OwnCoins,
     },
-    util::{expand_path, serial::serialize},
+    util::{
+        expand_path,
+        serial::{deserialize, serialize},
+    },
     Error::{WalletEmptyPassword, WalletTreeExists},
     Result,
 };
 
-use super::wallet_api::WalletApi;
-
 pub type WalletPtr = Arc<WalletDb>;
 
 #[derive(Clone, Debug)]
@@ -45,8 +46,6 @@ pub struct WalletDb {
     pub conn: SqlitePool,
 }
 
-impl WalletApi for WalletDb {}
-
 /// Helper function to initialize `WalletPtr`
 pub async fn init_wallet(wallet_path: &str, wallet_pass: &str) -> Result<WalletPtr> {
     let expanded = expand_path(wallet_path)?;
@@ -158,8 +157,8 @@ impl WalletDb {
             .fetch_one(&mut conn)
             .await?;
 
-        let public: PublicKey = self.get_value_deserialized(row.get("public"))?;
-        let secret: SecretKey = self.get_value_deserialized(row.get("secret"))?;
+        let public: PublicKey = deserialize(row.get("public"))?;
+        let secret: SecretKey = deserialize(row.get("secret"))?;
 
         Ok(Keypair { secret, public })
     }
@@ -195,8 +194,8 @@ impl WalletDb {
         let mut keypairs = vec![];
 
         for row in sqlx::query("SELECT * FROM keys").fetch_all(&mut conn).await? {
-            let public: PublicKey = self.get_value_deserialized(row.get("public"))?;
-            let secret: SecretKey = self.get_value_deserialized(row.get("secret"))?;
+            let public: PublicKey = deserialize(row.get("public"))?;
+            let secret: SecretKey = deserialize(row.get("secret"))?;
             keypairs.push(Keypair { public, secret });
         }
 
@@ -259,21 +258,21 @@ impl WalletDb {
 
         let mut own_coins = vec![];
         for row in rows {
-            let coin = self.get_value_deserialized(row.get("coin"))?;
+            let coin = deserialize(row.get("coin"))?;
 
             // Note
-            let serial = self.get_value_deserialized(row.get("serial"))?;
-            let coin_blind = self.get_value_deserialized(row.get("coin_blind"))?;
-            let value_blind = self.get_value_deserialized(row.get("valcom_blind"))?;
+            let serial = deserialize(row.get("serial"))?;
+            let coin_blind = deserialize(row.get("coin_blind"))?;
+            let value_blind = deserialize(row.get("valcom_blind"))?;
             // TODO: FIXME:
             let value_bytes: Vec<u8> = row.get("value");
             let value = u64::from_le_bytes(value_bytes.try_into().unwrap());
-            let token_id = self.get_value_deserialized(row.get("token_id"))?;
+            let token_id = deserialize(row.get("token_id"))?;
             let note = Note { serial, value, token_id, coin_blind, value_blind };
 
-            let secret = self.get_value_deserialized(row.get("secret"))?;
-            let nullifier = self.get_value_deserialized(row.get("nullifier"))?;
-            let leaf_position = self.get_value_deserialized(row.get("leaf_position"))?;
+            let secret = deserialize(row.get("secret"))?;
+            let nullifier = deserialize(row.get("nullifier"))?;
+            let leaf_position = deserialize(row.get("leaf_position"))?;
 
             let oc = OwnCoin { coin, note, secret, nullifier, leaf_position };
 
@@ -285,16 +284,17 @@ impl WalletDb {
 
     pub async fn put_own_coin(&self, own_coin: OwnCoin) -> Result<()> {
         debug!("Putting own coin into wallet database");
-        let coin = self.get_value_serialized(&own_coin.coin.to_bytes())?;
-        let serial = self.get_value_serialized(&own_coin.note.serial)?;
-        let coin_blind = self.get_value_serialized(&own_coin.note.coin_blind)?;
-        let value_blind = self.get_value_serialized(&own_coin.note.value_blind)?;
+
+        let coin = serialize(&own_coin.coin.to_bytes());
+        let serial = serialize(&own_coin.note.serial);
+        let coin_blind = serialize(&own_coin.note.coin_blind);
+        let value_blind = serialize(&own_coin.note.value_blind);
         let value = own_coin.note.value.to_le_bytes();
-        let token_id = self.get_value_serialized(&own_coin.note.token_id)?;
-        let secret = self.get_value_serialized(&own_coin.secret)?;
-        let is_spent = 0;
-        let nullifier = self.get_value_serialized(&own_coin.nullifier)?;
-        let leaf_position = self.get_value_serialized(&own_coin.leaf_position)?;
+        let token_id = serialize(&own_coin.note.token_id);
+        let secret = serialize(&own_coin.secret);
+        let is_spent: u32 = 0;
+        let nullifier = serialize(&own_coin.nullifier);
+        let leaf_position = serialize(&own_coin.leaf_position);
 
         let mut conn = self.conn.acquire().await?;
         sqlx::query(
@@ -330,8 +330,8 @@ impl WalletDb {
 
     pub async fn confirm_spend_coin(&self, coin: &Coin) -> Result<()> {
         debug!("Confirm spend coin");
-        let is_spent = 1;
-        let coin = self.get_value_serialized(coin)?;
+        let is_spent: u32 = 1;
+        let coin = serialize(coin);
 
         let mut conn = self.conn.acquire().await?;
         sqlx::query("UPDATE coins SET is_spent = ?1 WHERE coin = ?2;")
@@ -360,8 +360,8 @@ impl WalletDb {
             // TODO: FIXME:
             let value_bytes: Vec<u8> = row.get("value");
             let value = u64::from_le_bytes(value_bytes.try_into().unwrap());
-            let token_id = self.get_value_deserialized(row.get("token_id"))?;
-            let nullifier = self.get_value_deserialized(row.get("nullifier"))?;
+            let token_id = deserialize(row.get("token_id"))?;
+            let nullifier = deserialize(row.get("nullifier"))?;
             list.push(Balance { token_id, value, nullifier });
         }
 
@@ -380,7 +380,7 @@ impl WalletDb {
 
         let mut token_ids = vec![];
         for row in rows {
-            let token_id = self.get_value_deserialized(row.get("token_id"))?;
+            let token_id = deserialize(row.get("token_id"))?;
             token_ids.push(token_id);
         }
 
@@ -390,8 +390,8 @@ impl WalletDb {
     pub async fn token_id_exists(&self, token_id: DrkTokenId) -> Result<bool> {
         debug!("Checking if token ID exists");
 
-        let is_spent = 0;
-        let id = self.get_value_serialized(&token_id)?;
+        let is_spent: u32 = 0;
+        let id = serialize(&token_id);
 
         let mut conn = self.conn.acquire().await?;