bcap-x402-mcp 1.0.0

package/build/index.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import axios, { AxiosError } from "axios";
+import { x402Client, wrapAxiosWithPayment } from "@x402/axios";
+import { ExactEvmScheme } from "@x402/evm/exact/client";
+import { toClientEvmSigner } from "@x402/evm";
+import { ExactSvmScheme } from "@x402/svm/exact/client";
+import { privateKeyToAccount } from "viem/accounts";
+import { createPublicClient, http } from "viem";
+import { base, baseSepolia } from "viem/chains";
+import { createKeyPairSignerFromBytes } from "@solana/signers";
+import { base58 } from "@scure/base";
+import { z } from "zod";
+const evmPrivateKey = process.env.EVM_PRIVATE_KEY;
+const svmPrivateKey = process.env.SVM_PRIVATE_KEY;
+const baseURL = process.env.RESOURCE_SERVER_URL || "http://localhost:3001";
+const network = process.env.NETWORK || "testnet"; // "mainnet" or "testnet"
+if (!evmPrivateKey && !svmPrivateKey) {
+    console.error("At least one of EVM_PRIVATE_KEY or SVM_PRIVATE_KEY must be provided");
+    process.exit(1);
+}
+function getEvmChain() {
+    return network === "mainnet" ? base : baseSepolia;
+}
+async function createPaymentClient() {
+    const client = new x402Client();
+    if (evmPrivateKey) {
+        const account = privateKeyToAccount(evmPrivateKey);
+        const publicClient = createPublicClient({
+            chain: getEvmChain(),
+            transport: http(),
+        });
+        const evmSigner = toClientEvmSigner(account, publicClient);
+        client.register("eip155:*", new ExactEvmScheme(evmSigner));
+    }
+    if (svmPrivateKey) {
+        const svmSigner = await createKeyPairSignerFromBytes(base58.decode(svmPrivateKey));
+        client.register("solana:*", new ExactSvmScheme(svmSigner));
+    }
+    return wrapAxiosWithPayment(axios.create({ baseURL }), client);
+}
+/** Format an error into a text content response for the agent */
+function errorResponse(err) {
+    let message;
+    if (err instanceof AxiosError) {
+        const status = err.response?.status;
+        const data = err.response?.data;
+        message = `HTTP ${status}: ${JSON.stringify(data ?? err.message)}`;
+    }
+    else if (err instanceof Error) {
+        message = err.message;
+    }
+    else {
+        message = String(err);
+    }
+    return {
+        content: [{ type: "text", text: message }],
+        isError: true,
+    };
+}
+async function main() {
+    const api = await createPaymentClient();
+    const server = new McpServer({
+        name: "bcap-x402",
+        version: "1.0.0",
+    });
+    // --- Tools ---
+    server.registerTool("get_metrics", {
+        title: "Get Metrics",
+        description: "Get service metrics: total tweets posted, current cost per tweet in USD, accepted payment networks, and estimated waiting time in seconds.",
+        inputSchema: {},
+    }, async () => {
+        try {
+            const res = await api.get("/metrics");
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(res.data) },
+                ],
+            };
+        }
+        catch (err) {
+            return errorResponse(err);
+        }
+    });
+    server.registerTool("check_tweet_exists", {
+        title: "Check Tweet Exists",
+        description: "Check if a tweet with the given text has already been posted (duplicate detection). Returns { exists: boolean }.",
+        inputSchema: {
+            text: z.string().describe("The tweet text to check for duplicates"),
+        },
+    }, async ({ text }) => {
+        try {
+            const res = await api.post("/tweet-exists", { text });
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(res.data) },
+                ],
+            };
+        }
+        catch (err) {
+            return errorResponse(err);
+        }
+    });
+    server.registerTool("post_tweet", {
+        title: "Post Tweet",
+        description: `Submit a tweet for posting. This endpoint is x402 payment-gated — payment is handled automatically using the configured wallet.
+
+On success the tweet is queued for admin approval (status 202). Returns queue_id and status.`,
+        inputSchema: {
+            text: z
+                .string()
+                .describe("The tweet text content (max 280 characters)"),
+            image_id: z
+                .string()
+                .optional()
+                .describe("Optional image ID from a previous upload_image call"),
+        },
+    }, async ({ text, image_id }) => {
+        try {
+            const body = { text };
+            if (image_id) {
+                body.image_id = image_id;
+            }
+            const res = await api.post("/post-tweet", body);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(res.data) },
+                ],
+            };
+        }
+        catch (err) {
+            return errorResponse(err);
+        }
+    });
+    server.registerTool("upload_image", {
+        title: "Upload Image",
+        description: "Upload a base64-encoded image to attach to a future tweet. Returns an image_id to pass to post_tweet.",
+        inputSchema: {
+            image_base64: z.string().describe("Base64-encoded image data"),
+            filename: z
+                .string()
+                .optional()
+                .describe("Filename with extension (e.g. photo.png). Determines media type. Defaults to image.png."),
+        },
+    }, async ({ image_base64, filename }) => {
+        try {
+            const name = filename || "image.png";
+            const imageBuffer = Buffer.from(image_base64, "base64");
+            const ext = name.split(".").pop()?.toLowerCase() || "png";
+            const mimeMap = {
+                jpg: "image/jpeg",
+                jpeg: "image/jpeg",
+                png: "image/png",
+                gif: "image/gif",
+                webp: "image/webp",
+                mp4: "video/mp4",
+            };
+            const mime = mimeMap[ext] || "image/png";
+            const form = new FormData();
+            form.append("image", new Blob([imageBuffer], { type: mime }), name);
+            const res = await api.post("/upload-image", form);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(res.data) },
+                ],
+            };
+        }
+        catch (err) {
+            return errorResponse(err);
+        }
+    });
+    // --- Connect ---
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("bcap-x402 MCP server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "bcap-x402-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for Blockchain Capital's x402 payment-gated tweet API",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ARAIDevHub/bcap-x402-backend",
+    "directory": "mcp"
+  },
+  "keywords": ["mcp", "x402", "blockchain", "payments", "twitter"],
+  "bin": {
+    "bcap-x402-mcp": "./build/index.js"
+  },
+  "scripts": {
+    "build": "tsc && chmod 755 build/index.js",
+    "prepublishOnly": "npm run build",
+    "start": "node build/index.js"
+  },
+  "files": ["build"],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.0",
+    "@x402/axios": "^2.6.0",
+    "@x402/evm": "^2.6.0",
+    "@x402/svm": "^2.6.0",
+    "@solana/signers": "^5.5.0",
+    "@scure/base": "^1.2.6",
+    "axios": "^1.13.2",
+    "viem": "^2.39.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  }
+}