bsv-mcp 0.0.35 → 0.2.0

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

@@ -6,14 +6,15 @@ import type {
 	ServerNotification,
 	ServerRequest,
 } from "@modelcontextprotocol/sdk/types.js";
-import { sendOrdinals } from "js-1sat-ord";
 import type {
 	ChangeResult,
 	LocalSigner,
 	SendOrdinalsConfig,
 } from "js-1sat-ord";
+import { OneSatBroadcaster, sendOrdinals } from "js-1sat-ord";
 import { Sigma } from "sigma-protocol";
 import { z } from "zod";
+import { V5Broadcaster } from "../../utils/broadcaster";
 import type { Wallet } from "./wallet";
 
 /**
@@ -121,7 +122,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 {

package/tools/wallet/sendToAddress.ts

@@ -1,6 +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 type {
+	ServerNotification,
+	ServerRequest,
+} from "@modelcontextprotocol/sdk/types.js";
 import { toSatoshi } from "satoshi-token";
 import type { z } from "zod";
 import { getBsvPriceWithCache } from "../bsv/getPrice";
@@ -22,7 +26,7 @@ export function registerSendToAddressTool(server: McpServer, wallet: Wallet) {
 		},
 		async (
 			{ args }: { args: SendToAddressArgs },
-			extra: RequestHandlerExtra,
+			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
 		) => {
 			try {
 				const {

package/tools/wallet/setupDroplet.ts

@@ -0,0 +1,172 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import type {
+	ServerNotification,
+	ServerRequest,
+} from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { DropletClient } from "../../utils/droplet";
+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)",
+		{
+			args: setupDropletArgsSchema,
+		},
+		async (
+			{ args }: { args: SetupDropletArgs },
+			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
+		) => {
+			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 (args.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 (!args.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: args.faucetName,
+							fixed_drop_sats: args.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: ${args.action}`);
+				}
+			} catch (error) {
+				return {
+					content: [
+						{
+							type: "text",
+							text: error instanceof Error ? error.message : String(error),
+						},
+					],
+					isError: true,
+				};
+			}
+		},
+	);
+}