more clean up and minor changes

src/bin/cashierd.rs

@@ -25,7 +25,7 @@ use drk::{
     serial::{deserialize, serialize},
     service::{bridge, bridge::Bridge},
     util::{expand_path, generate_id, join_config_path, parse::truncate, NetworkName},
-    wallet::{cashierdb::MainTokenKey, CashierDb, WalletDb},
+    wallet::{cashierdb::TokenKey, CashierDb, WalletDb},
     Error, Result,
 };
 
@@ -127,10 +127,9 @@ impl Cashierd {
                     .sender
                     .send(bridge::BridgeRequests {
                         network: network.name.clone(),
-                        payload: bridge::BridgeRequestsPayload::Watch(Some((
-                            deposit_token.token_private_key,
-                            deposit_token.token_public_key,
-                        ))),
+                        payload: bridge::BridgeRequestsPayload::Watch(Some(
+                            deposit_token.token_key,
+                        )),
                     })
                     .await?;
             }
@@ -298,10 +297,7 @@ impl Cashierd {
                     .sender
                     .send(bridge::BridgeRequests {
                         network: network.clone(),
-                        payload: bridge::BridgeRequestsPayload::Watch(Some((
-                            keypair.private_key,
-                            keypair.public_key,
-                        ))),
+                        payload: bridge::BridgeRequestsPayload::Watch(Some(keypair)),
                     })
                     .await?;
             }
@@ -315,18 +311,18 @@ impl Cashierd {
             }
 
             match bridge_res.payload {
-                bridge::BridgeResponsePayload::Watch(token_priv, token_pub) => {
+                bridge::BridgeResponsePayload::Watch(token_key) => {
                     // add pairings to db
                     self.cashier_wallet.put_deposit_keys(
                         &drk_pub_key,
-                        &token_priv,
-                        &serialize(&token_pub),
+                        &token_key.private_key,
+                        &serialize(&token_key.public_key),
                         &network,
                         &token_id,
                         mint_address,
                     )?;
 
-                    return Ok(token_pub);
+                    return Ok(token_key.public_key);
                 }
                 bridge::BridgeResponsePayload::Address(token_pub) => {
                     return Ok(token_pub);
@@ -497,7 +493,7 @@ impl Cashierd {
                         if main_keypairs.is_empty() {
                             main_keypair = Keypair::new();
                             self.cashier_wallet.put_main_keys(
-                                &MainTokenKey {
+                                &TokenKey {
                                     private_key: serialize(&main_keypair),
                                     public_key: serialize(&main_keypair.pubkey()),
                                 },
@@ -536,7 +532,7 @@ impl Cashierd {
                         if main_keypairs.is_empty() {
                             main_keypair = Keypair::new();
                             self.cashier_wallet.put_main_keys(
-                                &MainTokenKey {
+                                &TokenKey {
                                     private_key: serialize(&main_keypair),
                                     public_key: serialize(&main_keypair.pubkey()),
                                 },

src/service/bridge.rs

@@ -7,6 +7,7 @@ use futures::stream::StreamExt;
 use log::*;
 
 use crate::util::NetworkName;
+use crate::wallet::cashierdb::TokenKey;
 use crate::{Error, Result};
 
 pub struct BridgeRequests {
@@ -20,12 +21,12 @@ pub struct BridgeResponse {
 }
 
 pub enum BridgeRequestsPayload {
-    Send(Vec<u8>, u64),                // send (address, amount)
-    Watch(Option<(Vec<u8>, Vec<u8>)>), // if already has a keypair
+    Send(Vec<u8>, u64),      // send (address, amount)
+    Watch(Option<TokenKey>), // if already has a keypair
 }
 
 pub enum BridgeResponsePayload {
-    Watch(Vec<u8>, String),
+    Watch(TokenSubscribtion),
     Address(String),
     Send,
     Empty,
@@ -46,7 +47,7 @@ pub struct BridgeSubscribtion {
 
 #[derive(Debug)]
 pub struct TokenSubscribtion {
-    pub secret_key: Vec<u8>,
+    pub private_key: Vec<u8>,
     pub public_key: String,
 }
 
@@ -163,9 +164,14 @@ impl Bridge {
 
         match req.payload {
             BridgeRequestsPayload::Watch(val) => match val {
-                Some((private_key, public_key)) => {
+                Some(token_key) => {
                     let pub_key = client
-                        .subscribe_with_keypair(private_key, public_key, drk_pub_key, mint_address)
+                        .subscribe_with_keypair(
+                            token_key.private_key,
+                            token_key.public_key,
+                            drk_pub_key,
+                            mint_address,
+                        )
                         .await;
 
                     if pub_key.is_err() {
@@ -193,7 +199,7 @@ impl Bridge {
                         let sub = sub?;
                         res = BridgeResponse {
                             error: BridgeResponseError::NoError,
-                            payload: BridgeResponsePayload::Watch(sub.secret_key, sub.public_key),
+                            payload: BridgeResponsePayload::Watch(sub),
                         };
                     }
                 }

src/service/btc.rs

@@ -5,16 +5,16 @@ use std::time::Duration;
 
 use async_trait::async_trait;
 
-use bitcoin_hashes::hex::ToHex;
 use bitcoin::blockdata::{
     script::{Builder, Script},
     transaction::{OutPoint, SigHashType, Transaction, TxIn, TxOut},
 };
 use bitcoin::hash_types::PubkeyHash as BtcPubKeyHash;
 use bitcoin::network::constants::Network;
-use bitcoin::util::psbt::serialize::Serialize;
 use bitcoin::util::address::Address;
 use bitcoin::util::ecdsa::{PrivateKey as BtcPrivKey, PublicKey as BtcPubKey};
+use bitcoin::util::psbt::serialize::Serialize;
+use bitcoin_hashes::hex::ToHex;
 use electrum_client::{Client as ElectrumClient, ElectrumApi, GetBalanceRes};
 use log::*;
 use secp256k1::{
@@ -169,7 +169,6 @@ pub struct BtcClient {
 
 impl BtcClient {
     pub async fn new(main_keypair: Keypair, network: &str) -> Result<Arc<Self>> {
-
         //TODO
         // info!(target: "SOL BRIDGE", "Main BTC wallet pubkey: {:?}", &main_keypair.pubkey());
 
@@ -322,7 +321,6 @@ impl BtcClient {
         debug!(target: "BTC BRIDGE", "unSigned tx: {:?}",
                &txid.to_hex());
 
-
         let signed_tx = sign_transaction(
             transaction,
             script,
@@ -354,7 +352,7 @@ impl NetworkClient for BtcClient {
         // Generate bitcoin keys
         let keypair = Keypair::new();
         let btc_keys = Account::new(&keypair, self.network);
-        let secret_key = serialize(&keypair);
+        let private_key = serialize(&keypair);
         let public_key = btc_keys.address.to_string();
 
         // start scheduler for checking balance
@@ -369,7 +367,7 @@ impl NetworkClient for BtcClient {
         .detach();
 
         Ok(TokenSubscribtion {
-            secret_key,
+            private_key,
             public_key,
         })
     }
@@ -398,7 +396,12 @@ impl NetworkClient for BtcClient {
     async fn get_notifier(self: Arc<Self>) -> Result<async_channel::Receiver<TokenNotification>> {
         Ok(self.notify_channel.1.clone())
     }
-    async fn send(self: Arc<Self>, address: Vec<u8>, _mint: Option<String>, amount: u64) -> Result<()> {
+    async fn send(
+        self: Arc<Self>,
+        address: Vec<u8>,
+        _mint: Option<String>,
+        amount: u64,
+    ) -> Result<()> {
         // address is not a btc address, so derive the btc address
         let client = &self.client;
         let public_key = deserialize(&address)?;
@@ -646,10 +649,10 @@ pub type BtcResult<T> = std::result::Result<T, BtcFailed>;
 #[cfg(test)]
 mod tests {
 
-    use crate::serial::{deserialize, serialize};
-    use std::str::FromStr;
     use super::Keypair;
+    use crate::serial::{deserialize, serialize};
     use secp256k1::constants::{PUBLIC_KEY_SIZE, SECRET_KEY_SIZE};
+    use std::str::FromStr;
 
     const KEYPAIR_LENGTH: usize = SECRET_KEY_SIZE + PUBLIC_KEY_SIZE;
 
@@ -668,7 +671,6 @@ mod tests {
 
     #[test]
     pub fn test_serialize_and_deserialize_keypair() -> super::BtcResult<()> {
-
         let keypair = Keypair::new();
 
         let bytes: [u8; KEYPAIR_LENGTH] = keypair.to_bytes();

src/service/sol.rs

@@ -407,7 +407,7 @@ impl NetworkClient for SolClient {
         let keypair = Keypair::generate(&mut OsRng);
 
         let public_key = keypair.pubkey().to_string();
-        let secret_key = serialize(&keypair);
+        let private_key = serialize(&keypair);
 
         let mint = self.check_mint_address(mint_address)?;
 
@@ -429,7 +429,7 @@ impl NetworkClient for SolClient {
         .detach();
 
         Ok(TokenSubscribtion {
-            secret_key,
+            private_key,
             public_key,
         })
     }

src/wallet/cashierdb.rs

@@ -18,7 +18,7 @@ pub struct CashierDb {
 }
 
 #[derive(Debug, Clone)]
-pub struct MainTokenKey {
+pub struct TokenKey {
     pub public_key: Vec<u8>,
     pub private_key: Vec<u8>,
 }
@@ -32,8 +32,7 @@ pub struct WithdrawToken {
 
 pub struct DepositToken {
     pub drk_public_key: jubjub::SubgroupPoint,
-    pub token_public_key: Vec<u8>,
-    pub token_private_key: Vec<u8>,
+    pub token_key: TokenKey,
     pub token_id: jubjub::Fr,
     pub mint_address: String,
 }
@@ -80,7 +79,7 @@ impl CashierDb {
         Ok(())
     }
 
-    pub fn put_main_keys(&self, token_key: &MainTokenKey, network: &NetworkName) -> Result<()> {
+    pub fn put_main_keys(&self, token_key: &TokenKey, network: &NetworkName) -> Result<()> {
         debug!(target: "CASHIERDB", "Put main keys");
 
         // open connection
@@ -104,7 +103,7 @@ impl CashierDb {
         Ok(())
     }
 
-    pub fn get_main_keys(&self, network: &NetworkName) -> Result<Vec<MainTokenKey>> {
+    pub fn get_main_keys(&self, network: &NetworkName) -> Result<Vec<TokenKey>> {
         debug!(target: "CASHIERDB", "Get main keys");
         // open connection
         let conn = Connection::open(&self.path)?;
@@ -127,7 +126,7 @@ impl CashierDb {
 
         for k in keys_iter {
             let k = k?;
-            keys.push(MainTokenKey {
+            keys.push(TokenKey {
                 private_key: k.0,
                 public_key: k.1,
             });
@@ -292,7 +291,7 @@ impl CashierDb {
         &self,
         d_key_public: &jubjub::SubgroupPoint,
         network: &NetworkName,
-    ) -> Result<Vec<MainTokenKey>> {
+    ) -> Result<Vec<TokenKey>> {
         debug!(target: "CASHIERDB", "Check for existing dkey");
         let d_key_public = self.get_value_serialized(d_key_public)?;
         // open connection
@@ -323,7 +322,7 @@ impl CashierDb {
 
         for k in keys_iter {
             let k = k?;
-            keys.push(MainTokenKey {
+            keys.push(TokenKey {
                 private_key: k.0,
                 public_key: k.1,
             });
@@ -367,14 +366,16 @@ impl CashierDb {
         for key in keys_iter {
             let key = key?;
             let drk_public_key: jubjub::SubgroupPoint = self.get_value_deserialized(&key.0)?;
-            let token_private_key = key.1;
-            let token_public_key = key.2;
+            let private_key = key.1;
+            let public_key = key.2;
             let token_id: jubjub::Fr = self.get_value_deserialized(&key.3)?;
             let mint_address: String = self.get_value_deserialized(&key.4)?;
             keys.push(DepositToken {
                 drk_public_key,
-                token_private_key,
-                token_public_key,
+                token_key: TokenKey {
+                    private_key,
+                    public_key,
+                },
                 token_id,
                 mint_address,
             });
@@ -519,7 +520,7 @@ mod tests {
         let network = NetworkName::Bitcoin;
 
         wallet.put_main_keys(
-            &MainTokenKey {
+            &TokenKey {
                 private_key: token_addr_private.clone(),
                 public_key: token_addr.clone(),
             },
@@ -574,8 +575,8 @@ mod tests {
         let resumed_keys = wallet.get_deposit_token_keys_by_network(&network)?;
 
         assert_eq!(resumed_keys[0].drk_public_key, public2);
-        assert_eq!(resumed_keys[0].token_private_key, token_addr_private);
-        assert_eq!(resumed_keys[0].token_public_key, token_addr);
+        assert_eq!(resumed_keys[0].token_key.private_key, token_addr_private);
+        assert_eq!(resumed_keys[0].token_key.public_key, token_addr);
         assert_eq!(resumed_keys[0].token_id, token_id);
 
         wallet.confirm_deposit_key_record(&public2, &network)?;