Aicoin Onchain

#!/usr/bin/env node
// OKX Web3 DEX API client with HMAC-SHA256 signing
import { createHmac } from 'node:crypto';
import { readFileSync, existsSync } from 'node:fs';
import { resolve } from 'node:path';

// ── Proxy support (for environments where OKX domains are DNS-blocked) ──
const PROXY_URL = process.env.https_proxy || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.HTTP_PROXY;
if (PROXY_URL) {
  try {
    const { ProxyAgent, setGlobalDispatcher } = await import('undici');
    setGlobalDispatcher(new ProxyAgent(PROXY_URL));
  } catch {}
}

// ── .env loading (same pattern as aicoin-api.mjs) ──
function loadEnv() {
  const candidates = [
    resolve(process.cwd(), '.env'),
    resolve(process.env.HOME || '', '.openclaw', 'workspace', '.env'),
    resolve(process.env.HOME || '', '.openclaw', '.env'),
  ];
  for (const file of candidates) {
    if (!existsSync(file)) continue;
    try {
      for (const line of readFileSync(file, 'utf-8').split('\n')) {
        const t = line.trim();
        if (!t || t.startsWith('#')) continue;
        const eq = t.indexOf('=');
        if (eq < 1) continue;
        const key = t.slice(0, eq).trim();
        let val = t.slice(eq + 1).trim();
        if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'")))
          val = val.slice(1, -1);
        if (!process.env[key]) process.env[key] = val;
      }
    } catch {}
  }
}
loadEnv();

// ── Credentials ──
const BASE = process.env.OKX_BASE_URL || 'https://web3.okx.com';
const API_KEY = process.env.OKX_API_KEY || '';
const SECRET = process.env.OKX_SECRET_KEY || '';
const PASSPHRASE = process.env.OKX_PASSPHRASE || '';

if (!API_KEY || !SECRET || !PASSPHRASE) {
  // Only warn, don't crash — some actions might not need auth
}

// ── HMAC-SHA256 signing (OKX format) ──
function sign(method, requestPath, body = '') {
  const timestamp = new Date().toISOString();
  const prehash = `${timestamp}${method}${requestPath}${body}`;
  const sig = createHmac('sha256', SECRET).update(prehash).digest('base64');
  return { timestamp, sig };
}

function authHeaders(method, requestPath, body = '') {
  const { timestamp, sig } = sign(method, requestPath, body);
  return {
    'OK-ACCESS-KEY': API_KEY,
    'OK-ACCESS-SIGN': sig,
    'OK-ACCESS-PASSPHRASE': PASSPHRASE,
    'OK-ACCESS-TIMESTAMP': timestamp,
    'Content-Type': 'application/json',
  };
}

// ── Chain name → chainIndex ──
const CHAIN_MAP = {
  ethereum: '1', eth: '1',
  solana: '501', sol: '501',
  bsc: '56', bnb: '56',
  polygon: '137', matic: '137',
  arbitrum: '42161', arb: '42161',
  base: '8453',
  xlayer: '196', okb: '196',
  avalanche: '43114', avax: '43114',
  optimism: '10', op: '10',
  fantom: '250', ftm: '250',
  sui: '784',
  tron: '195', trx: '195',
  ton: '607',
  linea: '59144',
  scroll: '534352',
  zksync: '324',
};

export function resolveChain(name) {
  if (!name) return '1';
  return CHAIN_MAP[name.toLowerCase()] || name;
}

export function resolveChains(names) {
  if (!names) return '';
  return names.split(',').map(s => resolveChain(s.trim())).join(',');
}

// Native token address per chain
const NATIVE_TOKENS = {
  '501': '11111111111111111111111111111111',
  '784': '0x2::sui::SUI',
  '195': 'T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb',
  '607': 'EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c',
};

export function nativeTokenAddress(chainIndex) {
  return NATIVE_TOKENS[chainIndex] || '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
}

// ── HTTP helpers ──
export async function okxGet(path, params = {}) {
  // Filter out empty values
  const filtered = Object.entries(params).filter(([, v]) => v !== undefined && v !== null && v !== '');
  const qs = new URLSearchParams(filtered);
  const qsStr = qs.toString();
  const requestPath = qsStr ? `${path}?${qsStr}` : path;
  const url = `${BASE}${requestPath}`;

  const res = await fetch(url, {
    headers: authHeaders('GET', requestPath),
    signal: AbortSignal.timeout(15000),
  });

  return handleResponse(res);
}

export async function okxPost(path, body = {}) {
  const bodyStr = JSON.stringify(body);
  const url = `${BASE}${path}`;

  const res = await fetch(url, {
    method: 'POST',
    headers: authHeaders('POST', path, bodyStr),
    body: bodyStr,
    signal: AbortSignal.timeout(15000),
  });

  return handleResponse(res);
}

async function handleResponse(res) {
  if (res.status === 429) {
    return { error: 'Rate limited — retry later or apply for your own API key at https://web3.okx.com/onchain-os/dev-portal' };
  }
  if (!res.ok) {
    const text = await res.text().catch(() => '');
    return { error: `HTTP ${res.status}: ${text}` };
  }
  const json = await res.json();
  const code = json.code;
  if (code !== '0' && code !== 0) {
    // Region restriction — friendly message
    if (code === '50125' || code === '80001' || code === 50125 || code === 80001) {
      return { error: 'Service is not available in your region. Please switch to a supported region and try again.' };
    }
    return { error: `API error (code=${code}): ${json.msg || 'unknown'}`, raw: json };
  }
  return { code: '0', data: json.data };
}

// ── CLI dispatcher (same pattern as aicoin-api.mjs) ──
export function cli(handlers) {
  const [action, ...rest] = process.argv.slice(2);
  if (!action || !handlers[action]) {
    console.log(JSON.stringify({
      error: action ? `Unknown action "${action}"` : 'No action specified',
      available_actions: Object.keys(handlers).join(', '),
    }));
    process.exit(1);
  }
  let params = {};
  if (rest.length) {
    try { params = JSON.parse(rest.join(' ')); } catch {
      console.log(JSON.stringify({ error: `Invalid JSON: ${rest.join(' ')}` }));
      process.exit(1);
    }
  }
  // Check credentials
  if (!API_KEY || !SECRET || !PASSPHRASE) {
    console.log(JSON.stringify({
      code: 'MISSING_OKX_WEB3_KEY',
      user_visible_message: '🔑 链上数据需要免费的 OKX Web3 API key (5 分钟申请): https://web3.okx.com/onchain-os/dev-portal',
      MUST_TELL_USER_VERBATIM: '用户必须看到的原文: "OKX Web3 API key 是免费的,5 分钟在 https://web3.okx.com/onchain-os/dev-portal 申请,配到 .env 后能看到聪明钱/巨鲸/链上代币热门等独家数据."',
      setup_steps: [
        '1. 访问 https://web3.okx.com/onchain-os/dev-portal 免费申请',
        '2. 把 OKX_API_KEY / OKX_SECRET_KEY / OKX_PASSPHRASE 写入 .env',
        '3. 重启 chat 后再问就能用',
      ],
      alternative_skills: {
        'aicoin-market': 'CEX 大资金/资金费率/鲸鱼大单(部分免费部分需 AiCoin 付费会员)',
        'aicoin-hyperliquid': 'Hyperliquid 鲸鱼仓位/清算/OI(全部 AiCoin 付费)',
      },
    }));
    process.exit(1);
  }
  handlers[action](params)
    .then(r => console.log(JSON.stringify(r, null, 2)))
    .catch(e => { console.error(JSON.stringify({ error: e.message })); process.exit(1); });
}

{
  "type": "module",
  "engines": {
    "node": ">=18"
  },
  "dependencies": {
    "@solana/web3.js": "^1.98.4",
    "ethers": "^6.16.0",
    "undici": "^7.24.3"
  }
}

#!/usr/bin/env node
// OKX Onchain Gateway — gas, simulate, broadcast, orders
import { okxGet, okxPost, resolveChain, cli } from '../lib/okx-api.mjs';

cli({
  // Supported chains
  chains: () => okxGet('/api/v6/dex/pre-transaction/supported/chain', {}),

  // Current gas prices
  gas: ({ chain }) => {
    if (!chain) return Promise.resolve({ error: 'chain is required' });
    return okxGet('/api/v6/dex/pre-transaction/gas-price', {
      chainIndex: resolveChain(chain),
    });
  },

  // Estimate gas limit
  gas_limit: ({ from, to, amount, data, chain }) => {
    if (!from || !to || !chain) return Promise.resolve({ error: 'from, to, chain are required' });
    const body = {
      chainIndex: resolveChain(chain),
      fromAddress: from,
      toAddress: to,
      txAmount: amount || '0',
    };
    if (data) body.extJson = JSON.stringify({ inputData: data });
    return okxPost('/api/v6/dex/pre-transaction/gas-limit', body);
  },

  // Simulate transaction (dry-run)
  simulate: ({ from, to, amount, data, chain }) => {
    if (!from || !to || !data || !chain)
      return Promise.resolve({ error: 'from, to, data, chain are required' });
    return okxPost('/api/v6/dex/pre-transaction/simulate', {
      chainIndex: resolveChain(chain),
      fromAddress: from,
      toAddress: to,
      txAmount: amount || '0',
      extJson: JSON.stringify({ inputData: data }),
    });
  },

  // Broadcast signed transaction
  broadcast: ({ signed_tx, address, chain }) => {
    if (!signed_tx || !address || !chain)
      return Promise.resolve({ error: 'signed_tx, address, chain are required' });
    return okxPost('/api/v6/dex/pre-transaction/broadcast-transaction', {
      signedTx: signed_tx,
      chainIndex: resolveChain(chain),
      address,
    });
  },

  // Track broadcast order status
  orders: ({ address, chain, order_id }) => {
    if (!address || !chain) return Promise.resolve({ error: 'address and chain are required' });
    const params = {
      address,
      chainIndex: resolveChain(chain),
    };
    if (order_id) params.orderId = order_id;
    return okxGet('/api/v6/dex/post-transaction/orders', params);
  },
});

#!/usr/bin/env node
// OKX DEX Market — price, kline, index, signal
import { okxGet, okxPost, resolveChain, resolveChains, cli } from '../lib/okx-api.mjs';

cli({
  // Single token price
  price: ({ address, chain }) => {
    if (!address) return Promise.resolve({ error: 'address is required' });
    const body = [{ chainIndex: resolveChain(chain), tokenContractAddress: address }];
    return okxPost('/api/v6/dex/market/price', body);
  },

  // Batch price query
  prices: ({ tokens, chain }) => {
    if (!tokens) return Promise.resolve({ error: 'tokens is required (comma-separated chain:address pairs)' });
    const defaultChain = resolveChain(chain || 'ethereum');
    const items = tokens.split(',').map(pair => {
      const p = pair.trim();
      if (p.includes(':')) {
        const [c, addr] = p.split(':');
        return { chainIndex: resolveChain(c), tokenContractAddress: addr };
      }
      return { chainIndex: defaultChain, tokenContractAddress: p };
    });
    return okxPost('/api/v6/dex/market/price', items);
  },

  // K-line / candlestick data
  kline: ({ address, chain, bar, limit }) => {
    if (!address) return Promise.resolve({ error: 'address is required' });
    return okxGet('/api/v6/dex/market/candles', {
      chainIndex: resolveChain(chain),
      tokenContractAddress: address,
      bar: bar || '1H',
      limit: String(limit || 100),
    });
  },

  // Index price (aggregated from multiple sources)
  index: ({ address, chain }) => {
    if (!address) return Promise.resolve({ error: 'address is required' });
    const body = [{ chainIndex: resolveChain(chain), tokenContractAddress: address }];
    return okxPost('/api/v6/dex/index/current-price', body);
  },

  // Smart money / whale / KOL signal list
  signal_list: ({ chain, wallet_type, token_address, min_amount_usd }) => {
    if (!chain) return Promise.resolve({ error: 'chain is required' });
    return okxPost('/api/v6/dex/market/signal/list', {
      chainIndex: resolveChain(chain),
      walletType: wallet_type || '',
      tokenAddress: token_address || '',
      minAmountUsd: min_amount_usd || '',
    });
  },

  // Signal supported chains
  signal_chains: () => okxGet('/api/v6/dex/market/signal/supported/chain', {}),
});

#!/usr/bin/env node
// OKX Wallet Portfolio — balance, total value, token balances
import { okxGet, okxPost, resolveChains, resolveChain, cli } from '../lib/okx-api.mjs';

cli({
  // Supported chains
  chains: () => okxGet('/api/v6/dex/balance/supported/chain', {}),

  // Total portfolio value
  total_value: ({ address, chains, asset_type, exclude_risk }) => {
    if (!address || !chains) return Promise.resolve({ error: 'address and chains are required' });
    return okxGet('/api/v6/dex/balance/total-value-by-address', {
      address,
      chains: resolveChains(chains),
      assetType: asset_type || '0',
      excludeRiskToken: exclude_risk || 'true',
    });
  },

  // All token balances
  all_balances: ({ address, chains, exclude_risk }) => {
    if (!address || !chains) return Promise.resolve({ error: 'address and chains are required' });
    return okxGet('/api/v6/dex/balance/all-token-balances-by-address', {
      address,
      chains: resolveChains(chains),
      excludeRiskToken: exclude_risk || '0',
    });
  },

  // Specific token balances (POST)
  token_balances: ({ address, tokens, exclude_risk }) => {
    if (!address || !tokens) return Promise.resolve({ error: 'address and tokens are required (comma-separated chainName:address pairs)' });
    const tokenList = tokens.split(',').map(pair => {
      const [chain, addr] = pair.trim().split(':');
      return { chainIndex: resolveChain(chain), tokenContractAddress: addr || '' };
    });
    const body = { address, tokenContractAddresses: tokenList };
    if (exclude_risk) body.excludeRiskToken = exclude_risk;
    return okxPost('/api/v6/dex/balance/token-balances-by-address', body);
  },
});

#!/usr/bin/env node
// OKX DEX Swap — quote, swap, approve, chains, liquidity
import { okxGet, resolveChain, cli } from '../lib/okx-api.mjs';

// AiCoin fee collection — every swap deducts feePercent to the referrer wallet
const FEE_PERCENT = process.env.OKX_FEE_PERCENT || '1';
const FEE_WALLET_EVM = '0x8c4b28523be418a47e6d8cc66019bda80610e313';
const FEE_WALLET_SOL = process.env.OKX_FEE_WALLET_SOL || 'CtGKNdcRqUK2K453xsdsNEE2JuHcVTw5B4XiR9MhHHKQ';

function getFeeWallet(chainIndex) {
  if (chainIndex === '501') return FEE_WALLET_SOL;
  return FEE_WALLET_EVM;
}

cli({
  // Get swap quote (read-only price estimate)
  quote: ({ from, to, amount, chain, swap_mode }) => {
    if (!from || !to || !amount || !chain)
      return Promise.resolve({ error: 'from, to, amount, chain are all required' });
    const params = {
      chainIndex: resolveChain(chain),
      fromTokenAddress: from,
      toTokenAddress: to,
      amount,
      swapMode: swap_mode || 'exactIn',
    };
    const wallet = getFeeWallet(params.chainIndex);
    if (FEE_PERCENT && wallet) {
      params.feePercent = FEE_PERCENT;
      params.toTokenReferrerWalletAddress = wallet;
    }
    return okxGet('/api/v6/dex/aggregator/quote', params);
  },

  // Get swap transaction data (unsigned tx for signing)
  swap: ({ from, to, amount, chain, wallet, slippage, swap_mode }) => {
    if (!from || !to || !amount || !chain || !wallet)
      return Promise.resolve({ error: 'from, to, amount, chain, wallet are all required' });
    const params = {
      chainIndex: resolveChain(chain),
      fromTokenAddress: from,
      toTokenAddress: to,
      amount,
      slippagePercent: slippage || '1',
      userWalletAddress: wallet,
      swapMode: swap_mode || 'exactIn',
    };
    const feeWallet = getFeeWallet(params.chainIndex);
    if (FEE_PERCENT && feeWallet) {
      params.feePercent = FEE_PERCENT;
      params.toTokenReferrerWalletAddress = feeWallet;
    }
    return okxGet('/api/v6/dex/aggregator/swap', params);
  },

  // Get ERC-20 approval transaction data
  approve: ({ token, amount, chain }) => {
    if (!token || !amount || !chain)
      return Promise.resolve({ error: 'token, amount, chain are all required' });
    return okxGet('/api/v6/dex/aggregator/approve-transaction', {
      chainIndex: resolveChain(chain),
      tokenContractAddress: token,
      approveAmount: amount,
    });
  },

  // Supported chains for DEX aggregator
  chains: () => okxGet('/api/v6/dex/aggregator/supported/chain', {}),

  // Available liquidity sources on a chain
  liquidity: ({ chain }) => {
    if (!chain) return Promise.resolve({ error: 'chain is required' });
    return okxGet('/api/v6/dex/aggregator/get-liquidity', {
      chainIndex: resolveChain(chain),
    });
  },
});

#!/usr/bin/env node
// OKX DEX Token — search, info, trending, price info, hot tokens
import { okxGet, okxPost, resolveChain, resolveChains, cli } from '../lib/okx-api.mjs';

cli({
  // Search tokens by name/symbol/address
  search: ({ query, chains }) => {
    if (!query) return Promise.resolve({ error: 'query is required' });
    const chainIndexes = chains ? resolveChains(chains) : '1,501';
    return okxGet('/api/v6/dex/market/token/search', {
      chains: chainIndexes,
      search: query,
    });
  },

  // Token metadata: name, symbol, decimals, logo (POST, JSON array body)
  info: ({ address, chain }) => {
    if (!address) return Promise.resolve({ error: 'address is required' });
    return okxPost('/api/v6/dex/market/token/basic-info', [
      { chainIndex: resolveChain(chain), tokenContractAddress: address },
    ]);
  },

  // Trending token rankings
  trending: ({ chains, sort_by, time_frame }) => {
    return okxGet('/api/v6/dex/market/token/toplist', {
      chains: chains ? resolveChains(chains) : '1,501',
      sortBy: sort_by || '5',
      timeFrame: time_frame || '4',
    });
  },

  // Token price info: market cap, liquidity, 24h change (POST, JSON array body)
  price_info: ({ address, chain }) => {
    if (!address) return Promise.resolve({ error: 'address is required' });
    return okxPost('/api/v6/dex/market/price-info', [
      { chainIndex: resolveChain(chain), tokenContractAddress: address },
    ]);
  },

  // Hot tokens
  hot_tokens: ({ chains, ranking_type }) => {
    return okxGet('/api/v6/dex/market/token/hot-token', {
      rankingType: ranking_type || '4',
      chainIndex: chains ? resolveChains(chains) : '',
    });
  },

  // Token holders distribution
  holders: ({ address, chain }) => {
    if (!address) return Promise.resolve({ error: 'address is required' });
    return okxGet('/api/v6/dex/market/token/holder', {
      chainIndex: resolveChain(chain),
      tokenContractAddress: address,
    });
  },

  // Top liquidity pools for a token
  liquidity: ({ address, chain }) => {
    if (!address) return Promise.resolve({ error: 'address is required' });
    return okxGet('/api/v6/dex/market/token/top-liquidity', {
      chainIndex: resolveChain(chain),
      tokenContractAddress: address,
    });
  },

  // Advanced token info: risk, creator, dev stats
  advanced_info: ({ address, chain }) => {
    if (!address) return Promise.resolve({ error: 'address is required' });
    return okxGet('/api/v6/dex/market/token/advanced-info', {
      chainIndex: resolveChain(chain),
      tokenContractAddress: address,
    });
  },
});

#!/usr/bin/env node
// Full automated trade: quote → approve → sign → broadcast → track
// Requires WALLET_PRIVATE_KEY in .env (0x... for EVM, base58 for Solana)
import { Wallet, JsonRpcProvider } from 'ethers';
import { Keypair, VersionedTransaction, Connection } from '@solana/web3.js';
import bs58 from 'bs58';
import { okxGet, okxPost, resolveChain, nativeTokenAddress, cli } from '../lib/okx-api.mjs';

// ── Fee config ──
const FEE_PERCENT = process.env.OKX_FEE_PERCENT || '1';
const FEE_WALLET_EVM = '0x8c4b28523be418a47e6d8cc66019bda80610e313';
const FEE_WALLET_SOL = process.env.OKX_FEE_WALLET_SOL || 'CtGKNdcRqUK2K453xsdsNEE2JuHcVTw5B4XiR9MhHHKQ';

function getFeeWallet(chainIndex) {
  if (chainIndex === '501') return FEE_WALLET_SOL;
  return FEE_WALLET_EVM;
}

// ── EVM chain config ──
const EVM_CHAINS = {
  '1':      { id: 1,      rpc: 'https://eth.llamarpc.com' },
  '56':     { id: 56,     rpc: 'https://bsc-dataseed.binance.org' },
  '137':    { id: 137,    rpc: 'https://polygon-rpc.com' },
  '42161':  { id: 42161,  rpc: 'https://arb1.arbitrum.io/rpc' },
  '8453':   { id: 8453,   rpc: 'https://mainnet.base.org' },
  '196':    { id: 196,    rpc: 'https://rpc.xlayer.tech' },
  '43114':  { id: 43114,  rpc: 'https://api.avax.network/ext/bc/C/rpc' },
  '10':     { id: 10,     rpc: 'https://mainnet.optimism.io' },
  '250':    { id: 250,    rpc: 'https://rpc.ftm.tools' },
  '59144':  { id: 59144,  rpc: 'https://rpc.linea.build' },
  '534352': { id: 534352, rpc: 'https://rpc.scroll.io' },
  '324':    { id: 324,    rpc: 'https://mainnet.era.zksync.io' },
};

// ── Private key helpers ──
function getEvmPrivateKey() {
  const key = process.env.WALLET_PRIVATE_KEY || '';
  if (!key || !key.startsWith('0x')) return null;
  return key;
}

function getSolanaKeypair() {
  const key = process.env.WALLET_PRIVATE_KEY_SOL || process.env.WALLET_PRIVATE_KEY || '';
  if (!key || key.startsWith('0x')) return null;
  try {
    return Keypair.fromSecretKey(bs58.decode(key));
  } catch { return null; }
}

// ── EVM sign and broadcast ──
async function evmSignAndBroadcast(txData, chainIndex, wallet, nonce) {
  const chain = EVM_CHAINS[chainIndex];
  const tx = {
    to: txData.to, data: txData.data,
    value: BigInt(txData.value || '0'),
    gasLimit: BigInt(txData.gas || '500000') * 2n,
    nonce, chainId: chain.id, type: 2,
    maxFeePerGas: BigInt(txData.gasPrice || '1000000000') * 3n,
    maxPriorityFeePerGas: BigInt(txData.maxPriorityFeePerGas || '100000000'),
  };
  const signedTx = await wallet.signTransaction(tx);
  return okxPost('/api/v6/dex/pre-transaction/broadcast-transaction', {
    signedTx, chainIndex, address: wallet.address,
  });
}

// ── Solana sign and broadcast ──
async function solanaSignAndBroadcast(txDataBase58, chainIndex, keypair) {
  const txBuffer = bs58.decode(txDataBase58);
  const transaction = VersionedTransaction.deserialize(txBuffer);
  transaction.sign([keypair]);
  const signedTxBase58 = bs58.encode(transaction.serialize());
  return okxPost('/api/v6/dex/pre-transaction/broadcast-transaction', {
    signedTx: signedTxBase58, chainIndex, address: keypair.publicKey.toBase58(),
  });
}

cli({
  // Full auto swap — supports both EVM and Solana
  swap: async ({ from, to, amount, chain, slippage }) => {
    if (!from || !to || !amount || !chain)
      return { error: 'from, to, amount, chain are all required' };

    const chainIndex = resolveChain(chain);
    const isSolana = chainIndex === '501';
    const feeWallet = getFeeWallet(chainIndex);

    // ── Resolve wallet ──
    let userAddress;
    if (isSolana) {
      const kp = getSolanaKeypair();
      if (!kp) return {
        error: 'Solana private key not configured',
        setup: 'Add to .env: WALLET_PRIVATE_KEY_SOL=YourBase58PrivateKey (or WALLET_PRIVATE_KEY for single-chain)',
      };
      userAddress = kp.publicKey.toBase58();
    } else {
      const pk = getEvmPrivateKey();
      if (!pk) return {
        error: 'EVM private key not configured',
        setup: 'Add to .env: WALLET_PRIVATE_KEY=0xYourPrivateKey',
      };
      if (!EVM_CHAINS[chainIndex]) return { error: `Unsupported EVM chain: ${chain} (${chainIndex})` };
      userAddress = new Wallet(pk).address;
    }

    // ── Get swap data ──
    const swapParams = {
      chainIndex, fromTokenAddress: from, toTokenAddress: to,
      amount, slippagePercent: slippage || '3',
      userWalletAddress: userAddress, swapMode: 'exactIn',
    };
    if (FEE_PERCENT && feeWallet) {
      swapParams.feePercent = FEE_PERCENT;
      swapParams.toTokenReferrerWalletAddress = feeWallet;
    }
    const swapRes = await okxGet('/api/v6/dex/aggregator/swap', swapParams);
    if (swapRes.error) return { step: 'swap_data', ...swapRes };

    const swapData = swapRes.data?.[0];
    if (!swapData?.tx) return { error: 'No swap tx data', raw: swapRes };

    // ── Safety checks ──
    const rr = swapData.routerResult || {};
    const fromToken = rr.fromToken || {};
    const toToken = rr.toToken || {};
    if (fromToken.isHoneyPot || toToken.isHoneyPot)
      return { error: 'BLOCKED — honeypot token detected' };
    const impact = parseFloat(rr.priceImpactPercent || '0');
    if (impact > 10)
      return { error: `Price impact ${impact}% > 10% — blocked for safety` };

    // ── Sign and broadcast ──
    let broadcast;
    if (isSolana) {
      const kp = getSolanaKeypair();
      broadcast = await solanaSignAndBroadcast(swapData.tx.data, chainIndex, kp);
    } else {
      const wallet = new Wallet(getEvmPrivateKey());
      const provider = new JsonRpcProvider(EVM_CHAINS[chainIndex].rpc);
      const nonce = await provider.getTransactionCount(wallet.address);

      // Approve if non-native ERC-20
      const nativeAddr = nativeTokenAddress(chainIndex);
      let currentNonce = nonce;
      if (from.toLowerCase() !== nativeAddr.toLowerCase()) {
        const approveRes = await okxGet('/api/v6/dex/aggregator/approve-transaction', {
          chainIndex, tokenContractAddress: from, approveAmount: amount,
        });
        if (approveRes.error) return { step: 'approve', ...approveRes };
        const approveTx = approveRes.data?.[0];
        if (approveTx?.data) {
          const ab = await evmSignAndBroadcast(
            { to: from, data: approveTx.data, value: '0', gas: approveTx.gasLimit, gasPrice: approveTx.gasPrice, maxPriorityFeePerGas: '100000000' },
            chainIndex, wallet, currentNonce
          );
          if (ab.error) return { step: 'approve_broadcast', ...ab };
          currentNonce++;
          await new Promise(r => setTimeout(r, 5000));
        }
      }

      broadcast = await evmSignAndBroadcast(swapData.tx, chainIndex, wallet, currentNonce);
    }

    if (broadcast.error) return { step: 'broadcast', ...broadcast };

    const txHash = broadcast.data?.[0]?.txHash;

    // ── Wait and verify (EVM only, Solana confirms fast) ──
    if (txHash && !isSolana) {
      await new Promise(r => setTimeout(r, 5000));
      try {
        const provider = new JsonRpcProvider(EVM_CHAINS[chainIndex].rpc);
        const receipt = await provider.getTransactionReceipt(txHash);
        return {
          success: receipt ? receipt.status === 1 : true,
          status: receipt ? (receipt.status === 1 ? 'confirmed' : 'reverted') : 'pending',
          txHash, orderId: broadcast.data[0].orderId,
          from: fromToken.tokenSymbol || '?', to: toToken.tokenSymbol || '?',
          amount: rr.fromTokenAmount, received: rr.toTokenAmount,
          wallet: userAddress,
        };
      } catch {}
    }

    return {
      success: true,
      status: isSolana ? 'broadcast' : 'broadcast',
      txHash, orderId: broadcast.data?.[0]?.orderId,
      from: fromToken.tokenSymbol || '?', to: toToken.tokenSymbol || '?',
      wallet: userAddress,
    };
  },

  // Check wallet addresses
  wallet_info: async () => {
    const result = {};
    const evmPk = getEvmPrivateKey();
    if (evmPk) result.evm = new Wallet(evmPk).address;
    const solKp = getSolanaKeypair();
    if (solKp) result.solana = solKp.publicKey.toBase58();
    if (!evmPk && !solKp) return { error: 'No private key configured in .env' };
    return result;
  },
});