nansen-cli 1.14.0 → 1.15.0

package/src/schema.json

@@ -1831,6 +1831,48 @@
           }
         }
       }
+    },
+    "wallet": {
+      "description": "Wallet management (local or Privy server wallets)",
+      "options": {
+        "provider": {
+          "type": "string",
+          "enum": ["local", "privy"],
+          "description": "Wallet provider (default: local). Use 'privy' for server-managed wallets."
+        }
+      },
+      "subcommands": {
+        "create": {
+          "description": "Create a new wallet",
+          "options": {
+            "name": { "type": "string", "description": "Wallet name (default: 'default')" }
+          }
+        },
+        "list": { "description": "List all wallets" },
+        "show": {
+          "description": "Show wallet details",
+          "options": {
+            "name": { "type": "string", "description": "Wallet name" }
+          }
+        },
+        "delete": {
+          "description": "Delete a wallet",
+          "options": {
+            "name": { "type": "string", "description": "Wallet name" }
+          }
+        },
+        "send": {
+          "description": "Send tokens or native currency",
+          "options": {
+            "to": { "type": "string", "required": true, "description": "Recipient address" },
+            "amount": { "type": "string", "description": "Amount to send" },
+            "chain": { "type": "string", "required": true, "description": "Blockchain to use" }
+          }
+        },
+        "export": { "description": "Export private keys (local only, requires password)" },
+        "default": { "description": "Set default wallet (local only)" },
+        "help": { "description": "Show wallet help" }
+      }
     }
   },
   "globalOptions": {
@@ -1879,13 +1921,11 @@
     "avalanche",
     "linea",
     "scroll",
-    "zksync",
     "mantle",
     "ronin",
     "sei",
     "plasma",
     "sonic",
-    "unichain",
     "monad",
     "hyperevm",
     "iotaevm"

package/src/trading.js

@@ -8,7 +8,7 @@
 import crypto from 'crypto';
 import fs from 'fs';
 import path from 'path';
-import { exportWallet, getDefaultAddress, showWallet, listWallets, getWalletConfig } from './wallet.js';
+import { exportWallet, getWalletConfig, 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';
@@ -68,6 +68,33 @@ const EVM_RPC_URLS = {
   base:     process.env.NANSEN_RPC_BASE     || 'https://mainnet.base.org',
 };
 
+/**
+ * Make a JSON-RPC call to an EVM RPC endpoint.
+ * @param {string} chain - Chain name (key into EVM_RPC_URLS)
+ * @param {string} method - JSON-RPC method name
+ * @param {Array} params - Method parameters
+ * @returns {Promise<*>} Parsed result value
+ * @throws {Error} If chain has no configured RPC or the RPC returns an error
+ */
+async function evmRpcCall(chain, method, params = []) {
+  const rpcUrl = EVM_RPC_URLS[chain];
+  if (!rpcUrl) throw new Error(`No RPC URL configured for chain: ${chain}`);
+  const res = await fetch(rpcUrl, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params }),
+  });
+  const text = await res.text();
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    throw new Error(`RPC endpoint returned non-JSON response (HTTP ${res.status}) for ${method}: ${text.slice(0, 100)}`);
+  }
+  if (body.error) throw new Error(`RPC error (${method}): ${body.error.message}`);
+  return body.result;
+}
+
 function getQuotesDir() {
   const configDir = path.join(process.env.HOME || process.env.USERPROFILE || '', '.nansen');
   return path.join(configDir, 'quotes');
@@ -187,7 +214,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, signerType = 'local') {
+export function saveQuote(quoteResponse, chain, signerType = 'local', privyWalletIds = null) {
   const dir = getQuotesDir();
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
@@ -198,6 +225,7 @@ export function saveQuote(quoteResponse, chain, signerType = 'local') {
   const quoteId = `${timestamp}-${hash}`;
 
   const data = { quoteId, chain, timestamp, signerType, response: quoteResponse };
+  if (privyWalletIds) data.privyWalletIds = privyWalletIds;
 
   fs.writeFileSync(path.join(dir, `${quoteId}.json`), JSON.stringify(data, null, 2), { mode: 0o600 });
   cleanupQuotes();
@@ -336,22 +364,8 @@ export function signEvmTransaction(txData, privateKeyHex, chain, nonce) {
  * @returns {Promise<number>} Nonce
  */
 export async function getEvmNonce(chain, address) {
-  const rpcUrl = EVM_RPC_URLS[chain];
-  if (!rpcUrl) throw new Error(`No RPC URL configured for chain: ${chain}`);
-
-  const res = await fetch(rpcUrl, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      jsonrpc: '2.0',
-      id: 1,
-      method: 'eth_getTransactionCount',
-      params: [address, 'pending'],
-    }),
-  });
-  const body = await res.json();
-  if (body.error) throw new Error(`RPC error: ${body.error.message}`);
-  return parseInt(body.result, 16);
+  const result = await evmRpcCall(chain, 'eth_getTransactionCount', [address, 'pending']);
+  return parseInt(result, 16);
 }
 
 /**
@@ -365,28 +379,21 @@ export async function getEvmNonce(chain, address) {
  * @returns {Promise<object>} Transaction receipt
  */
 export async function waitForReceipt(chain, txHash, timeoutMs = 30000, pollMs = 2000) {
-  const rpcUrl = EVM_RPC_URLS[chain];
-  if (!rpcUrl) throw new Error(`No RPC URL configured for chain: ${chain}`);
-
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
-    const res = await fetch(rpcUrl, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        jsonrpc: '2.0',
-        id: 1,
-        method: 'eth_getTransactionReceipt',
-        params: [txHash],
-      }),
-    });
-    const body = await res.json();
-    if (body.result) {
-      const status = parseInt(body.result.status, 16);
-      if (status !== 1) {
-        throw new Error(`Transaction reverted on-chain (status: ${body.result.status}). Tx: ${txHash}`);
+    try {
+      const receipt = await evmRpcCall(chain, 'eth_getTransactionReceipt', [txHash]);
+      if (receipt) {
+        const status = parseInt(receipt.status, 16);
+        if (status !== 1) {
+          throw new Error(`Transaction reverted on-chain (status: ${receipt.status}). Tx: ${txHash}`);
+        }
+        return receipt;
       }
-      return body.result;
+    } catch (e) {
+      // Re-throw confirmed on-chain reverts immediately; swallow transient RPC/network errors
+      if (e.message?.startsWith('Transaction reverted')) throw e;
+      // else: continue polling (pending tx, transient network error, etc.)
     }
     // Receipt not yet available — wait and retry
     await new Promise(r => setTimeout(r, pollMs));
@@ -399,30 +406,21 @@ export async function waitForReceipt(chain, txHash, timeoutMs = 30000, pollMs =
  * Returns { success: true } or { success: false, reason: string }.
  */
 export async function simulateEvmCall(chain, { from, to, data, value, gas }) {
-  const rpcUrl = EVM_RPC_URLS[chain];
-  if (!rpcUrl) return { success: true }; // Can't simulate, skip
+  if (!EVM_RPC_URLS[chain]) return { success: true }; // Can't simulate, skip
 
   try {
     const callObj = { from, to, data, value: value || '0x0' };
     if (gas) callObj.gas = gas; // Pass gas limit to catch under-gassed quotes
-    const res = await fetch(rpcUrl, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        jsonrpc: '2.0',
-        id: 1,
-        method: 'eth_call',
-        params: [callObj, 'latest'],
-      }),
-    });
-    const body = await res.json();
-    if (body.error) {
-      const reason = body.error.message || 'unknown';
-      return { success: false, reason };
+    await evmRpcCall(chain, 'eth_call', [callObj, 'latest']);
+    return { success: true };
+  } catch (e) {
+    const msg = e.message || 'unknown';
+    // Only block on actual contract-level revert errors from the RPC
+    if (msg.startsWith('RPC error (eth_call):')) {
+      return { success: false, reason: msg.replace(/^RPC error \(eth_call\): /, '') };
     }
+    // Network/infrastructure errors (fetch failure, rate limit, non-JSON response) → non-blocking
     return { success: true };
-  } catch {
-    return { success: true }; // Network error — don't block, let broadcast decide
   }
 }
 
@@ -431,23 +429,11 @@ export async function simulateEvmCall(chain, { from, to, data, value, gas }) {
  * Used to fix under-gassed quotes from aggregators.
  */
 export async function estimateEvmGas(chain, { from, to, data, value }) {
-  const rpcUrl = EVM_RPC_URLS[chain];
-  if (!rpcUrl) return null;
+  if (!EVM_RPC_URLS[chain]) return null;
 
   try {
-    const res = await fetch(rpcUrl, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        jsonrpc: '2.0',
-        id: 1,
-        method: 'eth_estimateGas',
-        params: [{ from, to, data, value: value || '0x0' }],
-      }),
-    });
-    const body = await res.json();
-    if (body.error) return null;
-    return parseInt(body.result, 16);
+    const result = await evmRpcCall(chain, 'eth_estimateGas', [{ from, to, data, value: value || '0x0' }]);
+    return parseInt(result, 16);
   } catch {
     return null;
   }
@@ -458,27 +444,16 @@ export async function estimateEvmGas(chain, { from, to, data, value }) {
  * Returns the allowance as a BigInt, or 0n on failure.
  */
 export async function checkErc20Allowance(chain, tokenAddress, ownerAddress, spenderAddress) {
-  const rpcUrl = EVM_RPC_URLS[chain];
-  if (!rpcUrl) return 0n;
+  if (!EVM_RPC_URLS[chain]) return 0n;
 
   try {
     // allowance(address,address) selector = 0xdd62ed3e
     const data = '0xdd62ed3e'
       + ownerAddress.slice(2).toLowerCase().padStart(64, '0')
       + spenderAddress.slice(2).toLowerCase().padStart(64, '0');
-    const res = await fetch(rpcUrl, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        jsonrpc: '2.0',
-        id: 1,
-        method: 'eth_call',
-        params: [{ to: tokenAddress, data }, 'latest'],
-      }),
-    });
-    const body = await res.json();
-    if (body.error || !body.result) return 0n;
-    return BigInt(body.result);
+    const result = await evmRpcCall(chain, 'eth_call', [{ to: tokenAddress, data }, 'latest']);
+    if (!result) return 0n;
+    return BigInt(result);
   } catch {
     return 0n;
   }
@@ -800,6 +775,8 @@ EXAMPLES:
         const isWalletConnect = walletName === 'walletconnect' || walletName === 'wc';
 
         let walletAddress;
+        let walletProvider = 'local';
+        let privyWalletIds = null;
         if (isWalletConnect) {
           if (chainType !== 'evm') {
             log('WalletConnect is only supported for EVM chains');
@@ -815,9 +792,21 @@ EXAMPLES:
         } else if (walletName) {
           const wallet = showWallet(walletName);
           walletAddress = chainType === 'solana' ? wallet.solana : wallet.evm;
+          if (wallet.provider === 'privy') {
+            walletProvider = 'privy';
+            privyWalletIds = wallet.privyWalletIds;
+          }
         } else {
           try {
-            walletAddress = getDefaultAddress(chainType);
+            const config = getWalletConfig();
+            if (config.defaultWallet) {
+              const wallet = showWallet(config.defaultWallet);
+              walletAddress = chainType === 'solana' ? wallet.solana : wallet.evm;
+              if (wallet.provider === 'privy') {
+                walletProvider = 'privy';
+                privyWalletIds = wallet.privyWalletIds;
+              }
+            }
           } catch {
             // No wallet configured — fall through to the check below
           }
@@ -861,7 +850,8 @@ EXAMPLES:
         log('');
         response.quotes.forEach((q, i) => log(formatQuote(q, i)));
 
-        const quoteId = saveQuote(response, chain, isWalletConnect ? 'walletconnect' : 'local');
+        const signerType = isWalletConnect ? 'walletconnect' : walletProvider;
+        const quoteId = saveQuote(response, chain, signerType, privyWalletIds);
         log(`\n  Quote ID: ${quoteId}`);
         log(`  Execute:  nansen trade execute --quote ${quoteId}`);
         if (response.quotes.length > 1) {
@@ -935,12 +925,18 @@ EXAMPLES:
           return;
         }
 
-        // Determine if this is a WalletConnect-signed quote
+        // Determine if this is a WalletConnect or Privy-signed quote
         const isWalletConnect = quoteData.signerType === 'walletconnect'
           || walletName === 'walletconnect' || walletName === 'wc';
+        const isPrivy = quoteData.signerType === 'privy';
 
         let exported = null;
-        if (!isWalletConnect) {
+        let privyClient = null;
+        if (isPrivy) {
+          // Privy signing -- import + instantiate once for all quotes
+          const { PrivyClient } = await import('./privy.js');
+          privyClient = new PrivyClient(process.env.PRIVY_APP_ID, process.env.PRIVY_APP_SECRET);
+        } else if (!isWalletConnect) {
           // Get wallet credentials once (before the loop)
           const walletConfig = getWalletConfig();
           let password = null;
@@ -1021,7 +1017,159 @@ EXAMPLES:
             let signedTransaction;
             let requestId;
 
-            if (chainType === 'solana') {
+            if (chainType === 'solana' && isPrivy) {
+              // Solana via Privy: sign the serialized transaction
+              let txBase64 = currentQuote.transaction;
+              if (typeof txBase64 === 'object' && txBase64.data) {
+                txBase64 = base58Decode(txBase64.data).toString('base64');
+              }
+              log('  Signing Solana transaction via Privy...');
+              const solWalletId = quoteData.privyWalletIds?.solana;
+              if (!solWalletId) throw new Error('No Solana Privy wallet ID in quote');
+              const signResult = await privyClient.signSolanaTransaction(solWalletId, txBase64);
+              signedTransaction = signResult.data?.signed_transaction || signResult.signed_transaction;
+              requestId = currentQuote.metadata?.requestId;
+
+            } else if (chainType === 'evm' && isPrivy) {
+              // EVM via Privy: sign-only, then broadcast via Trading API
+              const evmWalletId = quoteData.privyWalletIds?.evm;
+              if (!evmWalletId) throw new Error('No EVM Privy wallet ID in quote');
+
+              const walletResult = await privyClient.getWallet(evmWalletId);
+              const walletAddress = walletResult.address;
+
+              // Validate transaction.value (same checks as local wallet)
+              const isNative = isNativeToken(currentQuote.inputMint);
+              const txValue = BigInt(currentQuote.transaction.value || '0');
+              if (isNative) {
+                const expectedValue = BigInt(currentQuote.inAmount || currentQuote.inputAmount || '0');
+                if (txValue !== expectedValue) {
+                  log(`  ❌ Transaction value mismatch for ${quoteName}: tx.value=${txValue}, expected=${expectedValue}`);
+                  if (qi + 1 < endIndex) log(`  Trying next quote...`);
+                  lastQuoteError = `${quoteName} transaction value mismatch`;
+                  continue;
+                }
+              } else {
+                if (txValue > 0n) {
+                  log(`  ❌ ERC-20 swap has non-zero tx.value (${txValue}) for ${quoteName} — aborting`);
+                  if (qi + 1 < endIndex) log(`  Trying next quote...`);
+                  lastQuoteError = `${quoteName} unexpected tx.value`;
+                  continue;
+                }
+              }
+
+              // Handle approval if needed
+              if (currentQuote.approvalAddress && !isNative) {
+                const inputAmount = BigInt(currentQuote.inputAmount || currentQuote.inAmount || '0');
+                const existingAllowance = await checkErc20Allowance(
+                  chain, currentQuote.inputMint, walletAddress, currentQuote.approvalAddress
+                );
+
+                if (existingAllowance >= inputAmount && existingAllowance > 0n) {
+                  log(`  ✓ Sufficient allowance exists for ${quoteName}, skipping approval`);
+                } else {
+                  log(`  ⚠ Approval required → ${currentQuote.approvalAddress}`);
+                  const approvalNonce = await getEvmNonce(chain, walletAddress);
+                  const MAX_UINT256 = 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
+                  const approvalData = '0x095ea7b3'
+                    + currentQuote.approvalAddress.slice(2).toLowerCase().padStart(64, '0')
+                    + MAX_UINT256;
+                  const approvalMaxFee = currentQuote.transaction?.maxFeePerGas || currentQuote.transaction?.gasPrice || '1000000';
+                  const approvalPriorityFee = currentQuote.transaction?.maxPriorityFeePerGas || '1000000';
+                  const approvalSignResult = await privyClient.signEvmTransaction(evmWalletId, {
+                    to: currentQuote.inputMint,
+                    data: approvalData,
+                    value: '0x0',
+                    chain_id: chainConfig.chainId,
+                    nonce: toHex(approvalNonce),
+                    gas_limit: toHex(100000),
+                    max_fee_per_gas: toHex(approvalMaxFee),
+                    max_priority_fee_per_gas: toHex(approvalPriorityFee),
+                  });
+                  const signedApproval = approvalSignResult.data?.signed_transaction || approvalSignResult.signed_transaction;
+                  const approvalResult = await executeTransaction({ signedTransaction: signedApproval, chain, simulate: !noSimulate });
+                  if (approvalResult.status !== 'Success') {
+                    log(`  ❌ Approval failed for ${quoteName}: ${approvalResult.error || 'unknown'}`);
+                    if (qi + 1 < endIndex) log(`  Trying next quote...`);
+                    lastQuoteError = `${quoteName} approval failed`;
+                    continue;
+                  }
+                  log(`  Waiting for approval confirmation...`);
+                  try {
+                    const receipt = await waitForReceipt(chain, approvalResult.txHash);
+                    log(`  ✓ Approval confirmed in block ${parseInt(receipt.blockNumber, 16)}: ${approvalResult.txHash}`);
+                  } catch (receiptErr) {
+                    log(`  ❌ Approval may not have confirmed: ${receiptErr.message}`);
+                    if (qi + 1 < endIndex) log(`  Trying next quote...`);
+                    lastQuoteError = `${quoteName} approval unconfirmed`;
+                    continue;
+                  }
+                  await new Promise(r => setTimeout(r, 2000));
+                }
+              }
+
+              // Pre-flight simulation
+              if (!noSimulate) {
+                const sim = await simulateEvmCall(chain, {
+                  from: walletAddress,
+                  to: currentQuote.transaction.to,
+                  data: currentQuote.transaction.data,
+                  value: currentQuote.transaction.value ? '0x' + BigInt(currentQuote.transaction.value).toString(16) : '0x0',
+                });
+                if (!sim.success) {
+                  log(`  ⚠ Simulation failed for ${quoteName}: ${sim.reason}`);
+                  if (qi + 1 < endIndex) log(`  Trying next quote...`);
+                  lastQuoteError = `${quoteName} simulation failed: ${sim.reason}`;
+                  continue;
+                }
+              }
+
+              // Gas resolution — fall back to eth_estimateGas if quote has no gas
+              const txData = currentQuote.transaction;
+              const apiGas = parseInt(currentQuote.gas || '0');
+              const txGas = parseInt(txData.gas || txData.gasLimit || '0');
+              let finalGas = apiGas > 0 ? apiGas : txGas;
+              if (finalGas === 0) {
+                try {
+                  const rpcUrl = EVM_RPC_URLS[chain];
+                  const estRes = await fetch(rpcUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                      jsonrpc: '2.0', id: 1, method: 'eth_estimateGas',
+                      params: [{
+                        from: walletAddress, to: txData.to, data: txData.data || '0x',
+                        value: txData.value ? '0x' + BigInt(txData.value).toString(16) : '0x0',
+                      }],
+                    }),
+                  });
+                  const estBody = await estRes.json();
+                  if (estBody.result) finalGas = Math.ceil(parseInt(estBody.result, 16) * 1.5);
+                } catch { /* ignore */ }
+                if (finalGas === 0) finalGas = 210000;
+              }
+
+              log('  Fetching nonce...');
+              const nonce = await getEvmNonce(chain, walletAddress);
+
+              // Privy signs EIP-1559 (type 2) transactions, so convert gasPrice to EIP-1559 fields
+              const maxFee = txData.maxFeePerGas || txData.gasPrice || '1000000';
+              const priorityFee = txData.maxPriorityFeePerGas || '1000000';
+
+              log('  Signing EVM transaction via Privy...');
+              const signResult = await privyClient.signEvmTransaction(evmWalletId, {
+                to: txData.to,
+                data: txData.data || '0x',
+                value: txData.value ? '0x' + BigInt(txData.value).toString(16) : '0x0',
+                chain_id: chainConfig.chainId,
+                nonce: toHex(nonce),
+                gas_limit: toHex(finalGas),
+                max_fee_per_gas: toHex(maxFee),
+                max_priority_fee_per_gas: toHex(priorityFee),
+              });
+              signedTransaction = signResult.data?.signed_transaction || signResult.signed_transaction;
+
+            } else if (chainType === 'solana') {
               // Solana: transaction is either a base64 string (Jupiter) or an object
               // with a base58-encoded `data` field (OKX). Normalize to base64.
               let txBase64 = currentQuote.transaction;