bsv-mcp 0.0.36 → 0.2.7

package/tools/wallet/schemas.ts

@@ -1,77 +1,11 @@
-import type { SecurityLevel } from "@bsv/sdk";
 import { z } from "zod";
 
-// Define SecurityLevel to match the BSV SDK exactly
-const SecurityLevelEnum = z.union([z.literal(0), z.literal(1), z.literal(2)]);
-
-// Create a custom validator without tuples
-export const walletProtocolSchema = z.custom<[SecurityLevel, string]>((val) => {
-	return (
-		Array.isArray(val) &&
-		val.length === 2 &&
-		(val[0] === 0 || val[0] === 1 || val[0] === 2) &&
-		typeof val[1] === "string"
-	);
-});
-
 // Empty args schema for functions that don't take arguments
 export const emptyArgsSchema = z.object({});
 
 // Get public key arguments
 export const getPublicKeyArgsSchema = z.object({});
 
-// Create signature arguments
-export const createSignatureArgsSchema = z.object({
-	data: z.array(z.number()).optional(),
-	hashToDirectlySign: z.array(z.number()).optional(),
-	protocolID: walletProtocolSchema,
-	keyID: z.string(),
-	privilegedReason: z.string().optional(),
-	counterparty: z
-		.union([z.string(), z.literal("self"), z.literal("anyone")])
-		.optional(),
-	privileged: z.boolean().optional(),
-});
-
-// Verify signature arguments
-export const verifySignatureArgsSchema = z.object({
-	data: z.array(z.number()).optional(),
-	hashToDirectlyVerify: z.array(z.number()).optional(),
-	signature: z.array(z.number()),
-	protocolID: walletProtocolSchema,
-	keyID: z.string(),
-	privilegedReason: z.string().optional(),
-	counterparty: z
-		.union([z.string(), z.literal("self"), z.literal("anyone")])
-		.optional(),
-	forSelf: z.boolean().optional(),
-	privileged: z.boolean().optional(),
-});
-
-// Wallet encryption args
-export const walletEncryptArgsSchema = z.object({
-	plaintext: z.array(z.number()),
-	protocolID: walletProtocolSchema,
-	keyID: z.string(),
-	privilegedReason: z.string().optional(),
-	counterparty: z
-		.union([z.string(), z.literal("self"), z.literal("anyone")])
-		.optional(),
-	privileged: z.boolean().optional(),
-});
-
-// Wallet decryption args
-export const walletDecryptArgsSchema = z.object({
-	ciphertext: z.array(z.number()),
-	protocolID: walletProtocolSchema,
-	keyID: z.string(),
-	privilegedReason: z.string().optional(),
-	counterparty: z
-		.union([z.string(), z.literal("self"), z.literal("anyone")])
-		.optional(),
-	privileged: z.boolean().optional(),
-});
-
 // Combined wallet encryption/decryption args
 export const walletEncryptionArgsSchema = z
 	.object({
@@ -91,190 +25,25 @@ export const walletEncryptionArgsSchema = z
 			.optional()
 			.default("utf8")
 			.describe("Encoding of text data (default: utf8)"),
+		recipientPublicKeyHex: z
+			.string()
+			.length(66)
+			.regex(/^(02|03)[0-9a-fA-F]{64}$/)
+			.optional()
+			.describe(
+				"Recipient's public key in hex format (required for encryption mode)",
+			),
 	})
-	.describe("Schema for encryption and decryption operations");
-
-// Create HMAC arguments
-export const createHmacArgsSchema = z.object({
-	message: z.string(),
-	encoding: z.enum(["utf8", "hex", "base64"]).optional(),
-});
-
-// Verify HMAC arguments
-export const verifyHmacArgsSchema = z.object({
-	message: z.string(),
-	hmac: z.string(),
-	publicKey: z.string(),
-	encoding: z.enum(["utf8", "hex", "base64"]).optional(),
-});
-
-// Transaction input schema
-export const transactionInputSchema = z.object({
-	outpoint: z.string(),
-	inputDescription: z.string(), // Required field
-	sequence: z.number().optional(),
-});
-
-// Transaction output schema
-export const transactionOutputSchema = z.object({
-	lockingScript: z.string(),
-	satoshis: z.number(),
-	outputDescription: z.string(), // Required field
-	change: z.boolean().optional(),
-});
-
-// Create action args
-export const createActionArgsSchema = z.object({
-	description: z.string(),
-	labels: z.array(z.string()).optional(),
-	lockTime: z.number().optional(),
-	version: z.number().optional(),
-	inputBEEF: z.array(z.number()).optional(),
-	inputs: z.array(transactionInputSchema).optional(),
-	outputs: z.array(transactionOutputSchema).optional(),
-	options: z.record(z.union([z.string(), z.number(), z.boolean()])).optional(),
-});
-
-// Sign action args
-export const signActionArgsSchema = z.object({
-	reference: z.string(),
-	spends: z.record(z.any()).optional(),
-	options: z.record(z.union([z.string(), z.number(), z.boolean()])).optional(),
-});
-
-// List actions args
-export const listActionsArgsSchema = z.object({
-	labels: z.array(z.string()),
-	labelQueryMode: z.enum(["any", "all"]).optional(),
-	limit: z.number().optional(),
-	offset: z.number().optional(),
-	includeInputs: z.boolean().optional(),
-	includeOutputs: z.boolean().optional(),
-	includeLabels: z.boolean().optional(),
-	includeInputSourceLockingScripts: z.boolean().optional(),
-	includeInputUnlockingScripts: z.boolean().optional(),
-	seekPermission: z.boolean().optional(),
-});
-
-// List outputs args
-export const listOutputsArgsSchema = z.object({
-	basket: z.string(),
-	tags: z.array(z.string()).optional(),
-	tagQueryMode: z.enum(["all", "any"]).optional(),
-	limit: z.number().optional(),
-	offset: z.number().optional(),
-	include: z.enum(["locking scripts", "entire transactions"]).optional(),
-	includeLabels: z.boolean().optional(),
-	includeTags: z.boolean().optional(),
-	includeCustomInstructions: z.boolean().optional(),
-	seekPermission: z.boolean().optional(),
-});
-
-// Reveal counterparty key linkage args
-export const revealCounterpartyKeyLinkageArgsSchema = z.object({
-	counterparty: z.string(),
-	verifier: z.string(),
-	privileged: z.boolean().optional(),
-	privilegedReason: z.string().optional(),
-});
-
-// Reveal specific key linkage args
-export const revealSpecificKeyLinkageArgsSchema = z.object({
-	keyID: z.number(),
-	verifier: z.string(),
-	privileged: z.boolean().optional(),
-	privilegedReason: z.string().optional(),
-});
-
-// Abort action args
-export const abortActionArgsSchema = z.object({
-	reference: z.string(),
-});
-
-// Internalize action args
-export const internalizeActionArgsSchema = z.object({
-	tx: z.array(z.number()),
-	outputs: z.array(
-		z.object({
-			outputIndex: z.number(),
-			protocol: z.enum(["wallet payment", "basket insertion"]),
-			lockingScript: z.string(),
-			satoshis: z.number(),
-		}),
-	),
-	description: z.string(),
-	labels: z.array(z.string()).optional(),
-	seekPermission: z.boolean().optional(),
-});
-
-// Relinquish output args
-export const relinquishOutputArgsSchema = z.object({
-	basket: z.string(),
-	output: z.string(),
-});
-
-// Acquire certificate args
-export const acquireCertificateArgsSchema = z.object({
-	type: z.string(),
-	certifier: z.string(),
-	acquisitionProtocol: z.enum(["direct", "issuance"]),
-	fields: z.record(z.string()),
-	certifierUrl: z.string().optional(),
-	serialNumber: z.string().optional(),
-	signature: z.string().optional(),
-	revocationOutpoint: z.string().optional(),
-	keyringForSubject: z.record(z.string()).optional(),
-	keyringRevealer: z.string().optional(),
-	privileged: z.boolean().optional(),
-	privilegedReason: z.string().optional(),
-});
-
-// List certificates args
-export const listCertificatesArgsSchema = z.object({
-	certifiers: z.array(z.string()),
-	types: z.array(z.string()),
-	limit: z.number().optional(),
-	offset: z.number().optional(),
-	privileged: z.boolean().optional(),
-	privilegedReason: z.string().optional(),
-});
-
-// Prove certificate args
-export const proveCertificateArgsSchema = z.object({
-	certificate: z.object({}),
-	fieldsToReveal: z.array(z.string()),
-	verifier: z.string(),
-	privileged: z.boolean().optional(),
-	privilegedReason: z.string().optional(),
-});
-
-// Relinquish certificate args
-export const relinquishCertificateArgsSchema = z.object({
-	type: z.string(),
-	serialNumber: z.string(),
-	certifier: z.string(),
-});
-
-// Discover by identity key args
-export const discoverByIdentityKeyArgsSchema = z.object({
-	identityKey: z.string(),
-	limit: z.number().optional(),
-	offset: z.number().optional(),
-	seekPermission: z.boolean().optional(),
-});
-
-// Discover by attributes args
-export const discoverByAttributesArgsSchema = z.object({
-	attributes: z.record(z.string()),
-	limit: z.number().optional(),
-	offset: z.number().optional(),
-	seekPermission: z.boolean().optional(),
-});
-
-// Get header for height args
-export const getHeaderArgsSchema = z.object({
-	height: z.number(),
-});
+	.describe("Schema for encryption and decryption operations")
+	.superRefine((val, ctx) => {
+		if (val.mode === "encrypt" && !val.recipientPublicKeyHex) {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				message: "recipientPublicKeyHex is required when mode is 'encrypt'",
+				path: ["recipientPublicKeyHex"],
+			});
+		}
+	});
 
 // Get address args
 export const getAddressArgsSchema = z.object({});

package/tools/wallet/sendOrdinals.ts

@@ -1,19 +1,14 @@
 import { PrivateKey } 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 { sendOrdinals } from "js-1sat-ord";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import type {
 	ChangeResult,
 	LocalSigner,
 	SendOrdinalsConfig,
 } from "js-1sat-ord";
-import { Sigma } from "sigma-protocol";
+import { sendOrdinals } from "js-1sat-ord";
 import { z } from "zod";
+import { V5Broadcaster } from "../../utils/broadcaster";
 import type { Wallet } from "./wallet";
 
 /**
@@ -44,11 +39,8 @@ export function registerSendOrdinalsTool(server: McpServer, wallet: Wallet) {
 	server.tool(
 		"wallet_sendOrdinals",
 		"Transfers ordinals (NFTs) from your wallet to another address on the Bitcoin SV blockchain. This tool enables sending inscriptions you own to any valid BSV address. The transaction is created, signed, and broadcast automatically, with appropriate fee calculation and change handling.",
-		{ args: sendOrdinalsArgsSchema },
-		async (
-			{ args }: { args: SendOrdinalsArgs },
-			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
-		): Promise<CallToolResult> => {
+		{ ...sendOrdinalsArgsSchema.shape },
+		async ({ inscriptionOutpoint, destinationAddress, metadata }): Promise<CallToolResult> => {
 			try {
 				// 1. Get private key from wallet
 				const paymentPk = wallet.getPrivateKey();
@@ -68,7 +60,7 @@ export function registerSendOrdinalsTool(server: McpServer, wallet: Wallet) {
 				const walletAddress = paymentPk.toAddress().toString();
 
 				// 4. Parse the inscription outpoint
-				const [txid, voutStr] = args.inscriptionOutpoint.split("_");
+				const [txid, voutStr] = inscriptionOutpoint.split("_");
 				if (!txid || !voutStr) {
 					throw new Error(
 						"Invalid inscription outpoint format. Expected txid_vout",
@@ -83,7 +75,7 @@ export function registerSendOrdinalsTool(server: McpServer, wallet: Wallet) {
 
 				if (!inscription) {
 					throw new Error(
-						`Inscription ${args.inscriptionOutpoint} not found in your wallet`,
+						`Inscription ${inscriptionOutpoint} not found in your wallet`,
 					);
 				}
 
@@ -92,7 +84,7 @@ export function registerSendOrdinalsTool(server: McpServer, wallet: Wallet) {
 					paymentPk,
 					paymentUtxos,
 					ordinals: [inscription],
-					destinations: [{ address: args.destinationAddress }],
+					destinations: [{ address: destinationAddress }],
 					changeAddress: walletAddress,
 				};
 
@@ -107,8 +99,8 @@ export function registerSendOrdinalsTool(server: McpServer, wallet: Wallet) {
 				}
 
 				// Add metadata if provided
-				if (args.metadata) {
-					sendOrdinalsConfig.metaData = args.metadata;
+				if (metadata) {
+					sendOrdinalsConfig.metaData = metadata;
 				}
 
 				// Using the wallet's key for both payment and ordinals
@@ -121,7 +113,8 @@ export function registerSendOrdinalsTool(server: McpServer, wallet: Wallet) {
 				// 7. Broadcast the transaction
 				const disableBroadcasting = process.env.DISABLE_BROADCASTING === "true";
 				if (!disableBroadcasting) {
-					await changeResult.tx.broadcast();
+					const broadcaster = new V5Broadcaster();
+					await changeResult.tx.broadcast(broadcaster);
 
 					// 8. Refresh the wallet's UTXOs after spending
 					try {
@@ -142,8 +135,8 @@ export function registerSendOrdinalsTool(server: McpServer, wallet: Wallet) {
 									txid: changeResult.tx.id("hex"),
 									spentOutpoints: changeResult.spentOutpoints,
 									payChange: changeResult.payChange,
-									inscriptionOutpoint: args.inscriptionOutpoint,
-									destinationAddress: args.destinationAddress,
+									inscriptionOutpoint: inscriptionOutpoint,
+									destinationAddress: destinationAddress,
 								}),
 							},
 						],

package/tools/wallet/sendToAddress.ts

@@ -1,15 +1,10 @@
 import { P2PKH } from "@bsv/sdk";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
 import { toSatoshi } from "satoshi-token";
-import type { z } from "zod";
 import { getBsvPriceWithCache } from "../bsv/getPrice";
 import { sendToAddressArgsSchema } from "./schemas";
 import type { Wallet } from "./wallet";
 
-// Use the schema imported from schemas.ts
-export type SendToAddressArgs = z.infer<typeof sendToAddressArgsSchema>;
-
 /**
  * Register the sendToAddress tool
  */
@@ -17,20 +12,9 @@ export function registerSendToAddressTool(server: McpServer, wallet: Wallet) {
 	server.tool(
 		"wallet_sendToAddress",
 		"Sends Bitcoin SV (BSV) to a specified address. This tool supports payments in both BSV and USD amounts (with automatic conversion using current exchange rates). Transaction fees are automatically calculated and a confirmation with transaction ID is returned upon success.",
-		{
-			args: sendToAddressArgsSchema,
-		},
-		async (
-			{ args }: { args: SendToAddressArgs },
-			extra: RequestHandlerExtra,
-		) => {
+		{ ...sendToAddressArgsSchema.shape },
+		async ({ address, amount, currency = "BSV", description = "Send to address" }) => {
 			try {
-				const {
-					address,
-					amount,
-					currency = "BSV",
-					description = "Send to address",
-				} = args;
 
 				// Convert to satoshis
 				let satoshis: number;

package/tools/wallet/setupDroplet.ts

@@ -0,0 +1,161 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import type { IntegratedWallet } from "./integratedWallet";
+
+const setupDropletArgsSchema = z.object({
+	action: z.enum(["register_key", "create_faucet", "check_status"]),
+	faucetName: z.string().optional(),
+	fixedDropSats: z.number().optional(),
+});
+
+export type SetupDropletArgs = z.infer<typeof setupDropletArgsSchema>;
+
+/**
+ * Register the setupDroplet tool for Droplet API initialization
+ */
+export function registerSetupDropletTool(
+	server: McpServer,
+	integratedWallet: IntegratedWallet,
+) {
+	server.tool(
+		"wallet_setupDroplet",
+		"Setup and manage Droplet API integration. Actions: register_key (registers your public key), create_faucet (creates a new faucet), check_status (checks faucet status)",
+		{ ...setupDropletArgsSchema.shape },
+		async ({ action, faucetName, fixedDropSats }) => {
+			try {
+				const dropletClient = integratedWallet.getDropletClient();
+				if (!dropletClient) {
+					throw new Error("Droplet client not configured");
+				}
+
+				const config = dropletClient.getConfig();
+				const apiUrl = config.apiUrl;
+				const authKey = config.authKey;
+
+				switch (action) {
+					case "register_key": {
+						if (!authKey) {
+							throw new Error("No auth key configured");
+						}
+
+						const pubkey = authKey.toPublicKey().toString();
+
+						// Register the key with the Droplet API
+						const response = await fetch(`${apiUrl}/auth/register`, {
+							method: "POST",
+							headers: {
+								"Content-Type": "application/json",
+							},
+							body: JSON.stringify({ publicKey: pubkey }),
+						});
+
+						if (!response.ok) {
+							const error = await response.text();
+							throw new Error(`Failed to register key: ${error}`);
+						}
+
+						return {
+							content: [
+								{
+									type: "text",
+									text: JSON.stringify({
+										status: "success",
+										message: "Key registered successfully",
+										publicKey: pubkey,
+									}),
+								},
+							],
+						};
+					}
+
+					case "create_faucet": {
+						if (!faucetName) {
+							throw new Error(
+								"faucetName is required for create_faucet action",
+							);
+						}
+
+						// First, ensure the key is registered
+						if (authKey) {
+							const pubkey = authKey.toPublicKey().toString();
+							await fetch(`${apiUrl}/auth/register`, {
+								method: "POST",
+								headers: {
+									"Content-Type": "application/json",
+								},
+								body: JSON.stringify({ publicKey: pubkey }),
+							});
+						}
+
+						// Create the faucet
+						const body = {
+							name: faucetName,
+							fixed_drop_sats: fixedDropSats || 1000,
+							max_consolidation_inputs: 20,
+						};
+
+						const headers = authKey
+							? await dropletClient.getAuthHeaders("POST", "/faucets", body)
+							: {};
+
+						const response = await fetch(`${apiUrl}/faucets`, {
+							method: "POST",
+							headers: {
+								"Content-Type": "application/json",
+								...headers,
+							},
+							body: JSON.stringify(body),
+						});
+
+						if (!response.ok) {
+							const error = await response.text();
+							throw new Error(`Failed to create faucet: ${error}`);
+						}
+
+						const result = await response.json();
+						return {
+							content: [
+								{
+									type: "text",
+									text: JSON.stringify({
+										status: "success",
+										message: "Faucet created successfully",
+										faucet: result,
+									}),
+								},
+							],
+						};
+					}
+
+					case "check_status": {
+						const status = await dropletClient.getFaucetStatus();
+						return {
+							content: [
+								{
+									type: "text",
+									text: JSON.stringify({
+										status: "success",
+										faucetStatus: status,
+									}),
+								},
+							],
+						};
+					}
+
+					default:
+						throw new Error(`Unknown action: ${action}`);
+				}
+			} catch (error) {
+				return {
+					content: [
+						{
+							type: "text",
+							text: error instanceof Error ? error.message : String(error),
+						},
+					],
+					isError: true,
+				};
+			}
+		},
+	);
+}