bsv-mcp 0.3.0 → 0.3.2

package/index.ts

@@ -28,6 +28,11 @@ import { getBsvPriceWithCache } from "./tools/bsv/getPrice.ts";
 import { registerAllTools, type ToolsConfig } from "./tools/index.ts";
 import { IntegratedWallet } from "./tools/wallet/integratedWallet.ts";
 import { Wallet } from "./tools/wallet/wallet.ts";
+import { DroplitClient, readDroplitSponsorConfig } from "./utils/droplit";
+import {
+	initializeKeysForWalletMode,
+	readExternalWalletConfig,
+} from "./utils/externalWalletConfig";
 import {
 	type BSVJWTPayload,
 	createMCPJWTValidator,
@@ -37,6 +42,7 @@ import { SecureKeyManager } from "./utils/keyManager.ts";
 import { setServerInstance } from "./utils/passphrasePrompt.ts";
 import {
 	destroyWallet,
+	initExternalWallet,
 	initWallet,
 	setSpendingApprovalServerInstance,
 } from "./utils/walletInit.ts";
@@ -1107,6 +1113,8 @@ Options:
 Environment Variables:
   TRANSPORT           Transport mode: 'stdio' or 'http' (default: http)
   PORT               HTTP server port (default: 3000)
+  BRC100_WALLET_URL  Existing SDK HTTPWalletJSON signer RPC URL
+  BRC100_WALLET_ORIGINATOR  Signer permission origin (default: bsv-mcp.local)
   PRIVATE_KEY_WIF    Payment private key in WIF format
   DISABLE_TOOLS      Disable all tools (default: false)
   DISABLE_WALLET_TOOLS   Disable wallet tools (default: false)
@@ -1130,7 +1138,7 @@ Tool Categories:
 
 Authentication:
   - Most tools work without authentication
-  - Wallet operations require PRIVATE_KEY_WIF or generated keys
+  - Wallet operations use BRC100_WALLET_URL, PRIVATE_KEY_WIF or generated keys
   - BAP/A2B tools require identity keys (generated via bap_generate tool)
 		`);
 		process.exit(0);
@@ -1142,7 +1150,25 @@ Authentication:
 	}
 
 	// --- Initialize Keys ---
-	const { payPk, identityPk, xprv, source: keySource } = await initializeKeys();
+	const externalWallet = readExternalWalletConfig();
+	const sponsorConfig = CONFIG.useDroplitApi
+		? undefined
+		: readDroplitSponsorConfig();
+	const keys = await initializeKeysForWalletMode(
+		externalWallet,
+		initializeKeys,
+	);
+	const {
+		payPk,
+		identityPk,
+		xprv,
+		source: keySource,
+	} = keys ?? {
+		payPk: undefined,
+		identityPk: undefined,
+		xprv: undefined,
+		source: "external",
+	};
 
 	// Define persistence based on source
 	const hasPersistentPayKey =
@@ -1154,6 +1180,15 @@ Authentication:
 		(keySource === "file" || keySource === "env" || keySource === "encrypted");
 
 	const effectiveConfig = { ...CONFIG };
+	if (externalWallet) {
+		effectiveConfig.loadBapTools = false;
+		effectiveConfig.loadBsocialTools = false;
+		effectiveConfig.loadMneeTools = false;
+		effectiveConfig.loadA2bTools = false;
+		logFunc(
+			"External BRC-100 signer selected; local key loading and generation bypassed.",
+		);
+	}
 
 	// --- Configuration Logging ---
 	logFunc("\n--- BSV MCP Server Configuration ---");
@@ -1169,10 +1204,10 @@ Authentication:
 		);
 	}
 	logFunc(
-		`  PRIVATE_KEY_WIF:      ${process.env.PRIVATE_KEY_WIF ? "Set (using env key)" : "Not Set (using file/generating)"}`,
+		`  PRIVATE_KEY_WIF:      ${externalWallet ? "Unused (external signer)" : process.env.PRIVATE_KEY_WIF ? "Set (using env key)" : "Not Set (using file/generating)"}`,
 	);
 	logFunc(
-		`  IDENTITY_KEY_WIF:     ${process.env.IDENTITY_KEY_WIF ? "Set (using env key)" : "Not Set (using file/generating)"}`,
+		`  IDENTITY_KEY_WIF:     ${externalWallet ? "Unused (external signer)" : process.env.IDENTITY_KEY_WIF ? "Set (using env key)" : "Not Set (using file/generating)"}`,
 	);
 	if (process.env.BSV_MCP_PASSPHRASE) {
 		logFunc("  BSV_MCP_PASSPHRASE:   \x1b[31mDEPRECATED - Remove this!\x1b[0m");
@@ -1269,11 +1304,11 @@ Authentication:
 			: "\x1b[31mDisabled\x1b[0m";
 
 		let payKeyNote = "";
-		if (!hasPersistentPayKey) {
+		if (!externalWallet && !hasPersistentPayKey) {
 			payKeyNote = " \x1b[33m(Using generated payPk)\x1b[0m";
 		}
 		let identityKeyNote = "";
-		if (!hasPersistentIdentityKey) {
+		if (!externalWallet && !hasPersistentIdentityKey) {
 			identityKeyNote = " \x1b[33m(Using generated identityPk)\x1b[0m";
 		}
 
@@ -1310,7 +1345,15 @@ Authentication:
 
 	if (CONFIG.loadTools) {
 		// Check if we should use Droplit API mode
-		if (CONFIG.useDroplitApi && CONFIG.droplitFaucetName) {
+		if (externalWallet) {
+			const chain = process.env.BSV_CHAIN ?? "main";
+			if (chain !== "main" && chain !== "test")
+				throw new Error("BSV_CHAIN must be main or test");
+			const result = await initExternalWallet(externalWallet, chain);
+			remoteCtx = result.ctx;
+			remoteServices = result.services;
+			logFunc(`External BRC-100 signer ready. Identity: ${result.identityKey}`);
+		} else if (CONFIG.useDroplitApi && CONFIG.droplitFaucetName) {
 			// Initialize IntegratedWallet in Droplit mode
 			if (CONFIG.loadWalletTools) {
 				try {
@@ -1405,6 +1448,16 @@ Authentication:
 		}
 	}
 
+	const droplitClient =
+		sponsorConfig && remoteCtx
+			? new DroplitClient({ ...sponsorConfig, wallet: remoteCtx.wallet })
+			: undefined;
+	if (sponsorConfig && CONFIG.loadTools && !remoteCtx) {
+		throw new Error(
+			"Configured Droplit sponsor requires an initialized BRC-100 wallet context",
+		);
+	}
+
 	// Build the shared tools config (used by server factory for each session)
 	const toolsConfig: ToolsConfig = CONFIG.loadTools
 		? {
@@ -1424,6 +1477,7 @@ Authentication:
 				disableBroadcasting: effectiveConfig.disableBroadcasting,
 				ctx: remoteCtx,
 				services: remoteServices,
+				droplitClient,
 			}
 		: {
 				enableBsvTools: false,

package/package.json

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

package/tools/index.ts

@@ -2,6 +2,7 @@ import type { OneSatContext } from "@1sat/actions";
 import type { OneSatServices } from "@1sat/wallet-remote";
 import type { PrivateKey } from "@bsv/sdk";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { DroplitClient } from "../utils/droplit";
 import { registerA2bDiscoverTool } from "./a2b/discover";
 import { registerBapTools } from "./bap";
 import { registerBsocialTools } from "./bsocial";
@@ -9,6 +10,7 @@ import { registerBsvTools } from "./bsv";
 import { registerMneeTools } from "./mnee";
 import { registerOrdinalsTools } from "./ordinals";
 import { registerUtilsTools } from "./utils";
+import { registerDroplitTools } from "./wallet/droplit";
 import { registerWalletGetBalanceDroplitTool } from "./wallet/getBalanceDroplit";
 import type { IntegratedWallet } from "./wallet/integratedWallet";
 import { registerSetupDroplitTools } from "./wallet/setupDroplit";
@@ -45,6 +47,7 @@ export interface ToolsConfig {
 	disableBroadcasting?: boolean; // For wallet tools
 	ctx?: OneSatContext;
 	services?: OneSatServices;
+	droplitClient?: DroplitClient;
 }
 
 /**
@@ -99,7 +102,7 @@ export function registerAllTools(
 	}
 
 	// Register BAP tools
-	if (enableBapTools) {
+	if (enableBapTools && (!config.ctx || config.wallet)) {
 		const bapConfig: import("./bap").BapToolsConfig = {
 			disableBroadcasting: config.disableBroadcasting,
 			identityPk: config.identityPk,
@@ -116,6 +119,12 @@ export function registerAllTools(
 
 	// Register Wallet tools themselves
 	if (enableWalletTools) {
+		if (config.droplitClient)
+			registerDroplitTools(
+				server,
+				config.droplitClient,
+				config.disableBroadcasting,
+			);
 		if (config.integratedWallet?.isDroplitMode) {
 			// Register Droplit-mode wallet tools
 			const droplitClient = config.integratedWallet.getDroplitClient();
@@ -127,7 +136,7 @@ export function registerAllTools(
 				}
 				console.error("Registered Droplit mode wallet tools");
 			}
-		} else if (config.wallet) {
+		} else if (config.wallet || config.ctx) {
 			// Register normal wallet tools
 			const walletToolOptions = {
 				disableBroadcasting: config.disableBroadcasting === true,
@@ -140,7 +149,7 @@ export function registerAllTools(
 	}
 
 	// Register MNEE tools
-	if (enableMneeTools) {
+	if (enableMneeTools && (!config.ctx || config.wallet)) {
 		registerMneeTools(server);
 	}
 

package/tools/wallet/brc100.ts

@@ -184,8 +184,15 @@ export function registerBrc100Tools(
 			outputsJSON: z.string().describe("JSON array of outputs to internalize"),
 			description: z.string().describe("5-50 char description"),
 			labelsJSON: z.string().optional().describe("JSON array of label strings"),
+			seekPermission: z.boolean().optional(),
 		},
-		async ({ txJSON, outputsJSON, description, labelsJSON }) => {
+		async ({
+			txJSON,
+			outputsJSON,
+			description,
+			labelsJSON,
+			seekPermission,
+		}) => {
 			if (!ctx) return noCtx;
 			try {
 				return result(
@@ -193,6 +200,7 @@ export function registerBrc100Tools(
 						tx: parseRequiredJSON("txJSON", txJSON),
 						outputs: parseRequiredJSON("outputsJSON", outputsJSON),
 						description,
+						seekPermission,
 						labels: parseJSON("labelsJSON", labelsJSON),
 					}),
 				);
@@ -221,6 +229,7 @@ export function registerBrc100Tools(
 			includeOutputLockingScripts: z.boolean().default(false),
 			limit: z.number().default(25),
 			offset: z.number().default(0),
+			seekPermission: z.boolean().optional(),
 		},
 		async ({ labelsJSON, ...rest }) => {
 			if (!ctx) return noCtx;
@@ -250,6 +259,7 @@ export function registerBrc100Tools(
 			includeLabels: z.boolean().default(false),
 			limit: z.number().default(25),
 			offset: z.number().default(0),
+			seekPermission: z.boolean().optional(),
 		},
 		async ({ tagsJSON, ...rest }) => {
 			if (!ctx) return noCtx;
@@ -331,6 +341,8 @@ export function registerBrc100Tools(
 			keyID: z.string(),
 			counterparty: z.string().optional(),
 			privileged: z.boolean().optional(),
+			privilegedReason: z.string().optional(),
+			seekPermission: z.boolean().optional(),
 		},
 		async ({ protocolIDJSON, ...rest }) => {
 			if (!ctx) return noCtx;
@@ -358,6 +370,8 @@ export function registerBrc100Tools(
 			keyID: z.string(),
 			counterparty: z.string().optional(),
 			privileged: z.boolean().optional(),
+			privilegedReason: z.string().optional(),
+			seekPermission: z.boolean().optional(),
 		},
 		async ({ protocolIDJSON, ...rest }) => {
 			if (!ctx) return noCtx;
@@ -385,6 +399,8 @@ export function registerBrc100Tools(
 			keyID: z.string(),
 			counterparty: z.string().optional(),
 			privileged: z.boolean().optional(),
+			privilegedReason: z.string().optional(),
+			seekPermission: z.boolean().optional(),
 		},
 		async ({ protocolIDJSON, ...rest }) => {
 			if (!ctx) return noCtx;
@@ -413,6 +429,8 @@ export function registerBrc100Tools(
 			keyID: z.string(),
 			counterparty: z.string().optional(),
 			privileged: z.boolean().optional(),
+			privilegedReason: z.string().optional(),
+			seekPermission: z.boolean().optional(),
 		},
 		async ({ protocolIDJSON, ...rest }) => {
 			if (!ctx) return noCtx;
@@ -444,6 +462,8 @@ export function registerBrc100Tools(
 			keyID: z.string(),
 			counterparty: z.string().optional(),
 			privileged: z.boolean().optional(),
+			privilegedReason: z.string().optional(),
+			seekPermission: z.boolean().optional(),
 		},
 		async ({ protocolIDJSON, ...rest }) => {
 			if (!ctx) return noCtx;
@@ -480,6 +500,8 @@ export function registerBrc100Tools(
 			counterparty: z.string().optional(),
 			forSelf: z.boolean().optional(),
 			privileged: z.boolean().optional(),
+			privilegedReason: z.string().optional(),
+			seekPermission: z.boolean().optional(),
 		},
 		async ({ protocolIDJSON, ...rest }) => {
 			if (!ctx) return noCtx;
@@ -677,6 +699,7 @@ export function registerBrc100Tools(
 			identityKey: z.string().describe("Identity public key hex"),
 			limit: z.number().default(25),
 			offset: z.number().default(0),
+			seekPermission: z.boolean().optional(),
 		},
 		async (args) => {
 			if (!ctx) return noCtx;
@@ -697,6 +720,7 @@ export function registerBrc100Tools(
 				.describe("JSON object of attribute key/value pairs to match"),
 			limit: z.number().default(25),
 			offset: z.number().default(0),
+			seekPermission: z.boolean().optional(),
 		},
 		async ({ attributesJSON, ...rest }) => {
 			if (!ctx) return noCtx;

package/tools/wallet/droplit.ts

@@ -0,0 +1,124 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { assertBroadcastAllowed } from "../../utils/broadcastGuard";
+import { type DroplitClient, DroplitError } from "../../utils/droplit";
+import { createSuccessResponse } from "../utils/errorHandler";
+
+function errorResult(error: unknown) {
+	const failure =
+		error instanceof DroplitError
+			? error
+			: new DroplitError(
+					"request_failed",
+					"Droplit operation failed. Check configuration and broadcasting policy.",
+				);
+	const data = {
+		error: failure.code,
+		message: failure.message,
+		...(failure.status === undefined ? {} : { status: failure.status }),
+		...failure.details,
+	};
+	return {
+		...createSuccessResponse(data),
+		structuredContent: data,
+		isError: true,
+	};
+}
+
+export function registerDroplitTools(
+	server: McpServer,
+	client: DroplitClient,
+	disableBroadcasting = false,
+) {
+	server.registerTool(
+		"droplit_getAccess",
+		{
+			description:
+				"Read this connected wallet's sponsor authorization and quotas. If unauthorized, a human sponsor owner must approve the wallet manually. Does not create, fund, or approve anything.",
+			inputSchema: {},
+			annotations: {
+				readOnlyHint: true,
+				destructiveHint: false,
+				idempotentHint: true,
+				openWorldHint: true,
+			},
+		},
+		async () => {
+			try {
+				const access = await client.getAccess();
+				const data = {
+					...access,
+					...(!access.authorized
+						? {
+								error: "approval_required",
+								message:
+									"Ask the sponsor owner to approve this wallet. Copy the approval URL for manual review; do not auto-open or submit approval.",
+								approval_url: `https://droplit.dev${access.approval_path}`,
+							}
+						: {}),
+				};
+				return {
+					...createSuccessResponse(data),
+					structuredContent: data,
+					isError: !access.authorized,
+				};
+			} catch (error) {
+				return errorResult(error);
+			}
+		},
+	);
+	server.registerTool(
+		"droplit_push",
+		{
+			description:
+				"Submit one sponsored data transaction. Subject to sponsor approval and quotas. An unknown outcome requires checking transaction history before retrying.",
+			inputSchema: {
+				data: z.array(z.string()).min(1),
+				encoding: z.enum(["hex", "utf8"]),
+			},
+			annotations: {
+				readOnlyHint: false,
+				destructiveHint: true,
+				idempotentHint: false,
+				openWorldHint: true,
+			},
+		},
+		async ({ data, encoding }) => {
+			try {
+				if (disableBroadcasting) throw new Error("Broadcasting disabled");
+				assertBroadcastAllowed("droplit_push");
+				return createSuccessResponse(await client.push(data, encoding));
+			} catch (error) {
+				return errorResult(error);
+			}
+		},
+	);
+	server.registerTool(
+		"droplit_fund",
+		{
+			description:
+				"Submit one raw transaction for sponsor funding and broadcast. Subject to sponsor approval and quotas. Unknown outcomes must be reconciled before retrying.",
+			inputSchema: {
+				rawtx: z
+					.string()
+					.min(2)
+					.regex(/^(?:[0-9a-fA-F]{2})+$/, "Expected raw transaction hex"),
+			},
+			annotations: {
+				readOnlyHint: false,
+				destructiveHint: true,
+				idempotentHint: false,
+				openWorldHint: true,
+			},
+		},
+		async ({ rawtx }) => {
+			try {
+				if (disableBroadcasting) throw new Error("Broadcasting disabled");
+				assertBroadcastAllowed("droplit_fund");
+				return createSuccessResponse(await client.fund(rawtx));
+			} catch (error) {
+				return errorResult(error);
+			}
+		},
+	);
+}

package/tools/wallet/integratedWallet.ts

@@ -66,9 +66,7 @@ export class IntegratedWallet {
 		satoshis: number,
 	): Promise<{ txid: string }> {
 		if (this.droplitClient) {
-			// For Droplit API, we use the tap endpoint which sends the faucet's fixed amount
-			// Note: Droplit API doesn't support custom amounts, it uses fixed_drop_sats
-			const response = await this.droplitClient.tap(address);
+			const response = await this.droplitClient.tap(address, satoshis);
 			return { txid: response.txid };
 		}
 		if (this.localWallet) {

package/tools/wallet/revealDelegation.ts

@@ -0,0 +1,74 @@
+import type { OneSatContext } from "@1sat/actions";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import {
+	RevelationError,
+	revealDelegation,
+} from "../../utils/revealDelegation";
+import { createSuccessResponse } from "../utils/errorHandler";
+
+export function registerRevealDelegationTool(
+	server: McpServer,
+	ctx?: OneSatContext,
+) {
+	server.registerTool(
+		"wallet_revealDelegation",
+		{
+			description:
+				"Receive the human owner's BRC-169 certificate handoff, acquire and prove it with this connected agent wallet, and reveal its restrictions to the specified Sigma verifier. Imports a certificate and activates its existing delegation. Never pays, broadcasts, follows redirects, or retries an ambiguous POST. The subject keyring stays with the wallet.",
+			inputSchema: {
+				sigmaOrigin: z
+					.string()
+					.max(2048)
+					.describe(
+						"Explicit Sigma HTTPS origin, or HTTP loopback for local testing",
+					),
+				handoffJSON: z
+					.string()
+					.max(131072)
+					.describe(
+						"JSON package copied by the owner: certificate, subjectKeyring, revealTo, revelationPath",
+					),
+			},
+			annotations: {
+				readOnlyHint: false,
+				destructiveHint: false,
+				idempotentHint: false,
+				openWorldHint: true,
+			},
+		},
+		async ({ sigmaOrigin, handoffJSON }) => {
+			try {
+				if (!ctx)
+					throw new RevelationError(
+						"wallet_unavailable",
+						"Connect the agent's existing wallet first.",
+					);
+				const data = await revealDelegation(
+					ctx.wallet,
+					sigmaOrigin,
+					handoffJSON,
+				);
+				return { ...createSuccessResponse(data), structuredContent: data };
+			} catch (error) {
+				const failure =
+					error instanceof RevelationError
+						? error
+						: new RevelationError(
+								"revelation_failed",
+								"Delegation revelation failed. Check wallet and owner status before retrying.",
+							);
+				const data = {
+					error: failure.code,
+					message: failure.message,
+					...(failure.status === undefined ? {} : { status: failure.status }),
+				};
+				return {
+					...createSuccessResponse(data),
+					structuredContent: data,
+					isError: true,
+				};
+			}
+		},
+	);
+}

package/tools/wallet/setupDroplit.ts

@@ -23,11 +23,11 @@ type DroplitClient = NonNullable<
  * signing key, so resolve both up front rather than failing part-way through a
  * request with a different message depending on which tool was called.
  */
-function requireDroplit(integratedWallet: IntegratedWallet): {
+async function requireDroplit(integratedWallet: IntegratedWallet): Promise<{
 	apiUrl: string;
 	publicKeyHex: string;
 	client: DroplitClient;
-} {
+}> {
 	const client = integratedWallet.getDroplitClient();
 	if (!client) {
 		throw new Error(
@@ -35,14 +35,8 @@ function requireDroplit(integratedWallet: IntegratedWallet): {
 		);
 	}
 
-	const { apiUrl, authKey } = client.getConfig();
-	if (!authKey) {
-		throw new Error(
-			"Droplit requests must be signed, but no auth key is configured.",
-		);
-	}
-
-	return { apiUrl, publicKeyHex: authKey.toPublicKey().toString(), client };
+	const { apiUrl } = client.getConfig();
+	return { apiUrl, publicKeyHex: await client.getIdentityKey(), client };
 }
 
 async function failIfNotOk(
@@ -61,11 +55,11 @@ export function registerSetupDroplitTools(
 ) {
 	server.tool(
 		"wallet_registerDroplitKey",
-		"Registers this wallet's public key with the Droplit API so it can sign authenticated faucet requests. Run once before creating or operating a faucet.",
+		"Registers public authentication material. Registration does not grant sponsor access; a sponsor owner must approve the wallet separately.",
 		{},
 		async () => {
 			try {
-				const { apiUrl, publicKeyHex } = requireDroplit(integratedWallet);
+				const { apiUrl, publicKeyHex } = await requireDroplit(integratedWallet);
 
 				const response = await fetch(`${apiUrl}/auth/register`, {
 					method: "POST",
@@ -86,7 +80,7 @@ export function registerSetupDroplitTools(
 
 	server.tool(
 		"wallet_createDroplitFaucet",
-		"Provisions a new Droplit faucet owned by this wallet. Register the wallet's public key first with wallet_registerDroplitKey.",
+		"Creates a faucet owned by this wallet which must be funded before use. This does not provide free credit or approval for another sponsor.",
 		{
 			faucetName: z
 				.string()
@@ -109,7 +103,7 @@ export function registerSetupDroplitTools(
 		},
 		async ({ faucetName, fixedDropSats, maxConsolidationInputs }) => {
 			try {
-				const { client } = requireDroplit(integratedWallet);
+				const { client } = await requireDroplit(integratedWallet);
 
 				// Ownership comes from the BRC-103/104 identity established by the
 				// handshake, not from the body, so the key is never sent here.
@@ -141,11 +135,11 @@ export function registerSetupDroplitTools(
 
 	server.tool(
 		"wallet_checkDroplitFaucetStatus",
-		"Reads the status of the configured Droplit faucet, including balance and payout settings.",
+		"Reads public faucet balance and payout settings. This is not proof of caller authorization; use droplit_getAccess for that.",
 		{},
 		async () => {
 			try {
-				const { client } = requireDroplit(integratedWallet);
+				const { client } = await requireDroplit(integratedWallet);
 				return createSuccessResponse({
 					faucetStatus: await client.getFaucetStatus(),
 				});

package/tools/wallet/tools.ts

@@ -19,6 +19,7 @@ import { registerOpnsDeregisterTool } from "./opnsDeregister";
 import { registerOpnsRegisterTool } from "./opnsRegister";
 import { registerPurchaseListingTool } from "./purchaseListing";
 import { registerRefreshUtxosTool } from "./refreshUtxos";
+import { registerRevealDelegationTool } from "./revealDelegation";
 import { registerSendAllBsvTool } from "./sendAllBsv";
 import { registerSendBsvTool } from "./sendBsv";
 import { registerSignBsmTool } from "./signBsm";
@@ -31,7 +32,7 @@ import type { Wallet } from "./wallet";
 
 export function registerWalletTools(
 	server: McpServer,
-	wallet: Wallet,
+	wallet: Wallet | undefined,
 	config: {
 		disableBroadcasting: boolean;
 		enableA2bTools: boolean;
@@ -58,9 +59,10 @@ export function registerWalletTools(
 
 	// Register full BRC-100 wallet interface
 	registerBrc100Tools(server, config.ctx);
+	registerRevealDelegationTool(server, config.ctx);
 
 	// A2B tools have to be explicitly enabled
-	if (config.enableA2bTools) {
+	if (config.enableA2bTools && wallet && config.identityPk) {
 		// Register the wallet_a2bPublishMcp tool
 		registerA2bPublishMcpTool(server, wallet, config.identityPk, {
 			disableBroadcasting: config.disableBroadcasting,
@@ -71,8 +73,10 @@ export function registerWalletTools(
 	registerCreateOrdinalsTool(server, config.ctx);
 
 	// Register collection tools
-	registerGatherCollectionInfoTool(server, wallet);
-	registerMintCollectionTool(server, wallet);
+	if (wallet) {
+		registerGatherCollectionInfoTool(server, wallet);
+		registerMintCollectionTool(server, wallet);
+	}
 
 	// Register read-only wallet tools
 	registerGetOrdinalsTool(server, config.ctx);