@wlfi-agent/cli 1.4.13 → 1.4.14

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

@@ -0,0 +1,180 @@
+use anyhow::{anyhow, bail, Result};
+
+const MAX_U128_DECIMALS: u8 = 38;
+
+pub(super) fn format_token_amount(raw: u128, decimals: u8) -> Result<String> {
+    if decimals > MAX_U128_DECIMALS {
+        bail!("token decimals must be <= {MAX_U128_DECIMALS} for u128 formatting");
+    }
+    if decimals == 0 {
+        return Ok(raw.to_string());
+    }
+
+    let scale = pow10(decimals)?;
+    let whole = raw / scale;
+    let fractional = raw % scale;
+    if fractional == 0 {
+        return Ok(whole.to_string());
+    }
+
+    let mut fractional_text = format!("{fractional:0width$}", width = decimals as usize);
+    while fractional_text.ends_with('0') {
+        fractional_text.pop();
+    }
+    Ok(format!("{whole}.{fractional_text}"))
+}
+
+pub(super) fn format_gwei_amount(raw_wei: u128) -> Result<String> {
+    format_token_amount(raw_wei, 9)
+}
+
+pub(super) fn parse_required_token_amount(label: &str, value: &str, decimals: u8) -> Result<u128> {
+    parse_token_amount(label, value, decimals, false)
+}
+
+pub(super) fn parse_optional_token_amount(
+    label: &str,
+    value: Option<&str>,
+    decimals: u8,
+) -> Result<u128> {
+    match value {
+        Some(value) if !value.trim().is_empty() => parse_token_amount(label, value, decimals, true),
+        _ => Ok(0),
+    }
+}
+
+pub(super) fn parse_optional_gwei_amount(label: &str, value: Option<&str>) -> Result<u128> {
+    parse_optional_token_amount(label, value, 9)
+}
+
+pub(super) fn parse_legacy_amount(label: &str, value: f64, decimals: u8) -> Result<u128> {
+    if !value.is_finite() || value <= 0.0 {
+        bail!("{label} must be a positive finite number");
+    }
+    parse_required_token_amount(label, &value.to_string(), decimals)
+}
+
+fn parse_token_amount(label: &str, value: &str, decimals: u8, allow_zero: bool) -> Result<u128> {
+    if decimals > MAX_U128_DECIMALS {
+        bail!("{label} token decimals must be <= {MAX_U128_DECIMALS}");
+    }
+
+    let trimmed = value.trim();
+    if trimmed.is_empty() {
+        bail!("{label} is required");
+    }
+    if trimmed.starts_with('-') {
+        bail!("{label} must not be negative");
+    }
+
+    let mut parts = trimmed.split('.');
+    let whole_part = parts.next().unwrap_or_default();
+    let fractional_part = parts.next();
+    if parts.next().is_some() {
+        bail!("{label} must be a decimal number");
+    }
+
+    let whole_digits = if whole_part.is_empty() {
+        "0"
+    } else {
+        whole_part
+    };
+    if !whole_digits.chars().all(|ch| ch.is_ascii_digit()) {
+        bail!("{label} must be a decimal number");
+    }
+
+    let fractional_digits = fractional_part.unwrap_or_default();
+    if !fractional_digits.chars().all(|ch| ch.is_ascii_digit()) {
+        bail!("{label} must be a decimal number");
+    }
+    if fractional_digits.len() > decimals as usize {
+        bail!("{label} must use at most {} decimal places", decimals);
+    }
+
+    let scale = pow10(decimals)?;
+    let whole = whole_digits
+        .parse::<u128>()
+        .map_err(|_| anyhow!("{label} is too large"))?;
+    let whole_scaled = whole
+        .checked_mul(scale)
+        .ok_or_else(|| anyhow!("{label} is too large"))?;
+
+    let mut fractional_text = fractional_digits.to_string();
+    while fractional_text.len() < decimals as usize {
+        fractional_text.push('0');
+    }
+    let fractional = if fractional_text.is_empty() {
+        0
+    } else {
+        fractional_text
+            .parse::<u128>()
+            .map_err(|_| anyhow!("{label} is too large"))?
+    };
+
+    let value = whole_scaled
+        .checked_add(fractional)
+        .ok_or_else(|| anyhow!("{label} is too large"))?;
+    if !allow_zero && value == 0 {
+        bail!("{label} must be greater than zero");
+    }
+    Ok(value)
+}
+
+fn pow10(decimals: u8) -> Result<u128> {
+    let mut value = 1_u128;
+    for _ in 0..decimals {
+        value = value
+            .checked_mul(10)
+            .ok_or_else(|| anyhow!("10^{} overflows u128", decimals))?;
+    }
+    Ok(value)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        format_gwei_amount, format_token_amount, parse_optional_gwei_amount,
+        parse_optional_token_amount, parse_required_token_amount,
+    };
+
+    #[test]
+    fn parse_required_token_amount_accepts_decimal_strings() {
+        assert_eq!(
+            parse_required_token_amount("amount", "1.25", 6).expect("amount"),
+            1_250_000
+        );
+    }
+
+    #[test]
+    fn parse_required_token_amount_rejects_excess_precision() {
+        let err = parse_required_token_amount("amount", "1.0000001", 6).expect_err("must reject");
+        assert!(err
+            .to_string()
+            .contains("must use at most 6 decimal places"));
+    }
+
+    #[test]
+    fn parse_optional_token_amount_defaults_blank_to_zero() {
+        assert_eq!(
+            parse_optional_token_amount("amount", Some(""), 18).expect("blank"),
+            0
+        );
+        assert_eq!(
+            parse_optional_token_amount("amount", None, 18).expect("none"),
+            0
+        );
+    }
+
+    #[test]
+    fn format_token_amount_trims_trailing_zeroes() {
+        assert_eq!(format_token_amount(1_250_000, 6).expect("format"), "1.25");
+        assert_eq!(format_token_amount(1_000_000, 6).expect("format"), "1");
+    }
+
+    #[test]
+    fn gwei_helpers_round_trip() {
+        let raw = parse_optional_gwei_amount("fee", Some("2.5")).expect("parse");
+        assert_eq!(raw, 2_500_000_000);
+        assert_eq!(format_gwei_amount(raw).expect("format"), "2.5");
+    }
+}

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

@@ -0,0 +1,250 @@
+use anyhow::{anyhow, bail, Context, Result};
+use hex::FromHex;
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+use serde_json::{json, Value};
+use vault_domain::EvmAddress;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(super) struct FetchedTokenMetadata {
+    pub(super) chain_id: u64,
+    pub(super) name: String,
+    pub(super) symbol: String,
+    pub(super) decimals: u8,
+}
+
+#[derive(Debug, Serialize)]
+struct RpcRequest<'a> {
+    jsonrpc: &'static str,
+    method: &'a str,
+    params: Value,
+    id: u64,
+}
+
+#[derive(Debug, Deserialize)]
+struct RpcResponse {
+    result: Option<Value>,
+    error: Option<RpcError>,
+}
+
+#[derive(Debug, Deserialize)]
+struct RpcError {
+    code: i64,
+    message: String,
+}
+
+pub(super) async fn fetch_token_metadata(
+    chain_key: &str,
+    rpc_url: &str,
+    expected_chain_id: u64,
+    is_native: bool,
+    address: Option<&EvmAddress>,
+) -> Result<FetchedTokenMetadata> {
+    let client = Client::new();
+    let chain_id = fetch_chain_id(&client, rpc_url).await?;
+    if chain_id != expected_chain_id {
+        bail!(
+            "rpc url returned chain id {} but the saved network expects {}",
+            chain_id,
+            expected_chain_id
+        );
+    }
+
+    if is_native {
+        let (name, symbol) = native_metadata_for_chain(chain_id, chain_key);
+        return Ok(FetchedTokenMetadata {
+            chain_id,
+            name,
+            symbol,
+            decimals: 18,
+        });
+    }
+
+    let address = address.context("token address is required to fetch metadata")?;
+    let decimals = read_erc20_decimals(&client, rpc_url, address).await?;
+    let symbol = read_erc20_string(&client, rpc_url, address, "0x95d89b41")
+        .await
+        .context("failed to read token symbol")?;
+    let name = read_erc20_string(&client, rpc_url, address, "0x06fdde03")
+        .await
+        .context("failed to read token name")?;
+
+    Ok(FetchedTokenMetadata {
+        chain_id,
+        name,
+        symbol,
+        decimals,
+    })
+}
+
+async fn fetch_chain_id(client: &Client, rpc_url: &str) -> Result<u64> {
+    let response = call_rpc(client, rpc_url, "eth_chainId", json!([])).await?;
+    let result = response
+        .as_str()
+        .context("eth_chainId returned a non-string result")?;
+    parse_hex_u64(result, "eth_chainId")
+}
+
+async fn read_erc20_decimals(client: &Client, rpc_url: &str, address: &EvmAddress) -> Result<u8> {
+    let result = eth_call(client, rpc_url, address, "0x313ce567").await?;
+    let decoded = decode_hex_bytes(&result)?;
+    if decoded.len() != 32 {
+        bail!("decimals() returned {} bytes; expected 32", decoded.len());
+    }
+    let decimals = *decoded
+        .last()
+        .context("decimals() returned an empty payload")?;
+    Ok(decimals)
+}
+
+async fn read_erc20_string(
+    client: &Client,
+    rpc_url: &str,
+    address: &EvmAddress,
+    selector: &str,
+) -> Result<String> {
+    let result = eth_call(client, rpc_url, address, selector).await?;
+    decode_abi_string(&result)
+}
+
+async fn eth_call(
+    client: &Client,
+    rpc_url: &str,
+    address: &EvmAddress,
+    data: &str,
+) -> Result<String> {
+    let result = call_rpc(
+        client,
+        rpc_url,
+        "eth_call",
+        json!([
+            {
+                "to": address.to_string(),
+                "data": data,
+            },
+            "latest"
+        ]),
+    )
+    .await?;
+    result
+        .as_str()
+        .map(ToString::to_string)
+        .context("eth_call returned a non-string result")
+}
+
+async fn call_rpc(client: &Client, rpc_url: &str, method: &str, params: Value) -> Result<Value> {
+    let request = RpcRequest {
+        jsonrpc: "2.0",
+        method,
+        params,
+        id: 1,
+    };
+    let response = client
+        .post(rpc_url.trim())
+        .json(&request)
+        .send()
+        .await
+        .with_context(|| format!("rpc call {method} failed"))?;
+    let response = response
+        .error_for_status()
+        .with_context(|| format!("rpc call {method} failed"))?;
+    let payload: RpcResponse = response
+        .json()
+        .await
+        .with_context(|| format!("rpc call {method} returned invalid json"))?;
+    if let Some(error) = payload.error {
+        bail!(
+            "rpc call {method} failed: {} ({})",
+            error.message,
+            error.code
+        );
+    }
+    payload
+        .result
+        .ok_or_else(|| anyhow!("rpc call {method} returned no result"))
+}
+
+fn native_metadata_for_chain(chain_id: u64, chain_key: &str) -> (String, String) {
+    match chain_id {
+        1 | 10 | 8453 | 84532 | 42161 | 11155111 => ("Ether".to_string(), "ETH".to_string()),
+        56 => ("BNB".to_string(), "BNB".to_string()),
+        137 => ("MATIC".to_string(), "MATIC".to_string()),
+        _ => (format!("Native Asset ({chain_key})"), "NATIVE".to_string()),
+    }
+}
+
+fn parse_hex_u64(value: &str, label: &str) -> Result<u64> {
+    let trimmed = value.trim();
+    let digits = trimmed
+        .strip_prefix("0x")
+        .or_else(|| trimmed.strip_prefix("0X"))
+        .context(format!("{label} must be a 0x-prefixed hex string"))?;
+    u64::from_str_radix(digits, 16).with_context(|| format!("{label} must be valid hex"))
+}
+
+fn decode_hex_bytes(value: &str) -> Result<Vec<u8>> {
+    let trimmed = value.trim();
+    let digits = trimmed
+        .strip_prefix("0x")
+        .or_else(|| trimmed.strip_prefix("0X"))
+        .context("hex payload must be 0x-prefixed")?;
+    Vec::from_hex(digits).context("hex payload must contain valid hex bytes")
+}
+
+fn decode_abi_string(value: &str) -> Result<String> {
+    let bytes = decode_hex_bytes(value)?;
+    if bytes.len() < 64 {
+        bail!("abi string payload is too short");
+    }
+
+    let offset = decode_abi_usize(&bytes[0..32]).context("invalid abi string offset")?;
+    if offset + 32 > bytes.len() {
+        bail!("abi string offset points past the payload");
+    }
+    let length =
+        decode_abi_usize(&bytes[offset..offset + 32]).context("invalid abi string length")?;
+    let start = offset + 32;
+    let end = start + length;
+    if end > bytes.len() {
+        bail!("abi string length points past the payload");
+    }
+
+    String::from_utf8(bytes[start..end].to_vec()).context("abi string is not valid utf-8")
+}
+
+fn decode_abi_usize(bytes: &[u8]) -> Result<usize> {
+    if bytes.len() != 32 {
+        bail!("abi integer must be 32 bytes");
+    }
+    if bytes[..24].iter().any(|byte| *byte != 0) {
+        bail!("abi integer does not fit into usize");
+    }
+    let value = u64::from_be_bytes(
+        bytes[24..32]
+            .try_into()
+            .map_err(|_| anyhow!("abi integer tail is malformed"))?,
+    );
+    usize::try_from(value).context("abi integer does not fit into usize")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{decode_abi_string, parse_hex_u64};
+
+    #[test]
+    fn parse_hex_u64_reads_eth_chain_id_payloads() {
+        assert_eq!(parse_hex_u64("0x1", "chain").expect("chain"), 1);
+        assert_eq!(parse_hex_u64("0xa4b1", "chain").expect("chain"), 42161);
+    }
+
+    #[test]
+    fn decode_abi_string_reads_dynamic_strings() {
+        let encoded = concat!(
+            "0x",
+            "0000000000000000000000000000000000000000000000000000000000000020",
+            "0000000000000000000000000000000000000000000000000000000000000004",
+            "5553444300000000000000000000000000000000000000000000000000000000"
+        );
+        assert_eq!(decode_abi_string(encoded).expect("string"), "USDC");
+    }
+}

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

@@ -0,0 +1,82 @@
+use anyhow::{anyhow, bail, Result};
+use vault_domain::EvmAddress;
+
+use super::Field;
+
+pub(super) fn parse_positive_u128(label: &str, value: &str) -> Result<u128> {
+    let trimmed = value.trim();
+    let parsed = trimmed
+        .parse::<u128>()
+        .map_err(|_| anyhow!("{label} must be a valid unsigned integer"))?;
+    if parsed == 0 {
+        bail!("{label} must be greater than zero");
+    }
+    Ok(parsed)
+}
+
+pub(super) fn parse_non_negative_u128(label: &str, value: &str) -> Result<u128> {
+    value
+        .trim()
+        .parse::<u128>()
+        .map_err(|_| anyhow!("{label} must be a valid unsigned integer"))
+}
+
+pub(super) fn parse_positive_u64(label: &str, value: &str) -> Result<u64> {
+    let trimmed = value.trim();
+    let parsed = trimmed
+        .parse::<u64>()
+        .map_err(|_| anyhow!("{label} must be a valid unsigned integer"))?;
+    if parsed == 0 {
+        bail!("{label} must be greater than zero");
+    }
+    Ok(parsed)
+}
+
+pub(super) fn parse_address(label: &str, value: &str) -> Result<EvmAddress> {
+    value
+        .trim()
+        .parse::<EvmAddress>()
+        .map_err(|err| anyhow!("invalid {label} address: {err}"))
+}
+
+pub(super) fn bool_label(value: bool) -> &'static str {
+    if value {
+        "yes"
+    } else {
+        "no"
+    }
+}
+
+pub(super) fn is_allowed_input_char(field: Field, ch: char) -> bool {
+    match field {
+        Field::TokenKey | Field::ChainConfigKey => {
+            ch.is_ascii_alphanumeric() || matches!(ch, '-' | '_' | '.')
+        }
+        Field::PerTxLimit
+        | Field::DailyLimit
+        | Field::WeeklyLimit
+        | Field::PerTxMaxFeePerGasGwei
+        | Field::OverridePerTxLimit
+        | Field::OverrideDailyLimit
+        | Field::OverrideWeeklyLimit
+        | Field::OverridePerTxMaxFeePerGasGwei
+        | Field::ManualApprovalMinAmount
+        | Field::ManualApprovalMaxAmount => ch.is_ascii_digit() || ch == '.',
+        Field::MaxGasPerChainWei
+        | Field::DailyMaxTxCount
+        | Field::PerTxMaxPriorityFeePerGasWei
+        | Field::PerTxMaxCalldataBytes
+        | Field::OverrideMaxGasPerChainWei
+        | Field::OverrideDailyMaxTxCount
+        | Field::OverridePerTxMaxPriorityFeePerGasWei
+        | Field::OverridePerTxMaxCalldataBytes
+        | Field::ManualApprovalPriority
+        | Field::ChainConfigId => ch.is_ascii_digit(),
+        Field::NetworkAddress
+        | Field::OverrideRecipientAddress
+        | Field::ManualApprovalRecipientAddress => {
+            ch.is_ascii_hexdigit() || matches!(ch, 'x' | 'X')
+        }
+        _ => true,
+    }
+}