bsv-mcp 0.0.35 → 0.2.0

package/tools/bsocial/bmapFollow.ts

@@ -0,0 +1,125 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { BMAP_URL } from "../constants";
+
+// Schema for reading follows from BMAP API
+const bmapReadFollowsArgsSchema = z.object({
+	bapId: z
+		.string()
+		.describe("BAP identity key to get follow relationships for"),
+	type: z
+		.enum(["followers", "following"])
+		.default("following")
+		.describe("Type of relationship to query"),
+	limit: z
+		.number()
+		.min(1)
+		.max(100)
+		.default(20)
+		.describe("Maximum number of follows to return"),
+	page: z
+		.number()
+		.min(1)
+		.default(1)
+		.describe("Page number for pagination (1-based)"),
+});
+
+type BmapReadFollowsArgs = z.infer<typeof bmapReadFollowsArgsSchema>;
+
+/**
+ * Read follow relationships from BMAP API
+ */
+export async function readBmapFollows(args: BmapReadFollowsArgs): Promise<{
+	success: boolean;
+	data?: unknown;
+	error?: string;
+}> {
+	try {
+		const { bapId, type, limit, page } = args;
+
+		const params = new URLSearchParams();
+		params.append("limit", limit.toString());
+		params.append("page", page.toString());
+
+		const endpoint = type === "followers" ? "followers" : "following";
+		const response = await fetch(
+			`${BMAP_URL}/bap/${bapId}/${endpoint}?${params}`,
+			{
+				method: "GET",
+				headers: {
+					"Content-Type": "application/json",
+				},
+			},
+		);
+
+		if (!response.ok) {
+			const errorText = await response.text();
+			return {
+				success: false,
+				error: `BMAP API request failed: ${response.status} ${errorText}`,
+			};
+		}
+
+		const data = await response.json();
+		return {
+			success: true,
+			data,
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		console.error("Error reading BMAP follows:", errorMessage);
+		return {
+			success: false,
+			error: errorMessage,
+		};
+	}
+}
+
+/**
+ * Register the BMAP read follows tool with the MCP server
+ */
+export function registerBmapReadFollowsTool(server: McpServer) {
+	server.tool(
+		"bmap_readFollows",
+		"Read follow relationships from the BMAP API. Shows who a user is following or who follows them.",
+		{ args: bmapReadFollowsArgsSchema },
+		async ({
+			args,
+		}: {
+			args: BmapReadFollowsArgs;
+		}): Promise<CallToolResult> => {
+			try {
+				const result = await readBmapFollows(args);
+
+				if (result.success) {
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(result.data, null, 2),
+							},
+						],
+						isError: false,
+					};
+				}
+
+				return {
+					content: [
+						{
+							type: "text",
+							text: result.error || "Unknown error occurred",
+						},
+					],
+					isError: true,
+				};
+			} catch (error) {
+				const msg = error instanceof Error ? error.message : String(error);
+				return {
+					content: [{ type: "text", text: `Error: ${msg}` }],
+					isError: true,
+				};
+			}
+		},
+	);
+}

package/tools/bsocial/bmapLikes.ts

@@ -0,0 +1,111 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { BMAP_URL } from "../constants";
+
+// Schema for reading likes from BMAP API
+const bmapReadLikesArgsSchema = z.object({
+	txid: z.string().describe("Transaction ID of the post to get likes for"),
+	limit: z
+		.number()
+		.min(1)
+		.max(100)
+		.default(20)
+		.describe("Maximum number of likes to return"),
+	page: z
+		.number()
+		.min(1)
+		.default(1)
+		.describe("Page number for pagination (1-based)"),
+});
+
+type BmapReadLikesArgs = z.infer<typeof bmapReadLikesArgsSchema>;
+
+/**
+ * Read likes and reactions for a specific post from BMAP API
+ */
+export async function readBmapLikes(args: BmapReadLikesArgs): Promise<{
+	success: boolean;
+	data?: unknown;
+	error?: string;
+}> {
+	try {
+		const { txid, limit, page } = args;
+
+		const params = new URLSearchParams();
+		params.append("limit", limit.toString());
+		params.append("page", page.toString());
+
+		const response = await fetch(`${BMAP_URL}/post/${txid}/like?${params}`, {
+			method: "GET",
+			headers: {
+				"Content-Type": "application/json",
+			},
+		});
+
+		if (!response.ok) {
+			const errorText = await response.text();
+			return {
+				success: false,
+				error: `BMAP API request failed: ${response.status} ${errorText}`,
+			};
+		}
+
+		const data = await response.json();
+		return {
+			success: true,
+			data,
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		console.error("Error reading BMAP likes:", errorMessage);
+		return {
+			success: false,
+			error: errorMessage,
+		};
+	}
+}
+
+/**
+ * Register the BMAP read likes tool with the MCP server
+ */
+export function registerBmapReadLikesTool(server: McpServer) {
+	server.tool(
+		"bmap_readLikes",
+		"Read likes and reactions for a specific post from the BMAP API. Shows who liked the post and what emoji reactions were used.",
+		{ args: bmapReadLikesArgsSchema },
+		async ({ args }: { args: BmapReadLikesArgs }): Promise<CallToolResult> => {
+			try {
+				const result = await readBmapLikes(args);
+
+				if (result.success) {
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(result.data, null, 2),
+							},
+						],
+						isError: false,
+					};
+				}
+
+				return {
+					content: [
+						{
+							type: "text",
+							text: result.error || "Unknown error occurred",
+						},
+					],
+					isError: true,
+				};
+			} catch (error) {
+				const msg = error instanceof Error ? error.message : String(error);
+				return {
+					content: [{ type: "text", text: `Error: ${msg}` }],
+					isError: true,
+				};
+			}
+		},
+	);
+}

package/tools/bsocial/bmapReadPosts.ts

@@ -0,0 +1,148 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { BMAP_URL } from "../constants";
+
+// Schema for reading posts from BMAP API
+const bmapReadPostsArgsSchema = z.object({
+	bapId: z
+		.string()
+		.optional()
+		.describe("BAP identity key to filter posts by author"),
+	txid: z.string().optional().describe("Specific transaction ID to fetch"),
+	limit: z
+		.number()
+		.min(1)
+		.max(100)
+		.default(20)
+		.describe("Maximum number of posts to return"),
+	page: z
+		.number()
+		.min(1)
+		.default(1)
+		.describe("Page number for pagination (1-based)"),
+	feed: z
+		.boolean()
+		.default(false)
+		.describe("Whether to fetch feed (posts from followed users)"),
+	address: z.string().optional().describe("Bitcoin address to filter posts by"),
+});
+
+type BmapReadPostsArgs = z.infer<typeof bmapReadPostsArgsSchema>;
+
+/**
+ * Read social posts from the BMAP API (the query/read layer)
+ */
+export async function readBmapPosts(args: BmapReadPostsArgs): Promise<{
+	success: boolean;
+	data?: unknown;
+	error?: string;
+}> {
+	try {
+		const { bapId, txid, limit, page, feed, address } = args;
+
+		// Handle single post request
+		if (txid) {
+			const response = await fetch(`${BMAP_URL}/post/${txid}`, {
+				method: "GET",
+				headers: {
+					"Content-Type": "application/json",
+				},
+			});
+
+			if (!response.ok) {
+				const errorText = await response.text();
+				return {
+					success: false,
+					error: `BMAP API request failed: ${response.status} ${errorText}`,
+				};
+			}
+
+			const data = await response.json();
+			return {
+				success: true,
+				data,
+			};
+		}
+
+		// Handle posts list request
+		const params = new URLSearchParams();
+		if (bapId) params.append("bapId", bapId);
+		if (address) params.append("address", address);
+		params.append("limit", limit.toString());
+		params.append("page", page.toString());
+		if (feed) params.append("feed", "true");
+
+		const response = await fetch(`${BMAP_URL}/posts?${params}`, {
+			method: "GET",
+			headers: {
+				"Content-Type": "application/json",
+			},
+		});
+
+		if (!response.ok) {
+			const errorText = await response.text();
+			return {
+				success: false,
+				error: `BMAP API request failed: ${response.status} ${errorText}`,
+			};
+		}
+
+		const data = await response.json();
+		return {
+			success: true,
+			data,
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		console.error("Error reading BMAP posts:", errorMessage);
+		return {
+			success: false,
+			error: errorMessage,
+		};
+	}
+}
+
+/**
+ * Register the BMAP read posts tool with the MCP server
+ */
+export function registerBmapReadPostsTool(server: McpServer) {
+	server.tool(
+		"bmap_readPosts",
+		"Read social posts from the BMAP API (query layer). Can fetch posts by author (BAP ID), specific post by transaction ID, or recent posts from all users. Supports pagination and feed functionality.",
+		{ args: bmapReadPostsArgsSchema },
+		async ({ args }: { args: BmapReadPostsArgs }): Promise<CallToolResult> => {
+			try {
+				const result = await readBmapPosts(args);
+
+				if (result.success) {
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(result.data, null, 2),
+							},
+						],
+						isError: false,
+					};
+				}
+
+				return {
+					content: [
+						{
+							type: "text",
+							text: result.error || "Unknown error occurred",
+						},
+					],
+					isError: true,
+				};
+			} catch (error) {
+				const msg = error instanceof Error ? error.message : String(error);
+				return {
+					content: [{ type: "text", text: `Error: ${msg}` }],
+					isError: true,
+				};
+			}
+		},
+	);
+}

package/tools/bsocial/createPost.ts

@@ -0,0 +1,136 @@
+import { Utils } from "@bsv/sdk";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { B_PREFIX, MAP_PREFIX } from "../constants";
+import { signOpReturnWithAIP } from "../utils/aip";
+import { createResponse, formatError } from "../utils/errorHandler";
+import {
+	buildAndSendTransaction,
+	buildOpReturnScript,
+} from "../utils/transactionBuilder";
+import type { Wallet } from "../wallet/wallet";
+
+const { toArray } = Utils;
+
+// Schema for creating a social post
+const createPostArgsSchema = z.object({
+	content: z.string().describe("The content of the post"),
+	contentType: z
+		.enum(["text/plain", "text/markdown"])
+		.default("text/plain")
+		.describe("Content type of the post"),
+	app: z
+		.string()
+		.default("bsv-mcp")
+		.describe("Application name creating the post"),
+	additionalMapData: z
+		.record(z.string())
+		.optional()
+		.describe("Additional MAP protocol key-value pairs"),
+});
+
+type CreatePostArgs = z.infer<typeof createPostArgsSchema>;
+
+/**
+ * Create a social post on the BSV blockchain using B:// and MAP protocols
+ */
+export async function createSocialPost(
+	args: CreatePostArgs,
+	wallet: Wallet,
+): Promise<{
+	success: boolean;
+	txid?: string;
+	rawTx?: string;
+	error?: string;
+}> {
+	try {
+		const { content, contentType, app, additionalMapData } = args;
+
+		// Get wallet info
+		const address = await wallet.getAddress();
+		const paymentKey = wallet.getPaymentKey();
+		if (!paymentKey) {
+			return {
+				success: false,
+				error: "Payment key not available in wallet",
+			};
+		}
+
+		// Prepare file extension based on content type
+		const fileExtension = contentType === "text/markdown" ? "md" : "txt";
+		const fileName = `post.${fileExtension}`;
+
+		// Build B protocol data
+		const bData = [
+			toArray(B_PREFIX, "utf8"),
+			toArray(content, "utf8"),
+			toArray(contentType, "utf8"),
+			toArray("utf-8", "utf8"),
+			toArray(fileName, "utf8"),
+		];
+
+		// Build MAP protocol data
+		const mapData: Uint8Array[] = [
+			toArray(MAP_PREFIX, "utf8"),
+			toArray("SET", "utf8"),
+			toArray("app", "utf8"),
+			toArray(app, "utf8"),
+			toArray("type", "utf8"),
+			toArray("post", "utf8"),
+		];
+
+		// Add any additional MAP data
+		if (additionalMapData) {
+			for (const [key, value] of Object.entries(additionalMapData)) {
+				mapData.push(toArray(key, "utf8"), toArray(value, "utf8"));
+			}
+		}
+
+		// Combine protocols with pipe separator
+		const pipeData = toArray("|", "utf8");
+		const dataToSign = [...bData, pipeData, ...mapData];
+
+		// Sign the data with AIP
+		const { signedData } = await signOpReturnWithAIP(
+			dataToSign,
+			paymentKey,
+			address.toString(),
+		);
+
+		// Create OP_RETURN script
+		const script = buildOpReturnScript(signedData);
+
+		// Get UTXOs
+		const utxos = await wallet.getPaymentUtxos();
+
+		// Build and send transaction using the new utility
+		return await buildAndSendTransaction({
+			outputs: [{ script, satoshis: 0 }],
+			utxos,
+			changeAddress: address.toString(),
+			paymentKey,
+		});
+	} catch (error) {
+		console.error("Error creating social post:", formatError(error));
+		return {
+			success: false,
+			error: formatError(error),
+		};
+	}
+}
+
+/**
+ * Register the social post tool with the MCP server
+ */
+export function registerCreatePostTool(server: McpServer, wallet: Wallet) {
+	server.tool(
+		"bsocial_createPost",
+		"Create a social post on the BSV blockchain using B:// and MAP protocols. Posts are stored permanently on-chain and can include plain text or markdown content.",
+		{ args: createPostArgsSchema },
+		async ({ args }: { args: CreatePostArgs }): Promise<CallToolResult> => {
+			const result = await createSocialPost(args, wallet);
+			return createResponse(result);
+		},
+	);
+}

package/tools/bsocial/index.ts

@@ -0,0 +1,45 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { Wallet } from "../wallet/wallet";
+import { registerBmapReadFollowsTool } from "./bmapFollow";
+import { registerBmapReadLikesTool } from "./bmapLikes";
+import { registerBmapReadPostsTool } from "./bmapReadPosts";
+import { registerCreatePostTool } from "./createPost";
+import { registerReadPostsTool } from "./readPosts";
+
+interface BsocialToolsConfig {
+	wallet?: Wallet;
+}
+
+/**
+ * Register all BSocial tools with the MCP server
+ * @param server The MCP server instance
+ * @param config Configuration including wallet instance
+ */
+export function registerBsocialTools(
+	server: McpServer,
+	config: BsocialToolsConfig,
+): void {
+	// Register tools that don't require wallet
+	registerReadPostsTool(server);
+	console.error("✅ Registered bsocial_readPosts tool");
+
+	// Register BMAP API query tools (read layer)
+	registerBmapReadPostsTool(server);
+	console.error("✅ Registered bmap_readPosts tool");
+
+	registerBmapReadLikesTool(server);
+	console.error("✅ Registered bmap_readLikes tool");
+
+	registerBmapReadFollowsTool(server);
+	console.error("✅ Registered bmap_readFollows tool");
+
+	// Register tools that require wallet
+	if (config.wallet) {
+		registerCreatePostTool(server, config.wallet);
+		console.error("✅ Registered bsocial_createPost tool");
+	} else {
+		console.error(
+			"⚠️ bsocial_createPost tool not registered (no wallet available)",
+		);
+	}
+}