bsv-mcp 0.2.9 → 0.2.10

package/tools/wallet/purchaseListing.ts

@@ -1,326 +1,125 @@
-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,
-	type ExistingListing,
-	type LocalSigner,
-	oneSatBroadcaster,
-	type Payment,
-	type PurchaseOrdListingConfig,
-	purchaseOrdListing,
-	purchaseOrdTokenListing,
-	type Royalty,
-	TokenType,
-	type TokenUtxo,
-	type Utxo,
-} from "js-1sat-ord";
+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 {
 	MARKET_FEE_PERCENTAGE,
 	MARKET_WALLET_ADDRESS,
 	MINIMUM_MARKET_FEE_SATOSHIS,
-} from "../constants";
-import { purchaseListingArgsSchema } from "./schemas";
-import type { Wallet } from "./wallet";
-
-// Define types for 1Sat API response
-interface OrdUtxo {
-	txid: string;
-	vout: number;
-	satoshis: number;
-	script: string;
-	origin?: {
-		outpoint: string;
-		data?: {
-			map?: {
-				royalties?: string;
-				[key: string]: string | number | boolean | null | undefined;
-			};
-			insc?: {
-				text?: string;
-				file?: {
-					type?: string;
-					size?: number;
-				};
-			};
-		};
-	};
-	data?: {
-		list?: {
-			price: number;
-			payout: string;
-		};
-		bsv20?: {
-			amt?: string;
-			tick?: string;
-			id?: string;
-		};
-	};
-}
-
-/**
- * Register the purchaseListing tool
- *
- * This tool enables purchasing listed ordinals (NFTs or tokens) from the marketplace:
- * 1. Parses the listing outpoint to get the txid and vout
- * 2. Fetches the listing UTXO from the ordinals API
- * 3. Gets the wallet's payment UTXOs (using the wallet's internal UTXO management)
- * 4. Uses purchaseOrdListing or purchaseOrdTokenListing based on the listing type
- * 5. For NFTs, automatically detects and processes royalty payments to original creators
- * 6. Broadcasts the transaction
- * 7. Returns the transaction details including success status and txid
- *
- * The tool supports both NFT and token listings with appropriate type-specific handling.
- * Royalty payments are supported for NFT purchases only (based on creator-defined metadata).
- */
-export function registerPurchaseListingTool(server: McpServer, wallet: Wallet) {
-	// Store a reference to check if wallet is persistent
+} from '../constants'
+import { purchaseListingArgsSchema } from './schemas'
 
+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 (with royalty payments to original creators) and BSV-20/BSV-21 token purchases. The tool handles all aspects of the transaction - from fetching listing details, calculating fees, creating and broadcasting the transaction.",
+		'wallet_purchaseListing',
+		'Purchases a listing from the Bitcoin SV ordinals marketplace. Supports both NFT purchases and BSV21 token purchases.',
 		{ ...purchaseListingArgsSchema.shape },
-		async ({ listingOutpoint, ordAddress, listingType, tokenProtocol, tokenID, description }): 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,
-						);
-					}
-				}
-
-				// Fetch the listing info directly from the API
-				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}`,
-					);
-				}
-
-				const listingData = (await response.json()) as OrdUtxo;
-
-				// Check if the listing is valid and has a price
-				if (!listingData.data?.list?.price) {
-					throw new Error("Listing is either not for sale or invalid");
-				}
-
-				// Check if payout is available
-				if (!listingData.data.list.payout) {
-					throw new Error("Listing doesn't have payout information");
-				}
-
-				// Calculate the market fee (3% of listing price)
-				const listingPrice = listingData.data.list.price;
-				let marketFee = Math.round(listingPrice * MARKET_FEE_PERCENTAGE);
-
-				// Ensure minimum fee
-				if (marketFee < MINIMUM_MARKET_FEE_SATOSHIS) {
-					marketFee = MINIMUM_MARKET_FEE_SATOSHIS;
-				}
-
-				// Parse the listing outpoint to get txid and vout
-				const [txid, voutStr] = listingOutpoint.split("_");
-				if (!txid) {
-					throw new Error("Invalid outpoint format. Expected txid_vout");
-				}
-				const vout = Number.parseInt(voutStr || "0", 10);
-
-				// Get private key from the wallet
-				const paymentPk = wallet.getPrivateKey();
-				if (!paymentPk) {
-					throw new Error("No private key available in wallet");
-				}
-
-				// Get payment address
-				const paymentAddress = paymentPk.toAddress().toString();
-
-				// Get payment UTXOs from the wallet's managed UTXOs
-				const { paymentUtxos } = await wallet.getUtxos();
-				if (!paymentUtxos || paymentUtxos.length === 0) {
-					// Provide more helpful error message with instructions
-					throw new Error(
-						`No payment UTXOs available for address ${paymentAddress}. 
-Please fund this wallet address with enough BSV to cover the purchase price 
-(${listingData.data.list.price} satoshis) plus market fee (${marketFee} satoshis) and transaction fees.`,
-					);
+		async ({ listingOutpoint, listingType, tokenID, tokenAmount, description }): Promise<CallToolResult> => {
+			if (!ctx) {
+				return {
+					content: [
+						{
+							type: 'text',
+							text: 'Wallet not initialized. Please configure a wallet before purchasing.',
+						},
+					],
+					isError: true,
 				}
+			}
 
-				// Define market fee payment
-				const additionalPayments: Payment[] = [
-					{
-						to: MARKET_WALLET_ADDRESS,
-						amount: marketFee,
-					},
-				];
-
-				// Define metadata for the transaction
-				const metaData = {
-					app: "bsv-mcp",
-					type: "ord",
-					op: "purchase",
-				};
-
-				// Create the purchase transaction based on listing type
-				let transaction: ChangeResult;
-
-				if (listingType === "token") {
-					if (!tokenProtocol) {
-						throw new Error("tokenProtocol is required for token listings");
-					}
+			try {
+				let marketplaceRate = MARKET_FEE_PERCENTAGE
 
+				if (listingType === 'token') {
 					if (!tokenID) {
-						throw new Error("tokenID is required for token listings");
+						throw new Error('tokenID is required for token listings')
 					}
 
-					// Validate token data from the listing
-					if (!listingData.data.bsv20) {
-						throw new Error("This is not a valid BSV-20 token listing");
-					}
+					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}`)
+						}
+						const listingData = (await response.json()) as {
+							data?: { list?: { price: number }; bsv20?: { amt?: string } }
+						}
+						if (!listingData.data?.bsv20?.amt) {
+							throw new Error('Token listing does not have an amount')
+						}
+						tokenAmount = listingData.data.bsv20.amt
 
-					// For BSV-20, the amount should be included in the listing data
-					if (!listingData.data.bsv20.amt) {
-						throw new Error("Token listing doesn't have an amount specified");
+						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
+						}
 					}
 
-					// Convert the token protocol to the enum type expected by js-1sat-ord
-					const protocol =
-						tokenProtocol === "bsv-20" ? TokenType.BSV20 : TokenType.BSV21;
-
-					// Create a TokenUtxo with the required fields
-					const listingUtxo: TokenUtxo = {
-						txid,
-						vout,
-						script: listingData.script,
-						satoshis: 1, // TokenUtxo's satoshis must be exactly 1
-						amt: listingData.data.bsv20.amt,
-						id: tokenID,
-						payout: listingData.data.list.payout,
-					};
-
-					transaction = await purchaseOrdTokenListing({
-						protocol,
-						tokenID: tokenID,
-						utxos: paymentUtxos,
-						paymentPk,
-						listingUtxo,
-						ordAddress: ordAddress,
-						additionalPayments,
-						metaData,
-					});
-				} else {
-					// Create a regular Utxo for NFT listing
-					const listingUtxo: Utxo = {
-						txid,
-						vout,
-						script: listingData.script,
-						satoshis: listingData.satoshis,
-					};
-
-					// Create the ExistingListing object for NFT listings
-					const listing: ExistingListing = {
-						payout: listingData.data.list.payout,
-						listingUtxo,
-					};
-
-					// Check for royalties in the NFT origin data
-					// Royalties are only supported for NFTs, not for tokens
-					// The royalties are defined by the original creator as a JSON string
-					// in the NFT's metadata and parsed into a Royalty[] array
-					let royalties: Royalty[] = [];
-					if (listingData.origin?.data?.map?.royalties) {
-						try {
-							royalties = JSON.parse(listingData.origin.data.map.royalties);
-						} catch (error) {
-							// Remove console.warn
+					const result = await purchaseBsv21.execute(ctx, {
+						tokenId: tokenID,
+						outpoint: listingOutpoint,
+						amount: tokenAmount,
+						marketplaceAddress: MARKET_WALLET_ADDRESS,
+						marketplaceRate,
+					})
+
+					if (result.error) {
+						return {
+							content: [{ type: 'text', text: result.error }],
+							isError: true,
 						}
 					}
 
-					const purchaseOrdListingConfig: PurchaseOrdListingConfig = {
-						utxos: paymentUtxos,
-						paymentPk,
-						ordAddress: ordAddress,
-						listing,
-						additionalPayments,
-						metaData,
-						royalties,
-					};
-
-					transaction = await purchaseOrdListing(purchaseOrdListingConfig);
-				}
-
-				// After successful transaction creation, refresh the wallet's UTXOs
-				// This ensures the wallet doesn't try to reuse spent UTXOs
-				try {
-					await wallet.refreshUtxos();
-				} catch (refreshError) {
-					// Remove console.warn
-				}
-
-				// Optionally sign with identity key then broadcast the transaction
-
-				const disableBroadcasting = process.env.DISABLE_BROADCASTING === "true";
-				if (!disableBroadcasting) {
-					const broadcastResult = await transaction.tx.broadcast(
-						oneSatBroadcaster(),
-					);
-					// Handle broadcast response
-					const resultStatus =
-						typeof broadcastResult === "object" && "status" in broadcastResult
-							? broadcastResult.status
-							: "unknown";
-
-					const resultMessage =
-						typeof broadcastResult === "object" && "error" in broadcastResult
-							? broadcastResult.error
-							: "Transaction broadcast successful";
-
 					return {
 						content: [
 							{
-								type: "text",
+								type: 'text',
 								text: JSON.stringify({
-									status: resultStatus,
-									message: resultMessage,
-									txid: transaction.tx.id("hex"),
-									listingOutpoint: listingOutpoint,
-									destinationAddress: ordAddress,
-									listingType: listingType,
-									tokenProtocol: tokenID ? tokenProtocol : undefined,
-									tokenID: tokenID,
-									price: listingData.data.list.price,
-									marketFee,
-									marketFeeAddress: MARKET_WALLET_ADDRESS,
-									royaltiesPaid:
-										listingType === "nft" &&
-										listingData.origin?.data?.map?.royalties
-											? JSON.parse(listingData.origin.data.map.royalties)
-											: undefined,
+									status: 'success',
+									txid: result.txid,
+									listingOutpoint,
+									listingType,
+									tokenID,
 								}),
 							},
 						],
-					};
+					}
 				}
+
+				const result = await purchaseOrdinal.execute(ctx, {
+					outpoint: listingOutpoint,
+					marketplaceAddress: MARKET_WALLET_ADDRESS,
+					marketplaceRate,
+				})
+
+				if (result.error) {
+					return {
+						content: [{ type: 'text', text: result.error }],
+						isError: true,
+					}
+				}
+
 				return {
 					content: [
 						{
-							type: "text",
-							text: transaction.tx.toHex(),
+							type: 'text',
+							text: JSON.stringify({
+								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/schemas.ts

@@ -64,27 +64,23 @@ export const purchaseListingArgsSchema = z
 		listingOutpoint: z
 			.string()
 			.describe("The outpoint of the listing to purchase (txid_vout format)"),
-		ordAddress: z
-			.string()
-			.describe("The ordinal address to receive the purchased item"),
 		listingType: z
 			.enum(["nft", "token"])
 			.default("nft")
 			.describe(
-				"Type of listing: 'nft' for ordinal NFTs, 'token' for BSV-20 tokens",
+				"Type of listing: 'nft' for ordinal NFTs, 'token' for BSV21 tokens",
 			),
-		tokenProtocol: z
-			.enum(["bsv-20", "bsv-21"])
+		tokenID: z
+			.string()
 			.optional()
-			.default("bsv-21")
 			.describe(
-				"Token protocol for token listings (required when listingType is 'token')",
+				"Token ID (txid_vout of deploy transaction) — required when listingType is 'token'",
 			),
-		tokenID: z
+		tokenAmount: z
 			.string()
 			.optional()
 			.describe(
-				"Token ID for BSV-21 tokens or ticker for BSV-20 tokens (required when listingType is 'token')",
+				"Amount of tokens in the listing (as string) — required when listingType is 'token'",
 			),
 		description: z
 			.string()
@@ -92,7 +88,7 @@ export const purchaseListingArgsSchema = z
 			.describe("Optional description for the transaction"),
 	})
 	.describe(
-		"Schema for the wallet_purchaseListing tool arguments (purchase NFTs or tokens), with detailed field descriptions.",
+		"Schema for the wallet_purchaseListing tool arguments (purchase NFTs or BSV21 tokens).",
 	);
 
 // Export types

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,
-				};
+				}
 			}
 		},
-	);
+	)
 }