bsv-mcp 0.0.36 → 0.2.7

package/tools/wallet/mintCollection.ts

@@ -0,0 +1,373 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { Utils } from "@bsv/sdk";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type {
+	ChangeResult,
+	CollectionItemSubTypeData,
+	CollectionSubTypeData,
+	CollectionTraits,
+	CreateOrdinalsCollectionItemMetadata,
+	CreateOrdinalsCollectionMetadata,
+	CreateOrdinalsConfig,
+	LocalSigner,
+	RarityLabels,
+} from "js-1sat-ord";
+import { createOrdinals } from "js-1sat-ord";
+import { z } from "zod";
+import { V5Broadcaster } from "../../utils/broadcaster";
+import type { Wallet } from "./wallet";
+
+const mintCollectionArgsSchema = z.object({
+	folderPath: z
+		.string()
+		.describe("Path to folder containing images to mint as a collection"),
+	collectionName: z.string().describe("Name of the collection"),
+	description: z.string().describe("Description of the collection"),
+	rarityLabels: z
+		.array(
+			z.object({
+				label: z.string(),
+				percentage: z.number().min(0).max(100),
+			}),
+		)
+		.optional()
+		.describe("Rarity labels and their percentages"),
+	traits: z
+		.record(z.array(z.string()))
+		.optional()
+		.describe(
+			"Collection traits as key-value pairs where values are arrays of possible trait values",
+		),
+	skipBroadcast: z
+		.boolean()
+		.optional()
+		.describe("Skip broadcasting transactions (for testing)"),
+});
+
+type MintCollectionArgs = z.infer<typeof mintCollectionArgsSchema>;
+
+interface ImageFile {
+	path: string;
+	name: string;
+	data: Uint8Array;
+	contentType: string;
+}
+
+async function getImageFiles(folderPath: string): Promise<ImageFile[]> {
+	const files = await fs.readdir(folderPath);
+	const imageFiles: ImageFile[] = [];
+
+	const imageExtensions = [".jpg", ".jpeg", ".png", ".gif", ".webp", ".svg"];
+
+	for (const file of files) {
+		const filePath = path.join(folderPath, file);
+		const stat = await fs.stat(filePath);
+
+		if (stat.isFile()) {
+			const ext = path.extname(file).toLowerCase();
+			if (imageExtensions.includes(ext)) {
+				const data = await fs.readFile(filePath);
+				const contentType =
+					{
+						".jpg": "image/jpeg",
+						".jpeg": "image/jpeg",
+						".png": "image/png",
+						".gif": "image/gif",
+						".webp": "image/webp",
+						".svg": "image/svg+xml",
+					}[ext] || "application/octet-stream";
+
+				imageFiles.push({
+					path: filePath,
+					name: path.basename(file, ext),
+					data,
+					contentType,
+				});
+			}
+		}
+	}
+
+	return imageFiles.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function generateItemTraits(
+	itemIndex: number,
+	collectionTraits?: Record<string, string[]>,
+): Array<{ name: string; value: string }> {
+	const traits: Array<{ name: string; value: string }> = [];
+
+	if (collectionTraits) {
+		// Distribute traits across items deterministically
+		for (const [traitName, possibleValues] of Object.entries(
+			collectionTraits,
+		)) {
+			if (possibleValues.length > 0) {
+				const valueIndex = itemIndex % possibleValues.length;
+				traits.push({
+					name: traitName as string, // Object.entries always produces string keys
+					value: possibleValues[valueIndex],
+				});
+			}
+		}
+	}
+
+	return traits;
+}
+
+export function registerMintCollectionTool(server: McpServer, wallet: Wallet) {
+	server.tool(
+		"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, skipBroadcast }): Promise<CallToolResult> => {
+			try {
+				// Get keys from wallet
+				const paymentPk = wallet.getPaymentKey();
+				if (!paymentPk) {
+					throw new Error("No payment key available in wallet");
+				}
+				const identityPk = wallet.getIdentityKey();
+
+				// Get image files
+				const imageFiles = await getImageFiles(folderPath);
+				if (imageFiles.length === 0) {
+					throw new Error("No image files found in the specified folder");
+				}
+
+				console.error(`Found ${imageFiles.length} images to mint`);
+
+				// Prepare collection metadata
+				const collectionSubTypeData: CollectionSubTypeData = {
+					description: description,
+					quantity: imageFiles.length,
+					// Transform rarity labels to correct format
+					rarityLabels:
+						rarityLabels?.map((r) => ({ label: r.label })) || [],
+					// Transform traits - need to match the CollectionTraits type
+					traits: traits
+						? Object.entries(traits).reduce((acc, [key, values]) => {
+								acc[key] = {
+									values,
+									occurancePercentages: values.map(() =>
+										String(100 / values.length),
+									),
+								};
+								return acc;
+							}, {} as CollectionTraits)
+						: {},
+				};
+
+				const collectionMetadata: CreateOrdinalsCollectionMetadata = {
+					app: "ord",
+					type: "ord",
+					subType: "collection",
+					name: collectionName,
+					subTypeData: collectionSubTypeData,
+				};
+
+				// Create collection icon
+				const svgString = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+            <rect width="100" height="100" fill="#f0f0f0"/>
+            <text x="50" y="55" text-anchor="middle" font-family="Arial" font-size="16">${collectionName}</text>
+          </svg>`;
+				const collectionIconData = Utils.toBase64(
+					Utils.toArray(svgString, "utf8"),
+				);
+
+				const walletAddress = paymentPk.toAddress().toString();
+
+				// Get UTXOs for collection
+				const { paymentUtxos: collectionUtxos } = await wallet.getUtxos();
+				if (!collectionUtxos || collectionUtxos.length === 0) {
+					throw new Error("No payment UTXOs available");
+				}
+
+				// Create collection config
+				const collectionConfig: CreateOrdinalsConfig = {
+					utxos: collectionUtxos,
+					destinations: [
+						{
+							address: walletAddress,
+							inscription: {
+								dataB64: collectionIconData,
+								contentType: "image/svg+xml",
+							},
+						},
+					],
+					paymentPk,
+					changeAddress: walletAddress,
+					metaData: collectionMetadata,
+				};
+
+				if (identityPk) {
+					collectionConfig.signer = { idKey: identityPk } as LocalSigner;
+				}
+
+				console.error("Creating collection inscription...");
+				const collectionResult = (await createOrdinals(
+					collectionConfig,
+				)) as ChangeResult;
+
+				let collectionTxid = "";
+				const disableBroadcasting =
+					skipBroadcast || process.env.DISABLE_BROADCASTING === "true";
+
+				if (!disableBroadcasting) {
+					const broadcaster = new V5Broadcaster();
+					await collectionResult.tx.broadcast(broadcaster);
+					collectionTxid = collectionResult.tx.id("hex");
+					console.error(`✅ Collection created: ${collectionTxid}`);
+
+					// Refresh UTXOs after spending
+					await wallet.refreshUtxos();
+				} else {
+					collectionTxid = collectionResult.tx.id("hex");
+					console.error(
+						`🔸 Collection created (not broadcast): ${collectionTxid}`,
+					);
+				}
+
+				// Mint collection items
+				const results = {
+					collectionTxid,
+					itemTxids: [] as string[],
+					errors: [] as Array<{ file: string; error: string }>,
+					totalCost: collectionResult.tx.getFee(),
+				};
+
+				for (let i = 0; i < imageFiles.length; i++) {
+					const imageFile = imageFiles[i];
+					if (!imageFile) continue;
+
+					console.error(
+						`Minting item ${i + 1}/${imageFiles.length}: ${imageFile.name}`,
+					);
+
+					try {
+						const itemTraits = generateItemTraits(i, traits);
+
+						const itemSubTypeData: CollectionItemSubTypeData = {
+							collectionId: collectionTxid,
+							mintNumber: i + 1,
+							traits: itemTraits,
+						};
+
+						// Assign rarity if labels provided
+						if (rarityLabels && rarityLabels.length > 0) {
+							const rarityIndex = Math.floor(
+								(i / imageFiles.length) * rarityLabels.length,
+							);
+							const rarityItem =
+								rarityLabels[
+									Math.min(rarityIndex, rarityLabels.length - 1)
+								];
+							if (rarityItem) {
+								itemSubTypeData.rarityLabel = [
+									{ [rarityItem.label]: `${rarityItem.percentage}%` },
+								];
+							}
+						}
+
+						const itemMetadata: CreateOrdinalsCollectionItemMetadata = {
+							app: "ord",
+							type: "ord",
+							subType: "collectionItem",
+							name: imageFile.name,
+							subTypeData: itemSubTypeData,
+						};
+
+						// Get fresh UTXOs for each item
+						const { paymentUtxos: itemUtxos } = await wallet.getUtxos();
+						if (!itemUtxos || itemUtxos.length === 0) {
+							throw new Error("No payment UTXOs available for item");
+						}
+
+						const itemConfig: CreateOrdinalsConfig = {
+							utxos: itemUtxos,
+							destinations: [
+								{
+									address: walletAddress,
+									inscription: {
+										dataB64: Utils.toBase64(Array.from(imageFile.data)),
+										contentType: imageFile.contentType,
+									},
+								},
+							],
+							paymentPk,
+							changeAddress: walletAddress,
+							metaData: itemMetadata,
+						};
+
+						if (identityPk) {
+							itemConfig.signer = { idKey: identityPk } as LocalSigner;
+						}
+
+						const itemResult = (await createOrdinals(
+							itemConfig,
+						)) as ChangeResult;
+
+						if (!disableBroadcasting) {
+							const broadcaster = new V5Broadcaster();
+							await itemResult.tx.broadcast(broadcaster);
+							const itemTxid = itemResult.tx.id("hex");
+							results.itemTxids.push(itemTxid);
+							console.error(`  ✅ Item minted: ${itemTxid}`);
+
+							// Refresh UTXOs after each item
+							await wallet.refreshUtxos();
+						} else {
+							const itemTxid = itemResult.tx.id("hex");
+							results.itemTxids.push(itemTxid);
+							console.error(`  🔸 Item minted (not broadcast): ${itemTxid}`);
+						}
+
+						results.totalCost += itemResult.tx.getFee();
+					} catch (error) {
+						const errorMessage =
+							error instanceof Error ? error.message : String(error);
+						results.errors.push({ file: imageFile.name, error: errorMessage });
+						console.error(
+							`  ❌ Failed to mint ${imageFile.name}: ${errorMessage}`,
+						);
+					}
+				}
+
+				// Return results
+				return {
+					content: [
+						{
+							type: "text",
+							text: JSON.stringify(
+								{
+									success: true,
+									collectionTxid: results.collectionTxid,
+									itemsMinted: results.itemTxids.length,
+									totalItems: imageFiles.length,
+									errors: results.errors,
+									totalCost: results.totalCost,
+									summary: `Collection "${collectionName}" created with ${results.itemTxids.length}/${imageFiles.length} items successfully minted.${results.errors.length > 0 ? ` ${results.errors.length} items failed.` : ""}`,
+								},
+								null,
+								2,
+							),
+						},
+					],
+				};
+			} catch (error) {
+				const errorMessage =
+					error instanceof Error ? error.message : String(error);
+				return {
+					content: [
+						{
+							type: "text",
+							text: `Error minting collection: ${errorMessage}`,
+						},
+					],
+					isError: true,
+				};
+			}
+		},
+	);
+}

package/tools/wallet/purchaseListing.ts

@@ -1,27 +1,20 @@
 import { PrivateKey } from "@bsv/sdk";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import type {
-	ServerNotification,
-	ServerRequest,
-} from "@modelcontextprotocol/sdk/types.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,
-	oneSatBroadcaster,
-	purchaseOrdListing,
-	purchaseOrdTokenListing,
 } from "js-1sat-ord";
-import { Sigma } from "sigma-protocol";
-import type { z } from "zod";
 import {
 	MARKET_FEE_PERCENTAGE,
 	MARKET_WALLET_ADDRESS,
@@ -86,11 +79,8 @@ export function registerPurchaseListingTool(server: McpServer, wallet: Wallet) {
 	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.",
-		{ args: purchaseListingArgsSchema },
-		async (
-			{ args }: { args: z.infer<typeof purchaseListingArgsSchema> },
-			extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
-		): Promise<CallToolResult> => {
+		{ ...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;
@@ -108,7 +98,7 @@ export function registerPurchaseListingTool(server: McpServer, wallet: Wallet) {
 
 				// Fetch the listing info directly from the API
 				const response = await fetch(
-					`https://ordinals.gorillapool.io/api/txos/${args.listingOutpoint}?script=true`,
+					`https://ordinals.gorillapool.io/api/txos/${listingOutpoint}?script=true`,
 				);
 				if (!response.ok) {
 					throw new Error(
@@ -138,7 +128,7 @@ export function registerPurchaseListingTool(server: McpServer, wallet: Wallet) {
 				}
 
 				// Parse the listing outpoint to get txid and vout
-				const [txid, voutStr] = args.listingOutpoint.split("_");
+				const [txid, voutStr] = listingOutpoint.split("_");
 				if (!txid) {
 					throw new Error("Invalid outpoint format. Expected txid_vout");
 				}
@@ -182,12 +172,12 @@ Please fund this wallet address with enough BSV to cover the purchase price
 				// Create the purchase transaction based on listing type
 				let transaction: ChangeResult;
 
-				if (args.listingType === "token") {
-					if (!args.tokenProtocol) {
+				if (listingType === "token") {
+					if (!tokenProtocol) {
 						throw new Error("tokenProtocol is required for token listings");
 					}
 
-					if (!args.tokenID) {
+					if (!tokenID) {
 						throw new Error("tokenID is required for token listings");
 					}
 
@@ -203,7 +193,7 @@ Please fund this wallet address with enough BSV to cover the purchase price
 
 					// Convert the token protocol to the enum type expected by js-1sat-ord
 					const protocol =
-						args.tokenProtocol === "bsv-20" ? TokenType.BSV20 : TokenType.BSV21;
+						tokenProtocol === "bsv-20" ? TokenType.BSV20 : TokenType.BSV21;
 
 					// Create a TokenUtxo with the required fields
 					const listingUtxo: TokenUtxo = {
@@ -212,17 +202,17 @@ Please fund this wallet address with enough BSV to cover the purchase price
 						script: listingData.script,
 						satoshis: 1, // TokenUtxo's satoshis must be exactly 1
 						amt: listingData.data.bsv20.amt,
-						id: args.tokenID,
+						id: tokenID,
 						payout: listingData.data.list.payout,
 					};
 
 					transaction = await purchaseOrdTokenListing({
 						protocol,
-						tokenID: args.tokenID,
+						tokenID: tokenID,
 						utxos: paymentUtxos,
 						paymentPk,
 						listingUtxo,
-						ordAddress: args.ordAddress,
+						ordAddress: ordAddress,
 						additionalPayments,
 						metaData,
 					});
@@ -257,7 +247,7 @@ Please fund this wallet address with enough BSV to cover the purchase price
 					const purchaseOrdListingConfig: PurchaseOrdListingConfig = {
 						utxos: paymentUtxos,
 						paymentPk,
-						ordAddress: args.ordAddress,
+						ordAddress: ordAddress,
 						listing,
 						additionalPayments,
 						metaData,
@@ -301,16 +291,16 @@ Please fund this wallet address with enough BSV to cover the purchase price
 									status: resultStatus,
 									message: resultMessage,
 									txid: transaction.tx.id("hex"),
-									listingOutpoint: args.listingOutpoint,
-									destinationAddress: args.ordAddress,
-									listingType: args.listingType,
-									tokenProtocol: args.tokenID ? args.tokenProtocol : undefined,
-									tokenID: args.tokenID,
+									listingOutpoint: listingOutpoint,
+									destinationAddress: ordAddress,
+									listingType: listingType,
+									tokenProtocol: tokenID ? tokenProtocol : undefined,
+									tokenID: tokenID,
 									price: listingData.data.list.price,
 									marketFee,
 									marketFeeAddress: MARKET_WALLET_ADDRESS,
 									royaltiesPaid:
-										args.listingType === "nft" &&
+										listingType === "nft" &&
 										listingData.origin?.data?.map?.royalties
 											? JSON.parse(listingData.origin.data.map.royalties)
 											: undefined,

package/tools/wallet/refreshUtxos.ts

@@ -1,16 +1,7 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import type {
-	ServerNotification,
-	ServerRequest,
-} from "@modelcontextprotocol/sdk/types.js";
 import { toBitcoin } from "satoshi-token";
-import { z } from "zod";
 import type { Wallet } from "./wallet";
 
-const refreshUtxosArgsSchema = z.object({});
-type RefreshUtxosArgs = z.infer<typeof refreshUtxosArgsSchema>;
-
 /**
  * Registers the wallet_refreshUtxos tool that refreshes and returns the UTXOs for the wallet
  */
@@ -18,11 +9,8 @@ export function registerRefreshUtxosTool(server: McpServer, wallet: Wallet) {
 	server.tool(
 		"wallet_refreshUtxos",
 		"Refreshes and returns the wallet's UTXOs. This is useful for debugging UTXO issues, ensuring the wallet has the latest transaction outputs, and for verifying available funds before making transactions.",
-		{ args: refreshUtxosArgsSchema },
-		async (
-			{ args }: { args: RefreshUtxosArgs },
-			_extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
-		) => {
+		{},
+		async () => {
 			try {
 				// Force refresh the UTXOs
 				await wallet.refreshUtxos();