bsv-mcp 0.0.35 → 0.2.0

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.",
+		{ args: readPostsArgsSchema },
+		async ({ args }: { args: ReadPostsArgs }): Promise<CallToolResult> => {
+			try {
+				const result = await readSocialPosts(args);
+
+				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
@@ -124,7 +128,7 @@ export function registerDecodeTransactionTool(server: McpServer): void {
 		},
 		async (
 			{ args }: { args: DecodeTransactionArgs },
-			extra: RequestHandlerExtra,
+			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
 		) => {
 			try {
 				const { tx, encoding } = args;

package/tools/constants.ts

@@ -19,3 +19,24 @@ export const MARKET_WALLET_ADDRESS = "15q8YQSqUa9uTh6gh4AVixxq29xkpBBP9z";
  * Market fee will never be less than this amount
  */
 export const MINIMUM_MARKET_FEE_SATOSHIS = 10000; // 10000 satoshis = 0.0001 BSV
+
+export const BAP_PREFIX = "1BAPSuaPnfGnSBM3GLV9yhxUdYe4vGbdMT";
+export const B_PREFIX = "19HxigV4QyBv3tHpQVcUEQyq1pzZVdoAut";
+export const MAP_PREFIX = "1PuQa7K62MiKCtssSLKy1kh56WWU7MtUR5";
+export const AIP_PREFIX = "1HPcP7a4kQjpJzyV4HWHKagon76KC3BsZA";
+export const STORAGE_MNEMONIC_KEY = "id_mnemonic";
+export const PUBLIC_URL = process.env.PUBLIC_URL || "";
+export const BMAP_URL =
+	process.env.PUBLIC_BMAP_URL || "https://bmap-api-production.up.railway.app";
+
+export const ORDFS_URL =
+	process.env.PUBLIC_ORDFS_URL || "https://ordfs.network";
+export const YOURS_INSTALL_URL =
+	"https://chromewebstore.google.com/detail/yours-wallet/mlbnicldlpdimbjdcncnklfempedeipj";
+
+// export const BSOCIAL_API_URL =
+// 	process.env.PUBLIC_BSOCIAL_API_URL ||
+// 	"https://bsocial-overlay-production.up.railway.app/api/v1";
+
+export const BSOCIAL_API_URL = "https://api.sigmaidentity.com/v1";
+export const V5_API_URL = "https://ordinals.1sat.app/v5";

package/tools/index.ts

@@ -1,9 +1,18 @@
+import type { PrivateKey } from "@bsv/sdk";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { registerA2aCallTool } from "./a2b/call";
 import { registerA2bDiscoverTool } from "./a2b/discover";
+import { registerBapTools } from "./bap";
+// import { registerBigBlocksTools } from "./bigblocks"; // Disabled - Turbopack module resolution issues
+import { registerBsocialTools } from "./bsocial";
 import { registerBsvTools } from "./bsv";
+import { registerMneeTools } from "./mnee";
 import { registerOrdinalsTools } from "./ordinals";
 import { registerUtilsTools } from "./utils";
+import { registerWalletGetBalanceDropletTool } from "./wallet/getBalanceDroplet";
+import type { IntegratedWallet } from "./wallet/integratedWallet";
+import { registerSetupDropletTool } from "./wallet/setupDroplet";
+import { registerWalletTools } from "./wallet/tools";
+import type { Wallet } from "./wallet/wallet";
 
 /**
  * Configuration options for tools
@@ -12,13 +21,29 @@ import { registerUtilsTools } from "./utils";
  * - enableBsvTools: controlled by DISABLE_BSV_TOOLS
  * - enableOrdinalsTools: controlled by DISABLE_ORDINALS_TOOLS
  * - enableUtilsTools: controlled by DISABLE_UTILS_TOOLS
- * - enableA2bTools: controlled by DISABLE_A2B_TOOLS
+ * - enableA2bTools: controlled by ENABLE_A2B_TOOLS (disabled by default)
+ * - enableBapTools: controlled by DISABLE_BAP_TOOLS
+ * - enableBsocialTools: controlled by DISABLE_BSOCIAL_TOOLS
+ * - enableWalletTools: controlled by DISABLE_WALLET_TOOLS
+ * - enableMneeTools: controlled by DISABLE_MNEE_TOOLS
+ * - enableBigBlocksTools: controlled by DISABLE_BIGBLOCKS_TOOLS
  */
 export interface ToolsConfig {
 	enableBsvTools?: boolean;
 	enableOrdinalsTools?: boolean;
 	enableUtilsTools?: boolean;
 	enableA2bTools?: boolean;
+	enableBapTools?: boolean;
+	enableBsocialTools?: boolean;
+	enableWalletTools?: boolean;
+	enableMneeTools?: boolean;
+	enableBigBlocksTools?: boolean;
+	identityPk?: PrivateKey;
+	payPk?: PrivateKey;
+	xprv?: string;
+	wallet?: Wallet;
+	integratedWallet?: IntegratedWallet;
+	disableBroadcasting?: boolean; // For wallet tools
 }
 
 /**
@@ -28,19 +53,33 @@ export interface ToolsConfig {
  */
 export function registerAllTools(
 	server: McpServer,
-	config: ToolsConfig = {
-		enableBsvTools: true,
-		enableOrdinalsTools: true,
-		enableUtilsTools: true,
-		enableA2bTools: false,
-	},
+	config: ToolsConfig = {},
 ): void {
-	const {
-		enableBsvTools = true,
-		enableOrdinalsTools = true,
-		enableUtilsTools = true,
-		enableA2bTools = false,
-	} = config;
+	// Ensure defaults are true unless explicitly set to false via env vars or config
+	const enableBsvTools =
+		process.env.DISABLE_BSV_TOOLS !== "true" && config.enableBsvTools !== false;
+	const enableOrdinalsTools =
+		process.env.DISABLE_ORDINALS_TOOLS !== "true" &&
+		config.enableOrdinalsTools !== false;
+	const enableUtilsTools =
+		process.env.DISABLE_UTILS_TOOLS !== "true" &&
+		config.enableUtilsTools !== false; // Ensure Utils are enabled by default
+	const enableA2bTools =
+		process.env.ENABLE_A2B_TOOLS === "true" && config.enableA2bTools !== false;
+	const enableBapTools =
+		process.env.DISABLE_BAP_TOOLS !== "true" && config.enableBapTools !== false;
+	const enableWalletTools =
+		process.env.DISABLE_WALLET_TOOLS !== "true" &&
+		config.enableWalletTools !== false;
+	const enableMneeTools =
+		process.env.DISABLE_MNEE_TOOLS !== "true" &&
+		config.enableMneeTools !== false;
+	const enableBsocialTools =
+		process.env.DISABLE_BSOCIAL_TOOLS !== "true" &&
+		config.enableBsocialTools !== false;
+	const enableBigBlocksTools =
+		process.env.DISABLE_BIGBLOCKS_TOOLS !== "true" &&
+		config.enableBigBlocksTools !== false;
 
 	// Register BSV-related tools
 	if (enableBsvTools) {
@@ -59,11 +98,58 @@ export function registerAllTools(
 
 	// Register agent-to-blockchain tools
 	if (enableA2bTools) {
-		// Register agent-to-blockchain discovery tool
 		registerA2bDiscoverTool(server);
+	}
+
+	// Register BAP tools
+	if (enableBapTools) {
+		const bapConfig: import("./bap").BapToolsConfig = {
+			disableBroadcasting: config.disableBroadcasting,
+			identityPk: config.identityPk,
+			masterXprv: config.xprv,
+			wallet: config.wallet,
+		};
+		registerBapTools(server, bapConfig);
+	}
+
+	// Register BSocial tools
+	if (enableBsocialTools && config.wallet) {
+		registerBsocialTools(server, { wallet: config.wallet });
+	}
+
+	// Register BigBlocks tools
+	// Disabled - Turbopack module resolution issues
+	// if (enableBigBlocksTools) {
+	// 	registerBigBlocksTools(server);
+	// }
+
+	// Register Wallet tools themselves
+	if (enableWalletTools) {
+		if (config.integratedWallet?.isDropletMode) {
+			// Register Droplet-mode wallet tools
+			const dropletClient = config.integratedWallet.getDropletClient();
+			if (dropletClient) {
+				// Register Droplet-specific tools
+				registerWalletGetBalanceDropletTool(server, dropletClient);
+				if (config.integratedWallet) {
+					registerSetupDropletTool(server, config.integratedWallet);
+				}
+				console.error("Registered Droplet mode wallet tools");
+			}
+		} else if (config.wallet) {
+			// Register normal wallet tools
+			const walletToolOptions = {
+				disableBroadcasting: config.disableBroadcasting === true, // Default to false if undefined
+				enableA2bTools: enableA2bTools, // Use the already determined enableA2bTools value
+				identityPk: config.identityPk,
+			};
+			registerWalletTools(server, config.wallet, walletToolOptions);
+		}
+	}
 
-		// Register agent-to-agent call tool
-		// registerA2aCallTool(server);
+	// Register MNEE tools
+	if (enableMneeTools) {
+		registerMneeTools(server);
 	}
 
 	// Add more tool categories as needed

package/tools/mnee/index.ts

@@ -7,15 +7,23 @@ import { registerSendMneeTool } from "./sendMnee";
 const mnee = new Mnee({
 	environment: "production",
 });
+
+const mneeToolsRegistered = new WeakSet<McpServer>();
+
 /**
  * Register all MNEE tools with the MCP server
  * @param server The MCP server instance
  */
 export function registerMneeTools(server: McpServer): void {
+	if (mneeToolsRegistered.has(server)) {
+		// console.warn("WARN: MNEE tools already registered for this server instance. Skipping.");
+		return;
+	}
 	// Register MNEE-related tools
 	registerGetBalanceTool(server, mnee);
 
 	registerSendMneeTool(server, mnee);
 
 	registerParseTxTool(server, mnee);
+	mneeToolsRegistered.add(server);
 }

package/tools/mnee/parseTx.ts

@@ -1,7 +1,7 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import type {
+	CallToolResult,
 	ServerNotification,
 	ServerRequest,
 } from "@modelcontextprotocol/sdk/types.js";

package/tools/mnee/sendMnee.ts

@@ -1,7 +1,7 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import type {
+	CallToolResult,
 	ServerNotification,
 	ServerRequest,
 } from "@modelcontextprotocol/sdk/types.js";

package/tools/utils/aip.ts

@@ -0,0 +1,46 @@
+import { BSM, type PrivateKey, Utils } from "@bsv/sdk";
+import { AIP_PREFIX } from "../constants";
+
+const { toArray, toBase64, toUTF8 } = Utils;
+
+/**
+ * Sign OP_RETURN data with AIP (Author Identity Protocol)
+ * @param dataArrays - Array of data arrays to sign
+ * @param signingKey - Private key to sign with
+ * @param signingAddress - Address associated with the signing key
+ * @returns Object containing signed data array
+ */
+export async function signOpReturnWithAIP(
+	dataArrays: Uint8Array[],
+	signingKey: PrivateKey,
+	signingAddress: string,
+): Promise<{ signedData: Uint8Array[] }> {
+	// Concatenate all data arrays to create message to sign
+	let messageToSign = new Uint8Array();
+	for (const data of dataArrays) {
+		const temp = new Uint8Array(messageToSign.length + data.length);
+		temp.set(messageToSign);
+		temp.set(data, messageToSign.length);
+		messageToSign = temp;
+	}
+
+	// Create BSM signature
+	const signature = BSM.sign(messageToSign, signingKey);
+
+	// Convert signature to base64
+	const signatureBase64 = toBase64(signature.toCompact());
+
+	// Add AIP data to the arrays
+	const aipData: Uint8Array[] = [
+		toArray("|", "utf8"), // Separator
+		toArray(AIP_PREFIX, "utf8"),
+		toArray("BITCOIN_ECDSA", "utf8"),
+		toArray(signingAddress, "utf8"),
+		toArray(signatureBase64, "utf8"),
+	];
+
+	// Return combined data
+	return {
+		signedData: [...dataArrays, ...aipData],
+	};
+}

package/tools/utils/conversion.ts

@@ -1,5 +1,6 @@
 import { Utils } from "@bsv/sdk";
 import { z } from "zod";
+
 const {
 	toArray: bsvToArray,
 	toBase64: bsvToBase64,

package/tools/utils/errorHandler.ts

@@ -0,0 +1,76 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+
+/**
+ * Format an error message consistently
+ */
+export function formatError(error: unknown): string {
+	if (error instanceof Error) {
+		return error.message;
+	}
+	return String(error);
+}
+
+/**
+ * Create a standardized error response for MCP tools
+ */
+export function createErrorResponse(error: unknown): CallToolResult {
+	return {
+		content: [
+			{
+				type: "text",
+				text: formatError(error),
+			},
+		],
+		isError: true,
+	};
+}
+
+/**
+ * Create a standardized success response for MCP tools
+ */
+export function createSuccessResponse(data: unknown): CallToolResult {
+	const text = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+	return {
+		content: [
+			{
+				type: "text",
+				text,
+			},
+		],
+		isError: false,
+	};
+}
+
+/**
+ * Create a response based on a result object with success field
+ */
+export function createResponse(result: {
+	success: boolean;
+	[key: string]: unknown;
+}): CallToolResult {
+	return {
+		content: [
+			{
+				type: "text",
+				text: JSON.stringify(result, null, 2),
+			},
+		],
+		isError: !result.success,
+	};
+}
+
+/**
+ * Wrap an async function with standard error handling
+ */
+export function withErrorHandler<
+	T extends (...args: unknown[]) => Promise<unknown>,
+>(fn: T): (...args: Parameters<T>) => Promise<CallToolResult> {
+	return async (...args: Parameters<T>): Promise<CallToolResult> => {
+		try {
+			const result = await fn(...args);
+			return createSuccessResponse(result);
+		} catch (error) {
+			return createErrorResponse(error);
+		}
+	};
+}

package/tools/utils/index.ts

@@ -1,14 +1,50 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 import { convertData } from "./conversion";
+import { installAgentMasterTool } from "./installAgentMaster";
 
 const encodingSchema = z.enum(["utf8", "hex", "base64", "binary"]);
 
 /**
- * Register the unified conversion tool with the MCP server
+ * Register utility tools with the MCP server
  * @param server The MCP server instance
  */
 export function registerUtilsTools(server: McpServer): void {
+	// Register install agent master tool
+	server.tool(
+		installAgentMasterTool.name,
+		installAgentMasterTool.description,
+		{ args: installAgentMasterTool.inputSchema },
+		async ({ args }) => {
+			try {
+				const result = await installAgentMasterTool.handler(args);
+				return {
+					content: [
+						{
+							type: "text",
+							text:
+								typeof result === "string"
+									? result
+									: JSON.stringify(result, null, 2),
+						},
+					],
+				};
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				return {
+					content: [
+						{
+							type: "text",
+							text: `Error: ${msg}`,
+						},
+					],
+					isError: true,
+				};
+			}
+		},
+	);
+
+	// Register conversion tool
 	server.tool(
 		"utils_convertData",
 		"Converts data between different encodings (utf8, hex, base64, binary). Useful for transforming data formats when working with blockchain data, encryption, or file processing.\n\n" +
@@ -66,3 +102,11 @@ export function registerUtilsTools(server: McpServer): void {
 		},
 	);
 }
+
+export * from "./aip";
+// Export all utilities for use by other tools
+export * from "./errorHandler";
+export * from "./logger";
+export * from "./toolConfig";
+export * from "./toolRegistration";
+export * from "./transactionBuilder";