darkfid: Remove tokenlists logic.

bin/darkfid/src/main.rs

@@ -22,7 +22,7 @@ use darkfi::{
         ValidatorState, MAINNET_GENESIS_HASH_BYTES, MAINNET_GENESIS_TIMESTAMP,
         TESTNET_GENESIS_HASH_BYTES, TESTNET_GENESIS_TIMESTAMP,
     },
-    crypto::{address::Address, keypair::PublicKey, token_list::DrkTokenList},
+    crypto::{address::Address, keypair::PublicKey},
     net,
     net::P2pPtr,
     node::Client,
@@ -256,18 +256,9 @@ async fn realmain(args: Args, ex: Arc<Executor<'_>>) -> Result<()> {
         }
     };
 
-    debug!("Parsing token lists...");
-    let tokenlist = Arc::new(DrkTokenList::new(&[
-        ("drk", include_bytes!("../../../contrib/token/darkfi_token_list.min.json")),
-        ("btc", include_bytes!("../../../contrib/token/bitcoin_token_list.min.json")),
-        ("eth", include_bytes!("../../../contrib/token/erc20_token_list.min.json")),
-        ("sol", include_bytes!("../../../contrib/token/solana_token_list.min.json")),
-    ])?);
-    debug!("Finished parsing token lists");
-
     // TODO: sqldb init cleanup
     // Initialize Client
-    let client = Arc::new(Client::new(wallet, tokenlist).await?);
+    let client = Arc::new(Client::new(wallet).await?);
 
     // Parse cashier addresses
     let mut cashier_pubkeys = vec![];

bin/darkfid/src/rpc_tx.rs

@@ -4,12 +4,9 @@ use log::{error, warn};
 use serde_json::{json, Value};
 
 use darkfi::{
-    crypto::{address::Address, keypair::PublicKey, token_id::generate_id},
-    rpc::jsonrpc::{
-        ErrorCode::{InternalError, InvalidParams},
-        JsonError, JsonResponse, JsonResult,
-    },
-    util::{decode_base10, serial::serialize, NetworkName},
+    crypto::{address::Address, keypair::PublicKey, token_id},
+    rpc::jsonrpc::{ErrorCode::InvalidParams, JsonError, JsonResponse, JsonResult},
+    util::serial::serialize,
 };
 
 use super::Darkfid;
@@ -19,28 +16,31 @@ impl Darkfid {
     // RPCAPI:
     // Transfer a given amount of some token to the given address.
     // Returns a transaction ID upon success.
-    // --> {"jsonrpc": "2.0", "method": "tx.transfer", "params": ["darkfi" "gdrk", "1DarkFi...", 12.0], "id": 1}
+    //
+    // * `dest_addr` -> Recipient's DarkFi address
+    // * `token_id` -> ID of the token to send
+    // * `12345` -> Amount in `u64` of the funds to send
+    //
+    // --> {"jsonrpc": "2.0", "method": "tx.transfer", "params": ["dest_addr", "token_id", 12345], "id": 1}
     // <-- {"jsonrpc": "2.0", "result": "txID...", "id": 1}
     pub async fn transfer(&self, id: Value, params: &[Value]) -> JsonResult {
-        if params.len() != 4 ||
+        if params.len() != 3 ||
             !params[0].is_string() ||
             !params[1].is_string() ||
-            !params[2].is_string() ||
-            !params[3].is_f64()
+            !params[2].is_u64()
         {
             return JsonError::new(InvalidParams, None, id).into()
         }
 
-        let network = params[0].as_str().unwrap();
-        let token = params[1].as_str().unwrap();
-        let address = params[2].as_str().unwrap();
-        let amount = params[3].as_f64().unwrap();
-
         if !(*self.synced.lock().await) {
             error!("transfer(): Blockchain is not yet synced");
             return server_error(RpcError::NotYetSynced, id)
         }
 
+        let address = params[0].as_str().unwrap();
+        let token = params[1].as_str().unwrap();
+        let amount = params[2].as_u64().unwrap();
+
         let address = match Address::from_str(address) {
             Ok(v) => v,
             Err(e) => {
@@ -57,43 +57,14 @@ impl Darkfid {
             }
         };
 
-        let amount = amount.to_string();
-        let amount = match decode_base10(&amount, 8, true) {
-            Ok(v) => v,
-            Err(e) => {
-                error!("transfer(): Failed parsing amount from string: {}", e);
-                return server_error(RpcError::InvalidAmountParam, id)
-            }
-        };
-        let amount: u64 = match amount.try_into() {
-            Ok(v) => v,
-            Err(e) => {
-                error!("transfer(): Failed converting biguint to u64: {}", e);
-                return JsonError::new(InternalError, None, id).into()
-            }
-        };
-
-        let network = match NetworkName::from_str(network) {
+        let token_id = match token_id::parse_b58(token) {
             Ok(v) => v,
             Err(e) => {
-                error!("transfer(): Failed parsing NetworkName: {}", e);
-                return server_error(RpcError::NetworkNameError, id)
+                error!("transfer(): Failed parsing Token ID from string: {}", e);
+                return server_error(RpcError::ParseError, id)
             }
         };
 
-        let token_id =
-            if let Some(tok) = self.client.tokenlist.by_net[&network].get(token.to_uppercase()) {
-                tok.drk_address
-            } else {
-                match generate_id(&network, token) {
-                    Ok(v) => v,
-                    Err(e) => {
-                        error!("transfer(): Failed generate_id(): {}", e);
-                        return JsonError::new(InternalError, None, id).into()
-                    }
-                }
-            };
-
         let tx = match self
             .client
             .build_transaction(

bin/darkfid/src/rpc_wallet.rs

@@ -1,6 +1,5 @@
 use fxhash::FxHashMap;
-use log::{error, warn};
-use num_bigint::BigUint;
+use log::error;
 use pasta_curves::group::ff::PrimeField;
 use serde_json::{json, Value};
 
@@ -13,7 +12,6 @@ use darkfi::{
         ErrorCode::{InternalError, InvalidParams},
         JsonError, JsonResponse, JsonResult,
     },
-    util::{decode_base10, encode_base10, NetworkName},
 };
 
 use super::Darkfid;
@@ -191,10 +189,10 @@ impl Darkfid {
     }
 
     // RPCAPI:
-    // Queries the wallet for known balances.
-    // Returns a map of balances, indexed by `network`, and token ID.
+    /// Queries the wallet for known tokens with active balances.
+    /// Returns a map of balances, indexed by the token ID.
     // --> {"jsonrpc": "2.0", "method": "wallet.get_balances", "params": [], "id": 1}
-    // <-- {"jsonrpc": "2.0", "result": [{"btc": [100, "Bitcoin"]}, {...}], "id": 1}
+    // <-- {"jsonrpc": "2.0", "result": [{"1Foobar...": 100}, {...}]", "id": 1}
     pub async fn get_balances(&self, id: Value, _params: &[Value]) -> JsonResult {
         let balances = match self.client.get_balances().await {
             Ok(v) => v,
@@ -204,50 +202,18 @@ impl Darkfid {
             }
         };
 
-        // k: ticker/drk_addr, v: (amount, network, net_addr, drk_addr)
-        let mut ret: FxHashMap<String, (String, String, String, String)> = FxHashMap::default();
+        // k: token_id, v: [amount]
+        let mut ret: FxHashMap<String, u64> = FxHashMap::default();
 
         for balance in balances.list {
-            let drk_addr = bs58::encode(balance.token_id.to_repr()).into_string();
-            let mut amount = BigUint::from(balance.value);
+            let token_id = bs58::encode(balance.token_id.to_repr()).into_string();
+            let mut amount = balance.value;
 
-            let (net_name, net_addr) =
-                if let Some((net, tok)) = self.client.tokenlist.by_addr.get(&drk_addr) {
-                    (net, tok.net_address.clone())
-                } else {
-                    warn!("Could not find network name and token info for {}", drk_addr);
-                    (&NetworkName::DarkFi, "unknown".to_string())
-                };
-
-            let mut ticker = None;
-            for (k, v) in self.client.tokenlist.by_net[net_name].0.iter() {
-                if v.net_address == net_addr {
-                    ticker = Some(k.clone());
-                    break
-                }
-            }
-
-            if ticker.is_none() {
-                ticker = Some(drk_addr.clone())
-            }
-
-            let ticker = ticker.unwrap();
-
-            if let Some(prev) = ret.get(&ticker) {
-                // TODO: We shouldn't be hardcoding everything to 8 decimals.
-                let prev_amnt = match decode_base10(&prev.0, 8, false) {
-                    Ok(v) => v,
-                    Err(e) => {
-                        error!("Failed to decode_base10(): {}", e);
-                        return JsonError::new(InternalError, None, id).into()
-                    }
-                };
-
-                amount += prev_amnt;
+            if let Some(prev) = ret.get(&token_id) {
+                amount += prev;
             }
 
-            let amount = encode_base10(amount, 8);
-            ret.insert(ticker, (amount, net_name.to_string(), net_addr, drk_addr));
+            ret.insert(token_id, amount);
         }
 
         JsonResponse::new(json!(ret), id).into()