Aicoin Account

#!/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-account",
  "version": "1.1.4",
  "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
/**
 * check-tier.mjs — Check current AiCoin API key tier and guide upgrade
 *
 * Usage:
 *   node scripts/check-tier.mjs              # Check current tier
 *   node scripts/check-tier.mjs verify       # Verify after upgrade
 */
import { apiGet } from '../lib/aicoin-api.mjs';

// vip_type → Chinese tier name mapping
const VIP_TYPE_MAP = {
  basic: '基础版',
  normal: '标准版',
  premium: '高级版',
  professional: '专业版',
};

const TIER_ORDER = ['免费版', '基础版', '标准版', '高级版', '专业版'];

const TIER_PRICES = {
  '免费版': '$0',
  '基础版': '$29/月',
  '标准版': '$79/月',
  '高级版': '$299/月',
  '专业版': '$699/月',
};

const TIER_FEATURES = {
  '基础版': '资金费率、多空比、新闻',
  '标准版': '大单数据、聚合成交、信号',
  '高级版': '清算地图、指标K线',
  '专业版': '全部功能：AI分析、OI、美股',
};

const TIER_TESTS = [
  { tier: '免费版',   endpoint: '/api/v2/coin/ticker', params: { coin_list: 'bitcoin' }, label: '行情数据' },
  { tier: '基础版',   endpoint: '/api/v2/mix/ls-ratio', params: {}, label: '多空比' },
  { tier: '标准版',   endpoint: '/api/v2/order/bigOrder', params: { symbol: 'btcswapusdt:binance' }, label: '大单数据' },
  { tier: '高级版',   endpoint: '/api/upgrade/v2/futures/liquidation/map', params: { dbkey: 'btcswapusdt:binance', cycle: '24h' }, label: '清算地图' },
  { tier: '专业版',   endpoint: '/api/upgrade/v2/futures/trade-data', params: { dbkey: 'btcswapusdt:binance' }, label: 'OI持仓量' },
];

async function getKeyInfo() {
  try {
    const data = await apiGet('/api/v2/api-key-info');
    if (data.success !== false && data.data) {
      return data.data;
    }
  } catch {}
  return null;
}

async function checkTier() {
  // Step 1: Try to get tier from api-key-info (fast & accurate)
  const keyInfo = await getKeyInfo();
  let currentTier = '免费版';
  let endTime = null;

  if (keyInfo) {
    const vipType = keyInfo.vip_type;
    if (vipType && VIP_TYPE_MAP[vipType]) {
      currentTier = VIP_TYPE_MAP[vipType];
    }
    if (keyInfo.end_time) {
      // Convert timestamp or date string to human-readable
      const ts = typeof keyInfo.end_time === 'number' ? keyInfo.end_time * 1000 : new Date(keyInfo.end_time).getTime();
      if (!isNaN(ts)) {
        endTime = new Date(ts).toISOString().split('T')[0];
      }
    }
  }

  // Step 2: Endpoint tests as verification
  const results = [];
  for (const test of TIER_TESTS) {
    try {
      const data = await apiGet(test.endpoint, test.params);
      if (data.success === false && (data.errorCode === 304 || data.errorCode === 403)) {
        results.push({ 套餐: test.tier, 功能: test.label, 状态: '❌ 需升级' });
      } else {
        results.push({ 套餐: test.tier, 功能: test.label, 状态: '✅ 可用' });
      }
    } catch (e) {
      const msg = e.message || '';
      if (msg.includes('403') || msg.includes('304')) {
        results.push({ 套餐: test.tier, 功能: test.label, 状态: '❌ 需升级' });
      } else {
        results.push({ 套餐: test.tier, 功能: test.label, 状态: '⚠️ 网络错误' });
      }
    }
  }

  // Fallback: if api-key-info didn't return a tier, infer from endpoint tests
  // Only break on actual permission errors (❌ 需升级), skip network errors
  if (!keyInfo || !keyInfo.vip_type) {
    let inferred = '免费版';
    for (const test of TIER_TESTS) {
      const r = results.find(r => r.套餐 === test.tier);
      if (r && r.状态 === '✅ 可用') {
        inferred = test.tier;
      } else if (r && r.状态 === '❌ 需升级') {
        break; // actual permission denial — stop here
      }
      // ⚠️ 网络错误 — skip and continue checking higher tiers
    }
    currentTier = inferred;
  }

  // Build output
  const tierIndex = TIER_ORDER.indexOf(currentTier);
  const nextTier = tierIndex < TIER_ORDER.length - 1 ? TIER_ORDER[tierIndex + 1] : null;

  const output = {
    当前套餐: currentTier,
    ...(endTime ? { 到期时间: endTime } : {}),
    功能检测: results,
  };

  if (nextTier) {
    output.升级建议 = {
      下一级: `${nextTier} (${TIER_PRICES[nextTier]})`,
      新增功能: TIER_FEATURES[nextTier],
      升级链接: 'https://www.aicoin.com/opendata',
      操作步骤: [
        '1. 打开 https://www.aicoin.com/opendata',
        '2. 登录账号，选择目标套餐并付款',
        '3. 到「API管理」页面查看 Key（升级后原Key自动生效，无需更换）',
        '4. 如果是新Key，更新 .env 中的 AICOIN_ACCESS_KEY_ID 和 AICOIN_ACCESS_SECRET',
        '5. 运行 node scripts/check-tier.mjs verify 验证升级成功'
      ]
    };
  } else {
    output.状态 = '🎉 已是最高套餐专业版，所有功能可用！';
  }

  output.安全提示 = 'AiCoin API Key 仅用于获取市场数据，无法交易。密钥仅保存在本地。';

  return output;
}

const action = process.argv[2] || 'check';
const result = await checkTier();

if (action === 'verify') {
  result.验证模式 = true;
  result.说明 = '升级后请确认上方功能检测中对应功能显示 ✅';
}

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

#!/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);
}

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, 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 orderParams = { ...(params || {}) };
        if (exchange === 'okx' && market_type && market_type !== 'spot' && !orderParams.posSide) {
          if (orderParams.reduceOnly) {
            orderParams.posSide = side === 'buy' ? 'short' : 'long';
          } else {
            orderParams.posSide = side === 'buy' ? 'long' : 'short';
          }
        }
        const order = await ex.createOrder(symbol, type, side, amount, price, orderParams);
        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分钟），请重新创建订单预览。');
      }

      try { unlinkSync(pendingFile); } catch {}

      // Execute with stored params (prevents model from tampering between preview and confirm)
      const ex = await getExchange(pending.exchange, pending.market_type);
      const orderParams = { ...(pending.params || {}) };
      if (pending.exchange === 'okx' && pending.market_type && pending.market_type !== 'spot' && !orderParams.posSide) {
        if (orderParams.reduceOnly) {
          orderParams.posSide = pending.side === 'buy' ? 'short' : 'long';
        } else {
          orderParams.posSide = pending.side === 'buy' ? 'long' : 'short';
        }
      }
      const order = await ex.createOrder(pending.symbol, pending.type, pending.side, pending.amount, pending.price, orderParams);
      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];
    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') {
      try {
        const positions = await ex.fetchPositions([symbol]);
        const pos = positions.find(p => p.symbol === symbol);
        if (pos) {
          if (pos.leverage) orderInfo['杠杆'] = `${pos.leverage}x`;
          if (pos.marginMode || pos.marginType) orderInfo['保证金模式'] = pos.marginMode || pos.marginType;
          if (curPrice && pos.leverage) {
            const lev = Number(pos.leverage);
            const notional = mkt?.contractSize ? amount * mkt.contractSize * curPrice : amount * curPrice;
            orderInfo['预估保证金'] = `${(notional / lev).toFixed(2)} USDT`;
          }
        }
      } catch {}
    }

    return {
      _preview: true,
      status: '⚠️ 订单未下达',
      风险提示: '⚠️ 交易风险声明：加密货币交易具有高风险，可能导致本金全部损失。合约使用杠杆会放大收益和亏损。本工具仅提供交易执行功能，不构成投资建议。继续下单即表示你已知悉并接受以上风险。',
      用户须知: '下单前请确认：(1) 你已了解该交易的风险 (2) 投入的资金在可承受范围内 (3) 你已设置合适的止损',
      订单详情: orderInfo,
      操作指引: '请确认以上订单信息无误。回复「确认」或「yes」执行下单，回复「取消」放弃。',
    };
  },
  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);
}