bsv-mcp 0.0.18 → 0.0.20

package/README.md

@@ -48,22 +48,23 @@ To use the BSV MCP server with [Cursor](https://cursor.sh/):
 5. Enter the following configuration in JSON format:
 
 ```json
-{
-  "Bitcoin SV": {
-    "command": "env",
-    "args": [
-      "PRIVATE_KEY_WIF=<your_private_key_wif>",
-      "bun",
-      "run",
-      "<path_to_project>/index.ts"
-    ]
+  {
+    "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. Replace `<path_to_project>` with the full path to where you cloned this repository
-8. Click "Save"
+7. Click "Save"
 
 The BSV tools will now be available to Cursor's AI assistant under the "Bitcoin SV" namespace.
 
@@ -76,59 +77,30 @@ To connect this server to Claude for Desktop:
 3. Open your Claude for Desktop configuration file:
    ```bash
    # macOS/Linux
-   code ~/Library/Application\ Support/Claude/claude_desktop_config.json
+   code ~/Library/Application Support/Claude/claude_desktop_config.json
    
    # Windows
    code %APPDATA%\Claude\claude_desktop_config.json
    ```
 4. Add the BSV MCP server to your configuration (create the file if it doesn't exist):
    ```json
-   {
-     "mcpServers": {
-       "Bitcoin SV": {
-         "command": "env",
-         "args": [
-           "PRIVATE_KEY_WIF=<your_private_key_wif>",
-           "bun",
-           "run",
-           "<path_to_project>/index.ts"
-         ]
-       }
-     }
-   }
+  {
+    "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. Replace `<path_to_project>` with the full path to where you cloned this repository
-7. Save the file and restart Claude for Desktop
-8. The BSV tools will appear when you click the tools icon (hammer) in Claude for Desktop
-
-### Generic MCP Client Integration
-
-For other MCP clients that support JSON configuration:
-
-```json
-{
-  "Bitcoin SV": {
-    "command": "env",
-    "args": [
-      "PRIVATE_KEY_WIF=<your_private_key_wif>",
-      "bun",
-      "run",
-      "<path_to_project>/index.ts"
-    ]
-  }
-}
-```
-
-If running the server directly:
-
-```bash
-# Set environment variable first
-export PRIVATE_KEY_WIF=<your_private_key_wif>
-
-# Then run the server
-bun run index.ts
-```
+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
 
 ## Available Tools
 
@@ -267,6 +239,15 @@ The tool supports the following endpoint categories and specific endpoints:
 | `block_by_hash` | Complete block data via hash | `blockHash` | `{"hash":"000000000000...","confirmations":1000,"size":1000000,...}` |
 | `block_by_height` | Complete block data via height | `blockHeight` | `{"hash":"000000000000...","confirmations":1000,"size":1000000,...}` |
 | `tag_count_by_height` | Stats on tag count for a specific block | `blockHeight` | `{"tags":{"amp":3,"bitkey":5,"metanet":12,"planaria":7,"b":120}}` |
+| `block_headers` | Retrieves the last 10 block headers | None | `[{"hash":"000000000000...","height":826458,"version":536870912,...},...]` |
+| `block_pages` | Retrieves pages of transaction IDs for large blocks | `blockHash`, optional: `pageNumber` | `["tx1hash","tx2hash","tx3hash",...]` |
+
+#### Stats Data
+| Endpoint | Description | Required Parameters | Example Response |
+|----------|-------------|---------------------|------------------|
+| `block_stats_by_height` | Block statistics for a specific height | `blockHeight` | `{"size":123456,"txCount":512,"outputTotal":54.12345678,"outputTotalUsd":2345.67,...}` |
+| `block_miner_stats` | Block mining statistics for a time period | optional: `days` (default 7) | `{"blocks":{"miner1":412,"miner2":208,...},"total":1008}` |
+| `miner_summary_stats` | Summary of mining statistics | optional: `days` (default 7) | `{"totalBlocks":1008,"totalFees":1.23456789,"totalFeesUsd":53.67,...}` |
 
 #### Transaction Data
 | Endpoint | Description | Required Parameters | Example Response |
@@ -274,6 +255,7 @@ The tool supports the following endpoint categories and specific endpoints:
 | `tx_by_hash` | Detailed transaction data | `txHash` | `{"txid":"a1b2c3d4e5f6...","version":1,"locktime":0,"size":225,...}` |
 | `tx_raw` | Raw transaction hex data | `txHash` | `"01000000012345abcdef..."` |
 | `tx_receipt` | Transaction receipt | `txHash` | `{"blockHash":"000000000000...","blockHeight":800000,"confirmations":26458}` |
+| `bulk_tx_details` | Retrieve multiple transactions in one request | `txids` (array) | `[{"txid":"a1b2c3d4e5f6...","version":1,...}, {"txid":"b2c3d4e5f6a7...","version":1,...}]` |
 
 #### Address Data
 | Endpoint | Description | Required Parameters | Example Response |
@@ -298,6 +280,12 @@ The `bsv_explore` tool can be used with natural language prompts like:
 "Get unspent outputs for my wallet address"
 "Check transaction details for txid a1b2c3d4e5f6..."
 "What is the current BSV circulating supply?"
+"Show me the latest block headers"
+"Get transaction IDs for page 2 of a large block"
+"Show me block statistics for height 800000"
+"What are the mining statistics for the last 14 days?"
+"Get a summary of mining activity over the past 30 days"
+"Retrieve details for multiple transactions in a single query"
 ```
 
 Under the hood, the tool accepts parameters to specify which data to retrieve:
@@ -305,9 +293,12 @@ Under the hood, the tool accepts parameters to specify which data to retrieve:
 - `endpoint`: The specific WhatsOnChain endpoint to query (e.g., `chain_info`, `tx_by_hash`)
 - `network`: The BSV network to use (`main` or `test`)
 - Additional parameters as required by the specific endpoint:
-  - `blockHash`: For block_by_hash endpoint
-  - `blockHeight`: For block_by_height endpoint
-  - `txHash`: For transaction-related endpoints
+  - `blockHash`: For block_by_hash and block_pages endpoints
+  - `blockHeight`: For block_by_height, tag_count_by_height, and block_stats_by_height endpoints
+  - `pageNumber`: For block_pages endpoint (pagination)
+  - `days`: For block_miner_stats and miner_summary_stats endpoints (defaults to 7)
+  - `txHash`: For transaction-related endpoints (tx_by_hash, tx_raw, tx_receipt)
+  - `txids`: For bulk_tx_details endpoint (array of transaction IDs)
   - `address`: For address-related endpoints
   - `limit`: Optional pagination limit for address_history
 

package/index.ts

@@ -37,7 +37,7 @@ const privKey = validatePrivateKey();
 
 const server = new McpServer({
 	name: "Bitcoin SV MCP Server",
-	version: "0.0.18",
+	version: "0.0.20",
 });
 
 // Initialize wallet with the validated private key

package/package.json

@@ -2,7 +2,7 @@
 	"name": "bsv-mcp",
 	"module": "index.ts",
 	"type": "module",
-	"version": "0.0.18",
+	"version": "0.0.20",
 	"license": "MIT",
 	"author": "satchmo",
 	"description": "A collection of Bitcoin SV (BSV) tools for the Model Context Protocol (MCP) framework",

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,30 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import { z } from "zod";
+
+// Schema for agent discovery parameters
+export const a2bDiscoverArgsSchema = z.object({
+  query: z.string().describe("Agent name or capability to search for"),
+});
+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 records by name or capability",
+    { args: a2bDiscoverArgsSchema },
+    async (
+      { args }: { args: A2bDiscoverArgs },
+      extra: RequestHandlerExtra
+    ) => {
+      // TODO: implement on-chain lookup logic
+      return {
+        content: [{ type: "text", text: "Not implemented" }],
+        isError: true,
+      };
+    }
+  );
+} 

package/tools/bsv/explore.ts

@@ -17,12 +17,20 @@ enum ExploreEndpoint {
   // Block endpoints
   BLOCK_BY_HASH = "block_by_hash",
   BLOCK_BY_HEIGHT = "block_by_height",
+  BLOCK_HEADERS = "block_headers",
+  BLOCK_PAGES = "block_pages",
+  
+  // Stats endpoints
   TAG_COUNT_BY_HEIGHT = "tag_count_by_height",
+  BLOCK_STATS_BY_HEIGHT = "block_stats_by_height",
+  BLOCK_MINER_STATS = "block_miner_stats", 
+  MINER_SUMMARY_STATS = "miner_summary_stats",
   
   // Transaction endpoints
   TX_BY_HASH = "tx_by_hash",
   TX_RAW = "tx_raw",
   TX_RECEIPT = "tx_receipt",
+  BULK_TX_DETAILS = "bulk_tx_details",
   ADDRESS_HISTORY = "address_history",
   ADDRESS_UTXOS = "address_utxos",
   
@@ -42,10 +50,13 @@ const exploreArgsSchema = z.object({
   
   // Parameters for specific endpoints
   blockHash: z.string().optional().describe("Block hash (required for block_by_hash endpoint)"),
-  blockHeight: z.number().optional().describe("Block height (required for block_by_height endpoint)"),
+  blockHeight: z.number().optional().describe("Block height (required for block_by_height and block_stats_by_height endpoints)"),
   txHash: z.string().optional().describe("Transaction hash (required for tx_by_hash, tx_raw, and tx_receipt endpoints)"),
+  txids: z.array(z.string()).optional().describe("Array of transaction IDs for bulk_tx_details endpoint"),
   address: z.string().optional().describe("Bitcoin address (required for address_history and address_utxos endpoints)"),
   limit: z.number().optional().describe("Limit for paginated results (optional for address_history)"),
+  pageNumber: z.number().optional().describe("Page number for block_pages endpoint (defaults to 1)"),
+  days: z.number().optional().describe("Number of days for miner stats endpoints (defaults to 7)"),
 });
 
 // Type for the tool arguments
@@ -67,11 +78,18 @@ export function registerExploreTool(server: McpServer): void {
     "BLOCK DATA:\n" +
     "- block_by_hash: Complete block data via hash (requires blockHash parameter)\n" +
     "- block_by_height: Complete block data via height (requires blockHeight parameter)\n" +
-    "- tag_count_by_height: Stats on tag count for a specific block via height (requires blockHeight parameter)\n\n" +
+    "- tag_count_by_height: Stats on tag count for a specific block via height (requires blockHeight parameter)\n" +
+    "- block_headers: Retrieves the last 10 block headers\n" +
+    "- block_pages: Retrieves pages of transaction IDs for large blocks (requires blockHash and optional pageNumber)\n\n" +
+    "STATS DATA:\n" +
+    "- block_stats_by_height: Block statistics for a specific height (requires blockHeight parameter)\n" +
+    "- block_miner_stats: Block mining statistics for a time period (optional days parameter, default 7)\n" +
+    "- miner_summary_stats: Summary of mining statistics (optional days parameter, default 7)\n\n" +
     "TRANSACTION DATA:\n" +
     "- tx_by_hash: Detailed transaction data (requires txHash parameter)\n" +
     "- tx_raw: Raw transaction hex data (requires txHash parameter)\n" +
-    "- tx_receipt: Transaction receipt (requires txHash parameter)\n\n" +
+    "- tx_receipt: Transaction receipt (requires txHash parameter)\n" +
+    "- bulk_tx_details: Bulk transaction details (requires txids parameter as array of transaction hashes)\n\n" +
     "ADDRESS DATA:\n" +
     "- address_history: Transaction history for address (requires address parameter, optional limit)\n" +
     "- address_utxos: Unspent outputs for address (requires address parameter)\n\n" +
@@ -99,6 +117,18 @@ export function registerExploreTool(server: McpServer): void {
         if ([ExploreEndpoint.ADDRESS_HISTORY, ExploreEndpoint.ADDRESS_UTXOS].includes(params.endpoint) && !params.address) {
           throw new Error("address is required for address endpoints");
         }
+
+        if (params.endpoint === ExploreEndpoint.BLOCK_PAGES && !params.blockHash) {
+          throw new Error("blockHash is required for block_pages endpoint");
+        }
+        
+        if (params.endpoint === ExploreEndpoint.BLOCK_STATS_BY_HEIGHT && params.blockHeight === undefined) {
+          throw new Error("blockHeight is required for block_stats_by_height endpoint");
+        }
+        
+        if (params.endpoint === ExploreEndpoint.BULK_TX_DETAILS && (!params.txids || params.txids.length === 0)) {
+          throw new Error("txids array is required for bulk_tx_details endpoint");
+        }
         
         // Build API URL based on the selected endpoint
         let apiUrl = `${WOC_API_BASE_URL}/${params.network}`;
@@ -125,6 +155,27 @@ export function registerExploreTool(server: McpServer): void {
           case ExploreEndpoint.TAG_COUNT_BY_HEIGHT:
             apiUrl += `/block/tagcount/height/${params.blockHeight}/stats`;
             break;
+          case ExploreEndpoint.BLOCK_HEADERS:
+            apiUrl += "/block/headers";
+            break;
+          case ExploreEndpoint.BLOCK_PAGES: {
+            const pageNumber = params.pageNumber || 1;
+            apiUrl += `/block/hash/${params.blockHash}/page/${pageNumber}`;
+            break;
+          }
+          case ExploreEndpoint.BLOCK_STATS_BY_HEIGHT:
+            apiUrl += `/block/height/${params.blockHeight}/stats`;
+            break;
+          case ExploreEndpoint.BLOCK_MINER_STATS: {
+            const days = params.days !== undefined ? params.days : 7;
+            apiUrl += `/miner/blocks/stats?days=${days}`;
+            break;
+          }
+          case ExploreEndpoint.MINER_SUMMARY_STATS: {
+            const days = params.days !== undefined ? params.days : 7;
+            apiUrl += `/miner/summary/stats?days=${days}`;
+            break;
+          }
           case ExploreEndpoint.TX_BY_HASH:
             apiUrl += `/tx/hash/${params.txHash}`;
             break;
@@ -134,6 +185,9 @@ export function registerExploreTool(server: McpServer): void {
           case ExploreEndpoint.TX_RECEIPT:
             apiUrl += `/tx/${params.txHash}/receipt`;
             break;
+          case ExploreEndpoint.BULK_TX_DETAILS:
+            apiUrl += "/txs";
+            break;
           case ExploreEndpoint.ADDRESS_HISTORY:
             apiUrl += `/address/${params.address}/history`;
             if (params.limit !== undefined) {
@@ -150,10 +204,64 @@ export function registerExploreTool(server: McpServer): void {
             throw new Error(`Unsupported endpoint: ${params.endpoint}`);
         }
         
-        // Make the API request
+        // Special handling for bulk_tx_details which requires a POST request
+        if (params.endpoint === ExploreEndpoint.BULK_TX_DETAILS) {
+          const response = await fetch(apiUrl, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ txids: params.txids }),
+          });
+          
+          if (!response.ok) {
+            let errorMsg = `API error: ${response.status} ${response.statusText}`;
+            if (response.status === 404) {
+              errorMsg += " - One or more transaction IDs not found";
+            }
+            throw new Error(errorMsg);
+          }
+          
+          const result = await response.json();
+          
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(result, null, 2),
+              },
+            ],
+          };
+        }
+        
+        // For all other endpoints, use GET request
         const response = await fetch(apiUrl);
         if (!response.ok) {
-          throw new Error(`API error: ${response.status} ${response.statusText}`);
+          let errorMsg = `API error: ${response.status} ${response.statusText}`;
+          // Provide helpful tips for specific error codes
+          if (response.status === 404) {
+            switch (params.endpoint) {
+              case ExploreEndpoint.BLOCK_BY_HASH:
+                errorMsg += ` - Block hash "${params.blockHash}" not found`;
+                break;
+              case ExploreEndpoint.BLOCK_BY_HEIGHT:
+                errorMsg += ` - Block at height ${params.blockHeight} not found`;
+                break;
+              case ExploreEndpoint.BLOCK_PAGES:
+                errorMsg += ` - Block hash "${params.blockHash}" not found or page ${params.pageNumber || 1} does not exist`;
+                break;
+              case ExploreEndpoint.TX_BY_HASH:
+              case ExploreEndpoint.TX_RAW:
+              case ExploreEndpoint.TX_RECEIPT:
+                errorMsg += ` - Transaction hash "${params.txHash}" not found`;
+                break;
+              case ExploreEndpoint.ADDRESS_HISTORY:
+              case ExploreEndpoint.ADDRESS_UTXOS:
+                errorMsg += ` - No data found for address "${params.address}"`;
+                break;
+            }
+          }
+          throw new Error(errorMsg);
         }
         
         const result = await response.json();

package/tools/index.ts

@@ -2,6 +2,8 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { registerBsvTools } from "./bsv";
 import { registerOrdinalsTools } from "./ordinals";
 import { registerUtilsTools } from "./utils";
+import { registerA2bDiscoverTool } from "./a2b/discover";
+import { registerA2aCallTool } from "./a2b/call";
 
 /**
  * Register all tools with the MCP server
@@ -17,5 +19,11 @@ 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);
+
 	// Add more tool categories as needed
 }

package/tools/wallet/a2bPublish.ts

@@ -0,0 +1,150 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import { z } from "zod";
+import type { Wallet } from "./wallet";
+import { createOrdinals } from "js-1sat-ord";
+import type { Inscription, Destination, ChangeResult, PreMAP } from "js-1sat-ord";
+import { Utils } from "@bsv/sdk";
+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);
+
+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),
+});
+
+// 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 registerA2bPublishTool(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
+    ) => {
+      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");
+
+        // 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,
+        };
+        // 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 walletAddress = paymentPk.toAddress().toString();
+        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: 'agent' };
+
+        // 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/tools.ts

@@ -39,6 +39,10 @@ import type { createOrdinalsArgsSchema } from "./createOrdinals";
 import { registerGetAddressTool } from "./getAddress";
 import { registerPurchaseListingTool } from "./purchaseListing";
 import { registerSendToAddressTool } from "./sendToAddress";
+import { registerTransferOrdTokenTool } from "./transferOrdToken";
+import { registerA2bPublishTool } from "./a2bPublish";
+import type { transferOrdTokenArgsSchema } from "./transferOrdToken";
+import type { a2bPublishArgsSchema } from "./a2bPublish";
 import { Utils, type WalletProtocol } from "@bsv/sdk";
 
 // Define mapping from tool names to argument schemas
@@ -70,6 +74,8 @@ type ToolArgSchemas = {
 	wallet_getAddress: typeof getAddressArgsSchema;
 	wallet_sendToAddress: typeof sendToAddressArgsSchema;
 	wallet_purchaseListing: typeof purchaseListingArgsSchema;
+	wallet_transferOrdToken: typeof transferOrdTokenArgsSchema;
+	wallet_a2bPublish: typeof a2bPublishArgsSchema;
 	wallet_createOrdinals: typeof createOrdinalsArgsSchema;
 };
 
@@ -111,6 +117,12 @@ export function registerWalletTools(
 	// Register the wallet_purchaseListing tool
 	registerPurchaseListingTool(server, wallet);
 
+	// Register the wallet_transferOrdToken tool
+	registerTransferOrdTokenTool(server, wallet);
+
+	// Register the wallet_a2bPublish tool
+	registerA2bPublishTool(server, wallet);
+
 	// Register only the minimal public-facing tools
 	// wallet_createAction, wallet_signAction and wallet_getHeight have been removed
 

package/tools/wallet/transferOrdToken/index.ts

@@ -0,0 +1,103 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import { z } from "zod";
+import {
+  transferOrdTokens,
+  TokenType,
+  TokenInputMode,
+  TokenSelectionStrategy,
+  selectTokenUtxos,
+  type TransferOrdTokensConfig,
+  type Utxo,
+  type TokenUtxo,
+  type Payment,
+  type Distribution,
+  type TokenChangeResult,
+} from "js-1sat-ord";
+import type { Wallet } from "../wallet";
+
+// Schema for BSV-20/BSV-21 token transfer arguments
+export const transferOrdTokenArgsSchema = z.object({
+  protocol: z.enum(["bsv-20", "bsv-21"]),
+  tokenID: z.string(),
+  sendAmount: z.number(),
+  paymentUtxos: z.array(
+    z.object({ txid: z.string(), vout: z.number(), satoshis: z.number(), script: z.string() })
+  ),
+  tokenUtxos: z.array(
+    z.object({ txid: z.string(), vout: z.number(), satoshis: z.literal(1), script: z.string(), amt: z.string(), id: z.string() })
+  ),
+  distributions: z.array(z.object({ address: z.string(), tokens: z.number() })),
+  decimals: z.number(),
+  additionalPayments: z.array(z.object({ to: z.string(), amount: z.number() })).optional(),
+});
+export type TransferOrdTokenArgs = z.infer<typeof transferOrdTokenArgsSchema>;
+
+/**
+ * Register the wallet_transferOrdToken tool for transferring BSV tokens.
+ */
+export function registerTransferOrdTokenTool(server: McpServer, wallet: Wallet) {
+  server.tool(
+    "wallet_transferOrdToken",
+    "Transfers BSV-20 or BSV-21 tokens from your wallet via js-1sat-ord transferOrdTokens.",
+    { args: transferOrdTokenArgsSchema },
+    async (
+      { args }: { args: TransferOrdTokenArgs },
+      extra: RequestHandlerExtra
+    ) => {
+      try {
+        // fetch keys
+        const paymentPk = wallet.getPrivateKey();
+        if (!paymentPk) throw new Error("No private key available");
+        const ordPk = paymentPk;
+        const changeAddress = paymentPk.toAddress().toString();
+        const ordAddress = changeAddress;
+
+        // select token UTXOs
+        const { selectedUtxos: inputTokens } = selectTokenUtxos(
+          args.tokenUtxos as TokenUtxo[],
+          args.sendAmount,
+          args.decimals,
+          { inputStrategy: TokenSelectionStrategy.SmallestFirst, outputStrategy: TokenSelectionStrategy.LargestFirst }
+        );
+
+        // build config
+        const config: TransferOrdTokensConfig = {
+          protocol: args.protocol === "bsv-20" ? TokenType.BSV20 : TokenType.BSV21,
+          tokenID: args.tokenID,
+          utxos: args.paymentUtxos as Utxo[],
+          inputTokens,
+          distributions: args.distributions as Distribution[],
+          tokenChangeAddress: ordAddress,
+          changeAddress,
+          paymentPk,
+          ordPk,
+          additionalPayments: args.additionalPayments as Payment[] || [],
+          decimals: args.decimals,
+          inputMode: TokenInputMode.Needed,
+          splitConfig: { outputs: inputTokens.length === 1 ? 2 : 1, threshold: args.sendAmount },
+        };
+
+        // execute transfer
+        const result: TokenChangeResult = await transferOrdTokens(config);
+        await result.tx.broadcast();
+
+        // refresh UTXOs
+        try { await wallet.refreshUtxos(); } catch {}
+
+        // respond
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            txid: result.tx.id("hex"),
+            spentOutpoints: result.spentOutpoints,
+            payChange: result.payChange,
+            tokenChange: result.tokenChange,
+          }) }]
+        };
+      } catch (err: unknown) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: msg }], isError: true };
+      }
+    }
+  );
+}