nansen-cli 1.13.1 → 1.15.0

package/src/trading.js

@@ -8,10 +8,11 @@
 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';
+import { retrievePassword } from './keychain.js';
 
 // ============= Constants =============
 
@@ -67,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');
@@ -186,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 });
@@ -197,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();
@@ -335,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);
 }
 
 /**
@@ -364,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));
@@ -398,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
   }
 }
 
@@ -430,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;
   }
@@ -457,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;
   }
@@ -652,31 +628,15 @@ export function getWalletChainType(chainName) {
 
 // ============= CLI Helpers =============
 
-async function promptPassword(prompt, deps = {}) {
-  if (deps.promptFn) return deps.promptFn(prompt);
-  const readline = await import('readline');
-  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
-  return new Promise((resolve) => {
-    process.stderr.write(prompt);
-    let input = '';
-    const stdin = process.stdin;
-    const wasRaw = stdin.isRaw;
-    if (stdin.setRawMode) stdin.setRawMode(true);
-    stdin.resume();
-    const onData = (ch) => {
-      const c = ch.toString();
-      if (c === '\n' || c === '\r') {
-        if (stdin.setRawMode) stdin.setRawMode(wasRaw || false);
-        stdin.removeListener('data', onData);
-        process.stderr.write('\n');
-        rl.close();
-        resolve(input);
-      } else if (c === '\u0003') { rl.close(); process.exit(1); }
-      else if (c === '\u007f' || c === '\b') { input = input.slice(0, -1); }
-      else { input += c; }
-    };
-    stdin.on('data', onData);
-  });
+function resolveTradePassword() {
+  const { password, source } = retrievePassword();
+  if (source === 'file') {
+    process.stderr.write(
+      '⚠️  Password loaded from ~/.nansen/wallets/.credentials (insecure — plaintext on disk).\n' +
+      '   For better security, migrate to OS keychain: nansen wallet secure\n'
+    );
+  }
+  return password;
 }
 
 function isNativeToken(mintAddress) {
@@ -815,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');
@@ -830,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
           }
@@ -876,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) {
@@ -950,17 +925,36 @@ 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();
-          const password = walletConfig.passwordHash
-            ? (process.env.NANSEN_WALLET_PASSWORD || await promptPassword('Enter wallet password: ', deps))
-            : null;
+          let password = null;
+          if (walletConfig.passwordHash) {
+            password = resolveTradePassword();
+            if (!password) {
+              log(JSON.stringify({
+                error: 'PASSWORD_REQUIRED',
+                message: 'Wallet is encrypted and no password was found.',
+                resolution: [
+                  'Set NANSEN_WALLET_PASSWORD environment variable',
+                  'Or run: nansen wallet create (password is saved to OS keychain automatically)',
+                ],
+              }));
+              exit(1);
+              return;
+            }
+          }
 
           let effectiveWalletName = walletName;
           if (!effectiveWalletName) {
@@ -1023,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;