bsv-mcp 0.0.34 → 0.0.36

package/tools/wallet/a2bPublishMcp.ts

@@ -1,15 +1,21 @@
 import { PrivateKey, Utils } from "@bsv/sdk";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
 import type {
+	ClientNotification,
+	ClientRequest,
 	ServerNotification,
 	ServerRequest,
 } from "@modelcontextprotocol/sdk/types.js";
 import { createOrdinals } from "js-1sat-ord";
 import type {
 	ChangeResult,
+	CreateOrdinalsConfig,
 	Destination,
 	Inscription,
+	LocalSigner,
 	PreMAP,
 } from "js-1sat-ord";
 import { Sigma } from "sigma-protocol";
@@ -17,10 +23,16 @@ import { z } from "zod";
 import type { Wallet } from "./wallet";
 const { toArray, toBase64 } = Utils;
 
+// API endpoint for the A2B Overlay service
+const OVERLAY_API_URL = "https://a2b-overlay-production.up.railway.app/v1";
+
 // Schema for the MCP tool configuration
 export const McpConfigSchema = z.object({
 	command: z.string().describe("The command to execute the tool"),
 	args: z.array(z.string()).describe("Arguments to pass to the command"),
+	tools: z.array(z.string()).optional().describe("Available tool names"),
+	prompts: z.array(z.string()).optional().describe("Available prompt names"),
+	resources: z.array(z.string()).optional().describe("Available resource URIs"),
 	env: z.record(z.string()).optional().describe("Environment variables"),
 });
 
@@ -31,6 +43,10 @@ export const a2bPublishMcpArgsSchema = z.object({
 	toolName: z.string().describe("Human-friendly tool name"),
 	command: z.string().describe("The command to execute the tool"),
 	args: z.array(z.string()).describe("Arguments to pass to the command"),
+	keywords: z
+		.array(z.string())
+		.optional()
+		.describe("Optional keywords to improve tool discoverability"),
 	env: z
 		.array(
 			z.object({
@@ -51,6 +67,119 @@ export const a2bPublishMcpArgsSchema = z.object({
 
 export type A2bPublishMcpArgs = z.infer<typeof a2bPublishMcpArgsSchema>;
 
+/**
+ * Call the ingest endpoint to process a transaction
+ */
+async function callIngestEndpoint(txid: string): Promise<boolean> {
+	try {
+		const response = await fetch(`${OVERLAY_API_URL}/ingest`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+			},
+			body: JSON.stringify({ txid }),
+		});
+
+		if (!response.ok) {
+			console.warn(
+				`Ingest API returned status ${response.status}: ${response.statusText}`,
+			);
+			return false;
+		}
+
+		const result = await response.json();
+		// console.log('Ingest result:', result);
+		return true;
+	} catch (error) {
+		console.warn("Error calling ingest endpoint:", error);
+		return false;
+	}
+}
+
+/**
+ * Fetches MCP metadata (tools, prompts, resources) by running the command
+ * and connecting to it via the MCP client
+ */
+async function fetchMcpMetadata(
+	command: string,
+	args: string[],
+): Promise<{
+	tools: string[];
+	prompts: string[];
+	resources: string[];
+}> {
+	// console.log(`Fetching MCP metadata by running: ${command} ${args.join(' ')}`);
+
+	let transport: StdioClientTransport | undefined;
+	let client:
+		| Client<
+				ClientRequest,
+				ServerRequest,
+				ClientNotification | ServerNotification
+		  >
+		| undefined;
+
+	try {
+		// Create a transport to the MCP server
+		// Pass through all current environment variables to ensure the same configuration
+		transport = new StdioClientTransport({
+			command,
+			args,
+			env: {
+				...process.env, // Pass through all current environment variables
+				DISABLE_BROADCASTING: "true", // Prevent actual broadcasting during tool discovery
+			},
+		});
+
+		// Create and connect a client
+		client = new Client({
+			name: "metadata-fetcher",
+			version: "1.0.0",
+		});
+
+		await client.connect(transport);
+
+		// Fetch available tools, prompts, and resources
+		const toolsResponse = await client.listTools();
+		const promptsResponse = await client.listPrompts();
+		const resourcesResponse = await client.listResources();
+
+		// Extract the names/URIs
+		const tools = toolsResponse.tools.map((tool) => tool.name);
+		const prompts = promptsResponse.prompts.map((prompt) => prompt.name);
+		const resources = resourcesResponse.resources.map(
+			(resource) => resource.uri,
+		);
+
+		// Add known tools that might be missing, avoid duplicates
+		const allTools = [...new Set([...tools])];
+
+		return {
+			tools: allTools,
+			prompts,
+			resources,
+		};
+	} catch (error) {
+		console.error("Error fetching MCP metadata:", error);
+		// Return hardcoded list of known tools if fetching fails
+		return {
+			tools: [],
+			prompts: [],
+			resources: [],
+		};
+	} finally {
+		// Clean up resources
+		if (transport) {
+			try {
+				// Close the transport to shut down the child process
+				await transport.close();
+			} catch (e) {
+				console.error("Error closing transport:", e);
+			}
+		}
+	}
+}
+
 /**
  * Registers the wallet_a2bPublishMcp for publishing an MCP tool configuration on-chain
  */
@@ -61,7 +190,7 @@ export function registerA2bPublishMcpTool(
 ) {
 	server.tool(
 		"wallet_a2bPublishMcp",
-		"Publish an MCP tool configuration record on-chain via Ordinal inscription",
+		"Publish an MCP tool configuration record on-chain via Ordinal inscription. This creates a permanent, immutable, and discoverable tool definition that can be accessed by other MCP servers. The tool is published as a JSON inscription with metadata and optional digital signatures for authenticity verification.",
 		{ args: a2bPublishMcpArgsSchema },
 		async (
 			{ args }: { args: A2bPublishMcpArgs },
@@ -91,10 +220,17 @@ export function registerA2bPublishMcpTool(
 
 				const walletAddress = paymentPk.toAddress().toString();
 
+				// Fetch MCP metadata (tools, prompts, resources)
+				const metadata = await fetchMcpMetadata(args.command, args.args);
+				// console.log(`Discovered ${metadata.tools.length} tools, ${metadata.prompts.length} prompts, and ${metadata.resources.length} resources`);
+
 				// Assemble tool configuration
 				const toolConfig: McpConfig = {
 					command: args.command,
 					args: args.args,
+					tools: metadata.tools,
+					prompts: metadata.prompts,
+					resources: metadata.resources,
 					env: args.env
 						? args.env.reduce(
 								(acc, { key, description }) => {
@@ -114,7 +250,10 @@ export function registerA2bPublishMcpTool(
 					mcpServers: {
 						[args.toolName]: {
 							description: args.description || "",
-							type: "mcp-tool",
+							keywords: args.keywords || [],
+							tools: metadata.tools || [],
+							prompts: metadata.prompts || [],
+							resources: metadata.resources || [],
 							...toolConfig,
 						},
 					},
@@ -138,26 +277,32 @@ export function registerA2bPublishMcpTool(
 				// Default MAP metadata: file path, content type, encoding
 				const metaData: PreMAP = { app: "bsv-mcp", type: "a2b-mcp" };
 
-				// Inscribe the ordinal on-chain via js-1sat-ord
-				const result = await createOrdinals({
+				const createOrdinalsConfig = {
 					utxos: paymentUtxos,
 					destinations,
 					paymentPk,
 					changeAddress: walletAddress,
 					metaData,
-				});
+				} as CreateOrdinalsConfig;
+				if (identityPk) {
+					createOrdinalsConfig.signer = {
+						idKey: identityPk,
+					} as LocalSigner;
+				}
+				// Inscribe the ordinal on-chain via js-1sat-ord
+				const result = await createOrdinals(createOrdinalsConfig);
 
 				const changeResult = result as ChangeResult;
 
-				let finalTx = changeResult.tx;
-				if (identityPk) {
-					const sigma = new Sigma(result.tx);
-					const signResponse = sigma.sign(identityPk);
-					finalTx = signResponse.signedTx;
-				}
 				// Broadcast the transaction
 				if (!config.disableBroadcasting) {
-					await finalTx.broadcast();
+					await changeResult.tx.broadcast();
+					const txid = changeResult.tx.id("hex");
+
+					setTimeout(async () => {
+						// Call the ingest endpoint to process the transaction
+						await callIngestEndpoint(txid);
+					}, 1000);
 
 					// Refresh UTXOs after spending
 					try {
@@ -171,7 +316,7 @@ export function registerA2bPublishMcpTool(
 
 					// Build a nicely formatted result
 					const outpointIndex = 0; // First output with the inscription
-					const outpoint = `${finalTx.id("hex")}_${outpointIndex}`;
+					const outpoint = `${txid}_${outpointIndex}`;
 
 					// Tool URL for discovery is the outpoint
 					const onchainUrl = `ord://${outpoint}`;
@@ -183,10 +328,13 @@ export function registerA2bPublishMcpTool(
 								text: JSON.stringify(
 									{
 										status: "success",
-										txid: finalTx.id("hex"),
+										txid,
 										outpoint,
 										onchainUrl,
 										toolName: args.toolName,
+										toolCount: metadata.tools.length,
+										promptCount: metadata.prompts.length,
+										resourceCount: metadata.resources.length,
 										description:
 											args.description || `MCP Tool: ${args.toolName}`,
 										address: targetAddress,
@@ -202,7 +350,7 @@ export function registerA2bPublishMcpTool(
 					content: [
 						{
 							type: "text",
-							text: finalTx.toHex(),
+							text: changeResult.tx.toHex(),
 						},
 					],
 				};

package/tools/wallet/fetchPaymentUtxos.ts

@@ -0,0 +1,130 @@
+import { P2PKH, Transaction, Utils } from "@bsv/sdk";
+import type { Utxo } from "js-1sat-ord";
+const { toBase64 } = Utils;
+
+/**
+ * Type definition for WhatsOnChain UTXO response
+ */
+interface WhatsOnChainUtxo {
+	tx_hash: string;
+	tx_pos: number;
+	value: number;
+	height: number;
+	address?: string;
+}
+
+/**
+ * Fetches unspent transaction outputs (UTXOs) for a given address.
+ * Only returns confirmed unspent outputs.
+ *
+ * @param address - The address to fetch UTXOs for
+ * @returns Array of UTXOs or undefined if an error occurs
+ */
+export async function fetchPaymentUtxos(
+	address: string,
+): Promise<Utxo[] | undefined> {
+	if (!address) {
+		console.error("fetchPaymentUtxos: No address provided");
+		return undefined;
+	}
+
+	try {
+		// Fetch UTXOs from WhatsOnChain API
+		const response = await fetch(
+			`https://api.whatsonchain.com/v1/bsv/main/address/${address}/unspent`,
+		);
+
+		if (!response.ok) {
+			console.error(
+				`WhatsOnChain API error: ${response.status} ${response.statusText}`,
+			);
+			return undefined;
+		}
+
+		const data = (await response.json()) as WhatsOnChainUtxo[];
+
+		// Validate response format
+		if (!Array.isArray(data)) {
+			console.error("Invalid response format from WhatsOnChain API");
+			return undefined;
+		}
+
+		// For testing purposes (FOR TESTING ONLY - REMOVE IN PRODUCTION)
+		// const limitUTXOs = data.slice(0, 2);
+
+		// Process each UTXO
+		const utxos: (Utxo | null)[] = await Promise.all(
+			data.map(async (utxo: WhatsOnChainUtxo) => {
+				// Get the transaction hex to extract the correct script
+				const script = await getScriptFromTransaction(
+					utxo.tx_hash,
+					utxo.tx_pos,
+				);
+
+				if (!script) {
+					console.warn(
+						`Could not get script for UTXO: ${utxo.tx_hash}:${utxo.tx_pos}`,
+					);
+					return null;
+				}
+
+				return {
+					txid: utxo.tx_hash,
+					vout: utxo.tx_pos,
+					satoshis: utxo.value,
+					script: script,
+				};
+			}),
+		);
+
+		// Filter out any null entries from failed processing
+		const validUtxos = utxos.filter((utxo) => utxo !== null) as Utxo[];
+
+		return validUtxos;
+	} catch (error) {
+		console.error("Error fetching payment UTXOs:", error);
+		return undefined;
+	}
+}
+
+/**
+ * Gets the script from a transaction for a specific output index
+ *
+ * @param txid - The transaction ID
+ * @param vout - The output index
+ * @returns The script as hex string or undefined if an error occurs
+ */
+async function getScriptFromTransaction(
+	txid: string,
+	vout: number,
+): Promise<string | undefined> {
+	try {
+		const response = await fetch(
+			`https://api.whatsonchain.com/v1/bsv/main/tx/${txid}/hex`,
+		);
+
+		if (!response.ok) {
+			console.error(
+				`WhatsOnChain API error fetching tx hex: ${response.status} ${response.statusText}`,
+			);
+			return undefined;
+		}
+
+		const txHex = await response.text();
+		const tx = Transaction.fromHex(txHex);
+		const output = tx.outputs[vout];
+
+		if (!output) {
+			console.error(`Output index ${vout} not found in transaction ${txid}`);
+			return undefined;
+		}
+
+		return toBase64(output.lockingScript.toBinary());
+	} catch (error) {
+		console.error(
+			`Error getting script for transaction ${txid}:${vout}:`,
+			error,
+		);
+		return undefined;
+	}
+}

package/tools/wallet/refreshUtxos.ts

@@ -0,0 +1,76 @@
+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 { toBitcoin } from "satoshi-token";
+import { z } from "zod";
+import type { Wallet } from "./wallet";
+
+const refreshUtxosArgsSchema = z.object({});
+type RefreshUtxosArgs = z.infer<typeof refreshUtxosArgsSchema>;
+
+/**
+ * Registers the wallet_refreshUtxos tool that refreshes and returns the UTXOs for the wallet
+ */
+export function registerRefreshUtxosTool(server: McpServer, wallet: Wallet) {
+	server.tool(
+		"wallet_refreshUtxos",
+		"Refreshes and returns the wallet's UTXOs. This is useful for debugging UTXO issues, ensuring the wallet has the latest transaction outputs, and for verifying available funds before making transactions.",
+		{ args: refreshUtxosArgsSchema },
+		async (
+			{ args }: { args: RefreshUtxosArgs },
+			_extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
+		) => {
+			try {
+				// Force refresh the UTXOs
+				await wallet.refreshUtxos();
+
+				// Get the refreshed UTXOs
+				const { paymentUtxos, nftUtxos } = await wallet.getUtxos();
+
+				// Calculate total satoshis in payment UTXOs
+				const totalSatoshis = paymentUtxos.reduce(
+					(sum, utxo) => sum + utxo.satoshis,
+					0,
+				);
+
+				// Format the response
+				return {
+					content: [
+						{
+							type: "text",
+							text: JSON.stringify(
+								{
+									status: "success",
+									paymentUtxos: paymentUtxos.map((utxo) => ({
+										txid: utxo.txid,
+										vout: utxo.vout,
+										satoshis: utxo.satoshis,
+										outpoint: `${utxo.txid}_${utxo.vout}`,
+									})),
+									nftUtxos: nftUtxos.map((utxo) => ({
+										txid: utxo.txid,
+										vout: utxo.vout,
+										origin: utxo.origin,
+										outpoint: `${utxo.txid}_${utxo.vout}`,
+									})),
+									totalPaymentUtxos: paymentUtxos.length,
+									totalNftUtxos: nftUtxos.length,
+									totalSatoshis: totalSatoshis,
+									totalBsv: toBitcoin(totalSatoshis),
+								},
+								null,
+								2,
+							),
+						},
+					],
+				};
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				return { content: [{ type: "text", text: msg }], isError: true };
+			}
+		},
+	);
+}

package/tools/wallet/tools.ts

@@ -44,6 +44,7 @@ import type { createOrdinalsArgsSchema } from "./createOrdinals";
 import { registerGetAddressTool } from "./getAddress";
 import { registerGetPublicKeyTool } from "./getPublicKey";
 import { registerPurchaseListingTool } from "./purchaseListing";
+import { registerRefreshUtxosTool } from "./refreshUtxos";
 import { registerSendToAddressTool } from "./sendToAddress";
 import { registerTransferOrdTokenTool } from "./transferOrdToken";
 
@@ -83,6 +84,7 @@ type ToolArgSchemas = {
 	wallet_transferOrdToken: typeof transferOrdTokenArgsSchema;
 	wallet_a2bPublish: typeof a2bPublishArgsSchema;
 	wallet_createOrdinals: typeof createOrdinalsArgsSchema;
+	wallet_refreshUtxos: typeof emptyArgsSchema;
 };
 
 // Define a type for the handler function with proper argument types
@@ -133,6 +135,9 @@ export function registerWalletTools(
 	// Register the wallet_transferOrdToken tool
 	registerTransferOrdTokenTool(server, wallet);
 
+	// Register the wallet_refreshUtxos tool
+	registerRefreshUtxosTool(server, wallet);
+
 	// A2B tools have to be explicitly enabled
 	if (config.enableA2bTools) {
 		// Register the wallet_a2bPublishAgent tool

package/tools/wallet/wallet.ts

@@ -47,12 +47,8 @@ import type {
 	WalletCertificate,
 	WalletInterface,
 } from "@bsv/sdk";
-import {
-	type NftUtxo,
-	type Utxo,
-	fetchNftUtxos,
-	fetchPayUtxos,
-} from "js-1sat-ord";
+import { type NftUtxo, type Utxo, fetchNftUtxos } from "js-1sat-ord";
+import { fetchPaymentUtxos } from "./fetchPaymentUtxos";
 
 export class Wallet extends ProtoWallet implements WalletInterface {
 	private paymentUtxos: Utxo[] = [];
@@ -77,28 +73,37 @@ export class Wallet extends ProtoWallet implements WalletInterface {
 		try {
 			const privateKey = this.getPrivateKey();
 			if (!privateKey) {
-				console.warn("No private key available for fetching UTXOs");
-				return;
+				return; // Silent fail if no private key, keep existing UTXOs
 			}
 
-			const address = privateKey.toAddress();
+			const address = privateKey.toAddress().toString();
 			this.lastUtxoFetch = Date.now();
 
+			// Payment UTXOs
+			let newPaymentUtxos: Utxo[] | undefined = undefined;
 			try {
-				const utxos = await fetchPayUtxos(address);
-				this.paymentUtxos = utxos;
+				newPaymentUtxos = await fetchPaymentUtxos(address);
+				// Only update if we successfully got UTXOs
+				if (Array.isArray(newPaymentUtxos)) {
+					this.paymentUtxos = newPaymentUtxos;
+				}
 			} catch (error) {
-				console.error("Error fetching payment UTXOs:", error);
+				// Keep existing UTXOs, don't clear them on error
 			}
+
+			// NFT UTXOs - keep existing if fetch fails
+			let newNftUtxos: NftUtxo[] = [];
 			try {
-				const nftUtxos = await fetchNftUtxos(address);
-				this.nftUtxos = nftUtxos;
+				newNftUtxos = await fetchNftUtxos(address);
+				// Only update if we successfully got UTXOs
+				if (Array.isArray(newNftUtxos)) {
+					this.nftUtxos = newNftUtxos;
+				}
 			} catch (error) {
-				console.error("Error fetching NFT UTXOs:", error);
+				// Keep existing UTXOs, don't clear them on error
 			}
 		} catch (error) {
-			console.error("Error refreshing UTXOs:", error);
-			throw error;
+			// Silent global error, preserve existing UTXOs
 		}
 	}