bsv-mcp 0.2.9 → 0.2.11

package/tools/wallet/createOrdinals.ts

@@ -1,168 +1,87 @@
-import { PrivateKey } from "@bsv/sdk";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import type {
-	ChangeResult,
-	CreateOrdinalsCollectionItemMetadata,
-	CreateOrdinalsCollectionMetadata,
-	CreateOrdinalsConfig,
-	Destination,
-	Inscription,
-	LocalSigner,
-	PreMAP,
-} from "js-1sat-ord";
-import { createOrdinals } 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 { inscribe } from '@1sat/actions'
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js'
+import { z } from 'zod'
 
-/**
- * Schema for the createOrdinals tool arguments.
- * This is a simplified interface compared to the full CreateOrdinalsConfig
- * in js-1sat-ord. The wallet will provide UTXOs, private key, etc.
- */
 export const createOrdinalsArgsSchema = z.object({
-	// Base64-encoded data to inscribe
-	dataB64: z.string().describe("Base64-encoded content to inscribe"),
-	// Content type (e.g., "image/jpeg", "text/plain", etc.)
-	contentType: z.string().describe("MIME type of the content"),
-	// Optional destination address (if not provided, uses the wallet's address)
+	dataB64: z.string().describe('Base64-encoded content to inscribe'),
+	contentType: z.string().describe('MIME type of the content'),
 	destinationAddress: z
 		.string()
 		.optional()
-		.describe("Optional destination address for the ordinal"),
-	// Optional metadata for the inscription
+		.describe('Optional destination address for the ordinal'),
 	metadata: z
-		.any()
+		.record(z.string(), z.string())
 		.optional()
-		.describe("Optional MAP metadata for the inscription"),
-});
+		.describe('Optional MAP metadata for the inscription'),
+	signWithBAP: z
+		.boolean()
+		.optional()
+		.describe('Sign with BAP identity (Sigma protocol). Uses anchor+inscription two-step flow.'),
+})
 
-export type CreateOrdinalsArgs = z.infer<typeof createOrdinalsArgsSchema>;
+export type CreateOrdinalsArgs = z.infer<typeof createOrdinalsArgsSchema>
 
-/**
- * Registers the wallet_createOrdinals tool for minting ordinals/inscriptions
- */
-export function registerCreateOrdinalsTool(server: McpServer, wallet: Wallet) {
+export function registerCreateOrdinalsTool(
+	server: McpServer,
+	ctx: OneSatContext | undefined,
+) {
 	server.tool(
-		"wallet_createOrdinals",
-		"Creates and inscribes ordinals (NFTs) on the Bitcoin SV blockchain. This tool lets you mint new digital artifacts by encoding data directly into the blockchain. Supports various content types including images, text, JSON, and HTML. The tool handles transaction creation, fee calculation, and broadcasting.",
+		'wallet_createOrdinals',
+		'Creates and inscribes ordinals (NFTs) on the Bitcoin SV blockchain. This tool lets you mint new digital artifacts by encoding data directly into the blockchain. Supports various content types including images, text, JSON, and HTML. The tool handles transaction creation, fee calculation, and broadcasting.',
 		{ ...createOrdinalsArgsSchema.shape },
-		async ({ dataB64, contentType, destinationAddress, metadata }): Promise<CallToolResult> => {
-			try {
-				// Load optional identity key for sigma signing
-				const identityKeyWif = process.env.IDENTITY_KEY_WIF;
-				let identityPk: PrivateKey | undefined;
-				if (identityKeyWif) {
-					try {
-						identityPk = PrivateKey.fromWif(identityKeyWif);
-					} catch (e) {
-						console.warn(
-							"Warning: Invalid IDENTITY_KEY_WIF environment variable; sigma signing disabled",
-							e,
-						);
-					}
-				}
-
-				// 1. Get private key from wallet
-				const paymentPk = wallet.getPrivateKey();
-				if (!paymentPk) {
-					throw new Error("No private key available in wallet");
-				}
-
-				// 2. Get payment UTXOs from wallet
-				const { paymentUtxos } = await wallet.getUtxos();
-				if (!paymentUtxos || paymentUtxos.length === 0) {
-					throw new Error(
-						"No payment UTXOs available to fund this inscription",
-					);
-				}
-
-				// 3. Get the wallet address for change/destination if not provided
-				const walletAddress = paymentPk.toAddress().toString();
-
-				// 4. Create the inscription object
-				const inscription: Inscription = {
-					dataB64: dataB64,
-					contentType: contentType,
-				};
-
-				// 5. Create the destination
-				const destinations: Destination[] = [
-					{
-						address: destinationAddress || walletAddress,
-						inscription,
-					},
-				];
-
-				const createOrdinalsConfig: CreateOrdinalsConfig = {
-					utxos: paymentUtxos,
-					destinations,
-					paymentPk,
-					changeAddress: walletAddress,
-					metaData: metadata as
-						| PreMAP
-						| CreateOrdinalsCollectionMetadata
-						| CreateOrdinalsCollectionItemMetadata,
-				};
-
-				if (identityPk) {
-					createOrdinalsConfig.signer = {
-						idKey: identityPk,
-					} as LocalSigner;
+		async ({ dataB64, contentType, destinationAddress, metadata, signWithBAP }): Promise<CallToolResult> => {
+			if (!ctx) {
+				return {
+					content: [
+						{
+							type: 'text',
+							text: 'Wallet not initialized. Please configure a wallet before creating ordinals.',
+						},
+					],
+					isError: true,
 				}
+			}
 
-				// 6. Create and broadcast the transaction
-				const result = await createOrdinals(createOrdinalsConfig);
-
-				const changeResult = result as ChangeResult;
-
-				// 7. Optionally sign with identity key and broadcast the transaction
-
-				const disableBroadcasting = process.env.DISABLE_BROADCASTING === "true";
-				if (!disableBroadcasting) {
-					const broadcaster = new V5Broadcaster();
-					await changeResult.tx.broadcast(broadcaster);
-
-					// 8. Refresh the wallet's UTXOs after spending
-					try {
-						await wallet.refreshUtxos();
-					} catch (refreshError) {
-						console.warn(
-							"Failed to refresh UTXOs after transaction:",
-							refreshError,
-						);
-					}
-
-					// 9. Return transaction details
+			try {
+				const result = await inscribe.execute(ctx, {
+					base64Content: dataB64,
+					contentType,
+					map: metadata,
+					signWithBAP,
+				})
+
+				if (result.error) {
 					return {
-						content: [
-							{
-								type: "text",
-								text: JSON.stringify({
-									txid: changeResult.tx.id("hex"),
-									spentOutpoints: changeResult.spentOutpoints,
-									payChange: changeResult.payChange,
-									inscriptionAddress: destinationAddress || walletAddress,
-									contentType: contentType,
-								}),
-							},
-						],
-					};
+						content: [{ type: 'text', text: result.error }],
+						isError: true,
+					}
 				}
 
 				return {
 					content: [
 						{
-							type: "text",
-							text: changeResult.tx.toHex(),
+							type: 'text',
+							text: JSON.stringify({
+								txid: result.txid,
+								rawtx: result.rawtx,
+								contentType,
+							}),
 						},
 					],
-				};
+				}
 			} catch (err: unknown) {
-				const msg = err instanceof Error ? err.message : String(err);
-				return { content: [{ type: "text", text: msg }], isError: true };
+				return {
+					content: [
+						{
+							type: 'text',
+							text: err instanceof Error ? err.message : String(err),
+						},
+					],
+					isError: true,
+				}
 			}
 		},
-	);
+	)
 }

package/tools/wallet/getAddress.ts

@@ -1,34 +1,40 @@
+import {
+	deriveDepositAddresses,
+	type OneSatContext,
+} from "@1sat/actions";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { Wallet } from "./wallet";
+
+const MCP_ADDRESS_PREFIX = "mcp";
 
 /**
- * Register the tool to get the wallet address
- * @param server The MCP server instance
- * @param wallet The initialized custom Wallet instance
+ * Register the tool to get the wallet's BRC-29 deposit address
  */
 export function registerGetAddressTool(
 	server: McpServer,
-	wallet: Wallet,
+	ctx?: OneSatContext,
 ): void {
 	server.tool(
 		"wallet_getAddress",
-		"Retrieves the current wallet's Bitcoin SV address. This address can be used to receive BSV, ordinals, or tokens, and is derived from the wallet's private key.",
+		"Retrieves the wallet's BRC-29 deposit address derived for MCP. This address can receive BSV, ordinals, or tokens via external payments.",
 		{},
 		async () => {
 			try {
-				const address = wallet.getAddress();
-
-				if (!address) {
-					throw new Error(
-						"Could not retrieve address from wallet instance. Key might be missing or getAddress method failed.",
-					);
+				if (!ctx) {
+					throw new Error("BRC-100 wallet context not available");
 				}
 
+				const { derivations } = await deriveDepositAddresses.execute(ctx, {
+					prefix: MCP_ADDRESS_PREFIX,
+				});
+
 				return {
 					content: [
 						{
 							type: "text",
-							text: JSON.stringify({ address, status: "ok" }),
+							text: JSON.stringify({
+								address: derivations[0].address,
+								status: "ok",
+							}),
 						},
 					],
 				};

package/tools/wallet/getBalance.ts

@@ -1,54 +1,58 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { toBitcoin } from "satoshi-token"; // For converting satoshis to BSV string
-import type { Wallet } from "./wallet";
+import type { OneSatContext } from '@1sat/actions'
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { toBitcoin } from 'satoshi-token'
 
-/**
- * Registers the wallet_getBalance tool
- */
 export function registerWalletGetBalanceTool(
 	server: McpServer,
-	wallet: Wallet,
+	ctx: OneSatContext | undefined,
 ) {
 	server.tool(
-		"wallet_getBalance",
-		"Retrieves the current BSV balance for the wallet based on its UTXOs.",
+		'wallet_getBalance',
+		'Retrieves the current BSV balance for the wallet.',
 		{},
 		async () => {
-			try {
-				const { paymentUtxos } = await wallet.getUtxos();
-
-				let totalSatoshis = 0;
-				if (paymentUtxos && paymentUtxos.length > 0) {
-					for (const utxo of paymentUtxos) {
-						totalSatoshis += utxo.satoshis || 0;
-					}
+			if (!ctx) {
+				return {
+					content: [
+						{
+							type: 'text',
+							text: 'Wallet not initialized. Please configure a wallet before checking balance.',
+						},
+					],
+					isError: true,
 				}
+			}
 
-				const bsvAmount = toBitcoin(totalSatoshis); // Convert to BSV string
+			try {
+				const result = await ctx.wallet.listOutputs({ basket: 'default' })
+				const totalSatoshis = result.outputs.reduce(
+					(sum, output) => sum + output.satoshis,
+					0,
+				)
 
 				return {
 					content: [
 						{
-							type: "text",
+							type: 'text',
 							text: JSON.stringify({
 								satoshis: totalSatoshis,
-								bsv: bsvAmount,
-								utxoCount: paymentUtxos ? paymentUtxos.length : 0,
+								bsv: toBitcoin(totalSatoshis),
+								utxoCount: result.totalOutputs,
 							}),
 						},
 					],
-				};
+				}
 			} catch (error) {
 				return {
 					content: [
 						{
-							type: "text",
+							type: 'text',
 							text: error instanceof Error ? error.message : String(error),
 						},
 					],
 					isError: true,
-				};
+				}
 			}
 		},
-	);
+	)
 }

package/tools/wallet/getBsv21Balances.ts

@@ -0,0 +1,28 @@
+import { getBsv21Balances, type OneSatContext } from '@1sat/actions'
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+
+export function registerGetBsv21BalancesTool(
+	server: McpServer,
+	ctx?: OneSatContext,
+) {
+	server.tool(
+		'wallet_getBsv21Balances',
+		'Get aggregated BSV21 token balances grouped by token ID',
+		{},
+		async () => {
+			try {
+				if (!ctx) throw new Error('BRC-100 wallet context not available')
+				const result = await getBsv21Balances.execute(ctx, {})
+				return {
+					content: [{
+						type: 'text',
+						text: JSON.stringify(result, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2),
+					}],
+				}
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err)
+				return { content: [{ type: 'text', text: msg }], isError: true }
+			}
+		},
+	)
+}

package/tools/wallet/getLockData.ts

@@ -0,0 +1,25 @@
+import { getLockData, type OneSatContext } from '@1sat/actions'
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+
+export function registerGetLockDataTool(
+	server: McpServer,
+	ctx?: OneSatContext,
+) {
+	server.tool(
+		'wallet_getLockData',
+		'Get summary of time-locked BSV (total, unlockable, next unlock height)',
+		{},
+		async () => {
+			try {
+				if (!ctx) throw new Error('BRC-100 wallet context not available')
+				const result = await getLockData.execute(ctx, {})
+				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/getOrdinals.ts

@@ -0,0 +1,35 @@
+import { getOrdinals, type OneSatContext } from '@1sat/actions'
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { z } from 'zod'
+
+export function registerGetOrdinalsTool(
+	server: McpServer,
+	ctx?: OneSatContext,
+) {
+	server.tool(
+		'wallet_getOrdinals',
+		'List ordinals/inscriptions in the wallet with metadata',
+		{
+			limit: z.number().int().optional().describe('Max number of results to return'),
+			offset: z.number().int().optional().describe('Number of results to skip'),
+		},
+		async (params) => {
+			try {
+				if (!ctx) throw new Error('BRC-100 wallet context not available')
+				const result = await getOrdinals.execute(ctx, params)
+				const outputs = result.outputs.map((o: any) => ({
+					outpoint: o.outpoint,
+					satoshis: o.satoshis,
+					tags: o.tags,
+					customInstructions: o.customInstructions,
+				}))
+				return {
+					content: [{ type: 'text', text: JSON.stringify(outputs, 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/listOrdinal.ts

@@ -0,0 +1,86 @@
+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(),
+})
+
+const listOrdinalArgsSchema = z.object({
+	ordinal: walletOutputSchema.describe(
+		'WalletOutput of the ordinal to list (from wallet_getOrdinals)',
+	),
+	inputBEEF: z
+		.array(z.number())
+		.describe(
+			"BEEF bytes from listOutputs (include: 'entire transactions')",
+		),
+	price: z.number().describe('Price in satoshis'),
+	payAddress: z
+		.string()
+		.describe('Address to receive payment on purchase'),
+})
+
+export function registerListOrdinalTool(
+	server: McpServer,
+	ctx: OneSatContext | undefined,
+) {
+	server.tool(
+		'wallet_listOrdinal',
+		'List an ordinal for sale on the marketplace',
+		{ ...listOrdinalArgsSchema.shape },
+		async ({ ordinal, inputBEEF, price, payAddress }) => {
+			if (!ctx) {
+				return {
+					content: [
+						{
+							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,
+					price,
+					payAddress,
+				})
+
+				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/listTokens.ts

@@ -0,0 +1,28 @@
+import { listTokens, 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,
+) {
+	server.tool(
+		'wallet_listTokens',
+		'List BSV21 token outputs in the wallet',
+		{
+			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)
+				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/lockBsv.ts

@@ -0,0 +1,69 @@
+import type { OneSatContext } from '@1sat/actions'
+import { lockBsv } from '@1sat/actions'
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { z } from 'zod'
+
+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'),
+			}),
+		)
+		.describe('Array of lock requests'),
+})
+
+export function registerLockBsvTool(
+	server: McpServer,
+	ctx: OneSatContext | undefined,
+) {
+	server.tool(
+		'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.',
+						},
+					],
+					isError: true,
+				}
+			}
+
+			try {
+				const result = await lockBsv.execute(ctx, { requests })
+
+				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,
+				}
+			}
+		},
+	)
+}