polymarket-dvm-mcp 1.0.0

package/README.md

@@ -0,0 +1,78 @@
+# Polymarket DVM MCP Server
+
+A Model Context Protocol (MCP) server that interfaces with the Polymarket Data Verification Mechanism (DVM) via Nostr. This server allows AI agents to search for prediction markets and obtain detailed AI summaries.
+
+## Features
+
+- **Search Markets**: Search for prediction markets on Polymarket using keywords.
+- **AI Summary**: Get deep market analysis and AI-generated summaries for specific markets using their numerical IDs.
+- **Payment Handling**: Seamlessly handles Nostr DVM feedback (Kind 7000), providing lightning invoices when payment is required for searches or summaries.
+- **NDK Integration**: Uses the Nostr Dev Kit (NDK) for robust Nostr communication.
+
+## Prerequisites
+
+- Node.js (v18 or higher)
+- npm or yarn
+
+## Installation
+
+1. Clone the repository and navigate to the project directory.
+2. Install dependencies:
+   ```bash
+   npm install
+   ```
+3. Build the project:
+   ```bash
+   npm run build
+   ```
+
+## Configuration
+
+The server can be configured via environment variables:
+
+- `NOSTR_NSEC`: (Optional) Your Nostr private key in `nsec` format. If not provided, a random identity will be generated for each session.
+
+## Usage
+
+### Running the Server
+
+Start the server using `ts-node`:
+```bash
+npm start
+```
+
+Or run the compiled JavaScript (after building):
+```bash
+npm run serve
+```
+
+### MCP Tools
+
+The server exposes the following tools to MCP clients (like Claude Desktop):
+
+1. **`search_polymarket`**
+   - **Description**: Search for prediction markets. Returns markets with their questions and IDs.
+   - **Arguments**: `query` (string)
+   - **Note**: May return a lightning invoice during high utilization.
+
+2. **`get_market`**
+   - **Description**: Get a detailed AI summary for a specific market.
+   - **Arguments**: `marketId` (string, the numerical ID from search results)
+   - **Note**: Usually requires payment via lightning invoice.
+
+## Deployment with Docker
+
+You can run the MCP server using Docker:
+
+1. Build the image:
+   ```bash
+   docker build -t polymarket-dvm-mcp .
+   ```
+2. Run the container:
+   ```bash
+   docker run -i -e NOSTR_NSEC=your_nsec_here polymarket-dvm-mcp
+   ```
+
+## Security Note
+
+Your `nsec` is sensitive information. Never commit it to version control. Use environment variables to pass it safely to the application.

package/dist/index.js

@@ -0,0 +1,146 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { NostrClient } from "./ndk.js";
+import { NDKPrivateKeySigner } from "@nostr-dev-kit/ndk";
+const server = new Server({
+    name: "polymarket-dvm-mcp",
+    version: "0.1.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Helper for structured logging to stderr (to avoid interfering with MCP stdio)
+const log = (level, message, data) => {
+    const timestamp = new Date().toISOString();
+    console.error(JSON.stringify({ timestamp, level, message, data }));
+};
+const nsec = process.env.NOSTR_NSEC;
+let signer;
+if (nsec) {
+    try {
+        if (!nsec.startsWith('nsec1')) {
+            throw new Error("Invalid nsec format. Must start with 'nsec1'");
+        }
+        signer = new NDKPrivateKeySigner(nsec);
+        log("INFO", "Nostr identity loaded from NOSTR_NSEC");
+    }
+    catch (e) {
+        log("ERROR", `Failed to initialize Nostr signer: ${e.message}`);
+        process.exit(1);
+    }
+}
+else {
+    log("INFO", "No NOSTR_NSEC provided, generating random identity");
+    signer = NDKPrivateKeySigner.generate();
+}
+const nostrClient = new NostrClient(signer);
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "search_polymarket",
+                description: "Search for prediction markets on Polymarket. Returns a list of markets with their questions, descriptions, and numerical 'id' values. Use these numerical IDs to call 'get_market' for detailed analysis. Note: May return a JSON object with a lightning invoice if payment is required due to high utilization.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: {
+                            type: "string",
+                            description: "The search term or question to search for (e.g., 'Will Bitcoin hit $100k?').",
+                        },
+                    },
+                    required: ["query"],
+                },
+            },
+            {
+                name: "get_market",
+                description: "Get a detailed AI summary and deep market analysis for a specific Polymarket event. Requires a numerical market 'id' obtained from 'search_polymarket'. If the DVM requires payment for the AI summary, this tool will return a lightning invoice to be paid before the summary is provided.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        marketId: {
+                            type: "string",
+                            description: "The numerical market ID from search results (e.g., '956590').",
+                        },
+                    },
+                    required: ["marketId"],
+                },
+            },
+        ],
+    };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        log("DEBUG", `Connecting to Nostr relays for tool: ${name}`);
+        await nostrClient.connect();
+        if (name === "search_polymarket") {
+            const query = String(args?.query);
+            log("INFO", "Performing Polymarket search", { query });
+            const result = await nostrClient.requestSearch(query);
+            if ("status" in result && result.status === "payment-required") {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Payment required to perform this search due to high utilization.\n\nAmount: ${result.amount}\nInvoice: ${result.invoice}\n\nPlease pay the invoice and call this tool again once paid.`,
+                        },
+                    ],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        if (name === "get_market") {
+            const marketId = String(args?.marketId);
+            log("INFO", "Fetching market summary", { marketId });
+            const result = await nostrClient.requestSummary(marketId);
+            if ("status" in result && result.status === "payment-required") {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Payment required to access this summary.\n\nAmount: ${result.amount}\nInvoice: ${result.invoice}\n\nPlease pay the invoice and call this tool again once paid.`,
+                        },
+                    ],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        throw new Error(`Unknown tool: ${name}`);
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Polymarket DVM MCP server running on stdio");
+}
+main().catch((error) => {
+    console.error("Server error:", error);
+    process.exit(1);
+});

package/dist/ndk.js

@@ -0,0 +1,94 @@
+import NDK, { NDKEvent, NDKPrivateKeySigner } from '@nostr-dev-kit/ndk';
+import WebSocket from 'ws';
+// Required for NDK in Node.js
+// @ts-ignore
+global.WebSocket = WebSocket;
+export const DVM_PUBKEY = '813c654f1b7a4996c8f4769079288a0eace4380dd55e71949116100759b9dddc';
+export const RELAYS = ['wss://relay.damus.io', 'wss://nos.lol', 'wss://relay.primal.net'];
+export const KIND_SEARCH_REQUEST = 5005;
+export const KIND_SEARCH_RESULT = 6005;
+export const KIND_SUMMARY_REQUEST = 5001;
+export const KIND_SUMMARY_RESULT = 6001;
+export const KIND_FEEDBACK = 7000;
+export class NostrClient {
+    ndk;
+    constructor(signer) {
+        this.ndk = new NDK({
+            explicitRelayUrls: RELAYS,
+            signer: signer || NDKPrivateKeySigner.generate(),
+        });
+    }
+    async connect() {
+        await this.ndk.connect();
+        console.error('Connected to relays');
+    }
+    async requestSearch(query) {
+        const event = new NDKEvent(this.ndk);
+        event.kind = KIND_SEARCH_REQUEST;
+        event.content = query;
+        event.tags = [
+            ['p', DVM_PUBKEY],
+            ['i', query],
+        ];
+        await event.publish();
+        return await this.waitForDVM(event, [KIND_SEARCH_RESULT, KIND_FEEDBACK]);
+    }
+    async requestSummary(marketId) {
+        const event = new NDKEvent(this.ndk);
+        event.kind = KIND_SUMMARY_REQUEST;
+        event.content = marketId;
+        event.tags = [
+            ['p', DVM_PUBKEY],
+            ['i', marketId],
+        ];
+        await event.publish();
+        return this.waitForDVM(event, [KIND_SUMMARY_RESULT, KIND_FEEDBACK]);
+    }
+    async waitForDVM(requestEvent, kinds, timeoutMs = 60000) {
+        return new Promise((resolve, reject) => {
+            let resolved = false;
+            const filter = {
+                kinds: kinds,
+                '#e': [requestEvent.id],
+                authors: [DVM_PUBKEY],
+            };
+            const timeout = setTimeout(() => {
+                if (!resolved) {
+                    resolved = true;
+                    sub.stop();
+                    reject(new Error(`Timeout waiting for DVM response (Event ID: ${requestEvent.id})`));
+                }
+            }, timeoutMs);
+            const sub = this.ndk.subscribe(filter, { closeOnEose: false });
+            sub.on('event', (event) => {
+                if (resolved)
+                    return;
+                resolved = true;
+                clearTimeout(timeout);
+                sub.stop();
+                try {
+                    if (event.kind === KIND_FEEDBACK) {
+                        const statusTag = event.tags.find(t => t[0] === 'status');
+                        const amountTag = event.tags.find(t => t[0] === 'amount');
+                        resolve({
+                            status: statusTag ? statusTag[1] : 'unknown',
+                            amount: amountTag ? amountTag[1] : undefined,
+                            invoice: amountTag ? amountTag[2] : undefined,
+                            content: event.content
+                        });
+                    }
+                    else {
+                        resolve(JSON.parse(event.content));
+                    }
+                }
+                catch (e) {
+                    reject(new Error(`Failed to parse DVM response: ${e}`));
+                }
+            });
+        });
+    }
+    async close() {
+        // NDK doesn't have a direct close, but we can stop all subs if needed.
+        // Relays are handled by NDK internally.
+    }
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "polymarket-dvm-mcp",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "start": "ts-node src/index.ts",
+    "build": "tsc",
+    "serve": "node dist/index.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@nostr-dev-kit/ndk": "^3.0.0",
+    "@types/node": "^25.2.3",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3",
+    "ws": "^8.19.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.18.1"
+  }
+}