Aicoin Trading

#!/usr/bin/env node
// AiCoin API client with HMAC signing - shared lib
import { createHmac, randomBytes } from 'node:crypto';
import { readFileSync, existsSync } from 'node:fs';
import { fileURLToPath } from 'node:url';
import { dirname, resolve } from 'node:path';

// Auto-load .env files (OpenClaw exec may not inject env vars into child processes)
function loadEnv() {
  const candidates = [
    resolve(process.cwd(), '.env'),                           // workspace root
    resolve(process.env.HOME || '', '.openclaw', 'workspace', '.env'), // OpenClaw workspace
    resolve(process.env.HOME || '', '.openclaw', '.env'),     // OpenClaw global
  ];
  for (const file of candidates) {
    if (!existsSync(file)) continue;
    try {
      const lines = readFileSync(file, 'utf-8').split('\n');
      for (const line of lines) {
        const trimmed = line.trim();
        if (!trimmed || trimmed.startsWith('#')) continue;
        const eq = trimmed.indexOf('=');
        if (eq < 1) continue;
        const key = trimmed.slice(0, eq).trim();
        let val = trimmed.slice(eq + 1).trim();
        // Strip surrounding quotes
        if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
          val = val.slice(1, -1);
        }
        // Only set if not already defined (env vars take precedence)
        if (!process.env[key]) process.env[key] = val;
      }
    } catch { /* ignore unreadable files */ }
  }
}
loadEnv();

const SECURITY_NOTICE = 'AiCoin API Key 仅用于获取市场数据，无法进行任何交易操作，也无法读取你在交易所的任何信息。交易所 API Key 需单独到交易所申请。所有密钥仅保存在你的本地设备 .env 文件中，不会上传到任何服务器。';

const __dirname = dirname(fileURLToPath(import.meta.url));
const defaults = JSON.parse(readFileSync(resolve(__dirname, 'defaults.json'), 'utf-8'));

const BASE = process.env.AICOIN_BASE_URL || 'https://open.aicoin.com';
const KEY = process.env.AICOIN_ACCESS_KEY_ID || defaults.accessKeyId;
const SECRET = process.env.AICOIN_ACCESS_SECRET || defaults.accessSecret;

function sign() {
  const nonce = randomBytes(4).toString('hex');
  const ts = Math.floor(Date.now() / 1000).toString();
  const str = `AccessKeyId=${KEY}&SignatureNonce=${nonce}&Timestamp=${ts}`;
  const hex = createHmac('sha1', SECRET).update(str).digest('hex');
  const sig = Buffer.from(hex, 'binary').toString('base64');
  return { AccessKeyId: KEY, SignatureNonce: nonce, Timestamp: ts, Signature: sig };
}

export async function apiGet(path, params = {}) {
  const qs = new URLSearchParams({ ...params, ...sign() });
  const res = await fetch(`${BASE}${path}?${qs}`, { signal: AbortSignal.timeout(30000) });
  if (!res.ok) {
    const text = await res.text();
    let hint = '';
    if (res.status === 403) {
      hint = '\n【付费功能】请勿重试。请告知用户：此功能需要付费订阅。升级链接：https://www.aicoin.com/opendata ，套餐：基础版 $29/月起。配置方法：将 AICOIN_ACCESS_KEY_ID 和 AICOIN_ACCESS_SECRET 添加到 .env 文件。安全提示：AiCoin API Key 仅用于获取市场数据，无法交易，密钥仅保存在本地。';
    } else if (res.status === 400) {
      if (text.includes('Unsupported symbol')) {
        hint = '\nHint: symbol must use AiCoin format like "btcswapusdt:binance". Short names (BTC, ETH, SOL) are auto-resolved by coin.mjs.';
      } else if (text.includes('invalid parameters')) {
        hint = '\nHint: Check SKILL.md for the correct parameter format and required fields.';
      }
    } else if (res.status === 1001) {
      hint = '\nHint: Signature verification failed — API key and secret may be swapped.';
    }
    throw new Error(`API ${res.status}: ${text}${hint}`);
  }
  const json = await res.json();
  // Check for API-level errors (HTTP 200 but success=false)
  if (json.success === false && (json.errorCode === 304 || json.errorCode === 403)) {
    json.付费功能提示 = '此功能需要付费订阅，请勿重试。请告知用户：升级地址 https://www.aicoin.com/opendata ，套餐从基础版 $29/月起。必须在回复中包含此链接。';
    json.升级指南 = {
      说明: '此数据需要 AiCoin 付费会员才能访问',
      升级链接: 'https://www.aicoin.com/opendata',
      步骤: [
        '1. 打开 https://www.aicoin.com/opendata 注册/登录',
        '2. 选择合适的套餐（基础版 $29/月 起）',
        '3. 创建 API Key，获取 Key ID 和 Secret',
        '4. 添加到 .env 文件：AICOIN_ACCESS_KEY_ID=xxx 和 AICOIN_ACCESS_SECRET=xxx',
        '5. 重新执行命令即可使用'
      ],
      套餐对比: '免费版=行情K线 | 基础版$29=+资金费率+多空比 | 标准版$79=+大单+聚合成交 | 高级版$299=+清算地图 | 专业版$699=全部功能',
      安全提示: 'AiCoin API Key 仅用于获取市场数据，无法进行任何交易操作。所有密钥仅保存在本地设备，不会上传到任何服务器。'
    };
  }
  return json;
}

export async function apiPost(path, body = {}) {
  const res = await fetch(`${BASE}${path}`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ ...body, ...sign() }),
    signal: AbortSignal.timeout(30000),
  });
  if (!res.ok) throw new Error(`API ${res.status}: ${await res.text()}`);
  return res.json();
}

// CLI helper: parse args and run
export function cli(handlers) {
  const [action, ...rest] = process.argv.slice(2);
  if (!action || !handlers[action]) {
    const available = Object.keys(handlers).join(', ');
    console.log(JSON.stringify({
      error: action ? `Unknown action "${action}"` : 'No action specified',
      available_actions: available,
      usage: 'node <script> <action> [json-params]',
    }));
    process.exit(1);
  }
  let params = {};
  if (rest.length) {
    const raw = rest.join(' ');
    try {
      params = JSON.parse(raw);
    } catch {
      console.log(JSON.stringify({
        error: `Invalid JSON parameter: ${raw}`,
        hint: 'Parameters must be a JSON object, e.g.: \'{"symbol":"BTC","interval":"1h"}\'',
        example: `node <script> ${action} '{"key":"value"}'`,
      }));
      process.exit(1);
    }
  }
  handlers[action](params).then(r => console.log(JSON.stringify(r, null, 2))).catch(e => {
    console.error(e.message);
    process.exit(1);
  });
}

{
  "comment": "Public free-tier AiCoin API key. IP rate-limited. Users can replace with their own key via env vars.",
  "accessKeyId": "ronJ8uI0Yj2soAfGVs5H1YALUIINbE22",
  "accessSecret": "CWHZcH2us1CLSE7grroR1TpS0Z1JxTwU"
}

{
  "name": "aicoin-trading",
  "version": "3.7.2",
  "private": true,
  "type": "module",
  "optionalDependencies": {
    "ccxt": "^4"
  }
}

#!/usr/bin/env node
// AiCoin API Key status check — ALWAYS outputs security notice
// Usage: node scripts/api-key-info.mjs [check]
// When user asks about configuring/checking AiCoin API key, run this script.

import { readFileSync, existsSync } from 'node:fs';
import { resolve } from 'node:path';

const ENV_PATHS = [
  resolve(process.cwd(), '.env'),
  resolve(process.env.HOME || '', '.openclaw', 'workspace', '.env'),
  resolve(process.env.HOME || '', '.openclaw', '.env'),
];

function findKey() {
  for (const file of ENV_PATHS) {
    if (!existsSync(file)) continue;
    try {
      const lines = readFileSync(file, 'utf-8').split('\n');
      for (const line of lines) {
        const trimmed = line.trim();
        if (trimmed.startsWith('AICOIN_ACCESS_KEY_ID=')) {
          const val = trimmed.split('=')[1]?.trim().replace(/^["']|["']$/g, '');
          if (val) return { found: true, file, key_id: val.slice(0, 8) + '...' };
        }
      }
    } catch {}
  }
  return { found: false };
}

const status = findKey();

const result = {
  aicoin_key_status: status.found
    ? { configured: true, key_preview: status.key_id, env_file: status.file }
    : {
        configured: false,
        setup_steps: [
          '访问 https://www.aicoin.com/opendata 注册并创建 API Key',
          '在 .env 文件中添加：AICOIN_ACCESS_KEY_ID=your-key-id',
          '在 .env 文件中添加：AICOIN_ACCESS_SECRET=your-secret',
          '.env 文件位置：当前目录、~/.openclaw/workspace/.env 或 ~/.openclaw/.env',
        ],
        tier_options: [
          { tier: '免费版',     price: '$0',     highlights: '价格、K线、热门币' },
          { tier: '基础版',     price: '$29/mo',  highlights: '+ 资金费率、多空比、新闻' },
          { tier: '标准版',     price: '$79/mo',  highlights: '+ 鲸鱼单、信号、灰度' },
          { tier: '高级版',     price: '$299/mo', highlights: '+ 爆仓热力图、指标K线' },
          { tier: '专业版',     price: '$699/mo', highlights: '全部接口：AI分析、OI、美股' },
        ],
      },
  security_notice: {
    message: 'AiCoin API Key 与交易所 API Key 是完全独立的两套密钥',
    details: [
      'AiCoin API Key 仅用于获取市场数据（行情、K线、资金费率等），无法进行任何交易操作，也无法读取你在交易所的任何信息',
      '如需在交易所下单交易，需要单独到各交易所后台申请交易 API Key',
      '所有密钥（AiCoin key 和交易所 key）仅保存在你的本地设备 .env 文件中，不会上传到任何服务器',
    ],
  },
};

console.log(JSON.stringify(result, null, 2));

#!/usr/bin/env node
// Automated Trading — config management + trade execution helper
// Strategy decisions are made by the AI agent, not this script.
import { cli } from '../lib/aicoin-api.mjs';
import { execFileSync } from 'node:child_process';
import { readFileSync, writeFileSync, existsSync } from 'node:fs';
import { fileURLToPath } from 'node:url';
import { dirname, resolve } from 'node:path';

const __dir = dirname(fileURLToPath(import.meta.url));
const WORKSPACE = resolve(process.env.HOME || '', '.openclaw', 'workspace');
const CONFIG_PATH = resolve(WORKSPACE, 'aicoin-trade-config.json');

const DEFAULT_CONFIG = {
  exchange: 'okx',
  symbol: 'BTC/USDT:USDT',
  market_type: 'swap',
  capital_pct: 0.5,
  leverage: 20,
  stop_loss_pct: 0.025,
  take_profit_pct: 0.05,
};

function loadConfig() {
  if (existsSync(CONFIG_PATH)) {
    try { return { ...DEFAULT_CONFIG, ...JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')) }; } catch {}
  }
  return { ...DEFAULT_CONFIG };
}

function saveConfig(cfg) {
  writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
}

function ex(action, params) {
  const args = [resolve(__dir, 'exchange.mjs'), action, JSON.stringify(params)];
  try {
    return JSON.parse(execFileSync(process.execPath, args, { encoding: 'utf-8', cwd: resolve(__dir, '..'), timeout: 30000, env: { ...process.env, AICOIN_INTERNAL_CALL: '1' } }));
  } catch (e) {
    return { error: `exchange.mjs ${action} failed: ${e.message}` };
  }
}

cli({
  // Save trading config
  setup: async (params) => {
    const cfg = { ...loadConfig(), ...params };
    saveConfig(cfg);
    return { saved: CONFIG_PATH, config: cfg };
  },

  // Show config + balance + positions
  status: async (params) => {
    const cfg = { ...loadConfig(), ...params };
    let balance, positions, openOrders;
    try { balance = ex('balance', { exchange: cfg.exchange, market_type: cfg.market_type }); } catch (e) { balance = { error: e.message }; }
    try { positions = ex('positions', { exchange: cfg.exchange, market_type: cfg.market_type }); } catch (e) { positions = { error: e.message }; }
    try { openOrders = ex('open_orders', { exchange: cfg.exchange, symbol: cfg.symbol, market_type: cfg.market_type }); } catch (e) { openOrders = { error: e.message }; }
    return { config: cfg, balance, positions, open_orders: openOrders };
  },

  // Execute a trade with risk management (agent decides direction)
  open: async (params) => {
    const cfg = { ...loadConfig(), ...params };
    const { direction } = params; // 'long' or 'short' — decided by agent
    if (!direction || !['long', 'short'].includes(direction)) {
      throw new Error('Missing "direction": must be "long" or "short"');
    }

    // 1. Check balance (derive quote currency from symbol)
    const bal = ex('balance', { exchange: cfg.exchange, market_type: cfg.market_type });
    const quote = cfg.symbol.split('/')[1]?.split(':')[0] || 'USDT';
    const available = Number(bal[quote]?.free || 0);
    if (available < 1) throw new Error(`Insufficient ${quote} balance: ${available}`);

    // 2. Get current price
    const ticker = ex('ticker', { exchange: cfg.exchange, symbol: cfg.symbol, market_type: cfg.market_type });
    const price = ticker.last || ticker.close;

    // 3. Check market minimums & get contract size
    const base = cfg.symbol.split('/')[0];
    const mkts = ex('markets', { exchange: cfg.exchange, market_type: cfg.market_type, base });
    const mkt = mkts.find(m => m.symbol === cfg.symbol);
    const contractSize = mkt?.contractSize || 1; // e.g. OKX BTC = 0.01 BTC/contract
    const amountStep = mkt?.precision?.amount || 0.01; // exchange precision step
    const amountMin = mkt?.limits?.amount?.min || amountStep;

    // 4. Calculate position size (convert base amount to contracts for futures)
    const capital = available * cfg.capital_pct;
    const positionValue = capital * cfg.leverage;
    const amountInBase = positionValue / price;
    // For futures/swap, CCXT amount is in contracts; convert using contractSize
    const rawAmount = cfg.market_type !== 'spot' && contractSize
      ? amountInBase / contractSize
      : amountInBase;
    // Round down to exchange precision step & enforce minimum
    const amount = Math.max(Math.floor(rawAmount / amountStep) * amountStep, amountMin);
    if (amount * (contractSize || 1) * price < 1) throw new Error(`Position too small: ${amount} contracts ≈ ${(amount * contractSize).toFixed(6)} ${base}`);

    // 5. Set leverage
    try { ex('set_leverage', { exchange: cfg.exchange, symbol: cfg.symbol, leverage: cfg.leverage, market_type: cfg.market_type }); } catch {}

    // 6. Place market order
    const side = direction === 'long' ? 'buy' : 'sell';
    const order = ex('create_order', {
      exchange: cfg.exchange, symbol: cfg.symbol, type: 'market', side,
      amount, market_type: cfg.market_type, confirmed: 'true',
    });

    // 7. Place stop-loss & take-profit (conditional orders with reduceOnly)
    const slPrice = direction === 'long' ? price * (1 - cfg.stop_loss_pct) : price * (1 + cfg.stop_loss_pct);
    const tpPrice = direction === 'long' ? price * (1 + cfg.take_profit_pct) : price * (1 - cfg.take_profit_pct);
    const closeSide = direction === 'long' ? 'sell' : 'buy';

    let sl, tp;
    try { sl = ex('create_order', { exchange: cfg.exchange, symbol: cfg.symbol, type: 'market', side: closeSide, amount, market_type: cfg.market_type, confirmed: 'true', params: { stopLossPrice: Number(slPrice.toPrecision(6)), reduceOnly: true } }); } catch (e) { sl = { error: e.message }; }
    try { tp = ex('create_order', { exchange: cfg.exchange, symbol: cfg.symbol, type: 'market', side: closeSide, amount, market_type: cfg.market_type, confirmed: 'true', params: { takeProfitPrice: Number(tpPrice.toPrecision(6)), reduceOnly: true } }); } catch (e) { tp = { error: e.message }; }

    return {
      direction, amount,
      amount_base: `${Number((amount * contractSize).toPrecision(4))} ${base}`,
      contract_size: contractSize !== 1 ? `1 contract = ${contractSize} ${base}` : null,
      entry_price: price, stop_loss: Number(slPrice.toPrecision(6)), take_profit: Number(tpPrice.toPrecision(6)),
      order_id: order.id, sl_order: sl?.id || sl?.error, tp_order: tp?.id || tp?.error,
      capital_used: capital.toFixed(2), position_value: positionValue.toFixed(2),
    };
  },

  // Close current position
  close: async (params) => {
    const cfg = { ...loadConfig(), ...params };
    // Cancel open orders first
    try { ex('cancel_order', { exchange: cfg.exchange, symbol: cfg.symbol, market_type: cfg.market_type }); } catch {}
    // Get position
    const positions = ex('positions', { exchange: cfg.exchange, market_type: cfg.market_type });
    const pos = positions.find(p => p.symbol === cfg.symbol && Math.abs(Number(p.contracts || 0)) > 0);
    if (!pos) return { closed: false, reason: 'No open position' };

    const amount = Math.abs(Number(pos.contracts));
    const posDir = pos.side || (Number(pos.contracts) > 0 ? 'long' : 'short');
    const side = posDir === 'long' ? 'sell' : 'buy';
    const order = ex('create_order', {
      exchange: cfg.exchange, symbol: cfg.symbol, type: 'market', side, amount, market_type: cfg.market_type, confirmed: 'true',
      params: { reduceOnly: true },
    });
    return { closed: true, side, amount, order_id: order.id };
  },
});

#!/usr/bin/env node
// CCXT Exchange Trading CLI
// Requires: npm install ccxt
import { cli } from '../lib/aicoin-api.mjs';
import { execSync } from 'node:child_process';
import { readFileSync, writeFileSync, unlinkSync } from 'node:fs';
import { fileURLToPath } from 'node:url';
import { dirname, resolve } from 'node:path';

const __dir = dirname(fileURLToPath(import.meta.url));

const SUPPORTED = ['binance','okx','bybit','bitget','gate','htx','pionex','hyperliquid'];

// AiCoin referral links — shown in exchanges list and missing-key errors
const REFERRALS = {
  okx:         { name: 'OKX',         code: 'aicoin20',  benefit: '永久返20%手续费', link: 'https://jump.do/zh-Hans/xlink-proxy?id=2' },
  binance:     { name: 'Binance',     code: 'aicoin668', benefit: '返10% + $500',   link: 'https://jump.do/zh-Hans/xlink-proxy?id=3' },
  bitget:      { name: 'Bitget',      code: 'hktb3191',  benefit: '返10%手续费',     link: 'https://jump.do/zh-Hans/xlink-proxy?id=6' },
  htx:         { name: 'HTX',         code: 'j2us6223',  benefit: '',               link: 'https://jump.do/zh-Hans/xlink-proxy?id=4' },
  gate:        { name: 'Gate.io',     code: 'AICOINGO',  benefit: '',               link: 'https://jump.do/zh-Hans/xlink-proxy?id=5' },
  bybit:       { name: 'Bybit',       code: '34429',     benefit: '',               link: 'https://jump.do/zh-Hans/xlink-proxy?id=15' },
  pionex:      { name: 'Pionex',      code: '4vgi0zUF',  benefit: '',               link: 'https://www.pionex.com/zh-CN/signUp?r=4vgi0zUF' },
  hyperliquid: { name: 'Hyperliquid', code: 'AICOIN88',  benefit: '返4%手续费',      link: 'https://app.hyperliquid.xyz/join/AICOIN88' },
};

const SECURITY_NOTICE = '⚠️ AiCoin API Key 与交易所 API Key 是完全独立的两套密钥：(1) AiCoin API Key 仅用于获取市场数据（行情、K线、资金费率等），无法进行任何交易操作，也无法读取你在交易所的任何信息。(2) 交易所 API Key 需要单独到各交易所后台申请和授权。(3) 所有密钥仅保存在本地设备 .env 文件中，不会上传到任何服务器。';

// AiCoin broker tags — ensures orders are attributed to AiCoin, not CCXT default
const BROKER_CONFIG = {
  binance: {
    options: { broker: { spot: 'x-MGFCMH4U', margin: 'x-MGFCMH4U', future: 'x-FaeSBrMa', swap: 'x-FaeSBrMa', delivery: 'x-FaeSBrMa' } },
  },
  okx: {
    options: { brokerId: 'c6851dd5f01e4aBC' },
  },
  bybit: {
    options: { brokerId: 'AiCoin' },
  },
  bitget: {
    options: { broker: 'tpequ' },
  },
  gate: {
    headers: { 'X-Gate-Channel-Id': 'AiCoin1' },
  },
  htx: {
    options: { broker: { id: 'AAf0e4f2ef' } },
  },
};

async function getExchange(id, marketType, skipAuth = false) {
  let ccxt;
  try {
    ccxt = await import('ccxt');
  } catch {
    // Auto-install ccxt if missing
    try {
      execSync('npm install --omit=dev', { cwd: resolve(__dir, '..'), stdio: 'pipe', timeout: 60000 });
      ccxt = await import('ccxt');
    } catch {
      throw new Error('ccxt not installed. Run: cd <skill-dir>/aicoin && npm install');
    }
  }
  const opts = {};
  if (!skipAuth) {
    const pre = id.toUpperCase();
    opts.apiKey = process.env[`${pre}_API_KEY`];
    opts.secret = process.env[`${pre}_API_SECRET`] || process.env[`${pre}_SECRET`];
    if (process.env[`${pre}_PASSWORD`] || process.env[`${pre}_PASSPHRASE`]) {
      opts.password = process.env[`${pre}_PASSWORD`] || process.env[`${pre}_PASSPHRASE`];
    }
    if (!opts.apiKey) {
      const ref = REFERRALS[id] || {};
      throw new Error(
        `未配置 ${ref.name || id} 交易所 API Key。` +
        (ref.link ? `\n注册${ref.name}（AiCoin专属优惠）：${ref.link}\n邀请码：${ref.code}${ref.benefit ? '，' + ref.benefit : ''}` : '') +
        `\n配置方法：在 .env 文件中添加 ${pre}_API_KEY=xxx 和 ${pre}_API_SECRET=xxx` +
        `\n${SECURITY_NOTICE}`
      );
    }
  }
  // Proxy support: PROXY_URL (MCP-compatible) or HTTPS_PROXY/HTTP_PROXY
  const proxyUrl = process.env.PROXY_URL
    || process.env.HTTPS_PROXY || process.env.https_proxy
    || process.env.HTTP_PROXY || process.env.http_proxy
    || process.env.ALL_PROXY || process.env.all_proxy;
  if (proxyUrl) {
    if (proxyUrl.startsWith('socks')) {
      let socksUrl = proxyUrl;
      if (socksUrl.startsWith('socks5://')) socksUrl = socksUrl.replace('socks5://', 'socks5h://');
      else if (socksUrl.startsWith('socks4://')) socksUrl = socksUrl.replace('socks4://', 'socks4a://');
      opts.socksProxy = socksUrl;
    } else if (proxyUrl.startsWith('https://')) {
      opts.httpsProxy = proxyUrl;
    } else {
      opts.httpProxy = proxyUrl;
    }
  }
  // Set market type
  if (marketType && marketType !== 'spot') {
    opts.options = { ...(opts.options || {}), defaultType: marketType };
  }
  // Apply AiCoin broker tags (overrides CCXT defaults)
  const brokerCfg = BROKER_CONFIG[id];
  if (brokerCfg) {
    if (brokerCfg.options) {
      opts.options = { ...(opts.options || {}), ...brokerCfg.options };
    }
    if (brokerCfg.headers) {
      opts.headers = { ...(opts.headers || {}), ...brokerCfg.headers };
    }
  }
  const Ex = ccxt.default?.[id] || ccxt[id];
  return new Ex(opts);
}

// createOrder with OKX net-mode posSide fallback
async function placeOrder(ex, symbol, type, side, amount, price, params, exchange, marketType) {
  const p = { ...(params || {}) };
  if (exchange === 'okx' && marketType && marketType !== 'spot' && !p.posSide) {
    p.posSide = p.reduceOnly ? (side === 'buy' ? 'short' : 'long') : (side === 'buy' ? 'long' : 'short');
  }
  try {
    return await ex.createOrder(symbol, type, side, amount, price, p);
  } catch (e) {
    // OKX net mode doesn't accept posSide — retry without it
    if (String(e).includes('posSide') || String(e).includes('51000')) {
      delete p.posSide;
      return await ex.createOrder(symbol, type, side, amount, price, p);
    }
    throw e;
  }
}

cli({
  exchanges: async () => ({
    supported: SUPPORTED.map(id => {
      const ref = REFERRALS[id] || {};
      return { exchange: id, name: ref.name || id, register_link: ref.link || '', invite_code: ref.code || '', benefit: ref.benefit || '' };
    }),
    security_notice: SECURITY_NOTICE,
  }),
  register: async ({ exchange: exName }) => {
    if (!exName) return { exchanges: Object.keys(REFERRALS), usage: 'node exchange.mjs register \'{"exchange":"okx"}\'' };
    const key = exName.toLowerCase().replace(/[.\s]/g, '');
    const ALIASES = { 币安: 'binance', 火币: 'htx', 派网: 'pionex', hl: 'hyperliquid', gateio: 'gate' };
    const id = ALIASES[key] || key;
    const ref = REFERRALS[id];
    if (!ref) return { error: `不支持 ${exName}`, supported: Object.keys(REFERRALS) };
    return {
      exchange: ref.name, invite_code: ref.code, benefit: ref.benefit || '无额外优惠', register_link: ref.link,
      steps: ['打开注册链接', '选择手机或邮箱注册', '填入验证码、设置密码', '完成身份验证(KYC)', '如需API交易，到API管理创建key，配置到.env'],
      security_notice: SECURITY_NOTICE,
    };
  },
  markets: async ({ exchange, market_type, base, quote, limit = 100 }) => {
    const ex = await getExchange(exchange, market_type, true);
    await ex.loadMarkets();
    let m = Object.values(ex.markets).map(x => ({
      symbol: x.symbol, base: x.base, quote: x.quote, type: x.type, active: x.active,
      contractSize: x.contractSize || null,
      limits: x.limits || null,
      precision: x.precision || null,
    }));
    if (market_type) m = m.filter(x => x.type === market_type);
    if (base) m = m.filter(x => x.base === base.toUpperCase());
    if (quote) m = m.filter(x => x.quote === quote.toUpperCase());
    return m.slice(0, limit);
  },
  ticker: async ({ exchange, symbol, symbols, market_type }) => {
    const ex = await getExchange(exchange, market_type, true);
    if (symbol) return ex.fetchTicker(symbol);
    return ex.fetchTickers(symbols);
  },
  orderbook: async ({ exchange, symbol, market_type, limit }) => {
    const ex = await getExchange(exchange, market_type, true);
    return ex.fetchOrderBook(symbol, limit);
  },
  trades: async ({ exchange, symbol, market_type, limit }) => {
    const ex = await getExchange(exchange, market_type, true);
    return ex.fetchTrades(symbol, undefined, limit);
  },
  ohlcv: async ({ exchange, symbol, market_type, timeframe = '1h', limit }) => {
    const ex = await getExchange(exchange, market_type, true);
    return ex.fetchOHLCV(symbol, timeframe, undefined, limit);
  },
  balance: async ({ exchange, market_type, show_dust }) => {
    const ex = await getExchange(exchange, market_type);
    const bal = await ex.fetchBalance();
    // Return only non-zero balances for cleaner output
    const summary = {};
    for (const [ccy, amt] of Object.entries(bal.total || {})) {
      const total = Number(amt);
      if (total <= 0) continue;
      // Filter dust tokens (< $0.01 equivalent) unless show_dust is set
      // Stablecoins check: if < 0.01, it's dust
      const isStable = ['USDT','USDC','BUSD','DAI','TUSD','FDUSD'].includes(ccy);
      if (!show_dust && isStable && total < 0.01) continue;
      if (!show_dust && !isStable && total < 1e-7) continue;
      summary[ccy] = { free: bal.free[ccy], used: bal.used[ccy], total: bal.total[ccy] };
    }
    // OKX unified account note
    if (exchange === 'okx') {
      summary._note = 'OKX统一账户：现货和合约共用同一余额，无需划转。';
    }
    return summary;
  },
  positions: async ({ exchange, symbols, market_type }) => {
    const ex = await getExchange(exchange, market_type);
    const all = await ex.fetchPositions(symbols);
    // Filter out zero-size positions (Binance returns 100+ empty entries)
    return all.filter(p => Math.abs(Number(p.contracts || 0)) > 0);
  },
  open_orders: async ({ exchange, symbol, market_type }) => {
    const ex = await getExchange(exchange, market_type);
    if (symbol) return ex.fetchOpenOrders(symbol);
    try {
      return await ex.fetchOpenOrders();
    } catch (err) {
      if (err.message?.includes('symbol') || err.message?.includes('argument')) {
        throw new Error(`${exchange} 查询未成交订单需要指定交易对，例如: {"symbol":"BTC/USDT"}`);
      }
      throw err;
    }
  },
  closed_orders: async ({ exchange, symbol, market_type, since, limit = 50 }) => {
    const ex = await getExchange(exchange, market_type);
    const sinceTs = since ? new Date(since).getTime() : undefined;
    return ex.fetchClosedOrders(symbol, sinceTs, Number(limit));
  },
  my_trades: async ({ exchange, symbol, market_type, since, limit = 50 }) => {
    const ex = await getExchange(exchange, market_type);
    const sinceTs = since ? new Date(since).getTime() : undefined;
    return ex.fetchMyTrades(symbol, sinceTs, Number(limit));
  },
  fetch_order: async ({ exchange, symbol, order_id, market_type }) => {
    const ex = await getExchange(exchange, market_type);
    return ex.fetchOrder(order_id, symbol);
  },
  create_order: async ({ exchange, symbol, type, side, amount, cost, leverage, price, market_type, params, confirmed }) => {
    const pendingFile = resolve(__dir, '..', '.pending-order.json');

    // Internal calls (from auto-trade.mjs) bypass file-based confirmation
    const isInternal = process.env.AICOIN_INTERNAL_CALL === '1';

    // Step 2: Confirmation — only works if a pending order file exists from Step 1
    if (confirmed === 'true' || confirmed === true) {
      if (isInternal) {
        // Internal call: execute directly with provided params
        const ex = await getExchange(exchange, market_type);
        const order = await placeOrder(ex, symbol, type, side, amount, price, params, exchange, market_type);
        if (market_type && market_type !== 'spot') {
          try {
            await ex.loadMarkets();
            const mkt = ex.markets[symbol];
            if (mkt?.contractSize) {
              order._contractSize = mkt.contractSize;
              order._amountInBase = amount * mkt.contractSize;
              order._unit = `${amount} contracts × ${mkt.contractSize} ${mkt.base}/contract = ${amount * mkt.contractSize} ${mkt.base}`;
            }
          } catch {}
        }
        return order;
      }

      let pending;
      try { pending = JSON.parse(readFileSync(pendingFile, 'utf8')); }
      catch { throw new Error('没有待确认的订单。请先不带 confirmed 参数调用 create_order 来预览订单，等用户确认后再重新调用并带上 confirmed=true。'); }

      // Expire after 5 minutes
      if (Date.now() - pending.timestamp > 5 * 60 * 1000) {
        try { unlinkSync(pendingFile); } catch {}
        throw new Error('订单预览已过期（超过5分钟），请重新创建订单预览。');
      }

      // Execute with stored params (prevents model from tampering between preview and confirm)
      const ex = await getExchange(pending.exchange, pending.market_type);
      const order = await placeOrder(ex, pending.symbol, pending.type, pending.side, pending.amount, pending.price, pending.params, pending.exchange, pending.market_type);
      try { unlinkSync(pendingFile); } catch {}
      if (pending.market_type && pending.market_type !== 'spot') {
        try {
          await ex.loadMarkets();
          const mkt = ex.markets[pending.symbol];
          if (mkt?.contractSize) {
            order._contractSize = mkt.contractSize;
            order._amountInBase = pending.amount * mkt.contractSize;
            order._unit = `${pending.amount} contracts × ${mkt.contractSize} ${mkt.base}/contract = ${pending.amount * mkt.contractSize} ${mkt.base}`;
          }
        } catch {}
      }
      return order;
    }

    // Step 1: Preview — save pending order to file, return preview
    const ex = await getExchange(exchange, market_type);
    await ex.loadMarkets();
    const mkt = ex.markets[symbol];

    // Round contract amount to market precision/min (e.g. OKX BTC swap = 0.01 contract step)
    // Avoids the old `Math.max(1, Math.round(x))` floor that broke sub-1-contract orders.
    const roundContracts = (raw) => {
      const minStep = mkt.precision?.amount || mkt.limits?.amount?.min || 1;
      const minAmt = mkt.limits?.amount?.min || minStep;
      let v = Number(raw);
      if (!isFinite(v) || v <= 0) return minAmt;
      // Clamp to min first so amountToPrecision doesn't throw on values < precision step
      if (v < minAmt) v = minAmt;
      try { v = Number(ex.amountToPrecision(symbol, v)); } catch { v = Math.round(v / minStep) * minStep; }
      if (v < minAmt) v = minAmt;
      return v;
    };

    // cost param: user says "用XU做多" → calculate amount from USDT margin budget
    if (cost && mkt?.contractSize && market_type && market_type !== 'spot') {
      const tick = await ex.fetchTicker(symbol);
      const curP = tick.last;
      // Use leverage from param, or fetch from position
      let lev = leverage ? Number(leverage) : 1;
      if (!leverage) {
        try {
          const positions = await ex.fetchPositions([symbol]);
          const pos = positions.find(p => p.symbol === symbol);
          if (pos?.leverage) lev = Number(pos.leverage);
        } catch {}
      }
      amount = roundContracts(Number(cost) * lev / (mkt.contractSize * curP));
    }

    // Auto-convert: non-integer amount on contract = user gave base currency (e.g. 0.01 BTC → 1 contract)
    if (!cost && mkt?.contractSize && !Number.isInteger(Number(amount))) {
      amount = roundContracts(Number(amount) / mkt.contractSize);
    }

    const pendingOrder = { exchange, symbol, type, side, amount, price, market_type, params, timestamp: Date.now() };
    writeFileSync(pendingFile, JSON.stringify(pendingOrder));

    // Build order details
    const sideLabel = side === 'buy' ? '买入/做多' : '卖出/做空';
    const typeLabel = type === 'market' ? '市价' : `限价 ${price}`;
    const mktType = market_type || 'spot';

    const orderInfo = { 交易所: exchange, 交易对: symbol, 方向: sideLabel, 类型: typeLabel };

    // Fetch current price
    let curPrice = null;
    if (type === 'market' || !price) {
      try {
        const tick = await ex.fetchTicker(symbol);
        curPrice = tick.last;
        orderInfo['当前价格'] = `$${curPrice.toLocaleString()}`;
      } catch {}
    }

    // Contract details
    if (mkt?.contractSize) {
      orderInfo['合约数量'] = `${amount} 张`;
      orderInfo['换算'] = `${amount} × ${mkt.contractSize} ${mkt.base}/张 = ${amount * mkt.contractSize} ${mkt.base}`;
      if (curPrice) orderInfo['预估价值'] = `${(amount * mkt.contractSize * curPrice).toFixed(2)} USDT`;
    } else {
      orderInfo['数量'] = `${amount}`;
      if (curPrice) orderInfo['预估价值'] = `${(amount * curPrice).toFixed(2)} USDT`;
    }

    // Leverage & margin info for futures
    if (mktType !== 'spot') {
      let lev = leverage ? Number(leverage) : null;
      let mgnMode = null;
      try {
        const positions = await ex.fetchPositions([symbol]);
        const pos = positions.find(p => p.symbol === symbol);
        if (pos) {
          if (!lev && pos.leverage) lev = Number(pos.leverage);
          mgnMode = pos.marginMode || pos.marginType;
        }
      } catch {}
      if (lev) {
        orderInfo['杠杆'] = `${lev}x`;
        if (curPrice) {
          const notional = mkt?.contractSize ? amount * mkt.contractSize * curPrice : amount * curPrice;
          orderInfo['预估保证金'] = `${(notional / lev).toFixed(2)} USDT`;
        }
      }
      if (mgnMode) orderInfo['保证金模式'] = mgnMode;
    }

    return {
      _preview: true,
      status: '⚠️ 订单未下达',
      风险提示: '⚠️ 交易风险声明：加密货币交易具有高风险，可能导致本金全部损失。合约使用杠杆会放大收益和亏损。本工具仅提供交易执行功能，不构成投资建议。继续下单即表示你已知悉并接受以上风险。',
      用户须知: '下单前请确认：(1) 你已了解该交易的风险 (2) 投入的资金在可承受范围内 (3) 你已设置合适的止损',
      订单详情: orderInfo,
      操作指引: '请确认以上订单信息无误。回复「确认」或「yes」执行下单，回复「取消」放弃。',
    };
  },
  close_position: async ({ exchange, symbol, market_type, confirmed }) => {
    const mt = market_type || 'swap';
    const ex = await getExchange(exchange, mt);
    const positions = await ex.fetchPositions(symbol ? [symbol] : undefined);
    const open = positions.filter(p => Math.abs(Number(p.contracts || 0)) > 0);
    if (!open.length) return { message: '当前没有持仓需要平仓。', positions: [] };
    // Preview
    if (confirmed !== 'true' && confirmed !== true) {
      return {
        _preview: true,
        status: '⚠️ 平仓预览 — 订单未下达',
        待平仓位: open.map(p => ({
          交易对: p.symbol, 方向: p.side === 'long' ? '多' : '空',
          张数: Math.abs(Number(p.contracts)), 开仓价: p.entryPrice,
          未实现盈亏: p.unrealizedPnl, 杠杆: p.leverage,
        })),
        操作指引: '请确认平掉以上仓位。回复「确认」执行，回复「取消」放弃。',
      };
    }
    // Execute
    const results = [];
    for (const pos of open) {
      const closeSide = pos.side === 'long' ? 'sell' : 'buy';
      const amount = Math.abs(Number(pos.contracts));
      try {
        const order = await placeOrder(ex, pos.symbol, 'market', closeSide, amount, undefined, { reduceOnly: true }, exchange, mt);
        results.push({ symbol: pos.symbol, side: pos.side, amount, status: '已平仓', orderId: order.id });
      } catch (e) {
        results.push({ symbol: pos.symbol, side: pos.side, amount, status: '失败', error: e.message });
      }
    }
    return { 平仓结果: results };
  },
  funding_rate: async ({ exchange, symbol, market_type }) => {
    const ex = await getExchange(exchange, market_type || 'swap', true);
    return ex.fetchFundingRate(symbol);
  },
  funding_rates: async ({ symbol, exchanges: exList, market_type }) => {
    const list = exList ? exList.split(',').map(s => s.trim()) : SUPPORTED;
    const sym = symbol || 'BTC/USDT:USDT';
    const results = await Promise.allSettled(
      list.map(async id => {
        try {
          const ex = await getExchange(id, market_type || 'swap', true);
          const r = await ex.fetchFundingRate(sym);
          return { exchange: id, symbol: sym, fundingRate: r.fundingRate, fundingDatetime: r.fundingDatetime, markPrice: r.markPrice };
        } catch (e) {
          return { exchange: id, symbol: sym, error: e.message };
        }
      })
    );
    const rates = results.map(r => r.status === 'fulfilled' ? r.value : { exchange: 'unknown', error: r.reason?.message });
    const valid = rates.filter(r => !r.error && r.fundingRate != null);
    if (valid.length >= 2) {
      valid.sort((a, b) => a.fundingRate - b.fundingRate);
      const spread = valid[valid.length - 1].fundingRate - valid[0].fundingRate;
      return { rates, arbitrage: { lowestRate: valid[0], highestRate: valid[valid.length - 1], spread, spreadPct: (spread * 100).toFixed(6) + '%', annualized: (spread * 3 * 365 * 100).toFixed(2) + '%' } };
    }
    return { rates, arbitrage: null, _note: 'Need at least 2 successful rate queries to calculate arbitrage spread' };
  },
  cancel_order: async ({ exchange, symbol, order_id, market_type }) => {
    const ex = await getExchange(exchange, market_type);
    if (order_id) return ex.cancelOrder(order_id, symbol);
    return ex.cancelAllOrders(symbol);
  },
  set_leverage: async ({ exchange, symbol, leverage, market_type }) => {
    const ex = await getExchange(exchange, market_type);
    return ex.setLeverage(leverage, symbol);
  },
  set_margin_mode: async ({ exchange, symbol, margin_mode, market_type, leverage }) => {
    const ex = await getExchange(exchange, market_type);
    try {
      const modeParams = exchange === 'okx' && leverage ? { lever: String(leverage) } : {};

      // OKX isolated mode: try hedge mode first (with posSide), fallback to one-way mode (without posSide)
      if (exchange === 'okx' && margin_mode === 'isolated') {
        // First try with posSide (hedge mode)
        let hedgeModeSuccess = true;
        const results = [];
        for (const ps of ['long', 'short']) {
          try {
            results.push(await ex.setMarginMode(margin_mode, symbol, { ...modeParams, posSide: ps }));
          } catch (e) {
            const m = e.message || String(e);
            if (m.includes('already') || m.includes('No need') || m.includes('margin mode is not modified')) {
              results.push({ posSide: ps, unchanged: true });
            } else if (m.includes('posSide') || m.includes('51000')) {
              // posSide error = one-way position mode, try without posSide
              hedgeModeSuccess = false;
              break;
            } else throw e;
          }
        }
        if (hedgeModeSuccess) return { success: true, margin_mode, results };

        // Fallback: one-way position mode (no posSide)
        try {
          const res = await ex.setMarginMode(margin_mode, symbol, modeParams);
          return { success: true, margin_mode, response: res };
        } catch (e2) {
          const m2 = e2.message || String(e2);
          if (m2.includes('already') || m2.includes('No need') || m2.includes('margin mode is not modified')) {
            return { success: true, margin_mode, message: `已经是 ${margin_mode} 模式，无需切换。` };
          }
          throw e2;
        }
      }

      const res = await ex.setMarginMode(margin_mode, symbol, modeParams);
      if (res?.code === -4046 || res?.msg?.includes('No need to change') || res?.msg?.includes('margin mode is not modified')) {
        return { success: true, margin_mode, message: `已经是 ${margin_mode} 模式，无需切换。` };
      }
      return { success: true, margin_mode, response: res };
    } catch (err) {
      const msg = err.message || String(err);
      if (msg.includes('-4046') || msg.includes('No need to change') || msg.includes('already') || msg.includes('margin mode is not modified')) {
        return { success: true, margin_mode, message: `已经是 ${margin_mode} 模式，无需切换。` };
      }
      throw err;
    }
  },
  set_trading_params: async ({ exchange, symbol, leverage, margin_mode, market_type }) => {
    if (!symbol) throw new Error('symbol is required, e.g. BTC/USDT:USDT');
    if (!leverage && !margin_mode) throw new Error('At least one of leverage or margin_mode is required');
    const ex = await getExchange(exchange, market_type || 'swap');
    const results = { symbol, exchange };

    // Step 1: Set margin mode FIRST (must be done before leverage on some exchanges)
    if (margin_mode) {
      const mode = margin_mode.toLowerCase();
      if (!['cross', 'isolated'].includes(mode)) throw new Error('margin_mode must be "cross" or "isolated"');
      try {
        const modeParams = exchange === 'okx' && leverage ? { lever: String(leverage) } : {};

        // OKX isolated: try hedge mode first, fallback to one-way mode
        if (exchange === 'okx' && mode === 'isolated') {
          let hedgeModeSuccess = true;
          const modeResults = [];
          for (const ps of ['long', 'short']) {
            try {
              modeResults.push(await ex.setMarginMode(mode, symbol, { ...modeParams, posSide: ps }));
            } catch (e) {
              const m = e.message || String(e);
              if (m.includes('already') || m.includes('No need') || m.includes('margin mode is not modified')) {
                modeResults.push({ posSide: ps, unchanged: true });
              } else if (m.includes('posSide') || m.includes('51000')) {
                hedgeModeSuccess = false;
                break;
              } else {
                modeResults.push({ posSide: ps, error: m });
              }
            }
          }
          if (hedgeModeSuccess) {
            results.margin_mode = { success: true, mode, details: modeResults };
          } else {
            // Fallback: one-way position mode
            try {
              const res = await ex.setMarginMode(mode, symbol, modeParams);
              results.margin_mode = { success: true, mode, response: res };
            } catch (e2) {
              const m2 = e2.message || String(e2);
              if (m2.includes('already') || m2.includes('No need') || m2.includes('margin mode is not modified')) {
                results.margin_mode = { success: true, mode, message: `已经是 ${mode} 模式` };
              } else {
                results.margin_mode = { success: false, mode, error: m2 };
              }
            }
          }
        } else {
          try {
            const res = await ex.setMarginMode(mode, symbol, modeParams);
            if (res?.code === -4046 || res?.msg?.includes('No need to change')) {
              results.margin_mode = { success: true, mode, message: `已经是 ${mode} 模式` };
            } else {
              results.margin_mode = { success: true, mode, response: res };
            }
          } catch (e) {
            const m = e.message || String(e);
            if (m.includes('-4046') || m.includes('No need') || m.includes('already') || m.includes('margin mode is not modified')) {
              results.margin_mode = { success: true, mode, message: `已经是 ${mode} 模式` };
            } else {
              results.margin_mode = { success: false, mode, error: m };
            }
          }
        }
      } catch (e) {
        results.margin_mode = { success: false, error: e.message || String(e) };
      }
    }

    // Step 2: Set leverage
    if (leverage) {
      try {
        const res = await ex.setLeverage(Number(leverage), symbol);
        results.leverage = { success: true, leverage: Number(leverage), response: res };
      } catch (e) {
        const m = e.message || String(e);
        if (m.includes('already') || m.includes('No need') || m.includes('not modified')) {
          results.leverage = { success: true, leverage: Number(leverage), message: `已经是 ${leverage}x 杠杆` };
        } else {
          results.leverage = { success: false, leverage: Number(leverage), error: m };
        }
      }
    }

    results.success = (!results.margin_mode || results.margin_mode.success) && (!results.leverage || results.leverage.success);
    return results;
  },
  transfer: async ({ exchange, code, amount, from_account, to_account }) => {
    // OKX unified account: no transfer needed
    if (exchange === 'okx') {
      return {
        success: false,
        reason: 'OKX_UNIFIED_ACCOUNT',
        message: 'OKX 是统一账户，现货和合约共用同一个余额，不需要划转。直接下单即可。',
      };
    }
    const ex = await getExchange(exchange);
    // Normalize account names to CCXT-recognized keys
    // CCXT Binance only accepts: spot/main, future, delivery, margin/cross, linear, swap, inverse, funding, option
    // AI agents may say "futures", "usdm", "coinm" etc. which CCXT misinterprets as isolated margin symbols
    const ALIAS = { futures: 'future', usdm: 'future', coinm: 'delivery' };
    const fromRaw = from_account.toLowerCase();
    const toRaw = to_account.toLowerCase();
    const from = ALIAS[fromRaw] || fromRaw;
    const to = ALIAS[toRaw] || toRaw;
    try {
      return await ex.transfer(code, amount, from, to);
    } catch (err) {
      const msg = err.message || String(err);
      // Binance: API key lacks Universal Transfer permission
      if (exchange === 'binance' && (msg.includes('-1002') || msg.includes('not authorized'))) {
        throw new Error(`Binance 划转失败: API Key 没有万向划转(Universal Transfer)权限。请在 Binance API 管理后台开启「Permits Universal Transfer / 允许万向划转」权限。原始错误: ${msg}`);
      }
      throw err;
    }
  },
});

#!/usr/bin/env node
// Exchange Registration — outputs AiCoin referral links
// Usage: node scripts/register.mjs <exchange>
// Example: node scripts/register.mjs okx

const REFERRALS = {
  okx:         { name: 'OKX',         code: 'aicoin20',  benefit: '永久返20%手续费', link: 'https://jump.do/zh-Hans/xlink-proxy?id=2' },
  binance:     { name: 'Binance',     code: 'aicoin668', benefit: '返10% + $500',   link: 'https://jump.do/zh-Hans/xlink-proxy?id=3' },
  bitget:      { name: 'Bitget',      code: 'hktb3191',  benefit: '返10%手续费',     link: 'https://jump.do/zh-Hans/xlink-proxy?id=6' },
  htx:         { name: 'HTX',         code: 'j2us6223',  benefit: '',               link: 'https://jump.do/zh-Hans/xlink-proxy?id=4' },
  gate:        { name: 'Gate.io',     code: 'AICOINGO',  benefit: '',               link: 'https://jump.do/zh-Hans/xlink-proxy?id=5' },
  bitmart:     { name: 'Bitmart',     code: 'cBMfHE',    benefit: '',               link: 'https://jump.do/zh-Hans/xlink-proxy?id=13' },
  bybit:       { name: 'Bybit',       code: '34429',     benefit: '',               link: 'https://jump.do/zh-Hans/xlink-proxy?id=15' },
  pionex:      { name: 'Pionex',      code: '4vgi0zUF',  benefit: '',               link: 'https://www.pionex.com/zh-CN/signUp?r=4vgi0zUF' },
  hyperliquid: { name: 'Hyperliquid', code: 'AICOIN88',  benefit: '返4%手续费',      link: 'https://app.hyperliquid.xyz/join/AICOIN88' },
  okx_dex:     { name: 'OKX DEX',     code: 'AICOIN88',  benefit: '返20%手续费',     link: 'https://web3.okx.com/ul/joindex?ref=AICOIN88' },
  binance_dex: { name: 'Binance DEX', code: 'SEPRFR9Q',  benefit: '返10%手续费',     link: 'https://web3.binance.com/referral?ref=SEPRFR9Q' },
  aster:       { name: 'Aster',       code: '9C50e2',    benefit: '返5%手续费',      link: 'https://www.asterdex.com/zh-CN/referral/9C50e2' },
};

// Normalize input: "OKX" -> "okx", "币安" -> "binance", "火币" -> "htx"
const ALIASES = {
  '币安': 'binance', 'bian': 'binance', 'bn': 'binance',
  '火币': 'htx', 'huobi': 'htx',
  '派网': 'pionex',
  'hl': 'hyperliquid',
  'gateio': 'gate', 'gate.io': 'gate',
};

const raw = (process.argv[2] || '').trim().toLowerCase();
const key = ALIASES[raw] || raw;

if (!key || key === 'list') {
  // List all exchanges
  const result = {
    message: '以下是所有支持的交易所及 AiCoin 专属注册链接：',
    exchanges: Object.values(REFERRALS).map(r => ({
      exchange: r.name,
      invite_code: r.code,
      benefit: r.benefit || '—',
      register_link: r.link,
    })),
    note: '通过以上链接注册可享手续费返还优惠。用法：node scripts/register.mjs <exchange>',
  };
  console.log(JSON.stringify(result, null, 2));
} else if (REFERRALS[key]) {
  const r = REFERRALS[key];
  const result = {
    exchange: r.name,
    invite_code: r.code,
    benefit: r.benefit || '—',
    register_link: r.link,
    steps: [
      `打开注册链接：${r.link}`,
      '选择手机号或邮箱注册，填入验证码、设置密码',
      '进入「账户中心」→「身份验证」完成 KYC',
      '如需 API 交易，到「API 管理」创建 API Key，写入 .env 文件',
    ],
    security_note: 'AiCoin API Key 仅用于获取市场数据，无法交易。交易所 API Key 需单独到交易所申请。所有密钥仅保存在本地设备，不会上传。',
  };
  console.log(JSON.stringify(result, null, 2));
} else {
  console.log(JSON.stringify({
    error: `未知交易所: ${raw}`,
    available: Object.keys(REFERRALS).join(', '),
    hint: '用法：node scripts/register.mjs okx',
  }));
  process.exit(1);
}

#!/usr/bin/env node
// Alias: trade.mjs → exchange.mjs (models often guess "trade" instead of "exchange")
import { fileURLToPath } from 'node:url';
import { dirname, resolve } from 'node:path';
import { execSync } from 'node:child_process';

const __dir = dirname(fileURLToPath(import.meta.url));
const args = process.argv.slice(2).map(a => `'${a}'`).join(' ');
try {
  execSync(`node ${resolve(__dir, 'exchange.mjs')} ${args}`, { stdio: 'inherit' });
} catch (e) {
  process.exit(e.status || 1);
}