@c0pilot/mcp-polymarket 1.0.2 → 1.0.3

package/build/client.d.ts

@@ -10,6 +10,7 @@ export declare class ClobClientWrapper {
     ensureWriteAccess(): void;
     getGammaApiUrl(): string;
     getClobApiUrl(): string;
+    getDataApiUrl(): string;
     getFunder(): string;
 }
 export declare function getClientWrapper(): Promise<ClobClientWrapper>;

package/build/client.js

@@ -3,6 +3,7 @@ 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";
+const DATA_API_URL = "https://data-api.polymarket.com";
 export class ClobClientWrapper {
     client = null;
     config;
@@ -67,6 +68,9 @@ export class ClobClientWrapper {
     getClobApiUrl() {
         return CLOB_API_URL;
     }
+    getDataApiUrl() {
+        return DATA_API_URL;
+    }
     getFunder() {
         return this.config.funder;
     }

package/build/tools/account.js

@@ -1,13 +1,41 @@
 import { z } from "zod";
 import { AssetType } from "@polymarket/clob-client";
 const GetBalanceSchema = z.object({});
-const GetPositionsSchema = z.object({});
+const GetPositionsSchema = z.object({
+    redeemable: z.boolean().optional().default(false),
+    market: z.string().optional(),
+    limit: z.number().min(1).max(500).optional().default(100),
+});
+const UpdateAllowanceSchema = z.object({});
+async function fetchPositions(clientWrapper, redeemable, market, limit = 100) {
+    const baseUrl = clientWrapper.getDataApiUrl();
+    const funder = clientWrapper.getFunder();
+    const params = new URLSearchParams({
+        user: funder,
+        sizeThreshold: "0",
+        limit: limit.toString(),
+        sortBy: "CURRENT",
+        sortDirection: "DESC",
+    });
+    if (redeemable) {
+        params.set("redeemable", "true");
+    }
+    if (market) {
+        params.set("market", market);
+    }
+    const url = `${baseUrl}/positions?${params.toString()}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch positions: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return Array.isArray(data) ? data : [];
+}
 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,
             });
@@ -40,55 +68,80 @@ export function registerAccountTools(server, clientWrapper) {
             };
         }
     });
-    server.tool("polymarket_get_positions", "Get all open orders and positions for the configured wallet, including P&L calculations.", GetPositionsSchema.shape, async () => {
+    server.tool("polymarket_get_positions", `Get real positions (token holdings) for the configured wallet from Polymarket Data API.
+
+Returns actual token balances with P&L, not just open orders.
+
+**Parameters:**
+- redeemable: Filter to only show redeemable (resolved) positions (default: false)
+- market: Filter by condition ID (optional)
+- limit: Max results 1-500 (default: 100)
+
+**Response includes:**
+- token_id, condition_id, outcome, size, avg_price, current_price
+- pnl (cash P&L), pnl_percent
+- redeemable/mergeable flags
+- market title, slug, end_date`, GetPositionsSchema.shape, async (args) => {
         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,
+            const { redeemable, market, limit } = GetPositionsSchema.parse(args);
+            const positions = await fetchPositions(clientWrapper, redeemable, market, limit);
+            const formatted = positions.map((p) => ({
+                token_id: p.asset,
+                condition_id: p.conditionId,
+                market: p.title || "Unknown",
+                outcome: p.outcome || "Unknown",
+                size: p.size,
+                avg_price: p.avgPrice,
+                current_price: p.curPrice,
+                pnl: p.cashPnl,
+                pnl_percent: p.percentPnl,
+                redeemable: p.redeemable,
+                mergeable: p.mergeable,
+                slug: p.slug || "",
+                end_date: p.endDate || "",
             }));
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ positions: formatted, count: formatted.length }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error fetching positions: ${message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("polymarket_update_allowance", `Trigger a refresh of the USDC allowance for trading on Polymarket.
+
+Use this when orders fail due to insufficient allowance. This tells the CLOB server to re-check and update the on-chain allowance state.`, UpdateAllowanceSchema.shape, async () => {
+        try {
+            const client = clientWrapper.getClient();
+            await client.updateBalanceAllowance({
+                asset_type: AssetType.COLLATERAL,
+            });
+            // Fetch updated balance to confirm
+            const balanceData = await client.getBalanceAllowance({
+                asset_type: AssetType.COLLATERAL,
+            });
             return {
                 content: [
                     {
                         type: "text",
                         text: JSON.stringify({
-                            positions,
-                            open_orders: formattedOrders,
+                            status: "updated",
+                            balance: balanceData.balance || "0",
+                            allowance: balanceData.allowance || "0",
                         }, null, 2),
                     },
                 ],
@@ -100,7 +153,7 @@ export function registerAccountTools(server, clientWrapper) {
                 content: [
                     {
                         type: "text",
-                        text: `Error fetching positions: ${message}`,
+                        text: `Error updating allowance: ${message}`,
                     },
                 ],
                 isError: true,

package/build/tools/markets.js

@@ -5,7 +5,8 @@ const GetMarketsSchema = z.object({
     search: z.string().optional(),
 });
 const GetMarketSchema = z.object({
-    condition_id: z.string().min(1),
+    condition_id: z.string().optional(),
+    slug: z.string().optional(),
 });
 async function fetchGammaMarkets(clientWrapper, limit, offset, search) {
     const baseUrl = clientWrapper.getGammaApiUrl();
@@ -37,6 +38,22 @@ async function fetchGammaMarket(clientWrapper, conditionId) {
     }
     return await response.json();
 }
+async function fetchGammaMarketBySlug(clientWrapper, slug) {
+    const baseUrl = clientWrapper.getGammaApiUrl();
+    const params = new URLSearchParams({
+        slug: slug,
+        limit: "1",
+    });
+    const url = `${baseUrl}/markets?${params.toString()}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch market by slug: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (!Array.isArray(data) || data.length === 0)
+        return null;
+    return data[0];
+}
 function formatMarket(market) {
     const tokens = [];
     const outcomes = market.outcomes || ["Yes", "No"];
@@ -87,16 +104,35 @@ export function registerMarketTools(server, clientWrapper) {
             };
         }
     });
-    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) => {
+    server.tool("polymarket_get_market", `Get detailed information about a specific prediction market including token IDs, current prices, and market status.
+
+Provide either condition_id or slug to look up a market.`, GetMarketSchema.shape, async (args) => {
         try {
-            const { condition_id } = GetMarketSchema.parse(args);
-            const market = await fetchGammaMarket(clientWrapper, condition_id);
+            const { condition_id, slug } = GetMarketSchema.parse(args);
+            if (!condition_id && !slug) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Either condition_id or slug is required",
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            let market = null;
+            if (condition_id) {
+                market = await fetchGammaMarket(clientWrapper, condition_id);
+            }
+            else if (slug) {
+                market = await fetchGammaMarketBySlug(clientWrapper, slug);
+            }
             if (!market) {
                 return {
                     content: [
                         {
                             type: "text",
-                            text: `Market not found: ${condition_id}`,
+                            text: `Market not found: ${condition_id || slug}`,
                         },
                     ],
                     isError: true,

package/build/tools/trading.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { Side as ClobSide } from "@polymarket/clob-client";
+import { Side as ClobSide, OrderType } from "@polymarket/clob-client";
 const PlaceOrderSchema = z.object({
     token_id: z.string().min(1),
     side: z.enum(["BUY", "SELL"]),
@@ -12,6 +12,15 @@ const PlaceOrderSchema = z.object({
         return !isNaN(num) && num > 0 && num < 1;
     }, "Price must be between 0 and 1 (exclusive)"),
 });
+const PlaceMarketOrderSchema = z.object({
+    token_id: z.string().min(1),
+    side: z.enum(["BUY", "SELL"]),
+    amount: z.string().refine((val) => {
+        const num = parseFloat(val);
+        return !isNaN(num) && num > 0;
+    }, "Amount must be a positive number"),
+    order_type: z.enum(["FOK", "FAK"]).optional().default("FOK"),
+});
 const CancelOrderSchema = z.object({
     order_id: z.string().min(1),
 });
@@ -21,7 +30,6 @@ const GetTradesSchema = z.object({
 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,
@@ -29,7 +37,6 @@ async function getMarketInfoForToken(clientWrapper, tokenId) {
         };
     }
     catch {
-        // Default values if we can't fetch market info
         return {
             tickSize: 0.01,
             negRisk: false,
@@ -80,7 +87,7 @@ export function registerTradingTools(server, clientWrapper, includeWriteTools) {
     });
     // Only register write tools if not in readonly mode
     if (!includeWriteTools) {
-        console.error("Readonly mode: trading tools (place_order, cancel_order) disabled");
+        console.error("Readonly mode: trading tools (place_order, cancel_order, etc.) 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) => {
@@ -138,6 +145,65 @@ export function registerTradingTools(server, clientWrapper, includeWriteTools) {
             };
         }
     });
+    server.tool("polymarket_place_market_order", `Place a market order on Polymarket for immediate execution.
+
+CAUTION: This executes a REAL trade with REAL funds at market price!
+
+**Parameters:**
+- token_id: The token to trade
+- side: "BUY" or "SELL"
+- amount: For BUY — USD amount to spend. For SELL — number of shares to sell.
+- order_type: "FOK" (Fill or Kill, default) or "FAK" (Fill and Kill — allows partial fills)
+
+**Examples:**
+- BUY $10 worth of Yes tokens: side="BUY", amount="10"
+- SELL 5 shares at market: side="SELL", amount="5"`, PlaceMarketOrderSchema.shape, async (args) => {
+        try {
+            clientWrapper.ensureWriteAccess();
+            const { token_id, side, amount, order_type } = PlaceMarketOrderSchema.parse(args);
+            const client = clientWrapper.getClient();
+            const marketOrderType = order_type === "FAK" ? OrderType.FAK : OrderType.FOK;
+            const orderArgs = {
+                tokenID: token_id,
+                side: mapSide(side),
+                amount: parseFloat(amount),
+                orderType: marketOrderType,
+            };
+            const signedOrder = await client.createMarketOrder(orderArgs);
+            const response = (await client.postOrder(signedOrder, orderArgs.orderType));
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            order_id: response.orderID || "",
+                            status: response.status || "unknown",
+                            message: response.errorMsg,
+                            order_details: {
+                                token_id,
+                                side,
+                                amount,
+                                order_type,
+                                type: "MARKET",
+                            },
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error placing market order: ${message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
     server.tool("polymarket_cancel_order", "Cancel an existing order on Polymarket.", CancelOrderSchema.shape, async (args) => {
         try {
             clientWrapper.ensureWriteAccess();

package/build/types.d.ts

@@ -29,6 +29,12 @@ export interface Position {
     avg_price: string;
     current_price: string;
     pnl: string;
+    pnl_percent: string;
+    redeemable: boolean;
+    mergeable: boolean;
+    condition_id: string;
+    slug: string;
+    end_date: string;
 }
 export interface TradeInfo {
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c0pilot/mcp-polymarket",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "MCP server and client library for Polymarket prediction markets - trade, browse markets, manage positions",
   "type": "module",
   "main": "./build/index.js",