bsv-mcp 0.0.35 → 0.2.0

package/tools/wallet/tools.ts

@@ -1,5 +1,8 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { ToolCallback } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type PrivateKey, Utils } from "@bsv/sdk";
+import type {
+	McpServer,
+	ToolCallback,
+} from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
 import type {
 	CallToolResult,
@@ -7,84 +10,48 @@ import type {
 	ServerRequest,
 } from "@modelcontextprotocol/sdk/types.js";
 import type { z } from "zod";
-import type {
-	abortActionArgsSchema,
-	acquireCertificateArgsSchema,
-	createHmacArgsSchema,
-	discoverByAttributesArgsSchema,
-	discoverByIdentityKeyArgsSchema,
-	getHeaderArgsSchema,
-	internalizeActionArgsSchema,
-	listActionsArgsSchema,
-	listCertificatesArgsSchema,
-	listOutputsArgsSchema,
-	proveCertificateArgsSchema,
-	relinquishCertificateArgsSchema,
-	relinquishOutputArgsSchema,
-	revealCounterpartyKeyLinkageArgsSchema,
-	revealSpecificKeyLinkageArgsSchema,
-	verifyHmacArgsSchema,
-} from "./schemas";
-import type { Wallet } from "./wallet";
-
 import {
-	createSignatureArgsSchema,
+	type a2bPublishMcpArgsSchema,
+	registerA2bPublishMcpTool,
+} from "./a2bPublishMcp";
+import {
+	type createOrdinalsArgsSchema,
+	registerCreateOrdinalsTool,
+} from "./createOrdinals";
+import { registerGatherCollectionInfoTool } from "./gatherCollectionInfo";
+import { registerGetAddressTool } from "./getAddress";
+import { registerWalletGetBalanceTool } from "./getBalance";
+import { registerGetPublicKeyTool } from "./getPublicKey";
+import { registerMintCollectionTool } from "./mintCollection";
+import { registerPurchaseListingTool } from "./purchaseListing";
+import { registerRefreshUtxosTool } from "./refreshUtxos";
+import {
 	type emptyArgsSchema,
 	type getAddressArgsSchema,
 	type getPublicKeyArgsSchema,
 	type purchaseListingArgsSchema,
 	type sendToAddressArgsSchema,
-	verifySignatureArgsSchema,
 	walletEncryptionArgsSchema,
 } from "./schemas";
-
-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 { registerRefreshUtxosTool } from "./refreshUtxos";
 import { registerSendToAddressTool } from "./sendToAddress";
-import { registerTransferOrdTokenTool } from "./transferOrdToken";
-
-import type { a2bPublishArgsSchema } from "./a2bPublishAgent";
-import { registerA2bPublishMcpTool } from "./a2bPublishMcp";
-import type { transferOrdTokenArgsSchema } from "./transferOrdToken";
+import {
+	registerTransferOrdTokenTool,
+	type transferOrdTokenArgsSchema,
+} from "./transferOrdToken";
+import type { Wallet } from "./wallet";
 
 // Define mapping from tool names to argument schemas
 type ToolArgSchemas = {
 	wallet_getPublicKey: typeof getPublicKeyArgsSchema;
-	wallet_createSignature: typeof createSignatureArgsSchema;
-	wallet_verifySignature: typeof verifySignatureArgsSchema;
 	wallet_encryption: typeof walletEncryptionArgsSchema;
-	wallet_listActions: typeof listActionsArgsSchema;
-	wallet_listOutputs: typeof listOutputsArgsSchema;
-	wallet_getNetwork: typeof emptyArgsSchema;
-	wallet_getVersion: typeof emptyArgsSchema;
-	wallet_revealCounterpartyKeyLinkage: typeof revealCounterpartyKeyLinkageArgsSchema;
-	wallet_revealSpecificKeyLinkage: typeof revealSpecificKeyLinkageArgsSchema;
-	wallet_createHmac: typeof createHmacArgsSchema;
-	wallet_verifyHmac: typeof verifyHmacArgsSchema;
-	wallet_abortAction: typeof abortActionArgsSchema;
-	wallet_internalizeAction: typeof internalizeActionArgsSchema;
-	wallet_relinquishOutput: typeof relinquishOutputArgsSchema;
-	wallet_acquireCertificate: typeof acquireCertificateArgsSchema;
-	wallet_listCertificates: typeof listCertificatesArgsSchema;
-	wallet_proveCertificate: typeof proveCertificateArgsSchema;
-	wallet_relinquishCertificate: typeof relinquishCertificateArgsSchema;
-	wallet_discoverByIdentityKey: typeof discoverByIdentityKeyArgsSchema;
-	wallet_discoverByAttributes: typeof discoverByAttributesArgsSchema;
-	wallet_isAuthenticated: typeof emptyArgsSchema;
-	wallet_waitForAuthentication: typeof emptyArgsSchema;
-	wallet_getHeaderForHeight: typeof getHeaderArgsSchema;
 	wallet_getAddress: typeof getAddressArgsSchema;
 	wallet_sendToAddress: typeof sendToAddressArgsSchema;
 	wallet_purchaseListing: typeof purchaseListingArgsSchema;
 	wallet_transferOrdToken: typeof transferOrdTokenArgsSchema;
-	wallet_a2bPublish: typeof a2bPublishArgsSchema;
+	wallet_a2bPublish: typeof a2bPublishMcpArgsSchema;
 	wallet_createOrdinals: typeof createOrdinalsArgsSchema;
 	wallet_refreshUtxos: typeof emptyArgsSchema;
+	wallet_getBalance: typeof emptyArgsSchema;
 };
 
 // Define a type for the handler function with proper argument types
@@ -104,6 +71,7 @@ export function registerWalletTools(
 	config: {
 		disableBroadcasting: boolean;
 		enableA2bTools: boolean;
+		identityPk?: PrivateKey;
 	},
 ): ToolHandlerMap {
 	const handlers = {} as ToolHandlerMap;
@@ -124,7 +92,7 @@ export function registerWalletTools(
 	registerSendToAddressTool(server, wallet);
 
 	// Register the wallet_getAddress tool
-	registerGetAddressTool(server);
+	registerGetAddressTool(server, wallet);
 
 	// Register the wallet_getPublicKey tool
 	registerGetPublicKeyTool(server, wallet);
@@ -138,58 +106,17 @@ export function registerWalletTools(
 	// Register the wallet_refreshUtxos tool
 	registerRefreshUtxosTool(server, wallet);
 
+	// Register the wallet_getBalance tool
+	registerWalletGetBalanceTool(server, wallet);
+
 	// A2B tools have to be explicitly enabled
 	if (config.enableA2bTools) {
-		// Register the wallet_a2bPublishAgent tool
-		// registerA2bPublishAgentTool(server, wallet);
-
 		// Register the wallet_a2bPublishMcp tool
-		registerA2bPublishMcpTool(server, wallet, {
+		registerA2bPublishMcpTool(server, wallet, config.identityPk, {
 			disableBroadcasting: config.disableBroadcasting,
 		});
 	}
 
-	// Register only the minimal public-facing tools
-	// wallet_createAction, wallet_signAction and wallet_getHeight have been removed
-
-	// Register wallet_createSignature
-	registerTool(
-		"wallet_createSignature",
-		"Creates a cryptographic signature using the wallet's private key. This tool enables secure message signing and transaction authorization, supporting various signature protocols.",
-		{ args: createSignatureArgsSchema },
-		async (
-			{ args }: { args: z.infer<typeof createSignatureArgsSchema> },
-			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
-		) => {
-			try {
-				const result = await wallet.createSignature(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_verifySignature
-	registerTool(
-		"wallet_verifySignature",
-		"Verifies a cryptographic signature against a message or data. This tool supports various verification protocols and can validate signatures from both the wallet's own keys and external public keys.",
-		{ args: verifySignatureArgsSchema },
-		async (
-			{ args }: { args: z.infer<typeof verifySignatureArgsSchema> },
-			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
-		) => {
-			try {
-				const result = await wallet.verifySignature(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 combined wallet_encryption tool
 	registerTool(
 		"wallet_encryption",
@@ -197,12 +124,15 @@ export function registerWalletTools(
 			"PARAMETERS:\n" +
 			'- mode: (required) Either "encrypt" to encrypt plaintext or "decrypt" to decrypt ciphertext\n' +
 			"- data: (required) Text string or array of numbers to process\n" +
-			"- encoding: (optional) For text input, the encoding format (utf8, hex, base64) - default is utf8\n\n" +
+			"- encoding: (optional) For text input, the encoding format (utf8, hex, base64) - default is utf8\n" +
+			"- recipientPublicKeyHex: (optional) Hexadecimal representation of the recipient's public key (required for encrypt mode)\n\n" +
 			"EXAMPLES:\n" +
 			"1. Encrypt text data:\n" +
 			"   {\n" +
 			'     "mode": "encrypt",\n' +
-			'     "data": "Hello World"\n' +
+			'     "data": "Hello World",\n' +
+			'     "encoding": "utf8",\n' +
+			'     "recipientPublicKeyHex": "020202020202020202020202020202020202020202020202020202020202020202"\n' +
 			"   }\n\n" +
 			"2. Decrypt previously encrypted data:\n" +
 			"   {\n" +
@@ -215,60 +145,41 @@ export function registerWalletTools(
 			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
 		) => {
 			try {
-				const { mode, data, encoding } = args;
+				const { mode, data, encoding, recipientPublicKeyHex } = args;
 
-				// Set default values for required parameters
-				const protocolID: WalletProtocol = [1, "aes256"];
-				const keyID = "default";
-
-				// Convert string data to binary if needed
-				let binaryData: number[];
-				if (Array.isArray(data)) {
-					binaryData = data;
+				let inputData: number[];
+				if (typeof data === "string") {
+					inputData = Utils.toArray(data, encoding || "utf8");
 				} else {
-					// String data with encoding
-					const { toArray } = Utils;
-					binaryData = toArray(data, encoding || "utf8");
+					inputData = Array.from(data);
 				}
 
-				let result: { ciphertext?: number[]; plaintext?: number[] | string } =
-					{};
-				if (mode === "encrypt") {
-					result = await wallet.encrypt({
-						plaintext: binaryData,
-						protocolID,
-						keyID,
-					});
-				} else if (mode === "decrypt") {
-					result = await wallet.decrypt({
-						ciphertext: binaryData,
-						protocolID,
-						keyID,
-					});
+				// let resultBuffer: Buffer;
+				// let resultOutput: string | number[];
 
-					// For decryption, convert plaintext back to string if it's likely UTF-8 text
-					if (result.plaintext as number[]) {
-						try {
-							const { toUTF8 } = Utils;
-							const textResult = toUTF8(result.plaintext as number[]);
-							// If conversion succeeds and seems like valid text, return as string
-							if (textResult && textResult.length > 0) {
-								return {
-									content: [
-										{
-											type: "text",
-											text: JSON.stringify({ plaintext: textResult }),
-										},
-									],
-								};
-							}
-						} catch (e) {
-							// If UTF-8 conversion fails, continue with binary result
-						}
-					}
+				if (mode === "encrypt") {
+					// recipientPublicKeyHex is validated by Zod schema to be present for encrypt mode
+					// The schema ensures recipientPublicKeyHex is defined here.
+					// resultBuffer = await wallet.encrypt({
+					// 	data: inputBuffer,
+					// 	recipientPublicKeyHex: recipientPublicKeyHex as string, // Still needs type assertion if Zod optional isn't fully narrowed
+					// });
+					throw new Error("Encrypt method not yet implemented in wallet");
+					// if (encoding === "utf8") {
+					// 	resultOutput = Array.from(resultBuffer);
+					// } else {
+					// 	resultOutput = resultBuffer.toString(encoding || "base64");
+					// }
 				}
-
-				return { content: [{ type: "text", text: JSON.stringify(result) }] };
+				// mode === "decrypt"
+				// resultBuffer = await wallet.decrypt({ data: inputBuffer });
+				throw new Error("Decrypt method not yet implemented in wallet");
+
+				// return {
+				// 	content: [
+				// 		{ type: "text", text: JSON.stringify({ data: resultOutput }) },
+				// 	],
+				// };
 			} catch (error) {
 				const errorMessage =
 					error instanceof Error ? error.message : String(error);
@@ -288,5 +199,9 @@ export function registerWalletTools(
 	// Register createOrdinals tool
 	registerCreateOrdinalsTool(server, wallet);
 
+	// Register collection tools
+	registerGatherCollectionInfoTool(server, wallet);
+	registerMintCollectionTool(server, wallet);
+
 	return handlers;
 }

package/tools/wallet/transactionHelper.ts

@@ -0,0 +1,121 @@
+import { PrivateKey } from "@bsv/sdk";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import {
+	createErrorResponse,
+	createResponse,
+	formatError,
+} from "../utils/errorHandler";
+import type { Wallet } from "./wallet";
+
+interface TransactionContext {
+	wallet: Wallet;
+	identityKey?: string; // WIF from environment
+}
+
+interface TransactionResult {
+	success: boolean;
+	txid?: string;
+	rawTx?: string;
+	[key: string]: unknown;
+}
+
+/**
+ * Common transaction workflow wrapper
+ */
+export async function executeTransaction<TArgs>(
+	args: TArgs,
+	context: TransactionContext,
+	handler: (
+		args: TArgs,
+		keys: {
+			paymentKey: PrivateKey;
+			identityKey?: PrivateKey;
+			address: string;
+		},
+		wallet: Wallet,
+	) => Promise<TransactionResult>,
+): Promise<CallToolResult> {
+	try {
+		const { wallet, identityKey: identityKeyWif } = context;
+
+		// Get payment key
+		const paymentKey = wallet.getPaymentKey();
+		if (!paymentKey) {
+			throw new Error("Payment key not available");
+		}
+
+		// Get address
+		const address = await wallet.getAddress();
+		if (!address) {
+			throw new Error("Could not get wallet address");
+		}
+
+		// Parse identity key if provided
+		let identityKey: PrivateKey | undefined;
+		if (identityKeyWif) {
+			try {
+				identityKey = PrivateKey.fromWif(identityKeyWif);
+			} catch (e) {
+				console.warn(
+					"Invalid IDENTITY_KEY_WIF provided, skipping identity features",
+				);
+			}
+		}
+
+		// Execute the transaction handler
+		const result = await handler(
+			args,
+			{ paymentKey, identityKey, address: address.toString() },
+			wallet,
+		);
+
+		// Refresh UTXOs after successful transaction
+		if (
+			result.success &&
+			result.txid &&
+			process.env.DISABLE_BROADCASTING !== "true"
+		) {
+			wallet.refreshUtxos().catch((err) => {
+				console.warn("Failed to refresh UTXOs after transaction:", err);
+			});
+		}
+
+		return createResponse(result);
+	} catch (error) {
+		return createErrorResponse(error);
+	}
+}
+
+/**
+ * Get identity key from environment
+ */
+export function getIdentityKeyFromEnv(): PrivateKey | undefined {
+	const identityKeyWif = process.env.IDENTITY_KEY_WIF;
+	if (!identityKeyWif) return undefined;
+
+	try {
+		return PrivateKey.fromWif(identityKeyWif);
+	} catch (e) {
+		console.warn("Invalid IDENTITY_KEY_WIF in environment:", formatError(e));
+		return undefined;
+	}
+}
+
+/**
+ * Standard response for disabled broadcasting
+ */
+export function createDisabledBroadcastResponse(
+	txid: string,
+	rawTx: string,
+	extra?: Record<string, unknown>,
+): TransactionResult {
+	return {
+		success: true,
+		txid,
+		rawTx,
+		broadcastDisabled: true,
+		message:
+			"Broadcasting disabled. Use the raw transaction hex to broadcast manually.",
+		...extra,
+	};
+}

package/tools/wallet/transferOrdToken.ts

@@ -8,18 +8,20 @@ import type {
 import {
 	type Distribution,
 	type LocalSigner,
+	OneSatBroadcaster,
 	type Payment,
+	selectTokenUtxos,
 	type TokenChangeResult,
 	TokenInputMode,
 	TokenSelectionStrategy,
 	TokenType,
 	type TokenUtxo,
 	type TransferOrdTokensConfig,
-	type Utxo,
-	selectTokenUtxos,
 	transferOrdTokens,
+	type Utxo,
 } from "js-1sat-ord";
 import { z } from "zod";
+import { V5Broadcaster } from "../../utils/broadcaster";
 import type { Wallet } from "./wallet";
 
 // Schema for BSV-20/BSV-21 token transfer arguments
@@ -70,7 +72,7 @@ export function registerTransferOrdTokenTool(
 		) => {
 			try {
 				// fetch keys
-				const paymentPk = wallet.getPrivateKey();
+				const paymentPk = wallet.getPaymentKey();
 				if (!paymentPk) throw new Error("No private key available");
 				const ordPk = paymentPk;
 				const changeAddress = paymentPk.toAddress().toString();
@@ -122,7 +124,8 @@ export function registerTransferOrdTokenTool(
 				const result: TokenChangeResult = await transferOrdTokens(config);
 				const disableBroadcasting = process.env.DISABLE_BROADCASTING === "true";
 				if (!disableBroadcasting) {
-					await result.tx.broadcast();
+					const broadcaster = new V5Broadcaster();
+					await result.tx.broadcast(broadcaster);
 
 					// refresh UTXOs
 					try {

package/tools/wallet/utxo.ts

@@ -0,0 +1,62 @@
+import { Transaction } from "@bsv/sdk";
+
+export async function getTransactionById(
+	txid: string,
+): Promise<Transaction | null> {
+	const url = `https://junglebus.gorillapool.io/v1/transaction/${txid}`;
+	try {
+		const response = await fetch(url);
+		if (!response.ok) {
+			console.error(
+				`Failed to fetch transaction ${txid} from Junglebus: ${response.status} ${response.statusText}`,
+			);
+			return null;
+		}
+		const rawTxBuffer = await response.arrayBuffer();
+		if (!rawTxBuffer) {
+			console.error(`Empty raw transaction buffer for ${txid} from Junglebus`);
+			return null;
+		}
+
+		const uint8Array = arrayBufferToUint8Array(rawTxBuffer);
+		const tx = Transaction.fromBinary(uint8Array);
+
+		return tx;
+	} catch (error) {
+		console.error(
+			`Error fetching or parsing transaction ${txid}: ${error instanceof Error ? error.message : String(error)}`,
+		);
+		return null;
+	}
+}
+
+export async function getBeefTransactionById(
+	txid: string,
+): Promise<Transaction | null> {
+	const url = `https://junglebus.gorillapool.io/v1/transaction/beef/${txid}`;
+	try {
+		// console.error("URL:", url);
+		const response = await fetch(url);
+		if (!response.ok) {
+			console.warn(
+				`Failed to fetch transaction ${txid} from Junglebus: ${response.status} ${response.statusText}`,
+			);
+			return null;
+		}
+		const rawTxBuffer = await response.arrayBuffer();
+		if (!rawTxBuffer) {
+			console.warn(`Empty raw transaction buffer for ${txid} from Junglebus`);
+			return null;
+		}
+
+		const uint8Array = arrayBufferToUint8Array(rawTxBuffer);
+		const tx = Transaction.fromBEEF(uint8Array, txid);
+
+		return tx;
+	} catch (error) {
+		console.warn(
+			`Error fetching or parsing transaction ${txid}: ${error instanceof Error ? error.message : String(error)}`,
+		);
+		return null;
+	}
+}