feat: HIP-3 perp support — SILVER, GOLD, stocks on Hyperliquid

- New hip3.rs module: full EIP-712 signing for HIP-3 dex orders
  - Resolves dex offset (110000 + dex_idx * 10000) from perpDexs API
  - Msgpack serialization → keccak256 → Agent EIP-712 signing
  - Bypasses SDK which doesn't support HIP-3 assets
- perp quote SILVER/GOLD/TSLA/NVDA etc. — queries HIP-3 cash dex
  - Shows funding, OI, volume, oracle, premium, max leverage (20x)
- perp buy/sell routes HIP-3 assets through hip3::place_order()
- Symbol mapping: SILVER→cash:SILVER, GOLD→cash:GOLD, stock tickers→cash:TICKER
- Falls back: main perps → HIP-3 dexes → spot commodity pairs
- Added rmp-serde dep for msgpack wire format

Author: Michael Yuan

Cargo.toml

@@ -27,5 +27,6 @@ urlencoding = "2"
 regex = "1"
 openssl = { version = "0.10", features = ["vendored"] }
 hmac = "0.12"
+rmp-serde = "1"
 sha2 = "0.10"
 uuid = { version = "1", features = ["v4"] }

src/commands/perp.rs

@@ -2,8 +2,8 @@ use anyhow::{bail, Context, Result};
 use colored::Colorize;
 use serde_json::json;
 
-use crate::commands::quote::commodity_to_spot_token;
-use crate::{binance, config, signing};
+use crate::commands::quote::resolve_hip3_asset;
+use crate::{binance, config, hip3, signing};
 
 /// Resolve which exchange to use
 fn resolve_exchange(exchange: &str) -> Result<String> {
@@ -69,9 +69,9 @@ pub async fn buy(
     let amount_f: f64 = amount_usdc.parse().context("Invalid amount")?;
     let size = amount_f / price_f;
 
-    // Check if this is a commodity → route to spot order
-    if let Some(spot_token) = commodity_to_spot_token(&symbol) {
-        return commodity_spot_buy(spot_token, &symbol, price_f, size, &cfg, json_output).await;
+    // Check if this is a HIP-3 asset (commodities, stocks)
+    if let Some((dex, asset_name)) = resolve_hip3_asset(&symbol) {
+        return hip3_perp_buy(&dex, &asset_name, &symbol, price_f, size, amount_usdc, &cfg, json_output).await;
     }
 
     if !json_output {
@@ -156,9 +156,9 @@ pub async fn sell(
     let size: f64 = amount.parse().context("Invalid amount")?;
     let price_f: f64 = price.parse().context("Invalid price")?;
 
-    // Check if this is a commodity → route to spot order
-    if let Some(spot_token) = commodity_to_spot_token(&symbol) {
-        return commodity_spot_sell(spot_token, &symbol, price_f, size, &cfg, json_output).await;
+    // Check if this is a HIP-3 asset (commodities, stocks)
+    if let Some((dex, asset_name)) = resolve_hip3_asset(&symbol) {
+        return hip3_perp_sell(&dex, &asset_name, &symbol, price_f, size, &cfg, json_output).await;
     }
 
     if !json_output {
@@ -203,71 +203,74 @@ pub async fn sell(
     Ok(())
 }
 
-// ── Commodity spot order helpers ─────────────────────────────────────
+// ── HIP-3 perp order helpers ─────────────────────────────────────────
 
-/// Route a commodity "perp buy" to a spot buy on HL
-async fn commodity_spot_buy(
-    spot_token: &str,
+/// Place a HIP-3 perp buy order (e.g. cash:SILVER)
+#[allow(clippy::too_many_arguments)]
+async fn hip3_perp_buy(
+    dex: &str,
+    asset_name: &str,
     original_symbol: &str,
     price: f64,
     size: f64,
+    amount_usdc: &str,
     cfg: &config::HlConfig,
     json_output: bool,
 ) -> Result<()> {
     if !json_output {
         println!();
         println!(
-            "  📝 {} trades as {}/USDC spot on Hyperliquid",
-            original_symbol,
-            spot_token
+            "  📝 Placing HIP-3 perp limit BUY ({} on {} dex)",
+            asset_name.cyan(),
+            dex
         );
-        println!("  Placing spot limit BUY");
-        println!("  Token:    {}", spot_token.cyan());
+        println!("  Symbol:   {}", original_symbol.cyan());
+        println!("  Asset:    {}", asset_name);
         println!("  Size:     {:.6}", size);
         println!("  Price:    ${:.2}", price);
-        println!("  Total:    ${:.2}", price * size);
+        println!("  Total:    ${}", amount_usdc);
         println!(
             "  Network:  {}",
             if cfg.testnet { "Testnet" } else { "Mainnet" }
         );
         println!();
     }
 
-    let result = signing::place_spot_order(spot_token, true, price, size).await?;
+    let result = hip3::place_order(dex, asset_name, true, price, size).await?;
 
     let response = json!({
-        "action": "commodity_spot_buy",
+        "action": "hip3_perp_buy",
         "symbol": original_symbol,
-        "spotToken": spot_token,
+        "hip3Asset": asset_name,
+        "dex": dex,
         "size": format!("{:.6}", size),
         "price": format!("{:.2}", price),
-        "total_usdc": format!("{:.2}", price * size),
+        "total_usdc": amount_usdc,
         "network": if cfg.testnet { "testnet" } else { "mainnet" },
-        "note": format!("{} trades as {}/USDC spot pair (no perp available)", original_symbol, spot_token),
-        "result": format!("{:?}", result),
+        "result": result,
     });
 
     if json_output {
         println!("{}", serde_json::to_string_pretty(&response)?);
     } else {
-        match result {
-            hyperliquid_rust_sdk::ExchangeResponseStatus::Ok(data) => {
-                println!("  ✅ Spot order placed!");
-                println!("  Response: {:?}", data);
-            }
-            hyperliquid_rust_sdk::ExchangeResponseStatus::Err(e) => {
-                println!("  ❌ Order failed: {}", e);
+        if let Some(status) = result.get("status").and_then(|s| s.as_str()) {
+            if status == "ok" {
+                println!("  ✅ HIP-3 perp order placed!");
+            } else {
+                println!("  ❌ Order failed: {}", status);
             }
         }
+        println!("  Response: {}", serde_json::to_string_pretty(&result)?);
         println!();
     }
 
     Ok(())
 }
 
-/// Route a commodity "perp sell" to a spot sell on HL
-async fn commodity_spot_sell(
-    spot_token: &str,
+/// Place a HIP-3 perp sell order
+async fn hip3_perp_sell(
+    dex: &str,
+    asset_name: &str,
     original_symbol: &str,
     price: f64,
     size: f64,
@@ -277,12 +280,12 @@ async fn commodity_spot_sell(
     if !json_output {
         println!();
         println!(
-            "  📝 {} trades as {}/USDC spot on Hyperliquid",
-            original_symbol,
-            spot_token
+            "  📝 Placing HIP-3 perp limit SELL ({} on {} dex)",
+            asset_name.cyan(),
+            dex
         );
-        println!("  Placing spot limit SELL");
-        println!("  Token:    {}", spot_token.cyan());
+        println!("  Symbol:   {}", original_symbol.cyan());
+        println!("  Asset:    {}", asset_name);
         println!("  Size:     {:.6}", size);
         println!("  Price:    ${:.2}", price);
         println!(
@@ -292,31 +295,30 @@ async fn commodity_spot_sell(
         println!();
     }
 
-    let result = signing::place_spot_order(spot_token, false, price, size).await?;
+    let result = hip3::place_order(dex, asset_name, false, price, size).await?;
 
     let response = json!({
-        "action": "commodity_spot_sell",
+        "action": "hip3_perp_sell",
         "symbol": original_symbol,
-        "spotToken": spot_token,
+        "hip3Asset": asset_name,
+        "dex": dex,
         "size": format!("{:.6}", size),
         "price": format!("{:.2}", price),
         "network": if cfg.testnet { "testnet" } else { "mainnet" },
-        "note": format!("{} trades as {}/USDC spot pair (no perp available)", original_symbol, spot_token),
-        "result": format!("{:?}", result),
+        "result": result,
     });
 
     if json_output {
         println!("{}", serde_json::to_string_pretty(&response)?);
     } else {
-        match result {
-            hyperliquid_rust_sdk::ExchangeResponseStatus::Ok(data) => {
-                println!("  ✅ Spot order placed!");
-                println!("  Response: {:?}", data);
-            }
-            hyperliquid_rust_sdk::ExchangeResponseStatus::Err(e) => {
-                println!("  ❌ Order failed: {}", e);
+        if let Some(status) = result.get("status").and_then(|s| s.as_str()) {
+            if status == "ok" {
+                println!("  ✅ HIP-3 perp order placed!");
+            } else {
+                println!("  ❌ Order failed: {}", status);
             }
         }
+        println!("  Response: {}", serde_json::to_string_pretty(&result)?);
         println!();
     }
 

src/commands/quote.rs

@@ -357,7 +357,12 @@ async fn fetch_hl_perp(client: &reqwest::Client, symbol: &str) -> Result<Value>
         }
     }
 
-    // Not found in perps — check if it's a commodity with a spot pair
+    // Not found in main perps — check HIP-3 dexes (e.g. cash:SILVER, cash:GOLD)
+    if let Ok(data) = fetch_hip3_perp(client, symbol).await {
+        return Ok(data);
+    }
+
+    // Last resort — check if it's a commodity with a spot pair only
     let commodity_token = commodity_to_spot_token(symbol);
     if let Some(token) = commodity_token {
         return fetch_hl_commodity_as_perp(client, symbol, token).await;
@@ -366,6 +371,161 @@ async fn fetch_hl_perp(client: &reqwest::Client, symbol: &str) -> Result<Value>
     anyhow::bail!("Symbol {} not found in Hyperliquid perps", symbol)
 }
 
+/// Map user-friendly names to HIP-3 dex:symbol pairs
+/// Returns (dex_name, asset_name_in_dex) e.g. ("cash", "cash:SILVER")
+fn hip3_symbol_map(symbol: &str) -> Vec<(&'static str, String)> {
+    let sym = symbol.to_uppercase();
+
+    // If already prefixed with dex name, use directly
+    if sym.contains(':') {
+        let parts: Vec<&str> = sym.splitn(2, ':').collect();
+        if parts.len() == 2 {
+            return vec![(
+                match parts[0].to_lowercase().as_str() {
+                    "cash" => "cash",
+                    "xyz" => "xyz",
+                    "flx" => "flx",
+                    "km" => "km",
+                    _ => return vec![],
+                },
+                sym.to_lowercase(),
+            )];
+        }
+    }
+
+    // Map common aliases to the most liquid HIP-3 dex
+    // cash (dreamcash) is the most liquid for commodities and stocks
+    let mapped = match sym.as_str() {
+        // Commodities
+        "SILVER" | "XAG" => Some("SILVER"),
+        "GOLD" | "XAU" => Some("GOLD"),
+        // US indices
+        "USA500" | "SP500" | "SPX" => Some("USA500"),
+        // Stocks available on cash dex
+        "TSLA" | "NVDA" | "GOOGL" | "AMZN" | "MSFT" | "META" | "INTC" | "HOOD" => {
+            Some(sym.as_str())
+        }
+        _ => None,
+    };
+
+    if let Some(asset) = mapped {
+        // Try cash dex first (most liquid), then others
+        vec![
+            ("cash", format!("cash:{}", asset)),
+            ("xyz", format!("xyz:{}", asset)),
+            ("km", format!("km:{}", asset)),
+        ]
+    } else {
+        vec![]
+    }
+}
+
+/// Fetch perp data from HIP-3 dexes (e.g. cash:SILVER, cash:GOLD)
+async fn fetch_hip3_perp(client: &reqwest::Client, symbol: &str) -> Result<Value> {
+    let candidates = hip3_symbol_map(symbol);
+    if candidates.is_empty() {
+        anyhow::bail!("No HIP-3 mapping for {}", symbol);
+    }
+
+    let url = config::info_url();
+
+    for (dex, asset_name) in &candidates {
+        let meta_resp: Value = client
+            .post(&url)
+            .json(&json!({"type": "metaAndAssetCtxs", "dex": dex}))
+            .send()
+            .await?
+            .json()
+            .await
+            .context("Failed to parse HIP-3 metaAndAssetCtxs")?;
+
+        if let (Some(universe), Some(ctxs)) = (
+            meta_resp
+                .get(0)
+                .and_then(|m| m.get("universe"))
+                .and_then(|u| u.as_array()),
+            meta_resp.get(1).and_then(|c| c.as_array()),
+        ) {
+            for (i, asset) in universe.iter().enumerate() {
+                let name = asset.get("name").and_then(|n| n.as_str()).unwrap_or("");
+                if name.eq_ignore_ascii_case(asset_name) {
+                    if let Some(ctx) = ctxs.get(i) {
+                        let funding = ctx
+                            .get("funding")
+                            .and_then(|f| f.as_str())
+                            .unwrap_or("")
+                            .to_string();
+                        let open_interest = ctx
+                            .get("openInterest")
+                            .and_then(|f| f.as_str())
+                            .unwrap_or("")
+                            .to_string();
+                        let volume = ctx
+                            .get("dayNtlVlm")
+                            .and_then(|f| f.as_str())
+                            .unwrap_or("")
+                            .to_string();
+                        let mark_px = ctx
+                            .get("markPx")
+                            .and_then(|f| f.as_str())
+                            .unwrap_or("")
+                            .to_string();
+                        let oracle_px = ctx
+                            .get("oraclePx")
+                            .and_then(|f| f.as_str())
+                            .unwrap_or("")
+                            .to_string();
+                        let prev_day_px = ctx
+                            .get("prevDayPx")
+                            .and_then(|f| f.as_str())
+                            .unwrap_or("")
+                            .to_string();
+                        let premium = ctx
+                            .get("premium")
+                            .and_then(|f| f.as_str())
+                            .unwrap_or("")
+                            .to_string();
+                        let max_leverage = asset
+                            .get("maxLeverage")
+                            .and_then(|l| l.as_u64())
+                            .unwrap_or(0);
+                        let change_24h = calc_change(&mark_px, &prev_day_px);
+
+                        return Ok(json!({
+                            "symbol": symbol.to_uppercase(),
+                            "hip3Asset": name,
+                            "dex": dex,
+                            "markPx": mark_px,
+                            "oraclePx": oracle_px,
+                            "change24h": change_24h,
+                            "funding": funding,
+                            "premium": premium,
+                            "openInterest": open_interest,
+                            "volume24h": volume,
+                            "prevDayPx": prev_day_px,
+                            "maxLeverage": max_leverage,
+                            "source": format!("Hyperliquid HIP-3 ({})", dex),
+                        }));
+                    }
+                }
+            }
+        }
+    }
+
+    anyhow::bail!("Symbol {} not found in HIP-3 dexes", symbol)
+}
+
+/// Resolve a symbol to its HIP-3 dex asset name (for trading)
+/// Returns (dex_name, full_asset_name) e.g. ("cash", "cash:SILVER")
+pub fn resolve_hip3_asset(symbol: &str) -> Option<(String, String)> {
+    let candidates = hip3_symbol_map(symbol);
+    // Return the first candidate (most liquid dex)
+    candidates
+        .into_iter()
+        .next()
+        .map(|(dex, asset)| (dex.to_string(), asset))
+}
+
 /// Map commodity aliases to HL spot token names
 pub fn commodity_to_spot_token(symbol: &str) -> Option<&'static str> {
     match symbol.to_uppercase().as_str() {