bsv-mcp 0.2.14 → 0.3.0

package/tools/wallet/transferOrdToken.ts

@@ -1,31 +1,21 @@
-import type { OneSatContext } from '@1sat/actions'
-import { sendBsv21, transferOrdinals } from '@1sat/actions'
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import { z } from 'zod'
-
-const walletOutputSchema = z.object({
-	outpoint: z.string(),
-	satoshis: z.number().optional(),
-	tags: z.array(z.string()).optional(),
-	customInstructions: z.string().optional(),
-	lockingScript: z.string().optional(),
-})
+import type { OneSatContext } from "@1sat/actions";
+import { sendBsv21, sendOrdinals } from "@1sat/actions";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { assertBroadcastAllowed } from "../../utils/broadcastGuard";
 
 export const transferOrdTokenArgsSchema = z.object({
-	type: z.enum(['ordinal', 'bsv21']).describe(
-		"'ordinal' to transfer an inscription/NFT, 'bsv21' to send fungible BSV21 tokens",
-	),
-	// ordinal fields
-	ordinal: walletOutputSchema
-		.optional()
+	type: z
+		.enum(["ordinal", "bsv21"])
 		.describe(
-			"WalletOutput of the ordinal to transfer (from wallet_getOrdinals). Required when type='ordinal'",
+			"'ordinal' to transfer an inscription/NFT, 'bsv21' to send fungible BSV21 tokens",
 		),
-	inputBEEF: z
-		.array(z.number())
+	// ordinal fields
+	id: z
+		.string()
 		.optional()
 		.describe(
-			"BEEF bytes from listOutputs (include: 'entire transactions'). Required when type='ordinal'",
+			"Tracking id of the ordinal in the ordinals basket (the 'id:' tag from wallet_getOrdinals). Required when type='ordinal'",
 		),
 	// bsv21 fields
 	tokenId: z
@@ -35,130 +25,128 @@ export const transferOrdTokenArgsSchema = z.object({
 	amount: z
 		.string()
 		.optional()
-		.describe("Amount of tokens to send as a string integer. Required when type='bsv21'"),
+		.describe(
+			"Amount of tokens to send as a string integer. Required when type='bsv21'",
+		),
 	// shared destination fields
-	address: z.string().optional().describe('Recipient P2PKH address'),
+	address: z.string().optional().describe("Recipient P2PKH address"),
 	counterparty: z
 		.string()
 		.optional()
-		.describe('Recipient identity public key (hex)'),
-})
+		.describe("Recipient identity public key (hex)"),
+});
 
-export type TransferOrdTokenArgs = z.infer<typeof transferOrdTokenArgsSchema>
+export type TransferOrdTokenArgs = z.infer<typeof transferOrdTokenArgsSchema>;
 
 export function registerTransferOrdTokenTool(
 	server: McpServer,
 	ctx: OneSatContext | undefined,
 ) {
 	server.tool(
-		'wallet_transferOrdToken',
-		"Transfer an ordinal inscription or send BSV21 fungible tokens. Use type='ordinal' to transfer an NFT/inscription (requires the WalletOutput from wallet_getOrdinals and the BEEF). Use type='bsv21' to send fungible tokens by token ID and amount.",
+		"wallet_transferOrdToken",
+		"Transfer an ordinal inscription or send BSV21 fungible tokens. Use type='ordinal' to transfer an NFT/inscription by its ordinals-basket tracking id (from wallet_getOrdinals). Use type='bsv21' to send fungible tokens by token ID and amount.",
 		{ ...transferOrdTokenArgsSchema.shape },
-		async ({ type, ordinal, inputBEEF, tokenId, amount, address, counterparty }) => {
+		async ({ type, id, tokenId, amount, address, counterparty }) => {
 			if (!ctx) {
 				return {
 					content: [
 						{
-							type: 'text',
-							text: 'Wallet not initialized. Please configure a wallet before transferring.',
+							type: "text",
+							text: "Wallet not initialized. Please configure a wallet before transferring.",
 						},
 					],
 					isError: true,
-				}
+				};
 			}
 
 			try {
-				if (type === 'ordinal') {
-					if (!ordinal) {
-						return {
-							content: [{ type: 'text', text: "ordinal is required when type='ordinal'" }],
-							isError: true,
-						}
-					}
-					if (!inputBEEF) {
-						return {
-							content: [{ type: 'text', text: "inputBEEF is required when type='ordinal'" }],
-							isError: true,
-						}
-					}
-					if (!address && !counterparty) {
+				assertBroadcastAllowed("wallet_transferOrdToken");
+				if (!address && !counterparty) {
+					return {
+						content: [
+							{ type: "text", text: "address or counterparty is required" },
+						],
+						isError: true,
+					};
+				}
+
+				if (type === "ordinal") {
+					if (!id) {
 						return {
-							content: [{ type: 'text', text: 'address or counterparty is required' }],
+							content: [
+								{
+									type: "text",
+									text: "id is required when type='ordinal'",
+								},
+							],
 							isError: true,
-						}
+						};
 					}
 
-					const result = await transferOrdinals.execute(ctx, {
-						transfers: [
-							{
-								ordinal: ordinal as Parameters<typeof transferOrdinals.execute>[1]['transfers'][0]['ordinal'],
-								address,
-								counterparty,
-							},
-						],
-						inputBEEF,
-					})
+					const result = await sendOrdinals.execute(ctx, {
+						transfers: [{ id, address, counterparty }],
+					});
 
 					if (result.error) {
 						return {
-							content: [{ type: 'text', text: result.error }],
+							content: [{ type: "text", text: result.error }],
 							isError: true,
-						}
+						};
 					}
 
 					return {
-						content: [{ type: 'text', text: JSON.stringify({ txid: result.txid }) }],
-					}
+						content: [
+							{ type: "text", text: JSON.stringify({ txid: result.txid }) },
+						],
+					};
 				}
 
 				// bsv21
 				if (!tokenId) {
 					return {
-						content: [{ type: 'text', text: "tokenId is required when type='bsv21'" }],
+						content: [
+							{ type: "text", text: "tokenId is required when type='bsv21'" },
+						],
 						isError: true,
-					}
+					};
 				}
 				if (!amount) {
 					return {
-						content: [{ type: 'text', text: "amount is required when type='bsv21'" }],
-						isError: true,
-					}
-				}
-				if (!address && !counterparty) {
-					return {
-						content: [{ type: 'text', text: 'address or counterparty is required' }],
+						content: [
+							{ type: "text", text: "amount is required when type='bsv21'" },
+						],
 						isError: true,
-					}
+					};
 				}
 
 				const result = await sendBsv21.execute(ctx, {
 					tokenId,
-					amount,
-					address,
-					counterparty,
-				})
+					recipients: [{ amount, destination: { address, counterparty } }],
+				});
 
 				if (result.error) {
 					return {
-						content: [{ type: 'text', text: result.error }],
+						content: [{ type: "text", text: result.error }],
 						isError: true,
-					}
+					};
 				}
 
 				return {
-					content: [{ type: 'text', text: JSON.stringify({ txid: result.txid }) }],
-				}
+					content: [
+						{ type: "text", text: JSON.stringify({ txid: result.txid }) },
+					],
+				};
 			} catch (err: unknown) {
 				return {
 					content: [
 						{
-							type: 'text',
+							type: "text",
 							text: err instanceof Error ? err.message : String(err),
 						},
 					],
 					isError: true,
-				}
+				};
 			}
 		},
-	)
+	);
 }

package/tools/wallet/unlockBsv.ts

@@ -1,57 +1,63 @@
-import type { OneSatContext } from '@1sat/actions'
-import { unlockBsv } from '@1sat/actions'
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { OneSatContext } from "@1sat/actions";
+import { unlockBsv } from "@1sat/actions";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { assertBroadcastAllowed } from "../../utils/broadcastGuard";
 
 export function registerUnlockBsvTool(
 	server: McpServer,
 	ctx: OneSatContext | undefined,
 ) {
 	server.tool(
-		'wallet_unlockBsv',
-		'Unlock all matured time-locked BSV',
+		"wallet_unlockBsv",
+		"Unlock all matured time-locked BSV",
 		{},
 		async () => {
 			if (!ctx) {
 				return {
 					content: [
 						{
-							type: 'text',
-							text: 'Wallet not initialized. Please configure a wallet before unlocking.',
+							type: "text",
+							text: "Wallet not initialized. Please configure a wallet before unlocking.",
 						},
 					],
 					isError: true,
-				}
+				};
 			}
 
 			try {
-				const result = await unlockBsv.execute(ctx, {})
+				assertBroadcastAllowed("wallet_unlockBsv");
+				const result = await unlockBsv.execute(ctx, {});
 
 				if (result.error) {
 					return {
-						content: [{ type: 'text', text: result.error }],
+						content: [{ type: "text", text: result.error }],
 						isError: true,
-					}
+					};
 				}
 
 				return {
 					content: [
 						{
-							type: 'text',
-							text: JSON.stringify(result, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2),
+							type: "text",
+							text: JSON.stringify(
+								result,
+								(_, v) => (typeof v === "bigint" ? v.toString() : v),
+								2,
+							),
 						},
 					],
-				}
+				};
 			} catch (err: unknown) {
 				return {
 					content: [
 						{
-							type: 'text',
+							type: "text",
 							text: err instanceof Error ? err.message : String(err),
 						},
 					],
 					isError: true,
-				}
+				};
 			}
 		},
-	)
+	);
 }

package/tools/wallet/utxo.ts

@@ -1,4 +1,5 @@
 import { Transaction } from "@bsv/sdk";
+import { arrayBufferToUint8Array } from "../../utils/buffer";
 
 export async function getTransactionById(
 	txid: string,

package/tools/wallet/wallet.ts

@@ -8,7 +8,6 @@
 
 import type { GetPublicKeyArgs, GetPublicKeyResult, PubKeyHex } from "@bsv/sdk";
 import {
-	Beef,
 	type BroadcastFailure,
 	type BroadcastResponse,
 	fromUtxo,
@@ -16,7 +15,6 @@ import {
 	isBroadcastResponse,
 	P2PKH,
 	PrivateKey,
-	type PublicKey,
 	SatoshisPerKilobyte,
 	Script,
 	Transaction,
@@ -26,16 +24,6 @@ import { fetchNftUtxos, type NftUtxo, type Utxo } from "js-1sat-ord";
 import { V5Broadcaster } from "../../utils/broadcaster";
 import { fetchPaymentUtxosFromV5 } from "./fetchPaymentUtxos";
 
-// Local interface for what encrypt/decrypt expect, will be mapped from Zod schema
-interface InternalEncryptionArgs {
-	data: number[];
-	recipientPublicKey?: PublicKey; // For encryption
-}
-
-interface InternalDecryptionArgs {
-	data: number[];
-}
-
 export class Wallet {
 	private paymentUtxos: Utxo[] = [];
 	private nftUtxos: NftUtxo[] = [];
@@ -146,7 +134,7 @@ export class Wallet {
 		return this.getPaymentKey()?.toAddress();
 	}
 
-	async getPublicKey(args?: GetPublicKeyArgs): Promise<GetPublicKeyResult> {
+	async getPublicKey(_args?: GetPublicKeyArgs): Promise<GetPublicKeyResult> {
 		const currentPaymentKey = this.getPaymentKey();
 		if (!currentPaymentKey) {
 			throw new Error("No payment key available to derive public key.");

package/tools/wallet/sendToAddress.ts

@@ -1,74 +0,0 @@
-import type { OneSatContext } from '@1sat/actions'
-import { sendBsv } from '@1sat/actions'
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import { toSatoshi } from 'satoshi-token'
-import { getBsvPriceWithCache } from '../bsv/getPrice'
-import { sendToAddressArgsSchema } from './schemas'
-
-export function registerSendToAddressTool(
-	server: McpServer,
-	ctx: OneSatContext | undefined,
-) {
-	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.',
-		{ ...sendToAddressArgsSchema.shape },
-		async ({ address, amount, currency = 'BSV', description = 'Send to address' }) => {
-			if (!ctx) {
-				return {
-					content: [
-						{
-							type: 'text',
-							text: 'Wallet not initialized. Please configure a wallet before sending.',
-						},
-					],
-					isError: true,
-				}
-			}
-
-			try {
-				let satoshis: number
-				if (currency === 'USD') {
-					const bsvPriceUsd = await getBsvPriceWithCache()
-					satoshis = toSatoshi(amount / bsvPriceUsd)
-				} else {
-					satoshis = toSatoshi(amount)
-				}
-
-				const result = await sendBsv.execute(ctx, {
-					requests: [{ address, satoshis }],
-				})
-
-				if (result.error) {
-					return {
-						content: [{ type: 'text', text: result.error }],
-						isError: true,
-					}
-				}
-
-				return {
-					content: [
-						{
-							type: 'text',
-							text: JSON.stringify({
-								status: 'success',
-								txid: result.txid,
-								satoshis,
-							}),
-						},
-					],
-				}
-			} catch (error) {
-				return {
-					content: [
-						{
-							type: 'text',
-							text: error instanceof Error ? error.message : String(error),
-						},
-					],
-					isError: true,
-				}
-			}
-		},
-	)
-}

package/tools/wallet/setupDroplet.ts

@@ -1,161 +0,0 @@
-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,
-				};
-			}
-		},
-	);
-}