bsv-mcp 0.0.36 → 0.2.7

package/tools/bsv/token.ts

@@ -17,14 +17,11 @@ export function registerTokenTools(server: McpServer): void {
 	server.tool(
 		"bsv_toSatoshi",
 		{
-			args: z.object({
-				bitcoin: z.union([z.number(), z.string()]),
-				returnType: z.enum(["number", "string", "bigint"]).optional(),
-			}),
+			bitcoin: z.union([z.number(), z.string()]),
+			returnType: z.enum(["number", "string", "bigint"]).optional(),
 		},
-		async ({ args }) => {
+		async ({ bitcoin, returnType }) => {
 			try {
-				const { bitcoin, returnType } = args;
 				let result: number | string | bigint;
 
 				switch (returnType) {
@@ -49,14 +46,11 @@ export function registerTokenTools(server: McpServer): void {
 	server.tool(
 		"bsv_toBitcoin",
 		{
-			args: z.object({
-				satoshis: z.union([z.number(), z.string(), z.bigint()]),
-				returnType: z.enum(["number", "string", "bigint"]).optional(),
-			}),
+			satoshis: z.union([z.number(), z.string(), z.bigint()]),
+			returnType: z.enum(["number", "string", "bigint"]).optional(),
 		},
-		async ({ args }) => {
+		async ({ satoshis, returnType }) => {
 			try {
-				const { satoshis, returnType } = args;
 				let result: number | string | bigint;
 
 				switch (returnType) {
@@ -93,15 +87,12 @@ export function registerTokenTools(server: McpServer): void {
 	server.tool(
 		"bsv_toTokenSatoshi",
 		{
-			args: z.object({
-				token: z.union([z.number(), z.string(), z.bigint()]),
-				decimals: z.number().int().min(0),
-				returnType: z.enum(["number", "string", "bigint"]).optional(),
-			}),
+			token: z.union([z.number(), z.string(), z.bigint()]),
+			decimals: z.number().int().min(0),
+			returnType: z.enum(["number", "string", "bigint"]).optional(),
 		},
-		async ({ args }) => {
+		async ({ token, decimals, returnType }) => {
 			try {
-				const { token, decimals, returnType } = args;
 				let result: number | string | bigint;
 
 				switch (returnType) {
@@ -126,15 +117,12 @@ export function registerTokenTools(server: McpServer): void {
 	server.tool(
 		"bsv_toToken",
 		{
-			args: z.object({
-				tokenSatoshi: z.union([z.number(), z.string(), z.bigint()]),
-				decimals: z.number().int().min(0),
-				returnType: z.enum(["number", "string", "bigint"]).optional(),
-			}),
+			tokenSatoshi: z.union([z.number(), z.string(), z.bigint()]),
+			decimals: z.number().int().min(0),
+			returnType: z.enum(["number", "string", "bigint"]).optional(),
 		},
-		async ({ args }) => {
+		async ({ tokenSatoshi, decimals, returnType }) => {
 			try {
-				const { tokenSatoshi, decimals, returnType } = args;
 				let result: number | string | bigint;
 
 				switch (returnType) {

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,17 @@
+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 { 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 +20,27 @@ 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
  */
 export interface ToolsConfig {
 	enableBsvTools?: boolean;
 	enableOrdinalsTools?: boolean;
 	enableUtilsTools?: boolean;
 	enableA2bTools?: boolean;
+	enableBapTools?: boolean;
+	enableBsocialTools?: boolean;
+	enableWalletTools?: boolean;
+	enableMneeTools?: boolean;
+	identityPk?: PrivateKey;
+	payPk?: PrivateKey;
+	xprv?: string;
+	wallet?: Wallet;
+	integratedWallet?: IntegratedWallet;
+	disableBroadcasting?: boolean; // For wallet tools
 }
 
 /**
@@ -28,20 +50,30 @@ 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;
 	// Register BSV-related tools
 	if (enableBsvTools) {
 		registerBsvTools(server);
@@ -59,11 +91,52 @@ 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 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/getBalance.ts

@@ -19,11 +19,9 @@ export function registerGetBalanceTool(
 	server.tool(
 		"mnee_getBalance",
 		"Retrieves the current MNEE token balance for the wallet. Returns the balance in MNEE tokens.",
-		{
-			args: getBalanceArgsSchema,
-		},
+		{},
 		async (
-			{ args }: { args: GetBalanceArgs },
+			_params,
 			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
 		) => {
 			try {

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";
@@ -24,13 +24,13 @@ export function registerParseTxTool(
 	server.tool(
 		"mnee_parseTx",
 		"Parse an MNEE transaction to get detailed information about its operations and amounts. All amounts are in atomic units with 5 decimal precision (e.g. 1000 atomic units = 0.01 MNEE).",
-		{ args: parseTxArgsSchema },
+		{ ...parseTxArgsSchema.shape },
 		async (
-			{ args }: { args: ParseTxArgs },
+			{ txid },
 			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
 		): Promise<CallToolResult> => {
 			try {
-				const result: ParseTxResponse = await mnee.parseTx(args.txid);
+				const result: ParseTxResponse = await mnee.parseTx(txid);
 
 				return {
 					content: [

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";
@@ -42,18 +42,18 @@ export function registerSendMneeTool(server: McpServer, mnee: Mnee): void {
 	server.tool(
 		"mnee_sendMnee",
 		"Send MNEE tokens to a specified address",
-		{ args: sendMneeArgsSchema },
+		{ ...sendMneeArgsSchema.shape },
 		async (
-			{ args }: { args: SendMneeArgs },
+			{ address, amount, currency },
 			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
 		): Promise<CallToolResult> => {
 			try {
 				// Since 1 MNEE = $1, the amount is the same in both currencies
-				const mneeAmount = args.amount;
+				const mneeAmount = amount;
 
 				const transferRequest: SendMNEE[] = [
 					{
-						address: args.address,
+						address,
 						amount: mneeAmount,
 					},
 				];
@@ -101,7 +101,7 @@ export function registerSendMneeTool(server: McpServer, mnee: Mnee): void {
 									rawtx: result.rawtx,
 									mneeAmount: mneeAmount,
 									usdAmount: formatUSD(mneeAmount),
-									recipient: args.address,
+									recipient: address,
 								},
 								null,
 								2,

package/tools/ordinals/getInscription.ts

@@ -42,14 +42,13 @@ export function registerGetInscriptionTool(server: McpServer): void {
 		"ordinals_getInscription",
 		"Retrieves detailed information about a specific ordinal inscription by its outpoint. Returns complete inscription data including content type, file information, inscription origin, and current status. Useful for verifying NFT authenticity or retrieving metadata about digital artifacts.",
 		{
-			args: getInscriptionArgsSchema,
+			...getInscriptionArgsSchema.shape,
 		},
 		async (
-			{ args }: { args: GetInscriptionArgs },
+			{ outpoint },
 			extra: RequestHandlerExtra,
 		) => {
 			try {
-				const { outpoint } = args;
 
 				// Validate outpoint format
 				if (!/^[0-9a-f]{64}_\d+$/i.test(outpoint)) {

package/tools/ordinals/getTokenByIdOrTicker.ts

@@ -43,14 +43,17 @@ export function registerGetTokenByIdOrTickerTool(server: McpServer): void {
 		"ordinals_getTokenByIdOrTicker",
 		"Retrieves detailed information about a specific BSV-20 token by its ID or ticker symbol. Returns complete token data including ticker symbol, supply information, decimals, and current status. This tool is useful for verifying token authenticity or checking supply metrics.",
 		{
-			args: getTokenByIdOrTickerArgsSchema,
+			id: z
+				.string()
+				.optional()
+				.describe("BSV20 token ID in outpoint format (txid_vout)"),
+			tick: z.string().optional().describe("BSV20 token ticker symbol"),
 		},
 		async (
-			{ args }: { args: GetTokenByIdOrTickerArgs },
+			{ id, tick },
 			extra: RequestHandlerExtra,
 		) => {
 			try {
-				const { id, tick } = args;
 
 				// Validate that at least one of id or tick is provided
 				if (!id && !tick) {

package/tools/ordinals/marketListings.ts

@@ -95,29 +95,13 @@ export function registerMarketListingsTool(server: McpServer): void {
 		"ordinals_marketListings",
 		"Retrieves current marketplace listings for Bitcoin SV ordinals with flexible filtering. Supports multiple asset types (NFTs, BSV-20 tokens, BSV-21 tokens) through a unified interface. Results include listing prices, details about the assets, and seller information.",
 		{
-			args: marketListingsArgsSchema,
+			...marketListingsArgsSchema.shape,
 		},
 		async (
-			{ args }: { args: MarketListingsArgs },
+			{ limit, offset, sort, dir, address, origin, mime, num, minPrice, maxPrice, tokenType, id, tick, pending },
 			extra: RequestHandlerExtra,
 		) => {
 			try {
-				const {
-					limit,
-					offset,
-					sort,
-					dir,
-					address,
-					origin,
-					mime,
-					num,
-					minPrice,
-					maxPrice,
-					tokenType,
-					id,
-					tick,
-					pending,
-				} = args;
 
 				// Determine the API endpoint based on tokenType
 				let baseUrl = "https://ordinals.gorillapool.io/api";

package/tools/ordinals/marketSales.ts

@@ -73,12 +73,10 @@ export function registerMarketSalesTool(server: McpServer): void {
 		"ordinals_marketSales",
 		"Retrieves recent sales data for BSV-20 and BSV-21 tokens on the ordinals marketplace. This tool provides insights into market activity, including sale prices, transaction details, and token information. Supports filtering by token ID, ticker symbol, or seller address to help analyze market trends and track specific token sales.",
 		{
-			args: marketSalesArgsSchema,
+			...marketSalesArgsSchema.shape,
 		},
-		async ({ args }: { args: MarketSalesArgs }, extra: RequestHandlerExtra) => {
+		async ({ limit, offset, dir, tokenType, id, tick, pending, address }, extra: RequestHandlerExtra) => {
 			try {
-				const { limit, offset, dir, tokenType, id, tick, pending, address } =
-					args;
 
 				// Determine the API endpoint based on tokenType
 				let baseUrl = "https://ordinals.gorillapool.io/api";

package/tools/ordinals/searchInscriptions.ts

@@ -59,15 +59,13 @@ export function registerSearchInscriptionsTool(server: McpServer): void {
 		"ordinals_searchInscriptions",
 		"Searches for Bitcoin SV ordinal inscriptions using flexible criteria. This powerful search tool supports filtering by address, inscription content, MIME type, MAP fields, and other parameters. Results include detailed information about each matched inscription. Ideal for discovering NFTs and exploring the ordinals ecosystem.",
 		{
-			args: searchInscriptionsArgsSchema,
+			...searchInscriptionsArgsSchema.shape,
 		},
 		async (
-			{ args }: { args: SearchInscriptionsArgs },
+			{ limit, offset, dir, num, origin, address, map, terms, mime },
 			extra: RequestHandlerExtra,
 		) => {
 			try {
-				const { limit, offset, dir, num, origin, address, map, terms, mime } =
-					args;
 
 				// Build the URL with query parameters
 				const url = new URL(

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);
+		}
+	};
+}