nansen-cli 1.5.1 → 1.7.0

package/src/cli.js

@@ -4,6 +4,8 @@
  */
 
 import { NansenAPI, NansenError, ErrorCode, saveConfig, deleteConfig, getConfigFile, clearCache, getCacheDir, validateAddress, sleep } from './api.js';
+import { buildWalletCommands } from './wallet.js';
+import { buildTradingCommands } from './trading.js';
 import fs from 'fs';
 import { getUpdateNotification, scheduleUpdateCheck } from './update-check.js';
 import { createRequire } from 'module';
@@ -165,12 +167,20 @@ export const SCHEMA = {
     'token': {
       description: 'Token God Mode - deep analytics for any token',
       subcommands: {
+        'indicators': {
+          description: 'Risk and reward indicators for a token (Nansen Score)',
+          options: {
+            token: { type: 'string', required: true, description: 'Token address' },
+            chain: { type: 'string', default: 'ethereum' }
+          },
+          returns: ['token_info[market_cap_usd, market_cap_group, is_stablecoin]', 'risk_indicators[indicator_type, score, signal, signal_percentile, last_trigger_on]', 'reward_indicators[indicator_type, score, signal, signal_percentile, last_trigger_on]']
+        },
         'info': {
           description: 'Get detailed information for a specific token',
           options: {
             token: { type: 'string', required: true, description: 'Token address' },
             chain: { type: 'string', default: 'solana' },
-            timeframe: { type: 'string', default: '24h', enum: ['5m', '10m', '1h', '6h', '24h', '7d', '30d'] }
+            timeframe: { type: 'string', default: '1d', enum: ['5m', '1h', '6h', '12h', '1d', '7d'] }
           },
           returns: ['token_address', 'token_symbol', 'token_name', 'chain', 'price_usd', 'volume_usd', 'market_cap', 'holder_count', 'liquidity_usd']
         },
@@ -279,6 +289,16 @@ export const SCHEMA = {
         }
       }
     },
+    'search': {
+      description: 'Search for tokens and entities across Nansen',
+      options: {
+        query: { type: 'string', required: true, description: 'Search query (token name, symbol, address, or entity)' },
+        type: { type: 'string', default: 'any', enum: ['token', 'entity', 'any'], description: 'Result type filter' },
+        chain: { type: 'string', description: 'Filter by chain (e.g., ethereum, solana)' },
+        limit: { type: 'number', default: 25, description: 'Max results (1-50)' }
+      },
+      returns: ['tokens[name, symbol, chain, address, price, volume_24h, market_cap, rank]', 'entities[name, tags, rank]', 'total_results']
+    },
     'points': {
       description: 'Nansen Points analytics',
       subcommands: {
@@ -299,7 +319,8 @@ export const SCHEMA = {
     fields: { type: 'string', description: 'Comma-separated list of fields to include in output' },
     'no-retry': { type: 'boolean', description: 'Disable automatic retry on rate limits/errors' },
     retries: { type: 'number', default: 3, description: 'Max retry attempts' },
-    format: { type: 'string', enum: ['json', 'csv'], description: 'Output format (default: json)' }
+    format: { type: 'string', enum: ['json', 'csv'], description: 'Output format (default: json)' },
+    'x402-payment-signature': { type: 'string', description: 'Pre-signed x402 payment signature header' }
   },
   chains: ['ethereum', 'solana', 'base', 'bnb', 'arbitrum', 'polygon', 'optimism', 'avalanche', 'linea', 'scroll', 'mantle', 'ronin', 'sei', 'plasma', 'sonic', 'monad', 'hyperevm', 'iotaevm'],
   smartMoneyLabels: ['Fund', 'Smart Trader', '30D Smart Trader', '90D Smart Trader', '180D Smart Trader', 'Smart HL Perps Trader']
@@ -820,14 +841,17 @@ COMMANDS:
   login          Save your API key (interactive)
   logout         Remove saved API key
   schema         Output JSON schema for all commands (for agent introspection)
+  wallet         Local wallet management (create, list, show, export, default, delete)
+  quote          Get a DEX swap quote (chain, tokens, amount)
+  execute        Sign and broadcast a quoted trade
   cache          Cache management (clear)
   smart-money    Smart Money analytics (netflow, dex-trades, perp-trades, holdings, dcas, historical-holdings)
   profiler       Wallet profiling (balance, labels, transactions, pnl, pnl-summary, search,
                    historical-balances, related-wallets, counterparties, perp-positions, perp-trades,
                    batch, trace, compare)
-  token          Token God Mode (info, screener, holders, flows, dex-trades, pnl, who-bought-sold,
-                   flow-intelligence, transfers, jup-dca, perp-trades, perp-positions,
-                   perp-pnl-leaderboard)
+  token          Token God Mode (info, indicators, screener, holders, flows, dex-trades, pnl,
+                   who-bought-sold, flow-intelligence, transfers, jup-dca, perp-trades,
+                   perp-positions, perp-pnl-leaderboard)
   portfolio      Portfolio analytics (defi)
   perp           Perpetual futures analytics (screener, leaderboard)
   points         Nansen Points analytics (leaderboard)
@@ -847,6 +871,7 @@ GLOBAL OPTIONS:
   --symbol       Token symbol (for perp endpoints)
   --no-retry     Disable automatic retry on rate limits/errors
   --retries <n>  Max retry attempts (default: 3)
+  --x402-payment-signature <sig>  Pre-signed x402 payment signature header
   --cache        Enable response caching (default: off)
   --no-cache     Disable cache for this request
   --cache-ttl <s> Cache TTL in seconds (default: 300)
@@ -948,10 +973,16 @@ export function buildCommands(deps = {}) {
 
   return {
     'login': async (args, apiInstance, flags, options) => {
-      log('Nansen CLI Login\n');
-      log('Get your API key at: https://app.nansen.ai/api\n');
-      
-      const apiKey = await promptFn('Enter your API key: ', true);
+      // Support non-interactive: nansen login --api-key <key>
+      let apiKey = options['api-key'] || options.apiKey;
+
+      if (!apiKey) {
+        log('Nansen CLI Login\n');
+        log('Get your API key at: https://app.nansen.ai/api\n');
+        log('Tip: For non-interactive use: nansen login --api-key <key>\n');
+        
+        apiKey = await promptFn('Enter your API key: ', true);
+      }
       
       if (!apiKey || apiKey.trim().length === 0) {
         log('\n❌ No API key provided');
@@ -1179,7 +1210,8 @@ export function buildCommands(deps = {}) {
       }
 
       const handlers = {
-        'info': () => apiInstance.tokenInformation({ tokenAddress, chain, timeframe }),
+        'indicators': () => apiInstance.tokenIndicators({ tokenAddress, chain }),
+        'info': () => apiInstance.tokenInformation({ tokenAddress, chain, timeframe: options.timeframe }),
         'screener': async () => {
           const search = options.search;
           // When searching, fetch more results to filter from (API has no server-side search)
@@ -1292,6 +1324,15 @@ export function buildCommands(deps = {}) {
       return handlers[subcommand]();
     },
 
+    'search': async (args, apiInstance, flags, options) => {
+      return apiInstance.generalSearch({
+        query: args[0] || options.query,
+        resultType: options.type,
+        chain: options.chain,
+        limit: options.limit
+      });
+    },
+
     'points': async (args, apiInstance, flags, options) => {
       const subcommand = args[0] || 'help';
       const tier = options.tier;
@@ -1316,7 +1357,7 @@ export function buildCommands(deps = {}) {
 }
 
 // Commands that don't require API authentication
-export const NO_AUTH_COMMANDS = ['login', 'logout', 'help', 'schema', 'cache'];
+export const NO_AUTH_COMMANDS = ['login', 'logout', 'help', 'schema', 'cache', 'wallet', 'quote', 'execute'];
 
 // Command aliases for convenience
 export const COMMAND_ALIASES = {
@@ -1459,7 +1500,7 @@ export async function runCLI(rawArgs, deps = {}) {
   scheduleUpdateCheck();
   const notify = () => { if (updateNotification) errorOutput(updateNotification); };
 
-  const commands = { ...buildCommands(deps), ...commandOverrides };
+  const commands = { ...buildCommands(deps), ...buildWalletCommands(deps), ...buildTradingCommands(deps), ...commandOverrides };
 
   if (flags.version || flags.v) {
     output(VERSION);
@@ -1492,10 +1533,12 @@ export async function runCLI(rawArgs, deps = {}) {
         return { type: 'command-help', command };
       }
     }
-    // Fallback to main help
-    output(BANNER + HELP);
-    notify();
-    return { type: 'help' };
+    // Commands with handlers (e.g. quote, execute) show their own usage
+    if (command === 'help' || !commands[command]) {
+      output(BANNER + HELP);
+      notify();
+      return { type: 'help' };
+    }
   }
 
   if (!commands[command]) {
@@ -1538,7 +1581,11 @@ export async function runCLI(rawArgs, deps = {}) {
       ttl: options['cache-ttl'] !== undefined ? options['cache-ttl'] : 300
     };
     
-    const api = new NansenAPIClass(undefined, undefined, { retry: retryOptions, cache: cacheOptions });
+    const defaultHeaders = {};
+    if (options['x402-payment-signature']) {
+      defaultHeaders['Payment-Signature'] = options['x402-payment-signature'];
+    }
+    const api = new NansenAPIClass(undefined, undefined, { retry: retryOptions, cache: cacheOptions, defaultHeaders });
     let result = await commands[command](subArgs, api, flags, options);
     
     // Apply field filtering if --fields is specified
@@ -1566,7 +1613,7 @@ export async function runCLI(rawArgs, deps = {}) {
   } catch (error) {
     const errorData = formatError(error);
     const formatted = formatOutput(errorData, { pretty, table, csv });
-    errorOutput(formatted.text);
+    output(formatted.text);
     notify();
     exit(1);
     return { type: 'error', data: errorData };

package/src/crypto.js

@@ -0,0 +1,215 @@
+/**
+ * Shared cryptographic primitives for EVM transaction signing.
+ * Exports keccak256, secp256k1 ECDSA signing, RLP encoding.
+ * Zero external dependencies — uses Node.js built-in crypto only.
+ */
+
+import crypto from "crypto";
+
+// ============= Keccak-256 =============
+
+// Keccak-256 (NOT SHA3-256; Ethereum uses original Keccak with 0x01 padding).
+// Uses a flat 25-element state array (lanes indexed as state[x + 5*y])
+// with BigInt64 arithmetic.
+
+const RC = [
+  0x0000000000000001n, 0x0000000000008082n, 0x800000000000808an, 0x8000000080008000n,
+  0x000000000000808bn, 0x0000000080000001n, 0x8000000080008081n, 0x8000000000008009n,
+  0x000000000000008an, 0x0000000000000088n, 0x0000000080008009n, 0x000000008000000an,
+  0x000000008000808bn, 0x800000000000008bn, 0x8000000000008089n, 0x8000000000008003n,
+  0x8000000000008002n, 0x8000000000000080n, 0x000000000000800an, 0x800000008000000an,
+  0x8000000080008081n, 0x8000000000008080n, 0x0000000080000001n, 0x8000000080008008n,
+];
+
+const ROT = [
+   0,  1, 62, 28, 27,
+  36, 44,  6, 55, 20,
+   3, 10, 43, 25, 39,
+  41, 45, 15, 21,  8,
+  18,  2, 61, 56, 14,
+];
+
+const M = 0xffffffffffffffffn;
+
+function rot64(v, r) {
+  return r === 0 ? v : ((v << BigInt(r)) | (v >> BigInt(64 - r))) & M;
+}
+
+function keccakF(s) {
+  for (let round = 0; round < 24; round++) {
+    const c0 = s[0] ^ s[5] ^ s[10] ^ s[15] ^ s[20];
+    const c1 = s[1] ^ s[6] ^ s[11] ^ s[16] ^ s[21];
+    const c2 = s[2] ^ s[7] ^ s[12] ^ s[17] ^ s[22];
+    const c3 = s[3] ^ s[8] ^ s[13] ^ s[18] ^ s[23];
+    const c4 = s[4] ^ s[9] ^ s[14] ^ s[19] ^ s[24];
+    const d0 = (c4 ^ rot64(c1, 1)) & M;
+    const d1 = (c0 ^ rot64(c2, 1)) & M;
+    const d2 = (c1 ^ rot64(c3, 1)) & M;
+    const d3 = (c2 ^ rot64(c4, 1)) & M;
+    const d4 = (c3 ^ rot64(c0, 1)) & M;
+    for (let y = 0; y < 25; y += 5) {
+      s[y]     = (s[y]     ^ d0) & M;
+      s[y + 1] = (s[y + 1] ^ d1) & M;
+      s[y + 2] = (s[y + 2] ^ d2) & M;
+      s[y + 3] = (s[y + 3] ^ d3) & M;
+      s[y + 4] = (s[y + 4] ^ d4) & M;
+    }
+    const t = new Array(25);
+    for (let x = 0; x < 5; x++) {
+      for (let y = 0; y < 5; y++) {
+        const src = x + 5 * y;
+        const dst = y + 5 * ((2 * x + 3 * y) % 5);
+        t[dst] = rot64(s[src], ROT[src]);
+      }
+    }
+    for (let y = 0; y < 25; y += 5) {
+      const t0 = t[y], t1 = t[y+1], t2 = t[y+2], t3 = t[y+3], t4 = t[y+4];
+      s[y]   = (t0 ^ ((~t1 & M) & t2)) & M;
+      s[y+1] = (t1 ^ ((~t2 & M) & t3)) & M;
+      s[y+2] = (t2 ^ ((~t3 & M) & t4)) & M;
+      s[y+3] = (t3 ^ ((~t4 & M) & t0)) & M;
+      s[y+4] = (t4 ^ ((~t0 & M) & t1)) & M;
+    }
+    s[0] = (s[0] ^ RC[round]) & M;
+  }
+}
+
+export function keccak256(input) {
+  const rate = 136;
+  const s = new Array(25).fill(0n);
+  const blocks = Math.max(1, Math.ceil((input.length + 1) / rate));
+  const padded = Buffer.alloc(blocks * rate);
+  input.copy(padded);
+  padded[input.length] ^= 0x01;
+  padded[padded.length - 1] ^= 0x80;
+  for (let off = 0; off < padded.length; off += rate) {
+    for (let i = 0; i < 17; i++) {
+      s[i] ^= padded.readBigUInt64LE(off + i * 8);
+    }
+    keccakF(s);
+  }
+  const out = Buffer.alloc(32);
+  for (let i = 0; i < 4; i++) {
+    out.writeBigUInt64LE(s[i] & M, i * 8);
+  }
+  return out;
+}
+
+// ============= secp256k1 ECDSA =============
+
+const P = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2Fn;
+const N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141n;
+const Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798n;
+const Gy = 0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8n;
+
+function modInv(a, m) {
+  let [old_r, r] = [((a % m) + m) % m, m];
+  let [old_s, s] = [1n, 0n];
+  while (r !== 0n) {
+    const q = old_r / r;
+    [old_r, r] = [r, old_r - q * r];
+    [old_s, s] = [s, old_s - q * s];
+  }
+  return ((old_s % m) + m) % m;
+}
+
+function ptAdd(x1, y1, x2, y2) {
+  if (x1 === null) return [x2, y2];
+  if (x2 === null) return [x1, y1];
+  if (x1 === x2 && y1 === y2) {
+    const lam = (3n * x1 * x1 * modInv(2n * y1, P)) % P;
+    const x3 = ((lam * lam - 2n * x1) % P + P) % P;
+    return [x3, ((lam * (x1 - x3) - y1) % P + P) % P];
+  }
+  if (x1 === x2) return [null, null];
+  const lam = (((y2 - y1) % P + P) * modInv(((x2 - x1) % P + P) % P, P)) % P;
+  const x3 = ((lam * lam - x1 - x2) % P + P) % P;
+  return [x3, ((lam * (x1 - x3) - y1) % P + P) % P];
+}
+
+function ptMul(k, x, y) {
+  let [rx, ry] = [null, null];
+  let [qx, qy] = [x, y];
+  while (k > 0n) {
+    if (k & 1n) [rx, ry] = ptAdd(rx, ry, qx, qy);
+    [qx, qy] = ptAdd(qx, qy, qx, qy);
+    k >>= 1n;
+  }
+  return [rx, ry];
+}
+
+function rfc6979k(privBuf, hash) {
+  let v = Buffer.alloc(32, 0x01);
+  let k = Buffer.alloc(32, 0x00);
+  k = crypto.createHmac('sha256', k).update(Buffer.concat([v, Buffer.from([0x00]), privBuf, hash])).digest();
+  v = crypto.createHmac('sha256', k).update(v).digest();
+  k = crypto.createHmac('sha256', k).update(Buffer.concat([v, Buffer.from([0x01]), privBuf, hash])).digest();
+  v = crypto.createHmac('sha256', k).update(v).digest();
+  while (true) {
+    v = crypto.createHmac('sha256', k).update(v).digest();
+    const candidate = BigInt('0x' + v.toString('hex'));
+    if (candidate >= 1n && candidate < N) return candidate;
+    k = crypto.createHmac('sha256', k).update(Buffer.concat([v, Buffer.from([0x00])])).digest();
+    v = crypto.createHmac('sha256', k).update(v).digest();
+  }
+}
+
+/**
+ * Sign a 32-byte hash with secp256k1 ECDSA.
+ * Uses RFC 6979 deterministic k and low-S normalization (EIP-2).
+ * Returns { r, s, v } where v is the recovery ID (0 or 1).
+ */
+export function signSecp256k1(hash, privateKey) {
+  const z = BigInt('0x' + hash.toString('hex'));
+  const d = BigInt('0x' + privateKey.toString('hex'));
+  const k = rfc6979k(privateKey, hash);
+  const [rx, ry] = ptMul(k, Gx, Gy);
+  const r = rx % N;
+  if (r === 0n) throw new Error('Invalid signature: r=0');
+  let s = (modInv(k, N) * ((z + r * d) % N)) % N;
+  if (s === 0n) throw new Error('Invalid signature: s=0');
+  let v = (ry % 2n === 0n) ? 0 : 1;
+  if (s > N >> 1n) { s = N - s; v ^= 1; }
+  return {
+    r: Buffer.from(r.toString(16).padStart(64, '0'), 'hex'),
+    s: Buffer.from(s.toString(16).padStart(64, '0'), 'hex'),
+    v,
+  };
+}
+
+// ============= RLP Encoding =============
+
+export function bigIntToMinBuf(n) {
+  if (n === 0n) return Buffer.alloc(0);
+  const hex = n.toString(16);
+  return Buffer.from(hex.length % 2 ? '0' + hex : hex, 'hex');
+}
+
+export function rlpEncode(input) {
+  if (Array.isArray(input)) {
+    const encoded = input.map(rlpEncode);
+    const payload = Buffer.concat(encoded);
+    if (payload.length < 56) {
+      return Buffer.concat([Buffer.from([0xc0 + payload.length]), payload]);
+    }
+    const lenBytes = bigIntToMinBuf(BigInt(payload.length));
+    return Buffer.concat([Buffer.from([0xf7 + lenBytes.length]), lenBytes, payload]);
+  }
+
+  let data;
+  if (Buffer.isBuffer(input)) {
+    data = input;
+  } else {
+    let hex = (typeof input === 'string' ? input : '').replace(/^0x/, '');
+    hex = hex.replace(/^0+/, '');
+    if (hex === '' || hex.length === 0) return Buffer.from([0x80]);
+    if (hex.length % 2) hex = '0' + hex;
+    data = Buffer.from(hex, 'hex');
+  }
+
+  if (data.length === 0) return Buffer.from([0x80]);
+  if (data.length === 1 && data[0] < 0x80) return data;
+  if (data.length < 56) return Buffer.concat([Buffer.from([0x80 + data.length]), data]);
+  const lenBytes = bigIntToMinBuf(BigInt(data.length));
+  return Buffer.concat([Buffer.from([0xb7 + lenBytes.length]), lenBytes, data]);
+}