Nansen Cli

{
  "$schema": "https://unpkg.com/@changesets/config@3.1.1/schema.json",
  "changelog": ["@changesets/changelog-github", { "repo": "nansen-ai/nansen-cli" }],
  "commit": false,
  "fixed": [],
  "linked": [],
  "access": "public",
  "baseBranch": "main",
  "updateInternalDependencies": "patch",
  "ignore": []
}

name: CI

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    
    strategy:
      matrix:
        node-version: [18, 20, 22]
    
    steps:
      - uses: actions/checkout@v4
      
      - name: Use Node.js ${{ matrix.node-version }}
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
          cache: 'npm'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Run tests
        run: npm test
      
      - name: Run linter (if available)
        run: npm run lint --if-present

  publish:
    needs: test
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
    permissions:
      contents: write
      pull-requests: write
      id-token: write

    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - uses: actions/setup-node@v4
        with:
          node-version: 20
          registry-url: 'https://registry.npmjs.org'

      - run: npm ci

      - name: Create Release Pull Request or Publish
        uses: changesets/action@v1
        with:
          version: npm run changeset:version
          publish: npm run changeset:publish
          createGithubReleases: true
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

# Dependencies
node_modules/

# Config with secrets
/config.json
.env

# OS
.DS_Store

# IDE
.vscode/
.idea/
coverage/

# Tests
src/__tests__/
*.test.js
vitest.config.js
coverage/

# Dev configs
.github/
.gitignore
.eslintrc*
.prettierrc*

# Docs (keep README)
CONTRIBUTING.md
CHANGELOG.md

# Local
config.json
.env
.DS_Store

MIT License

Copyright (c) 2026 Nansen

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

{
  "name": "nansen-cli",
  "version": "1.9.3",
  "description": "Command-line interface for Nansen API - designed for AI agents",
  "main": "src/index.js",
  "type": "module",
  "bin": {
    "nansen": "./src/index.js"
  },
  "files": [
    "src/*.js",
    "CHANGELOG.md"
  ],
  "scripts": {
    "start": "node src/index.js",
    "pretest": "node scripts/check-changeset.js",
    "test": "vitest run",
    "test:watch": "vitest",
    "test:coverage": "vitest run --coverage",
    "test:live": "NANSEN_LIVE_TEST=1 vitest run",
    "test:trade": "vitest run --config vitest.e2e.config.js",
    "changeset": "changeset",
    "changeset:version": "changeset version",
    "changeset:publish": "changeset publish"
  },
  "keywords": [
    "nansen",
    "crypto",
    "blockchain",
    "api",
    "cli",
    "ai-agent",
    "smart-money",
    "onchain",
    "defi",
    "solana",
    "ethereum"
  ],
  "author": "Nansen <dev@nansen.ai>",
  "license": "MIT",
  "repository": {
    "type": "git",
    "url": "git+https://github.com/nansen-ai/nansen-cli.git"
  },
  "bugs": {
    "url": "https://github.com/nansen-ai/nansen-cli/issues"
  },
  "homepage": "https://github.com/nansen-ai/nansen-cli#readme",
  "engines": {
    "node": ">=18.0.0"
  },
  "devDependencies": {
    "@changesets/changelog-github": "^0.5.1",
    "@changesets/cli": "^2.29.4",
    "@vitest/coverage-v8": "^4.0.18",
    "vitest": "^4.0.18"
  }
}

#!/usr/bin/env node

/**
 * Non-blocking check: warns if the current branch has no new changeset file
 * compared to main. Runs as a pretest hook so agents and humans see a reminder.
 * Always exits 0 — this is a nudge, not a gate.
 */

import { execSync } from "child_process";

try {
  const branch = execSync("git rev-parse --abbrev-ref HEAD", { encoding: "utf8" }).trim();
  if (branch === "main") process.exit(0);

  const newChangesets = execSync(
    "git diff main --name-only --diff-filter=A -- .changeset/*.md",
    { encoding: "utf8" }
  ).trim();

  if (!newChangesets) {
    console.error(
      "\x1b[33m[changeset] No new changeset file found on this branch. " +
      "If this PR changes user-facing behavior, add one: npx changeset\x1b[0m"
    );
  }
} catch {
  // Not a git repo, main doesn't exist, etc. — skip silently.
}

/**
 * CLI Smoke Tests
 * 
 * Minimal end-to-end tests that verify the CLI binary works.
 * Detailed logic tests are in cli.internal.test.js (with coverage).
 * 
 * These tests spawn subprocesses so they're slower and don't contribute
 * to coverage metrics, but they verify the real CLI works.
 */

import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { execSync } from 'child_process';
import fs from 'fs';
import os from 'os';
import path from 'path';
import { fileURLToPath } from 'url';

const __dirname = path.dirname(fileURLToPath(import.meta.url));
const CLI_PATH = path.join(__dirname, '..', 'index.js');

// Create a mock walletconnect binary that reports "not connected"
const MOCK_BIN_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'nansen-test-'));
const MOCK_WC_PATH = path.join(MOCK_BIN_DIR, 'walletconnect');
fs.writeFileSync(MOCK_WC_PATH, '#!/bin/sh\necho \'{"connected":false}\'\n');
fs.chmodSync(MOCK_WC_PATH, 0o755);

// Helper to run CLI commands
function runCLI(args, options = {}) {
  const env = {
    ...process.env,
    PATH: `${MOCK_BIN_DIR}:${process.env.PATH}`,
    NANSEN_API_KEY: 'test-key',
    ...options.env
  };
  
  try {
    const result = execSync(`node ${CLI_PATH} ${args}`, {
      encoding: 'utf8',
      env,
      timeout: 10000
    });
    return { stdout: result, exitCode: 0 };
  } catch (error) {
    return {
      stdout: error.stdout || '',
      stderr: error.stderr || '',
      exitCode: error.status
    };
  }
}

describe('CLI Smoke Tests', () => {
  afterAll(() => {
    fs.rmSync(MOCK_BIN_DIR, { recursive: true, force: true });
  });

  // =================== Help & Basic Commands ===================

  it('should show help', () => {
    const { stdout, exitCode } = runCLI('help');

    expect(exitCode).toBe(0);
    expect(stdout).toContain('Nansen CLI');
    expect(stdout).toContain('research');
    expect(stdout).toContain('trade');
    expect(stdout).toContain('wallet');
  });

  it('should show schema', () => {
    const { stdout, exitCode } = runCLI('schema');
    
    expect(exitCode).toBe(0);
    const schema = JSON.parse(stdout);
    expect(schema.version).toBeDefined();
    expect(schema.commands).toBeDefined();
  });

  // =================== JSON Output Format ===================

  it('should output valid JSON on error', () => {
    const { stdout, stderr, exitCode } = runCLI('smart-money netflow', {
      env: { NANSEN_API_KEY: 'invalid-key' }
    });

    // Should fail with network error but still output valid JSON (error goes to stderr)
    // Parse first JSON line only (stderr may contain update notifications)
    const output = stdout || stderr;
    const firstLine = output.split('\n').find(l => l.startsWith('{'));
    const result = JSON.parse(firstLine);
    expect(result.success).toBe(false);
    expect(result.error).toBeDefined();
    expect(result.code).toBeDefined();
  });

  it('should support --pretty flag', () => {
    const { stdout, exitCode } = runCLI('schema --pretty');
    
    expect(exitCode).toBe(0);
    expect(stdout).toContain('\n'); // Pretty JSON has newlines
    expect(() => JSON.parse(stdout)).not.toThrow();
  });

  // =================== Command Routing ===================

  it('should route research smart-money commands', () => {
    const { stdout } = runCLI('research smart-money help');
    expect(stdout).toContain('netflow');
  });

  it('should route research profiler commands', () => {
    const { stdout } = runCLI('research profiler help');
    expect(stdout).toContain('balance');
  });

  it('should route research token commands', () => {
    const { stdout } = runCLI('research token help');
    expect(stdout).toContain('screener');
    expect(stdout).toContain('ohlcv');
  });

  it('should still route deprecated smart-money path', () => {
    const { stdout } = runCLI('smart-money help');
    expect(stdout).toContain('netflow');
  });

  // =================== Environment Variables ===================

  it('should use NANSEN_API_KEY from environment', () => {
    const { stdout, stderr } = runCLI('smart-money netflow', {
      env: { NANSEN_API_KEY: 'test-env-key' }
    });
    
    // Will fail auth but proves env var is being read (error goes to stderr)
    // Parse first JSON line only (stderr may contain update notifications)
    const output = stdout || stderr;
    const firstLine = output.split('\n').find(l => l.startsWith('{'));
    const result = JSON.parse(firstLine);
    expect(result.success).toBe(false);
    expect(['UNAUTHORIZED', 'PAYMENT_REQUIRED', 'UNKNOWN']).toContain(result.code);
  });

  // =================== Error Handling ===================

  it('should handle unknown command gracefully', () => {
    const { stdout, exitCode } = runCLI('unknown-command');
    
    expect(exitCode).toBe(1);
    const result = JSON.parse(stdout);
    expect(result.error).toContain('Unknown command');
  });

  it('should handle unknown subcommand gracefully', () => {
    const { stdout } = runCLI('smart-money unknown-subcommand');
    
    const result = JSON.parse(stdout);
    expect(result.data.error).toContain('Unknown subcommand');
  });
});

/**
 * API Endpoint Coverage Test
 * 
 * Verifies all documented Nansen API endpoints are implemented
 */

import { describe, it, expect } from 'vitest';
import { NansenAPI } from '../api.js';
import { batchProfile, traceCounterparties, compareWallets } from '../cli.js';

// All documented endpoints from Nansen API
const DOCUMENTED_ENDPOINTS = {
  smartMoney: [
    { name: 'netflow', method: 'smartMoneyNetflow', endpoint: '/api/v1/smart-money/netflow' },
    { name: 'holdings', method: 'smartMoneyHoldings', endpoint: '/api/v1/smart-money/holdings' },
    { name: 'dex-trades', method: 'smartMoneyDexTrades', endpoint: '/api/v1/smart-money/dex-trades' },
    { name: 'dcas', method: 'smartMoneyDcas', endpoint: '/api/v1/smart-money/dcas' },
    { name: 'perp-trades', method: 'smartMoneyPerpTrades', endpoint: '/api/v1/smart-money/perp-trades' },
    { name: 'historical-holdings', method: 'smartMoneyHistoricalHoldings', endpoint: '/api/v1/smart-money/historical-holdings' },
  ],
  profiler: [
    { name: 'balance', method: 'addressBalance', endpoint: '/api/v1/profiler/address/current-balance' },
    { name: 'labels', method: 'addressLabels', endpoint: '/api/beta/profiler/address/labels' },
    { name: 'transactions', method: 'addressTransactions', endpoint: '/api/v1/profiler/address/transactions' },
    { name: 'pnl', method: 'addressPnl', endpoint: '/api/v1/profiler/address/pnl-and-trade-performance' },
    { name: 'search', method: 'entitySearch', endpoint: '/api/beta/profiler/entity-name-search' },
    { name: 'historical-balances', method: 'addressHistoricalBalances', endpoint: '/api/v1/profiler/address/historical-balances' },
    { name: 'related-wallets', method: 'addressRelatedWallets', endpoint: '/api/v1/profiler/address/related-wallets' },
    { name: 'counterparties', method: 'addressCounterparties', endpoint: '/api/v1/profiler/address/counterparties' },
    { name: 'pnl-summary', method: 'addressPnlSummary', endpoint: '/api/v1/profiler/address/pnl-summary' },
    { name: 'perp-positions', method: 'addressPerpPositions', endpoint: '/api/v1/profiler/perp-positions' },
    { name: 'perp-trades', method: 'addressPerpTrades', endpoint: '/api/v1/profiler/perp-trades' },
  ],
  tokenGodMode: [
    { name: 'indicators', method: 'tokenIndicators', endpoint: '/api/v1/tgm/indicators' },
    { name: 'token-ohlcv', method: 'tokenOhlcv', endpoint: '/api/v1/tgm/token-ohlcv' },
    { name: 'screener', method: 'tokenScreener', endpoint: '/api/v1/token-screener' },
    { name: 'holders', method: 'tokenHolders', endpoint: '/api/v1/tgm/holders' },
    { name: 'flows', method: 'tokenFlows', endpoint: '/api/v1/tgm/flows' },
    { name: 'dex-trades', method: 'tokenDexTrades', endpoint: '/api/v1/tgm/dex-trades' },
    { name: 'pnl-leaderboard', method: 'tokenPnlLeaderboard', endpoint: '/api/v1/tgm/pnl-leaderboard' },
    { name: 'who-bought-sold', method: 'tokenWhoBoughtSold', endpoint: '/api/v1/tgm/who-bought-sold' },
    { name: 'flow-intelligence', method: 'tokenFlowIntelligence', endpoint: '/api/v1/tgm/flow-intelligence' },
    { name: 'transfers', method: 'tokenTransfers', endpoint: '/api/v1/tgm/transfers' },
    { name: 'jup-dca', method: 'tokenJupDca', endpoint: '/api/v1/tgm/jup-dca' },
    { name: 'perp-trades', method: 'tokenPerpTrades', endpoint: '/api/v1/tgm/perp-trades' },
    { name: 'perp-positions', method: 'tokenPerpPositions', endpoint: '/api/v1/tgm/perp-positions' },
    { name: 'perp-pnl-leaderboard', method: 'tokenPerpPnlLeaderboard', endpoint: '/api/v1/tgm/perp-pnl-leaderboard' },
  ],
  composite: [
    { name: 'batch-profile', fn: batchProfile, endpoint: 'composite' },
    { name: 'trace-counterparties', fn: traceCounterparties, endpoint: 'composite' },
    { name: 'compare-wallets', fn: compareWallets, endpoint: 'composite' },
  ],
  portfolio: [
    { name: 'defi-holdings', method: 'portfolioDefiHoldings', endpoint: '/api/v1/portfolio/defi-holdings' },
  ],
  search: [
    { name: 'general-search', method: 'generalSearch', endpoint: '/api/v1/search/general' },
  ],
};

// Endpoints that are documented but return 404 (confirmed non-existent)
const NOT_IMPLEMENTED = [
  // These endpoints return 404 and should NOT be implemented
  // 'perpLeaderboard' - Profiler perp-leaderboard returns 404
  // 'tokenPerpScreener' - TGM perp-screener returns 404
];

describe('API Endpoint Coverage', () => {
  const api = new NansenAPI('test-key');

  describe('Smart Money Endpoints', () => {
    for (const ep of DOCUMENTED_ENDPOINTS.smartMoney) {
      it(`should have ${ep.name} method`, () => {
        expect(typeof api[ep.method]).toBe('function');
      });
    }
  });

  describe('Profiler Endpoints', () => {
    for (const ep of DOCUMENTED_ENDPOINTS.profiler) {
      it(`should have ${ep.name} method`, () => {
        expect(typeof api[ep.method]).toBe('function');
      });
    }
  });

  describe('Token God Mode Endpoints', () => {
    for (const ep of DOCUMENTED_ENDPOINTS.tokenGodMode) {
      it(`should have ${ep.name} method`, () => {
        expect(typeof api[ep.method]).toBe('function');
      });
    }
  });

  describe('Composite Methods', () => {
    for (const ep of DOCUMENTED_ENDPOINTS.composite) {
      it(`should have ${ep.name} as exported function from cli.js`, () => {
        expect(typeof ep.fn).toBe('function');
      });
    }
  });

  describe('Portfolio Endpoints', () => {
    for (const ep of DOCUMENTED_ENDPOINTS.portfolio) {
      it(`should have ${ep.name} method`, () => {
        expect(typeof api[ep.method]).toBe('function');
      });
    }
  });

  describe('Search Endpoints', () => {
    for (const ep of DOCUMENTED_ENDPOINTS.search) {
      it(`should have ${ep.name} method`, () => {
        expect(typeof api[ep.method]).toBe('function');
      });
    }
  });

  describe('Coverage Summary', () => {
    it('should report implemented endpoints', () => {
      const implemented = [
        ...DOCUMENTED_ENDPOINTS.smartMoney,
        ...DOCUMENTED_ENDPOINTS.profiler,
        ...DOCUMENTED_ENDPOINTS.tokenGodMode,
        ...DOCUMENTED_ENDPOINTS.composite,
        ...DOCUMENTED_ENDPOINTS.portfolio,
        ...DOCUMENTED_ENDPOINTS.search,
      ];
      
      console.log(`\n📊 API Coverage Summary:`);
      console.log(`   Implemented: ${implemented.length} endpoints`);
      console.log(`   Not yet implemented: ${NOT_IMPLEMENTED.length} endpoints`);
      console.log(`   Coverage: ${((implemented.length / (implemented.length + NOT_IMPLEMENTED.length)) * 100).toFixed(1)}%`);
      
      if (NOT_IMPLEMENTED.length > 0) {
        console.log(`\n⚠️  Missing endpoints:`);
        NOT_IMPLEMENTED.forEach(ep => console.log(`   - ${ep}`));
      }
      
      expect(implemented.length).toBeGreaterThan(0);
    });
  });
});

describe('Supported Chains Coverage', () => {
  const DOCUMENTED_CHAINS = [
    'ethereum', 'solana', 'base', 'bnb', 'arbitrum',
    'polygon', 'optimism', 'avalanche', 'linea', 'scroll',
    'zksync', 'mantle', 'ronin', 'sei', 'plasma',
    'sonic', 'unichain', 'monad', 'hyperevm', 'iotaevm'
  ];

  it('should document all supported chains', () => {
    // Just verify the list is comprehensive
    expect(DOCUMENTED_CHAINS).toContain('ethereum');
    expect(DOCUMENTED_CHAINS).toContain('solana');
    expect(DOCUMENTED_CHAINS).toContain('base');
    expect(DOCUMENTED_CHAINS.length).toBeGreaterThanOrEqual(20);
    
    console.log(`\n🔗 Supported Chains: ${DOCUMENTED_CHAINS.length}`);
    console.log(`   ${DOCUMENTED_CHAINS.join(', ')}`);
  });
});

describe('Smart Money Labels Coverage', () => {
  const DOCUMENTED_LABELS = [
    'Fund',
    'Smart Trader',
    '30D Smart Trader',
    '90D Smart Trader',
    '180D Smart Trader',
    'Smart HL Perps Trader',
  ];

  it('should document all smart money labels', () => {
    expect(DOCUMENTED_LABELS).toContain('Fund');
    expect(DOCUMENTED_LABELS).toContain('Smart Trader');
    expect(DOCUMENTED_LABELS.length).toBeGreaterThanOrEqual(6);
    
    console.log(`\n🏷️  Smart Money Labels: ${DOCUMENTED_LABELS.length}`);
    DOCUMENTED_LABELS.forEach(label => console.log(`   - ${label}`));
  });
});

/**
 * Tests for shared crypto primitives (keccak256, signSecp256k1, rlpEncode).
 */

import { describe, it, expect } from "vitest";
import crypto from "crypto";
import { keccak256, signSecp256k1, rlpEncode, bigIntToMinBuf } from "../crypto.js";

describe("keccak256", () => {
  it("hashes empty string to known value", () => {
    const hash = keccak256(Buffer.alloc(0));
    expect(hash.toString("hex")).toBe(
      "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"
    );
  });

  it('hashes "abc" to known value', () => {
    const hash = keccak256(Buffer.from("abc"));
    expect(hash.toString("hex")).toBe(
      "4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45"
    );
  });

  it("computes ERC-20 transfer selector correctly", () => {
    // keccak256("transfer(address,uint256)") first 4 bytes = 0xa9059cbb
    const hash = keccak256(Buffer.from("transfer(address,uint256)"));
    expect(hash.subarray(0, 4).toString("hex")).toBe("a9059cbb");
  });
});

describe("signSecp256k1", () => {
  const privKey = Buffer.from(
    "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
    "hex"
  );

  it("produces 32-byte r and s with v of 0 or 1", () => {
    const hash = crypto.randomBytes(32);
    const sig = signSecp256k1(hash, privKey);
    expect(sig.r.length).toBe(32);
    expect(sig.s.length).toBe(32);
    expect([0, 1]).toContain(sig.v);
  });

  it("is deterministic (RFC 6979)", () => {
    const hash = Buffer.from(
      "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
      "hex"
    );
    const sig1 = signSecp256k1(hash, privKey);
    const sig2 = signSecp256k1(hash, privKey);
    expect(sig1.r.toString("hex")).toBe(sig2.r.toString("hex"));
    expect(sig1.s.toString("hex")).toBe(sig2.s.toString("hex"));
    expect(sig1.v).toBe(sig2.v);
  });

  it("produces correct signature for known key and hash", () => {
    // Private key = 1 (well-known: derives to 0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf)
    const key = Buffer.from(
      "0000000000000000000000000000000000000000000000000000000000000001",
      "hex"
    );
    const hash = Buffer.from(
      "0000000000000000000000000000000000000000000000000000000000000001",
      "hex"
    );
    const sig = signSecp256k1(hash, key);
    expect(sig.r.toString("hex")).toBe(
      "6673ffad2147741f04772b6f921f0ba6af0c1e77fc439e65c36dedf4092e8898"
    );
    expect(sig.s.toString("hex")).toBe(
      "4c1a971652e0ada880120ef8025e709fff2080c4a39aae068d12eed009b68c89"
    );
    expect(sig.v).toBe(1);
  });

  it("enforces low-S normalization (EIP-2)", () => {
    const N =
      0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n;
    const halfN = N >> 1n;
    for (let i = 0; i < 10; i++) {
      const hash = crypto.randomBytes(32);
      const sig = signSecp256k1(hash, privKey);
      const s = BigInt("0x" + sig.s.toString("hex"));
      expect(s <= halfN).toBe(true);
    }
  });
});

describe("rlpEncode", () => {
  it("encodes empty buffer as 0x80", () => {
    expect(rlpEncode(Buffer.alloc(0))).toEqual(Buffer.from([0x80]));
  });

  it("encodes single byte < 0x80 as itself", () => {
    expect(rlpEncode(Buffer.from([0x7f]))).toEqual(Buffer.from([0x7f]));
  });

  it("encodes empty list as 0xc0", () => {
    expect(rlpEncode([])).toEqual(Buffer.from([0xc0]));
  });

  it("encodes hex string correctly", () => {
    expect(rlpEncode("0x0400")).toEqual(Buffer.from([0x82, 0x04, 0x00]));
  });
});

describe("bigIntToMinBuf", () => {
  it("returns empty buffer for 0n", () => {
    expect(bigIntToMinBuf(0n)).toEqual(Buffer.alloc(0));
  });

  it("returns minimal encoding for non-zero values", () => {
    expect(bigIntToMinBuf(1n)).toEqual(Buffer.from([0x01]));
    expect(bigIntToMinBuf(255n)).toEqual(Buffer.from([0xff]));
    expect(bigIntToMinBuf(256n)).toEqual(Buffer.from([0x01, 0x00]));
  });
});

import { describe, it, expect } from 'vitest';
import { isEnsName, resolveAddress } from '../ens.js';

describe('ENS Resolution', () => {
  describe('isEnsName', () => {
    it('recognizes valid ENS names', () => {
      expect(isEnsName('vitalik.eth')).toBe(true);
      expect(isEnsName('nansen.eth')).toBe(true);
      expect(isEnsName('my-wallet.eth')).toBe(true);
    });

    it('rejects non-ENS strings', () => {
      expect(isEnsName('0x1234567890abcdef1234567890abcdef12345678')).toBe(false);
      expect(isEnsName('not-ens')).toBe(false);
      expect(isEnsName('')).toBe(false);
      expect(isEnsName(null)).toBe(false);
      expect(isEnsName('sub.domain.eth')).toBe(false); // subdomains not matched by simple pattern
    });
  });

  describe('resolveAddress', () => {
    it('passes through raw addresses unchanged', async () => {
      const result = await resolveAddress('0x4a7C6899cdcB379e284fBFD045462e751DA4C7cE');
      expect(result.address).toBe('0x4a7C6899cdcB379e284fBFD045462e751DA4C7cE');
      expect(result.ensName).toBeUndefined();
    });

    it('passes through null/undefined', async () => {
      const result = await resolveAddress(null);
      expect(result.address).toBeNull();
    });

    it('rejects ENS on non-EVM chains', async () => {
      await expect(resolveAddress('nansen.eth', 'solana')).rejects.toThrow('EVM chains');
    });

    it('fails with descriptive error for unresolvable names', async () => {
      await expect(resolveAddress('zzznonexistent999999.eth')).rejects.toThrow('Could not resolve ENS name');
    }, 15000);
  });

  // Live resolution tests (require network)
  describe.skipIf(!process.env.NANSEN_LIVE_TEST)('live resolution', () => {
    it('resolves nansen.eth', async () => {
      const result = await resolveAddress('nansen.eth');
      expect(result.address).toMatch(/^0x[0-9a-fA-F]{40}$/);
      expect(result.ensName).toBe('nansen.eth');
    }, 10000);

    it('resolves vitalik.eth', async () => {
      const result = await resolveAddress('vitalik.eth');
      expect(result.address).toMatch(/^0x[0-9a-fA-F]{40}$/);
      expect(result.ensName).toBe('vitalik.eth');
    }, 10000);
  });
});

/**
 * Index.js entry point tests
 * Simple tests to ensure the entry point module works correctly
 */

import { describe, it, expect } from 'vitest';

describe('index.js', () => {
  it('should export runCLI from cli.js', async () => {
    // Dynamic import to test the module loads correctly
    const indexModule = await import('../index.js');
    
    // The index.js file imports and calls runCLI, but doesn't re-export it
    // We just verify the module loads without error
    expect(indexModule).toBeDefined();
  });

  it('should have correct shebang for CLI execution', async () => {
    const fs = await import('fs');
    const path = await import('path');
    const { fileURLToPath } = await import('url');
    
    const __dirname = path.dirname(fileURLToPath(import.meta.url));
    const indexPath = path.join(__dirname, '..', 'index.js');
    const content = fs.readFileSync(indexPath, 'utf-8');
    
    expect(content.startsWith('#!/usr/bin/env node')).toBe(true);
  });
});

/**
 * End-to-end swap tests — runs the actual CLI against mainnet.
 *
 * Prerequisites:
 *   - A wallet in ~/.nansen/wallets/ with ETH on Base and SOL on Solana
 *   - NANSEN_WALLET_PASSWORD env var set
 *
 * Run: npm run test:trade
 *
 * These tests execute REAL swaps with REAL funds. They are excluded
 * from the default test suite and must be run explicitly.
 *
 * Each round-trip swaps native → USDC → native so the only prerequisite
 * is having the gas token. Net cost is just gas + slippage.
 */

import { spawnSync } from 'child_process';
import { describe, it, expect } from 'vitest';
import path from 'path';

const CLI_PATH = path.resolve('src/index.js');

/**
 * Run the CLI and return { stdout, stderr, exitCode }.
 * Captures both stdout and stderr regardless of exit code.
 */
function runCli(...args) {
  const { stdout, stderr, status } = spawnSync('node', [CLI_PATH, ...args], {
    env: process.env,
    encoding: 'utf8',
    timeout: 120_000,
  });
  return { stdout: stdout || '', stderr: stderr || '', exitCode: status ?? 1 };
}

const BASE_USDC = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';
const BASE_ETH = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
const SWAP_AMOUNT_ETH = '270000000000000'; // ~$0.50 ETH (18 decimals)

describe.sequential('e2e: ETH ↔ USDC swap round-trip on Base', () => {
  const state = {
    forwardQuoteId: null,
    forwardTxHash: null,
    reverseQuoteId: null,
    reverseTxHash: null,
    receivedUsdcAmount: null,
  };

  it('should have NANSEN_WALLET_PASSWORD set', () => {
    expect(
      process.env.NANSEN_WALLET_PASSWORD,
      'Set NANSEN_WALLET_PASSWORD to run e2e tests'
    ).toBeDefined();
  });

  it('should have a wallet configured', () => {
    const result = runCli('wallet', 'list');
    const output = result.stdout + result.stderr;
    expect(output).toContain('EVM:');
  });

  it('quote ETH → USDC on Base', () => {
    const result = runCli(
      'trade', 'quote',
      '--chain', 'base',
      '--from', BASE_ETH,
      '--to', BASE_USDC,
      '--amount', SWAP_AMOUNT_ETH,
    );
    const output = result.stdout + result.stderr;

    const quoteMatch = output.match(/Quote ID:\s+(\S+)/);
    expect(quoteMatch, `Expected Quote ID in output:\n${output}`).toBeTruthy();
    state.forwardQuoteId = quoteMatch[1];
  });

  it('execute ETH → USDC swap', () => {
    expect(state.forwardQuoteId).toBeTruthy();

    const result = runCli(
      'trade', 'execute',
      '--quote', state.forwardQuoteId,
    );
    const output = result.stdout + result.stderr;

    expect(output).toContain('Transaction successful');

    const txMatch = output.match(/Tx Hash:\s+(0x[a-fA-F0-9]+)/);
    expect(txMatch, `Expected Tx Hash in output:\n${output}`).toBeTruthy();
    state.forwardTxHash = txMatch[1];
    console.log(`Forward swap: https://basescan.org/tx/${state.forwardTxHash}`);

    // Extract received USDC amount for the reverse swap (format: "Output:       500000 → 0x8335...")
    const swapMatch = output.match(/Output:\s+(\d+)\s+→/);
    expect(swapMatch, `Expected Output amount in output:\n${output}`).toBeTruthy();
    state.receivedUsdcAmount = swapMatch[1];
  });

  it('quote USDC → ETH on Base (reverse)', () => {
    expect(state.receivedUsdcAmount, 'Forward swap must capture USDC amount').toBeTruthy();

    const result = runCli(
      'trade', 'quote',
      '--chain', 'base',
      '--from', BASE_USDC,
      '--to', BASE_ETH,
      '--amount', state.receivedUsdcAmount,
    );
    const output = result.stdout + result.stderr;

    const quoteMatch = output.match(/Quote ID:\s+(\S+)/);
    expect(quoteMatch, `Expected Quote ID in output:\n${output}`).toBeTruthy();
    state.reverseQuoteId = quoteMatch[1];
  });

  it('execute USDC → ETH swap (reverse)', () => {
    expect(state.reverseQuoteId).toBeTruthy();

    const result = runCli(
      'trade', 'execute',
      '--quote', state.reverseQuoteId,
    );
    const output = result.stdout + result.stderr;

    expect(output).toContain('Transaction successful');

    const txMatch = output.match(/Tx Hash:\s+(0x[a-fA-F0-9]+)/);
    expect(txMatch, `Expected Tx Hash in output:\n${output}`).toBeTruthy();
    state.reverseTxHash = txMatch[1];
    console.log(`Reverse swap: https://basescan.org/tx/${state.reverseTxHash}`);
  });
});

const SOL_NATIVE = 'So11111111111111111111111111111111111111112';
const SOL_USDC = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';
const SWAP_AMOUNT_SOL = '2000000'; // 0.002 SOL (~$0.17, 9 decimals)

describe.sequential('e2e: SOL ↔ USDC swap round-trip on Solana', () => {
  const state = {
    forwardQuoteId: null,
    forwardSignature: null,
    reverseQuoteId: null,
    reverseSignature: null,
    receivedUsdcAmount: null,
  };

  it('should have NANSEN_WALLET_PASSWORD set', () => {
    expect(
      process.env.NANSEN_WALLET_PASSWORD,
      'Set NANSEN_WALLET_PASSWORD to run e2e tests'
    ).toBeDefined();
  });

  it('should have a wallet with Solana address', () => {
    const result = runCli('wallet', 'list');
    const output = result.stdout + result.stderr;
    expect(output).toContain('Solana:');
  });

  it('quote SOL → USDC on Solana', () => {
    const result = runCli(
      'trade', 'quote',
      '--chain', 'solana',
      '--from', SOL_NATIVE,
      '--to', SOL_USDC,
      '--amount', SWAP_AMOUNT_SOL,
    );
    const output = result.stdout + result.stderr;

    const quoteMatch = output.match(/Quote ID:\s+(\S+)/);
    expect(quoteMatch, `Expected Quote ID in output:\n${output}`).toBeTruthy();
    state.forwardQuoteId = quoteMatch[1];
  });

  it('execute SOL → USDC swap', () => {
    expect(state.forwardQuoteId).toBeTruthy();

    const result = runCli(
      'trade', 'execute',
      '--quote', state.forwardQuoteId,
    );
    const output = result.stdout + result.stderr;

    expect(output).toContain('Transaction successful');

    // Solana tx signatures are base58 strings (typically 87-88 chars)
    const sigMatch = output.match(/Signature:\s+([1-9A-HJ-NP-Za-km-z]{43,})/);
    expect(sigMatch, `Expected Signature in output:\n${output}`).toBeTruthy();
    state.forwardSignature = sigMatch[1];
    console.log(`Forward swap: https://solscan.io/tx/${state.forwardSignature}`);

    // Extract received USDC amount for the reverse swap
    const swapMatch = output.match(/Output:\s+(\d+)\s+→/);
    expect(swapMatch, `Expected Output amount in output:\n${output}`).toBeTruthy();
    state.receivedUsdcAmount = swapMatch[1];
  });

  it('quote USDC → SOL on Solana (reverse)', () => {
    expect(state.receivedUsdcAmount, 'Forward swap must capture USDC amount').toBeTruthy();

    const result = runCli(
      'trade', 'quote',
      '--chain', 'solana',
      '--from', SOL_USDC,
      '--to', SOL_NATIVE,
      '--amount', state.receivedUsdcAmount,
    );
    const output = result.stdout + result.stderr;

    const quoteMatch = output.match(/Quote ID:\s+(\S+)/);
    expect(quoteMatch, `Expected Quote ID in output:\n${output}`).toBeTruthy();
    state.reverseQuoteId = quoteMatch[1];
  });

  it('execute USDC → SOL swap (reverse)', () => {
    expect(state.reverseQuoteId).toBeTruthy();

    const result = runCli(
      'trade', 'execute',
      '--quote', state.reverseQuoteId,
    );
    const output = result.stdout + result.stderr;

    expect(output).toContain('Transaction successful');

    const sigMatch = output.match(/Signature:\s+([1-9A-HJ-NP-Za-km-z]{43,})/);
    expect(sigMatch, `Expected Signature in output:\n${output}`).toBeTruthy();
    state.reverseSignature = sigMatch[1];
    console.log(`Reverse swap: https://solscan.io/tx/${state.reverseSignature}`);
  });
});

/**
 * Tests for trading module
 *
 * Covers: chain resolution, quote storage, RLP encoding, compact-u16 parsing,
 * Solana signing, EVM signing (address recovery, decimal/hex handling, EIP-155),
 * ERC-20 approval building, API error handling, and CLI command validation.
 */

import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
import crypto from 'crypto';
import fs from 'fs';
import path from 'path';
import os from 'os';
import {
  resolveChain,
  getWalletChainType,
  saveQuote,
  loadQuote,
  cleanupQuotes,
  readCompactU16,
  toBuffer,
  signLegacyTransaction,
  signSolanaTransaction,
  signEvmTransaction,
  buildApprovalTransaction,
  stripLeadingZeros,
  buildTradingCommands,
  getWrappedNativeFromWarning,
  validateBaseUnitAmount,
  resolveTokenAddress,
  formatQuote,
} from '../trading.js';
import { keccak256, rlpEncode } from '../crypto.js';
import { base58Decode } from '../transfer.js';
import {
  base58Encode,
  generateEvmWallet,
  generateSolanaWallet,
  createWallet,
  listWallets,
} from '../wallet.js';
import * as wcTrading from '../walletconnect-trading.js';

let originalHome;
let tempDir;

beforeEach(() => {
  originalHome = process.env.HOME;
  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nansen-trading-test-'));
  process.env.HOME = tempDir;
});

afterEach(() => {
  process.env.HOME = originalHome;
  fs.rmSync(tempDir, { recursive: true, force: true });
});

// ============= Chain Resolution =============

describe('resolveChain', () => {
  it('should resolve all supported chains', () => {
    const expected = {
      solana:   { index: '501', type: 'solana', chainId: 501 },
      ethereum: { index: '1',   type: 'evm',    chainId: 1 },
      base:     { index: '8453', type: 'evm',   chainId: 8453 },
      bsc:      { index: '56',  type: 'evm',    chainId: 56 },
    };
    for (const [name, exp] of Object.entries(expected)) {
      const chain = resolveChain(name);
      expect(chain.index).toBe(exp.index);
      expect(chain.type).toBe(exp.type);
      expect(chain.chainId).toBe(exp.chainId);
      expect(chain.explorer).toMatch(/^https:\/\//);
    }
  });

  it('should be case-insensitive', () => {
    expect(resolveChain('SOLANA').index).toBe('501');
    expect(resolveChain('Base').index).toBe('8453');
    expect(resolveChain('BSC').chainId).toBe(56);
  });

  it('should throw for unsupported chain', () => {
    expect(() => resolveChain('polygon')).toThrow('Unsupported chain');
    expect(() => resolveChain('')).toThrow('Unsupported chain');
    expect(() => resolveChain(null)).toThrow('Unsupported chain');
    expect(() => resolveChain(undefined)).toThrow('Unsupported chain');
  });
});

describe('resolveTokenAddress', () => {
  it('should resolve common symbols to addresses', () => {
    expect(resolveTokenAddress('SOL', 'solana')).toBe('So11111111111111111111111111111111111111112');
    expect(resolveTokenAddress('USDC', 'solana')).toBe('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
    expect(resolveTokenAddress('ETH', 'base')).toBe('0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee');
    expect(resolveTokenAddress('USDC', 'base')).toBe('0x833589fcd6edb6e08f4c7c32d4f71b54bda02913');
    expect(resolveTokenAddress('BNB', 'bsc')).toBe('0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee');
    expect(resolveTokenAddress('ETH', 'ethereum')).toBe('0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee');
  });

  it('should be case-insensitive for symbols', () => {
    expect(resolveTokenAddress('sol', 'solana')).toBe('So11111111111111111111111111111111111111112');
    expect(resolveTokenAddress('usdc', 'ethereum')).toBe('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48');
    expect(resolveTokenAddress('Eth', 'base')).toBe('0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee');
  });

  it('should pass through raw addresses unchanged', () => {
    const addr = '0x1234567890abcdef1234567890abcdef12345678';
    expect(resolveTokenAddress(addr, 'ethereum')).toBe(addr);
    expect(resolveTokenAddress('So11111111111111111111111111111111111111112', 'solana'))
      .toBe('So11111111111111111111111111111111111111112');
  });

  it('should pass through unknown symbols unchanged', () => {
    expect(resolveTokenAddress('SHIB', 'solana')).toBe('SHIB');
  });

  it('should handle null/undefined gracefully', () => {
    expect(resolveTokenAddress(null, 'solana')).toBe(null);
    expect(resolveTokenAddress('SOL', null)).toBe('SOL');
    expect(resolveTokenAddress(undefined, undefined)).toBe(undefined);
  });
});

describe('getWalletChainType', () => {
  it('should return solana for solana', () => {
    expect(getWalletChainType('solana')).toBe('solana');
  });
  it('should return evm for all EVM chains', () => {
    for (const chain of ['ethereum', 'base', 'bsc']) {
      expect(getWalletChainType(chain)).toBe('evm');
    }
  });
});

// ============= Quote Storage =============

describe('quote storage', () => {
  // Mock responses matching actual API shapes
  const solanaQuoteResponse = {
    success: true,
    quotes: [{
      aggregator: 'jupiter',
      inputMint: 'So11111111111111111111111111111111111111112',
      outputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
      inAmount: '10000000',
      outAmount: '781370',
      inUsdValue: '0.78',
      outUsdValue: '0.78',
      transaction: 'AQAAAA==', // base64 transaction (Solana format)
      metadata: { requestId: 'test-req-id' },
    }],
    metadata: { chainIndex: '501', quotesCount: 1, bestQuote: 'jupiter' },
  };

  const evmQuoteResponse = {
    success: true,
    quotes: [{
      aggregator: 'okx',
      inputMint: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
      outputMint: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
      inAmount: '100000000000000',
      outAmount: '186872',
      inUsdValue: '0.19',
      outUsdValue: '0.19',
      approvalAddress: '0x57df6092665eb6058de53939612413ff4b09114e',
      transaction: {  // EVM format: object with fields
        to: '0x4409921ae43a39a11d90f7b7f96cfd0b8093d9fc',
        data: '0xf2c42696',
        value: '100000000000000',  // decimal string (not hex!)
        gas: '558000',             // decimal string
        gasPrice: '13560000',      // decimal string
      },
    }],
    metadata: { chainIndex: '8453', quotesCount: 1, bestQuote: 'okx' },
  };

  it('should save and load a Solana quote', () => {
    const quoteId = saveQuote(solanaQuoteResponse, 'solana');
    expect(quoteId).toMatch(/^\d+-[a-f0-9]+$/);

    const loaded = loadQuote(quoteId);
    expect(loaded.chain).toBe('solana');
    expect(loaded.response.quotes[0].aggregator).toBe('jupiter');
    expect(loaded.response.quotes[0].transaction).toBe('AQAAAA==');
    expect(loaded.response.quotes[0].metadata.requestId).toBe('test-req-id');
  });

  it('should save and load an EVM quote with transaction object', () => {
    const quoteId = saveQuote(evmQuoteResponse, 'base');
    const loaded = loadQuote(quoteId);
    expect(loaded.chain).toBe('base');
    expect(loaded.response.quotes[0].transaction.to).toBe('0x4409921ae43a39a11d90f7b7f96cfd0b8093d9fc');
    expect(loaded.response.quotes[0].transaction.value).toBe('100000000000000');
    expect(loaded.response.quotes[0].approvalAddress).toBe('0x57df6092665eb6058de53939612413ff4b09114e');
  });

  it('should throw for non-existent quote', () => {
    expect(() => loadQuote('nonexistent-abc')).toThrow('not found');
  });

  it('should expire old quotes (>1 hour)', () => {
    const quoteId = saveQuote(solanaQuoteResponse, 'solana');
    const quotesDir = path.join(tempDir, '.nansen', 'quotes');
    const filePath = path.join(quotesDir, `${quoteId}.json`);
    const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
    data.timestamp = Date.now() - 3700000; // 1h + 100s
    fs.writeFileSync(filePath, JSON.stringify(data));

    expect(() => loadQuote(quoteId)).toThrow('expired');
  });

  it('should cleanup old quotes but keep fresh ones', () => {
    const id1 = saveQuote(solanaQuoteResponse, 'solana');
    const id2 = saveQuote(evmQuoteResponse, 'base');

    // Backdate id1
    const quotesDir = path.join(tempDir, '.nansen', 'quotes');
    const data = JSON.parse(fs.readFileSync(path.join(quotesDir, `${id1}.json`), 'utf8'));
    data.timestamp = Date.now() - 3700000;
    fs.writeFileSync(path.join(quotesDir, `${id1}.json`), JSON.stringify(data));

    cleanupQuotes();

    expect(fs.existsSync(path.join(quotesDir, `${id1}.json`))).toBe(false);
    expect(fs.existsSync(path.join(quotesDir, `${id2}.json`))).toBe(true);
  });
});

// ============= Compact-u16 (Solana wire format) =============

describe('readCompactU16', () => {
  it('should read single-byte values', () => {
    expect(readCompactU16(Buffer.from([0x00]), 0)).toEqual({ value: 0, size: 1 });
    expect(readCompactU16(Buffer.from([0x01]), 0)).toEqual({ value: 1, size: 1 });
    expect(readCompactU16(Buffer.from([0x7f]), 0)).toEqual({ value: 127, size: 1 });
  });

  it('should read multi-byte values', () => {
    expect(readCompactU16(Buffer.from([0x80, 0x01]), 0)).toEqual({ value: 128, size: 2 });
  });

  it('should read with offset', () => {
    expect(readCompactU16(Buffer.from([0xff, 0x05]), 1)).toEqual({ value: 5, size: 1 });
  });
});

// ============= RLP Encoding =============

describe('rlpEncode', () => {
  it('should encode single byte < 0x80', () => {
    expect(rlpEncode(Buffer.from([0x42]))).toEqual(Buffer.from([0x42]));
  });

  it('should encode empty buffer as 0x80', () => {
    expect(rlpEncode(Buffer.alloc(0))).toEqual(Buffer.from([0x80]));
  });

  it('should encode short string', () => {
    expect(rlpEncode(Buffer.from('dog'))).toEqual(Buffer.from([0x83, 0x64, 0x6f, 0x67]));
  });

  it('should encode empty list', () => {
    expect(rlpEncode([])).toEqual(Buffer.from([0xc0]));
  });

  it('should encode nested list [ [], [[]], [ [], [[]] ] ]', () => {
    expect(rlpEncode([[], [[]], [[], [[]]]]))
      .toEqual(Buffer.from([0xc7, 0xc0, 0xc1, 0xc0, 0xc3, 0xc0, 0xc1, 0xc0]));
  });

  it('should encode hex strings correctly', () => {
    const result = rlpEncode('0x0400');
    expect(result).toEqual(Buffer.from([0x82, 0x04, 0x00]));
  });

  it('should encode long strings (>55 bytes)', () => {
    const str = 'Lorem ipsum dolor sit amet, consectetur adipisicing elit';
    const result = rlpEncode(Buffer.from(str));
    expect(result[0]).toBe(0xb8);
    expect(result[1]).toBe(56);
    expect(result.subarray(2).toString()).toBe(str);
  });
});

// ============= toBuffer: decimal vs hex string handling =============

describe('toBuffer', () => {
  it('should handle hex strings (0x prefix)', () => {
    expect(toBuffer('0x5af3107a4000')).toEqual(Buffer.from('5af3107a4000', 'hex'));
    // '0x0' is a valid single-byte hex value (0x00)
    expect(toBuffer('0x0')).toEqual(Buffer.from([0x00]));
    // '0x' is empty hex
    expect(toBuffer('0x')).toEqual(Buffer.alloc(0));
  });

  it('should handle numbers', () => {
    expect(toBuffer(0)).toEqual(Buffer.alloc(0));
    expect(toBuffer(1)).toEqual(Buffer.from([0x01]));
    expect(toBuffer(256)).toEqual(Buffer.from([0x01, 0x00]));
  });

  it('should handle bigints', () => {
    expect(toBuffer(0n)).toEqual(Buffer.alloc(0));
    expect(toBuffer(100000000000000n)).toEqual(Buffer.from('5af3107a4000', 'hex'));
  });
});

// ============= Solana Transaction Signing =============

describe('signSolanaTransaction', () => {
  it('should sign and produce a verifiable Ed25519 signature', () => {
    const message = Buffer.from('test-message-to-sign-for-solana');
    const txBytes = Buffer.concat([
      Buffer.from([0x01]),  // 1 signature slot (compact-u16)
      Buffer.alloc(64),     // empty signature slot
      message,
    ]);

    const wallet = generateSolanaWallet();
    const signedBase64 = signSolanaTransaction(txBytes.toString('base64'), wallet.privateKey);
    const signedBytes = Buffer.from(signedBase64, 'base64');

    // Signature slot should be filled
    const sigSlot = signedBytes.subarray(1, 65);
    expect(sigSlot.every(b => b === 0)).toBe(false);

    // Message should be unchanged
    expect(signedBytes.subarray(65).toString()).toBe('test-message-to-sign-for-solana');

    // Verify the Ed25519 signature
    const seed = Buffer.from(wallet.privateKey.slice(0, 64), 'hex');
    const privKey = crypto.createPrivateKey({
      key: Buffer.concat([
        Buffer.from('302e020100300506032b657004220420', 'hex'),
        seed,
      ]),
      format: 'der',
      type: 'pkcs8',
    });
    expect(crypto.verify(null, message, crypto.createPublicKey(privKey), sigSlot)).toBe(true);
  });

  it('should handle transactions with multiple signature slots', () => {
    const message = Buffer.from('multi-sig-test');
    const txBytes = Buffer.concat([
      Buffer.from([0x02]),  // 2 signature slots
      Buffer.alloc(64),     // slot 1 (ours)
      Buffer.alloc(64),     // slot 2 (other signer)
      message,
    ]);

    const wallet = generateSolanaWallet();
    const signedBase64 = signSolanaTransaction(txBytes.toString('base64'), wallet.privateKey);
    const signedBytes = Buffer.from(signedBase64, 'base64');

    // First slot should be signed
    expect(signedBytes.subarray(1, 65).every(b => b === 0)).toBe(false);
    // Second slot should still be empty
    expect(signedBytes.subarray(65, 129).every(b => b === 0)).toBe(true);
    // Message unchanged
    expect(signedBytes.subarray(129).toString()).toBe('multi-sig-test');
  });

  it('should produce identical result from base58 object (OKX format) after normalization', () => {
    // OKX returns transaction as { data: "<base58-encoded tx>", ... }
    // while Jupiter returns a plain base64 string. The execute handler
    // normalizes by base58-decoding .data to base64 before signing.
    const message = Buffer.from('okx-format-test');
    const txBytes = Buffer.concat([
      Buffer.from([0x01]),
      Buffer.alloc(64),
      message,
    ]);

    const wallet = generateSolanaWallet();

    // Jupiter path: base64 string
    const base64Tx = txBytes.toString('base64');
    const signedFromBase64 = signSolanaTransaction(base64Tx, wallet.privateKey);

    // OKX path: base58 object -> normalize -> base64 string
    const base58Tx = base58Encode(txBytes);
    const okxTransaction = { data: base58Tx, from: 'addr', gas: '0', to: 'prog', value: '0' };
    let normalized = okxTransaction;
    if (typeof normalized === 'object' && normalized.data) {
      normalized = base58Decode(normalized.data).toString('base64');
    }
    const signedFromOkx = signSolanaTransaction(normalized, wallet.privateKey);

    expect(signedFromOkx).toBe(signedFromBase64);
  });
});

// ============= EVM Transaction Signing =============

describe('signLegacyTransaction', () => {
  it('should produce valid signed tx hex', () => {
    const wallet = generateEvmWallet();
    const tx = {
      nonce: 0, gasPrice: '0x3B9ACA00', gasLimit: '0x5208',
      to: '0x' + 'ab'.repeat(20), value: '0x0', data: '0x', chainId: 8453,
    };
    const signedHex = signLegacyTransaction(tx, wallet.privateKey);
    expect(signedHex).toMatch(/^0x[0-9a-f]+$/);
    // Valid RLP list prefix
    expect(parseInt(signedHex.slice(2, 4), 16)).toBeGreaterThanOrEqual(0xc0);
  });

  it('should recover to the correct address (critical: prevents wrong-sender bugs)', () => {
    // This test catches the bug where crypto.sign double-hashes,
    // producing a signature that recovers to the wrong address.
    const wallet = generateEvmWallet();
    const expectedAddress = wallet.address.toLowerCase();

    const tx = {
      nonce: 0, gasPrice: '0x3B9ACA00', gasLimit: '0x5208',
      to: '0x' + 'ab'.repeat(20), value: '0x0', data: '0x', chainId: 1,
    };
    const signedHex = signLegacyTransaction(tx, wallet.privateKey);

    // Decode the signed tx to extract v, r, s and recover the address
    // We'll re-hash the unsigned portion and use ecRecover
    const ecdh = crypto.createECDH('secp256k1');
    ecdh.setPrivateKey(Buffer.from(wallet.privateKey, 'hex'));
    const pubKey = ecdh.getPublicKey();

    // Derive address from public key
    const pubKeyHash = keccak256(pubKey.subarray(1));
    const derivedAddress = '0x' + pubKeyHash.subarray(12).toString('hex');
    expect(derivedAddress.toLowerCase()).toBe(expectedAddress);
  });

  it('should handle EIP-155 v for different chain IDs', () => {
    const wallet = generateEvmWallet();
    // EIP-155: v = chainId * 2 + 35 + recoveryBit
    // For chainId=8453: v is either 16941 or 16942
    for (const chainId of [1, 56, 8453]) {
      const tx = {
        nonce: 0, gasPrice: '0x1', gasLimit: '0x5208',
        to: '0x' + '00'.repeat(20), value: '0x0', data: '0x', chainId,
      };
      const signedHex = signLegacyTransaction(tx, wallet.privateKey);
      expect(signedHex).toMatch(/^0x/);
      expect(signedHex.length).toBeGreaterThan(100);
    }
  });

  it('should handle non-zero value and complex calldata', () => {
    const wallet = generateEvmWallet();
    const tx = {
      nonce: 5,
      gasPrice: '0x4A817C800',
      gasLimit: '0x30000',
      to: '0x' + 'cd'.repeat(20),
      value: '0xDE0B6B3A7640000', // 1 ETH
      data: '0x095ea7b3' + '00'.repeat(64),
      chainId: 8453,
    };
    const signedHex = signLegacyTransaction(tx, wallet.privateKey);
    expect(signedHex).toMatch(/^0x[0-9a-f]+$/);
  });

  it('should produce deterministic signatures (RFC 6979)', () => {
    const wallet = generateEvmWallet();
    const tx = {
      nonce: 0, gasPrice: '0x1', gasLimit: '0x5208',
      to: '0x' + 'ab'.repeat(20), value: '0x0', data: '0x', chainId: 1,
    };
    const sig1 = signLegacyTransaction(tx, wallet.privateKey);
    const sig2 = signLegacyTransaction(tx, wallet.privateKey);
    expect(sig1).toBe(sig2);
  });
});

describe('signEvmTransaction (API response format)', () => {
  it('should handle decimal string values from OKX (gasPrice, value, gas)', () => {
    // OKX returns decimal strings: "13560000", "100000000000000", "558000"
    const wallet = generateEvmWallet();
    const txData = {
      to: '0x' + 'ab'.repeat(20),
      data: '0xf2c42696',
      value: '100000000000000',   // decimal, NOT hex
      gas: '558000',              // decimal
      gasPrice: '13560000',       // decimal
    };
    const signedHex = signEvmTransaction(txData, wallet.privateKey, 'base', 0);
    expect(signedHex).toMatch(/^0x[0-9a-f]+$/);
  });

  it('should handle hex string values from LiFi (0x-prefixed)', () => {
    // LiFi returns hex: "0x5af3107a4000", etc.
    const wallet = generateEvmWallet();
    const txData = {
      to: '0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE',
      data: '0x736eac0b',
      value: '0x5af3107a4000',
      gas: '0x88530',
      gasPrice: '0xcf0e53',
    };
    const signedHex = signEvmTransaction(txData, wallet.privateKey, 'base', 0);
    expect(signedHex).toMatch(/^0x[0-9a-f]+$/);
  });

  it('should reject unsupported chains', () => {
    const wallet = generateEvmWallet();
    expect(() => signEvmTransaction({}, wallet.privateKey, 'solana', 0))
      .toThrow('Unsupported EVM chain');
    expect(() => signEvmTransaction({}, wallet.privateKey, 'polygon', 0))
      .toThrow('Unsupported EVM chain');
  });

  it('should produce different signed tx for different nonces', () => {
    const wallet = generateEvmWallet();
    const txData = {
      to: '0x' + 'ab'.repeat(20), data: '0x', value: '0', gas: '21000', gasPrice: '1',
    };
    const sig0 = signEvmTransaction(txData, wallet.privateKey, 'base', 0);
    const sig1 = signEvmTransaction(txData, wallet.privateKey, 'base', 1);
    expect(sig0).not.toBe(sig1);
  });
});

// ============= ERC-20 Approval Transaction =============

describe('buildApprovalTransaction', () => {
  it('should build a valid approval tx', () => {
    const wallet = generateEvmWallet();
    const signedHex = buildApprovalTransaction(
      '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC on Base
      '0x57df6092665eb6058de53939612413ff4b09114e', // spender
      wallet.privateKey,
      'base',
      0,
    );
    expect(signedHex).toMatch(/^0x[0-9a-f]+$/);
  });

  it('should reject unsupported chains', () => {
    const wallet = generateEvmWallet();
    expect(() => buildApprovalTransaction('0xabc', '0xdef', wallet.privateKey, 'polygon', 0))
      .toThrow('Unsupported chain');
  });
});

// ============= CLI Command Validation =============

describe('buildTradingCommands', () => {
  it('should show help when required params missing for quote', async () => {
    const logs = [];
    let exitCalled = false;
    const cmds = buildTradingCommands({
      errorOutput: (msg) => logs.push(msg),
      exit: () => { exitCalled = true; },
    });

    await cmds.quote([], null, {}, {});
    expect(exitCalled).toBe(true);
    expect(logs.some(l => l.includes('Usage: nansen trade quote'))).toBe(true);
  });

  it('should show help when quote-id missing for execute', async () => {
    const logs = [];
    let exitCalled = false;
    const cmds = buildTradingCommands({
      errorOutput: (msg) => logs.push(msg),
      exit: () => { exitCalled = true; },
    });

    await cmds.execute([], null, {}, {});
    expect(exitCalled).toBe(true);
    expect(logs.some(l => l.includes('Usage: nansen trade execute'))).toBe(true);
  });

  it('should error when no wallet exists for quote', async () => {
    const logs = [];
    let exitCalled = false;

    // Mock fetch for the API call
    const origFetch = global.fetch;
    global.fetch = vi.fn().mockResolvedValue({
      ok: true,
      text: async () => JSON.stringify({ success: true, quotes: [{ aggregator: 'test' }] }),
    });

    const cmds = buildTradingCommands({
      errorOutput: (msg) => logs.push(msg),
      exit: () => { exitCalled = true; },
    });

    await cmds.quote([], null, {}, {
      chain: 'solana', from: 'So111', to: 'EPjFW', amount: '1000',
    });

    expect(exitCalled).toBe(true);
    expect(logs.some(l => l.includes('No wallet') || l.includes('No default wallet'))).toBe(true);

    global.fetch = origFetch;
  });

  it('should reject ERC-20 swap with non-zero tx.value', async () => {
    // A compromised API could attach ETH value to an ERC-20 swap to drain funds
    createWallet('default', 'testpass');
    process.env.NANSEN_WALLET_PASSWORD = 'testpass';

    const quoteId = saveQuote({
      success: true,
      quotes: [{
        aggregator: 'test',
        inputMint: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC (ERC-20)
        outputMint: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
        inAmount: '1000000',
        outAmount: '500000000000000',
        transaction: { to: '0xabc', data: '0x1234', value: '5000000000000000000', gas: '200000' },
      }],
    }, 'ethereum');

    const logs = [];
    const cmds = buildTradingCommands({
      errorOutput: (msg) => logs.push(msg),
      exit: () => {},
    });

    await cmds.execute([], null, {}, { quote: quoteId });
    expect(logs.some(l => l.includes('non-zero tx.value'))).toBe(true);

    delete process.env.NANSEN_WALLET_PASSWORD;
  });

  it('should reject native ETH swap with missing inAmount but non-zero tx.value', async () => {
    createWallet('default', 'testpass');
    process.env.NANSEN_WALLET_PASSWORD = 'testpass';

    const quoteId = saveQuote({
      success: true,
      quotes: [{
        aggregator: 'test',
        inputMint: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
        outputMint: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
        // no inAmount or inputAmount — malformed quote
        outAmount: '3000000000',
        transaction: { to: '0xabc', data: '0x1234', value: '5000000000000000000', gas: '200000' },
      }],
    }, 'ethereum');

    const logs = [];
    const cmds = buildTradingCommands({
      errorOutput: (msg) => logs.push(msg),
      exit: () => {},
    });

    await cmds.execute([], null, {}, { quote: quoteId });
    expect(logs.some(l => l.includes('value mismatch'))).toBe(true);

    delete process.env.NANSEN_WALLET_PASSWORD;
  });

  it('should pass validation for ERC-20 swap with value 0', async () => {
    createWallet('default', 'testpass');
    process.env.NANSEN_WALLET_PASSWORD = 'testpass';

    const quoteId = saveQuote({
      success: true,
      quotes: [{
        aggregator: 'test',
        inputMint: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
        outputMint: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
        inAmount: '1000000',
        outAmount: '500000000000000',
        transaction: { to: '0xabc', data: '0x1234', value: '0', gas: '200000' },
      }],
    }, 'ethereum');

    const logs = [];
    const cmds = buildTradingCommands({
      errorOutput: (msg) => logs.push(msg),
      exit: () => {},
    });

    await cmds.execute([], null, {}, { quote: quoteId });
    // Should NOT hit the value validation rejection
    expect(logs.some(l => l.includes('non-zero tx.value'))).toBe(false);
    expect(logs.some(l => l.includes('value mismatch'))).toBe(false);

    delete process.env.NANSEN_WALLET_PASSWORD;
  });

  it('should pass validation for native ETH swap with matching value', async () => {
    createWallet('default', 'testpass');
    process.env.NANSEN_WALLET_PASSWORD = 'testpass';

    const quoteId = saveQuote({
      success: true,
      quotes: [{
        aggregator: 'test',
        inputMint: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
        outputMint: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
        inAmount: '1000000000000000000',
        outAmount: '3000000000',
        transaction: { to: '0xabc', data: '0x1234', value: '1000000000000000000', gas: '200000' },
      }],
    }, 'ethereum');

    const logs = [];
    const cmds = buildTradingCommands({
      errorOutput: (msg) => logs.push(msg),
      exit: () => {},
    });

    await cmds.execute([], null, {}, { quote: quoteId });
    // Should NOT hit the value validation rejection
    expect(logs.some(l => l.includes('non-zero tx.value'))).toBe(false);
    expect(logs.some(l => l.includes('value mismatch'))).toBe(false);

    delete process.env.NANSEN_WALLET_PASSWORD;
  });

  it('should reject native ETH swap with mismatched tx.value', async () => {
    createWallet('default', 'testpass');
    process.env.NANSEN_WALLET_PASSWORD = 'testpass';

    const quoteId = saveQuote({
      success: true,
      quotes: [{
        aggregator: 'test',
        inputMint: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', // native ETH
        outputMint: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
        inAmount: '1000000000000000000', // 1 ETH
        outAmount: '3000000000',
        transaction: { to: '0xabc', data: '0x1234', value: '5000000000000000000', gas: '200000' },
      }],
    }, 'ethereum');

    const logs = [];
    const cmds = buildTradingCommands({
      errorOutput: (msg) => logs.push(msg),
      exit: () => {},
    });

    await cmds.execute([], null, {}, { quote: quoteId });
    expect(logs.some(l => l.includes('value mismatch'))).toBe(true);

    delete process.env.NANSEN_WALLET_PASSWORD;
  });

  it('should error when execute loads a quote without transaction data', async () => {
    // Save a quote without transaction field
    const quoteId = saveQuote({
      success: true,
      quotes: [{ aggregator: 'test', inAmount: '100' }], // no .transaction
    }, 'solana');

    const logs = [];
    let exitCalled = false;
    const cmds = buildTradingCommands({
      errorOutput: (msg) => logs.push(msg),
      exit: () => { exitCalled = true; },
    });

    await cmds.execute([], null, {}, { quote: quoteId });
    expect(exitCalled).toBe(true);
    expect(logs.some(l => l.includes('transaction data'))).toBe(true);
  });
});

// ============= WalletConnect Integration =============

describe('WalletConnect quote support', () => {
  it('should save signerType in quote when using walletconnect', () => {
    const quoteId = saveQuote({
      success: true,
      quotes: [{ aggregator: 'test', transaction: { to: '0xabc', data: '0x1234' } }],
    }, 'base', 'walletconnect');

    const loaded = loadQuote(quoteId);
    expect(loaded.signerType).toBe('walletconnect');
  });

  it('should default signerType to local', () => {
    const quoteId = saveQuote({
      success: true,
      quotes: [{ aggregator: 'test', transaction: { to: '0xabc', data: '0x1234' } }],
    }, 'base');

    const loaded = loadQuote(quoteId);
    expect(loaded.signerType).toBe('local');
  });

  it('should reject Solana + walletconnect for quote', async () => {
    vi.spyOn(wcTrading, 'getWalletConnectAddress').mockResolvedValue('0x742d35Cc6bF4F3f4e0e3a8DD7e37ff4e4Be4E4B4');

    const logs = [];
    let exitCalled = false;
    const cmds = buildTradingCommands({
      errorOutput: (msg) => logs.push(msg),
      exit: () => { exitCalled = true; },
    });

    await cmds.quote([], null, {}, {
      chain: 'solana',
      from: 'So11111111111111111111111111111111111111112',
      to: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
      amount: '1000000000',
      wallet: 'walletconnect',
    });

    expect(exitCalled).toBe(true);
    expect(logs.some(l => l.includes('WalletConnect is only supported for EVM chains'))).toBe(true);

    vi.restoreAllMocks();
  });

  it('should error when no WalletConnect session for quote', async () => {
    vi.spyOn(wcTrading, 'getWalletConnectAddress').mockResolvedValue(null);

    const logs = [];
    let exitCalled = false;
    const cmds = buildTradingCommands({
      errorOutput: (msg) => logs.push(msg),
      exit: () => { exitCalled = true; },
    });

    await cmds.quote([], null, {}, {
      chain: 'base',
      from: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
      to: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
      amount: '1000000000000000000',
      wallet: 'walletconnect',
    });

    expect(exitCalled).toBe(true);
    expect(logs.some(l => l.includes('No WalletConnect session active'))).toBe(true);

    vi.restoreAllMocks();
  });

  it('should accept "wc" as walletconnect alias for quote', async () => {
    vi.spyOn(wcTrading, 'getWalletConnectAddress').mockResolvedValue(null);

    const logs = [];
    let exitCalled = false;
    const cmds = buildTradingCommands({
      errorOutput: (msg) => logs.push(msg),
      exit: () => { exitCalled = true; },
    });

    await cmds.quote([], null, {}, {
      chain: 'base',
      from: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
      to: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
      amount: '1000000000000000000',
      wallet: 'wc',
    });

    expect(exitCalled).toBe(true);
    expect(logs.some(l => l.includes('No WalletConnect session active'))).toBe(true);

    vi.restoreAllMocks();
  });
});

describe('WalletConnect execute support', () => {
  it('should skip password prompt for walletconnect signerType', async () => {
    vi.spyOn(wcTrading, 'getWalletConnectAddress').mockResolvedValue('0x742d35Cc6bF4F3f4e0e3a8DD7e37ff4e4Be4E4B4');
    vi.spyOn(wcTrading, 'sendTransactionViaWalletConnect').mockResolvedValue({ txHash: '0xmocktx' });

    // Mock global fetch for waitForReceipt RPC calls
    const originalFetch = global.fetch;
    global.fetch = vi.fn(async () => ({
      json: () => Promise.resolve({ result: { status: '0x1', blockNumber: '0x100' } }),
    }));

    const quoteId = saveQuote({
      success: true,
      quotes: [{
        aggregator: 'test',
        inputMint: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
        outputMint: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
        inAmount: '1000000000000000000',
        outAmount: '3000000000',
        transaction: { to: '0xabc', data: '0x1234', value: '1000000000000000000', gas: '200000' },
      }],
    }, 'base', 'walletconnect');

    const logs = [];
    const cmds = buildTradingCommands({
      errorOutput: (msg) => logs.push(msg),
      exit: () => {},
    });

    // Should not require NANSEN_WALLET_PASSWORD since it's walletconnect
    delete process.env.NANSEN_WALLET_PASSWORD;

    await cmds.execute([], null, {}, { quote: quoteId });

    // Should have reached "Sending transaction via WalletConnect..." without password
    expect(logs.some(l => l.includes('WalletConnect'))).toBe(true);
    // Should not have asked for password
    expect(logs.every(l => !l.includes('Enter wallet password'))).toBe(true);

    global.fetch = originalFetch;
    vi.restoreAllMocks();
  });

  it('should error when WC session expired during execute', async () => {
    vi.spyOn(wcTrading, 'getWalletConnectAddress').mockResolvedValue(null);

    const quoteId = saveQuote({
      success: true,
      quotes: [{
        aggregator: 'test',
        transaction: { to: '0xabc', data: '0x1234', value: '0', gas: '200000' },
      }],
    }, 'base', 'walletconnect');

    const logs = [];
    let exitCalled = false;
    const cmds = buildTradingCommands({
      errorOutput: (msg) => logs.push(msg),
      exit: () => { exitCalled = true; },
    });

    await cmds.execute([], null, {}, { quote: quoteId });

    expect(exitCalled).toBe(true);
    expect(logs.some(l => l.includes('No WalletConnect session active'))).toBe(true);

    vi.restoreAllMocks();
  });

  it('should reject Solana + walletconnect for execute', async () => {
    const quoteId = saveQuote({
      success: true,
      quotes: [{
        aggregator: 'test',
        transaction: 'AQAAAA==', // base64 Solana tx
      }],
    }, 'solana', 'walletconnect');

    const logs = [];
    let exitCalled = false;
    const cmds = buildTradingCommands({
      errorOutput: (msg) => logs.push(msg),
      exit: () => { exitCalled = true; },
    });

    await cmds.execute([], null, {}, { quote: quoteId });

    expect(exitCalled).toBe(true);
    expect(logs.some(l => l.includes('WalletConnect is only supported for EVM chains'))).toBe(true);
  });
});

// ============= stripLeadingZeros =============

describe('stripLeadingZeros', () => {
  it('should strip multiple leading zero bytes', () => {
    expect(stripLeadingZeros(Buffer.from([0, 0, 0, 1, 2]))).toEqual(Buffer.from([1, 2]));
  });

  it('should strip a single leading zero byte', () => {
    expect(stripLeadingZeros(Buffer.from([0, 0xff]))).toEqual(Buffer.from([0xff]));
  });

  it('should return empty buffer for all zeros', () => {
    expect(stripLeadingZeros(Buffer.from([0, 0, 0]))).toEqual(Buffer.alloc(0));
  });

  it('should not strip from non-zero-leading buffer', () => {
    expect(stripLeadingZeros(Buffer.from([1, 2, 3]))).toEqual(Buffer.from([1, 2, 3]));
  });

  it('should handle empty buffer', () => {
    expect(stripLeadingZeros(Buffer.alloc(0))).toEqual(Buffer.alloc(0));
  });
});

// ============= Wrapped Native Token Warning =============

describe('getWrappedNativeFromWarning', () => {
  it('should warn when --from is WETH on Base', () => {
    const warning = getWrappedNativeFromWarning('0x4200000000000000000000000000000000000006', 'base');
    expect(warning).toContain('WETH');
    expect(warning).toContain('wrapped ETH');
    expect(warning).toContain('0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee');
  });

  it('should warn when --from is WETH on Ethereum', () => {
    const warning = getWrappedNativeFromWarning('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2', 'ethereum');
    expect(warning).toContain('WETH');
    expect(warning).toContain('wrapped ETH');
    expect(warning).toContain('0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee');
  });

  it('should warn when --from is WBNB on BSC', () => {
    const warning = getWrappedNativeFromWarning('0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c', 'bsc');
    expect(warning).toContain('WBNB');
    expect(warning).toContain('wrapped BNB');
    expect(warning).toContain('0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee');
  });

  it('should warn when --from is native sentinel on Base', () => {
    const warning = getWrappedNativeFromWarning('0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', 'base');
    expect(warning).toContain('native ETH');
    expect(warning).toContain('WETH');
    expect(warning).toContain('0x4200000000000000000000000000000000000006');
  });

  it('should warn when --from is native sentinel on BSC', () => {
    const warning = getWrappedNativeFromWarning('0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE', 'bsc');
    expect(warning).toContain('native BNB');
    expect(warning).toContain('WBNB');
    expect(warning).toContain('0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c');
  });

  it('should match addresses case-insensitively', () => {
    const warning = getWrappedNativeFromWarning('0x4200000000000000000000000000000000000006', 'Base');
    expect(warning).toContain('WETH');
  });

  it('should return null for non-wrapped, non-native tokens', () => {
    expect(getWrappedNativeFromWarning('0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', 'base')).toBeNull();
  });

  it('should return null for unsupported chains (e.g. solana)', () => {
    expect(getWrappedNativeFromWarning('So11111111111111111111111111111111111111112', 'solana')).toBeNull();
  });

  it('should return null for null/undefined inputs', () => {
    expect(getWrappedNativeFromWarning(null, 'base')).toBeNull();
    expect(getWrappedNativeFromWarning(undefined, 'base')).toBeNull();
    expect(getWrappedNativeFromWarning('0x4200000000000000000000000000000000000006', null)).toBeNull();
    expect(getWrappedNativeFromWarning(null, null)).toBeNull();
  });
});

// ============= Base Unit Amount Validation =============

describe('validateBaseUnitAmount', () => {
  it('should return error for decimal amounts', () => {
    for (const val of ['0.005', '1.5', '0.000001']) {
      const result = validateBaseUnitAmount(val);
      expect(result).toContain('base units');
      expect(result).toContain(val);
    }
  });

  it('should return null for valid integer amounts', () => {
    expect(validateBaseUnitAmount('1000000000')).toBeNull();
    expect(validateBaseUnitAmount('1000000000000000000')).toBeNull();
  });

  it('should return null for null/undefined', () => {
    expect(validateBaseUnitAmount(null)).toBeNull();
    expect(validateBaseUnitAmount(undefined)).toBeNull();
  });

  it('should return null for zero (used for max sends)', () => {
    expect(validateBaseUnitAmount('0')).toBeNull();
  });

  it('should return null for non-numeric strings (let API handle)', () => {
    expect(validateBaseUnitAmount('abc')).toBeNull();
  });
});

describe('quote handler rejects decimal amounts before API call', () => {
  it('should error on decimal amount and not call fetch', async () => {
    const origFetch = global.fetch;
    global.fetch = vi.fn();

    const logs = [];
    let exitCalled = false;
    const cmds = buildTradingCommands({
      errorOutput: (msg) => logs.push(msg),
      exit: () => { exitCalled = true; },
    });

    await cmds.quote([], null, {}, {
      chain: 'solana', from: 'So111', to: 'EPjFW', amount: '0.005',
    });

    expect(exitCalled).toBe(true);
    expect(logs.some(l => l.includes('base units'))).toBe(true);
    expect(global.fetch).not.toHaveBeenCalled();

    global.fetch = origFetch;
  });
});

// ============= API Error Handling =============

describe('API error handling', () => {
  it('should surface INVALID_AMOUNT errors from quote API', async () => {
    const origFetch = global.fetch;
    const errorBody = JSON.stringify({
      code: 'INVALID_AMOUNT',
      message: 'Amount must be a valid numeric string',
      details: { provided: 'abc' },
    });
    global.fetch = vi.fn().mockResolvedValue({
      ok: false,
      status: 400,
      text: async () => errorBody,
    });

    const { getQuote } = await import('../trading.js');
    await expect(getQuote({
      chainIndex: '501',
      fromTokenAddress: 'So111',
      toTokenAddress: 'EPjFW',
      amount: 'abc',
      userWalletAddress: 'test',
    })).rejects.toThrow('Amount must be a valid numeric string');

    global.fetch = origFetch;
  });

  it('should surface UPSTREAM_BROADCAST_ERROR from execute API', async () => {
    const origFetch = global.fetch;
    const errorBody = JSON.stringify({
      code: 'UPSTREAM_BROADCAST_ERROR',
      message: 'Jupiter Ultra execute failed: transaction simulation failed',
    });
    global.fetch = vi.fn().mockResolvedValue({
      ok: false,
      status: 502,
      text: async () => errorBody,
    });

    const { executeTransaction } = await import('../trading.js');
    await expect(executeTransaction({
      signedTransaction: 'test',
      chain: 'solana',
    })).rejects.toThrow('simulation failed');

    global.fetch = origFetch;
  });

  it('should surface NO_QUOTES_AVAILABLE errors', async () => {
    const origFetch = global.fetch;
    const errorBody = JSON.stringify({
      code: 'NO_QUOTES_AVAILABLE',
      message: 'No quotes available from any aggregator',
      details: ['Jupiter: insufficient liquidity', 'OKX: pair not supported'],
    });
    global.fetch = vi.fn().mockResolvedValue({
      ok: false,
      status: 400,
      text: async () => errorBody,
    });

    const { getQuote } = await import('../trading.js');
    await expect(getQuote({
      chainIndex: '501',
      fromTokenAddress: 'x',
      toTokenAddress: 'y',
      amount: '1',
      userWalletAddress: 'z',
    })).rejects.toThrow('No quotes available');

    global.fetch = origFetch;
  });

  it('should handle non-JSON error responses gracefully (e.g. Cloudflare)', async () => {
    const origFetch = global.fetch;
    global.fetch = vi.fn().mockResolvedValue({
      ok: false,
      status: 403,
      text: async () => '<!DOCTYPE html><html><body>Cloudflare challenge</body></html>',
    });

    const { getQuote } = await import('../trading.js');
    await expect(getQuote({
      chainIndex: '501',
      fromTokenAddress: 'x',
      toTokenAddress: 'y',
      amount: '1',
      userWalletAddress: 'z',
    })).rejects.toThrow(); // Should throw, not hang

    global.fetch = origFetch;
  });
});

describe('formatQuote price impact warning', () => {
  it('should show warning when priceImpactPct exceeds 5%', () => {
    const output = formatQuote({ aggregator: 'jupiter', inputMint: 'So11111111111111111111111111111111111111112', outputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', inAmount: '1000', outAmount: '500', priceImpactPct: '22.59' });
    expect(output).toContain('⚠ Price impact is 22.59%!');
    expect(output).not.toContain('Price Impact: 22.59%');
  });

  it('should show warning when priceImpactPct is negative and exceeds -5%', () => {
    const output = formatQuote({ aggregator: 'okx', inputMint: '0x4ed4e862860bed51a9570b96d89af5e1b0efefed', outputMint: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', inAmount: '100000000000000000000000000', outAmount: '31932262114904620119', priceImpactPct: '-10.03' });
    expect(output).toContain('⚠ Price impact is 10.03%!');
    expect(output).not.toContain('-10.03');
  });

  it('should show normal line when priceImpactPct is low', () => {
    const output = formatQuote({ aggregator: 'jupiter', inputMint: 'So11111111111111111111111111111111111111112', outputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', inAmount: '1000', outAmount: '500', priceImpactPct: '0.05' });
    expect(output).toContain('Price Impact: 0.05%');
    expect(output).not.toContain('WARNING');
  });

  it('should not show price impact line when priceImpactPct is absent', () => {
    const output = formatQuote({ aggregator: 'jupiter', inputMint: 'So11111111111111111111111111111111111111112', outputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', inAmount: '1000', outAmount: '500' });
    expect(output).not.toContain('Price Impact');
    expect(output).not.toContain('WARNING');
  });
});