@wlfi-agent/cli 1.4.16 → 1.4.18

package/crates/vault-cli-admin/src/shared_config.rs

@@ -392,9 +392,9 @@ mod tests {
             r#"{
   "chains": {},
   "tokens": {},
-  "chainId": 11155111,
-  "chainName": "sepolia",
-  "rpcUrl": "https://rpc.sepolia.example"
+  "chainId": 56,
+  "chainName": "bsc",
+  "rpcUrl": "https://rpc.bsc.example"
 }
 "#,
         )
@@ -405,11 +405,11 @@ mod tests {
         assert!(config.chains.contains_key("bsc"));
         assert!(config.tokens.contains_key("usd1"));
         assert!(config.tokens.contains_key("bnb"));
-        assert_eq!(config.chain_id, Some(11155111));
-        assert_eq!(config.chain_name.as_deref(), Some("sepolia"));
+        assert_eq!(config.chain_id, Some(56));
+        assert_eq!(config.chain_name.as_deref(), Some("bsc"));
         assert_eq!(
             config.rpc_url.as_deref(),
-            Some("https://rpc.sepolia.example")
+            Some("https://rpc.bsc.example")
         );
 
         fs::remove_dir_all(&root).expect("cleanup temp root");
@@ -489,25 +489,25 @@ mod tests {
         let path = root.join("config.json");
 
         let mut config = WlfiConfig {
-            chain_id: Some(11155111),
-            chain_name: Some("sepolia".to_string()),
-            rpc_url: Some("https://rpc.sepolia.example".to_string()),
+            chain_id: Some(1),
+            chain_name: Some("eth".to_string()),
+            rpc_url: Some("https://rpc.ethereum.example".to_string()),
             ..WlfiConfig::default()
         };
         config.chains.insert(
-            "sepolia".to_string(),
+            "eth".to_string(),
             super::ChainProfile {
-                chain_id: 11155111,
-                name: "sepolia".to_string(),
-                rpc_url: Some("https://rpc.sepolia.example".to_string()),
+                chain_id: 1,
+                name: "eth".to_string(),
+                rpc_url: Some("https://rpc.ethereum.example".to_string()),
                 extra: BTreeMap::new(),
             },
         );
         config.tokens.insert(
-            "usdc".to_string(),
+            "usd1".to_string(),
             TokenProfile {
-                name: Some("USD Coin".to_string()),
-                symbol: "USDC".to_string(),
+                name: Some("USD1".to_string()),
+                symbol: "USD1".to_string(),
                 default_policy: Some(TokenPolicyProfile {
                     per_tx_amount: Some(25.0),
                     daily_amount: Some(100.0),
@@ -559,9 +559,9 @@ mod tests {
                     extra: BTreeMap::new(),
                 }],
                 chains: BTreeMap::from([(
-                    "sepolia".to_string(),
+                    "eth".to_string(),
                     TokenChainProfile {
-                        chain_id: 11155111,
+                        chain_id: 1,
                         is_native: false,
                         address: Some("0x1000000000000000000000000000000000000000".to_string()),
                         decimals: 6,

package/crates/vault-cli-admin/src/tui/token_rpc.rs

@@ -229,7 +229,54 @@ fn decode_abi_usize(bytes: &[u8]) -> Result<usize> {
 
 #[cfg(test)]
 mod tests {
-    use super::{decode_abi_string, parse_hex_u64};
+    use std::io::{Read, Write};
+    use std::net::TcpListener;
+    use std::thread;
+    use std::time::Duration;
+
+    use super::{
+        call_rpc, decode_abi_string, decode_hex_bytes, decode_abi_usize, eth_call,
+        fetch_token_metadata, native_metadata_for_chain, parse_hex_u64, read_erc20_decimals,
+    };
+    use reqwest::Client;
+    use serde_json::json;
+    use vault_domain::EvmAddress;
+
+    fn start_mock_rpc_server(responses: Vec<String>) -> (String, thread::JoinHandle<()>) {
+        let listener = TcpListener::bind("127.0.0.1:0").expect("bind");
+        let addr = listener.local_addr().expect("addr");
+        let handle = thread::spawn(move || {
+            for body in responses {
+                let (mut stream, _) = listener.accept().expect("accept");
+                stream
+                    .set_read_timeout(Some(Duration::from_millis(250)))
+                    .expect("timeout");
+                let mut buffer = [0u8; 4096];
+                loop {
+                    match stream.read(&mut buffer) {
+                        Ok(0) => break,
+                        Ok(_) => continue,
+                        Err(err)
+                            if err.kind() == std::io::ErrorKind::WouldBlock
+                                || err.kind() == std::io::ErrorKind::TimedOut =>
+                        {
+                            break;
+                        }
+                        Err(err) => panic!("failed to read request: {err}"),
+                    }
+                }
+                let response = format!(
+                    "HTTP/1.1 200 OK\r\ncontent-type: application/json\r\ncontent-length: {}\r\nconnection: close\r\n\r\n{}",
+                    body.len(),
+                    body
+                );
+                stream
+                    .write_all(response.as_bytes())
+                    .expect("write response");
+            }
+        });
+        (format!("http://{addr}"), handle)
+    }
 
     #[test]
     fn parse_hex_u64_reads_eth_chain_id_payloads() {
@@ -243,8 +290,148 @@ mod tests {
             "0x",
             "0000000000000000000000000000000000000000000000000000000000000020",
             "0000000000000000000000000000000000000000000000000000000000000004",
-            "5553444300000000000000000000000000000000000000000000000000000000"
+            "5553443100000000000000000000000000000000000000000000000000000000"
+        );
+        assert_eq!(decode_abi_string(encoded).expect("string"), "USD1");
+    }
+
+    #[test]
+    fn helper_parsers_reject_invalid_inputs() {
+        assert!(parse_hex_u64("1", "chain").is_err());
+        assert!(parse_hex_u64("0xzz", "chain").is_err());
+        assert!(decode_hex_bytes("deadbeef").is_err());
+        assert!(decode_hex_bytes("0xzz").is_err());
+        assert!(decode_abi_usize(&[0u8; 31]).is_err());
+
+        let too_short = "0x1234";
+        assert!(decode_abi_string(too_short).is_err());
+        let bad_offset = concat!(
+            "0x",
+            "0000000000000000000000000000000000000000000000000000000000000060",
+            "0000000000000000000000000000000000000000000000000000000000000004",
+            "5553443100000000000000000000000000000000000000000000000000000000"
         );
-        assert_eq!(decode_abi_string(encoded).expect("string"), "USDC");
+        assert!(decode_abi_string(bad_offset).is_err());
+        let bad_utf8 = concat!(
+            "0x",
+            "0000000000000000000000000000000000000000000000000000000000000020",
+            "0000000000000000000000000000000000000000000000000000000000000002",
+            "ffff000000000000000000000000000000000000000000000000000000000000"
+        );
+        assert!(decode_abi_string(bad_utf8).is_err());
+    }
+
+    #[test]
+    fn native_metadata_for_chain_covers_known_and_fallback_symbols() {
+        assert_eq!(native_metadata_for_chain(1, "eth"), ("Ether".to_string(), "ETH".to_string()));
+        assert_eq!(native_metadata_for_chain(56, "bsc"), ("BNB".to_string(), "BNB".to_string()));
+        assert_eq!(native_metadata_for_chain(137, "polygon"), ("MATIC".to_string(), "MATIC".to_string()));
+        assert_eq!(
+            native_metadata_for_chain(999, "custom"),
+            ("Native Asset (custom)".to_string(), "NATIVE".to_string())
+        );
+    }
+
+    #[tokio::test]
+    async fn rpc_helpers_cover_success_and_error_responses() {
+        let (rpc_url, handle) = start_mock_rpc_server(vec![
+            json!({"jsonrpc":"2.0","id":1,"result":"0x1"}).to_string(),
+            json!({"jsonrpc":"2.0","id":1,"error":{"code":-32000,"message":"boom"}}).to_string(),
+            json!({"jsonrpc":"2.0","id":1,"result":42}).to_string(),
+        ]);
+
+        let client = Client::new();
+        let value = call_rpc(&client, &rpc_url, "eth_chainId", json!([]))
+            .await
+            .expect("chain id");
+        assert_eq!(value, json!("0x1"));
+
+        let err = call_rpc(&client, &rpc_url, "eth_call", json!([]))
+            .await
+            .expect_err("rpc error");
+        assert!(err.to_string().contains("boom"));
+
+        let address: EvmAddress = "0x1111111111111111111111111111111111111111"
+            .parse()
+            .expect("address");
+        let err = eth_call(&client, &rpc_url, &address, "0x313ce567")
+            .await
+            .expect_err("non-string eth_call");
+        assert!(err.to_string().contains("non-string"));
+
+        handle.join().expect("server join");
+    }
+
+    #[tokio::test]
+    async fn fetch_token_metadata_covers_native_erc20_and_validation_failures() {
+        let symbol_payload = concat!(
+            "0x",
+            "0000000000000000000000000000000000000000000000000000000000000020",
+            "0000000000000000000000000000000000000000000000000000000000000004",
+            "5553443100000000000000000000000000000000000000000000000000000000"
+        );
+        let name_payload = concat!(
+            "0x",
+            "0000000000000000000000000000000000000000000000000000000000000020",
+            "0000000000000000000000000000000000000000000000000000000000000004",
+            "5553443100000000000000000000000000000000000000000000000000000000"
+        );
+        let decimals_payload = format!("0x{}", "00".repeat(31) + "06");
+        let address: EvmAddress = "0x1111111111111111111111111111111111111111"
+            .parse()
+            .expect("address");
+
+        let (rpc_url, handle) = start_mock_rpc_server(vec![
+            json!({"jsonrpc":"2.0","id":1,"result":"0x1"}).to_string(),
+            json!({"jsonrpc":"2.0","id":1,"result":"0x1"}).to_string(),
+            json!({"jsonrpc":"2.0","id":1,"result":decimals_payload}).to_string(),
+            json!({"jsonrpc":"2.0","id":1,"result":symbol_payload}).to_string(),
+            json!({"jsonrpc":"2.0","id":1,"result":name_payload}).to_string(),
+            json!({"jsonrpc":"2.0","id":1,"result":"0x2"}).to_string(),
+            json!({"jsonrpc":"2.0","id":1,"result":"0x1"}).to_string(),
+        ]);
+
+        let native = fetch_token_metadata("eth", &rpc_url, 1, true, None)
+            .await
+            .expect("native metadata");
+        assert_eq!(native.symbol, "ETH");
+        assert_eq!(native.decimals, 18);
+
+        let erc20 = fetch_token_metadata("eth", &rpc_url, 1, false, Some(&address))
+            .await
+            .expect("erc20 metadata");
+        assert_eq!(erc20.symbol, "USD1");
+        assert_eq!(erc20.name, "USD1");
+        assert_eq!(erc20.decimals, 6);
+
+        let err = fetch_token_metadata("eth", &rpc_url, 1, true, None)
+            .await
+            .expect_err("chain mismatch");
+        assert!(err.to_string().contains("expects 1"));
+
+        let err = fetch_token_metadata("eth", &rpc_url, 1, false, None)
+            .await
+            .expect_err("missing address");
+        assert!(err.to_string().contains("token address is required"));
+
+        handle.join().expect("server join");
+    }
+
+    #[tokio::test]
+    async fn read_erc20_decimals_rejects_wrong_length_payloads() {
+        let (rpc_url, handle) = start_mock_rpc_server(vec![
+            json!({"jsonrpc":"2.0","id":1,"result":"0x0102"}).to_string(),
+        ]);
+        let client = Client::new();
+        let address: EvmAddress = "0x1111111111111111111111111111111111111111"
+            .parse()
+            .expect("address");
+
+        let err = read_erc20_decimals(&client, &rpc_url, &address)
+            .await
+            .expect_err("bad decimals payload");
+        assert!(err.to_string().contains("expected 32"));
+
+        handle.join().expect("server join");
     }
 }

package/crates/vault-cli-admin/src/tui/utils.rs

@@ -80,3 +80,62 @@ pub(super) fn is_allowed_input_char(field: Field, ch: char) -> bool {
         _ => true,
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        bool_label, is_allowed_input_char, parse_address, parse_non_negative_u128,
+        parse_positive_u128, parse_positive_u64,
+    };
+    use crate::tui::Field;
+
+    #[test]
+    fn parsers_accept_trimmed_values_and_reject_invalid_or_zero_inputs() {
+        assert_eq!(parse_positive_u128("amount", " 42 ").expect("u128"), 42);
+        assert_eq!(
+            parse_non_negative_u128("count", " 0 ").expect("non-negative"),
+            0
+        );
+        assert_eq!(parse_positive_u64("chain", " 7 ").expect("u64"), 7);
+
+        assert!(parse_positive_u128("amount", "0").is_err());
+        assert!(parse_positive_u128("amount", "nope").is_err());
+        assert!(parse_non_negative_u128("count", "nope").is_err());
+        assert!(parse_positive_u64("chain", "0").is_err());
+        assert!(parse_positive_u64("chain", "bad").is_err());
+    }
+
+    #[test]
+    fn parse_address_and_bool_label_cover_happy_and_error_paths() {
+        assert_eq!(bool_label(true), "yes");
+        assert_eq!(bool_label(false), "no");
+
+        let address = parse_address(
+            "recipient",
+            " 0x1111111111111111111111111111111111111111 ",
+        )
+        .expect("address");
+        assert_eq!(address.as_str(), "0x1111111111111111111111111111111111111111");
+        assert!(parse_address("recipient", "not-an-address").is_err());
+    }
+
+    #[test]
+    fn allowed_input_characters_match_field_types() {
+        assert!(is_allowed_input_char(Field::TokenKey, 'a'));
+        assert!(is_allowed_input_char(Field::TokenKey, '-'));
+        assert!(!is_allowed_input_char(Field::TokenKey, '!'));
+
+        assert!(is_allowed_input_char(Field::PerTxLimit, '9'));
+        assert!(is_allowed_input_char(Field::PerTxLimit, '.'));
+        assert!(!is_allowed_input_char(Field::PerTxLimit, 'x'));
+
+        assert!(is_allowed_input_char(Field::DailyMaxTxCount, '4'));
+        assert!(!is_allowed_input_char(Field::DailyMaxTxCount, '.'));
+
+        assert!(is_allowed_input_char(Field::NetworkAddress, 'a'));
+        assert!(is_allowed_input_char(Field::NetworkAddress, 'X'));
+        assert!(!is_allowed_input_char(Field::NetworkAddress, 'g'));
+
+        assert!(is_allowed_input_char(Field::TokenName, '!'));
+    }
+}