nansen-cli 1.7.0 → 1.9.0

package/src/ens.js

@@ -0,0 +1,163 @@
+/**
+ * ENS (Ethereum Name Service) resolution
+ * Resolves .eth names to addresses using public APIs with onchain RPC fallback.
+ * Zero external dependencies.
+ */
+
+import https from 'https';
+import { keccak256 } from './crypto.js';
+
+const ENS_PATTERN = /^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?\.eth$/;
+
+const EVM_CHAINS = [
+  'ethereum', 'base', 'optimism', 'arbitrum', 'polygon', 'bnb',
+  'avalanche', 'fantom', 'gnosis', 'linea', 'scroll', 'zksync',
+  'blast', 'mantle', 'ronin', 'sei', 'plasma', 'sonic', 'unichain', 'monad', 'hyperevm', 'iotaevm'
+];
+
+/**
+ * Check if a string looks like an ENS name
+ */
+export function isEnsName(name) {
+  return typeof name === 'string' && ENS_PATTERN.test(name.trim());
+}
+
+/**
+ * Resolve an address input — if it's an ENS name, resolve it; otherwise pass through.
+ *
+ * @param {string} addressOrName - Address (0x...) or ENS name (*.eth)
+ * @param {string} chain - Chain context (ENS only resolves on EVM chains)
+ * @returns {Promise<{address: string, ensName?: string}>}
+ */
+export async function resolveAddress(addressOrName, chain = 'ethereum') {
+  if (!addressOrName || typeof addressOrName !== 'string') {
+    return { address: addressOrName };
+  }
+
+  const trimmed = addressOrName.trim();
+
+  if (!isEnsName(trimmed)) {
+    return { address: trimmed };
+  }
+
+  if (!EVM_CHAINS.includes(chain)) {
+    throw new Error(`ENS names can only be resolved on EVM chains, not ${chain}`);
+  }
+
+  const name = trimmed.toLowerCase();
+  const errors = [];
+
+  // Try ensideas API first (fast, no auth)
+  try {
+    const addr = await resolveViaEnsIdeas(name);
+    if (addr) return { address: addr, ensName: name };
+  } catch (e) {
+    errors.push(`ensideas: ${e.message}`);
+  }
+
+  // Fallback: onchain resolution via public RPC
+  try {
+    const addr = await resolveOnchain(name);
+    if (addr) return { address: addr, ensName: name };
+  } catch (e) {
+    errors.push(`onchain: ${e.message}`);
+  }
+
+  throw new Error(`Could not resolve ENS name: ${name}${errors.length ? ` (${errors.join('; ')})` : ''}`);
+}
+
+// ============= Resolvers =============
+
+function httpsGet(url, timeoutMs = 5000) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, { timeout: timeoutMs }, (res) => {
+      let data = '';
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        if (res.statusCode !== 200) return reject(new Error(`HTTP ${res.statusCode}`));
+        try { resolve(JSON.parse(data)); } catch (e) { reject(e); }
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
+  });
+}
+
+function httpsPost(url, body, timeoutMs = 5000) {
+  return new Promise((resolve, reject) => {
+    const payload = JSON.stringify(body);
+    const parsed = new URL(url);
+    const req = https.request({
+      hostname: parsed.hostname,
+      path: parsed.pathname,
+      method: 'POST',
+      timeout: timeoutMs,
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) }
+    }, (res) => {
+      let buf = '';
+      res.on('data', chunk => { buf += chunk; });
+      res.on('end', () => {
+        if (res.statusCode !== 200) return reject(new Error(`HTTP ${res.statusCode}`));
+        try { resolve(JSON.parse(buf)); } catch (e) { reject(e); }
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
+    req.write(payload);
+    req.end();
+  });
+}
+
+const VALID_ADDR = /^0x[0-9a-fA-F]{40}$/;
+
+async function resolveViaEnsIdeas(name) {
+  const result = await httpsGet(`https://api.ensideas.com/ens/resolve/${encodeURIComponent(name)}`);
+  if (result?.address && VALID_ADDR.test(result.address)) return result.address;
+  return null;
+}
+
+/**
+ * Compute ENS namehash using keccak256 from crypto.js
+ */
+function namehash(name) {
+  let node = Buffer.alloc(32, 0); // bytes32(0)
+  if (!name) return node.toString('hex');
+
+  const labels = name.split('.').reverse();
+  for (const label of labels) {
+    const labelHash = keccak256(Buffer.from(label, 'utf8'));
+    node = keccak256(Buffer.concat([node, labelHash]));
+  }
+  return node.toString('hex');
+}
+
+const ENS_REGISTRY = '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e';
+const ZERO_HASH = '0000000000000000000000000000000000000000000000000000000000000000';
+const RPC_URL = 'https://eth.llamarpc.com';
+
+async function resolveOnchain(name) {
+  const hash = namehash(name);
+
+  // Step 1: Get resolver from ENS registry — resolver(bytes32)
+  const resolverResult = await httpsPost(RPC_URL, {
+    jsonrpc: '2.0', id: 1, method: 'eth_call',
+    params: [{ to: ENS_REGISTRY, data: '0x0178b8bf' + hash }, 'latest']
+  });
+
+  const resolverHex = resolverResult?.result;
+  if (!resolverHex || resolverHex === '0x' || resolverHex.slice(2) === ZERO_HASH) return null;
+
+  const resolver = '0x' + resolverHex.slice(26);
+
+  // Step 2: Call addr(bytes32) on the resolver — selector 0x3b3b57de
+  const addrResult = await httpsPost(RPC_URL, {
+    jsonrpc: '2.0', id: 2, method: 'eth_call',
+    params: [{ to: resolver, data: '0x3b3b57de' + hash }, 'latest']
+  });
+
+  const addrHex = addrResult?.result;
+  if (!addrHex || addrHex === '0x' || addrHex.slice(2) === ZERO_HASH) return null;
+
+  const address = '0x' + addrHex.slice(26);
+  return VALID_ADDR.test(address) ? address : null;
+}

package/src/trading.js

@@ -11,6 +11,7 @@ import path from 'path';
 import { exportWallet, getDefaultAddress, showWallet, listWallets } from './wallet.js';
 import { base58Decode } from './transfer.js';
 import { keccak256, signSecp256k1, rlpEncode } from './crypto.js';
+import { getWalletConnectAddress, sendTransactionViaWalletConnect, sendApprovalViaWalletConnect } from './walletconnect-trading.js';
 
 // ============= Constants =============
 
@@ -23,6 +24,60 @@ const CHAIN_MAP = {
   bsc:      { index: '56',  type: 'evm',    chainId: 56,   name: 'BSC',      explorer: 'https://bscscan.com/tx/' },
 };
 
+// Extend when adding new EVM chains (e.g. arbitrum WETH, polygon WMATIC)
+const WRAPPED_NATIVE_TOKENS = {
+  ethereum: { address: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2', symbol: 'WETH', nativeSymbol: 'ETH' },
+  base:     { address: '0x4200000000000000000000000000000000000006', symbol: 'WETH', nativeSymbol: 'ETH' },
+  bsc:      { address: '0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c', symbol: 'WBNB', nativeSymbol: 'BNB' },
+};
+
+// Common token symbol → address lookup per chain.
+// Native sentinels: Solana uses native mint, EVM uses 0xeee…eee.
+// Wrapped-native addresses (WETH, WBNB) are derived from WRAPPED_NATIVE_TOKENS
+// to avoid duplication — keep that map as the single source of truth.
+const EVM_NATIVE = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
+const TOKEN_SYMBOLS = {
+  solana: {
+    SOL:  'So11111111111111111111111111111111111111112',
+    WSOL: 'So11111111111111111111111111111111111111112',
+    USDC: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+    USDT: 'Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB',
+  },
+  ethereum: {
+    ETH:  EVM_NATIVE,
+    WETH: WRAPPED_NATIVE_TOKENS.ethereum.address,
+    USDC: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+    USDT: '0xdac17f958d2ee523a2206206994597c13d831ec7',
+  },
+  base: {
+    ETH:  EVM_NATIVE,
+    WETH: WRAPPED_NATIVE_TOKENS.base.address,
+    USDC: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
+    // NOTE: Legacy L2-bridged USDT on Base. If Tether deploys natively on Base
+    // (like Circle did with USDC), this address will need updating.
+    USDT: '0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2',
+  },
+  bsc: {
+    BNB:  EVM_NATIVE,
+    WBNB: WRAPPED_NATIVE_TOKENS.bsc.address,
+    USDC: '0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d',
+    USDT: '0x55d398326f99059ff775485246999027b3197955',
+  },
+};
+
+/**
+ * Resolve a token symbol (e.g. "SOL", "USDC") to its canonical address
+ * for the given chain. Returns the input unchanged if no match is found
+ * (assumes it's already a raw address).
+ */
+export function resolveTokenAddress(symbolOrAddress, chainName) {
+  if (!symbolOrAddress || !chainName) return symbolOrAddress;
+  const chainTokens = TOKEN_SYMBOLS[chainName.toLowerCase()];
+  if (!chainTokens) return symbolOrAddress;
+  const resolved = chainTokens[symbolOrAddress.toUpperCase()];
+  return resolved || symbolOrAddress;
+}
+
 // Default public RPC endpoints (used for nonce fetching)
 const EVM_RPC_URLS = {
   ethereum: process.env.NANSEN_RPC_ETHEREUM || 'https://eth.llamarpc.com',
@@ -149,7 +204,7 @@ export async function executeTransaction(params, { retries = 2, retryDelayMs = 1
  * Save a quote response to disk for later execution.
  * @returns {string} Quote ID
  */
-export function saveQuote(quoteResponse, chain) {
+export function saveQuote(quoteResponse, chain, signerType = 'local') {
   const dir = getQuotesDir();
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
@@ -159,7 +214,7 @@ export function saveQuote(quoteResponse, chain) {
   const hash = crypto.randomBytes(4).toString('hex');
   const quoteId = `${timestamp}-${hash}`;
 
-  const data = { quoteId, chain, timestamp, response: quoteResponse };
+  const data = { quoteId, chain, timestamp, signerType, response: quoteResponse };
 
   fs.writeFileSync(path.join(dir, `${quoteId}.json`), JSON.stringify(data, null, 2), { mode: 0o600 });
   cleanupQuotes();
@@ -646,6 +701,47 @@ function isNativeToken(mintAddress) {
   return /^0x[eE]{40}$/.test(mintAddress);
 }
 
+/**
+ * Check if --from is a wrapped native token or native sentinel and return
+ * a warning string, or null if no warning is needed. Pure function.
+ */
+export function getWrappedNativeFromWarning(tokenAddress, chain) {
+  if (!tokenAddress || !chain) return null;
+  const wrapped = WRAPPED_NATIVE_TOKENS[chain.toLowerCase()];
+  if (!wrapped) return null;
+
+  const addr = tokenAddress.toLowerCase();
+
+  // Case 1: --from is wrapped token (e.g. WETH) — suggest native sentinel
+  if (addr === wrapped.address.toLowerCase()) {
+    return `Warning: --from is ${wrapped.symbol} (wrapped ${wrapped.nativeSymbol}). ` +
+      `If you hold native ${wrapped.nativeSymbol}, use: 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee`;
+  }
+
+  // Case 2: --from is native sentinel — mention the wrapped alternative
+  if (isNativeToken(tokenAddress)) {
+    return `Warning: --from is native ${wrapped.nativeSymbol}. ` +
+      `If you hold ${wrapped.symbol} instead, use: ${wrapped.address}`;
+  }
+
+  return null;
+}
+
+/**
+ * Check if amount contains a decimal point (i.e. not in base units).
+ * Returns an error string if invalid, or null if OK. Pure function.
+ */
+export function validateBaseUnitAmount(amount) {
+  if (!amount) return null;
+  const str = String(amount);
+  if (str.includes('.')) {
+    return 'Amount must be in base units (integer), not token units. ' +
+      'Examples: 1000000000 lamports = 1 SOL, 1000000000000000000 wei = 1 ETH, ' +
+      '1000000 = 1 USDC. Got: ' + str;
+  }
+  return null;
+}
+
 function formatQuote(quote, index) {
   const lines = [];
   const label = index !== undefined ? `  Quote #${index + 1}` : '  Best Quote';
@@ -672,8 +768,10 @@ export function buildTradingCommands(deps = {}) {
   return {
     'quote': async (args, apiInstance, flags, options) => {
       const chain = options.chain || args[0];
-      const from = options.from || options['from-token'] || args[1];
-      const to = options.to || options['to-token'] || args[2];
+      const fromRaw = options.from || options['from-token'] || args[1];
+      const toRaw = options.to || options['to-token'] || args[2];
+      const from = resolveTokenAddress(fromRaw, chain);
+      const to = resolveTokenAddress(toRaw, chain);
       const amount = options.amount || args[3];
       const walletName = options.wallet;
       const slippage = options.slippage;
@@ -687,8 +785,8 @@ Usage: nansen quote --chain <chain> --from <token> --to <token> --amount <baseUn
 
 OPTIONS:
   --chain <chain>           Chain: solana, ethereum, base, bsc
-  --from <address>          Input token address
-  --to <address>            Output token address
+  --from <symbol|address>   Input token (symbol like SOL, USDC or address)
+  --to <symbol|address>     Output token (symbol like USDC, ETH or address)
   --amount <units>          Amount in BASE UNITS (e.g. lamports, wei)
   --wallet <name>           Wallet name (default: default wallet)
   --slippage <pct>          Slippage as decimal (e.g. 0.03 for 3%). Default: 0.03
@@ -697,19 +795,41 @@ OPTIONS:
   --swap-mode <mode>        exactIn (default) or exactOut
 
 EXAMPLES:
+  nansen quote --chain solana --from SOL --to USDC --amount 1000000000
+  nansen quote --chain base --from ETH --to USDC --amount 1000000000000000000
   nansen quote --chain solana --from So11111111111111111111111111111111111111112 --to EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v --amount 1000000000
-  nansen quote --chain base --from 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee --to 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 --amount 1000000000000000000
 `);
         exit(1);
         return;
       }
 
+      const amountError = validateBaseUnitAmount(amount);
+      if (amountError) {
+        errorOutput(`Error: ${amountError}`);
+        exit(1);
+        return;
+      }
+
       try {
         const chainConfig = resolveChain(chain);
         const chainType = chainConfig.type === 'evm' ? 'evm' : 'solana';
 
+        const isWalletConnect = walletName === 'walletconnect' || walletName === 'wc';
+
         let walletAddress;
-        if (walletName) {
+        if (isWalletConnect) {
+          if (chainType !== 'evm') {
+            errorOutput('WalletConnect is only supported for EVM chains');
+            exit(1);
+            return;
+          }
+          walletAddress = await getWalletConnectAddress();
+          if (!walletAddress) {
+            errorOutput('No WalletConnect session active. Run: walletconnect connect');
+            exit(1);
+            return;
+          }
+        } else if (walletName) {
           const wallet = showWallet(walletName);
           walletAddress = chainType === 'solana' ? wallet.solana : wallet.evm;
         } else {
@@ -725,6 +845,9 @@ EXAMPLES:
         errorOutput(`\nFetching quote on ${chainConfig.name}...`);
         errorOutput(`  Wallet: ${walletAddress}`);
 
+        const fromWarning = getWrappedNativeFromWarning(from, chain);
+        if (fromWarning) errorOutput(`  ${fromWarning}`);
+
         const params = {
           chainIndex: chainConfig.index,
           fromTokenAddress: from,
@@ -751,9 +874,9 @@ EXAMPLES:
         errorOutput('');
         response.quotes.forEach((q, i) => errorOutput(formatQuote(q, i)));
 
-        const quoteId = saveQuote(response, chain);
+        const quoteId = saveQuote(response, chain, isWalletConnect ? 'walletconnect' : 'local');
         errorOutput(`\n  Quote ID: ${quoteId}`);
-        errorOutput(`  Execute:  nansen execute --quote ${quoteId}`);
+        errorOutput(`  Execute:  nansen trade execute --quote ${quoteId}`);
 
         if (response.quotes[0]?.approvalAddress && !isNativeToken(response.quotes[0]?.inputMint)) {
           errorOutput(`\n  Warning: This token swap requires an ERC-20 approval step.`);
@@ -764,7 +887,11 @@ EXAMPLES:
         return undefined; // Output already printed above
 
       } catch (err) {
-        errorOutput(`Error: ${err.message}`);
+        let message = err.message;
+        if (err.code === 'INVALID_AMOUNT' || /amount/i.test(err.message)) {
+          message += '. Amounts must be in base units (e.g., 1000000000 lamports for 1 SOL, 1000000000000000000 wei for 1 ETH)';
+        }
+        errorOutput(`Error: ${message}`);
         if (err.details) errorOutput(`  Details: ${JSON.stringify(err.details)}`);
         exit(1);
       }
@@ -777,7 +904,7 @@ EXAMPLES:
 
       if (!quoteId) {
         errorOutput(`
-Usage: nansen execute --quote <quoteId> [options]
+Usage: nansen trade execute --quote <quoteId> [options]
 
 OPTIONS:
   --quote <id>              Quote ID from 'nansen quote'
@@ -785,7 +912,7 @@ OPTIONS:
   --no-simulate             Skip pre-broadcast simulation
 
 EXAMPLES:
-  nansen execute --quote 1708900000000-abc123
+  nansen trade execute --quote 1708900000000-abc123
 `);
         exit(1);
         return;
@@ -818,21 +945,50 @@ EXAMPLES:
           return;
         }
 
-        // Get wallet credentials once (before the loop)
-        const password = process.env.NANSEN_WALLET_PASSWORD || await promptPassword('Enter wallet password: ', deps);
+        // Determine if this is a WalletConnect-signed quote
+        const isWalletConnect = quoteData.signerType === 'walletconnect'
+          || walletName === 'walletconnect' || walletName === 'wc';
 
-        let effectiveWalletName = walletName;
-        if (!effectiveWalletName) {
-          const list = listWallets();
-          effectiveWalletName = list.defaultWallet;
-        }
-        if (!effectiveWalletName) {
-          errorOutput('No wallet found. Create one with: nansen wallet create');
-          exit(1);
-          return;
+        let exported = null;
+        if (!isWalletConnect) {
+          // Get wallet credentials once (before the loop)
+          const password = process.env.NANSEN_WALLET_PASSWORD || await promptPassword('Enter wallet password: ', deps);
+
+          let effectiveWalletName = walletName;
+          if (!effectiveWalletName) {
+            const list = listWallets();
+            effectiveWalletName = list.defaultWallet;
+          }
+          if (!effectiveWalletName) {
+            errorOutput('No wallet found. Create one with: nansen wallet create');
+            exit(1);
+            return;
+          }
+
+          exported = exportWallet(effectiveWalletName, password);
+        } else {
+          // Verify WalletConnect session is still active and address matches quote
+          if (chainType !== 'evm') {
+            errorOutput('WalletConnect is only supported for EVM chains');
+            exit(1);
+            return;
+          }
+          const wcAddress = await getWalletConnectAddress();
+          if (!wcAddress) {
+            errorOutput('No WalletConnect session active. Run: walletconnect connect');
+            exit(1);
+            return;
+          }
+          // Check address matches the one used during quoting
+          const quoteWallet = quoteData.response?.quotes?.[0]?.transaction?.from
+            || quoteData.response?.metadata?.userWalletAddress;
+          if (quoteWallet && wcAddress.toLowerCase() !== quoteWallet.toLowerCase()) {
+            errorOutput(`Connected wallet (${wcAddress}) doesn't match quote. Get a new quote with --wallet walletconnect`);
+            exit(1);
+            return;
+          }
         }
 
-        const exported = exportWallet(effectiveWalletName, password);
         let lastQuoteError = null;
 
         for (let qi = startIndex; qi < endIndex; qi++) {
@@ -870,6 +1026,149 @@ EXAMPLES:
               signedTransaction = signSolanaTransaction(txBase64, exported.solana.privateKey);
               requestId = currentQuote.metadata?.requestId;
 
+            } else if (isWalletConnect) {
+              // EVM via WalletConnect: wallet signs and may broadcast
+              const wcAddress = await getWalletConnectAddress();
+              const isNative = isNativeToken(currentQuote.inputMint);
+
+              // Validate transaction.value (same checks as local wallet)
+              const txValue = BigInt(currentQuote.transaction.value || '0');
+              if (isNative) {
+                const expectedValue = BigInt(currentQuote.inAmount || currentQuote.inputAmount || '0');
+                if (txValue !== expectedValue) {
+                  errorOutput(`  ❌ Transaction value mismatch for ${quoteName}: tx.value=${txValue}, expected=${expectedValue}`);
+                  if (qi + 1 < endIndex) errorOutput(`  Trying next quote...`);
+                  lastQuoteError = `${quoteName} transaction value mismatch`;
+                  continue;
+                }
+              } else {
+                if (txValue > 0n) {
+                  errorOutput(`  ❌ ERC-20 swap has non-zero tx.value (${txValue}) for ${quoteName} — aborting`);
+                  if (qi + 1 < endIndex) errorOutput(`  Trying next quote...`);
+                  lastQuoteError = `${quoteName} unexpected tx.value`;
+                  continue;
+                }
+              }
+
+              // Handle approval via WalletConnect if needed
+              if (currentQuote.approvalAddress && !isNative) {
+                const inputAmount = BigInt(currentQuote.inputAmount || currentQuote.inAmount || '0');
+                const existingAllowance = await checkErc20Allowance(
+                  chain, currentQuote.inputMint, wcAddress, currentQuote.approvalAddress
+                );
+
+                if (existingAllowance >= inputAmount && existingAllowance > 0n) {
+                  errorOutput(`  ✓ Sufficient allowance exists for ${quoteName}, skipping approval`);
+                } else {
+                  errorOutput(`  ⚠ Approval required → ${currentQuote.approvalAddress}`);
+                  errorOutput(`  Sending approval via WalletConnect...`);
+                  try {
+                    const approvalResult = await sendApprovalViaWalletConnect(
+                      currentQuote.inputMint,
+                      currentQuote.approvalAddress,
+                      chainConfig.chainId,
+                    );
+                    let approvalTxHash = approvalResult.txHash;
+                    if (!approvalTxHash && approvalResult.signedTransaction) {
+                      // Wallet returned a signed tx instead of broadcasting — broadcast via Trading API
+                      errorOutput(`  Broadcasting approval via Trading API...`);
+                      const broadcastResult = await executeTransaction({
+                        signedTransaction: approvalResult.signedTransaction,
+                        chain,
+                        simulate: !noSimulate,
+                      });
+                      if (broadcastResult.status !== 'Success') {
+                        throw new Error(broadcastResult.error || 'broadcast failed');
+                      }
+                      approvalTxHash = broadcastResult.txHash;
+                    }
+                    if (approvalTxHash) {
+                      errorOutput(`  Waiting for approval confirmation...`);
+                      const receipt = await waitForReceipt(chain, approvalTxHash);
+                      errorOutput(`  ✓ Approval confirmed in block ${parseInt(receipt.blockNumber, 16)}: ${approvalTxHash}`);
+                    }
+                  } catch (approvalErr) {
+                    errorOutput(`  ❌ Approval failed for ${quoteName}: ${approvalErr.message}`);
+                    if (qi + 1 < endIndex) errorOutput(`  Trying next quote...`);
+                    lastQuoteError = `${quoteName} approval failed`;
+                    continue;
+                  }
+                  await new Promise(r => setTimeout(r, 2000));
+                  errorOutput('');
+                }
+              }
+
+              // Pre-flight simulation
+              if (!noSimulate) {
+                const txData = currentQuote.transaction;
+                const sim = await simulateEvmCall(chain, {
+                  from: wcAddress,
+                  to: txData.to,
+                  data: txData.data,
+                  value: txData.value ? '0x' + BigInt(txData.value).toString(16) : '0x0',
+                });
+                if (!sim.success) {
+                  errorOutput(`  ⚠ Simulation failed for ${quoteName}: ${sim.reason}`);
+                  if (qi + 1 < endIndex) errorOutput(`  Trying next quote...`);
+                  lastQuoteError = `${quoteName} simulation failed: ${sim.reason}`;
+                  continue;
+                }
+              }
+
+              // Resolve gas
+              const txData = currentQuote.transaction;
+              const apiGas = parseInt(currentQuote.gas || "0");
+              const txGas = parseInt(txData.gas || txData.gasLimit || "0");
+              const finalGas = apiGas > 0 ? apiGas : txGas;
+
+              // Send transaction via WalletConnect
+              errorOutput('  Sending transaction via WalletConnect...');
+              let wcResult;
+              try {
+                wcResult = await sendTransactionViaWalletConnect({
+                  to: txData.to,
+                  data: txData.data,
+                  value: txData.value || '0',
+                  gas: String(finalGas),
+                  chainId: chainConfig.chainId,
+                });
+              } catch (wcErr) {
+                errorOutput(`  ❌ WalletConnect transaction failed for ${quoteName}: ${wcErr.message}`);
+                if (qi + 1 < endIndex) errorOutput(`  Trying next quote...`);
+                lastQuoteError = `${quoteName}: ${wcErr.message}`;
+                continue;
+              }
+
+              if (wcResult.txHash) {
+                // Wallet broadcast — verify on-chain
+                errorOutput('  Verifying on-chain status...');
+                try {
+                  await waitForReceipt(chain, wcResult.txHash);
+                } catch (receiptErr) {
+                  errorOutput(`\n  ⚠ Transaction was broadcast but REVERTED on-chain!`);
+                  errorOutput(`    Tx Hash:   ${wcResult.txHash}`);
+                  errorOutput(`    Explorer:  ${chainConfig.explorer}${wcResult.txHash}`);
+                  errorOutput(`    Error:     ${receiptErr.message}`);
+                  if (qi + 1 < endIndex) {
+                    errorOutput(`  Trying next quote...`);
+                    lastQuoteError = `${quoteName} reverted on-chain`;
+                    continue;
+                  }
+                  exit(1);
+                  return;
+                }
+
+                errorOutput(`\n  ✓ Transaction successful!`);
+                errorOutput(`    Tx Hash:   ${wcResult.txHash}`);
+                errorOutput(`    Chain:       ${chainConfig.name}`);
+                errorOutput(`    Explorer:    ${chainConfig.explorer}${wcResult.txHash}`);
+                errorOutput('');
+                return undefined; // Success
+              }
+
+              // Wallet returned signedTransaction — fall through to broadcast via Trading API
+              signedTransaction = wcResult.signedTransaction;
+
             } else {
               // EVM: quote.transaction is { to, data, value, gas, gasPrice }
               const walletAddress = exported.evm.address;