bsv-mcp 0.2.14 → 0.3.0

package/tools/wallet/integratedWallet.ts

@@ -1,5 +1,9 @@
-import { P2PKH, type PrivateKey, Script } from "@bsv/sdk";
-import { DropletClient, type DropletConfig } from "../../utils/droplet";
+import { type PrivateKey, Utils } from "@bsv/sdk";
+import { DroplitClient, type DroplitConfig } from "../../utils/droplit";
+import {
+	buildAndSendTransaction,
+	buildOpReturnScript,
+} from "../utils/transactionBuilder";
 import { Wallet } from "./wallet";
 
 export interface IntegratedWalletConfig {
@@ -7,26 +11,26 @@ export interface IntegratedWalletConfig {
 	paymentKey?: PrivateKey;
 	identityKey?: PrivateKey;
 
-	// Droplet API config
-	useDropletApi?: boolean;
-	dropletConfig?: DropletConfig;
+	// Droplit API config
+	useDroplitApi?: boolean;
+	droplitConfig?: DroplitConfig;
 }
 
 /**
- * Integrated wallet that can use either local keys or Droplet API
+ * Integrated wallet that can use either local keys or Droplit API
  */
 export class IntegratedWallet {
 	private localWallet?: Wallet;
-	private dropletClient?: DropletClient;
+	private droplitClient?: DroplitClient;
 
-	constructor(private config: IntegratedWalletConfig) {
-		if (config.useDropletApi && config.dropletConfig) {
-			// If we have a payment key, use it for auth with Droplet API
+	constructor(config: IntegratedWalletConfig) {
+		if (config.useDroplitApi && config.droplitConfig) {
+			// If we have a payment key, use it for auth with Droplit API
 			if (config.paymentKey) {
-				config.dropletConfig.authKey = config.paymentKey;
+				config.droplitConfig.authKey = config.paymentKey;
 			}
-			this.dropletClient = new DropletClient(config.dropletConfig);
-			console.error("IntegratedWallet: Using Droplet API mode");
+			this.droplitClient = new DroplitClient(config.droplitConfig);
+			console.error("IntegratedWallet: Using Droplit API mode");
 		} else if (config.paymentKey) {
 			this.localWallet = new Wallet(config.paymentKey, config.identityKey);
 			console.error("IntegratedWallet: Using local wallet mode");
@@ -37,21 +41,22 @@ export class IntegratedWallet {
 		}
 	}
 
-	get isDropletMode(): boolean {
-		return !!this.dropletClient;
+	get isDroplitMode(): boolean {
+		return !!this.droplitClient;
 	}
 
 	get hasWallet(): boolean {
-		return !!this.localWallet || !!this.dropletClient;
+		return !!this.localWallet || !!this.droplitClient;
 	}
 
 	async getBalance(): Promise<number> {
-		if (this.dropletClient) {
-			const status = await this.dropletClient.getFaucetStatus();
+		if (this.droplitClient) {
+			const status = await this.droplitClient.getFaucetStatus();
 			return status.balance_satoshis;
 		}
 		if (this.localWallet) {
-			return this.localWallet.getTotalBalance();
+			const { paymentUtxos } = await this.localWallet.getUtxos();
+			return paymentUtxos.reduce((sum, utxo) => sum + utxo.satoshis, 0);
 		}
 		throw new Error("No wallet configured");
 	}
@@ -59,52 +64,49 @@ export class IntegratedWallet {
 	async sendToAddress(
 		address: string,
 		satoshis: number,
-		description?: string,
 	): Promise<{ txid: string }> {
-		if (this.dropletClient) {
-			// For Droplet API, we use the tap endpoint which sends the faucet's fixed amount
-			// Note: Droplet API doesn't support custom amounts, it uses fixed_drop_sats
-			const response = await this.dropletClient.tap(address);
+		if (this.droplitClient) {
+			// For Droplit API, we use the tap endpoint which sends the faucet's fixed amount
+			// Note: Droplit API doesn't support custom amounts, it uses fixed_drop_sats
+			const response = await this.droplitClient.tap(address);
 			return { txid: response.txid };
 		}
 		if (this.localWallet) {
-			const tx = await this.localWallet.createAction({
-				description: description || "Send to address",
-				outputs: [
-					{
-						lockingScript: new P2PKH().lock(address).toHex(),
-						satoshis,
-						outputDescription: `Payment to ${address}`,
-					},
-				],
-			});
-			return { txid: tx.txid };
+			return await this.localWallet.sendToAddress(address, satoshis);
 		}
 		throw new Error("No wallet configured");
 	}
 
 	async pushData(data: string[], encoding = "hex"): Promise<{ txid: string }> {
-		if (this.dropletClient) {
-			const response = await this.dropletClient.push(data, encoding);
+		if (this.droplitClient) {
+			const response = await this.droplitClient.push(data, encoding);
 			return { txid: response.txid };
 		}
 		if (this.localWallet) {
-			// For local wallet, we need to implement OP_RETURN transaction
-			// This is a simplified version - you might want to enhance this
-			const opReturnScript = Script.fromASM(
-				`OP_FALSE OP_RETURN ${data.join(" ")}`,
+			const paymentKey = this.localWallet.getPaymentKey();
+			const changeAddress = this.localWallet.getAddress();
+			if (!paymentKey || !changeAddress) {
+				throw new Error("Local wallet has no payment key");
+			}
+			if (encoding !== "hex" && encoding !== "utf8" && encoding !== "base64") {
+				throw new Error(
+					`Unsupported push data encoding "${encoding}"; expected hex, utf8 or base64`,
+				);
+			}
+			const script = buildOpReturnScript(
+				data.map((item) => Utils.toArray(item, encoding)),
 			);
-			const tx = await this.localWallet.createAction({
-				description: "Push data",
-				outputs: [
-					{
-						lockingScript: opReturnScript.toHex(),
-						satoshis: 0,
-						outputDescription: "OP_RETURN data",
-					},
-				],
+			const { paymentUtxos } = await this.localWallet.getUtxos();
+			const result = await buildAndSendTransaction({
+				outputs: [{ script, satoshis: 0 }],
+				utxos: paymentUtxos,
+				changeAddress,
+				paymentKey,
 			});
-			return { txid: tx.txid };
+			if (!result.success || !result.txid) {
+				throw new Error(result.error ?? "Failed to broadcast OP_RETURN data");
+			}
+			return { txid: result.txid };
 		}
 		throw new Error("No wallet configured");
 	}
@@ -114,7 +116,7 @@ export class IntegratedWallet {
 		return this.localWallet;
 	}
 
-	getDropletClient(): DropletClient | undefined {
-		return this.dropletClient;
+	getDroplitClient(): DroplitClient | undefined {
+		return this.droplitClient;
 	}
 }

package/tools/wallet/listOrdinal.ts

@@ -1,86 +1,87 @@
-import type { OneSatContext } from '@1sat/actions'
-import { listOrdinal } 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 { sellOrdinal } from "@1sat/actions";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { assertBroadcastAllowed } from "../../utils/broadcastGuard";
 
 const listOrdinalArgsSchema = z.object({
-	ordinal: walletOutputSchema.describe(
-		'WalletOutput of the ordinal to list (from wallet_getOrdinals)',
-	),
-	inputBEEF: z
-		.array(z.number())
+	id: z
+		.string()
 		.describe(
-			"BEEF bytes from listOutputs (include: 'entire transactions')",
+			"Tracking id of the ordinal in the ordinals basket (the 'id:' tag from wallet_getOrdinals)",
 		),
-	price: z.number().describe('Price in satoshis'),
+	price: z
+		.number()
+		.int()
+		.positive()
+		.describe("Price in satoshis; whole satoshis above zero"),
 	payAddress: z
 		.string()
-		.describe('Address to receive payment on purchase'),
-})
+		.optional()
+		.describe(
+			"Address to receive payment on purchase. Defaults to the wallet's P1SAT '1sat 0' address.",
+		),
+});
 
 export function registerListOrdinalTool(
 	server: McpServer,
 	ctx: OneSatContext | undefined,
 ) {
 	server.tool(
-		'wallet_listOrdinal',
-		'List an ordinal for sale on the marketplace',
+		"wallet_listOrdinal",
+		"List an ordinal for sale on the marketplace",
 		{ ...listOrdinalArgsSchema.shape },
-		async ({ ordinal, inputBEEF, price, payAddress }) => {
+		async ({ id, price, payAddress }) => {
 			if (!ctx) {
 				return {
 					content: [
 						{
-							type: 'text',
-							text: 'Wallet not initialized. Please configure a wallet before listing.',
+							type: "text",
+							text: "Wallet not initialized. Please configure a wallet before listing.",
 						},
 					],
 					isError: true,
-				}
+				};
 			}
 
 			try {
-				const result = await listOrdinal.execute(ctx, {
-					ordinal: ordinal as Parameters<typeof listOrdinal.execute>[1]['ordinal'],
-					inputBEEF,
+				assertBroadcastAllowed("wallet_listOrdinal");
+				const result = await sellOrdinal.execute(ctx, {
+					id,
 					price,
 					payAddress,
-				})
+				});
 
 				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/listTokens.ts

@@ -1,28 +1,29 @@
-import { listTokens, type OneSatContext } from '@1sat/actions'
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import { z } from 'zod'
+import { listBsv21, type OneSatContext } from "@1sat/actions";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
 
-export function registerListTokensTool(
-	server: McpServer,
-	ctx?: OneSatContext,
-) {
+export function registerListTokensTool(server: McpServer, ctx?: OneSatContext) {
 	server.tool(
-		'wallet_listTokens',
-		'List BSV21 token outputs in the wallet',
+		"wallet_listTokens",
+		"List BSV21 token outputs in the wallet",
 		{
-			limit: z.number().int().optional().describe('Max number of results to return'),
+			limit: z
+				.number()
+				.int()
+				.optional()
+				.describe("Max number of results to return"),
 		},
 		async (params) => {
 			try {
-				if (!ctx) throw new Error('BRC-100 wallet context not available')
-				const result = await listTokens.execute(ctx, params)
+				if (!ctx) throw new Error("BRC-100 wallet context not available");
+				const result = await listBsv21.execute(ctx, params);
 				return {
-					content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-				}
+					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 }
+				const msg = err instanceof Error ? err.message : String(err);
+				return { content: [{ type: "text", text: msg }], isError: true };
 			}
 		},
-	)
+	);
 }

package/tools/wallet/lockBsv.ts

@@ -1,69 +1,83 @@
-import type { OneSatContext } from '@1sat/actions'
-import { lockBsv } from '@1sat/actions'
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import { z } from 'zod'
+import type { OneSatContext } from "@1sat/actions";
+import { lockBsv } from "@1sat/actions";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { assertBroadcastAllowed } from "../../utils/broadcastGuard";
 
 const lockBsvArgsSchema = z.object({
 	requests: z
 		.array(
 			z.object({
-				satoshis: z.number().describe('Amount in satoshis to lock'),
-				until: z.number().describe('Block height until which to lock'),
+				satoshis: z
+					.number()
+					.int()
+					.positive()
+					.describe("Amount in satoshis to lock; whole satoshis above zero"),
+				until: z
+					.number()
+					.int()
+					.positive()
+					.describe("Block height until which to lock"),
 			}),
 		)
-		.describe('Array of lock requests'),
-})
+		.describe("Array of lock requests"),
+});
 
 export function registerLockBsvTool(
 	server: McpServer,
 	ctx: OneSatContext | undefined,
 ) {
 	server.tool(
-		'wallet_lockBsv',
-		'Lock BSV until a specific block height',
+		"wallet_lockBsv",
+		"Lock BSV until a specific block height",
 		{ ...lockBsvArgsSchema.shape },
 		async ({ requests }) => {
 			if (!ctx) {
 				return {
 					content: [
 						{
-							type: 'text',
-							text: 'Wallet not initialized. Please configure a wallet before locking.',
+							type: "text",
+							text: "Wallet not initialized. Please configure a wallet before locking.",
 						},
 					],
 					isError: true,
-				}
+				};
 			}
 
 			try {
-				const result = await lockBsv.execute(ctx, { requests })
+				assertBroadcastAllowed("wallet_lockBsv");
+				const result = await lockBsv.execute(ctx, { requests });
 
 				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/mintCollection.ts

@@ -12,11 +12,11 @@ import type {
 	CreateOrdinalsCollectionMetadata,
 	CreateOrdinalsConfig,
 	LocalSigner,
-	RarityLabels,
 } from "js-1sat-ord";
 import { createOrdinals } from "js-1sat-ord";
 import { z } from "zod";
 import { V5Broadcaster } from "../../utils/broadcaster";
+import { assertBroadcastAllowed } from "../../utils/broadcastGuard";
 import type { Wallet } from "./wallet";
 
 const mintCollectionArgsSchema = z.object({
@@ -46,8 +46,6 @@ const mintCollectionArgsSchema = z.object({
 		.describe("Skip broadcasting transactions (for testing)"),
 });
 
-type MintCollectionArgs = z.infer<typeof mintCollectionArgsSchema>;
-
 interface ImageFile {
 	path: string;
 	name: string;
@@ -121,10 +119,20 @@ export function registerMintCollectionTool(server: McpServer, wallet: Wallet) {
 		"wallet_mintCollection",
 		"Mint a collection of ordinals from a folder of images with proper metadata. This tool creates a collection inscription first, then mints each image as a collection item with the appropriate metadata linking it to the collection.",
 		{ ...mintCollectionArgsSchema.shape },
-		async ({ folderPath, collectionName, description, rarityLabels, traits: traitsJson, skipBroadcast }): Promise<CallToolResult> => {
+		async ({
+			folderPath,
+			collectionName,
+			description,
+			rarityLabels,
+			traits: traitsJson,
+			skipBroadcast,
+		}): Promise<CallToolResult> => {
 			try {
+				assertBroadcastAllowed("wallet_mintCollection");
 				// Parse traits JSON string if provided
-				const traits: Record<string, string[]> | undefined = traitsJson ? JSON.parse(traitsJson) : undefined;
+				const traits: Record<string, string[]> | undefined = traitsJson
+					? JSON.parse(traitsJson)
+					: undefined;
 				// Get keys from wallet
 				const paymentPk = wallet.getPaymentKey();
 				if (!paymentPk) {
@@ -145,8 +153,7 @@ export function registerMintCollectionTool(server: McpServer, wallet: Wallet) {
 					description: description,
 					quantity: imageFiles.length,
 					// Transform rarity labels to correct format
-					rarityLabels:
-						rarityLabels?.map((r) => ({ label: r.label })) || [],
+					rarityLabels: rarityLabels?.map((r) => ({ label: r.label })) || [],
 					// Transform traits - need to match the CollectionTraits type
 					traits: traits
 						? Object.entries(traits).reduce((acc, [key, values]) => {
@@ -262,9 +269,7 @@ export function registerMintCollectionTool(server: McpServer, wallet: Wallet) {
 								(i / imageFiles.length) * rarityLabels.length,
 							);
 							const rarityItem =
-								rarityLabels[
-									Math.min(rarityIndex, rarityLabels.length - 1)
-								];
+								rarityLabels[Math.min(rarityIndex, rarityLabels.length - 1)];
 							if (rarityItem) {
 								itemSubTypeData.rarityLabel = [
 									{ [rarityItem.label]: `${rarityItem.percentage}%` },

package/tools/wallet/opnsDeregister.ts

@@ -1,80 +1,70 @@
-import type { OneSatContext } from '@1sat/actions'
-import { opnsDeregister } 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 { deregisterOpns } from "@1sat/actions";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { assertBroadcastAllowed } from "../../utils/broadcastGuard";
 
 const opnsDeregisterArgsSchema = z.object({
-	ordinal: walletOutputSchema.describe(
-		'WalletOutput of the OpNS ordinal to deregister (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 registerOpnsDeregisterTool(
 	server: McpServer,
 	ctx: OneSatContext | undefined,
 ) {
 	server.tool(
-		'wallet_opnsDeregister',
-		'Deregister an OpNS name',
+		"wallet_opnsDeregister",
+		"Deregister an OpNS name",
 		{ ...opnsDeregisterArgsSchema.shape },
-		async ({ ordinal, inputBEEF }) => {
+		async ({ id }) => {
 			if (!ctx) {
 				return {
 					content: [
 						{
-							type: 'text',
-							text: 'Wallet not initialized. Please configure a wallet before deregistering.',
+							type: "text",
+							text: "Wallet not initialized. Please configure a wallet before deregistering.",
 						},
 					],
 					isError: true,
-				}
+				};
 			}
 
 			try {
-				const result = await opnsDeregister.execute(ctx, {
-					ordinal: ordinal as Parameters<typeof opnsDeregister.execute>[1]['ordinal'],
-					inputBEEF,
-				})
+				assertBroadcastAllowed("wallet_opnsDeregister");
+				const result = await deregisterOpns.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,
-				}
+				};
 			}
 		},
-	)
+	);
 }