Update ui to display a token dropdown

crates/common/src/raindex_client/add_orders.rs

@@ -87,17 +87,10 @@ mod tests {
     mod non_wasm {
         use super::*;
         use crate::raindex_client::tests::{get_test_yaml, CHAIN_ID_1_ORDERBOOK_ADDRESS};
-        use alloy::{
-            hex::encode_prefixed,
-            primitives::{Address, B256, U256},
-            sol_types::SolValue,
-        };
-        use alloy_ethers_typecast::rpc::Response;
+        use alloy::primitives::{Address, U256};
         use httpmock::MockServer;
-        use rain_orderbook_app_settings::spec_version::SpecVersion;
-        use rain_orderbook_bindings::IOrderBookV4::IO;
         use serde_json::json;
-        use std::{collections::HashMap, str::FromStr};
+        use std::str::FromStr;
 
         #[tokio::test]
         async fn test_get_transaction_add_orders() {

crates/js_api/src/gui/mod.rs

@@ -18,8 +18,12 @@ use rain_orderbook_common::{
     erc20::ERC20,
 };
 use serde::{Deserialize, Serialize};
-use std::collections::BTreeMap;
 use std::io::prelude::*;
+use std::{
+    collections::BTreeMap,
+    sync::{Arc, RwLock},
+};
+use strict_yaml_rust::StrictYaml;
 use thiserror::Error;
 use wasm_bindgen_utils::{impl_wasm_traits, prelude::*, wasm_export};
 
@@ -98,10 +102,8 @@ impl DotrainOrderGui {
         )]
         dotrain: String,
     ) -> Result<Vec<String>, GuiError> {
-        let dotrain_order = DotrainOrder::create(dotrain.clone(), None).await?;
-        Ok(GuiCfg::parse_deployment_keys(
-            dotrain_order.dotrain_yaml().documents.clone(),
-        )?)
+        let documents = DotrainOrderGui::get_yaml_documents(&dotrain)?;
+        Ok(GuiCfg::parse_deployment_keys(documents)?)
     }
 
     /// Creates a new GUI instance for managing a specific deployment configuration.
@@ -402,10 +404,8 @@ impl DotrainOrderGui {
     pub async fn get_strategy_details(
         #[wasm_export(param_description = "Complete dotrain YAML content")] dotrain: String,
     ) -> Result<NameAndDescriptionCfg, GuiError> {
-        let dotrain_order = DotrainOrder::create(dotrain.clone(), None).await?;
-        let details =
-            GuiCfg::parse_strategy_details(dotrain_order.dotrain_yaml().documents.clone())?;
-        Ok(details)
+        let documents = DotrainOrderGui::get_yaml_documents(&dotrain)?;
+        Ok(GuiCfg::parse_strategy_details(documents)?)
     }
 
     /// Gets metadata for all deployments defined in the configuration.
@@ -443,10 +443,8 @@ impl DotrainOrderGui {
     pub async fn get_deployment_details(
         #[wasm_export(param_description = "Complete dotrain YAML content")] dotrain: String,
     ) -> Result<BTreeMap<String, NameAndDescriptionCfg>, GuiError> {
-        let dotrain_order = DotrainOrder::create(dotrain.clone(), None).await?;
-        Ok(GuiCfg::parse_deployment_details(
-            dotrain_order.dotrain_yaml().documents.clone(),
-        )?)
+        let documents = DotrainOrderGui::get_yaml_documents(&dotrain)?;
+        Ok(GuiCfg::parse_deployment_details(documents)?)
     }
 
     /// Gets metadata for a specific deployment by key.
@@ -592,6 +590,15 @@ impl DotrainOrderGui {
         Ok(rainlang)
     }
 }
+impl DotrainOrderGui {
+    pub fn get_yaml_documents(dotrain: &str) -> Result<Vec<Arc<RwLock<StrictYaml>>>, GuiError> {
+        let frontmatter = RainDocument::get_front_matter(&dotrain)
+            .unwrap_or("")
+            .to_string();
+        let dotrain_yaml = DotrainYaml::new(vec![frontmatter.clone()], false)?;
+        Ok(dotrain_yaml.documents)
+    }
+}
 
 #[derive(Error, Debug)]
 pub enum GuiError {

crates/js_api/src/gui/select_tokens.rs

@@ -309,9 +309,13 @@ impl DotrainOrderGui {
             .await;
         results.extend(fetched_results);
         results.sort_by(|a, b| {
-            let na = a.name.to_lowercase();
-            let nb = b.name.to_lowercase();
-            na.cmp(&nb).then_with(|| a.address.cmp(&b.address))
+            a.address
+                .to_string()
+                .to_lowercase()
+                .cmp(&b.address.to_string().to_lowercase())
+        });
+        results.dedup_by(|a, b| {
+            a.address.to_string().to_lowercase() == b.address.to_string().to_lowercase()
         });
 
         Ok(results)
@@ -553,26 +557,18 @@ mod tests {
             assert_eq!(tokens.len(), 4);
             assert_eq!(
                 tokens[0].address.to_string(),
-                "0xc2132D05D31c914a87C6611C10748AEb04B58e8F"
-            );
-            assert_eq!(
-                tokens[1].address.to_string(),
-                "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063"
-            );
-            assert_eq!(
-                tokens[2].address.to_string(),
                 "0x0000000000000000000000000000000000000001"
             );
-            assert_eq!(tokens[2].decimals, 18);
-            assert_eq!(tokens[2].name, "Token 3");
-            assert_eq!(tokens[2].symbol, "T3");
+            assert_eq!(tokens[0].decimals, 18);
+            assert_eq!(tokens[0].name, "Token 3");
+            assert_eq!(tokens[0].symbol, "T3");
             assert_eq!(
-                tokens[3].address.to_string(),
+                tokens[1].address.to_string(),
                 "0x0000000000000000000000000000000000000002"
             );
-            assert_eq!(tokens[3].decimals, 6);
-            assert_eq!(tokens[3].name, "Token 4");
-            assert_eq!(tokens[3].symbol, "T4");
+            assert_eq!(tokens[1].decimals, 6);
+            assert_eq!(tokens[1].name, "Token 4");
+            assert_eq!(tokens[1].symbol, "T4");
         }
     }
 

crates/settings/src/remote/tokens.rs

@@ -35,6 +35,7 @@ pub struct Tokens {
     pub keywords: Vec<String>,
     pub version: Version,
     pub tokens: Vec<Token>,
+    #[serde(rename = "logoURI")]
     pub logo_uri: String,
 }
 
@@ -43,28 +44,31 @@ impl Token {
         self,
         networks: &HashMap<String, NetworkCfg>,
         document: Arc<RwLock<StrictYaml>>,
-    ) -> Result<TokenCfg, RemoteTokensError> {
-        let network = networks
+    ) -> Result<Option<TokenCfg>, RemoteTokensError> {
+        match networks
             .values()
             .find(|network| network.chain_id == self.chain_id)
-            .ok_or(RemoteTokensError::NetworkNotFound(format!(
-                "network with chain_id {}",
-                self.chain_id
-            )))
-            .cloned()?;
-
-        let token_cfg = TokenCfg {
-            document: document.clone(),
-            key: self.name.to_lowercase().replace(' ', "-").clone(),
-            network: Arc::new(network),
-            address: Address::from_str(&self.address)
-                .map_err(|e| RemoteTokensError::ParseTokenAddressError(e.to_string()))?,
-            decimals: Some(self.decimals as u8),
-            label: Some(self.name.clone()),
-            symbol: Some(self.symbol),
-        };
-
-        Ok(token_cfg)
+        {
+            Some(network) => {
+                let token_cfg = TokenCfg {
+                    document: document.clone(),
+                    key: format!(
+                        "{}-{}-{}",
+                        network.key,
+                        self.name.replace(' ', "-").clone(),
+                        self.address.to_lowercase()
+                    ),
+                    network: Arc::new(network.clone()),
+                    address: Address::from_str(&self.address)
+                        .map_err(|e| RemoteTokensError::ParseTokenAddressError(e.to_string()))?,
+                    decimals: Some(self.decimals as u8),
+                    label: Some(self.name.clone()),
+                    symbol: Some(self.symbol),
+                };
+                Ok(Some(token_cfg))
+            }
+            None => Ok(None),
+        }
     }
 }
 

crates/settings/src/remote_tokens.rs

@@ -1,4 +1,4 @@
-use crate::remote::tokens::{RemoteTokensError, Tokens};
+use crate::remote::tokens::{RemoteTokensError, Token, Tokens};
 use crate::yaml::context::Context;
 use crate::yaml::{
     default_document, optional_vec, require_string, FieldErrorKind, YamlError, YamlParseableValue,
@@ -41,17 +41,24 @@ impl RemoteTokensCfg {
                 .json::<Tokens>()
                 .await?;
 
+            let mut unique_tokens: HashMap<(u32, String), Token> = HashMap::new();
             for token in &tokens_res.tokens {
-                let token_cfg = token
-                    .clone()
-                    .try_into_token_cfg(networks, remote_tokens.document.clone())?;
+                let token_id = (token.chain_id, token.address.to_lowercase());
+                unique_tokens.insert(token_id, token.clone());
+            }
 
-                if tokens.contains_key(&token_cfg.key) {
-                    return Err(ParseRemoteTokensError::ConflictingTokens(
-                        token_cfg.key.clone(),
-                    ));
+            for token in unique_tokens.values() {
+                if let Some(token_cfg) = token
+                    .clone()
+                    .try_into_token_cfg(networks, remote_tokens.document.clone())?
+                {
+                    if tokens.contains_key(&token_cfg.key) {
+                        return Err(ParseRemoteTokensError::ConflictingTokens(
+                            token_cfg.key.clone(),
+                        ));
+                    }
+                    tokens.insert(token_cfg.key.clone(), token_cfg);
                 }
-                tokens.insert(token_cfg.key.clone(), token_cfg);
             }
         }
 
@@ -235,7 +242,7 @@ using-tokens-from:
             "decimals": 18
         }
     ],
-    "logoUri": "http://localhost.com"
+    "logoURI": "http://localhost.com"
 }
         "#;
         server
@@ -279,17 +286,19 @@ using-tokens-from:
 
         assert_eq!(tokens.len(), 2_usize);
 
-        let token = tokens.get("token1").unwrap();
-        assert_eq!(token.key, "token1");
+        let token1_key = "remote-network-Token1-0x0000000000000000000000000000000000000001";
+        let token = tokens.get(token1_key).unwrap();
+        assert_eq!(token.key, token1_key);
         assert_eq!(
             token.address,
             Address::from_str("0x0000000000000000000000000000000000000001").unwrap()
         );
         assert_eq!(token.network.key, "remote-network");
         assert_eq!(token.network.chain_id, 123);
 
-        let token = tokens.get("token2").unwrap();
-        assert_eq!(token.key, "token2");
+        let token2_key = "remote2-network-Token2-0x0000000000000000000000000000000000000002";
+        let token = tokens.get(token2_key).unwrap();
+        assert_eq!(token.key, token2_key);
         assert_eq!(
             token.address,
             Address::from_str("0x0000000000000000000000000000000000000002").unwrap()
@@ -343,7 +352,7 @@ using-tokens-from:
             "decimals": 18
         }
     ],
-    "logoUri": "http://localhost.com"
+    "logoURI": "http://localhost.com"
 }
         "#;
 
@@ -373,7 +382,7 @@ using-tokens-from:
             "decimals": 18
         }
     ],
-    "logoUri": "http://localhost.com"
+    "logoURI": "http://localhost.com"
 }
         "#;
 
@@ -452,17 +461,19 @@ using-tokens-from:
 
         assert_eq!(tokens.len(), 4_usize);
 
-        let token = tokens.get("token3").unwrap();
-        assert_eq!(token.key, "token3");
+        let token3_key = "remote3-network-Token3-0x0000000000000000000000000000000000000003";
+        let token = tokens.get(token3_key).unwrap();
+        assert_eq!(token.key, token3_key);
         assert_eq!(
             token.address,
             Address::from_str("0x0000000000000000000000000000000000000003").unwrap()
         );
         assert_eq!(token.network.key, "remote3-network");
         assert_eq!(token.network.chain_id, 345);
 
-        let token = tokens.get("token4").unwrap();
-        assert_eq!(token.key, "token4");
+        let token4_key = "remote4-network-Token4-0x0000000000000000000000000000000000000004";
+        let token = tokens.get(token4_key).unwrap();
+        assert_eq!(token.key, token4_key);
         assert_eq!(
             token.address,
             Address::from_str("0x0000000000000000000000000000000000000004").unwrap()