bsv-mcp 0.2.14 → 0.3.0

package/tools/wallet/opnsRegister.ts

@@ -1,80 +1,70 @@
-import type { OneSatContext } from '@1sat/actions'
-import { opnsRegister } 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 { registerOpns } from "@1sat/actions";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { assertBroadcastAllowed } from "../../utils/broadcastGuard";
 
 const opnsRegisterArgsSchema = z.object({
-	ordinal: walletOutputSchema.describe(
-		'WalletOutput of the OpNS ordinal to register (from listOutputs)',
-	),
-	inputBEEF: z
-		.array(z.number())
-		.describe(
-			"BEEF bytes from listOutputs (include: 'entire transactions')",
-		),
-})
+	id: z
+		.string()
+		.describe("Tracking id of the OpNS name in the wallet's OPNS basket"),
+});
 
 export function registerOpnsRegisterTool(
 	server: McpServer,
 	ctx: OneSatContext | undefined,
 ) {
 	server.tool(
-		'wallet_opnsRegister',
-		'Register an OpNS name',
+		"wallet_opnsRegister",
+		"Register an OpNS name",
 		{ ...opnsRegisterArgsSchema.shape },
-		async ({ ordinal, inputBEEF }) => {
+		async ({ id }) => {
 			if (!ctx) {
 				return {
 					content: [
 						{
-							type: 'text',
-							text: 'Wallet not initialized. Please configure a wallet before registering.',
+							type: "text",
+							text: "Wallet not initialized. Please configure a wallet before registering.",
 						},
 					],
 					isError: true,
-				}
+				};
 			}
 
 			try {
-				const result = await opnsRegister.execute(ctx, {
-					ordinal: ordinal as Parameters<typeof opnsRegister.execute>[1]['ordinal'],
-					inputBEEF,
-				})
+				assertBroadcastAllowed("wallet_opnsRegister");
+				const result = await registerOpns.execute(ctx, { id });
 
 				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/purchaseListing.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from "bun:test";
+import {
+	MARKET_FEE_PERCENTAGE,
+	MINIMUM_MARKET_FEE_SATOSHIS,
+} from "../constants";
+import { computeMarketplaceRate } from "./purchaseListing";
+
+describe("computeMarketplaceRate", () => {
+	it("applies the minimum fee floor below the threshold", () => {
+		const price = 100_000;
+
+		expect(computeMarketplaceRate(price)).toBe(
+			MINIMUM_MARKET_FEE_SATOSHIS / price,
+		);
+	});
+
+	it("applies the percentage above the minimum-fee threshold", () => {
+		expect(computeMarketplaceRate(1_000_000)).toBe(MARKET_FEE_PERCENTAGE);
+	});
+
+	it("returns a finite rate for a zero price", () => {
+		const rate = computeMarketplaceRate(0);
+
+		expect(rate).toBe(MARKET_FEE_PERCENTAGE);
+		expect(Number.isFinite(rate)).toBe(true);
+	});
+});

package/tools/wallet/purchaseListing.ts

@@ -1,85 +1,104 @@
-import type { OneSatContext } from '@1sat/actions'
-import { purchaseBsv21, purchaseOrdinal } from '@1sat/actions'
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js'
+import type { OneSatContext } from "@1sat/actions";
+import { buyBsv21, buyOrdinal } from "@1sat/actions";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { assertBroadcastAllowed } from "../../utils/broadcastGuard";
 import {
 	MARKET_FEE_PERCENTAGE,
 	MARKET_WALLET_ADDRESS,
 	MINIMUM_MARKET_FEE_SATOSHIS,
-} from '../constants'
-import { purchaseListingArgsSchema } from './schemas'
+} from "../constants";
+import { purchaseListingArgsSchema } from "./schemas";
+
+export function computeMarketplaceRate(listingPriceSatoshis: number): number {
+	if (listingPriceSatoshis === 0) {
+		return MARKET_FEE_PERCENTAGE;
+	}
+
+	const fee = Math.round(listingPriceSatoshis * MARKET_FEE_PERCENTAGE);
+	return Math.max(fee, MINIMUM_MARKET_FEE_SATOSHIS) / listingPriceSatoshis;
+}
 
 export function registerPurchaseListingTool(
 	server: McpServer,
 	ctx: OneSatContext | undefined,
 ) {
 	server.tool(
-		'wallet_purchaseListing',
-		'Purchases a listing from the Bitcoin SV ordinals marketplace. Supports both NFT purchases and BSV21 token purchases.',
+		"wallet_purchaseListing",
+		"Purchases a listing from the Bitcoin SV ordinals marketplace. Supports both NFT purchases and BSV21 token purchases.",
 		{ ...purchaseListingArgsSchema.shape },
-		async ({ listingOutpoint, listingType, tokenID, tokenAmount, description }): Promise<CallToolResult> => {
+		async ({
+			listingOutpoint,
+			listingType,
+			tokenID,
+			tokenAmount,
+		}): Promise<CallToolResult> => {
 			if (!ctx) {
 				return {
 					content: [
 						{
-							type: 'text',
-							text: 'Wallet not initialized. Please configure a wallet before purchasing.',
+							type: "text",
+							text: "Wallet not initialized. Please configure a wallet before purchasing.",
 						},
 					],
 					isError: true,
-				}
+				};
 			}
 
 			try {
-				let marketplaceRate = MARKET_FEE_PERCENTAGE
+				assertBroadcastAllowed("wallet_purchaseListing");
+				let marketplaceRate = MARKET_FEE_PERCENTAGE;
 
-				if (listingType === 'token') {
+				if (listingType === "token") {
 					if (!tokenID) {
-						throw new Error('tokenID is required for token listings')
+						throw new Error("tokenID is required for token listings");
 					}
 
 					if (!tokenAmount) {
 						const response = await fetch(
 							`https://ordinals.gorillapool.io/api/txos/${listingOutpoint}?script=true`,
-						)
+						);
 						if (!response.ok) {
-							throw new Error(`Failed to fetch listing data: ${response.statusText}`)
+							throw new Error(
+								`Failed to fetch listing data: ${response.statusText}`,
+							);
 						}
 						const listingData = (await response.json()) as {
-							data?: { list?: { price: number }; bsv20?: { amt?: string } }
-						}
+							data?: { list?: { price: number }; bsv20?: { amt?: string } };
+						};
 						if (!listingData.data?.bsv20?.amt) {
-							throw new Error('Token listing does not have an amount')
+							throw new Error("Token listing does not have an amount");
 						}
-						tokenAmount = listingData.data.bsv20.amt
+						tokenAmount = listingData.data.bsv20.amt;
 
 						if (listingData.data?.list?.price) {
-							const fee = Math.round(listingData.data.list.price * MARKET_FEE_PERCENTAGE)
-							marketplaceRate = Math.max(fee, MINIMUM_MARKET_FEE_SATOSHIS) / listingData.data.list.price
+							marketplaceRate = computeMarketplaceRate(
+								listingData.data.list.price,
+							);
 						}
 					}
 
-					const result = await purchaseBsv21.execute(ctx, {
+					const result = await buyBsv21.execute(ctx, {
 						tokenId: tokenID,
 						outpoint: listingOutpoint,
 						amount: tokenAmount,
 						marketplaceAddress: MARKET_WALLET_ADDRESS,
 						marketplaceRate,
-					})
+					});
 
 					if (result.error) {
 						return {
-							content: [{ type: 'text', text: result.error }],
+							content: [{ type: "text", text: result.error }],
 							isError: true,
-						}
+						};
 					}
 
 					return {
 						content: [
 							{
-								type: 'text',
+								type: "text",
 								text: JSON.stringify({
-									status: 'success',
+									status: "success",
 									txid: result.txid,
 									listingOutpoint,
 									listingType,
@@ -87,39 +106,39 @@ export function registerPurchaseListingTool(
 								}),
 							},
 						],
-					}
+					};
 				}
 
-				const result = await purchaseOrdinal.execute(ctx, {
+				const result = await buyOrdinal.execute(ctx, {
 					outpoint: listingOutpoint,
 					marketplaceAddress: MARKET_WALLET_ADDRESS,
 					marketplaceRate,
-				})
+				});
 
 				if (result.error) {
 					return {
-						content: [{ type: 'text', text: result.error }],
+						content: [{ type: "text", text: result.error }],
 						isError: true,
-					}
+					};
 				}
 
 				return {
 					content: [
 						{
-							type: 'text',
+							type: "text",
 							text: JSON.stringify({
-								status: 'success',
+								status: "success",
 								txid: result.txid,
 								listingOutpoint,
 								listingType,
 							}),
 						},
 					],
-				}
+				};
 			} catch (err: unknown) {
-				const msg = err instanceof Error ? err.message : String(err)
-				return { content: [{ type: 'text', text: msg }], isError: true }
+				const msg = err instanceof Error ? err.message : String(err);
+				return { content: [{ type: "text", text: msg }], isError: true };
 			}
 		},
-	)
+	);
 }

package/tools/wallet/refreshUtxos.ts

@@ -1,4 +1,4 @@
-import { syncAddresses, type OneSatContext } from "@1sat/actions";
+import { type OneSatContext, syncAddresses } from "@1sat/actions";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 const MCP_ADDRESS_PREFIX = "mcp";

package/tools/wallet/schemas.ts

@@ -48,14 +48,6 @@ export const walletEncryptionArgsSchema = z
 // Get address args
 export const getAddressArgsSchema = z.object({});
 
-// Send to address args
-export const sendToAddressArgsSchema = z.object({
-	address: z.string(),
-	amount: z.number(),
-	currency: z.enum(["BSV", "USD"]).optional().default("BSV"),
-	description: z.string().optional(),
-});
-
 /**
  * Schema for purchase listing arguments
  */
@@ -82,16 +74,11 @@ export const purchaseListingArgsSchema = z
 			.describe(
 				"Amount of tokens in the listing (as string) — required when listingType is 'token'",
 			),
-		description: z
-			.string()
-			.optional()
-			.describe("Optional description for the transaction"),
 	})
 	.describe(
 		"Schema for the wallet_purchaseListing tool arguments (purchase NFTs or BSV21 tokens).",
 	);
 
 // Export types
-export type SendToAddressArgs = z.infer<typeof sendToAddressArgsSchema>;
 export type PurchaseListingArgs = z.infer<typeof purchaseListingArgsSchema>;
 export type WalletEncryptionArgs = z.infer<typeof walletEncryptionArgsSchema>;

package/tools/wallet/sendAllBsv.ts

@@ -1,64 +1,70 @@
-import type { OneSatContext } from '@1sat/actions'
-import { sendAllBsv } from '@1sat/actions'
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import { z } from 'zod'
+import type { OneSatContext } from "@1sat/actions";
+import { sendAllBsv } from "@1sat/actions";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { assertBroadcastAllowed } from "../../utils/broadcastGuard";
 
 const sendAllBsvArgsSchema = z.object({
 	destination: z
 		.string()
-		.describe('Destination P2PKH address to send all funds to'),
-})
+		.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',
+		"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.',
+							type: "text",
+							text: "Wallet not initialized. Please configure a wallet before sending.",
 						},
 					],
 					isError: true,
-				}
+				};
 			}
 
 			try {
-				const result = await sendAllBsv.execute(ctx, { destination })
+				assertBroadcastAllowed("wallet_sendAllBsv");
+				const result = await sendAllBsv.execute(ctx, { destination });
 
 				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/sendBsv.ts

@@ -0,0 +1,107 @@
+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 { z } from "zod";
+import { assertBroadcastAllowed } from "../../utils/broadcastGuard";
+import { getBsvPriceWithCache } from "../bsv/getPrice";
+
+const recipientSchema = z.object({
+	address: z.string().optional().describe("Destination P2PKH address"),
+	paymail: z.string().optional().describe("Destination paymail address"),
+	amount: z
+		.number()
+		.positive()
+		.finite()
+		.describe("Amount to send; must be greater than zero"),
+	currency: z
+		.enum(["BSV", "USD"])
+		.optional()
+		.default("BSV")
+		.describe("Currency of amount (default: BSV)"),
+});
+
+const sendBsvArgsSchema = z.object({
+	recipients: z.array(recipientSchema).describe("Array of payment recipients"),
+});
+
+export function registerSendBsvTool(
+	server: McpServer,
+	ctx: OneSatContext | undefined,
+) {
+	server.tool(
+		"wallet_sendBsv",
+		"Send BSV to one or more recipients by address or paymail. Supports BSV and USD amounts with automatic conversion.",
+		{ ...sendBsvArgsSchema.shape },
+		async ({ recipients }) => {
+			if (!ctx) {
+				return {
+					content: [{ type: "text", text: "Wallet not initialized." }],
+					isError: true,
+				};
+			}
+
+			try {
+				assertBroadcastAllowed("wallet_sendBsv");
+				let bsvPrice: number | undefined;
+
+				const requests = await Promise.all(
+					recipients.map(async (r) => {
+						if (!r.address && !r.paymail) {
+							throw new Error("Each recipient requires an address or paymail");
+						}
+
+						let satoshis: number;
+						if (r.currency === "USD") {
+							if (!bsvPrice) bsvPrice = await getBsvPriceWithCache();
+							satoshis = toSatoshi(r.amount / bsvPrice);
+						} else {
+							satoshis = toSatoshi(r.amount);
+						}
+
+						return {
+							...(r.address && { address: r.address }),
+							...(r.paymail && { paymail: r.paymail }),
+							satoshis,
+						};
+					}),
+				);
+
+				const result = await sendBsv.execute(ctx, { requests });
+
+				if (result.error) {
+					return {
+						content: [{ type: "text", text: result.error }],
+						isError: true,
+					};
+				}
+
+				return {
+					content: [
+						{
+							type: "text",
+							text: JSON.stringify({
+								status: "success",
+								txid: result.txid,
+								recipients: requests.map((r) => ({
+									destination: r.address || r.paymail,
+									satoshis: r.satoshis,
+								})),
+							}),
+						},
+					],
+				};
+			} catch (error) {
+				return {
+					content: [
+						{
+							type: "text",
+							text: error instanceof Error ? error.message : String(error),
+						},
+					],
+					isError: true,
+				};
+			}
+		},
+	);
+}