bsv-mcp 0.2.9 → 0.2.10

package/tools/wallet/tools.ts

@@ -1,15 +1,15 @@
-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 { registerMintCollectionTool } from "./mintCollection";
 import { registerPurchaseListingTool } from "./purchaseListing";
 import { registerRefreshUtxosTool } from "./refreshUtxos";
-import { walletEncryptionArgsSchema } from "./schemas";
 import { registerSendToAddressTool } from "./sendToAddress";
 import { registerTransferOrdTokenTool } from "./transferOrdToken";
 import type { Wallet } from "./wallet";
@@ -21,28 +21,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);
-
 	// 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);
 
 	// 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,83 +53,8 @@ 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);

package/tools/wallet/transferOrdToken.ts

@@ -1,156 +1,164 @@
-import { PrivateKey } from "@bsv/sdk";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import {
-	type Distribution,
-	type LocalSigner,
-	OneSatBroadcaster,
-	type Payment,
-	selectTokenUtxos,
-	type TokenChangeResult,
-	TokenInputMode,
-	TokenSelectionStrategy,
-	TokenType,
-	type TokenUtxo,
-	type TransferOrdTokensConfig,
-	transferOrdTokens,
-	type Utxo,
-} from "js-1sat-ord";
-import { z } from "zod";
-import { V5Broadcaster } from "../../utils/broadcaster";
-import type { Wallet } from "./wallet";
+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(),
+})
 
-// Schema for BSV-20/BSV-21 token transfer arguments
 export const transferOrdTokenArgsSchema = z.object({
-	protocol: z.enum(["bsv-20", "bsv-21"]),
-	tokenID: z.string(),
-	sendAmount: z.number(),
-	paymentUtxos: z.array(
-		z.object({
-			txid: z.string(),
-			vout: z.number(),
-			satoshis: z.number(),
-			script: z.string(),
-		}),
-	),
-	tokenUtxos: z.array(
-		z.object({
-			txid: z.string(),
-			vout: z.number(),
-			satoshis: z.literal(1),
-			script: z.string(),
-			amt: z.string(),
-			id: z.string(),
-		}),
+	type: z.enum(['ordinal', 'bsv21']).describe(
+		"'ordinal' to transfer an inscription/NFT, 'bsv21' to send fungible BSV21 tokens",
 	),
-	distributions: z.array(z.object({ address: z.string(), tokens: z.number() })),
-	decimals: z.number(),
-	additionalPayments: z
-		.array(z.object({ to: z.string(), amount: z.number() }))
-		.optional(),
-});
-export type TransferOrdTokenArgs = z.infer<typeof transferOrdTokenArgsSchema>;
+	// ordinal fields
+	ordinal: walletOutputSchema
+		.optional()
+		.describe(
+			"WalletOutput of the ordinal to transfer (from wallet_getOrdinals). Required when type='ordinal'",
+		),
+	inputBEEF: z
+		.array(z.number())
+		.optional()
+		.describe(
+			"BEEF bytes from listOutputs (include: 'entire transactions'). Required when type='ordinal'",
+		),
+	// bsv21 fields
+	tokenId: z
+		.string()
+		.optional()
+		.describe("Token ID (txid_vout format). Required when type='bsv21'"),
+	amount: z
+		.string()
+		.optional()
+		.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'),
+	counterparty: z
+		.string()
+		.optional()
+		.describe('Recipient identity public key (hex)'),
+})
+
+export type TransferOrdTokenArgs = z.infer<typeof transferOrdTokenArgsSchema>
 
-/**
- * Register the wallet_transferOrdToken tool for transferring BSV tokens.
- */
 export function registerTransferOrdTokenTool(
 	server: McpServer,
-	wallet: Wallet,
+	ctx: OneSatContext | undefined,
 ) {
 	server.tool(
-		"wallet_transferOrdToken",
-		"Transfers BSV-20 or BSV-21 tokens from your wallet via js-1sat-ord transferOrdTokens.",
+		'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.",
 		{ ...transferOrdTokenArgsSchema.shape },
-		async ({ protocol, tokenID, sendAmount, paymentUtxos, tokenUtxos, distributions, decimals, additionalPayments }) => {
-			try {
-				// fetch keys
-				const paymentPk = wallet.getPaymentKey();
-				if (!paymentPk) throw new Error("No private key available");
-				const ordPk = paymentPk;
-				const changeAddress = paymentPk.toAddress().toString();
-				const ordAddress = changeAddress;
+		async ({ type, ordinal, inputBEEF, tokenId, amount, address, counterparty }) => {
+			if (!ctx) {
+				return {
+					content: [
+						{
+							type: 'text',
+							text: 'Wallet not initialized. Please configure a wallet before transferring.',
+						},
+					],
+					isError: true,
+				}
+			}
 
-				// select token UTXOs
-				const { selectedUtxos: inputTokens } = selectTokenUtxos(
-					tokenUtxos as TokenUtxo[],
-					sendAmount,
-					decimals,
-					{
-						inputStrategy: TokenSelectionStrategy.SmallestFirst,
-						outputStrategy: TokenSelectionStrategy.LargestFirst,
-					},
-				);
+			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) {
+						return {
+							content: [{ type: 'text', text: 'address or counterparty is required' }],
+							isError: true,
+						}
+					}
 
-				// build config
-				const config: TransferOrdTokensConfig = {
-					protocol:
-						protocol === "bsv-20" ? TokenType.BSV20 : TokenType.BSV21,
-					tokenID,
-					utxos: paymentUtxos as Utxo[],
-					inputTokens,
-					distributions: distributions as Distribution[],
-					tokenChangeAddress: ordAddress,
-					changeAddress,
-					paymentPk,
-					ordPk,
-					additionalPayments: (additionalPayments as Payment[]) || [],
-					decimals,
-					inputMode: TokenInputMode.Needed,
-					splitConfig: {
-						outputs: inputTokens.length === 1 ? 2 : 1,
-						threshold: sendAmount,
-					},
-				};
+					const result = await transferOrdinals.execute(ctx, {
+						transfers: [
+							{
+								ordinal: ordinal as Parameters<typeof transferOrdinals.execute>[1]['transfers'][0]['ordinal'],
+								address,
+								counterparty,
+							},
+						],
+						inputBEEF,
+					})
 
-				const identityPk = process.env.IDENTITY_KEY_WIF
-					? PrivateKey.fromWif(process.env.IDENTITY_KEY_WIF)
-					: undefined;
+					if (result.error) {
+						return {
+							content: [{ type: 'text', text: result.error }],
+							isError: true,
+						}
+					}
 
-				if (identityPk) {
-					config.signer = {
-						idKey: identityPk,
-					} as LocalSigner;
+					return {
+						content: [{ type: 'text', text: JSON.stringify({ txid: result.txid }) }],
+					}
 				}
 
-				// execute transfer
-				const result: TokenChangeResult = await transferOrdTokens(config);
-				const disableBroadcasting = process.env.DISABLE_BROADCASTING === "true";
-				if (!disableBroadcasting) {
-					const broadcaster = new V5Broadcaster();
-					await result.tx.broadcast(broadcaster);
+				// bsv21
+				if (!tokenId) {
+					return {
+						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' }],
+						isError: true,
+					}
+				}
 
-					// refresh UTXOs
-					try {
-						await wallet.refreshUtxos();
-					} catch {}
+				const result = await sendBsv21.execute(ctx, {
+					tokenId,
+					amount,
+					address,
+					counterparty,
+				})
 
-					// respond
+				if (result.error) {
 					return {
-						content: [
-							{
-								type: "text",
-								text: JSON.stringify({
-									txid: result.tx.id("hex"),
-									spentOutpoints: result.spentOutpoints,
-									payChange: result.payChange,
-									tokenChange: result.tokenChange,
-								}),
-							},
-						],
-					};
+						content: [{ type: 'text', text: result.error }],
+						isError: true,
+					}
 				}
+
+				return {
+					content: [{ type: 'text', text: JSON.stringify({ txid: result.txid }) }],
+				}
+			} catch (err: unknown) {
 				return {
 					content: [
 						{
-							type: "text",
-							text: result.tx.toHex(),
+							type: 'text',
+							text: err instanceof Error ? err.message : String(err),
 						},
 					],
-				};
-			} catch (err: unknown) {
-				const msg = err instanceof Error ? err.message : String(err);
-				return { content: [{ type: "text", text: msg }], isError: true };
+					isError: true,
+				}
 			}
 		},
-	);
+	)
 }