pass network name to the bridge instead of asset_id

sql/cashier.sql

@@ -1,14 +1,18 @@
 CREATE TABLE IF NOT EXISTS deposit_keypairs(
-    d_key_public INTEGER PRIMARY KEY NOT NULL,
+    keypair_id INTEGER PRIMARY KEY NOT NULL,
+    d_key_public BLOB NOT NULL,
    	token_key_private BLOB NOT NULL,
     token_key_public BLOB NOT NULL,
+	network BLOB NOT NULL,
 	asset_id BLOB NOT NULL
 );
 
 CREATE TABLE IF NOT EXISTS withdraw_keypairs(
-    token_key_id BLOB PRIMARY KEY NOT NULL,
+    keypair_id INTEGER PRIMARY KEY NOT NULL,
+    token_key_id BLOB NOT NULL,
 	d_key_private BLOB NOT NULL,
     d_key_public BLOB NOT NULL,
+	network BLOB NOT NULL,
 	asset_id BLOB NOT NULL,
 	confirm BLOB NOT NULL
 );

src/service/bridge.rs

@@ -2,11 +2,11 @@ use crate::Result;
 
 use async_trait::async_trait;
 
-use crate::serial::serialize;
 use async_std::sync::{Arc, Mutex};
 use std::collections::HashMap;
 
 pub struct BridgeRequests {
+    pub network: String,
     pub asset_id: jubjub::Fr,
     pub payload: BridgeRequestsPayload,
 }
@@ -49,32 +49,34 @@ pub struct TokenNotification {
 }
 
 pub struct Bridge {
-    clients: Mutex<HashMap<Vec<u8>, Arc<dyn TokenClient + Send + Sync>>>,
-    notifiers: Mutex<HashMap<Vec<u8>, async_channel::Receiver<TokenNotification>>>,
+    clients: Mutex<HashMap<String, Arc<dyn TokenClient + Send + Sync>>>,
+    //notifiers: Mutex<HashMap<Vec<u8>, async_channel::Receiver<TokenNotification>>>,
 }
 
 impl Bridge {
     pub fn new() -> Arc<Self> {
         Arc::new(Self {
             clients: Mutex::new(HashMap::new()),
-            notifiers: Mutex::new(HashMap::new()),
+            //notifiers: Mutex::new(HashMap::new()),
         })
     }
 
     pub async fn add_clients(
         self: Arc<Self>,
-        asset_id: jubjub::Fr,
+        network: String,
         client: Arc<dyn TokenClient + Send + Sync>,
     ) -> Result<()> {
-        let asset_id = serialize(&asset_id);
+        //let notifier = client.get_notifier().await?;
 
-        let notifier = client.get_notifier().await?;
-
-        self.clients.lock().await.insert(asset_id.clone(), client);
-        self.notifiers
+        self.clients
             .lock()
             .await
-            .insert(asset_id, notifier.clone());
+            .insert(network.clone(), client.clone());
+
+        //        self.notifiers
+        //            .lock()
+        //            .await
+        //            .insert(asset_id, notifier.clone());
         Ok(())
     }
 
@@ -95,9 +97,9 @@ impl Bridge {
         rep: async_channel::Sender<BridgeResponse>,
     ) -> Result<()> {
         let req = req.recv().await?;
-        let asset_id = serialize(&req.asset_id);
+        let network = req.network;
 
-        if !self.clients.lock().await.contains_key(&asset_id) {
+        if !self.clients.lock().await.contains_key(&network) {
             let res = BridgeResponse {
                 error: BridgeResponseError::NotSupportedClient,
                 payload: BridgeResponsePayload::Empty,
@@ -106,7 +108,7 @@ impl Bridge {
             return Ok(());
         }
 
-        let client = &self.clients.lock().await[&asset_id];
+        let client = &self.clients.lock().await[&network];
 
         match req.payload {
             BridgeRequestsPayload::WatchRequest => {

src/service/btc.rs

@@ -143,14 +143,14 @@ pub struct BtcClient {
 }
 
 impl BtcClient {
-    pub fn new(btc_endpoint: (Network, String)) -> Result<Self> {
+    pub fn new(btc_endpoint: (Network, String)) -> Result<Arc<Self>> {
         let (network, client_address) = btc_endpoint;
         let client = ElectrumClient::new(&client_address)
             .map_err(|err| crate::Error::from(super::BtcFailed::from(err)))?;
-        Ok(Self {
+        Ok(Arc::new(Self {
             client: Arc::new(client),
             network,
-        })
+        }))
     }
 }
 

src/service/sol.rs

@@ -270,9 +270,34 @@ impl TokenClient for SolClient {
     }
 }
 
+/// Derive an associated token address from given owner and mint
+fn get_associated_token_account(owner: &Pubkey, mint: &Pubkey) -> (Pubkey, u8) {
+
+    let associated_token =
+        Pubkey::from_str("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL").unwrap();
+
+    Pubkey::find_program_address(
+        &[
+            &owner.to_bytes(),
+            &spl_token::id().to_bytes(),
+            &mint.to_bytes(),
+        ],
+        &associated_token,
+    )
+}
+
+/// Check if given account is a valid token mint
+fn account_is_initialized_mint(mint: &Pubkey) -> bool {
+    let rpc = RpcClient::new(RPC_SERVER.to_string());
+    match rpc.get_token_supply(mint) {
+        Ok(_) => return true,
+        Err(_) => return false,
+    }
+}
+
 impl Encodable for Keypair {
     fn encode<S: std::io::Write>(&self, s: S) -> Result<usize> {
-        let key = self.to_bytes();
+        let key: Vec<u8> = self.to_bytes().to_vec();
         let len = key.encode(s)?;
         Ok(len)
     }
@@ -377,26 +402,4 @@ impl From<crate::error::Error> for SolFailed {
 
 pub type SolResult<T> = std::result::Result<T, SolFailed>;
 
-/// Derive an associated token address from given owner and mint
-fn get_associated_token_account(owner: &Pubkey, mint: &Pubkey) -> (Pubkey, u8) {
-    let associated_token =
-        Pubkey::from_str("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL").unwrap();
 
-    Pubkey::find_program_address(
-        &[
-            &owner.to_bytes(),
-            &spl_token::id().to_bytes(),
-            &mint.to_bytes(),
-        ],
-        &associated_token,
-    )
-}
-
-/// Check if given account is a valid token mint
-fn account_is_initialized_mint(mint: &Pubkey) -> bool {
-    let rpc = RpcClient::new(RPC_SERVER.to_string());
-    match rpc.get_token_supply(mint) {
-        Ok(_) => return true,
-        Err(_) => return false,
-    }
-}

src/wallet/cashierdb.rs

@@ -63,10 +63,10 @@ impl CashierDb {
         let asset_id = self.get_value_serialized(asset_id)?;
 
         let mut stmt =
-            conn.prepare("SELECT * FROM deposit_keypairs where d_key_public = :d_key_public AND asset_id = :asset_id")?;
+            conn.prepare("SELECT token_key_private, token_key_public FROM deposit_keypairs where d_key_public = :d_key_public AND asset_id = :asset_id")?;
         let keys_iter = stmt.query_map::<(Vec<u8>, Vec<u8>), _, _>(
             &[(":d_key_public", &d_key_public), (":asset_id", &asset_id)],
-            |row| Ok((row.get(1)?, row.get(2)?)),
+            |row| Ok((row.get(0)?, row.get(1)?)),
         )?;
 
         let mut keys = vec![];
@@ -83,27 +83,29 @@ impl CashierDb {
         d_key_public: &jubjub::SubgroupPoint,
         token_private: &Vec<u8>,
         token_public: &Vec<u8>,
+        network: &String,
         asset_id: &jubjub::Fr,
     ) -> Result<()> {
         debug!(target: "CASHIERDB", "Put exchange keys");
 
-        let d_key_public = self.get_value_serialized(d_key_public)?;
-
         // open connection
         let conn = Connection::open(&self.path)?;
         // unlock database
         conn.pragma_update(None, "key", &self.password)?;
 
+        let d_key_public = self.get_value_serialized(d_key_public)?;
         let asset_id = self.get_value_serialized(asset_id)?;
+        let network = self.get_value_serialized(network)?;
 
         conn.execute(
-            "INSERT INTO deposit_keypairs(d_key_public, token_key_private, token_public_key_public, asset_id)
-            VALUES (:d_key_public, :token_key_private, :token_key_public, :asset_id)",
+            "INSERT INTO deposit_keypairs(d_key_public, token_key_private, token_key_public, network, asset_id)
+            VALUES (:d_key_public, :token_key_private, :token_key_public, :network, :asset_id)",
             named_params! {
-                ":d_key_public": d_key_public,
+                ":d_key_public": &d_key_public,
                 ":token_key_private": token_private,
                 ":token_key_public": token_public,
-                ":asset_id": asset_id,
+                ":network": &network,
+                ":asset_id": &asset_id,
             },
         )?;
         Ok(())
@@ -191,10 +193,10 @@ impl CashierDb {
             ],
             |row| {
                 let public: jubjub::SubgroupPoint = self
-                    .get_value_deserialized(row.get(2)?)
+                    .get_value_deserialized(row.get(3)?)
                     .expect("get public key deserialize");
                 let private: jubjub::Fr = self
-                    .get_value_deserialized(row.get(1)?)
+                    .get_value_deserialized(row.get(2)?)
                     .expect("get  private key deserialize");
                 Ok(Keypair { public, private })
             },
@@ -212,7 +214,7 @@ impl CashierDb {
     pub fn get_withdraw_token_public_key_by_dkey_public(
         &self,
         pub_key: &jubjub::SubgroupPoint,
-    ) -> Result<Option<(Vec<u8>, jubjub::Fr)>> {
+    ) -> Result<Option<(Vec<u8>, String, jubjub::Fr)>> {
         debug!(target: "CASHIERDB", "Get token address by pub_key");
         // open connection
         let conn = Connection::open(&self.path)?;
@@ -224,17 +226,20 @@ impl CashierDb {
         let confirm = self.get_value_serialized(&false)?;
 
         let mut stmt = conn.prepare(
-            "SELECT token_key_id, asset_id FROM withdraw_keypairs WHERE d_key_public = :d_key_public AND confirm = :confirm;",
+            "SELECT token_key_id, network, asset_id FROM withdraw_keypairs WHERE d_key_public = :d_key_public AND confirm = :confirm;",
         )?;
-        let addr_iter = stmt.query_map::<(Vec<u8>, jubjub::Fr), _, _>(
+        let addr_iter = stmt.query_map::<(Vec<u8>, String, jubjub::Fr), _, _>(
             &[(":d_key_public", &d_key_public), (":confirm", &&confirm)],
             |row| {
                 let token_public_key = row.get(0)?;
-                let asset_id = row.get(1)?;
+                let network: String = self
+                    .get_value_deserialized(row.get(1)?)
+                    .expect("deserialize network str");
+                let asset_id = row.get(2)?;
                 let asset_id: jubjub::Fr = self
                     .get_value_deserialized(asset_id)
                     .expect("deserialize asset_id");
-                Ok((token_public_key, asset_id))
+                Ok((token_public_key, network, asset_id))
             },
         )?;
 
@@ -276,12 +281,14 @@ impl CashierDb {
         token_key_id: &Vec<u8>,
         d_key_public: &jubjub::SubgroupPoint,
         d_key_private: &jubjub::Fr,
+        network: &String,
         asset_id: &jubjub::Fr,
     ) -> Result<()> {
         debug!(target: "CASHIERDB", "Put withdraw keys");
 
         let d_key_public = self.get_value_serialized(d_key_public)?;
         let d_key_private = self.get_value_serialized(d_key_private)?;
+        let network = self.get_value_serialized(network)?;
         let asset_id = self.get_value_serialized(asset_id)?;
 
         // open connection
@@ -292,12 +299,13 @@ impl CashierDb {
         let confirm = self.get_value_serialized(&false)?;
 
         conn.execute(
-            "INSERT INTO withdraw_keypairs(token_key_id, d_key_private, d_key_public, asset_id, confirm)
-            VALUES (:token_key_id, :d_key_private, :d_key_public, :asset_id, :confirm)",
+            "INSERT INTO withdraw_keypairs(token_key_id, d_key_private, d_key_public, network,  asset_id, confirm)
+            VALUES (:token_key_id, :d_key_private, :d_key_public,:network, :asset_id, :confirm)",
             named_params! {
                 ":token_key_id": token_key_id,
                 ":d_key_private": d_key_private,
                 ":d_key_public": d_key_public,
+                ":network": network,
                 ":asset_id": asset_id,
                 ":confirm": confirm,
             },
@@ -332,7 +340,13 @@ mod tests {
 
         let asset_id: jubjub::Fr = jubjub::Fr::random(&mut OsRng);
 
-        wallet.put_withdraw_keys(&token_addr, &public2, &secret2, &asset_id)?;
+        wallet.put_withdraw_keys(
+            &token_addr,
+            &public2,
+            &secret2,
+            &String::from("btc"),
+            &asset_id,
+        )?;
 
         let addr = wallet.get_withdraw_keys_by_token_public_key(&token_addr, &asset_id)?;