bsv-mcp 0.0.35 → 0.2.0

package/tools/bap/friend.ts

@@ -0,0 +1,267 @@
+import {
+	type BroadcastFailure,
+	type BroadcastResponse,
+	fromUtxo,
+	isBroadcastFailure,
+	isBroadcastResponse,
+	P2PKH,
+	PrivateKey,
+	SatoshisPerKilobyte,
+	Script,
+	Transaction,
+	Utils,
+} from "@bsv/sdk";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import type {
+	CallToolResult,
+	ServerNotification,
+	ServerRequest,
+} from "@modelcontextprotocol/sdk/types.js";
+import { BAP, MemberID } from "bsv-bap";
+import { z } from "zod";
+import { BsocialBroadcaster } from "../../utils/broadcaster";
+import {
+	friendPrivateKeyFromMemberIdKey,
+	friendPublicKeyFromSeedString,
+} from "../../utils/keys";
+import { MAP_PREFIX } from "../constants";
+import {
+	fetchPaymentUtxos,
+	fetchPaymentUtxosFromV5,
+} from "../wallet/fetchPaymentUtxos";
+import type { Wallet } from "../wallet/wallet";
+
+const { toArray, toHex } = Utils;
+
+const APP_DOMAIN = "bsv-mcp";
+
+export const bapFriendArgsSchema = z.object({
+	targetBapId: z.string().min(1, "targetBapId is required."),
+});
+
+export type BapFriendArgs = z.infer<typeof bapFriendArgsSchema>;
+
+export interface BapFriendConfig {
+	disableBroadcasting?: boolean;
+}
+
+export function registerBapFriendTool(
+	server: McpServer,
+	wallet: Wallet,
+	xprv: string,
+	config?: BapFriendConfig,
+) {
+	server.tool(
+		"bap_friend",
+		"Initiates a friend request to another BAP ID by broadcasting an on-chain MAP transaction.",
+		{ args: bapFriendArgsSchema },
+		async (
+			{ args }: { args: BapFriendArgs },
+			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
+		): Promise<CallToolResult> => {
+			const { targetBapId } = args;
+			const logFunc = console.error;
+
+			try {
+				// --- Preconditions ---
+				if (!xprv) {
+					return {
+						isError: true,
+						content: [
+							{
+								type: "text",
+								text: "Server does not have a BAP master key (xprv). Cannot derive friend public key.",
+							},
+						],
+					};
+				}
+
+				const payPk = wallet.getPaymentKey();
+				const identityPk = wallet.getIdentityKey();
+
+				if (!identityPk || !payPk) {
+					return {
+						isError: true,
+						content: [
+							{
+								type: "text",
+								text: !payPk
+									? "Wallet private key not available. Cannot fund friend request transaction."
+									: "Wallet identity key not available. Cannot derive friend public key.",
+							},
+						],
+					};
+				}
+
+				// 3. Derive Initial Identity
+				const bap = new BAP(xprv);
+				const idpk = PrivateKey.fromWif(
+					bap.newId().exportMemberBackup().derivedPrivateKey,
+				);
+				const identityInstance = new MemberID(idpk);
+				const paymentAddress = payPk.toAddress();
+
+				// --- Derive friend public key ---
+				const friendPubKey = friendPrivateKeyFromMemberIdKey(
+					identityPk,
+					targetBapId,
+				)
+					.toPublicKey()
+					.toString();
+
+				// --- Build MAP payload ---
+				const payloadParts: (string | number[])[] = [
+					MAP_PREFIX,
+					"SET",
+					"app",
+					APP_DOMAIN,
+					"type",
+					"friend",
+					"bapID",
+					targetBapId,
+					"publicKey",
+					friendPubKey,
+				];
+
+				const payloadBuffers = payloadParts.map(
+					(part) => toArray(part) as number[],
+				);
+
+				const signedBuffers =
+					identityInstance.signOpReturnWithAIP(payloadBuffers);
+				const payloadHex = signedBuffers.map((b) => toHex(b));
+				const asmPayload = `OP_0 ${payloadHex.join(" ")}`;
+				const opReturnScript = Script.fromASM(asmPayload);
+
+				// --- Build Transaction ---
+				const tx = new Transaction();
+				tx.addOutput({ lockingScript: opReturnScript, satoshis: 0 });
+
+				// --- Fund transaction ---
+				const utxos = await fetchPaymentUtxosFromV5(paymentAddress);
+				if (!utxos || utxos.length === 0) {
+					return {
+						isError: true,
+						content: [
+							{
+								type: "text",
+								text: `No UTXOs available for payment address ${paymentAddress}. Cannot send friend request.`,
+							},
+						],
+					};
+				}
+
+				const feeModel = new SatoshisPerKilobyte(10);
+				let totalInput = 0n;
+				let estFee = await feeModel.computeFee(tx);
+
+				for (const utxo of utxos) {
+					if (totalInput >= BigInt(estFee)) break;
+
+					const unlockTemplate = new P2PKH().unlock(
+						payPk,
+						"all",
+						false,
+						utxo.satoshis,
+						Script.fromBinary(toArray(utxo.script, "hex")),
+					);
+
+					const input = fromUtxo(utxo, unlockTemplate);
+					tx.addInput(input);
+					totalInput += BigInt(utxo.satoshis);
+					estFee = await feeModel.computeFee(tx);
+				}
+
+				if (totalInput < BigInt(estFee)) {
+					return {
+						isError: true,
+						content: [
+							{
+								type: "text",
+								text: `Not enough funds to cover fee. Needed ${estFee}, have ${totalInput}.`,
+							},
+						],
+					};
+				}
+
+				const change = totalInput - BigInt(estFee);
+				if (change > 0n) {
+					tx.addOutput({
+						lockingScript: new P2PKH().lock(paymentAddress),
+						satoshis: Number(change),
+						change: true,
+					});
+				}
+
+				await tx.fee(feeModel);
+				await tx.sign();
+
+				const txHex = tx.toHex();
+				const txid = tx.id("hex");
+
+				if (config?.disableBroadcasting) {
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify({
+									success: true,
+									disabledBroadcast: true,
+									txid,
+									rawTx: txHex,
+									message: `Broadcasting disabled. Friend request transaction built for ${targetBapId}.`,
+								}),
+							},
+						],
+					};
+				}
+
+				// --- Broadcast ---
+				const broadcaster = new BsocialBroadcaster();
+				const broadcastResult = await tx.broadcast(broadcaster);
+
+				let success = true;
+				let errorMsg: string | undefined;
+				let resultTxid = txid;
+
+				if (isBroadcastResponse(broadcastResult as BroadcastResponse)) {
+					resultTxid = (broadcastResult as BroadcastResponse).txid;
+				} else if (isBroadcastFailure(broadcastResult as BroadcastFailure)) {
+					success = false;
+					const failure = broadcastResult as BroadcastFailure;
+					errorMsg = `Broadcast failed: ${failure.description} (Code: ${failure.code})`;
+					if (failure.txid) resultTxid = failure.txid;
+				}
+
+				return {
+					isError: !success,
+					content: [
+						{
+							type: "text",
+							text: JSON.stringify({
+								success,
+								txid: resultTxid,
+								rawTx: txHex,
+								message: success
+									? `Friend request sent to ${targetBapId}.`
+									: (errorMsg ?? "Broadcast failed"),
+							}),
+						},
+					],
+				};
+			} catch (err) {
+				const errMsg = err instanceof Error ? err.message : String(err);
+				return {
+					isError: true,
+					content: [
+						{
+							type: "text",
+							text: `Failed to send friend request: ${errMsg}`,
+						},
+					],
+				};
+			}
+		},
+	);
+}

package/tools/bap/generate.test.ts

@@ -0,0 +1,350 @@
+import {
+	afterEach,
+	beforeEach,
+	describe,
+	expect,
+	it,
+	mock,
+	spyOn,
+} from "bun:test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { HD, PrivateKey, Transaction } from "@bsv/sdk";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import type {
+	CallToolResult,
+	ServerNotification,
+	ServerRequest,
+} from "@modelcontextprotocol/sdk/types.js";
+import * as passphrasePromptModule from "../../utils/passphrasePrompt";
+import * as utxoUtils from "../wallet/fetchPaymentUtxos";
+import { type BapGenerateArgs, registerBapGenerateTool } from "./generate";
+
+type GenericToolHandler = (
+	params: { args: BapGenerateArgs },
+	extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
+) => CallToolResult | Promise<CallToolResult>;
+
+const mockMcpServerInstance = {
+	tool: (..._args: Parameters<McpServer["tool"]>): void => undefined,
+};
+
+const KEY_DIR = path.join(os.homedir(), ".bsv-mcp");
+const KEY_FILE_PATH = path.join(KEY_DIR, "keys.json");
+
+const MOCK_PAY_PK_WIF = "L3tg5yk23vBrSGZT8pfrDFQBK8n46eeot2Sf91ezNt7rhyReCA53";
+const MOCK_PAY_ADDRESS = PrivateKey.fromWif(MOCK_PAY_PK_WIF).toAddress();
+const MOCK_KEYS_WITH_PAYPK = { payPk: MOCK_PAY_PK_WIF };
+const MOCK_UTXO_SCRIPT_HASH_PLACEHOLDER =
+	"1a2b3c4d5e6f7081920a1b2c3d4e5f607081920a";
+const MOCK_UTXO = {
+	txid: "a1b2c3d4".repeat(8),
+	vout: 0,
+	satoshis: 100000,
+	script: `76a914${MOCK_UTXO_SCRIPT_HASH_PLACEHOLDER}88ac`,
+};
+
+describe("BAP Generate Tool", () => {
+	let readFileSyncSpy: ReturnType<typeof spyOn<typeof fs, "readFileSync">>;
+	let writeFileSyncSpy: ReturnType<typeof spyOn<typeof fs, "writeFileSync">>;
+	let existsSyncSpy: ReturnType<typeof spyOn<typeof fs, "existsSync">>;
+	let mkdirSyncSpy: ReturnType<typeof spyOn<typeof fs, "mkdirSync">>;
+	let mockServerToolSpy: ReturnType<
+		typeof spyOn<typeof mockMcpServerInstance, "tool">
+	>;
+	let fetchPaymentUtxosSpy: ReturnType<
+		typeof spyOn<typeof utxoUtils, "fetchPaymentUtxos">
+	>;
+	let transactionBroadcastSpy: ReturnType<
+		typeof spyOn<Transaction.prototype, "broadcast">
+	>;
+	let passphrasePromptSpy: ReturnType<
+		typeof spyOn<
+			typeof passphrasePromptModule,
+			"promptForPassphraseWithFallback"
+		>
+	>;
+
+	beforeEach(() => {
+		mockServerToolSpy = spyOn(mockMcpServerInstance, "tool");
+		mockServerToolSpy.mockClear();
+
+		readFileSyncSpy = spyOn(fs, "readFileSync");
+		writeFileSyncSpy = spyOn(fs, "writeFileSync");
+		existsSyncSpy = spyOn(fs, "existsSync");
+		mkdirSyncSpy = spyOn(fs, "mkdirSync");
+		fetchPaymentUtxosSpy = spyOn(utxoUtils, "fetchPaymentUtxos");
+		transactionBroadcastSpy = spyOn(Transaction.prototype, "broadcast");
+		passphrasePromptSpy = spyOn(
+			passphrasePromptModule,
+			"promptForPassphraseWithFallback",
+		);
+
+		// Make existsSync path-aware: .bep files return false (skip encrypted path),
+		// .json files return true (use legacy path)
+		existsSyncSpy.mockImplementation((filePath: fs.PathLike) => {
+			const p = String(filePath);
+			if (p.endsWith(".bep") || p.endsWith(".bep.backup")) return false;
+			return true;
+		});
+		// Reject passphrase prompts immediately so SecureKeyManager falls through
+		// to legacy/unencrypted code paths (simulates user cancelling the prompt)
+		passphrasePromptSpy.mockRejectedValue(new Error("cancelled by test"));
+		readFileSyncSpy.mockReturnValue(JSON.stringify(MOCK_KEYS_WITH_PAYPK));
+		mkdirSyncSpy.mockImplementation(() => undefined);
+		writeFileSyncSpy.mockImplementation(() => undefined);
+		fetchPaymentUtxosSpy.mockResolvedValue([MOCK_UTXO]);
+		transactionBroadcastSpy.mockResolvedValue(
+			`mock_txid_broadcasted_${"a".repeat(40)}`,
+		);
+	});
+
+	afterEach(() => {
+		mockServerToolSpy.mockRestore();
+		readFileSyncSpy.mockRestore();
+		writeFileSyncSpy.mockRestore();
+		existsSyncSpy.mockRestore();
+		mkdirSyncSpy.mockRestore();
+		fetchPaymentUtxosSpy.mockRestore();
+		transactionBroadcastSpy.mockRestore();
+		passphrasePromptSpy.mockRestore();
+	});
+
+	it("should register bap_generate tool with the MCP server", () => {
+		registerBapGenerateTool(mockMcpServerInstance as unknown as McpServer);
+		expect(mockServerToolSpy).toHaveBeenCalledTimes(1);
+		expect(mockServerToolSpy).toHaveBeenCalledWith(
+			"bap_generate",
+			expect.any(String),
+			{ args: expect.any(Object) },
+			expect.any(Function),
+		);
+	});
+
+	const getRegisteredHandler = (): GenericToolHandler => {
+		if (mockServerToolSpy.mock.calls.length === 0) {
+			throw new Error("Tool handler not registered or spy not called.");
+		}
+		return mockServerToolSpy.mock.calls[0][3] as GenericToolHandler;
+	};
+
+	it("should generate keys and TX if payPk exists and no BAP keys, and save all to keys.json", async () => {
+		const initialKeys = { payPk: MOCK_PAY_PK_WIF };
+		readFileSyncSpy.mockReturnValue(JSON.stringify(initialKeys));
+		fetchPaymentUtxosSpy.mockResolvedValue([MOCK_UTXO]);
+
+		registerBapGenerateTool(mockMcpServerInstance as unknown as McpServer);
+		const handler = getRegisteredHandler();
+		const mockExtra = {} as RequestHandlerExtra<
+			ServerRequest,
+			ServerNotification
+		>;
+		const result = (await handler({ args: {} }, mockExtra)) as CallToolResult;
+
+		expect(result.isError).toBe(false);
+		expect(mkdirSyncSpy).toHaveBeenCalledWith(KEY_DIR, {
+			recursive: true,
+			mode: 0o700,
+		});
+		expect(writeFileSyncSpy).toHaveBeenCalledTimes(1);
+		const writtenData = JSON.parse(
+			writeFileSyncSpy.mock.calls[0][1] as string,
+		) as Record<string, string>;
+
+		expect(writtenData.payPk).toBe(MOCK_PAY_PK_WIF);
+		expect(writtenData.xprv).toBeString();
+		expect(writtenData.xprv?.startsWith("xprv")).toBe(true);
+		expect(writtenData.identityPk).toBeString();
+
+		expect(result.content?.[0]?.text).toContain(
+			"BAP HD Key and Initial Identity Generated & Saved",
+		);
+		expect(result.content?.[0]?.text).toContain("Registration TXID:");
+		expect(transactionBroadcastSpy).toHaveBeenCalled();
+	});
+
+	it("should return error if keys.json does not exist", async () => {
+		existsSyncSpy.mockReturnValue(false);
+
+		registerBapGenerateTool(mockMcpServerInstance as unknown as McpServer);
+		const handler = getRegisteredHandler();
+		const mockExtra = {} as RequestHandlerExtra<
+			ServerRequest,
+			ServerNotification
+		>;
+		const result = (await handler({ args: {} }, mockExtra)) as CallToolResult;
+
+		expect(result.isError).toBe(true);
+		expect(result.content?.[0]?.text).toContain(
+			"keys.json not found. Payment Private Key (payPk) is required.",
+		);
+		expect(writeFileSyncSpy).not.toHaveBeenCalled();
+	});
+
+	it("should return error if payPk is missing from keys.json", async () => {
+		readFileSyncSpy.mockReturnValue(JSON.stringify({ someOtherKey: "value" }));
+
+		registerBapGenerateTool(mockMcpServerInstance as unknown as McpServer);
+		const handler = getRegisteredHandler();
+		const mockExtra = {} as RequestHandlerExtra<
+			ServerRequest,
+			ServerNotification
+		>;
+		const result = (await handler({ args: {} }, mockExtra)) as CallToolResult;
+
+		expect(result.isError).toBe(true);
+		expect(result.content?.[0]?.text).toContain(
+			"Payment Private Key (payPk) does not exist in keys.json.",
+		);
+		expect(writeFileSyncSpy).not.toHaveBeenCalled();
+	});
+
+	it("should return error if xprv already exists", async () => {
+		const existingKeys = {
+			payPk: MOCK_PAY_PK_WIF,
+			xprv: "already_exists_xprv",
+		};
+		readFileSyncSpy.mockReturnValue(JSON.stringify(existingKeys));
+
+		registerBapGenerateTool(mockMcpServerInstance as unknown as McpServer);
+		const handler = getRegisteredHandler();
+		const mockExtra = {} as RequestHandlerExtra<
+			ServerRequest,
+			ServerNotification
+		>;
+		const result = (await handler({ args: {} }, mockExtra)) as CallToolResult;
+
+		expect(result.isError).toBe(true);
+		expect(result.content?.[0]?.text).toContain(
+			"BAP Master Key (xprv) already exists in keys.json.",
+		);
+		expect(writeFileSyncSpy).not.toHaveBeenCalled();
+	});
+
+	it("should return error if identityPk already exists", async () => {
+		const existingKeys = {
+			payPk: MOCK_PAY_PK_WIF,
+			identityPk: "L5BBNhvVgvpdV1AkMJMNGy89MHEUnyiKhrs11GNAUxWjXvhxgcAg",
+		};
+		readFileSyncSpy.mockReturnValue(JSON.stringify(existingKeys));
+
+		registerBapGenerateTool(mockMcpServerInstance as unknown as McpServer);
+		const handler = getRegisteredHandler();
+		const mockExtra = {} as RequestHandlerExtra<
+			ServerRequest,
+			ServerNotification
+		>;
+		const result = (await handler({ args: {} }, mockExtra)) as CallToolResult;
+
+		expect(result.isError).toBe(true);
+		expect(result.content?.[0]?.text).toContain(
+			"BAP Identity Key (identityPk) already exists in keys.json.",
+		);
+		expect(writeFileSyncSpy).not.toHaveBeenCalled();
+	});
+
+	it("should handle HD key generation error gracefully", async () => {
+		const originalHDFromRandom = HD.fromRandom;
+		HD.fromRandom = () => {
+			throw new Error("Test HD generation error");
+		};
+		readFileSyncSpy.mockReturnValue(JSON.stringify(MOCK_KEYS_WITH_PAYPK));
+
+		const mockExtra = {} as RequestHandlerExtra<
+			ServerRequest,
+			ServerNotification
+		>;
+
+		try {
+			registerBapGenerateTool(mockMcpServerInstance as unknown as McpServer);
+			const handler = getRegisteredHandler();
+			const result = (await handler({ args: {} }, mockExtra)) as CallToolResult;
+
+			expect(result.isError).toBe(true);
+			expect(result.content?.[0]?.text).toContain(
+				"Failed during BAP key generation/saving or transaction construction: Test HD generation error",
+			);
+			expect(writeFileSyncSpy).not.toHaveBeenCalled();
+		} finally {
+			HD.fromRandom = originalHDFromRandom;
+		}
+	});
+
+	it("should handle error if keys.json is corrupt", async () => {
+		readFileSyncSpy.mockImplementation(() => {
+			throw new Error("JSON Parse error: Unexpected identifier 'this'.");
+		});
+
+		registerBapGenerateTool(mockMcpServerInstance as unknown as McpServer);
+		const handler = getRegisteredHandler();
+		const mockExtra = {} as RequestHandlerExtra<
+			ServerRequest,
+			ServerNotification
+		>;
+		const result = (await handler({ args: {} }, mockExtra)) as CallToolResult;
+
+		expect(result.isError).toBe(true);
+		expect(result.content?.[0]?.text).toContain(
+			"Could not read or parse keys.json: JSON Parse error",
+		);
+		expect(writeFileSyncSpy).not.toHaveBeenCalled();
+	});
+
+	it("should handle error if no UTXOs are found for payPk", async () => {
+		readFileSyncSpy.mockReturnValue(JSON.stringify(MOCK_KEYS_WITH_PAYPK));
+		fetchPaymentUtxosSpy.mockResolvedValue([]);
+
+		registerBapGenerateTool(mockMcpServerInstance as unknown as McpServer);
+		const handler = getRegisteredHandler();
+		const mockExtra = {} as RequestHandlerExtra<
+			ServerRequest,
+			ServerNotification
+		>;
+		const result = (await handler({ args: {} }, mockExtra)) as CallToolResult;
+
+		expect(result.isError).toBe(false);
+		expect(result.content?.[0]?.text).toContain(
+			"No UTXOs found for payment address",
+		);
+		expect(result.content?.[0]?.text).toContain(
+			"Cannot fund BAP registration.",
+		);
+		expect(writeFileSyncSpy).toHaveBeenCalledTimes(1);
+		const writtenData = JSON.parse(
+			writeFileSyncSpy.mock.calls[0][1] as string,
+		) as Record<string, string>;
+		expect(writtenData.xprv).toBeString();
+		expect(writtenData.identityPk).toBeString();
+		expect(transactionBroadcastSpy).not.toHaveBeenCalled();
+	});
+
+	it("should handle error if transaction broadcast fails", async () => {
+		readFileSyncSpy.mockReturnValue(JSON.stringify(MOCK_KEYS_WITH_PAYPK));
+		fetchPaymentUtxosSpy.mockResolvedValue([MOCK_UTXO]);
+		transactionBroadcastSpy.mockRejectedValue(
+			new Error("Broadcast network error"),
+		);
+
+		registerBapGenerateTool(mockMcpServerInstance as unknown as McpServer);
+		const handler = getRegisteredHandler();
+		const mockExtra = {} as RequestHandlerExtra<
+			ServerRequest,
+			ServerNotification
+		>;
+		const result = (await handler({ args: {} }, mockExtra)) as CallToolResult;
+
+		expect(result.isError).toBe(false);
+		expect(result.content?.[0]?.text).toContain(
+			"Keys generated and saved, but failed to broadcast BAP registration transaction",
+		);
+		expect(result.content?.[0]?.text).toContain("Broadcast network error");
+		expect(writeFileSyncSpy).toHaveBeenCalledTimes(1);
+		const writtenData = JSON.parse(
+			writeFileSyncSpy.mock.calls[0][1] as string,
+		) as Record<string, string>;
+		expect(writtenData.xprv).toBeString();
+		expect(transactionBroadcastSpy).toHaveBeenCalled();
+	});
+});