darkfid: implemented transfer

src/bin/darkfid.rs

@@ -372,13 +372,10 @@ impl Darkfid {
     // <-- {"result": "txID"}
     async fn transfer(&self, id: Value, params: Value) -> JsonResult {
         let args = params.as_array();
-
         if args.is_none() {
             return JsonResult::Err(jsonerr(InvalidParams, None, id));
         }
-
         let args = args.unwrap();
-
         if args.len() != 3 {
             return JsonResult::Err(jsonerr(InvalidParams, None, id));
         }
@@ -390,48 +387,58 @@ impl Darkfid {
         if token.as_str().is_none() {
             return JsonResult::Err(jsonerr(InvalidTokenIdParam, None, id));
         }
+        let token = token.as_str().unwrap();
+        if address.as_str().is_none() {
+            return JsonResult::Err(jsonerr(InvalidAddressParam, None, id));
+        }
 
-        let _token = token.as_str().unwrap();
-
-        let token_vec = self.client.lock().await.get_token_id().await;
+        let address = address.as_str().unwrap();
+        if amount.as_str().is_none() {
+            return JsonResult::Err(jsonerr(InvalidAmountParam, None, id));
+        }
+        let amount = amount.as_str().unwrap();
 
-        //for (symbol, token_id) in self.drk_tokenlist.iter() {}
+        let hashmap = self.drk_tokenlist.drk_tokenlist.clone();
 
-        if address.as_str().is_none() {
-            return JsonResult::Err(jsonerr(InvalidAddressParam, None, id));
+        if hashmap.get(token).is_none() {
+            return JsonResult::Err(jsonerr(InvalidParams, None, id));
         }
+        // get the id for the token
+        let token_id = hashmap.get(token).unwrap();
+
+        let result: Result<()> = async {
+            // check if it's in the database
+            if self
+                .client
+                .lock()
+                .await
+                .token_id_exists(token_id)
+                .await
+                .unwrap()
+                == true
+            {
+                let own_token_id = token_id;
+                let drk_address = bs58::decode(&address).into_vec()?;
+                let drk_address: jubjub::SubgroupPoint = deserialize(&drk_address)?;
+
+                let decimals: usize = 8;
+                let amount = decode_base10(amount, decimals, true)?;
 
-        let _address = address.as_str().unwrap();
+                self.client
+                    .lock()
+                    .await
+                    .transfer(*own_token_id, drk_address, amount)
+                    .await?;
+            }
 
-        if amount.as_f64().is_none() {
-            return JsonResult::Err(jsonerr(InvalidAmountParam, None, id));
+            Ok(())
         }
+        .await;
 
-        let _amount = amount.as_f64().unwrap();
-
-        // TODO: get tokenID from walletdb
-        //let result: Result<()> = async {
-        //    let token_id = parse_wrapped_token(token, self.tokenlist.clone())?;
-        //    let address = bs58::decode(&address).into_vec()?;
-        //    let address: jubjub::SubgroupPoint = deserialize(&address)?;
-        //    self.client
-        //        .lock()
-        //        .await
-        //        .transfer(token_id, address, amount)
-        //        .await?;
-        //    Ok(())
-        //}
-        //.await;
-
-        //match result {
-        //    Ok(res) => JsonResult::Resp(jsonresp(json!(res), json!(id))),
-        //    Err(err) => JsonResult::Err(jsonerr(InternalError, Some(err.to_string()), json!(id))),
-        //}
-        return JsonResult::Err(jsonerr(
-            ServerError(-32005),
-            Some("failed to withdraw".to_string()),
-            id,
-        ));
+        match result {
+            Ok(res) => JsonResult::Resp(jsonresp(json!(res), json!(id))),
+            Err(err) => JsonResult::Err(jsonerr(InternalError, Some(err.to_string()), json!(id))),
+        }
     }
 }
 

src/client.rs

@@ -115,7 +115,6 @@ impl Client {
         pub_key: jubjub::SubgroupPoint,
         amount: u64,
     ) -> Result<()> {
-
         debug!(target: "CLIENT", "Start transfer {}", amount);
 
         if amount == 0 {
@@ -136,7 +135,6 @@ impl Client {
         asset_id: jubjub::Fr,
         clear_input: bool,
     ) -> Result<()> {
-
         debug!(target: "CLIENT", "Start send {}", amount);
 
         let slab = self
@@ -145,7 +143,6 @@ impl Client {
 
         self.gateway.put_slab(slab).await?;
 
-        
         debug!(target: "CLIENT", "End send {}", amount);
 
         Ok(())
@@ -158,7 +155,6 @@ impl Client {
         asset_id: jubjub::Fr,
         clear_input: bool,
     ) -> Result<Slab> {
-
         debug!(target: "CLIENT", "Start build slab from tx");
 
         let mut clear_inputs: Vec<tx::TransactionBuilderClearInputInfo> = vec![];
@@ -208,9 +204,8 @@ impl Client {
         asset_id: jubjub::Fr,
         outputs: &mut Vec<tx::TransactionBuilderOutputInfo>,
     ) -> Result<Vec<tx::TransactionBuilderInputInfo>> {
-
         debug!(target: "CLIENT", "Start build inputs");
-        
+
         let mut inputs: Vec<tx::TransactionBuilderInputInfo> = vec![];
         let mut inputs_value: u64 = 0;
 
@@ -263,8 +258,7 @@ impl Client {
     ) -> Result<()> {
         // start subscribing
         debug!(target: "CLIENT", "Start subscriber for cashier");
-        let gateway_slabs_sub: GatewaySlabsSubscriber =
-            self.gateway.start_subscriber().await?;
+        let gateway_slabs_sub: GatewaySlabsSubscriber = self.gateway.start_subscriber().await?;
 
         let secret_key = self.main_keypair.private;
         let state = self.state.clone();
@@ -298,8 +292,7 @@ impl Client {
     pub async fn connect_to_subscriber(&self) -> Result<()> {
         // start subscribing
         debug!(target: "CLIENT", "Start subscriber");
-        let gateway_slabs_sub: GatewaySlabsSubscriber =
-            self.gateway.start_subscriber().await?;
+        let gateway_slabs_sub: GatewaySlabsSubscriber = self.gateway.start_subscriber().await?;
 
         let (notify, _) = async_channel::unbounded::<(jubjub::SubgroupPoint, u64)>();
 
@@ -340,6 +333,10 @@ impl Client {
     //    self.state.lock().await.wallet.get_token_ids()
     //}
 
+    pub async fn token_id_exists(&self, token_id: &jubjub::Fr) -> Result<bool> {
+        self.state.lock().await.wallet.token_id_exists(token_id)
+    }
+
     pub async fn get_token_id(&self) -> Result<Vec<jubjub::Fr>> {
         self.state.lock().await.wallet.get_token_id()
     }
@@ -441,7 +438,6 @@ impl State {
                         witness: witness.clone(),
                     };
 
-
                     self.wallet.put_own_coins(own_coin)?;
                     let pub_key = zcash_primitives::constants::SPENDING_KEY_GENERATOR * secret;
 

src/util/token_list.rs

@@ -87,7 +87,7 @@ impl SolTokenList {
 }
 
 pub struct DrkTokenList {
-    drk_tokenlist: HashMap<String, jubjub::Fr>,
+    pub drk_tokenlist: HashMap<String, jubjub::Fr>,
 }
 
 impl DrkTokenList {

src/wallet/walletdb.rs

@@ -130,7 +130,6 @@ impl WalletDb {
     }
 
     pub fn get_own_coins(&self) -> Result<OwnCoins> {
-
         debug!(target: "WALLETDB", "Get own coins");
 
         let conn = Connection::open(&self.path)?;
@@ -274,7 +273,6 @@ impl WalletDb {
         coin_id: u64,
         witness: IncrementalWitness<MerkleNode>,
     ) -> Result<()> {
-
         debug!(target: "WALLETDB", "Updating witness");
 
         let conn = Connection::open(&self.path)?;
@@ -366,6 +364,16 @@ impl WalletDb {
         Ok(token_ids)
     }
 
+    pub fn token_id_exists(&self, token_id: &jubjub::Fr) -> Result<bool> {
+        debug!(target: "WALLETDB", "Check tokenID exists");
+        let conn = Connection::open(&self.path)?;
+        conn.pragma_update(None, "key", &self.password)?;
+        let id = self.get_value_serialized(token_id)?;
+        let mut stmt = conn.prepare("SELECT * FROM coins WHERE asset_id > :id")?;
+        let id_check = stmt.exists([id])?;
+        Ok(id_check)
+    }
+
     pub fn test_wallet(&self) -> Result<()> {
         let conn = Connection::open(&self.path)?;
         conn.pragma_update(None, "key", &self.password)?;