bin/darkfid2, drk2: added get_token_id() method

src/bin/cashierd2.rs

@@ -3,7 +3,6 @@ use log::*;
 use std::path::PathBuf;
 
 use clap::clap_app;
-use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
 use simplelog::{
     CombinedLogger, Config as SimLogConfig, ConfigBuilder, LevelFilter, TermLogger, TerminalMode,
@@ -22,7 +21,6 @@ use drk::{
         jsonrpc::{error as jsonerr, response as jsonresp},
         jsonrpc::{ErrorCode::*, JsonRequest, JsonResult},
     },
-    serial::{deserialize, serialize},
     service::{bridge, CashierService},
     util::join_config_path,
     wallet::{CashierDb, WalletDb},
@@ -35,7 +33,7 @@ struct Cashierd {
     config: CashierdConfig,
     client_wallet: Arc<WalletDb>,
     cashier_wallet: Arc<CashierDb>,
-    //bridge: Arc<bridge::Bridge>,
+    bridge: Arc<bridge::Bridge>,
     // clientdb:
     // mint_params:
     // spend_params:
@@ -52,7 +50,7 @@ impl Cashierd {
             &PathBuf::from(config.cashierdb_path.clone()),
             config.password.clone(),
         )?;
-        //let bridge = bridge::Bridge::new();
+        let bridge = bridge::Bridge::new();
 
         Ok(Self {
             verbose,
@@ -123,6 +121,16 @@ impl Cashierd {
         return JsonResult::Err(jsonerr(MethodNotFound, None, req.id));
     }
 
+    // TODO: change token type away from jubjub::Fr
+    // TODO: reply with deposit address
+
+    // 1. deserialize asset_id and dark pubkey
+    // 2. get deposit coin keys
+    // 3. create bridge subscription
+    // 4. send over async channel
+    // 5. create receiver
+    // 6. match the payload
+    // 7. send the reply
     async fn deposit(self, id: Value, params: Value) -> JsonResult {
         debug!(target: "CASHIER", "Received deposit request");
 
@@ -131,21 +139,23 @@ impl Cashierd {
             return JsonResult::Err(jsonerr(InvalidParams, None, id));
         }
 
-        let args = params.as_array().expect("Params is empty");
-
-        if args.len() != 3 {
-            return JsonResult::Err(jsonerr(InvalidParams, None, id));
-        }
+        let args = params.as_array().unwrap();
 
         debug!(target: "CASHIER", "Processing input");
         let _network = &args[0];
+        let token = &args[1];
+        let pubkey = &args[2];
 
-        if args[1].as_str().is_none() {
+        if token.as_str().is_none() {
             return JsonResult::Err(jsonerr(InvalidParams, None, id));
         }
 
-        // TODO: change token type away from jubjub::Fr
-        // TODO: reply with deposit address
+        //let token = if deserialize(token.as_bytes()).is_err() {
+        //    // do something
+        //} else {
+        //    // do something else
+        //    // token.unwrap()
+        //};
 
         //let _token: jubjub::Fr = deserialize(&args[1].as_str().unwrap().as_bytes()).unwrap();
 

src/bin/darkfid2.rs

@@ -1,5 +1,5 @@
-use async_std::sync::Arc;
 use log::*;
+use std::fs;
 use std::path::PathBuf;
 
 use clap::clap_app;
@@ -8,6 +8,8 @@ use simplelog::{
     CombinedLogger, Config as SimLogConfig, ConfigBuilder, LevelFilter, TermLogger, TerminalMode,
     WriteLogger,
 };
+
+use async_std::sync::Arc;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::TcpListener;
 
@@ -61,6 +63,7 @@ impl Darkfid {
             Some("create_wallet") => return self.create_wallet(req.id, req.params).await,
             Some("key_gen") => return self.key_gen(req.id, req.params).await,
             Some("get_key") => return self.get_key(req.id, req.params).await,
+            Some("get_token_id") => return self.get_token_id(req.id, req.params).await,
             Some("deposit") => return self.deposit(req.id, req.params).await,
             Some("withdraw") => return self.withdraw(req.id, req.params).await,
             Some("transfer") => return self.transfer(req.id, req.params).await,
@@ -114,6 +117,34 @@ impl Darkfid {
         }
     }
 
+    // --> {"jsonrpc": "2.0", "method": "get_token_id",
+    //      "params": [token],
+    //      "id": 42}
+    // <-- {"result": "Ht5G1RhkcKnpLVLMhqJc5aqZ4wYUEbxbtZwGCVbgU7DL"}
+    async fn get_token_id(self, id: Value, params: Value) -> JsonResult {
+        let args = params.as_array().unwrap();
+        let symbol = &args[0];
+
+        if symbol.as_str().is_none() {
+            return JsonResult::Err(jsonerr(InvalidParams, None, id));
+        };
+
+        let symbol = symbol.as_str().unwrap().to_uppercase();
+
+        let file_contents =
+            fs::read_to_string("token/solanatokenlist.json").expect("Can't find tokenlist file");
+        let root: Value = serde_json::from_str(&file_contents).unwrap();
+        let tokens = root["tokens"].as_array().unwrap();
+
+        for item in tokens {
+            if item["symbol"] == symbol {
+                let address = &item["address"];
+                return JsonResult::Resp(jsonresp(json!(address), id));
+            }
+        }
+        return JsonResult::Err(jsonerr(InvalidParams, None, id));
+    }
+
     // --> {"jsonrpc": "2.0", "method": "deposit",
     //      "params": [network, token, publickey],
     //      "id": 42}
@@ -128,6 +159,11 @@ impl Darkfid {
 
         let network = &args[0];
         let token = &args[1];
+
+        if token.as_str().is_none() {
+            return JsonResult::Err(jsonerr(InvalidParams, None, id));
+        };
+
         // TODO: Optional sanity checking here, but cashier *must* do so too.
 
         let pubkey: String;

src/bin/drk2.rs

@@ -75,6 +75,13 @@ impl Drk {
         Ok(self.request(req).await?)
     }
 
+    // --> {"jsonrpc": "2.0", "method": "get_key", "params": ["usdc"], "id": 42}
+    // <-- {"jsonrpc": "2.0", "result": "vdNS7oBj7KvsMWWmo9r96SV4SqATLrGsH2a3PGpCfJC", "id": 42}
+    async fn get_token_id(&self, token: &str) -> Result<Value> {
+        let req = jsonrpc::request(json!("get_token_id"), json!([token]));
+        Ok(self.request(req).await?)
+    }
+
     // --> {"jsonrpc": "2.0", "method": "deposit", "params": ["solana", "usdc"], "id": 42}
     // <-- {"jsonrpc": "2.0", "result": "Ht5G1RhkcKnpLVLMhqJc5aqZ4wYUEbxbtZwGCVbgU7DL", "id": 42}
     async fn deposit(&self, network: &str, asset: &str) -> Result<Value> {
@@ -134,6 +141,15 @@ async fn start(config: &DrkConfig, options: ArgMatches<'_>) -> Result<()> {
         }
     }
 
+    if let Some(matches) = options.subcommand_matches("id") {
+        let token = matches.value_of("TOKEN").unwrap();
+
+        let reply = client.get_token_id(&token).await?;
+
+        println!("Server replied: {}", &reply.to_string());
+        return Ok(());
+    }
+
     if let Some(matches) = options.subcommand_matches("deposit") {
         let network = matches.value_of("network").unwrap().to_lowercase();
         let token = matches.value_of("TOKEN").unwrap();
@@ -197,6 +213,11 @@ async fn main() -> Result<()> {
             (@arg keygen: --keygen "Generate wallet keypair")
             (@arg address: --address "Get wallet address")
         )
+        (@subcommand id =>
+            (about: "Get hexidecimal ID for token symbol")
+            (@arg TOKEN: +required
+                    "Which token to query (BTC/SOL/USDC/...)")
+        )
         (@subcommand deposit =>
             (about: "Deposit clear assets for Dark assets")
             (@arg network: +required +takes_value --network