feat: commodity perp quote and trading on HL (SILVER, GOLD)

- perp quote SILVER → fetches SLV/USDC spot pair data from HL
- perp quote GOLD → fetches XAUT0/USDC spot pair data from HL
- perp buy/sell SILVER routes to SLV/USDC spot order automatically
- perp buy/sell GOLD routes to XAUT0/USDC spot order automatically
- Commodity aliases: SILVER/XAG→SLV, GOLD/XAU/XAUT→XAUT0
- Human output shows source, note, and spot pair info for commodities
- Falls back from perp universe to spot universe for commodity symbols

Author: Michael Yuan

src/commands/perp.rs

@@ -2,6 +2,7 @@ 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};
 
 /// Resolve which exchange to use
@@ -68,6 +69,11 @@ 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;
+    }
+
     if !json_output {
         println!();
         println!("  📝 Placing perp limit BUY (long)");
@@ -150,6 +156,11 @@ 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;
+    }
+
     if !json_output {
         println!();
         println!("  📝 Placing perp limit SELL (short)");
@@ -191,3 +202,123 @@ pub async fn sell(
 
     Ok(())
 }
+
+// ── Commodity spot order helpers ─────────────────────────────────────
+
+/// Route a commodity "perp buy" to a spot buy on HL
+async fn commodity_spot_buy(
+    spot_token: &str,
+    original_symbol: &str,
+    price: f64,
+    size: f64,
+    cfg: &config::HlConfig,
+    json_output: bool,
+) -> Result<()> {
+    if !json_output {
+        println!();
+        println!(
+            "  📝 {} trades as {}/USDC spot on Hyperliquid",
+            original_symbol,
+            spot_token
+        );
+        println!("  Placing spot limit BUY");
+        println!("  Token:    {}", spot_token.cyan());
+        println!("  Size:     {:.6}", size);
+        println!("  Price:    ${:.2}", price);
+        println!("  Total:    ${:.2}", price * size);
+        println!(
+            "  Network:  {}",
+            if cfg.testnet { "Testnet" } else { "Mainnet" }
+        );
+        println!();
+    }
+
+    let result = signing::place_spot_order(spot_token, true, price, size).await?;
+
+    let response = json!({
+        "action": "commodity_spot_buy",
+        "symbol": original_symbol,
+        "spotToken": spot_token,
+        "size": format!("{:.6}", size),
+        "price": format!("{:.2}", price),
+        "total_usdc": format!("{:.2}", price * size),
+        "network": if cfg.testnet { "testnet" } else { "mainnet" },
+        "note": format!("{} trades as {}/USDC spot pair (no perp available)", original_symbol, spot_token),
+        "result": format!("{:?}", 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);
+            }
+        }
+        println!();
+    }
+
+    Ok(())
+}
+
+/// Route a commodity "perp sell" to a spot sell on HL
+async fn commodity_spot_sell(
+    spot_token: &str,
+    original_symbol: &str,
+    price: f64,
+    size: f64,
+    cfg: &config::HlConfig,
+    json_output: bool,
+) -> Result<()> {
+    if !json_output {
+        println!();
+        println!(
+            "  📝 {} trades as {}/USDC spot on Hyperliquid",
+            original_symbol,
+            spot_token
+        );
+        println!("  Placing spot limit SELL");
+        println!("  Token:    {}", spot_token.cyan());
+        println!("  Size:     {:.6}", size);
+        println!("  Price:    ${:.2}", price);
+        println!(
+            "  Network:  {}",
+            if cfg.testnet { "Testnet" } else { "Mainnet" }
+        );
+        println!();
+    }
+
+    let result = signing::place_spot_order(spot_token, false, price, size).await?;
+
+    let response = json!({
+        "action": "commodity_spot_sell",
+        "symbol": original_symbol,
+        "spotToken": spot_token,
+        "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),
+    });
+
+    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);
+            }
+        }
+        println!();
+    }
+
+    Ok(())
+}

src/commands/quote.rs

@@ -357,9 +357,141 @@ 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
+    let commodity_token = commodity_to_spot_token(symbol);
+    if let Some(token) = commodity_token {
+        return fetch_hl_commodity_as_perp(client, symbol, token).await;
+    }
+
     anyhow::bail!("Symbol {} not found in Hyperliquid perps", symbol)
 }
 
+/// 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() {
+        "SILVER" | "XAG" => Some("SLV"),
+        "GOLD" | "XAU" | "XAUT" => Some("XAUT0"),
+        "SLV" => Some("SLV"),
+        "XAUT0" => Some("XAUT0"),
+        "GLD" => Some("GLD"),
+        _ => None,
+    }
+}
+
+/// Fetch commodity spot data and format it like a perp quote
+async fn fetch_hl_commodity_as_perp(
+    client: &reqwest::Client,
+    original_symbol: &str,
+    token_name: &str,
+) -> Result<Value> {
+    let url = config::info_url();
+
+    let meta_resp: Value = client
+        .post(&url)
+        .json(&json!({"type": "spotMetaAndAssetCtxs"}))
+        .send()
+        .await?
+        .json()
+        .await
+        .context("Failed to parse spotMetaAndAssetCtxs")?;
+
+    let tokens = meta_resp
+        .get(0)
+        .and_then(|m| m.get("tokens"))
+        .and_then(|t| t.as_array())
+        .ok_or_else(|| anyhow::anyhow!("Failed to get spot tokens"))?;
+
+    let universe = meta_resp
+        .get(0)
+        .and_then(|m| m.get("universe"))
+        .and_then(|u| u.as_array())
+        .ok_or_else(|| anyhow::anyhow!("Failed to get spot universe"))?;
+
+    let ctxs = meta_resp
+        .get(1)
+        .and_then(|c| c.as_array())
+        .ok_or_else(|| anyhow::anyhow!("Failed to get spot contexts"))?;
+
+    // Find token index
+    let token_idx = tokens
+        .iter()
+        .find(|t| {
+            t.get("name")
+                .and_then(|n| n.as_str())
+                .map(|n| n.eq_ignore_ascii_case(token_name))
+                .unwrap_or(false)
+        })
+        .and_then(|t| t.get("index").and_then(|i| i.as_u64()))
+        .ok_or_else(|| anyhow::anyhow!("Token {} not found on HL spot", token_name))?;
+
+    // Find the pair with this token and USDC (index 0)
+    for (i, pair) in universe.iter().enumerate() {
+        if let Some(pair_tokens) = pair.get("tokens").and_then(|t| t.as_array()) {
+            let indices: Vec<u64> = pair_tokens.iter().filter_map(|t| t.as_u64()).collect();
+            if indices.contains(&token_idx) && indices.contains(&0) {
+                if let Some(ctx) = ctxs.get(i) {
+                    let mark_px = ctx
+                        .get("markPx")
+                        .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 volume = ctx
+                        .get("dayNtlVlm")
+                        .and_then(|f| f.as_str())
+                        .unwrap_or("")
+                        .to_string();
+                    let mid_px = ctx
+                        .get("midPx")
+                        .and_then(|f| f.as_str())
+                        .unwrap_or("")
+                        .to_string();
+                    let supply = ctx
+                        .get("circulatingSupply")
+                        .and_then(|f| f.as_str())
+                        .unwrap_or("")
+                        .to_string();
+                    let change_24h = calc_change(&mark_px, &prev_day_px);
+                    let pair_name = pair
+                        .get("name")
+                        .and_then(|n| n.as_str())
+                        .unwrap_or("")
+                        .to_string();
+
+                    return Ok(json!({
+                        "symbol": original_symbol,
+                        "spotToken": token_name,
+                        "spotPair": pair_name,
+                        "markPx": mark_px,
+                        "midPx": mid_px,
+                        "oraclePx": null,
+                        "change24h": change_24h,
+                        "funding": null,
+                        "premium": null,
+                        "openInterest": null,
+                        "volume24h": volume,
+                        "prevDayPx": prev_day_px,
+                        "circulatingSupply": supply,
+                        "maxLeverage": 1,
+                        "source": "Hyperliquid Spot (commodity)",
+                        "note": format!("{} trades as {}/USDC spot pair on Hyperliquid (no perp available)", original_symbol, token_name)
+                    }));
+                }
+            }
+        }
+    }
+
+    anyhow::bail!(
+        "Commodity {} (token {}) not found as spot pair on Hyperliquid",
+        original_symbol,
+        token_name
+    )
+}
+
 async fn fetch_yahoo_quote(client: &reqwest::Client, symbol: &str) -> Result<Value> {
     // If symbol is a known crypto, try -USD first (avoid stock ticker collisions like BTC=Grayscale)
     let is_crypto = coingecko_symbol_map().contains_key(symbol);
@@ -820,6 +952,17 @@ fn print_perp_quote(data: &Value) {
     println!("  Open Interest: {}", oi);
     println!("  24h Volume:    ${}", vol);
     println!("  Max Leverage:  {}x", max_lev);
-    println!("  Source:        {}", "Hyperliquid".yellow());
+    let source = data["source"].as_str().unwrap_or("Hyperliquid");
+    println!("  Source:        {}", source.yellow());
+    if let Some(note) = data["note"].as_str() {
+        println!("  ℹ️  {}", note.dimmed());
+    }
+    if let Some(token) = data["spotToken"].as_str() {
+        println!(
+            "  Spot Pair:     {}/USDC ({})",
+            token.cyan(),
+            data["spotPair"].as_str().unwrap_or("")
+        );
+    }
     println!();
 }