nansen-cli 1.8.0 → 1.9.0

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;

package/src/transfer.js

@@ -7,6 +7,8 @@
 import crypto from 'crypto';
 import { base58Encode, exportWallet, getWalletConfig, verifyPassword } from './wallet.js';
 import { keccak256, signSecp256k1, rlpEncode, bigIntToMinBuf } from './crypto.js';
+import { getWalletConnectAddress, sendTransactionViaWalletConnect } from './walletconnect-trading.js';
+import { EVM_CHAIN_IDS } from './chain-ids.js';
 
 // ============= Constants =============
 
@@ -27,7 +29,8 @@ const CHAIN_RPCS = {
   'solana': process.env.NANSEN_SOLANA_RPC || DEFAULT_SOLANA_RPC,
 };
 
-const CHAIN_IDS = { 'ethereum': 1, 'evm': 1, 'base': 8453 };
+// Alias: buildEvmTransaction uses 'evm' as a generic fallback
+const CHAIN_IDS = { ...EVM_CHAIN_IDS, evm: 1 };
 
 // ============= Base58 =============
 
@@ -587,12 +590,19 @@ async function broadcastTransaction(signedTx, chain) {
 // Exported for testing
 export { parseAmount, formatAmount, signEd25519, encodeCompactU16, base58Decode, base58DecodePubkey, deriveATA, validateEvmAddress, validateSolanaAddress, bigIntToHex };
 
-export async function sendTokens({ to, amount, chain, token = null, wallet = null, password, max = false, dryRun = false }) {
+export async function sendTokens({ to, amount, chain, token = null, wallet = null, password, max = false, dryRun = false, walletconnect = false }) {
   // Validate address
   const validate = chain === 'solana' ? validateSolanaAddress : validateEvmAddress;
   const v = validate(to);
   if (!v.valid) throw new Error(`Invalid recipient: ${v.error}`);
 
+  if (walletconnect) {
+    if (chain === 'solana') {
+      throw new Error('WalletConnect is only supported for EVM chains');
+    }
+    return sendTokensViaWalletConnect({ to, amount, chain, token, max, dryRun });
+  }
+
   const config = getWalletConfig();
   if (!verifyPassword(password, config)) throw new Error('Incorrect password');
 
@@ -701,6 +711,127 @@ export async function sendTokens({ to, amount, chain, token = null, wallet = nul
   };
 }
 
+/**
+ * Send tokens via WalletConnect (EVM only).
+ */
+async function sendTokensViaWalletConnect({ to, amount, chain, token, max, dryRun }) {
+  const rpcUrl = CHAIN_RPCS[chain] || CHAIN_RPCS.evm;
+  const chainId = CHAIN_IDS[chain] || 1;
+
+  const wcAddress = await getWalletConnectAddress();
+  if (!wcAddress) throw new Error('No WalletConnect session active. Run: walletconnect connect');
+
+  let txTo, txValue, txData, decimals = 18;
+
+  if (token) {
+    // Validate ERC-20 contract
+    const code = await rpcCall(rpcUrl, 'eth_getCode', [token, 'latest']);
+    if (!code || code === '0x' || code === '0x0') {
+      throw new Error(`Address ${token} is not a contract — not a valid ERC-20 token`);
+    }
+    const decResult = await rpcCall(rpcUrl, 'eth_call', [{ to: token, data: '0x313ce567' }, 'latest']);
+    decimals = parseInt(decResult, 16);
+
+    if (max) {
+      // Max ERC-20: full token balance
+      const balResult = await rpcCall(rpcUrl, 'eth_call', [{
+        to: token, data: '0x70a08231' + wcAddress.slice(2).toLowerCase().padStart(64, '0'),
+      }, 'latest']);
+      const tokenBalance = BigInt(balResult || '0x0');
+      if (tokenBalance === 0n) throw new Error('Token balance is zero');
+      amount = formatAmount(tokenBalance, decimals);
+      stderr(`  Max send: ${amount} (ERC-20)`);
+    }
+
+    const amountRaw = parseAmount(amount, decimals);
+    const toStripped = to.replace(/^0x/, '').padStart(64, '0');
+    const amtHex = amountRaw.toString(16).padStart(64, '0');
+
+    txTo = token;
+    txValue = '0';
+    txData = '0x' + ERC20_TRANSFER_SELECTOR + toStripped + amtHex;
+  } else {
+    // Native ETH
+    if (max) {
+      const balHex = await rpcCall(rpcUrl, 'eth_getBalance', [wcAddress, 'latest']);
+      const ethBalance = BigInt(balHex);
+      // Reserve gas estimate (3x gasLimit * baseFee estimate)
+      let estGasLimit;
+      try {
+        const dummyEstimate = await rpcCall(rpcUrl, 'eth_estimateGas', [
+          { from: wcAddress, to, value: '0x1' },
+        ]);
+        estGasLimit = BigInt(dummyEstimate) * 120n / 100n;
+      } catch {
+        estGasLimit = 21000n;
+      }
+      const feeHistory = await rpcCall(rpcUrl, 'eth_feeHistory', [4, 'latest', [50]]);
+      const baseFee = BigInt(feeHistory.baseFeePerGas[feeHistory.baseFeePerGas.length - 1]);
+      const safeReserve = baseFee * 2n * estGasLimit * 3n;
+      if (ethBalance <= safeReserve) throw new Error(`Insufficient balance: ${ethBalance} wei (need > ${safeReserve} for gas)`);
+      const maxAmount = ethBalance - safeReserve;
+      amount = formatAmount(maxAmount, 18);
+      stderr(`  Max send: ${amount} ETH (reserved ${formatAmount(safeReserve, 18)} for gas)`);
+    }
+
+    const amountRaw = parseAmount(amount, 18);
+    txTo = to;
+    txValue = amountRaw.toString();
+    txData = '0x';
+  }
+
+  if (dryRun) {
+    return {
+      dryRun: true,
+      from: wcAddress,
+      to, amount, token, chain,
+    };
+  }
+
+  // Estimate gas instead of hardcoding — ERC-20 transfers with hooks may need more than 100k
+  let gasLimit;
+  try {
+    const estimateParams = { from: wcAddress, to: txTo };
+    if (txData && txData !== '0x') estimateParams.data = txData;
+    if (txValue && txValue !== '0') estimateParams.value = '0x' + BigInt(txValue).toString(16);
+    const gasEstimate = await rpcCall(rpcUrl, 'eth_estimateGas', [estimateParams]);
+    gasLimit = (BigInt(gasEstimate) * 120n / 100n).toString(); // 20% buffer
+  } catch {
+    gasLimit = token ? '100000' : '21000'; // fallback
+  }
+
+  stderr('  Sending transaction via WalletConnect...');
+  const wcResult = await sendTransactionViaWalletConnect({
+    to: txTo,
+    data: txData,
+    value: txValue,
+    gas: gasLimit,
+    chainId,
+  });
+
+  let txHash;
+  if (wcResult.txHash) {
+    txHash = wcResult.txHash;
+  } else if (wcResult.signedTransaction) {
+    txHash = await broadcastTransaction(wcResult.signedTransaction, chain);
+  } else {
+    throw new Error('No transaction hash or signed transaction returned from WalletConnect');
+  }
+
+  // Wait for confirmation
+  const confirmation = await waitForEvmConfirmation(rpcUrl, txHash);
+
+  return {
+    success: true,
+    transactionHash: txHash,
+    confirmed: confirmation.confirmed,
+    ...(confirmation.blockNumber ? { blockNumber: confirmation.blockNumber } : {}),
+    from: wcAddress,
+    to, amount, token, chain,
+    explorer: getExplorerUrl(chain, txHash),
+  };
+}
+
 /**
  * Get block explorer URL for a transaction.
  */