bsv-mcp 0.2.9 → 0.2.11

package/tools/wallet/sendAllBsv.ts

@@ -0,0 +1,64 @@
+import type { OneSatContext } from '@1sat/actions'
+import { sendAllBsv } from '@1sat/actions'
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { z } from 'zod'
+
+const sendAllBsvArgsSchema = z.object({
+	destination: z
+		.string()
+		.describe('Destination P2PKH address to send all funds to'),
+})
+
+export function registerSendAllBsvTool(
+	server: McpServer,
+	ctx: OneSatContext | undefined,
+) {
+	server.tool(
+		'wallet_sendAllBsv',
+		'Send all BSV in the wallet to a single recipient',
+		{ ...sendAllBsvArgsSchema.shape },
+		async ({ destination }) => {
+			if (!ctx) {
+				return {
+					content: [
+						{
+							type: 'text',
+							text: 'Wallet not initialized. Please configure a wallet before sending.',
+						},
+					],
+					isError: true,
+				}
+			}
+
+			try {
+				const result = await sendAllBsv.execute(ctx, { destination })
+
+				if (result.error) {
+					return {
+						content: [{ type: 'text', text: result.error }],
+						isError: true,
+					}
+				}
+
+				return {
+					content: [
+						{
+							type: 'text',
+							text: JSON.stringify(result, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2),
+						},
+					],
+				}
+			} catch (err: unknown) {
+				return {
+					content: [
+						{
+							type: 'text',
+							text: err instanceof Error ? err.message : String(err),
+						},
+					],
+					isError: true,
+				}
+			}
+		},
+	)
+}

package/tools/wallet/sendToAddress.ts

@@ -1,75 +1,74 @@
-import { P2PKH } from "@bsv/sdk";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { toSatoshi } from "satoshi-token";
-import { getBsvPriceWithCache } from "../bsv/getPrice";
-import { sendToAddressArgsSchema } from "./schemas";
-import type { Wallet } from "./wallet";
+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'
 
-/**
- * Register the sendToAddress tool
- */
-export function registerSendToAddressTool(server: McpServer, wallet: Wallet) {
+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.",
+		'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" }) => {
-			try {
-
-				// Convert to satoshis
-				let satoshis: number;
-				if (currency === "USD") {
-					// Get current BSV price
-					const bsvPriceUsd = await getBsvPriceWithCache();
-
-					// Convert USD to BSV
-					const bsvAmount = amount / bsvPriceUsd;
+		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,
+				}
+			}
 
-					// Convert BSV to satoshis using the library
-					satoshis = toSatoshi(bsvAmount);
+			try {
+				let satoshis: number
+				if (currency === 'USD') {
+					const bsvPriceUsd = await getBsvPriceWithCache()
+					satoshis = toSatoshi(amount / bsvPriceUsd)
 				} else {
-					// Convert BSV to satoshis using the library
-					satoshis = toSatoshi(amount);
+					satoshis = toSatoshi(amount)
 				}
 
-				// Create P2PKH script from address
-				const lockingScript = new P2PKH().lock(address);
+				const result = await sendBsv.execute(ctx, {
+					requests: [{ address, satoshis }],
+				})
 
-				// Create the transaction
-				const tx = await wallet.createAction({
-					description,
-					outputs: [
-						{
-							lockingScript: lockingScript.toHex(),
-							satoshis,
-							outputDescription: `Payment to ${address}`,
-						},
-					],
-				});
+				if (result.error) {
+					return {
+						content: [{ type: 'text', text: result.error }],
+						isError: true,
+					}
+				}
 
 				return {
 					content: [
 						{
-							type: "text",
+							type: 'text',
 							text: JSON.stringify({
-								status: "success",
-								txid: tx.txid,
+								status: 'success',
+								txid: result.txid,
 								satoshis,
 							}),
 						},
 					],
-				};
+				}
 			} catch (error) {
 				return {
 					content: [
 						{
-							type: "text",
+							type: 'text',
 							text: error instanceof Error ? error.message : String(error),
 						},
 					],
 					isError: true,
-				};
+				}
 			}
 		},
-	);
+	)
 }

package/tools/wallet/signBsm.ts

@@ -0,0 +1,29 @@
+import { signBsm, type OneSatContext } from '@1sat/actions'
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { z } from 'zod'
+
+export function registerSignBsmTool(
+	server: McpServer,
+	ctx?: OneSatContext,
+) {
+	server.tool(
+		'wallet_signBsm',
+		'Sign a message using BSM (Bitcoin Signed Message) format',
+		{
+			message: z.string().describe('The message to sign'),
+			encoding: z.enum(['utf8', 'hex', 'base64']).optional().describe('Message encoding format'),
+		},
+		async (params) => {
+			try {
+				if (!ctx) throw new Error('BRC-100 wallet context not available')
+				const result = await signBsm.execute(ctx, params)
+				return {
+					content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+				}
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err)
+				return { content: [{ type: 'text', text: msg }], isError: true }
+			}
+		},
+	)
+}

package/tools/wallet/sweepBsv.ts

@@ -0,0 +1,70 @@
+import type { OneSatContext } from '@1sat/actions'
+import { sweepBsv } from '@1sat/actions'
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { z } from 'zod'
+
+const sweepInputSchema = z.object({
+	outpoint: z.string().describe('Outpoint (txid_vout)'),
+	satoshis: z.number().int().describe('Satoshis in output'),
+	lockingScript: z.string().describe('Locking script hex'),
+})
+
+const sweepBsvSchema = z.object({
+	inputs: z.array(sweepInputSchema).describe('UTXOs to sweep (use prepareSweepInputs to build these)'),
+	wif: z.string().describe('WIF private key controlling the inputs'),
+	amount: z.number().int().optional().describe('Amount to sweep (satoshis). If omitted, sweeps all input value.'),
+})
+
+export function registerSweepBsvTool(
+	server: McpServer,
+	ctx: OneSatContext | undefined,
+) {
+	server.tool(
+		'wallet_sweepBsv',
+		'Sweep BSV from an external WIF private key into the wallet',
+		{ ...sweepBsvSchema.shape },
+		async ({ inputs, wif, amount }) => {
+			if (!ctx) {
+				return {
+					content: [
+						{
+							type: 'text' as const,
+							text: 'BRC-100 wallet context not available',
+						},
+					],
+					isError: true,
+				}
+			}
+
+			try {
+				const result = await sweepBsv.execute(ctx, { inputs, wif, amount })
+
+				if (result.error) {
+					return {
+						content: [{ type: 'text' as const, text: result.error }],
+						isError: true,
+					}
+				}
+
+				return {
+					content: [
+						{
+							type: 'text' as const,
+							text: JSON.stringify(result, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2),
+						},
+					],
+				}
+			} catch (error) {
+				return {
+					content: [
+						{
+							type: 'text' as const,
+							text: error instanceof Error ? error.message : String(error),
+						},
+					],
+					isError: true,
+				}
+			}
+		},
+	)
+}

package/tools/wallet/sweepBsv21.ts

@@ -0,0 +1,71 @@
+import type { OneSatContext } from '@1sat/actions'
+import { sweepBsv21 } from '@1sat/actions'
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { z } from 'zod'
+
+const sweepBsv21InputSchema = z.object({
+	outpoint: z.string().describe('Outpoint (txid_vout)'),
+	satoshis: z.number().int().describe('Satoshis (should be 1)'),
+	lockingScript: z.string().describe('Locking script hex'),
+	tokenId: z.string().describe('Token ID (txid_vout format)'),
+	amount: z.string().describe('Token amount as string'),
+})
+
+const sweepBsv21Schema = z.object({
+	inputs: z.array(sweepBsv21InputSchema).describe('Token UTXOs to sweep (must all be same tokenId)'),
+	wif: z.string().describe('WIF private key controlling the inputs'),
+})
+
+export function registerSweepBsv21Tool(
+	server: McpServer,
+	ctx: OneSatContext | undefined,
+) {
+	server.tool(
+		'wallet_sweepBsv21',
+		'Sweep BSV21 tokens from an external WIF private key into the wallet',
+		{ ...sweepBsv21Schema.shape },
+		async ({ inputs, wif }) => {
+			if (!ctx) {
+				return {
+					content: [
+						{
+							type: 'text' as const,
+							text: 'BRC-100 wallet context not available',
+						},
+					],
+					isError: true,
+				}
+			}
+
+			try {
+				const result = await sweepBsv21.execute(ctx, { inputs, wif })
+
+				if (result.error) {
+					return {
+						content: [{ type: 'text' as const, text: result.error }],
+						isError: true,
+					}
+				}
+
+				return {
+					content: [
+						{
+							type: 'text' as const,
+							text: JSON.stringify(result, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2),
+						},
+					],
+				}
+			} catch (error) {
+				return {
+					content: [
+						{
+							type: 'text' as const,
+							text: error instanceof Error ? error.message : String(error),
+						},
+					],
+					isError: true,
+				}
+			}
+		},
+	)
+}

package/tools/wallet/sweepOrdinals.ts

@@ -0,0 +1,69 @@
+import type { OneSatContext } from '@1sat/actions'
+import { sweepOrdinals } from '@1sat/actions'
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { z } from 'zod'
+
+const sweepInputSchema = z.object({
+	outpoint: z.string().describe('Outpoint (txid_vout)'),
+	satoshis: z.number().int().describe('Satoshis (should be 1)'),
+	lockingScript: z.string().describe('Locking script hex'),
+})
+
+const sweepOrdinalsSchema = z.object({
+	inputs: z.array(sweepInputSchema).describe('Ordinal UTXOs to sweep'),
+	wif: z.string().describe('WIF private key controlling the inputs'),
+})
+
+export function registerSweepOrdinalsTool(
+	server: McpServer,
+	ctx: OneSatContext | undefined,
+) {
+	server.tool(
+		'wallet_sweepOrdinals',
+		'Sweep ordinals from an external WIF private key into the wallet',
+		{ ...sweepOrdinalsSchema.shape },
+		async ({ inputs, wif }) => {
+			if (!ctx) {
+				return {
+					content: [
+						{
+							type: 'text' as const,
+							text: 'BRC-100 wallet context not available',
+						},
+					],
+					isError: true,
+				}
+			}
+
+			try {
+				const result = await sweepOrdinals.execute(ctx, { inputs, wif })
+
+				if (result.error) {
+					return {
+						content: [{ type: 'text' as const, text: result.error }],
+						isError: true,
+					}
+				}
+
+				return {
+					content: [
+						{
+							type: 'text' as const,
+							text: JSON.stringify(result, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2),
+						},
+					],
+				}
+			} catch (error) {
+				return {
+					content: [
+						{
+							type: 'text' as const,
+							text: error instanceof Error ? error.message : String(error),
+						},
+					],
+					isError: true,
+				}
+			}
+		},
+	)
+}

package/tools/wallet/tools.ts

@@ -1,17 +1,32 @@
-import { type PrivateKey, Utils } from "@bsv/sdk";
+import type { OneSatContext } from "@1sat/actions";
+import type { PrivateKey } from "@bsv/sdk";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { registerA2bPublishMcpTool } from "./a2bPublishMcp";
+import { registerBrc100Tools } from "./brc100";
 import { registerCreateOrdinalsTool } from "./createOrdinals";
 import { registerGatherCollectionInfoTool } from "./gatherCollectionInfo";
 import { registerGetAddressTool } from "./getAddress";
 import { registerWalletGetBalanceTool } from "./getBalance";
-import { registerGetPublicKeyTool } from "./getPublicKey";
+import { registerGetBsv21BalancesTool } from "./getBsv21Balances";
+import { registerGetLockDataTool } from "./getLockData";
+import { registerGetOrdinalsTool } from "./getOrdinals";
+import { registerListTokensTool } from "./listTokens";
 import { registerMintCollectionTool } from "./mintCollection";
 import { registerPurchaseListingTool } from "./purchaseListing";
 import { registerRefreshUtxosTool } from "./refreshUtxos";
-import { walletEncryptionArgsSchema } from "./schemas";
 import { registerSendToAddressTool } from "./sendToAddress";
+import { registerSignBsmTool } from "./signBsm";
 import { registerTransferOrdTokenTool } from "./transferOrdToken";
+import { registerListOrdinalTool } from "./listOrdinal";
+import { registerCancelListingTool } from "./cancelListing";
+import { registerSendAllBsvTool } from "./sendAllBsv";
+import { registerLockBsvTool } from "./lockBsv";
+import { registerUnlockBsvTool } from "./unlockBsv";
+import { registerOpnsRegisterTool } from "./opnsRegister";
+import { registerOpnsDeregisterTool } from "./opnsDeregister";
+import { registerSweepBsvTool } from "./sweepBsv";
+import { registerSweepOrdinalsTool } from "./sweepOrdinals";
+import { registerSweepBsv21Tool } from "./sweepBsv21";
 import type { Wallet } from "./wallet";
 
 export function registerWalletTools(
@@ -21,28 +36,29 @@ export function registerWalletTools(
 		disableBroadcasting: boolean;
 		enableA2bTools: boolean;
 		identityPk?: PrivateKey;
+		ctx?: OneSatContext;
 	},
 ): void {
 	// Register the wallet_sendToAddress tool
-	registerSendToAddressTool(server, wallet);
+	registerSendToAddressTool(server, config.ctx);
 
 	// Register the wallet_getAddress tool
-	registerGetAddressTool(server, wallet);
-
-	// Register the wallet_getPublicKey tool
-	registerGetPublicKeyTool(server, wallet);
+	registerGetAddressTool(server, config.ctx);
 
 	// Register the wallet_purchaseListing tool
-	registerPurchaseListingTool(server, wallet);
+	registerPurchaseListingTool(server, config.ctx);
 
 	// Register the wallet_transferOrdToken tool
-	registerTransferOrdTokenTool(server, wallet);
+	registerTransferOrdTokenTool(server, config.ctx);
 
 	// Register the wallet_refreshUtxos tool
-	registerRefreshUtxosTool(server, wallet);
+	registerRefreshUtxosTool(server, config.ctx);
 
 	// Register the wallet_getBalance tool
-	registerWalletGetBalanceTool(server, wallet);
+	registerWalletGetBalanceTool(server, config.ctx);
+
+	// Register full BRC-100 wallet interface
+	registerBrc100Tools(server, config.ctx);
 
 	// A2B tools have to be explicitly enabled
 	if (config.enableA2bTools) {
@@ -52,86 +68,32 @@ export function registerWalletTools(
 		});
 	}
 
-	// Register combined wallet_encryption tool
-	server.tool(
-		"wallet_encryption",
-		"Combined tool for encrypting and decrypting data using the wallet's cryptographic keys.\n\n" +
-			"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" +
-			"- 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' +
-			'     "encoding": "utf8",\n' +
-			'     "recipientPublicKeyHex": "020202020202020202020202020202020202020202020202020202020202020202"\n' +
-			"   }\n\n" +
-			"2. Decrypt previously encrypted data:\n" +
-			"   {\n" +
-			'     "mode": "decrypt",\n' +
-			'     "data": [encrypted bytes from previous response]\n' +
-			"   }",
-		{ ...walletEncryptionArgsSchema.shape },
-		async ({ mode, data, encoding, recipientPublicKeyHex }) => {
-			try {
-
-				let inputData: number[];
-				if (typeof data === "string") {
-					inputData = Utils.toArray(data, encoding || "utf8");
-				} else {
-					inputData = Array.from(data);
-				}
-
-				// let resultBuffer: Buffer;
-				// let resultOutput: string | number[];
-
-				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");
-					// }
-				}
-				// 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);
-				return {
-					content: [
-						{
-							type: "text",
-							text: `Error during ${mode}: ${errorMessage}`,
-						},
-					],
-					isError: true,
-				};
-			}
-		},
-	);
-
 	// Register createOrdinals tool
-	registerCreateOrdinalsTool(server, wallet);
+	registerCreateOrdinalsTool(server, config.ctx);
 
 	// Register collection tools
 	registerGatherCollectionInfoTool(server, wallet);
 	registerMintCollectionTool(server, wallet);
 
+	// Register read-only wallet tools
+	registerGetOrdinalsTool(server, config.ctx);
+	registerListTokensTool(server, config.ctx);
+	registerGetBsv21BalancesTool(server, config.ctx);
+	registerGetLockDataTool(server, config.ctx);
+	registerSignBsmTool(server, config.ctx);
+
+	// Register state-changing action tools
+	registerListOrdinalTool(server, config.ctx);
+	registerCancelListingTool(server, config.ctx);
+	registerSendAllBsvTool(server, config.ctx);
+	registerLockBsvTool(server, config.ctx);
+	registerUnlockBsvTool(server, config.ctx);
+	registerOpnsRegisterTool(server, config.ctx);
+	registerOpnsDeregisterTool(server, config.ctx);
+
+	// Register sweep tools
+	registerSweepBsvTool(server, config.ctx);
+	registerSweepOrdinalsTool(server, config.ctx);
+	registerSweepBsv21Tool(server, config.ctx);
+
 }