@aicoin/trade-mcp 1.0.5

package/.env.example

@@ -0,0 +1,41 @@
+# AiCoin Trade MCP Configuration
+# Copy this file to .env and fill in your values
+
+# Default exchange
+DEFAULT_EXCHANGE=binance
+
+# Supported: binance, binanceusdm, binancecoinm,
+#            okx, bybit, bitget, gate,
+#            huobi, pionex, hyperliquid
+
+# --- Exchange API Keys ---
+
+# BINANCE_API_KEY=your_api_key
+# BINANCE_SECRET=your_secret
+
+# OKX_API_KEY=your_api_key
+# OKX_SECRET=your_secret
+# OKX_PASSPHRASE=your_passphrase
+
+# BYBIT_API_KEY=your_api_key
+# BYBIT_SECRET=your_secret
+
+# BITGET_API_KEY=your_api_key
+# BITGET_SECRET=your_secret
+# BITGET_PASSPHRASE=your_passphrase
+
+# GATE_API_KEY=your_api_key
+# GATE_SECRET=your_secret
+
+# HUOBI_API_KEY=your_api_key
+# HUOBI_SECRET=your_secret
+
+# PIONEX_API_KEY=your_api_key
+# PIONEX_SECRET=your_secret
+
+# HYPERLIQUID_API_KEY=your_api_key
+# HYPERLIQUID_SECRET=your_secret
+
+# --- Proxy (optional) ---
+# USE_PROXY=false
+# PROXY_URL=http://127.0.0.1:7890

package/README.md

@@ -0,0 +1,154 @@
+# AiCoin Trade MCP Server
+
+AI-powered cryptocurrency trading via ccxt.
+
+## Features
+
+- 24 trading tools (9 public + 15 private)
+- 9 supported exchanges
+- Exchange API keys stored locally via env vars (never sent to cloud)
+- stdio transport for local MCP clients
+
+## Quick Start
+
+```bash
+npm install
+cp .env.example .env
+# Edit .env with your exchange API keys
+npm run build
+npm start
+```
+
+## Environment Variables
+
+```bash
+DEFAULT_EXCHANGE=binance
+
+BINANCE_API_KEY=your_key
+BINANCE_SECRET=your_secret
+
+OKX_API_KEY=your_key
+OKX_SECRET=your_secret
+OKX_PASSPHRASE=your_passphrase
+
+BYBIT_API_KEY=your_key
+BYBIT_SECRET=your_secret
+
+USE_PROXY=false
+PROXY_URL=http://127.0.0.1:7890
+```
+
+## Available Tools
+
+### Public (no API key required)
+
+| Tool | Description |
+|------|-------------|
+| `list_exchanges` | List all 9 supported exchanges |
+| `get_ticker` | Real-time ticker for a trading pair |
+| `get_tickers` | Batch tickers for multiple pairs |
+| `get_ohlcv` | K-line/candlestick data |
+| `get_orderbook` | Order book depth |
+| `get_trades` | Recent trades |
+| `get_markets` | All trading pairs on an exchange |
+| `get_funding_rates` | Perpetual contract funding rates |
+| `get_funding_rate_history` | Historical funding rates |
+
+### Private (requires exchange API key)
+
+| Tool | Description |
+|------|-------------|
+| `get_balance` | Account balance |
+| `create_order` | Place market/limit order |
+| `cancel_order` | Cancel an open order |
+| `cancel_all_orders` | Cancel all open orders for a symbol |
+| `get_order` | Get order details by ID |
+| `get_open_orders` | List unfilled orders |
+| `get_closed_orders` | List filled/cancelled orders |
+| `get_my_trades` | Get personal trade history |
+| `get_positions` | Open positions (futures/swap) |
+| `set_leverage` | Set leverage multiplier |
+| `set_margin_mode` | Set cross/isolated margin |
+| `get_ledger` | Account ledger entries |
+| `get_deposits` | Deposit history |
+| `get_withdrawals` | Withdrawal history |
+| `transfer` | Transfer between accounts |
+
+## Client Configuration
+
+### Claude Desktop
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "aicoin-trade": {
+      "command": "npx",
+      "args": ["-y", "@aicoin/trade-mcp"],
+      "env": {
+        "DEFAULT_EXCHANGE": "okx",
+        "OKX_API_KEY": "your_key",
+        "OKX_SECRET": "your_secret",
+        "OKX_PASSPHRASE": "your_passphrase"
+      }
+    }
+  }
+}
+```
+
+### Cursor
+
+Add to `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "aicoin-trade": {
+      "command": "npx",
+      "args": ["-y", "@aicoin/trade-mcp"],
+      "env": {
+        "DEFAULT_EXCHANGE": "binance",
+        "BINANCE_API_KEY": "your_key",
+        "BINANCE_SECRET": "your_secret"
+      }
+    }
+  }
+}
+```
+
+### Windsurf
+
+Add to `~/.codeium/windsurf/mcp_config.json` (same format as Cursor).
+
+### VS Code (Copilot)
+
+Add to `.vscode/mcp.json`:
+
+```json
+{
+  "servers": {
+    "aicoin-trade": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@aicoin/trade-mcp"],
+      "env": {
+        "DEFAULT_EXCHANGE": "okx",
+        "OKX_API_KEY": "your_key",
+        "OKX_SECRET": "your_secret",
+        "OKX_PASSPHRASE": "your_passphrase"
+      }
+    }
+  }
+}
+```
+
+### Claude Code
+
+```bash
+claude mcp add aicoin-trade -- npx -y @aicoin/trade-mcp
+```
+
+## Supported Exchanges
+
+binance, binanceusdm, binancecoinm, okx, bybit, bitget, gate, huobi, hyperliquid

package/build/index.js

@@ -0,0 +1,721 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/tools/public.ts
+import { z } from "zod";
+
+// src/exchange/manager.ts
+import * as ccxt from "ccxt";
+
+// src/exchange/broker.ts
+var BROKER_CONFIG = {
+  binance: {
+    options: {
+      broker: {
+        spot: "x-MGFCMH4U",
+        future: "x-FaeSBrMa",
+        delivery: "x-FaeSBrMa"
+      }
+    },
+    headers: {}
+  },
+  binanceusdm: {
+    options: {
+      broker: { future: "x-FaeSBrMa" }
+    },
+    headers: {}
+  },
+  binancecoinm: {
+    options: {
+      broker: { delivery: "x-FaeSBrMa" }
+    },
+    headers: {}
+  },
+  okx: {
+    options: { brokerId: "c6851dd5f01e4aBC" },
+    headers: {}
+  },
+  bybit: {
+    options: {},
+    headers: { Referer: "AiCoin" }
+  },
+  bitget: {
+    options: {},
+    headers: { "X-CHANNEL-API-CODE": "tpequ" }
+  },
+  gate: {
+    options: {},
+    headers: { "X-Gate-Channel-Id": "AiCoin1" }
+  },
+  huobi: {
+    options: {
+      broker: { id: "AAf0e4f2ef" }
+    },
+    headers: {}
+  },
+  pionex: {
+    options: { brokerId: "AiCoin2023" },
+    headers: {}
+  },
+  hyperliquid: {
+    options: {
+      broker: {
+        address: "0xc7580C3eFaeae84865B7Cd1ee11d9f3069F36E82"
+      }
+    },
+    headers: {}
+  }
+};
+function getBrokerOptions(exchangeId) {
+  const id = exchangeId.toLowerCase();
+  return BROKER_CONFIG[id] ?? { options: {}, headers: {} };
+}
+
+// src/exchange/manager.ts
+var SUPPORTED_EXCHANGES = [
+  "binance",
+  "binanceusdm",
+  "binancecoinm",
+  "okx",
+  "bybit",
+  "bitget",
+  "gate",
+  "huobi",
+  "hyperliquid"
+];
+var cache = {};
+function buildOptions(config) {
+  const { exchangeId, marketType, apiKey, secret, passphrase, skipAuth } = config;
+  const id = exchangeId.toLowerCase();
+  const key = skipAuth ? void 0 : apiKey || process.env[`${id.toUpperCase()}_API_KEY`];
+  const sec = skipAuth ? void 0 : secret || process.env[`${id.toUpperCase()}_SECRET`];
+  const pass = skipAuth ? void 0 : passphrase || process.env[`${id.toUpperCase()}_PASSPHRASE`];
+  const broker = getBrokerOptions(id);
+  const opts = {
+    enableRateLimit: true,
+    options: {
+      ...broker.options,
+      ...marketType && marketType !== "spot" ? { defaultType: marketType } : {}
+    }
+  };
+  if (Object.keys(broker.headers).length > 0) {
+    opts.headers = broker.headers;
+  }
+  if (key) opts.apiKey = key;
+  if (sec) opts.secret = sec;
+  if (pass) opts.password = pass;
+  const proxyUrl = process.env.PROXY_URL;
+  if (process.env.USE_PROXY === "true" && 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 if (proxyUrl.startsWith("http://")) {
+      opts.httpProxy = proxyUrl;
+    }
+  }
+  return opts;
+}
+function createInstance(id, opts) {
+  const ExchangeClass = ccxt[id];
+  if (typeof ExchangeClass !== "function") {
+    throw new Error(`Exchange '${id}' is not available in ccxt`);
+  }
+  return new ExchangeClass(opts);
+}
+function getExchange(exchangeId, marketType, options) {
+  const id = (exchangeId || process.env.DEFAULT_EXCHANGE || "binance").toLowerCase();
+  const type = marketType || "spot";
+  const skipAuth = options?.skipAuth ?? false;
+  const key = `${id}:${type}${skipAuth ? ":pub" : ""}`;
+  if (!cache[key]) {
+    if (!SUPPORTED_EXCHANGES.includes(id)) {
+      throw new Error(
+        `Exchange '${id}' not supported. Available: ${SUPPORTED_EXCHANGES.join(", ")}`
+      );
+    }
+    cache[key] = createInstance(id, buildOptions({ exchangeId: id, marketType: type, skipAuth }));
+  }
+  return cache[key];
+}
+
+// src/tools/utils.ts
+function ok(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data) }]
+  };
+}
+function err(e) {
+  const message = e instanceof Error ? e.message : typeof e === "string" ? e : String(e);
+  return {
+    content: [{ type: "text", text: `Error: ${message}` }],
+    isError: true
+  };
+}
+function okList(data, max = 200) {
+  const truncated = data.length > max;
+  const items = truncated ? data.slice(0, max) : data;
+  return ok({
+    total: data.length,
+    returned: items.length,
+    truncated,
+    data: items
+  });
+}
+
+// src/tools/public.ts
+var marketTypeSchema = z.enum(["spot", "future", "swap"]).optional().describe("Market type, default spot");
+function registerPublicTools(server2) {
+  server2.tool(
+    "list_exchanges",
+    "List all supported cryptocurrency exchanges",
+    {},
+    async () => ok(SUPPORTED_EXCHANGES)
+  );
+  server2.tool(
+    "get_ticker",
+    "Get real-time ticker for a trading pair",
+    {
+      exchange: z.string().describe("Exchange ID, e.g. binance, okx, bybit"),
+      symbol: z.string().describe("Trading pair, e.g. BTC/USDT"),
+      market_type: marketTypeSchema
+    },
+    async ({ exchange, symbol, market_type }) => {
+      try {
+        const ex = getExchange(exchange, market_type, { skipAuth: true });
+        const ticker = await ex.fetchTicker(symbol);
+        return ok(ticker);
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_orderbook",
+    "Get order book depth for a trading pair",
+    {
+      exchange: z.string().describe("Exchange ID"),
+      symbol: z.string().describe("Trading pair, e.g. BTC/USDT"),
+      limit: z.number().min(1).optional().default(20).describe("Depth limit"),
+      market_type: marketTypeSchema
+    },
+    async ({ exchange, symbol, limit, market_type }) => {
+      try {
+        const ex = getExchange(exchange, market_type, { skipAuth: true });
+        const book = await ex.fetchOrderBook(symbol, limit);
+        return ok(book);
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_trades",
+    "Get recent trades for a trading pair",
+    {
+      exchange: z.string().describe("Exchange ID"),
+      symbol: z.string().describe("Trading pair, e.g. BTC/USDT"),
+      limit: z.number().optional().default(50).describe("Number of trades"),
+      market_type: marketTypeSchema
+    },
+    async ({ exchange, symbol, limit, market_type }) => {
+      try {
+        const ex = getExchange(exchange, market_type, { skipAuth: true });
+        const trades = await ex.fetchTrades(symbol, void 0, limit);
+        return ok(trades);
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_markets",
+    "Get available trading pairs on an exchange (filtered, paginated)",
+    {
+      exchange: z.string().describe("Exchange ID"),
+      market_type: marketTypeSchema.describe("Filter by market type"),
+      base: z.string().optional().describe("Filter by base currency, e.g. BTC"),
+      quote: z.string().optional().describe("Filter by quote currency, e.g. USDT"),
+      limit: z.number().int().min(1).max(500).optional().default(100).describe("Max results (1-500, default 100)")
+    },
+    async ({ exchange, market_type, base, quote, limit }) => {
+      try {
+        const ex = getExchange(exchange, market_type, { skipAuth: true });
+        await ex.loadMarkets();
+        let markets = Object.values(ex.markets).map((m) => ({
+          symbol: m.symbol,
+          base: m.base,
+          quote: m.quote,
+          type: m.type,
+          active: m.active
+        }));
+        if (market_type) markets = markets.filter((m) => m.type === market_type);
+        if (base) markets = markets.filter((m) => m.base === base.toUpperCase());
+        if (quote) markets = markets.filter((m) => m.quote === quote.toUpperCase());
+        return okList(markets.slice(0, limit), limit);
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_funding_rates",
+    "Get current funding rates for perpetual contracts",
+    {
+      exchange: z.string().describe("Exchange ID"),
+      symbols: z.array(z.string()).min(1).describe('Trading pairs to query, e.g. ["BTC/USDT:USDT"]')
+    },
+    async ({ exchange, symbols }) => {
+      try {
+        const ex = getExchange(exchange, "swap", { skipAuth: true });
+        const rates = await ex.fetchFundingRates(symbols);
+        return ok(rates);
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_tickers",
+    "Get tickers for multiple trading pairs at once",
+    {
+      exchange: z.string().describe("Exchange ID"),
+      symbols: z.array(z.string()).optional().describe('Trading pairs, e.g. ["BTC/USDT","ETH/USDT"]'),
+      market_type: marketTypeSchema
+    },
+    async ({ exchange, symbols, market_type }) => {
+      try {
+        const ex = getExchange(exchange, market_type, { skipAuth: true });
+        const syms = symbols && symbols.length > 0 ? symbols : void 0;
+        const tickers = await ex.fetchTickers(syms);
+        return okList(Object.values(tickers));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_funding_rate_history",
+    "Get historical funding rates for a perpetual contract",
+    {
+      exchange: z.string().describe("Exchange ID"),
+      symbol: z.string().describe("Trading pair, e.g. BTC/USDT:USDT"),
+      limit: z.number().optional().default(100).describe("Number of records")
+    },
+    async ({ exchange, symbol, limit }) => {
+      try {
+        const ex = getExchange(exchange, "swap", { skipAuth: true });
+        const history = await ex.fetchFundingRateHistory(
+          symbol,
+          void 0,
+          limit
+        );
+        return ok(history);
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_ohlcv",
+    "Get OHLCV candlestick (K-line) data for a trading pair",
+    {
+      exchange: z.string().describe("Exchange ID"),
+      symbol: z.string().describe("Trading pair, e.g. BTC/USDT"),
+      timeframe: z.string().optional().default("1d").describe("Timeframe: 1m, 5m, 15m, 1h, 4h, 1d, 1w"),
+      limit: z.number().optional().default(100).describe("Number of candles, max 1000"),
+      market_type: marketTypeSchema
+    },
+    async ({ exchange, symbol, timeframe, limit, market_type }) => {
+      try {
+        const ex = getExchange(exchange, market_type, { skipAuth: true });
+        const data = await ex.fetchOHLCV(
+          symbol,
+          timeframe,
+          void 0,
+          Math.min(limit, 1e3)
+        );
+        return ok(data);
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+}
+
+// src/tools/private.ts
+import { z as z2 } from "zod";
+var marketTypeSchema2 = z2.enum(["spot", "future", "swap", "margin"]).optional().describe("Market type, default spot");
+function registerPrivateTools(server2) {
+  server2.tool(
+    "get_balance",
+    "Get account balance from exchange",
+    {
+      exchange: z2.string().describe("Exchange ID"),
+      market_type: marketTypeSchema2
+    },
+    async ({ exchange, market_type }) => {
+      try {
+        const ex = getExchange(exchange, market_type);
+        const bal = await ex.fetchBalance();
+        return ok({
+          total: bal.total,
+          free: bal.free,
+          used: bal.used
+        });
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "create_order",
+    "Place a new order (market or limit)",
+    {
+      exchange: z2.string().describe("Exchange ID"),
+      symbol: z2.string().describe("Trading pair, e.g. BTC/USDT"),
+      type: z2.enum(["market", "limit"]).describe("Order type"),
+      side: z2.enum(["buy", "sell"]).describe("Order side"),
+      amount: z2.number().positive().describe("Order amount"),
+      price: z2.number().positive().optional().describe("Limit price (required for limit orders)"),
+      pos_side: z2.enum(["long", "short"]).optional().describe("Position side for hedge mode (okx): long/short"),
+      margin_mode: z2.enum(["cross", "isolated"]).optional().describe("Margin mode for derivatives (okx): cross/isolated"),
+      market_type: marketTypeSchema2
+    },
+    async ({
+      exchange,
+      symbol,
+      type,
+      side,
+      amount,
+      price,
+      pos_side,
+      margin_mode,
+      market_type
+    }) => {
+      try {
+        if (type === "limit" && price == null) {
+          return err("price is required for limit orders");
+        }
+        const ex = getExchange(exchange, market_type);
+        const params = {};
+        if (pos_side) params.posSide = pos_side;
+        if (margin_mode) params.tdMode = margin_mode;
+        const order = await ex.createOrder(
+          symbol,
+          type,
+          side,
+          amount,
+          price,
+          params
+        );
+        return ok(order);
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "cancel_order",
+    "Cancel an open order",
+    {
+      exchange: z2.string().describe("Exchange ID"),
+      order_id: z2.string().describe("Order ID to cancel"),
+      symbol: z2.string().describe("Trading pair, e.g. BTC/USDT"),
+      market_type: marketTypeSchema2
+    },
+    async ({ exchange, order_id, symbol, market_type }) => {
+      try {
+        const ex = getExchange(exchange, market_type);
+        return ok(await ex.cancelOrder(order_id, symbol));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_open_orders",
+    "Get all open (unfilled) orders",
+    {
+      exchange: z2.string().describe("Exchange ID"),
+      symbol: z2.string().optional().describe("Trading pair filter, e.g. BTC/USDT"),
+      market_type: marketTypeSchema2
+    },
+    async ({ exchange, symbol, market_type }) => {
+      try {
+        const ex = getExchange(exchange, market_type);
+        return ok(await ex.fetchOpenOrders(symbol));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_closed_orders",
+    "Get closed (filled/cancelled) orders",
+    {
+      exchange: z2.string().describe("Exchange ID"),
+      symbol: z2.string().optional().describe("Trading pair filter"),
+      limit: z2.number().optional().default(20).describe("Number of orders to return"),
+      market_type: marketTypeSchema2
+    },
+    async ({ exchange, symbol, limit, market_type }) => {
+      try {
+        const ex = getExchange(exchange, market_type);
+        return ok(
+          await ex.fetchClosedOrders(symbol, void 0, limit)
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_positions",
+    "Get open positions (futures/swap only)",
+    {
+      exchange: z2.string().describe("Exchange ID"),
+      symbols: z2.array(z2.string()).optional().describe('Filter by symbols, e.g. ["BTC/USDT:USDT"]'),
+      market_type: z2.enum(["swap", "future"]).optional().default("swap").describe("Market type: swap (default) or future")
+    },
+    async ({ exchange, symbols, market_type }) => {
+      try {
+        const ex = getExchange(exchange, market_type);
+        return ok(await ex.fetchPositions(symbols));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_order",
+    "Get a single order by ID",
+    {
+      exchange: z2.string().describe("Exchange ID"),
+      order_id: z2.string().describe("Order ID"),
+      symbol: z2.string().describe("Trading pair, e.g. BTC/USDT"),
+      market_type: marketTypeSchema2
+    },
+    async ({ exchange, order_id, symbol, market_type }) => {
+      try {
+        const ex = getExchange(exchange, market_type);
+        return ok(await ex.fetchOrder(order_id, symbol));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_my_trades",
+    "Get your trade history (filled executions)",
+    {
+      exchange: z2.string().describe("Exchange ID"),
+      symbol: z2.string().optional().describe("Trading pair filter"),
+      limit: z2.number().optional().default(50).describe("Number of trades to return"),
+      market_type: marketTypeSchema2
+    },
+    async ({ exchange, symbol, limit, market_type }) => {
+      try {
+        const ex = getExchange(exchange, market_type);
+        return ok(
+          await ex.fetchMyTrades(symbol, void 0, limit)
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "cancel_all_orders",
+    "Cancel all open orders for a symbol",
+    {
+      exchange: z2.string().describe("Exchange ID"),
+      symbol: z2.string().describe("Trading pair, e.g. BTC/USDT"),
+      market_type: marketTypeSchema2
+    },
+    async ({ exchange, symbol, market_type }) => {
+      try {
+        const ex = getExchange(exchange, market_type);
+        if (ex.has["cancelAllOrders"]) {
+          return ok(await ex.cancelAllOrders(symbol));
+        }
+        const open = await ex.fetchOpenOrders(symbol);
+        const results = await Promise.allSettled(
+          open.map((o) => ex.cancelOrder(o.id, symbol))
+        );
+        const cancelled = results.filter((r) => r.status === "fulfilled").length;
+        const failed = results.filter((r) => r.status === "rejected").length;
+        return ok({ cancelled, failed, total: open.length });
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "set_leverage",
+    "Set leverage for a trading pair (futures/swap)",
+    {
+      exchange: z2.string().describe("Exchange ID"),
+      leverage: z2.number().int().positive().describe("Leverage multiplier, e.g. 10"),
+      symbol: z2.string().describe("Trading pair, e.g. BTC/USDT:USDT"),
+      market_type: marketTypeSchema2
+    },
+    async ({ exchange, leverage, symbol, market_type }) => {
+      try {
+        const ex = getExchange(
+          exchange,
+          market_type || "swap"
+        );
+        return ok(await ex.setLeverage(leverage, symbol));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "set_margin_mode",
+    "Set margin mode (cross or isolated) for futures/swap",
+    {
+      exchange: z2.string().describe("Exchange ID"),
+      margin_mode: z2.enum(["cross", "isolated"]).describe("Margin mode"),
+      symbol: z2.string().describe("Trading pair, e.g. BTC/USDT:USDT"),
+      leverage: z2.number().int().positive().optional().describe("Leverage to set alongside margin mode. If omitted, auto-reads current leverage from the exchange"),
+      market_type: z2.enum(["swap", "future"]).optional().default("swap").describe("Market type: swap (default) or future")
+    },
+    async ({ exchange, margin_mode, symbol, leverage, market_type }) => {
+      try {
+        const ex = getExchange(exchange, market_type);
+        let lever = leverage;
+        if (lever == null) {
+          const info = await ex.fetchLeverage(symbol, { marginMode: margin_mode });
+          lever = info?.longLeverage ?? info?.shortLeverage;
+        }
+        const params = {};
+        if (lever != null) params.lever = String(lever);
+        return ok(
+          await ex.setMarginMode(margin_mode, symbol, params)
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_ledger",
+    "Get account ledger / transaction history",
+    {
+      exchange: z2.string().describe("Exchange ID"),
+      code: z2.string().optional().describe("Currency code filter, e.g. USDT"),
+      limit: z2.number().optional().default(20).describe("Number of entries"),
+      market_type: marketTypeSchema2
+    },
+    async ({ exchange, code, limit, market_type }) => {
+      try {
+        const ex = getExchange(exchange, market_type);
+        return ok(
+          await ex.fetchLedger(code, void 0, limit)
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_deposits",
+    "Get deposit history",
+    {
+      exchange: z2.string().describe("Exchange ID"),
+      code: z2.string().optional().describe("Currency code filter, e.g. USDT"),
+      limit: z2.number().optional().default(20).describe("Number of records"),
+      market_type: marketTypeSchema2
+    },
+    async ({ exchange, code, limit, market_type }) => {
+      try {
+        const ex = getExchange(exchange, market_type);
+        return ok(
+          await ex.fetchDeposits(code, void 0, limit)
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_withdrawals",
+    "Get withdrawal history",
+    {
+      exchange: z2.string().describe("Exchange ID"),
+      code: z2.string().optional().describe("Currency code filter, e.g. USDT"),
+      limit: z2.number().optional().default(20).describe("Number of records"),
+      market_type: marketTypeSchema2
+    },
+    async ({ exchange, code, limit, market_type }) => {
+      try {
+        const ex = getExchange(exchange, market_type);
+        return ok(
+          await ex.fetchWithdrawals(code, void 0, limit)
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "transfer",
+    "Transfer funds between accounts (e.g. spot to futures)",
+    {
+      exchange: z2.string().describe("Exchange ID"),
+      code: z2.string().describe("Currency code, e.g. USDT"),
+      amount: z2.number().positive().describe("Amount"),
+      from_account: z2.string().describe("Source account: spot, swap, future"),
+      to_account: z2.string().describe("Target account: spot, swap, future"),
+      market_type: marketTypeSchema2
+    },
+    async ({
+      exchange,
+      code,
+      amount,
+      from_account,
+      to_account,
+      market_type
+    }) => {
+      try {
+        const ex = getExchange(exchange, market_type);
+        return ok(
+          await ex.transfer(
+            code,
+            amount,
+            from_account,
+            to_account
+          )
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+}
+
+// src/tools/index.ts
+function registerAllTools(server2) {
+  registerPublicTools(server2);
+  registerPrivateTools(server2);
+}
+
+// src/index.ts
+var server = new McpServer({
+  name: "aicoin-trade",
+  version: "1.0.3"
+});
+registerAllTools(server);
+var transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@aicoin/trade-mcp",
+  "version": "1.0.5",
+  "description": "AiCoin Trade MCP Server - AI-powered cryptocurrency trading via ccxt",
+  "main": "build/index.js",
+  "type": "module",
+  "bin": {
+    "aicoin-trade-mcp": "./build/index.js"
+  },
+  "files": [
+    "build",
+    "README.md",
+    ".env.example"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --outDir build --clean",
+    "start": "node build/index.js",
+    "dev": "tsup src/index.ts --format esm --outDir build --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.8.0",
+    "ccxt": "^4.4.71",
+    "socks-proxy-agent": "^8.0.5",
+    "zod": "^3.22.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.6.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.2.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "mcp",
+    "aicoin",
+    "crypto",
+    "trading",
+    "ccxt"
+  ],
+  "license": "MIT"
+}