bsv-mcp 0.0.36 → 0.2.7

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.",
+		{ ...bmapReadPostsArgsSchema.shape },
+		async ({ bapId, txid, limit, page, feed, address }): Promise<CallToolResult> => {
+			try {
+				const result = await readBmapPosts({ bapId, txid, limit, page, feed, address });
+
+				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.",
+		{ ...createPostArgsSchema.shape },
+		async ({ content, contentType, app, additionalMapData }): Promise<CallToolResult> => {
+			const result = await createSocialPost({ content, contentType, app, additionalMapData }, 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)",
+		);
+	}
+}

package/tools/bsocial/readPosts.ts

@@ -0,0 +1,255 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type {
+	ApiResponse,
+	BapIdentity,
+	PostMeta,
+	PostResponse,
+	PostsResponse,
+	PostTransaction,
+} from "bmap-api-types";
+import { z } from "zod";
+import { BMAP_URL } from "../constants";
+
+// Schema for reading posts
+const readPostsArgsSchema = 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)"),
+});
+
+type ReadPostsArgs = z.infer<typeof readPostsArgsSchema>;
+
+/**
+ * Read social posts from the BMAP API using official types
+ */
+export async function readSocialPosts(args: ReadPostsArgs): Promise<{
+	success: boolean;
+	posts?: PostTransaction[];
+	signers?: BapIdentity[];
+	meta?: PostMeta[];
+	pagination?: {
+		page: number;
+		limit: number;
+		count: number;
+	};
+	error?: string;
+}> {
+	try {
+		const { bapId, txid, limit, page, feed } = 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()) as ApiResponse<PostResponse>;
+
+			if (data.status !== "success") {
+				return {
+					success: false,
+					error: data.error || "Unknown API error",
+				};
+			}
+
+			return {
+				success: true,
+				posts: [data.result.post],
+				signers: data.result.signers,
+				meta: [data.result.meta],
+			};
+		}
+
+		// Handle posts list request
+		const params = new URLSearchParams();
+		if (bapId) params.append("bapId", bapId);
+		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()) as ApiResponse<PostsResponse>;
+
+		if (data.status !== "success") {
+			return {
+				success: false,
+				error: data.error || "Unknown API error",
+			};
+		}
+
+		return {
+			success: true,
+			posts: data.data.results,
+			signers: data.data.signers,
+			meta: data.data.meta,
+			pagination: {
+				page: data.data.page,
+				limit: data.data.limit,
+				count: data.data.count,
+			},
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		console.error("Error reading social posts:", errorMessage);
+		return {
+			success: false,
+			error: errorMessage,
+		};
+	}
+}
+
+/**
+ * Format a post transaction for display
+ */
+function formatPost(
+	post: PostTransaction,
+	index: number,
+	signer?: BapIdentity,
+	meta?: PostMeta,
+): string {
+	const lines = [
+		`Post ${index + 1}:`,
+		`  TX ID: ${post.tx.h}`,
+		`  Content: ${post.B[0]?.content || "[No Content]"}`,
+		`  Content Type: ${post.B[0]?.["content-type"] || "text/plain"}`,
+		`  Timestamp: ${new Date(post.timestamp * 1000).toISOString()}`,
+	];
+
+	// Add signer information
+	if (signer) {
+		lines.push(`  Author: ${signer.displayName || signer.idKey}`);
+		if (signer.paymail) {
+			lines.push(`  Paymail: ${signer.paymail}`);
+		}
+	}
+
+	// Add MAP data
+	const mapData = post.MAP.find((m) => m.type === "post");
+	if (mapData?.app) {
+		lines.push(`  App: ${mapData.app}`);
+	}
+
+	// Add metadata
+	if (meta) {
+		if (meta.likes > 0) {
+			lines.push(`  Likes: ${meta.likes}`);
+		}
+		if (meta.replies > 0) {
+			lines.push(`  Replies: ${meta.replies}`);
+		}
+		if (meta.reactions.length > 0) {
+			const reactions = meta.reactions
+				.map((r) => `${r.emoji}(${r.count})`)
+				.join(" ");
+			lines.push(`  Reactions: ${reactions}`);
+		}
+	}
+
+	return lines.join("\n");
+}
+
+/**
+ * Register the read posts tool with the MCP server
+ */
+export function registerReadPostsTool(server: McpServer) {
+	server.tool(
+		"bsocial_readPosts",
+		"Read social posts from the BSV blockchain using BMAP API. Can fetch posts by author (BAP ID), specific post by transaction ID, or recent posts from all users. Supports pagination and feed functionality.",
+		{ ...readPostsArgsSchema.shape },
+		async ({ bapId, txid, limit, page, feed }): Promise<CallToolResult> => {
+			try {
+				const result = await readSocialPosts({ bapId, txid, limit, page, feed });
+
+				if (result.success && result.posts) {
+					// Format posts for display
+					const formattedPosts = result.posts
+						.map((post, index) => {
+							const signer = result.signers?.find(
+								(s) => s.currentAddress === post.AIP[0]?.address,
+							);
+							const meta = result.meta?.[index];
+							return formatPost(post, index, signer, meta);
+						})
+						.join("\n\n");
+
+					let output =
+						result.posts.length > 0 ? formattedPosts : "No posts found";
+
+					// Add pagination info
+					if (result.pagination) {
+						output += `\n\nPagination: Page ${result.pagination.page}, showing ${result.posts.length} of ${result.pagination.count} posts`;
+					}
+
+					return {
+						content: [
+							{
+								type: "text",
+								text: output,
+							},
+						],
+						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/bsv/decodeTransaction.ts

@@ -1,6 +1,10 @@
 import { Transaction, Utils } from "@bsv/sdk";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import type {
+	ServerNotification,
+	ServerRequest,
+} from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 
 // Schema for decode transaction arguments
@@ -119,15 +123,12 @@ export function registerDecodeTransactionTool(server: McpServer): void {
 	server.tool(
 		"bsv_decodeTransaction",
 		"Decodes and analyzes Bitcoin SV transactions to provide detailed insights. This powerful tool accepts either a transaction ID or raw transaction data and returns comprehensive information including inputs, outputs, fee calculations, script details, and blockchain context. Supports both hex and base64 encoded transactions and automatically fetches additional on-chain data when available.",
-		{
-			args: decodeTransactionArgsSchema,
-		},
+		decodeTransactionArgsSchema.shape,
 		async (
-			{ args }: { args: DecodeTransactionArgs },
-			extra: RequestHandlerExtra,
+			{ tx, encoding },
+			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
 		) => {
 			try {
-				const { tx, encoding } = args;
 				let transaction: Transaction;
 				let rawTx: string;
 				let txid: string;

package/tools/bsv/explore.ts

@@ -131,10 +131,9 @@ export function registerExploreTool(server: McpServer): void {
 			"NETWORK:\n" +
 			"- health: API health check\n\n" +
 			"Use the appropriate parameters for each endpoint type and specify 'main' or 'test' network.",
-		{ args: exploreArgsSchema },
-		async ({ args }) => {
+		exploreArgsSchema.shape,
+		async (params) => {
 			try {
-				const params = exploreArgsSchema.parse(args);
 
 				// Validate required parameters for specific endpoints
 				if (

package/tools/bsv/getPrice.ts

@@ -1,5 +1,4 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
 
 // Define cache duration (5 minutes in milliseconds)
 const PRICE_CACHE_DURATION = 5 * 60 * 1000;
@@ -53,14 +52,7 @@ export function registerGetPriceTool(server: McpServer): void {
 	server.tool(
 		"bsv_getPrice",
 		"Retrieves the current price of Bitcoin SV (BSV) in USD from a reliable exchange API. This tool provides real-time market data that can be used for calculating transaction values, monitoring market conditions, or converting between BSV and fiat currencies.",
-		{
-			args: z
-				.object({})
-				.optional()
-				.describe(
-					"No parameters required - simply returns the current BSV price in USD",
-				),
-		},
+		{},
 		async () => {
 			try {
 				const price = await getBsvPriceWithCache();