bsv-mcp 0.0.34 → 0.0.35

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # BSV MCP Server Changelog
 
+## v0.0.35 - A2B Overlay Integration & Improved MCP Server Publishing
+
+### Features
+- **A2B Overlay Integration**: Implemented a robust connection to the A2B Overlay API
+  - Updated `a2b_discover` tool to search for on-chain MCP servers and agents
+  - Enhanced search capabilities with relevance-based result ranking
+  - User-friendly formatted output with command suggestions
+  - Support for filtering by type (agent/tool/all), block range, and free text search
+- **Improved MCP Server Publishing**: Enhanced the wallet_a2bPublishMcp tool
+  - Better identity key integration via LocalSigner
+  - More robust configuration for sigma signing
+  - Improved transaction handling and error reporting
+
+### Technical Improvements
+- Updated API endpoint to use production overlay service
+- Implemented enhanced search for better relevance scoring
+- Better error handling for API responses
+- Improved response formatting for readability
+- Updated type definitions for consistency
+
 ## v0.0.34 - Transaction Broadcast Control
 
 ### Features

package/index.ts

@@ -73,7 +73,7 @@ function initializePrivateKey(): PrivateKey | undefined {
 const privKey = initializePrivateKey();
 
 const server = new McpServer(
-	{ name: "Bitcoin SV", version: "0.0.34" },
+	{ name: "Bitcoin SV", version: "0.0.35" },
 	// {
 	// 	// Advertise only what you actually implement
 	// 	capabilities: {

package/package.json

@@ -2,7 +2,7 @@
 	"name": "bsv-mcp",
 	"module": "index.ts",
 	"type": "module",
-	"version": "0.0.34",
+	"version": "0.0.35",
 	"license": "MIT",
 	"author": "satchmo",
 	"description": "A collection of Bitcoin SV (BSV) tools for the Model Context Protocol (MCP) framework",
@@ -14,11 +14,12 @@
 		"bitcoin",
 		"bsv",
 		"bitcoin-sv",
-		"mcp",
-		"model-context-protocol",
 		"wallet",
 		"ordinals",
-		"blockchain"
+		"blockchain",
+		"1sat-ordinals",
+		"explorer",
+		"block explorer"
 	],
 	"files": [
 		"package.json",

package/resources/junglebus.ts

@@ -0,0 +1,242 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// Main JungleBus API documentation URL
+const JUNGLEBUS_DOCS_URL = "https://junglebus.gorillapool.io/docs/";
+
+/**
+ * Manually structured JungleBus API documentation
+ * Provides a clean summary of key JungleBus API endpoints and functionality
+ */
+export function getJungleBusDocumentation(): string {
+	return `# JungleBus API Documentation
+
+## Overview
+
+JungleBus is a transaction monitoring service for Bitcoin SV that allows applications to subscribe to transaction events and filter them based on specific criteria. The API provides both subscription and querying capabilities.
+
+## API Endpoints
+
+### Base URL
+\`\`\`
+https://junglebus.gorillapool.io/v1
+\`\`\`
+
+### Transaction API
+
+#### Get Transaction by ID
+\`\`\`
+GET /transaction/get/{txid}
+\`\`\`
+
+Returns detailed information about a specific transaction, including:
+- Transaction data (hex format)
+- Block information (hash, height, time)
+- Input and output details
+- Address information
+
+#### Get Transactions by Block Hash
+\`\`\`
+GET /block/{blockhash}/transactions
+\`\`\`
+
+Returns all transactions within a specific block.
+
+### Subscription API
+
+#### Create Subscription
+\`\`\`
+POST /subscribe
+\`\`\`
+
+Create a new subscription to monitor transactions based on filtering criteria.
+
+Example request body:
+\`\`\`json
+{
+  "callback": "https://your-callback-url.com",
+  "fromBlock": 0,
+  "query": {
+    "find": {
+      "out.tape.cell.s": "BEEF"
+    }
+  }
+}
+\`\`\`
+
+#### Delete Subscription
+\`\`\`
+DELETE /subscribe/{id}
+\`\`\`
+
+Deletes an existing subscription.
+
+### Network API
+
+#### Get Network Info
+\`\`\`
+GET /network/info
+\`\`\`
+
+Returns current blockchain network information, including block height and other statistics.
+
+## Client Implementations
+
+### TypeScript Client
+
+Installation:
+\`\`\`bash
+$ npm install @gorillapool/js-junglebus
+\`\`\`
+
+Usage:
+\`\`\`javascript
+import { JungleBusClient } from '@gorillapool/js-junglebus';
+
+const server = "junglebus.gorillapool.io";
+const jungleBusClient = new JungleBusClient(server, {
+  onConnected(ctx) {
+    // add your own code here
+    console.log(ctx);
+  },
+  onConnecting(ctx) {
+    // add your own code here
+    console.log(ctx);
+  },
+  onDisconnected(ctx) {
+    // add your own code here
+    console.log(ctx);
+  },
+  onError(ctx) {
+    // add your own code here
+    console.error(ctx);
+  }
+});
+
+// create subscriptions in the dashboard of the JungleBus website
+const subId = "...."; // fill in the ID for the subscription
+const fromBlock = 750000;
+
+const subscription = jungleBusClient.Subscribe(
+  subId,
+  fromBlock,
+  onPublish(tx) => {
+    // add your own code here
+    console.log(tx);
+  },
+  onStatus(ctx) => {
+    // add your own code here
+    console.log(ctx);
+  },
+  onError(ctx) => {
+    // add your own code here
+    console.log(ctx);
+  },
+  onMempool(tx) => {
+    // add your own code here
+    console.log(tx);
+  }
+);
+
+// For lite mode (transaction hash and block height only)
+await client.Subscribe("a5e2fa655c41753331539a2a86546bf9335ff6d9b7a512dc9acddb00ab9985c0", 1550000, onPublish, onStatus, onError, onMempool, true);
+\`\`\`
+
+### Go Client
+
+Installation:
+\`\`\`bash
+go get github.com/GorillaPool/go-junglebus
+\`\`\`
+
+Usage:
+\`\`\`go
+package main
+
+import (
+  "context"
+  "log"
+  "sync"
+  "github.com/GorillaPool/go-junglebus"
+  "github.com/GorillaPool/go-junglebus/models"
+)
+
+func main() {
+  wg := &sync.WaitGroup{}
+  
+  junglebusClient, err := junglebus.New(
+    junglebus.WithHTTP("https://junglebus.gorillapool.io"),
+  )
+  if err != nil {
+    log.Fatalln(err.Error())
+  }
+  
+  subscriptionID := "..." // fill in the ID for the subscription
+  fromBlock := uint64(750000)
+  
+  eventHandler := junglebus.EventHandler{
+    // do not set this function to leave out mined transactions
+    OnTransaction: func(tx *models.TransactionResponse) {
+      log.Printf("[TX]: %d: %v", tx.BlockHeight, tx.Id)
+    },
+    // do not set this function to leave out mempool transactions
+    OnMempool: func(tx *models.TransactionResponse) {
+      log.Printf("[MEMPOOL TX]: %v", tx.Id)
+    },
+    OnStatus: func(status *models.ControlResponse) {
+      log.Printf("[STATUS]: %v", status)
+    },
+    OnError: func(err error) {
+      log.Printf("[ERROR]: %v", err)
+    },
+  }
+  
+  var subscription *junglebus.Subscription
+  if subscription, err = junglebusClient.Subscribe(context.Background(), subscriptionID, fromBlock, eventHandler); err != nil {
+    log.Printf("ERROR: failed getting subscription %s", err.Error())
+  }
+  
+  // For lite mode
+  if subscription, err := junglebusClient.SubscribeWithQueue(context.Background(), subscriptionID, fromBlock, 0, eventHandler, &junglebus.SubscribeOptions{
+    QueueSize: 100000,
+    LiteMode: true,
+  }); err != nil {
+    log.Printf("ERROR: failed getting subscription %s", err.Error())
+  }
+  
+  wg.Add(1)
+  wg.Wait()
+}
+\`\`\`
+
+## Further Reading
+
+For complete API documentation, visit [JungleBus Docs](${JUNGLEBUS_DOCS_URL})
+`;
+}
+
+/**
+ * Register the JungleBus API documentation resource with the MCP server
+ * @param server The MCP server instance
+ */
+export function registerJungleBusResource(server: McpServer): void {
+	server.resource(
+		"junglebus-api-docs",
+		JUNGLEBUS_DOCS_URL,
+		{
+			title: "JungleBus API Documentation",
+			description:
+				"API documentation for JungleBus, a transaction monitoring service for Bitcoin SV",
+		},
+		async (uri) => {
+			const documentationContent = getJungleBusDocumentation();
+			return {
+				contents: [
+					{
+						uri: uri.href,
+						text: documentationContent,
+					},
+				],
+			};
+		},
+	);
+}

package/resources/resources.ts

@@ -1,6 +1,7 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { registerBRCsResources } from "./brcs";
 import { registerChangelogResource } from "./changelog";
+import { registerJungleBusResource } from "./junglebus";
 
 /**
  * Register all resources with the MCP server
@@ -13,5 +14,8 @@ export function registerResources(server: McpServer): void {
 	// Register changelog resource
 	registerChangelogResource(server);
 
+	// Register JungleBus API documentation resource
+	registerJungleBusResource(server);
+
 	// Add more resource categories here as needed
 }

package/tools/a2b/discover.ts

@@ -6,25 +6,34 @@ import type {
 } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 
-type OverlayRequest = {
+// API endpoint for the A2B Overlay service
+const OVERLAY_API_URL = "https://a2b-overlay-production.up.railway.app/v1";
+
+type A2BDiscoveryItem = {
+	txid: string;
+	outpoint: string;
 	type: "agent" | "tool";
-	query: string;
-	limit: number;
-	offset: number;
-	fromBlock?: number;
-	toBlock?: number;
+	app: string;
+	serverName: string;
+	command: string;
+	description: string;
+	keywords: string[];
+	args: Record<string, string>;
+	env: Record<string, string>;
+	blockHeight: number;
+	timestamp: string;
+	tools?: string[];
+	prompts?: string[];
+	resources?: string[];
 };
 
-type OverlayResponse = {
-	agents: {
-		name: string;
-		description: string;
-		capabilities: string[];
-	}[];
-	tools: {
-		name: string;
-		description: string;
-	}[];
+type OverlaySearchResponse = {
+	items: A2BDiscoveryItem[];
+	total: number;
+	limit: number;
+	offset: number;
+	queryType: "agent" | "tool" | "all";
+	query: string;
 };
 
 // Schema for agent discovery parameters
@@ -38,6 +47,73 @@ export const a2bDiscoverArgsSchema = z.object({
 });
 export type A2bDiscoverArgs = z.infer<typeof a2bDiscoverArgsSchema>;
 
+/**
+ * Format the response in a user-friendly way
+ */
+function formatSearchResults(data: unknown, queryType: string): string {
+	// console.log(`Received data: ${JSON.stringify(data).substring(0, 200)}...`); // Debug log
+
+	// Check if data is an object with items property
+	if (!data) {
+		return `No ${queryType} results found.`;
+	}
+
+	// Handle the new API format where data is an object with 'items' array
+	const items = Array.isArray(data)
+		? data
+		: (data as { items?: A2BDiscoveryItem[] }).items;
+
+	// Ensure items is an array
+	if (!items || !Array.isArray(items) || items.length === 0) {
+		return `No ${queryType} results found.`;
+	}
+
+	let result = `Found ${items.length} ${queryType === "all" ? "items" : `${queryType}s`}:\n\n`;
+
+	items.forEach((item, index) => {
+		if (!item) return;
+
+		// Agent or MCP server name with description
+		result += `${index + 1}. **${item.serverName || "Unknown"}** - ${item.description || "No description"}\n`;
+
+		// Display command to run
+		if (item.command) {
+			const args = item.args ? Object.values(item.args).join(" ") : "";
+			result += `   Command: \`${item.command} ${args}\`\n`;
+		}
+
+		// Add tools count if available
+		if (item.tools && Array.isArray(item.tools)) {
+			result += `   Tools: ${item.tools.length} available\n`;
+		}
+
+		// Add keywords if available
+		if (
+			item.keywords &&
+			Array.isArray(item.keywords) &&
+			item.keywords.length > 0
+		) {
+			result += `   Keywords: ${item.keywords.join(", ")}\n`;
+		}
+
+		// Add blockchain details
+		if (item.outpoint) {
+			result += `   Outpoint: ${item.outpoint}\n`;
+		}
+
+		if (item.blockHeight !== undefined) {
+			const date = item.timestamp
+				? new Date(item.timestamp).toLocaleDateString()
+				: "Unknown date";
+			result += `   Block: ${item.blockHeight}, ${date}\n`;
+		}
+
+		result += "\n";
+	});
+
+	return result;
+}
+
 /**
  * Registers the a2b_discover tool for on-chain agent discovery
  */
@@ -50,49 +126,113 @@ export function registerA2bDiscoverTool(server: McpServer) {
 			{ args }: { args: A2bDiscoverArgs },
 			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
 		) => {
-			if (args.queryType === "agent") {
-				return {
-					content: [
-						{ type: "text", text: "Agent discovery is not supported yet" },
-					],
-					isError: true,
-				};
-			}
-
-			if (args.queryType !== "tool") {
-				return {
-					content: [
-						{
-							type: "text",
-							text: "Only tool discovery is supported currently",
-						},
-					],
-					isError: true,
-				};
-			}
-
 			try {
 				const params = new URLSearchParams();
+
+				// Set query type (agent, tool, or all)
 				params.set("type", args.queryType);
-				params.set("query", args.query);
-				params.set("limit", args.limit?.toString() ?? "5");
+
+				// Use enhanced search for better relevance scoring
+				let searchEndpoint = "/search/enhanced";
+
+				// For empty queries, use the regular search endpoint
+				if (!args.query || !args.query.trim()) {
+					searchEndpoint = "/search";
+				} else {
+					params.set("q", args.query); // enhanced search uses 'q' parameter
+				}
+
+				// Add pagination parameters
+				params.set("limit", args.limit?.toString() ?? "10");
 				params.set("offset", args.offset?.toString() ?? "0");
+
+				// Add block range if specified
 				if (args.fromBlock) {
 					params.set("fromBlock", args.fromBlock.toString());
 				}
 				if (args.toBlock) {
 					params.set("toBlock", args.toBlock.toString());
 				}
-				const OVERLAY_URL = `https://overlay.a2b.network/v1/search?${params.toString()}`;
-				const response = await fetch(OVERLAY_URL);
-				const data = (await response.json()) as OverlayResponse;
+
+				// Construct the full URL
+				const searchUrl = `${OVERLAY_API_URL}${searchEndpoint}?${params.toString()}`;
+				//console.log(`Searching URL: ${searchUrl}`);
+
+				// Make the request to the overlay API
+				const response = await fetch(searchUrl, {
+					method: "GET",
+					headers: {
+						Accept: "application/json",
+					},
+				});
+
+				if (!response.ok) {
+					throw new Error(
+						`API returned status ${response.status}: ${response.statusText}`,
+					);
+				}
+
+				const data = (await response.json()) as OverlaySearchResponse;
+
+				// Format the results for better readability
+				let result = "";
+
+				if (data?.items?.length > 0) {
+					result = `Found ${data.items.length} ${args.queryType}(s):\n\n`;
+
+					data.items.forEach((item: A2BDiscoveryItem, index: number) => {
+						// Server name and description
+						result += `${index + 1}. **${item.serverName || "Unknown"}** - ${item.description || "No description"}\n`;
+
+						// Command to run
+						if (item.command) {
+							const cmdArgs = item.args
+								? Object.values(item.args).join(" ")
+								: "";
+							result += `   Command: \`${item.command} ${cmdArgs}\`\n`;
+						}
+
+						// Tools available
+						if (item.tools?.length) {
+							result += `   Tools: ${item.tools.length} available\n`;
+						}
+
+						// Keywords
+						if (item.keywords?.length) {
+							result += `   Keywords: ${item.keywords.join(", ")}\n`;
+						}
+
+						// Blockchain details
+						if (item.outpoint) {
+							result += `   Outpoint: ${item.outpoint}\n`;
+						}
+
+						if (item.blockHeight !== undefined) {
+							const date = item.timestamp
+								? new Date(item.timestamp).toLocaleDateString()
+								: "Unknown date";
+							result += `   Block: ${item.blockHeight}, ${date}\n`;
+						}
+
+						result += "\n";
+					});
+				} else {
+					result = `No ${args.queryType} results found.`;
+				}
+
 				return {
-					content: [{ type: "text", text: JSON.stringify(data) }],
+					content: [{ type: "text", text: result }],
 					isError: false,
 				};
 			} catch (error) {
+				console.error("Search error:", error);
 				return {
-					content: [{ type: "text", text: `Error querying overlay: ${error}` }],
+					content: [
+						{
+							type: "text",
+							text: `Error querying A2B Overlay: ${error instanceof Error ? error.message : String(error)}`,
+						},
+					],
 					isError: true,
 				};
 			}

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
 		}
 	}