@c0pilot/mcp-polymarket 1.0.0

package/README.md

@@ -0,0 +1,159 @@
+# mcp-polymarket
+
+MCP (Model Context Protocol) server and client library for [Polymarket](https://polymarket.com) prediction markets.
+
+[![npm version](https://badge.fury.io/js/mcp-polymarket.svg)](https://www.npmjs.com/package/mcp-polymarket)
+
+## Features
+
+- **MCP Server**: Run as a standalone MCP server for AI agents
+- **Client Library**: Import and use in your own projects
+- Browse and search prediction markets
+- View order books and market prices
+- Check wallet balance and positions
+- Place and cancel orders
+- Full integration with Polymarket's CLOB API
+
+## Installation
+
+```bash
+npm install mcp-polymarket
+```
+
+## Usage
+
+### As MCP Server
+
+#### With Claude Desktop
+
+Add to your Claude Desktop configuration (`~/Library/Application Support/Claude/claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "polymarket": {
+      "command": "npx",
+      "args": ["mcp-polymarket"],
+      "env": {
+        "POLYMARKET_PRIVATE_KEY": "0x...",
+        "POLYMARKET_FUNDER": "0x..."
+      }
+    }
+  }
+}
+```
+
+#### Standalone
+
+```bash
+export POLYMARKET_PRIVATE_KEY="0x..."
+export POLYMARKET_FUNDER="0x..."
+npx mcp-polymarket
+```
+
+### As Library
+
+```typescript
+import { ClobClientWrapper } from 'mcp-polymarket/client';
+import { createConfig } from 'mcp-polymarket/config';
+
+// Create config
+const config = createConfig({
+  privateKey: '0x...',
+  funder: '0x...',      // optional
+  readonly: false,       // optional
+});
+
+// Initialize client
+const client = new ClobClientWrapper(config);
+await client.initialize();
+
+// Use the client
+const clobClient = client.getClient();
+const orderbook = await clobClient.getOrderBook(tokenId);
+```
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Required | Default | Description |
+|----------|----------|---------|-------------|
+| `POLYMARKET_PRIVATE_KEY` | Yes | - | Wallet private key for signing |
+| `POLYMARKET_FUNDER` | No | derived | Proxy wallet address |
+| `POLYMARKET_API_KEY` | No | derived | API key (auto-derived if not set) |
+| `POLYMARKET_API_SECRET` | No | derived | API secret (auto-derived if not set) |
+| `POLYMARKET_PASSPHRASE` | No | derived | API passphrase (auto-derived if not set) |
+| `POLYMARKET_CHAIN_ID` | No | 137 | Polygon mainnet |
+| `POLYMARKET_READONLY` | No | false | Disable trading tools |
+
+### Finding Your Funder Address
+
+Your "funder" is your Polymarket proxy wallet - the address shown on polymarket.com when logged in. If you deposited through Polymarket's UI, funds are in this proxy wallet.
+
+## Available MCP Tools
+
+### Read-Only
+
+| Tool | Description |
+|------|-------------|
+| `polymarket_get_markets` | List active prediction markets |
+| `polymarket_get_market` | Get details for a specific market |
+| `polymarket_get_orderbook` | View order book for a token |
+| `polymarket_get_balance` | Check wallet USDC balance |
+| `polymarket_get_positions` | View open orders and positions |
+| `polymarket_get_trades` | Get recent trade history |
+
+### Trading
+
+| Tool | Description |
+|------|-------------|
+| `polymarket_place_order` | Place a limit order (BUY/SELL) |
+| `polymarket_cancel_order` | Cancel an open order |
+
+## API Exports
+
+```typescript
+// Main MCP server entry
+import mcp from 'mcp-polymarket';
+
+// Client wrapper for Polymarket CLOB
+import { ClobClientWrapper } from 'mcp-polymarket/client';
+
+// Configuration utilities
+import { createConfig, loadConfig, Config } from 'mcp-polymarket/config';
+
+// Type definitions
+import { MarketInfo, OrderbookInfo, Position } from 'mcp-polymarket/types';
+```
+
+## Security
+
+- Private keys are never logged
+- Use `POLYMARKET_READONLY=true` for safe exploration
+- API credentials auto-derived from private key
+- Input validation on all parameters
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Run tests
+npm test
+
+# Run E2E tests (requires env vars)
+npm run test:e2e
+```
+
+## Related
+
+- [@openclaw/polymarket](https://github.com/unsanction/openclaw-polymarket) - OpenClaw plugin using this library
+
+## License
+
+MIT

package/build/client.d.ts

@@ -0,0 +1,15 @@
+import { ClobClient } from "@polymarket/clob-client";
+import { Config } from "./config.js";
+export declare class ClobClientWrapper {
+    private client;
+    private config;
+    constructor(config?: Config);
+    initialize(): Promise<void>;
+    getClient(): ClobClient;
+    isReadonly(): boolean;
+    ensureWriteAccess(): void;
+    getGammaApiUrl(): string;
+    getClobApiUrl(): string;
+    getFunder(): string;
+}
+export declare function getClientWrapper(): Promise<ClobClientWrapper>;

package/build/client.js

@@ -0,0 +1,79 @@
+import { ClobClient } from "@polymarket/clob-client";
+import { Wallet } from "ethers";
+import { getConfig } from "./config.js";
+const CLOB_API_URL = "https://clob.polymarket.com";
+const GAMMA_API_URL = "https://gamma-api.polymarket.com";
+export class ClobClientWrapper {
+    client = null;
+    config;
+    constructor(config) {
+        this.config = config || getConfig();
+    }
+    async initialize() {
+        // Skip if already initialized
+        if (this.client) {
+            return;
+        }
+        // Cast to any to handle ethers version mismatch between our ethers and @polymarket/clob-client's ethers
+        const wallet = new Wallet(this.config.privateKey);
+        const funder = this.config.funder;
+        // Signature type depends on wallet setup:
+        // 0 = Direct EOA (when funder == signer)
+        // 1 = Magic/Privy (email wallet)
+        // 2 = Browser wallet proxy/GnosisSafe (when funder != signer)
+        const signatureType = funder.toLowerCase() === wallet.address.toLowerCase() ? 0 : 2;
+        if (this.config.apiKey && this.config.apiSecret && this.config.passphrase) {
+            // Use provided API credentials
+            this.client = new ClobClient(CLOB_API_URL, this.config.chainId, wallet, {
+                key: this.config.apiKey,
+                secret: this.config.apiSecret,
+                passphrase: this.config.passphrase,
+            }, signatureType, funder);
+            // Initialized with provided API credentials
+        }
+        else {
+            // Create client with funder to properly derive API credentials
+            const tempClient = new ClobClient(CLOB_API_URL, this.config.chainId, wallet, undefined, signatureType, funder);
+            try {
+                // Try to derive or create API credentials
+                const creds = await tempClient.createOrDeriveApiKey();
+                this.client = new ClobClient(CLOB_API_URL, this.config.chainId, wallet, creds, signatureType, funder);
+            }
+            catch {
+                // Failed to derive API credentials, using unauthenticated client
+                this.client = tempClient;
+            }
+        }
+    }
+    getClient() {
+        if (!this.client) {
+            throw new Error("Client not initialized. Call initialize() first.");
+        }
+        return this.client;
+    }
+    isReadonly() {
+        return this.config.readonly;
+    }
+    ensureWriteAccess() {
+        if (this.config.readonly) {
+            throw new Error("Trading is disabled in readonly mode. Set POLYMARKET_READONLY=false to enable trading.");
+        }
+    }
+    getGammaApiUrl() {
+        return GAMMA_API_URL;
+    }
+    getClobApiUrl() {
+        return CLOB_API_URL;
+    }
+    getFunder() {
+        return this.config.funder;
+    }
+}
+let clientWrapper = null;
+export async function getClientWrapper() {
+    if (!clientWrapper) {
+        clientWrapper = new ClobClientWrapper();
+        await clientWrapper.initialize();
+    }
+    return clientWrapper;
+}

package/build/config.d.ts

@@ -0,0 +1,24 @@
+export interface Config {
+    privateKey: string;
+    apiKey?: string;
+    apiSecret?: string;
+    passphrase?: string;
+    funder: string;
+    chainId: number;
+    readonly: boolean;
+}
+export declare function deriveAddressFromPrivateKey(privateKey: string): string;
+/**
+ * Create a Config from an object (useful for plugins that pass config directly)
+ */
+export declare function createConfig(options: {
+    privateKey: string;
+    funder?: string;
+    apiKey?: string;
+    apiSecret?: string;
+    passphrase?: string;
+    chainId?: number;
+    readonly?: boolean;
+}): Config;
+export declare function loadConfig(): Config;
+export declare function getConfig(): Config;

package/build/config.js

@@ -0,0 +1,55 @@
+import { Wallet } from "ethers";
+function getEnvVar(name, required = false) {
+    const value = process.env[name];
+    if (required && !value) {
+        throw new Error(`Missing required environment variable: ${name}`);
+    }
+    return value;
+}
+export function deriveAddressFromPrivateKey(privateKey) {
+    const wallet = new Wallet(privateKey);
+    return wallet.address;
+}
+/**
+ * Create a Config from an object (useful for plugins that pass config directly)
+ */
+export function createConfig(options) {
+    const privateKey = options.privateKey;
+    if (!privateKey) {
+        throw new Error("privateKey is required");
+    }
+    return {
+        privateKey,
+        funder: options.funder || deriveAddressFromPrivateKey(privateKey),
+        apiKey: options.apiKey,
+        apiSecret: options.apiSecret,
+        passphrase: options.passphrase,
+        chainId: options.chainId || 137,
+        readonly: options.readonly || false,
+    };
+}
+export function loadConfig() {
+    const privateKey = getEnvVar("POLYMARKET_PRIVATE_KEY", true);
+    const funder = getEnvVar("POLYMARKET_FUNDER") || deriveAddressFromPrivateKey(privateKey);
+    const chainId = parseInt(getEnvVar("POLYMARKET_CHAIN_ID") || "137", 10);
+    const readonly = getEnvVar("POLYMARKET_READONLY")?.toLowerCase() === "true";
+    const apiKey = getEnvVar("POLYMARKET_API_KEY");
+    const apiSecret = getEnvVar("POLYMARKET_API_SECRET");
+    const passphrase = getEnvVar("POLYMARKET_PASSPHRASE");
+    return {
+        privateKey,
+        apiKey,
+        apiSecret,
+        passphrase,
+        funder,
+        chainId,
+        readonly,
+    };
+}
+let cachedConfig = null;
+export function getConfig() {
+    if (!cachedConfig) {
+        cachedConfig = loadConfig();
+    }
+    return cachedConfig;
+}

package/build/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/index.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { getClientWrapper } from "./client.js";
+import { registerAllTools } from "./tools/index.js";
+async function main() {
+    console.error("Starting Polymarket MCP Server...");
+    // Initialize the CLOB client
+    const clientWrapper = await getClientWrapper();
+    console.error("CLOB client initialized");
+    // Create MCP server
+    const server = new McpServer({
+        name: "polymarket",
+        version: "1.0.0",
+    });
+    // Register all tools
+    registerAllTools(server, clientWrapper);
+    // Connect via stdio transport
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Polymarket MCP Server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/build/tools/account.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ClobClientWrapper } from "../client.js";
+export declare function registerAccountTools(server: McpServer, clientWrapper: ClobClientWrapper): void;

package/build/tools/account.js

@@ -0,0 +1,110 @@
+import { z } from "zod";
+import { AssetType } from "@polymarket/clob-client";
+const GetBalanceSchema = z.object({});
+const GetPositionsSchema = z.object({});
+export function registerAccountTools(server, clientWrapper) {
+    server.tool("polymarket_get_balance", "Get the USDC balance and allowance for the configured wallet on Polymarket.", GetBalanceSchema.shape, async () => {
+        try {
+            const client = clientWrapper.getClient();
+            const funder = clientWrapper.getFunder();
+            // Get balance allowance for USDC collateral
+            const balanceData = await client.getBalanceAllowance({
+                asset_type: AssetType.COLLATERAL,
+            });
+            const result = {
+                balance: balanceData.balance || "0",
+                allowance: balanceData.allowance || "0",
+            };
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            address: funder,
+                            ...result,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error fetching balance: ${message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("polymarket_get_positions", "Get all open orders and positions for the configured wallet, including P&L calculations.", GetPositionsSchema.shape, async () => {
+        try {
+            const client = clientWrapper.getClient();
+            // Get open orders to derive positions
+            const openOrders = (await client.getOpenOrders());
+            if (!openOrders || openOrders.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({ positions: [], open_orders: [] }, null, 2),
+                        },
+                    ],
+                };
+            }
+            // Group orders by token to calculate positions
+            const positionMap = new Map();
+            for (const order of openOrders) {
+                const tokenId = order.asset_id;
+                const existing = positionMap.get(tokenId);
+                if (!existing) {
+                    positionMap.set(tokenId, {
+                        token_id: tokenId,
+                        market: order.market || "Unknown",
+                        outcome: order.outcome || "Unknown",
+                        size: order.original_size,
+                        avg_price: order.price,
+                        current_price: order.price,
+                        pnl: "0",
+                    });
+                }
+            }
+            const positions = Array.from(positionMap.values());
+            // Also return raw open orders for transparency
+            const formattedOrders = openOrders.map((o) => ({
+                id: o.id,
+                token_id: o.asset_id,
+                side: o.side,
+                price: o.price,
+                size: o.original_size,
+                filled: o.size_matched,
+            }));
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            positions,
+                            open_orders: formattedOrders,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error fetching positions: ${message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/build/tools/index.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ClobClientWrapper } from "../client.js";
+export declare function registerAllTools(server: McpServer, clientWrapper: ClobClientWrapper): void;

package/build/tools/index.js

@@ -0,0 +1,15 @@
+import { registerMarketTools } from "./markets.js";
+import { registerOrderbookTools } from "./orderbook.js";
+import { registerAccountTools } from "./account.js";
+import { registerTradingTools } from "./trading.js";
+export function registerAllTools(server, clientWrapper) {
+    const isReadonly = clientWrapper.isReadonly();
+    console.error(`Registering tools (readonly: ${isReadonly})`);
+    // Register read-only tools
+    registerMarketTools(server, clientWrapper);
+    registerOrderbookTools(server, clientWrapper);
+    registerAccountTools(server, clientWrapper);
+    // Register trading tools (write tools are conditionally included)
+    registerTradingTools(server, clientWrapper, !isReadonly);
+    console.error("All tools registered successfully");
+}

package/build/tools/markets.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ClobClientWrapper } from "../client.js";
+export declare function registerMarketTools(server: McpServer, clientWrapper: ClobClientWrapper): void;

package/build/tools/markets.js

@@ -0,0 +1,128 @@
+import { z } from "zod";
+const GetMarketsSchema = z.object({
+    limit: z.number().min(1).max(100).optional().default(10),
+    offset: z.number().min(0).optional().default(0),
+    search: z.string().optional(),
+});
+const GetMarketSchema = z.object({
+    condition_id: z.string().min(1),
+});
+async function fetchGammaMarkets(clientWrapper, limit, offset, search) {
+    const baseUrl = clientWrapper.getGammaApiUrl();
+    const params = new URLSearchParams({
+        limit: limit.toString(),
+        offset: offset.toString(),
+        active: "true",
+    });
+    if (search) {
+        params.set("slug_contains", search.toLowerCase());
+    }
+    const url = `${baseUrl}/markets?${params.toString()}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch markets: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return Array.isArray(data) ? data : [];
+}
+async function fetchGammaMarket(clientWrapper, conditionId) {
+    const baseUrl = clientWrapper.getGammaApiUrl();
+    const url = `${baseUrl}/markets/${conditionId}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        if (response.status === 404) {
+            return null;
+        }
+        throw new Error(`Failed to fetch market: ${response.statusText}`);
+    }
+    return await response.json();
+}
+function formatMarket(market) {
+    const tokens = [];
+    const outcomes = market.outcomes || ["Yes", "No"];
+    const prices = market.outcomePrices || [];
+    const tokenIds = market.clobTokenIds || [];
+    for (let i = 0; i < outcomes.length; i++) {
+        tokens.push({
+            token_id: tokenIds[i] || "",
+            outcome: outcomes[i],
+            price: prices[i] ? parseFloat(prices[i]) : 0,
+        });
+    }
+    return {
+        condition_id: market.conditionId,
+        question: market.question,
+        tokens,
+        volume: market.volume || "0",
+        end_date: market.endDate || "",
+        active: market.active,
+        closed: market.closed,
+    };
+}
+export function registerMarketTools(server, clientWrapper) {
+    server.tool("polymarket_get_markets", "List available prediction markets on Polymarket. Returns market question, current prices for Yes/No outcomes, and trading volume.", GetMarketsSchema.shape, async (args) => {
+        try {
+            const { limit, offset, search } = GetMarketsSchema.parse(args);
+            const markets = await fetchGammaMarkets(clientWrapper, limit, offset, search);
+            const formatted = markets.map(formatMarket);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(formatted, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error fetching markets: ${message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("polymarket_get_market", "Get detailed information about a specific prediction market including token IDs, current prices, and market status.", GetMarketSchema.shape, async (args) => {
+        try {
+            const { condition_id } = GetMarketSchema.parse(args);
+            const market = await fetchGammaMarket(clientWrapper, condition_id);
+            if (!market) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Market not found: ${condition_id}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const formatted = formatMarket(market);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(formatted, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error fetching market: ${message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/build/tools/orderbook.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ClobClientWrapper } from "../client.js";
+export declare function registerOrderbookTools(server: McpServer, clientWrapper: ClobClientWrapper): void;

package/build/tools/orderbook.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+const GetOrderbookSchema = z.object({
+    token_id: z.string().min(1),
+});
+function formatOrderbook(tokenId, rawOrderbook) {
+    const formatEntries = (entries) => {
+        if (!entries)
+            return [];
+        return entries.map((e) => ({
+            price: e.price,
+            size: e.size,
+        }));
+    };
+    return {
+        token_id: tokenId,
+        bids: formatEntries(rawOrderbook.bids),
+        asks: formatEntries(rawOrderbook.asks),
+    };
+}
+export function registerOrderbookTools(server, clientWrapper) {
+    server.tool("polymarket_get_orderbook", "Get the order book for a specific token showing current bids and asks with prices and sizes.", GetOrderbookSchema.shape, async (args) => {
+        try {
+            const { token_id } = GetOrderbookSchema.parse(args);
+            const client = clientWrapper.getClient();
+            const orderbook = await client.getOrderBook(token_id);
+            const formatted = formatOrderbook(token_id, orderbook);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(formatted, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error fetching orderbook: ${message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/build/tools/trading.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ClobClientWrapper } from "../client.js";
+export declare function registerTradingTools(server: McpServer, clientWrapper: ClobClientWrapper, includeWriteTools: boolean): void;

package/build/tools/trading.js

@@ -0,0 +1,173 @@
+import { z } from "zod";
+import { Side as ClobSide } from "@polymarket/clob-client";
+const PlaceOrderSchema = z.object({
+    token_id: z.string().min(1),
+    side: z.enum(["BUY", "SELL"]),
+    size: z.string().refine((val) => {
+        const num = parseFloat(val);
+        return !isNaN(num) && num > 0;
+    }, "Size must be a positive number"),
+    price: z.string().refine((val) => {
+        const num = parseFloat(val);
+        return !isNaN(num) && num > 0 && num < 1;
+    }, "Price must be between 0 and 1 (exclusive)"),
+});
+const CancelOrderSchema = z.object({
+    order_id: z.string().min(1),
+});
+const GetTradesSchema = z.object({
+    limit: z.number().min(1).max(100).optional().default(20),
+});
+async function getMarketInfoForToken(clientWrapper, tokenId) {
+    const client = clientWrapper.getClient();
+    try {
+        // The CLOB client should have a method to get market info
+        const marketInfo = (await client.getMarket(tokenId));
+        return {
+            tickSize: marketInfo.minimum_tick_size || 0.01,
+            negRisk: marketInfo.neg_risk || false,
+        };
+    }
+    catch {
+        // Default values if we can't fetch market info
+        return {
+            tickSize: 0.01,
+            negRisk: false,
+        };
+    }
+}
+function mapSide(side) {
+    return side === "BUY" ? ClobSide.BUY : ClobSide.SELL;
+}
+export function registerTradingTools(server, clientWrapper, includeWriteTools) {
+    // Get trades is always available (read-only)
+    server.tool("polymarket_get_trades", "Get recent executed trades for the configured wallet.", GetTradesSchema.shape, async (args) => {
+        try {
+            const { limit } = GetTradesSchema.parse(args);
+            const client = clientWrapper.getClient();
+            const allTrades = (await client.getTrades({}));
+            const trades = (allTrades || []).slice(0, limit);
+            const formatted = trades.map((t) => ({
+                id: t.id,
+                token_id: t.asset_id,
+                side: t.side,
+                price: t.price,
+                size: t.size,
+                timestamp: t.timestamp || t.match_time || "",
+                status: t.status,
+            }));
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(formatted, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error fetching trades: ${message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Only register write tools if not in readonly mode
+    if (!includeWriteTools) {
+        console.error("Readonly mode: trading tools (place_order, cancel_order) disabled");
+        return;
+    }
+    server.tool("polymarket_place_order", "Place a limit order on Polymarket. CAUTION: This executes a real trade with real funds. Price must be between 0 and 1, size in shares.", PlaceOrderSchema.shape, async (args) => {
+        try {
+            clientWrapper.ensureWriteAccess();
+            const { token_id, side, size, price } = PlaceOrderSchema.parse(args);
+            const client = clientWrapper.getClient();
+            // Get market info for tick size and neg risk
+            const { tickSize, negRisk } = await getMarketInfoForToken(clientWrapper, token_id);
+            // Create the order
+            const orderArgs = {
+                tokenID: token_id,
+                side: mapSide(side),
+                size: parseFloat(size),
+                price: parseFloat(price),
+                feeRateBps: 0,
+            };
+            const signedOrder = await client.createOrder(orderArgs);
+            // Post the order
+            const response = (await client.postOrder(signedOrder));
+            const result = {
+                order_id: response.orderID || "",
+                status: response.status || "unknown",
+                message: response.errorMsg,
+            };
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            ...result,
+                            order_details: {
+                                token_id,
+                                side,
+                                size,
+                                price,
+                                tick_size: tickSize,
+                                neg_risk: negRisk,
+                            },
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error placing order: ${message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("polymarket_cancel_order", "Cancel an existing order on Polymarket.", CancelOrderSchema.shape, async (args) => {
+        try {
+            clientWrapper.ensureWriteAccess();
+            const { order_id } = CancelOrderSchema.parse(args);
+            const client = clientWrapper.getClient();
+            const response = await client.cancelOrder({ orderID: order_id });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            order_id,
+                            status: "cancelled",
+                            response,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error cancelling order: ${message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/build/types.d.ts

@@ -0,0 +1,51 @@
+export interface TokenInfo {
+    token_id: string;
+    outcome: string;
+    price: number;
+}
+export interface MarketInfo {
+    condition_id: string;
+    question: string;
+    tokens: TokenInfo[];
+    volume: string;
+    end_date: string;
+    active: boolean;
+    closed: boolean;
+}
+export interface OrderbookEntry {
+    price: string;
+    size: string;
+}
+export interface OrderbookInfo {
+    bids: OrderbookEntry[];
+    asks: OrderbookEntry[];
+    token_id: string;
+}
+export interface Position {
+    token_id: string;
+    market: string;
+    outcome: string;
+    size: string;
+    avg_price: string;
+    current_price: string;
+    pnl: string;
+}
+export interface TradeInfo {
+    id: string;
+    token_id: string;
+    side: string;
+    price: string;
+    size: string;
+    timestamp: string;
+    status: string;
+}
+export interface BalanceInfo {
+    balance: string;
+    allowance: string;
+}
+export interface OrderResult {
+    order_id: string;
+    status: string;
+    message?: string;
+}
+export type Side = "BUY" | "SELL";

package/build/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@c0pilot/mcp-polymarket",
+  "version": "1.0.0",
+  "description": "MCP server and client library for Polymarket prediction markets - trade, browse markets, manage positions",
+  "type": "module",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
+    },
+    "./client": {
+      "types": "./build/client.d.ts",
+      "default": "./build/client.js"
+    },
+    "./config": {
+      "types": "./build/config.d.ts",
+      "default": "./build/config.js"
+    },
+    "./types": {
+      "types": "./build/types.d.ts",
+      "default": "./build/types.js"
+    }
+  },
+  "bin": {
+    "mcp-polymarket": "./build/index.js"
+  },
+  "files": [
+    "build",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc && chmod 755 build/index.js",
+    "start": "node build/index.js",
+    "test": "vitest run",
+    "test:e2e": "vitest run e2e",
+    "clean": "rm -rf build",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "polymarket",
+    "prediction-markets",
+    "trading",
+    "crypto",
+    "clob",
+    "model-context-protocol"
+  ],
+  "author": "unsanction",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/unsanction/mcp-polymarket"
+  },
+  "homepage": "https://github.com/unsanction/mcp-polymarket#readme",
+  "bugs": {
+    "url": "https://github.com/unsanction/mcp-polymarket/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@polymarket/clob-client": "^5.2.1",
+    "ethers": "^6.16.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "dotenv": "^17.2.3",
+    "typescript": "^5.0.0",
+    "vitest": "^4.0.18"
+  }
+}