bsv-mcp 0.0.23 → 0.0.24

package/README.md

@@ -8,6 +8,30 @@
 
 A collection of Bitcoin SV (BSV) tools for the Model Context Protocol (MCP) framework. This library provides wallet, ordinals, and utility functions for BSV blockchain interaction.
 
+## Installation and Setup
+
+### Prerequisites
+
+This project is built using [Bun](https://bun.sh/), a fast JavaScript runtime and package manager. While Bun is recommended for best performance, the server can also run with Node.js and npm.
+
+#### Installing Bun (Recommended)
+
+**macOS (using Homebrew):**
+```bash
+brew tap oven-sh/bun
+brew install bun
+```
+
+**macOS/Linux/WSL (using installer script):**
+```bash
+curl -fsSL https://bun.sh/install | bash
+```
+
+**Windows:**
+Windows users should use WSL (Windows Subsystem for Linux) or Docker to run Bun.
+
+Node.js and npm will also work but may not offer the same performance benefits.
+
 ## Connecting to MCP Clients
 
 This server implements the [Model Context Protocol](https://modelcontextprotocol.io/) (MCP), allowing AI assistants to utilize Bitcoin SV functionalities. You can connect this server to various MCP-compatible clients.
@@ -19,39 +43,59 @@ This server implements the [Model Context Protocol](https://modelcontextprotocol
 To use the BSV MCP server with [Cursor](https://cursor.sh/):
 
 1. Install Cursor if you haven't already
-2. Clone this repository and run `bun install` in the project directory
-3. Open Cursor and navigate to Settings → Extensions → Model Context Protocol
-4. Click "Add a new global MCP server"
-5. Enter the following configuration in JSON format:
+2. Open Cursor and navigate to Settings → Extensions → Model Context Protocol
+3. Click "Add a new global MCP server"
+4. Enter the following configuration in JSON format:
 
 ```json
-  {
-    "mcpServers": {
-      "Bitcoin SV": {
-        "command": "bunx",
-        "args": [
-          "bsv-mcp@latest"
-        ],
-        "env": {
-          "PRIVATE_KEY_WIF": "<your_private_key_wif>"
-        }
+{
+  "mcpServers": {
+    "Bitcoin SV": {
+      "command": "bunx",
+      "args": [
+        "bsv-mcp@latest"
+      ],
+      "env": {
+        "PRIVATE_KEY_WIF": "<your_private_key_wif>"
       }
     }
   }
+}
 ```
 
-6. Replace `<your_private_key_wif>` with your actual private key WIF (keep this secure!)
-7. Click "Save"
+5. Replace `<your_private_key_wif>` with your actual private key WIF (keep this secure!)
+6. Click "Save"
 
 The BSV tools will now be available to Cursor's AI assistant under the "Bitcoin SV" namespace.
 
+#### Alternative for npm users
+
+If you prefer to use npm instead of Bun:
+
+```json
+{
+  "mcpServers": {
+    "Bitcoin SV": {
+      "command": "npx",
+      "args": [
+        "bsv-mcp@latest"
+      ],
+      "env": {
+        "PRIVATE_KEY_WIF": "<your_private_key_wif>"
+      }
+    }
+  }
+}
+```
+
 ### Claude for Desktop
 
 To connect this server to Claude for Desktop:
 
-1. Ensure you have [Claude for Desktop](https://claude.ai/desktop) installed and updated to the latest version
-2. Clone this repository and run `bun install` in the project directory
-3. Open your Claude for Desktop configuration file:
+1. Open [Claude for Desktop](https://claude.ai/desktop) and go to Claude > Settings > Developer
+2. Click "Edit Config". 
+
+Open the Claude configuration json file in your favorite text editor. If you prefer to do it from the cli:
 
    ```bash
    # macOS/Linux
@@ -61,25 +105,29 @@ To connect this server to Claude for Desktop:
    code %APPDATA%\Claude\claude_desktop_config.json
    ```
 
-4. Add the BSV MCP server to your configuration (create the file if it doesn't exist):
+3. Add the BSV MCP server to your configuration:
    ```json
-    {
-      "mcpServers": {
-        "Bitcoin SV": {
-          "command": "bunx",
-          "args": [
-            "bsv-mcp@latest"
-          ],
-          "env": {
-            "PRIVATE_KEY_WIF": "<your_private_key_wif>"
-          }
-        }
-      }
-    }
+   {
+     "mcpServers": {
+       "Bitcoin SV": {
+         "command": "bunx",
+         "args": [
+           "bsv-mcp@latest"
+         ],
+         "env": {
+           "PRIVATE_KEY_WIF": "<your_private_key_wif>"
+         }
+       }
+     }
+   }
    ```
-5. Replace `<your_private_key_wif>` with your actual private key WIF
-6. Save the file and restart Claude for Desktop
-7. The BSV tools will appear when you click the tools icon (hammer) in Claude for Desktop
+4. Replace `<your_private_key_wif>` with your actual private key WIF
+5. Save the file and restart Claude for Desktop
+6. The BSV tools will appear when you click the tools icon (hammer) in Claude for Desktop
+
+#### Alternative for npm users (Claude)
+
+If you prefer to use npm instead of Bun, replace the "command" field with "npx".
 
 ## Available Tools
 
@@ -179,6 +227,102 @@ Once connected, you can use natural language to interact with Bitcoin SV through
 
 - "Convert 'Hello World' from UTF-8 to hex format"
 
+## MCP Prompts and Resources
+
+The BSV MCP server exposes specialized prompts and resources that provide detailed information and context about Bitcoin SV technologies. These can be accessed by AI models to enhance their understanding and capabilities.
+
+### Available Prompts
+
+The server provides the following educational prompts that can be accessed directly via the MCP protocol:
+
+#### Ordinals Prompt
+- **Identifier**: `bitcoin_sv_ordinals`
+- **Description**: Comprehensive information about Bitcoin SV ordinals, including what they are, how they work, and how to use them.
+- **Usage**: Ask the assistant about "Bitcoin SV ordinals" or "1Sat Ordinals" to access this information.
+
+#### BSV SDK Prompts
+A collection of prompts providing detailed information about the Bitcoin SV SDK:
+
+- **Overview**
+  - **Identifier**: `bitcoin_sv_sdk_overview`
+  - **Description**: General overview of the Bitcoin SV SDK, including its purpose and main components.
+  - **Usage**: "Tell me about the BSV SDK" or "What is the Bitcoin SV SDK?"
+
+- **Wallet Operations**
+  - **Identifier**: `bitcoin_sv_sdk_wallet`
+  - **Description**: Information about wallet operations in the BSV SDK.
+  - **Usage**: "How do wallet operations work in the BSV SDK?"
+
+- **Transaction Building**
+  - **Identifier**: `bitcoin_sv_sdk_transaction`
+  - **Description**: Details about transaction creation and manipulation.
+  - **Usage**: "Explain BSV SDK transaction building" or "How do I create transactions with BSV SDK?"
+
+- **Authentication**
+  - **Identifier**: `bitcoin_sv_sdk_auth`
+  - **Description**: Authentication and identity protocols in BSV SDK.
+  - **Usage**: "How does authentication work with BSV SDK?"
+
+- **Cryptography**
+  - **Identifier**: `bitcoin_sv_sdk_cryptography`
+  - **Description**: Signing, encryption, and verification functionality.
+  - **Usage**: "Explain BSV SDK cryptography features"
+
+- **Scripting**
+  - **Identifier**: `bitcoin_sv_sdk_script`
+  - **Description**: Bitcoin scripting and contract capabilities.
+  - **Usage**: "How do I work with Bitcoin scripts using the BSV SDK?"
+
+- **Primitives**
+  - **Identifier**: `bitcoin_sv_sdk_primitives`
+  - **Description**: Core data types and structures in the BSV SDK.
+  - **Usage**: "What primitives are available in the BSV SDK?"
+
+### Available Resources
+
+The server also provides access to Bitcoin Request for Comments (BRC) specifications and documentation:
+
+#### BRC Resources
+- **BRCs Overview**
+  - **Identifier**: `brcs_readme`
+  - **Description**: Overview of all Bitcoin SV protocol specifications in the BRCs repository.
+  - **Usage**: "Show me the Bitcoin SV BRCs overview"
+
+- **BRCs Summary**
+  - **Identifier**: `brcs_summary`
+  - **Description**: Table of contents for all Bitcoin SV BRCs.
+  - **Usage**: "Give me a summary of Bitcoin SV BRCs"
+
+- **Specific BRC Specifications**
+  - **Identifier**: `brc_spec`
+  - **Description**: Access specific BRC specifications by category and number.
+  - **Usage**: "Show me BRC 8 on Transaction Envelopes" or "What does BRC 1 specify?"
+
+#### BRC Categories
+The BRC specifications are organized into the following categories:
+- Wallet
+- Transactions
+- Scripts
+- Tokens
+- Overlays
+- Payments
+- Peer-to-Peer
+- Key Derivation
+- Outpoints
+- Opinions
+- State Machines
+- Apps
+
+### Using Prompts and Resources
+
+AI models can use these prompts and resources to provide more accurate and detailed responses about Bitcoin SV technologies. As a user, you can:
+
+1. **Ask about a specific topic**: "Tell me about Bitcoin SV ordinals" or "Explain BSV SDK transaction building"
+2. **Request specific BRC details**: "What does BRC 8 specify?" or "Show me the BRC on Transaction Creation"
+3. **Get general overviews**: "What is the BSV SDK?" or "Show me a summary of all BRCs"
+
+These prompts and resources enhance the AI's knowledge base, enabling more technical and accurate responses even for complex Bitcoin SV topics.
+
 ## How MCP Works
 
 When you interact with an MCP-enabled AI assistant:
@@ -191,17 +335,39 @@ When you interact with an MCP-enabled AI assistant:
 
 ## Troubleshooting
 
-If you're having issues connecting to the server:
+If you're having issues with the BSV MCP server:
+
+### Connection Issues
 
-1. Ensure the package dependencies are properly installed: `bun install`
+1. Make sure Bun or Node.js is installed on your system
 2. Verify your WIF private key is correctly set in the environment
 3. Check that your client supports MCP and is properly configured
 4. Look for error messages in the client's console output
 
+### Keeping Bun Up to Date
+
+It's important to keep Bun updated to the latest version to ensure compatibility:
+
+```bash
+# Update Bun to the latest version
+bun upgrade
+```
+
+To verify your current Bun version:
+```bash
+bun --version
+```
+
+### Logging and Debugging
+
 For Claude for Desktop, check the logs at:
 
 ```bash
+# macOS/Linux
 tail -n 20 -f ~/Library/Logs/Claude/mcp*.log
+
+# Windows
+type %APPDATA%\Claude\Logs\mcp*.log
 ```
 
 For Cursor, check the Cursor MCP logs in Settings → Extensions → Model Context Protocol.
@@ -314,16 +480,37 @@ The tool supports both mainnet and testnet:
 
 # Development
 
+## Project Setup
+
+If you want to contribute to the project or run it locally:
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/b-open-io/bsv-mcp.git
+   cd bsv-mcp
+   ```
+
+2. Install dependencies:
+   ```bash
+   bun install
+   # or with npm
+   npm install
+   ```
+
 ## Running the Server
 
 ```bash
 bun run index.ts
+# or with npm
+npm run start
 ```
 
 ### Running Tests
 
 ```bash
 bun test
+# or with npm
+npm test
 ```
 
 ## License

package/index.ts

@@ -2,6 +2,8 @@
 import { PrivateKey } from "@bsv/sdk";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerAllPrompts } from "./prompts";
+import { registerResources } from "./resources/resources";
 import { registerAllTools } from "./tools";
 import { registerWalletTools } from "./tools/wallet/tools";
 import { Wallet } from "./tools/wallet/wallet";
@@ -43,10 +45,25 @@ function validatePrivateKey(): PrivateKey {
 // Validate private key early before starting the server
 const privKey = validatePrivateKey();
 
-const server = new McpServer({
-	name: "Bitcoin SV MCP Server",
-	version: "0.0.23",
-});
+const server = new McpServer(
+	{ name: "Bitcoin SV", version: "0.0.24" },
+	// {
+	// 	// Advertise only what you actually implement
+	// 	capabilities: {
+	// 		completions: {},
+	// 		experimental: {},
+	// 		logging: {},
+	// 		prompts: {},
+	// 		resources: {},
+	// 		tools: {},
+	// 	},
+	// 	// Optional instructions banner for clients
+	// 	instructions: `
+	// 		This server exposes Bitcoin SV helpers.
+	// 		Tools are idempotent unless marked destructive.
+	// 	`,
+	// },
+);
 
 // Initialize wallet with the validated private key
 const wallet = new Wallet(privKey);
@@ -57,6 +74,12 @@ registerWalletTools(server, wallet);
 // Register all other tools (BSV, Ordinals, Utils, etc.)
 registerAllTools(server);
 
+// Register resources
+registerResources(server);
+
+// Register prompts
+registerAllPrompts(server);
+
 // Connect to the transport
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/package.json

@@ -2,7 +2,7 @@
 	"name": "bsv-mcp",
 	"module": "index.ts",
 	"type": "module",
-	"version": "0.0.23",
+	"version": "0.0.24",
 	"license": "MIT",
 	"author": "satchmo",
 	"description": "A collection of Bitcoin SV (BSV) tools for the Model Context Protocol (MCP) framework",
@@ -41,8 +41,8 @@
 		"typescript": "^5.8.3"
 	},
 	"dependencies": {
-		"@bsv/sdk": "^1.4.19",
-		"@modelcontextprotocol/sdk": "^1.10.1",
+		"@bsv/sdk": "^1.4.20",
+		"@modelcontextprotocol/sdk": "^1.10.2",
 		"@types/node": "^22.14.1",
 		"js-1sat-ord": "^0.1.81",
 		"mnee": "^2.0.0",

package/tools/a2b/call.ts

@@ -0,0 +1,32 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import { z } from "zod";
+
+// Schema for invoking another agent via A2A protocol
+export const a2aCallArgsSchema = z.object({
+	url: z.string().url().describe("Full agent-to-agent endpoint URL"),
+	method: z.string().describe("A2A method name to invoke"),
+	params: z
+		.record(z.any())
+		.optional()
+		.describe("Payload parameters for the A2A call"),
+});
+export type A2aCallArgs = z.infer<typeof a2aCallArgsSchema>;
+
+/**
+ * Registers the a2a_call tool for agent-to-agent HTTP/SSE calls
+ */
+export function registerA2aCallTool(server: McpServer) {
+	server.tool(
+		"a2a_call",
+		"Invoke a remote agent's A2A endpoint via HTTP/SSE",
+		{ args: a2aCallArgsSchema },
+		async ({ args }: { args: A2aCallArgs }, extra: RequestHandlerExtra) => {
+			// TODO: implement HTTP request logic (e.g., fetch, SSE)
+			return {
+				content: [{ type: "text", text: "Not implemented" }],
+				isError: true,
+			};
+		},
+	);
+}

package/tools/a2b/discover.ts

@@ -0,0 +1,101 @@
+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";
+
+type OverlayRequest = {
+	type: "agent" | "tool";
+	query: string;
+	limit: number;
+	offset: number;
+	fromBlock?: number;
+	toBlock?: number;
+};
+
+type OverlayResponse = {
+	agents: {
+		name: string;
+		description: string;
+		capabilities: string[];
+	}[];
+	tools: {
+		name: string;
+		description: string;
+	}[];
+};
+
+// Schema for agent discovery parameters
+export const a2bDiscoverArgsSchema = z.object({
+	queryType: z.enum(["agent", "tool"]).describe("Type of discovery to perform"),
+	query: z.string().describe("Search agent or tool names, descriptions"),
+	limit: z.number().optional().describe("Limit the number of results"),
+	offset: z.number().optional().describe("Offset the results"),
+	fromBlock: z.number().optional().describe("From block"),
+	toBlock: z.number().optional().describe("To block"),
+});
+export type A2bDiscoverArgs = z.infer<typeof a2bDiscoverArgsSchema>;
+
+/**
+ * Registers the a2b_discover tool for on-chain agent discovery
+ */
+export function registerA2bDiscoverTool(server: McpServer) {
+	server.tool(
+		"a2b_discover",
+		"Search on-chain agent and MCP tool records. Use 'agent' to search for agents, 'tool' to search for MCP tools.",
+		{ args: a2bDiscoverArgsSchema },
+		async (
+			{ 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();
+				params.set("type", args.queryType);
+				params.set("query", args.query);
+				params.set("limit", args.limit?.toString() ?? "5");
+				params.set("offset", args.offset?.toString() ?? "0");
+				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;
+				return {
+					content: [{ type: "text", text: JSON.stringify(data) }],
+					isError: false,
+				};
+			} catch (error) {
+				return {
+					content: [{ type: "text", text: `Error querying overlay: ${error}` }],
+					isError: true,
+				};
+			}
+		},
+	);
+}

package/tools/index.ts

@@ -1,4 +1,6 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerA2aCallTool } from "./a2b/call";
+import { registerA2bDiscoverTool } from "./a2b/discover";
 import { registerBsvTools } from "./bsv";
 import { registerMneeTools } from "./mnee";
 import { registerOrdinalsTools } from "./ordinals";
@@ -18,6 +20,12 @@ export function registerAllTools(server: McpServer): void {
 	// Register utility tools
 	registerUtilsTools(server);
 
+	// Register agent-to-blockchain discovery tool
+	registerA2bDiscoverTool(server);
+
+	// Register agent-to-agent call tool
+	// registerA2aCallTool(server);
+
 	// Register MNEE tools
 	registerMneeTools(server);
 

package/tools/wallet/a2bPublishAgent.ts

@@ -0,0 +1,284 @@
+import { 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 { createOrdinals } from "js-1sat-ord";
+import type {
+	ChangeResult,
+	Destination,
+	Inscription,
+	PreMAP,
+} from "js-1sat-ord";
+import { z } from "zod";
+import type { Wallet } from "./wallet";
+const { toArray, toBase64 } = Utils;
+
+// https://raw.githubusercontent.com/google/A2A/refs/heads/main/specification/json/a2a.json
+
+// A2A AgentCard schema (per A2A spec)
+const AgentCapabilitiesSchema = z.object({
+	streaming: z.boolean().default(false),
+	pushNotifications: z.boolean().default(false),
+	stateTransitionHistory: z.boolean().default(false),
+});
+const AgentSkillSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	description: z.string().nullable(),
+	tags: z.array(z.string()).nullable(),
+	examples: z.array(z.string()).nullable(),
+	inputModes: z.array(z.string()).nullable(),
+	outputModes: z.array(z.string()).nullable(),
+});
+
+// Provider per A2A spec
+const AgentProviderSchema = z
+	.object({
+		organization: z.string(),
+		url: z.string().url().nullable().default(null),
+	})
+	.nullable()
+	.default(null);
+
+// Authentication per A2A spec
+const AgentAuthenticationSchema = z
+	.object({
+		schemes: z.array(z.string()),
+		credentials: z.string().nullable().default(null),
+	})
+	.nullable()
+	.default(null);
+
+// Pricing plan schema
+export const PricingSchema = z.object({
+	id: z.string(),
+	description: z.string().nullable().optional(),
+	currency: z.string(),
+	amount: z
+		.number()
+		.describe(
+			"Cost in standard units of currency (e.g., BSV, USD, not satoshis)",
+		),
+	address: z.string(),
+	acceptedCurrencies: z.array(z.string()).optional(),
+	skills: z.array(z.string()).optional(),
+	interval: z.enum(["day", "week", "month", "year"]).nullable().optional(),
+	includedCalls: z.record(z.number()).optional(),
+});
+
+export type PricingConfig = z.infer<typeof PricingSchema>;
+
+export const AgentCardSchema = z.object({
+	name: z.string(),
+	description: z.string().nullable().default(null),
+	url: z.string().url(),
+	provider: AgentProviderSchema,
+	version: z.string(),
+	documentationUrl: z.string().url().nullable().default(null),
+	capabilities: AgentCapabilitiesSchema,
+	authentication: AgentAuthenticationSchema,
+	defaultInputModes: z.array(z.string()).default(["text"]),
+	defaultOutputModes: z.array(z.string()).default(["text"]),
+	skills: z.array(AgentSkillSchema),
+	"x-payment": z.array(PricingSchema).optional().default([]),
+});
+
+// Schema for on-chain agent publish parameters
+export const a2bPublishArgsSchema = z.object({
+	agentUrl: z
+		.string()
+		.url()
+		.describe("Agent base URL (e.g. https://example.com)"),
+	agentName: z.string().describe("Human-friendly agent name"),
+	description: z
+		.string()
+		.nullable()
+		.optional()
+		.describe("Optional agent description"),
+	providerOrganization: z
+		.string()
+		.optional()
+		.describe("Optional provider organization name"),
+	providerUrl: z.string().url().optional().describe("Optional provider URL"),
+	version: z.string().optional().describe("Optional agent version"),
+	documentationUrl: z
+		.string()
+		.url()
+		.nullable()
+		.optional()
+		.describe("Optional documentation URL"),
+	streaming: z
+		.boolean()
+		.default(false)
+		.describe("Supports SSE (tasks/sendSubscribe)"),
+	pushNotifications: z
+		.boolean()
+		.default(false)
+		.describe("Supports push notifications"),
+	stateTransitionHistory: z
+		.boolean()
+		.default(false)
+		.describe("Supports state transition history"),
+	defaultInputModes: z
+		.array(z.string())
+		.default(["text"])
+		.describe("Default input modes"),
+	defaultOutputModes: z
+		.array(z.string())
+		.default(["text"])
+		.describe("Default output modes"),
+	skills: z
+		.array(AgentSkillSchema)
+		.optional()
+		.default([])
+		.describe("List of agent skills"),
+	destinationAddress: z
+		.string()
+		.optional()
+		.describe("Optional target address for inscription"),
+});
+export type A2bPublishArgs = z.infer<typeof a2bPublishArgsSchema>;
+
+/**
+ * Registers the wallet_a2bPublish tool for publishing an agent record on-chain
+ */
+export function registerA2bPublishAgentTool(server: McpServer, wallet: Wallet) {
+	server.tool(
+		"wallet_a2bPublish",
+		"Publish an agent.json record on-chain via Ordinal inscription",
+		{ args: a2bPublishArgsSchema },
+		async (
+			{ args }: { args: A2bPublishArgs },
+			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
+		) => {
+			try {
+				const paymentPk = wallet.getPrivateKey();
+				if (!paymentPk) throw new Error("No private key available");
+				const { paymentUtxos } = await wallet.getUtxos();
+				if (!paymentUtxos?.length)
+					throw new Error("No payment UTXOs available to fund inscription");
+
+				// TODO: Get the skills from actually running the MCP instead of trusting the agent args for args.skills
+				const walletAddress = paymentPk.toAddress().toString();
+
+				// Create pricing plans using the new schema
+				const pricingConfig: PricingConfig[] = [
+					// {
+					//   id: "subscription-premium",
+					//   description: "Premium subscription with all features",
+					//   currency: "USD",
+					//   amount: 10,
+					//   address: walletAddress,
+					//   interval: "month",
+					//   skills: ["wallet_a2bPublish", "wallet_a2bCall"],
+					// },
+					// {
+					//   id: "subscription-free",
+					//   description: "Free tier with limited features",
+					//   currency: "USD",
+					//   amount: 0,
+					//   address: walletAddress,
+					//   interval: "month",
+					//   skills: ["wallet_a2bCall"],
+					// },
+					{
+						id: "pay-per-call-default",
+						description: "Pay-per-call for publish operations",
+						currency: "USD",
+						amount: 1,
+						address: walletAddress,
+						skills: ["wallet_a2bPublish"],
+						interval: null,
+					},
+					// {
+					//   id: "pay-per-call-royalty",
+					//   description: "Royalty payment for agent",
+					//   currency: "USD",
+					//   amount: 1,
+					//   address: "1JOExxxxxxxxxxxx",
+					//   skills: ["wallet_a2bPublish"],
+					//   interval: null,
+					// }
+				];
+
+				// Assemble AgentCard with defaults and user overrides
+				const agentCard = {
+					name: args.agentName,
+					description: args.description ?? null,
+					url: args.agentUrl,
+					provider:
+						args.providerOrganization && args.providerUrl
+							? {
+									organization: args.providerOrganization,
+									url: args.providerUrl,
+								}
+							: null,
+					version: args.version ?? "1.0.0",
+					documentationUrl: args.documentationUrl ?? null,
+					capabilities: {
+						streaming: args.streaming,
+						pushNotifications: args.pushNotifications,
+						stateTransitionHistory: args.stateTransitionHistory,
+					},
+					authentication: null,
+					defaultInputModes: args.defaultInputModes,
+					defaultOutputModes: args.defaultOutputModes,
+					skills: args.skills,
+					"x-payment-config": pricingConfig,
+				};
+				// Validate compliance
+				AgentCardSchema.parse(agentCard);
+				const fileContent = JSON.stringify(agentCard, null, 2);
+				// Base64 payload for inscription
+				const dataB64 = toBase64(toArray(fileContent));
+				const inscription: Inscription = {
+					dataB64,
+					contentType: "application/json",
+				};
+				// Destination for the ordinal
+				const targetAddress = args.destinationAddress ?? walletAddress;
+				const destinations: Destination[] = [
+					{ address: targetAddress, inscription },
+				];
+				// Default MAP metadata: file path, content type, encoding
+				const metaData: PreMAP = { app: "bsv-mcp", type: "a2b" };
+
+				// Inscribe the ordinal on-chain via js-1sat-ord
+				const result = await createOrdinals({
+					utxos: paymentUtxos,
+					destinations,
+					paymentPk,
+					changeAddress: walletAddress,
+					metaData,
+				});
+				const changeResult = result as ChangeResult;
+				await changeResult.tx.broadcast();
+				// Refresh UTXOs
+				try {
+					await wallet.refreshUtxos();
+				} catch {}
+				// Return transaction details
+				return {
+					content: [
+						{
+							type: "text",
+							text: JSON.stringify({
+								txid: changeResult.tx.id("hex"),
+								spentOutpoints: changeResult.spentOutpoints,
+								payChange: changeResult.payChange,
+								inscriptionAddress: targetAddress,
+								agentCard,
+							}),
+						},
+					],
+				};
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				return { content: [{ type: "text", text: msg }], isError: true };
+			}
+		},
+	);
+}

package/tools/wallet/a2bPublishMcp.ts

@@ -0,0 +1,161 @@
+import { 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 { createOrdinals } from "js-1sat-ord";
+import type {
+	ChangeResult,
+	Destination,
+	Inscription,
+	PreMAP,
+} from "js-1sat-ord";
+import { z } from "zod";
+import type { Wallet } from "./wallet";
+const { toArray, toBase64 } = Utils;
+
+// 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"),
+	env: z.record(z.string()).optional().describe("Environment variables"),
+});
+
+export type McpConfig = z.infer<typeof McpConfigSchema>;
+
+// Schema for on-chain tool publish parameters
+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"),
+	env: z
+		.record(z.string())
+		.optional()
+		.describe("Optional environment variables"),
+	description: z.string().optional().describe("Optional tool description"),
+	destinationAddress: z
+		.string()
+		.optional()
+		.describe("Optional target address for inscription"),
+});
+
+export type A2bPublishMcpArgs = z.infer<typeof a2bPublishMcpArgsSchema>;
+
+/**
+ * Registers the wallet_a2bPublishMcp for publishing an MCP tool configuration on-chain
+ */
+export function registerA2bPublishMcpTool(server: McpServer, wallet: Wallet) {
+	server.tool(
+		"wallet_a2bPublishMcp",
+		"Publish an MCP tool configuration record on-chain via Ordinal inscription",
+		{ args: a2bPublishMcpArgsSchema },
+		async (
+			{ args }: { args: A2bPublishMcpArgs },
+			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
+		) => {
+			try {
+				const paymentPk = wallet.getPrivateKey();
+				if (!paymentPk) throw new Error("No private key available");
+
+				const { paymentUtxos } = await wallet.getUtxos();
+				if (!paymentUtxos?.length)
+					throw new Error("No payment UTXOs available to fund inscription");
+
+				const walletAddress = paymentPk.toAddress().toString();
+
+				// Assemble tool configuration
+				const toolConfig: McpConfig = {
+					command: args.command,
+					args: args.args,
+					env: args.env,
+				};
+
+				// Validate compliance
+				McpConfigSchema.parse(toolConfig);
+
+				// Prepare the full configuration with metadata
+				const fullConfig = {
+					name: args.toolName,
+					description: args.description || `MCP Tool: ${args.toolName}`,
+					config: toolConfig,
+					type: "mcp-tool",
+				};
+
+				const fileContent = JSON.stringify(fullConfig, null, 2);
+
+				// Base64 payload for inscription
+				const dataB64 = toBase64(toArray(fileContent));
+				const inscription: Inscription = {
+					dataB64,
+					contentType: "application/json",
+				};
+
+				// Destination for the ordinal
+				const targetAddress = args.destinationAddress ?? walletAddress;
+				const destinations: Destination[] = [
+					{ address: targetAddress, inscription },
+				];
+
+				// 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({
+					utxos: paymentUtxos,
+					destinations,
+					paymentPk,
+					changeAddress: walletAddress,
+					metaData,
+				});
+
+				const changeResult = result as ChangeResult;
+
+				// Broadcast the transaction
+				await changeResult.tx.broadcast();
+
+				// Refresh UTXOs after spending
+				try {
+					await wallet.refreshUtxos();
+				} catch (refreshError) {
+					console.warn(
+						"Failed to refresh UTXOs after transaction:",
+						refreshError,
+					);
+				}
+
+				// Build a nicely formatted result
+				const outpointIndex = 0; // First output with the inscription
+				const outpoint = `${changeResult.tx.id("hex")}_${outpointIndex}`;
+
+				// Tool URL for discovery is the outpoint
+				const onchainUrl = `ord://${outpoint}`;
+
+				return {
+					content: [
+						{
+							type: "text",
+							text: JSON.stringify(
+								{
+									status: "success",
+									txid: changeResult.tx.id("hex"),
+									outpoint,
+									onchainUrl,
+									toolName: args.toolName,
+									description: args.description || `MCP Tool: ${args.toolName}`,
+									address: targetAddress,
+								},
+								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/getPublicKey.ts

@@ -0,0 +1,35 @@
+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 type { z } from "zod";
+import { getPublicKeyArgsSchema } from "./schemas";
+import type { Wallet } from "./wallet";
+
+// Use the schema imported from schemas.ts
+export type GetPublicKeyArgs = z.infer<typeof getPublicKeyArgsSchema>;
+
+/**
+ * Register the getPublicKey tool
+ */
+export function registerGetPublicKeyTool(server: McpServer, wallet: Wallet) {
+	server.tool(
+		"wallet_getPublicKey",
+		"Retrieves the current wallet's public key. This public key can be used for cryptographic operations like signature verification or encryption.",
+		{ args: getPublicKeyArgsSchema },
+		async (
+			{ args }: { args: GetPublicKeyArgs },
+			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
+		) => {
+			try {
+				const result = await wallet.getPublicKey(args);
+				return { content: [{ type: "text", text: JSON.stringify(result) }] };
+			} 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

@@ -31,7 +31,7 @@ import {
 	createSignatureArgsSchema,
 	type emptyArgsSchema,
 	type getAddressArgsSchema,
-	getPublicKeyArgsSchema,
+	type getPublicKeyArgsSchema,
 	type purchaseListingArgsSchema,
 	type sendToAddressArgsSchema,
 	verifySignatureArgsSchema,
@@ -42,9 +42,13 @@ import { Utils, type WalletProtocol } from "@bsv/sdk";
 import { registerCreateOrdinalsTool } from "./createOrdinals";
 import type { createOrdinalsArgsSchema } from "./createOrdinals";
 import { registerGetAddressTool } from "./getAddress";
+import { registerGetPublicKeyTool } from "./getPublicKey";
 import { registerPurchaseListingTool } from "./purchaseListing";
 import { registerSendToAddressTool } from "./sendToAddress";
 import { registerTransferOrdTokenTool } from "./transferOrdToken";
+
+import type { a2bPublishArgsSchema } from "./a2bPublishAgent";
+import { registerA2bPublishMcpTool } from "./a2bPublishMcp";
 import type { transferOrdTokenArgsSchema } from "./transferOrdToken";
 
 // Define mapping from tool names to argument schemas
@@ -77,6 +81,7 @@ type ToolArgSchemas = {
 	wallet_sendToAddress: typeof sendToAddressArgsSchema;
 	wallet_purchaseListing: typeof purchaseListingArgsSchema;
 	wallet_transferOrdToken: typeof transferOrdTokenArgsSchema;
+	wallet_a2bPublish: typeof a2bPublishArgsSchema;
 	wallet_createOrdinals: typeof createOrdinalsArgsSchema;
 };
 
@@ -115,34 +120,24 @@ export function registerWalletTools(
 	// Register the wallet_getAddress tool
 	registerGetAddressTool(server);
 
+	// Register the wallet_getPublicKey tool
+	registerGetPublicKeyTool(server, wallet);
+
 	// Register the wallet_purchaseListing tool
 	registerPurchaseListingTool(server, wallet);
 
 	// Register the wallet_transferOrdToken tool
 	registerTransferOrdTokenTool(server, wallet);
 
+	// Register the wallet_a2bPublishAgent tool
+	// registerA2bPublishAgentTool(server, wallet);
+
+	// Register the wallet_a2bPublishMcp tool
+	registerA2bPublishMcpTool(server, wallet);
+
 	// Register only the minimal public-facing tools
 	// wallet_createAction, wallet_signAction and wallet_getHeight have been removed
 
-	// Register wallet_getPublicKey
-	registerTool(
-		"wallet_getPublicKey",
-		"Retrieves the current wallet's public key. This public key can be used for cryptographic operations like signature verification or encryption.",
-		{ args: getPublicKeyArgsSchema },
-		async (
-			{ args }: { args: z.infer<typeof getPublicKeyArgsSchema> },
-			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
-		) => {
-			try {
-				const result = await wallet.getPublicKey(args);
-				return { content: [{ type: "text", text: JSON.stringify(result) }] };
-			} catch (err: unknown) {
-				const msg = err instanceof Error ? err.message : String(err);
-				return { content: [{ type: "text", text: msg }], isError: true };
-			}
-		},
-	);
-
 	// Register wallet_createSignature
 	registerTool(
 		"wallet_createSignature",