generate_id: added NetworkName. disabled parse_wrapped_token

src/bin/cashierd.rs

@@ -206,7 +206,7 @@ impl Cashierd {
         let result: Result<String> = async {
             Self::validate_token_id(&network, token_id)?;
 
-            let asset_id = generate_id(token_id)?;
+            let asset_id = generate_id(token_id, &network)?;
 
             let drk_pub_key = bs58::decode(&drk_pub_key).into_vec()?;
             let drk_pub_key: jubjub::SubgroupPoint = deserialize(&drk_pub_key)?;
@@ -300,7 +300,7 @@ impl Cashierd {
         let result: Result<String> = async {
             Self::validate_token_id(&network, token)?;
 
-            let asset_id = generate_id(&token)?;
+            let asset_id = generate_id(&token, &network)?;
             let address = serialize(&address.to_string());
 
             let cashier_public: jubjub::SubgroupPoint;

src/bin/darkfid.rs

@@ -17,7 +17,7 @@ use drk::{
         rpcserver::{listen_and_serve, RequestHandler, RpcServerConfig},
     },
     serial::{deserialize, serialize},
-    util::{assign_id, expand_path, join_config_path, parse_wrapped_token, TokenList},
+    util::{assign_id, expand_path, join_config_path, TokenList},
     wallet::WalletDb,
     Result,
 };
@@ -331,23 +331,28 @@ impl Darkfid {
 
         let amount = amount.as_f64().unwrap();
 
-        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))),
-        }
+        //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,
+        ));
     }
 }
 

src/util/mod.rs

@@ -4,6 +4,6 @@ pub mod path;
 pub mod token_list;
 
 pub use net_name::NetworkName;
-pub use parse::{generate_id, parse_network, parse_params, parse_wrapped_token};
+pub use parse::{assign_id, generate_id, parse_params};
 pub use path::{expand_path, join_config_path};
 pub use token_list::TokenList;

src/util/parse.rs

@@ -55,12 +55,14 @@ use std::str::FromStr;
 
 // here we hash the alphanumeric token ID. if it fails, we change the last 4 bytes and hash it
 // again, and keep repeating until it works.
-pub fn generate_id(tkn_str: &str) -> Result<jubjub::Fr> {
-    if bs58::decode(tkn_str).into_vec().is_err() {
+pub fn generate_id(tkn_str: &str, network: &NetworkName) -> Result<jubjub::Fr> {
+    let mut id_string = network.to_string();
+    id_string.push_str(tkn_str);
+    if bs58::decode(id_string.clone()).into_vec().is_err() {
         // TODO: make this an error
         debug!(target: "PARSE ID", "COULD NOT DECODE STR");
     }
-    let mut data = bs58::decode(tkn_str).into_vec().unwrap();
+    let mut data = bs58::decode(id_string).into_vec().unwrap();
 
     let token_id = match deserialize::<jubjub::Fr>(&data) {
         Ok(v) => v,
@@ -87,27 +89,27 @@ pub fn generate_id(tkn_str: &str) -> Result<jubjub::Fr> {
     Ok(token_id)
 }
 
-pub fn parse_wrapped_token(token: &str, tokenlist: TokenList) -> Result<jubjub::Fr> {
-    match token.to_lowercase().as_str() {
-        "sol" => {
-            let id = "So11111111111111111111111111111111111111112";
-            let token_id = generate_id(id)?;
-            Ok(token_id)
-        }
-        "btc" => Err(Error::TokenParseError),
-        tkn => {
-            // (== 44) can represent a Solana base58 token mint address
-            let id = if token.len() == 44 {
-                token.to_string()
-            } else {
-                symbol_to_id(tkn, tokenlist)?
-            };
-
-            let token_id = generate_id(&id)?;
-            Ok(token_id)
-        }
-    }
-}
+//pub fn parse_wrapped_token(token: &str, tokenlist: TokenList) -> Result<jubjub::Fr> {
+//    match token.to_lowercase().as_str() {
+//        "sol" => {
+//            let id = "So11111111111111111111111111111111111111112";
+//            let token_id = generate_id(id)?;
+//            Ok(token_id)
+//        }
+//        "btc" => Err(Error::TokenParseError),
+//        tkn => {
+//            // (== 44) can represent a Solana base58 token mint address
+//            let id = if token.len() == 44 {
+//                token.to_string()
+//            } else {
+//                symbol_to_id(tkn, tokenlist)?
+//            };
+//
+//            let token_id = generate_id(&id)?;
+//            Ok(token_id)
+//        }
+//    }
+//}
 
 pub fn assign_id(network: &str, token: &str, tokenlist: TokenList) -> Result<String> {
     match NetworkName::from_str(network)? {