omnitrade-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Connectry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,240 @@
+# OmniTrade MCP
+
+> **One AI. 107 Exchanges. Natural language trading.**
+
+Connect Claude to Binance, Coinbase, Kraken, and 104 more cryptocurrency exchanges through the Model Context Protocol (MCP).
+
+[![npm version](https://img.shields.io/npm/v/omnitrade-mcp)](https://www.npmjs.com/package/omnitrade-mcp)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- 🔗 **107 Exchanges** — Connect to any exchange supported by CCXT
+- 🤖 **Natural Language** — Ask Claude to trade in plain English
+- 🔒 **Local-Only** — API keys never leave your machine
+- ⚡ **Arbitrage Detection** — Find price differences across exchanges
+- 📊 **Unified Portfolio** — See all holdings in one view
+- 🛡️ **Safety First** — Order limits, pair whitelists, testnet mode
+
+## Quick Start
+
+### 1. Install
+
+```bash
+npm install -g omnitrade-mcp
+```
+
+### 2. Configure
+
+Create `~/.omnitrade/config.json`:
+
+```json
+{
+  "exchanges": {
+    "binance": {
+      "apiKey": "YOUR_API_KEY",
+      "secret": "YOUR_SECRET",
+      "testnet": true
+    },
+    "coinbase": {
+      "apiKey": "YOUR_API_KEY",
+      "secret": "YOUR_SECRET",
+      "password": "YOUR_PASSPHRASE",
+      "testnet": true
+    }
+  },
+  "security": {
+    "maxOrderSize": 100,
+    "confirmTrades": true
+  }
+}
+```
+
+Set proper permissions:
+
+```bash
+chmod 600 ~/.omnitrade/config.json
+```
+
+### 3. Add to Claude Desktop
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "omnitrade": {
+      "command": "omnitrade-mcp"
+    }
+  }
+}
+```
+
+### 4. Trade
+
+Restart Claude Desktop and start chatting:
+
+- *"What's my balance on Binance?"*
+- *"Show me ETH prices across all exchanges"*
+- *"Buy $50 of BTC on the cheapest exchange"*
+- *"Are there any arbitrage opportunities for SOL?"*
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `get_balances` | Get portfolio balances across exchanges |
+| `get_portfolio` | Unified portfolio summary |
+| `get_prices` | Current prices for a trading pair |
+| `compare_prices` | Find best price across exchanges |
+| `place_order` | Execute buy/sell orders |
+| `get_orders` | View open and recent orders |
+| `cancel_order` | Cancel an open order |
+| `get_arbitrage` | Find arbitrage opportunities |
+| `check_spread` | Check spread for a specific pair |
+
+## Supported Exchanges
+
+OmniTrade supports **107 exchanges** through [CCXT](https://github.com/ccxt/ccxt), including:
+
+**Tier 1 (Certified):** Binance, Bybit, OKX, Gate.io, KuCoin, Bitget, HTX, Crypto.com, MEXC, WOO X, Hyperliquid
+
+**Tier 2:** Coinbase, Kraken, Bitstamp, Gemini, Bitfinex, Poloniex, Deribit, Upbit, Bithumb, Bitvavo, and 80+ more
+
+## Security
+
+### Local-Only Architecture
+
+```
+┌─────────────────────────────────────┐
+│       YOUR MACHINE                  │
+│                                     │
+│  Claude ←→ OmniTrade MCP           │
+│              ↓                      │
+│         config.json (your keys)    │
+│              ↓                      │
+│         Exchange APIs              │
+└─────────────────────────────────────┘
+          (HTTPS to exchanges)
+```
+
+- ✅ API keys stay on your machine
+- ✅ No cloud storage
+- ✅ No telemetry
+- ✅ Open source — audit the code
+
+### API Key Best Practices
+
+**Always:**
+- Enable only View + Trade permissions
+- **Disable** withdrawal permissions
+- Use IP restrictions when available
+- Use testnet for testing
+
+**Never:**
+- Share your config file
+- Commit config to git
+- Enable withdrawal permissions
+
+### Safety Features
+
+```json
+{
+  "security": {
+    "maxOrderSize": 100,        // Max $100 per order
+    "allowedPairs": ["BTC/USDT", "ETH/USDT"],  // Whitelist
+    "testnetOnly": true,        // Force testnet
+    "confirmTrades": true       // Require confirmation
+  }
+}
+```
+
+## Configuration
+
+### Full Config Example
+
+```json
+{
+  "exchanges": {
+    "binance": {
+      "apiKey": "xxx",
+      "secret": "xxx",
+      "testnet": true
+    },
+    "coinbase": {
+      "apiKey": "xxx",
+      "secret": "xxx", 
+      "password": "xxx",
+      "testnet": true
+    },
+    "kraken": {
+      "apiKey": "xxx",
+      "secret": "xxx",
+      "testnet": false
+    }
+  },
+  "defaultExchange": "binance",
+  "security": {
+    "maxOrderSize": 100,
+    "allowedPairs": ["BTC/USDT", "ETH/USDT", "SOL/USDT"],
+    "testnetOnly": false,
+    "confirmTrades": true
+  }
+}
+```
+
+### Config Locations
+
+The config file is searched in order:
+
+1. `~/.omnitrade/config.json` (recommended)
+2. `./omnitrade.config.json`
+3. `./.omnitrade.json`
+
+## Testnet Setup
+
+### Binance Testnet
+
+1. Go to https://testnet.binance.vision/
+2. Login with GitHub
+3. Generate API keys
+4. Get free testnet coins from faucet
+
+### Coinbase Sandbox
+
+1. Go to https://portal.cdp.coinbase.com/
+2. Create new project
+3. Enable sandbox mode
+4. Generate API keys
+
+## Disclaimer
+
+```
+⚠️ IMPORTANT
+
+This software is provided "as is" without warranty of any kind.
+
+Cryptocurrency trading involves substantial risk of loss. 
+Past performance does not guarantee future results.
+
+This software does NOT provide financial, investment, or trading advice.
+You are solely responsible for your trading decisions.
+
+Always test with testnet before using real funds.
+Never trade more than you can afford to lose.
+```
+
+## License
+
+MIT © [Connectry Labs](https://connectry.io)
+
+## Links
+
+- [GitHub](https://github.com/Connectry-io/omnitrade-mcp)
+- [npm](https://www.npmjs.com/package/omnitrade-mcp)
+- [CCXT Documentation](https://docs.ccxt.com/)
+- [MCP Specification](https://modelcontextprotocol.io/)
+
+---
+
+Made with ⚡ by [Connectry Labs](https://connectry.io)

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,999 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/config/loader.ts
+import { readFileSync, existsSync, statSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/types/index.ts
+import { z } from "zod";
+var ExchangeConfigSchema = z.object({
+  apiKey: z.string().min(1, "API key is required"),
+  secret: z.string().min(1, "Secret is required"),
+  password: z.string().optional(),
+  // For exchanges requiring passphrase (Coinbase, KuCoin)
+  testnet: z.boolean().default(true)
+  // Default to testnet for safety
+});
+var SecurityConfigSchema = z.object({
+  confirmTrades: z.boolean().default(true),
+  maxOrderSize: z.number().positive().default(100),
+  // Max USD per order
+  allowedPairs: z.array(z.string()).optional(),
+  // Whitelist of trading pairs
+  testnetOnly: z.boolean().default(false),
+  // Force testnet mode globally
+  disableWithdrawals: z.boolean().default(true)
+  // Extra safety (we don't support withdrawals anyway)
+});
+var ConfigSchema = z.object({
+  exchanges: z.record(z.string(), ExchangeConfigSchema),
+  security: SecurityConfigSchema.optional(),
+  defaultExchange: z.string().optional()
+});
+
+// src/config/loader.ts
+var CONFIG_PATHS = [
+  join(homedir(), ".omnitrade", "config.json"),
+  join(process.cwd(), "omnitrade.config.json"),
+  join(process.cwd(), ".omnitrade.json")
+];
+function loadConfig() {
+  for (const configPath of CONFIG_PATHS) {
+    if (existsSync(configPath)) {
+      checkFilePermissions(configPath);
+      const raw = readFileSync(configPath, "utf-8");
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        throw new Error(`Invalid JSON in config file: ${configPath}`);
+      }
+      const result = ConfigSchema.safeParse(parsed);
+      if (!result.success) {
+        const errors = result.error.errors.map((e) => `  - ${e.path.join(".")}: ${e.message}`).join("\n");
+        throw new Error(`Invalid config at ${configPath}:
+${errors}`);
+      }
+      console.error(`\u2713 Config loaded from: ${configPath}`);
+      console.error(`\u2713 Exchanges configured: ${Object.keys(result.data.exchanges).join(", ")}`);
+      return result.data;
+    }
+  }
+  throw new Error(
+    `Config file not found.
+
+Create a config file at: ${CONFIG_PATHS[0]}
+
+Example config:
+` + JSON.stringify(
+      {
+        exchanges: {
+          binance: {
+            apiKey: "YOUR_API_KEY",
+            secret: "YOUR_SECRET",
+            testnet: true
+          }
+        },
+        security: {
+          maxOrderSize: 100,
+          confirmTrades: true
+        }
+      },
+      null,
+      2
+    ) + `
+
+Then set permissions: chmod 600 ${CONFIG_PATHS[0]}
+
+Docs: https://github.com/Connectry-io/omnitrade-mcp#configuration`
+  );
+}
+function checkFilePermissions(configPath) {
+  try {
+    const stats = statSync(configPath);
+    const mode = stats.mode & 511;
+    if (mode & 36) {
+      console.error(`
+\u26A0\uFE0F  SECURITY WARNING: Config file is readable by others!`);
+      console.error(`   File: ${configPath}`);
+      console.error(`   Current permissions: ${mode.toString(8)}`);
+      console.error(`   Recommended: Run 'chmod 600 ${configPath}'
+`);
+    }
+  } catch {
+  }
+}
+
+// src/exchanges/manager.ts
+import ccxt from "ccxt";
+var ExchangeManager = class {
+  exchanges = /* @__PURE__ */ new Map();
+  config;
+  constructor(config) {
+    this.config = config;
+    this.initializeExchanges();
+  }
+  /**
+   * Initialize exchange connections from config
+   */
+  initializeExchanges() {
+    for (const [name, exchangeConfig] of Object.entries(this.config.exchanges)) {
+      try {
+        const exchange = this.createExchange(name, exchangeConfig);
+        if (exchange) {
+          this.exchanges.set(name, exchange);
+          console.error(`\u2713 Exchange initialized: ${name}${exchangeConfig.testnet ? " (testnet)" : ""}`);
+        }
+      } catch (error) {
+        console.error(`\u2717 Failed to initialize ${name}: ${error.message}`);
+      }
+    }
+    if (this.exchanges.size === 0) {
+      throw new Error("No exchanges could be initialized. Check your config.");
+    }
+  }
+  /**
+   * Create a CCXT exchange instance
+   */
+  createExchange(name, config) {
+    const exchangeId = name.toLowerCase();
+    if (!ccxt.exchanges.includes(exchangeId)) {
+      console.error(`\u2717 Unknown exchange: ${name}. Supported: ${ccxt.exchanges.slice(0, 10).join(", ")}...`);
+      return null;
+    }
+    const ExchangeClass = ccxt[exchangeId];
+    if (!ExchangeClass) {
+      console.error(`\u2717 Could not load exchange class: ${name}`);
+      return null;
+    }
+    const exchange = new ExchangeClass({
+      apiKey: config.apiKey,
+      secret: config.secret,
+      password: config.password,
+      enableRateLimit: true,
+      // Respect rate limits
+      options: {
+        defaultType: "spot",
+        // Default to spot trading
+        adjustForTimeDifference: true
+        // Handle time sync issues
+      }
+    });
+    if (config.testnet) {
+      try {
+        exchange.setSandboxMode(true);
+      } catch {
+        console.error(`\u26A0 ${name} does not support testnet mode, using production`);
+      }
+    }
+    return exchange;
+  }
+  /**
+   * Get a specific exchange by name
+   */
+  get(name) {
+    return this.exchanges.get(name.toLowerCase());
+  }
+  /**
+   * Get all initialized exchanges
+   */
+  getAll() {
+    return this.exchanges;
+  }
+  /**
+   * Get list of initialized exchange names
+   */
+  getNames() {
+    return Array.from(this.exchanges.keys());
+  }
+  /**
+   * Get the default exchange (first configured or explicitly set)
+   */
+  getDefault() {
+    if (this.config.defaultExchange) {
+      return this.exchanges.get(this.config.defaultExchange.toLowerCase());
+    }
+    return this.exchanges.values().next().value;
+  }
+  /**
+   * Get default exchange name
+   */
+  getDefaultName() {
+    if (this.config.defaultExchange) {
+      return this.config.defaultExchange.toLowerCase();
+    }
+    return this.exchanges.keys().next().value;
+  }
+  /**
+   * Check if an exchange is in testnet mode
+   */
+  isTestnet(name) {
+    const config = this.config.exchanges[name];
+    return config?.testnet ?? true;
+  }
+};
+
+// src/tools/balances.ts
+import { z as z2 } from "zod";
+function registerBalanceTools(server, exchangeManager) {
+  server.tool(
+    "get_balances",
+    "Get portfolio balances across all connected exchanges. Returns asset holdings with free (available) and locked (in orders) amounts.",
+    {
+      exchange: z2.string().optional().describe('Specific exchange name (e.g., "binance"). Omit to query all exchanges.'),
+      asset: z2.string().optional().describe('Filter by specific asset (e.g., "BTC", "ETH"). Omit for all assets.'),
+      hideZero: z2.boolean().default(true).describe("Hide assets with zero balance (default: true)")
+    },
+    async ({ exchange, asset, hideZero }) => {
+      const balances = [];
+      const exchangesToQuery = exchange ? [[exchange.toLowerCase(), exchangeManager.get(exchange)]].filter(
+        ([, ex]) => ex !== void 0
+      ) : Array.from(exchangeManager.getAll().entries());
+      if (exchangesToQuery.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: exchange ? `Exchange not configured: ${exchange}. Available: ${exchangeManager.getNames().join(", ")}` : "No exchanges configured."
+            }
+          ],
+          isError: true
+        };
+      }
+      for (const [name, ex] of exchangesToQuery) {
+        if (!ex) continue;
+        try {
+          const balance = await ex.fetchBalance();
+          for (const [symbol, total] of Object.entries(balance.total)) {
+            const totalAmount = total;
+            if (hideZero && totalAmount === 0) continue;
+            if (asset && symbol.toUpperCase() !== asset.toUpperCase()) continue;
+            const free = balance.free[symbol] || 0;
+            const locked = balance.used[symbol] || 0;
+            balances.push({
+              exchange: name,
+              asset: symbol,
+              free,
+              locked,
+              total: totalAmount
+            });
+          }
+        } catch (error) {
+          balances.push({
+            exchange: name,
+            asset: "ERROR",
+            free: 0,
+            locked: 0,
+            total: 0,
+            error: error.message
+          });
+        }
+      }
+      balances.sort((a, b) => b.total - a.total);
+      const summary = {
+        exchanges: exchangeManager.getNames().length,
+        assetsFound: balances.filter((b) => !("error" in b)).length,
+        balances
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(summary, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "get_portfolio",
+    "Get a unified portfolio summary across all exchanges with total values.",
+    {},
+    async () => {
+      const assetTotals = {};
+      const errors = [];
+      for (const [name, ex] of exchangeManager.getAll()) {
+        try {
+          const balance = await ex.fetchBalance();
+          for (const [symbol, total] of Object.entries(balance.total)) {
+            const amount = total;
+            if (amount === 0) continue;
+            if (!assetTotals[symbol]) {
+              assetTotals[symbol] = { total: 0, byExchange: {} };
+            }
+            assetTotals[symbol].total += amount;
+            assetTotals[symbol].byExchange[name] = amount;
+          }
+        } catch (error) {
+          errors.push(`${name}: ${error.message}`);
+        }
+      }
+      const assets = Object.entries(assetTotals).map(([asset, data]) => ({
+        asset,
+        total: data.total,
+        distribution: data.byExchange
+      })).sort((a, b) => b.total - a.total);
+      const portfolio = {
+        summary: {
+          totalAssets: assets.length,
+          exchanges: exchangeManager.getNames()
+        },
+        assets,
+        errors: errors.length > 0 ? errors : void 0
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(portfolio, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/prices.ts
+import { z as z3 } from "zod";
+function registerPriceTools(server, exchangeManager) {
+  server.tool(
+    "get_prices",
+    "Get current market prices for a trading pair across exchanges. Returns bid, ask, and last traded price.",
+    {
+      symbol: z3.string().describe('Trading pair in format "BASE/QUOTE" (e.g., "BTC/USDT", "ETH/USD")'),
+      exchange: z3.string().optional().describe("Specific exchange name. Omit to query all exchanges.")
+    },
+    async ({ symbol, exchange }) => {
+      const prices = [];
+      const errors = [];
+      const normalizedSymbol = symbol.toUpperCase();
+      const exchangesToQuery = exchange ? [[exchange.toLowerCase(), exchangeManager.get(exchange)]].filter(
+        ([, ex]) => ex !== void 0
+      ) : Array.from(exchangeManager.getAll().entries());
+      if (exchangesToQuery.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: exchange ? `Exchange not configured: ${exchange}` : "No exchanges configured."
+            }
+          ],
+          isError: true
+        };
+      }
+      for (const [name, ex] of exchangesToQuery) {
+        if (!ex) continue;
+        try {
+          const ticker = await ex.fetchTicker(normalizedSymbol);
+          prices.push({
+            exchange: name,
+            symbol: normalizedSymbol,
+            bid: ticker.bid ?? 0,
+            ask: ticker.ask ?? 0,
+            last: ticker.last ?? 0,
+            timestamp: ticker.timestamp ?? Date.now()
+          });
+        } catch (error) {
+          errors.push(`${name}: ${error.message}`);
+        }
+      }
+      if (prices.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No prices found for ${normalizedSymbol}. Errors: ${errors.join("; ")}`
+            }
+          ],
+          isError: true
+        };
+      }
+      prices.sort((a, b) => b.last - a.last);
+      const result = {
+        symbol: normalizedSymbol,
+        priceCount: prices.length,
+        prices,
+        errors: errors.length > 0 ? errors : void 0
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "compare_prices",
+    "Find the best price for buying or selling across all connected exchanges. Identifies arbitrage opportunities.",
+    {
+      symbol: z3.string().describe('Trading pair in format "BASE/QUOTE" (e.g., "BTC/USDT")'),
+      side: z3.enum(["buy", "sell"]).describe('"buy" to find lowest ask price, "sell" to find highest bid price')
+    },
+    async ({ symbol, side }) => {
+      const normalizedSymbol = symbol.toUpperCase();
+      const prices = [];
+      for (const [name, ex] of exchangeManager.getAll()) {
+        try {
+          const ticker = await ex.fetchTicker(normalizedSymbol);
+          if (ticker.bid && ticker.ask) {
+            prices.push({
+              exchange: name,
+              symbol: normalizedSymbol,
+              bid: ticker.bid,
+              ask: ticker.ask,
+              last: ticker.last ?? 0,
+              timestamp: ticker.timestamp ?? Date.now()
+            });
+          }
+        } catch {
+          continue;
+        }
+      }
+      if (prices.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No prices found for ${normalizedSymbol} on any exchange.`
+            }
+          ],
+          isError: true
+        };
+      }
+      if (prices.length === 1) {
+        const only = prices[0];
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  recommendation: `${side.toUpperCase()} on ${only.exchange} (only exchange with this pair)`,
+                  bestExchange: only.exchange,
+                  bestPrice: side === "buy" ? only.ask : only.bid,
+                  note: "Only one exchange has this trading pair."
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      const sorted = [...prices].sort((a, b) => {
+        if (side === "buy") {
+          return a.ask - b.ask;
+        } else {
+          return b.bid - a.bid;
+        }
+      });
+      const best = sorted[0];
+      const worst = sorted[sorted.length - 1];
+      const bestPrice = side === "buy" ? best.ask : best.bid;
+      const worstPrice = side === "buy" ? worst.ask : worst.bid;
+      const savings = Math.abs(worstPrice - bestPrice);
+      const savingsPercent = savings / worstPrice * 100;
+      const comparison = {
+        recommendation: `${side.toUpperCase()} on ${best.exchange} for best price`,
+        bestExchange: best.exchange,
+        bestPrice,
+        allPrices: sorted.map((p) => ({
+          exchange: p.exchange,
+          price: side === "buy" ? p.ask : p.bid
+        })),
+        savings: {
+          amount: parseFloat(savings.toFixed(8)),
+          percent: savingsPercent.toFixed(2) + "%",
+          vs: worst.exchange
+        }
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(comparison, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/orders.ts
+import { z as z4 } from "zod";
+function registerOrderTools(server, exchangeManager, config) {
+  server.tool(
+    "place_order",
+    "Execute a buy or sell order on an exchange. Supports market and limit orders with safety checks.",
+    {
+      exchange: z4.string().describe('Exchange to trade on (e.g., "binance", "coinbase")'),
+      symbol: z4.string().describe('Trading pair (e.g., "BTC/USDT", "ETH/USD")'),
+      side: z4.enum(["buy", "sell"]).describe('Order side: "buy" or "sell"'),
+      type: z4.enum(["market", "limit"]).default("market").describe('Order type: "market" (immediate) or "limit" (at specified price)'),
+      amount: z4.number().positive().describe("Amount of base currency to trade"),
+      price: z4.number().positive().optional().describe("Limit price (required for limit orders, ignored for market orders)")
+    },
+    async ({ exchange, symbol, side, type, amount, price }) => {
+      const ex = exchangeManager.get(exchange);
+      if (!ex) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Exchange not configured: ${exchange}. Available: ${exchangeManager.getNames().join(", ")}`
+            }
+          ],
+          isError: true
+        };
+      }
+      const normalizedSymbol = symbol.toUpperCase();
+      const security = config.security;
+      if (security?.allowedPairs && security.allowedPairs.length > 0) {
+        const allowed = security.allowedPairs.map((p) => p.toUpperCase());
+        if (!allowed.includes(normalizedSymbol)) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Trading pair not in allowlist: ${normalizedSymbol}
+Allowed pairs: ${allowed.join(", ")}`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+      if (security?.maxOrderSize) {
+        try {
+          const ticker = await ex.fetchTicker(normalizedSymbol);
+          const estimatedUsdValue = amount * (ticker.last ?? 0);
+          if (estimatedUsdValue > security.maxOrderSize) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Order exceeds maximum allowed size.
+Estimated value: $${estimatedUsdValue.toFixed(2)}
+Maximum allowed: $${security.maxOrderSize}
+Reduce amount or update security.maxOrderSize in config.`
+                }
+              ],
+              isError: true
+            };
+          }
+        } catch {
+          console.error("Warning: Could not verify order size against limit");
+        }
+      }
+      if (type === "limit" && !price) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: 'Limit orders require a price. Please specify the "price" parameter.'
+            }
+          ],
+          isError: true
+        };
+      }
+      try {
+        let order;
+        if (type === "market") {
+          order = await ex.createMarketOrder(normalizedSymbol, side, amount);
+        } else {
+          order = await ex.createLimitOrder(normalizedSymbol, side, amount, price);
+        }
+        const result = {
+          success: true,
+          orderId: order.id,
+          exchange,
+          symbol: normalizedSymbol,
+          side,
+          type,
+          amount: order.amount,
+          filled: order.filled,
+          remaining: order.remaining,
+          price: order.price ?? order.average,
+          cost: order.cost,
+          status: order.status,
+          timestamp: order.timestamp ?? Date.now()
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Order failed: ${error.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "get_orders",
+    "View open and recent orders. Can filter by exchange, trading pair, or status.",
+    {
+      exchange: z4.string().optional().describe("Filter by exchange name"),
+      symbol: z4.string().optional().describe("Filter by trading pair"),
+      status: z4.enum(["open", "closed", "all"]).default("open").describe('Order status filter: "open", "closed", or "all"'),
+      limit: z4.number().positive().max(100).default(20).describe("Maximum orders to return")
+    },
+    async ({ exchange, symbol, status, limit }) => {
+      const orders = [];
+      const errors = [];
+      const normalizedSymbol = symbol?.toUpperCase();
+      const exchangesToQuery = exchange ? [[exchange.toLowerCase(), exchangeManager.get(exchange)]].filter(
+        ([, ex]) => ex !== void 0
+      ) : Array.from(exchangeManager.getAll().entries());
+      for (const [name, ex] of exchangesToQuery) {
+        if (!ex) continue;
+        try {
+          let fetchedOrders = [];
+          if (status === "open" || status === "all") {
+            const open = await ex.fetchOpenOrders(normalizedSymbol);
+            fetchedOrders.push(...open.map((o) => ({ ...o, exchange: name })));
+          }
+          if (status === "closed" || status === "all") {
+            const closed = await ex.fetchClosedOrders(normalizedSymbol, void 0, limit);
+            fetchedOrders.push(...closed.map((o) => ({ ...o, exchange: name })));
+          }
+          orders.push(...fetchedOrders);
+        } catch (error) {
+          errors.push(`${name}: ${error.message}`);
+        }
+      }
+      orders.sort((a, b) => {
+        const aTime = a.timestamp ?? 0;
+        const bTime = b.timestamp ?? 0;
+        return bTime - aTime;
+      });
+      const limited = orders.slice(0, limit);
+      const result = {
+        count: limited.length,
+        status,
+        orders: limited,
+        errors: errors.length > 0 ? errors : void 0
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "cancel_order",
+    "Cancel an open order by its ID.",
+    {
+      exchange: z4.string().describe("Exchange where the order was placed"),
+      orderId: z4.string().describe("Order ID to cancel"),
+      symbol: z4.string().describe("Trading pair of the order")
+    },
+    async ({ exchange, orderId, symbol }) => {
+      const ex = exchangeManager.get(exchange);
+      if (!ex) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Exchange not configured: ${exchange}`
+            }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const result = await ex.cancelOrder(orderId, symbol.toUpperCase());
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  orderId,
+                  exchange,
+                  symbol: symbol.toUpperCase(),
+                  status: "cancelled",
+                  result
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to cancel order: ${error.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/arbitrage.ts
+import { z as z5 } from "zod";
+var DEFAULT_SYMBOLS = [
+  "BTC/USDT",
+  "ETH/USDT",
+  "BNB/USDT",
+  "SOL/USDT",
+  "XRP/USDT",
+  "ADA/USDT",
+  "DOGE/USDT",
+  "DOT/USDT",
+  "MATIC/USDT",
+  "LTC/USDT"
+];
+function registerArbitrageTools(server, exchangeManager) {
+  server.tool(
+    "get_arbitrage",
+    "Find arbitrage opportunities by comparing prices across exchanges. Identifies pairs where you can buy low on one exchange and sell high on another.",
+    {
+      symbols: z5.array(z5.string()).optional().describe(
+        'Trading pairs to check (e.g., ["BTC/USDT", "ETH/USDT"]). Defaults to top 10 pairs.'
+      ),
+      minSpread: z5.number().min(0).max(100).default(0.5).describe("Minimum spread percentage to report (default: 0.5%)")
+    },
+    async ({ symbols, minSpread }) => {
+      const checkSymbols = symbols ?? DEFAULT_SYMBOLS;
+      const opportunities = [];
+      const exchangeNames = exchangeManager.getNames();
+      if (exchangeNames.length < 2) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Arbitrage requires at least 2 exchanges configured. Currently have: " + exchangeNames.length
+            }
+          ],
+          isError: true
+        };
+      }
+      for (const symbol of checkSymbols) {
+        const normalizedSymbol = symbol.toUpperCase();
+        const prices = [];
+        for (const [name, ex] of exchangeManager.getAll()) {
+          try {
+            const ticker = await ex.fetchTicker(normalizedSymbol);
+            if (ticker.bid && ticker.ask && ticker.bid > 0 && ticker.ask > 0) {
+              prices.push({
+                exchange: name,
+                bid: ticker.bid,
+                ask: ticker.ask
+              });
+            }
+          } catch {
+            continue;
+          }
+        }
+        if (prices.length < 2) continue;
+        const bestBuy = prices.reduce((a, b) => a.ask < b.ask ? a : b);
+        const bestSell = prices.reduce((a, b) => a.bid > b.bid ? a : b);
+        if (bestSell.bid > bestBuy.ask) {
+          const spread = bestSell.bid - bestBuy.ask;
+          const spreadPercent = spread / bestBuy.ask * 100;
+          if (spreadPercent >= minSpread) {
+            opportunities.push({
+              symbol: normalizedSymbol,
+              buyExchange: bestBuy.exchange,
+              buyPrice: bestBuy.ask,
+              sellExchange: bestSell.exchange,
+              sellPrice: bestSell.bid,
+              spreadPercent: parseFloat(spreadPercent.toFixed(3)),
+              potentialProfit: parseFloat(spread.toFixed(8))
+            });
+          }
+        }
+      }
+      opportunities.sort((a, b) => b.spreadPercent - a.spreadPercent);
+      const result = {
+        found: opportunities.length,
+        opportunities,
+        note: "Spreads shown BEFORE trading fees. Always account for:\n\u2022 Trading fees on both exchanges (typically 0.1-0.2% each)\n\u2022 Transfer fees if moving funds between exchanges\n\u2022 Slippage on larger orders\n\u2022 Price movement during execution"
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "check_spread",
+    "Check the price spread for a single trading pair across all exchanges.",
+    {
+      symbol: z5.string().describe('Trading pair to check (e.g., "BTC/USDT")')
+    },
+    async ({ symbol }) => {
+      const normalizedSymbol = symbol.toUpperCase();
+      const prices = [];
+      for (const [name, ex] of exchangeManager.getAll()) {
+        try {
+          const ticker = await ex.fetchTicker(normalizedSymbol);
+          if (ticker.bid && ticker.ask) {
+            const spread = ticker.ask - ticker.bid;
+            const spreadPercent = spread / ticker.bid * 100;
+            prices.push({
+              exchange: name,
+              bid: ticker.bid,
+              ask: ticker.ask,
+              spread: parseFloat(spread.toFixed(8)),
+              spreadPercent: parseFloat(spreadPercent.toFixed(3))
+            });
+          }
+        } catch {
+          continue;
+        }
+      }
+      if (prices.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No prices found for ${normalizedSymbol} on any exchange.`
+            }
+          ],
+          isError: true
+        };
+      }
+      prices.sort((a, b) => a.ask - b.ask);
+      let arbitrage = null;
+      if (prices.length >= 2) {
+        const bestBuy = prices[0];
+        const bestSell = prices.reduce((a, b) => a.bid > b.bid ? a : b);
+        if (bestSell.bid > bestBuy.ask && bestSell.exchange !== bestBuy.exchange) {
+          const profit = bestSell.bid - bestBuy.ask;
+          const profitPercent = profit / bestBuy.ask * 100;
+          arbitrage = {
+            exists: true,
+            buyOn: bestBuy.exchange,
+            buyAt: bestBuy.ask,
+            sellOn: bestSell.exchange,
+            sellAt: bestSell.bid,
+            profit: parseFloat(profit.toFixed(8)),
+            profitPercent: parseFloat(profitPercent.toFixed(3)) + "%"
+          };
+        } else {
+          arbitrage = {
+            exists: false,
+            reason: "Best bid is not higher than best ask across exchanges"
+          };
+        }
+      }
+      const result = {
+        symbol: normalizedSymbol,
+        exchanges: prices.length,
+        prices,
+        arbitrage
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+function showBanner() {
+  console.error(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551                                                               \u2551
+\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2557   \u2551
+\u2551  \u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557  \u2551
+\u2551  \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551  \u2551
+\u2551  \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551  \u2551
+\u2551  \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551  \u2551
+\u2551   \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D     \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D\u255A\u2550\u255D   \u255A\u2550\u255D   \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D  \u2551
+\u2551                                                               \u2551
+\u2551   MCP Server v${VERSION}                                          \u2551
+\u2551   One AI. 107 Exchanges. Natural language trading.           \u2551
+\u2551                                                               \u2551
+\u2551   by Connectry Labs \u2022 https://connectry.io                    \u2551
+\u2551                                                               \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`);
+}
+async function main() {
+  showBanner();
+  console.error("Loading configuration...");
+  let config;
+  try {
+    config = loadConfig();
+  } catch (error) {
+    console.error(`
+\u274C ${error.message}`);
+    process.exit(1);
+  }
+  console.error("\nInitializing exchanges...");
+  let exchangeManager;
+  try {
+    exchangeManager = new ExchangeManager(config);
+  } catch (error) {
+    console.error(`
+\u274C ${error.message}`);
+    process.exit(1);
+  }
+  console.error("\nStarting MCP server...");
+  const server = new McpServer({
+    name: "omnitrade-mcp",
+    version: VERSION
+  });
+  registerBalanceTools(server, exchangeManager);
+  registerPriceTools(server, exchangeManager);
+  registerOrderTools(server, exchangeManager, config);
+  registerArbitrageTools(server, exchangeManager);
+  console.error("\u2713 Tools registered: get_balances, get_portfolio, get_prices, compare_prices, place_order, get_orders, cancel_order, get_arbitrage, check_spread");
+  if (config.security?.testnetOnly) {
+    console.error("\n\u{1F512} TESTNET-ONLY MODE: All exchanges forced to testnet");
+  }
+  if (config.security?.maxOrderSize) {
+    console.error(`\u{1F512} Order size limit: $${config.security.maxOrderSize} max per trade`);
+  }
+  if (config.security?.allowedPairs?.length) {
+    console.error(`\u{1F512} Trading pairs whitelist: ${config.security.allowedPairs.join(", ")}`);
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("\n\u2705 OmniTrade MCP server is ready!");
+  console.error("   Waiting for Claude to connect via MCP...\n");
+}
+process.on("uncaughtException", (error) => {
+  console.error("Uncaught exception:", error.message);
+  process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+  console.error("Unhandled rejection:", reason);
+  process.exit(1);
+});
+main().catch((error) => {
+  console.error("Fatal error:", error.message);
+  process.exit(1);
+});
+/**
+ * OmniTrade MCP Server
+ * 
+ * Multi-exchange AI trading via Model Context Protocol.
+ * Connects Claude to 107+ cryptocurrency exchanges through CCXT.
+ * 
+ * @author Connectry Labs
+ * @license MIT
+ * @see https://github.com/Connectry-io/omnitrade-mcp
+ */

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "omnitrade-mcp",
+  "version": "0.1.0",
+  "description": "Multi-exchange AI trading via MCP. 107 exchanges. One AI.",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "omnitrade-mcp": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "test": "vitest",
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "trading",
+    "crypto",
+    "cryptocurrency",
+    "ai",
+    "claude",
+    "binance",
+    "coinbase",
+    "kraken",
+    "exchange",
+    "arbitrage",
+    "ccxt"
+  ],
+  "author": {
+    "name": "Connectry Labs",
+    "email": "labs@connectry.io",
+    "url": "https://connectry.io"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Connectry-io/omnitrade-mcp"
+  },
+  "homepage": "https://github.com/Connectry-io/omnitrade-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/Connectry-io/omnitrade-mcp/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "ccxt": "^4.5.38",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.3",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  }
+}