bsv-mcp 0.0.1 → 0.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 BSV-MCP Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

package/README.md

@@ -1,5 +1,9 @@
 # Bitcoin SV MCP Server
 
+> **⚠️ NOTICE: Experimental Work in Progress**  
+> This project is in an early experimental stage. Features may change, and the API is not yet stable.
+> Contributions, feedback, and bug reports are welcome! Feel free to open issues or submit pull requests.
+
 A collection of Bitcoin SV (BSV) tools for the Model Context Protocol (MCP) framework. This library provides wallet, ordinals, and utility functions for BSV blockchain interaction.
 
 ## Installation
@@ -150,7 +154,8 @@ Wallet tools provide core BSV wallet functionality:
 | `wallet_decrypt` | Decrypts data using a specified protocol and key |
 | `wallet_getAddress` | Returns a BSV address for the current wallet or a derived path |
 | `wallet_sendToAddress` | Sends BSV to a specified address (supports BSV or USD amounts) |
-| `wallet_purchaseListing` | Purchases an NFT from a marketplace listing |
+| `wallet_purchaseListing` | Purchases NFTs or BSV-20/BSV-21 tokens from marketplace listings |
+| `wallet_createOrdinals` | Creates and inscribes ordinals on the BSV blockchain |
 
 ### BSV Tools
 
@@ -169,8 +174,8 @@ Tools for working with ordinals (NFTs) on BSV:
 |-----------|-------------|
 | `ordinals_getInscription` | Retrieves detailed information about a specific inscription |
 | `ordinals_searchInscriptions` | Searches for inscriptions based on various criteria |
-| `ordinals_marketListings` | Retrieves current marketplace listings for inscriptions |
-| `ordinals_bsv20MarketSales` | Gets information about BSV20 token market sales |
+| `ordinals_marketListings` | Retrieves market listings for NFTs, BSV-20, and BSV-21 tokens with unified interface |
+| `ordinals_marketSales` | Gets information about BSV-20 and BSV-21 token market sales |
 | `ordinals_getBsv20ById` | Retrieves details about a specific BSV20 token by ID |
 
 ### Utility Tools
@@ -189,11 +194,15 @@ Once connected, you can use natural language to interact with Bitcoin SV through
 - "Get my Bitcoin SV address"
 - "Send 0.01 BSV to 1ExampleBsvAddressXXXXXXXXXXXXXXXXX"
 - "Send $5 USD worth of BSV to 1ExampleBsvAddressXXXXXXXXXXXXXXXXX"
+- "Purchase this NFT listing: txid_vout"
+- "Purchase this BSV-20 token listing: txid_vout"
 
 ### Ordinals (NFTs)
 - "Show me information about the NFT with outpoint 6a89047af2cfac96da17d51ae8eb62c5f1d982be2bc4ba0d0cd2084b7ffed325_0"
 - "Search for Pixel Zoide NFTs"
 - "Show me the current marketplace listings for BSV NFTs"
+- "Show me BSV-20 token listings for ticker PEPE"
+- "Get recent BSV-20 token sales"
 
 ### Blockchain Operations
 - "What is the current BSV price?"
@@ -228,6 +237,17 @@ tail -n 20 -f ~/Library/Logs/Claude/mcp*.log
 
 For Cursor, check the Cursor MCP logs in Settings → Extensions → Model Context Protocol.
 
+## Recent Updates
+
+### Enhanced Marketplace Tools
+- **Unified Market Listings**: The `ordinals_marketListings` tool now supports NFTs, BSV-20, and BSV-21 tokens through a single interface with appropriate filtering.
+- **Improved Market Sales**: The `ordinals_marketSales` tool (renamed from `ordinals_bsv20MarketSales`) now supports both BSV-20 and BSV-21 token sales.
+- **Token Purchases**: The `wallet_purchaseListing` tool has been enhanced to support purchasing both NFTs and BSV-20/BSV-21 tokens.
+
+### API Refinements
+- Standardized endpoint structure for interactions with the GorillaPool API.
+- Improved parameter handling for different token types and marketplace actions.
+
 ## Development
 
 This project was created using `bun init` in bun v1.2.9. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.
@@ -255,4 +275,4 @@ bun test
 
 ## License
 
-[Include your license information here]
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/index.ts

@@ -1,7 +1,5 @@
 #!/usr/bin/env bun
-import {
-	PrivateKey,
-} from "@bsv/sdk";
+import { PrivateKey } from "@bsv/sdk";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { registerAllTools } from "./tools";
@@ -10,7 +8,7 @@ import { Wallet } from "./tools/wallet/wallet";
 
 const server = new McpServer({
 	name: "Bitcoin SV MCP",
-	version: "1.0.0",
+	version: "0.0.1",
 });
 
 // Singleton wallet instance (for demo, could be replaced with real key management)

package/package.json

@@ -2,7 +2,7 @@
 	"name": "bsv-mcp",
 	"module": "index.ts",
 	"type": "module",
-	"version": "0.0.1",
+	"version": "0.0.3",
 	"bin": {
 		"bsv-mcp": "./index.ts"
 	},

package/tools/constants.ts

@@ -0,0 +1,21 @@
+/**
+ * Constants for BSV MCP Tools
+ */
+
+/**
+ * Market fee percentage applied to all marketplace purchases
+ * Expressed as a decimal (e.g., 0.03 = 3%)
+ */
+export const MARKET_FEE_PERCENTAGE = 0.03;
+
+/**
+ * Market wallet address where fees are sent
+ * This is the recipient address for marketplace fees
+ */
+export const MARKET_WALLET_ADDRESS = "15q8YQSqUa9uTh6gh4AVixxq29xkpBBP9z";
+
+/**
+ * Minimum fee in satoshis
+ * Market fee will never be less than this amount
+ */
+export const MINIMUM_MARKET_FEE_SATOSHIS = 10000; // 10000 satoshis = 0.0001 BSV

package/tools/ordinals/index.ts

@@ -1,8 +1,8 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { registerBsv20MarketSalesTool } from "./bsv20MarketSales";
 import { registerGetBsv20ByIdTool } from "./getBsv20ById";
 import { registerGetInscriptionTool } from "./getInscription";
 import { registerMarketListingsTool } from "./marketListings";
+import { registerMarketSalesTool } from "./marketSales";
 import { registerSearchInscriptionsTool } from "./searchInscriptions";
 
 /**
@@ -14,6 +14,6 @@ export function registerOrdinalsTools(server: McpServer): void {
 	registerGetInscriptionTool(server);
 	registerSearchInscriptionsTool(server);
 	registerMarketListingsTool(server);
-	registerBsv20MarketSalesTool(server);
+	registerMarketSalesTool(server);
 	registerGetBsv20ByIdTool(server);
 }

package/tools/ordinals/marketListings.ts

@@ -2,8 +2,9 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
 import { z } from "zod";
 
-// Schema for market listings arguments
+// Enhanced schema for unified market listings arguments
 export const marketListingsArgsSchema = z.object({
+	// Common parameters
 	limit: z
 		.number()
 		.int()
@@ -12,29 +13,47 @@ export const marketListingsArgsSchema = z.object({
 		.default(20)
 		.describe("Number of results (1-100, default 20)"),
 	offset: z.number().int().min(0).default(0).describe("Pagination offset"),
-	sort: z
-		.enum(["recent", "price", "num"])
-		.default("recent")
-		.describe("Sort method (recent, price, or num)"),
 	dir: z
 		.enum(["asc", "desc"])
 		.default("desc")
 		.describe("Sort direction (asc or desc)"),
 	address: z.string().optional().describe("Bitcoin address"),
+	
+	// NFT-specific parameters
 	origin: z.string().optional().describe("Origin outpoint"),
 	mime: z.string().optional().describe("MIME type filter"),
 	num: z.string().optional().describe("Inscription number"),
+	
+	// General market parameters
 	minPrice: z.number().optional().describe("Minimum price in satoshis"),
 	maxPrice: z.number().optional().describe("Maximum price in satoshis"),
+	
+	// Token-specific parameters
+	tokenType: z
+		.enum(["nft", "bsv20", "bsv21", "all"])
+		.default("all")
+		.describe("Type of token to search for (nft, bsv20, bsv21, or all)"),
+	sort: z
+		.enum(["recent", "price", "num", "height", "price_per_token"])
+		.default("recent")
+		.describe("Sort method (recent, price, num, height, price_per_token)"),
+	bsv20Type: z
+		.enum(["v1", "v2", "all"])
+		.default("all")
+		.optional()
+		.describe("BSV20 token type (v1, v2, or all)"),
+	id: z.string().optional().describe("Token ID in outpoint format"),
+	tick: z.string().optional().describe("Token ticker symbol"),
+	pending: z.boolean().default(false).optional().describe("Include pending sales"),
 });
 
 export type MarketListingsArgs = z.infer<typeof marketListingsArgsSchema>;
 
-// Simplified market listing response type
+// Unified response type that covers all token types
 interface MarketListingResponse {
 	results: Array<{
 		outpoint: string;
-		origin: {
+		origin?: {
 			outpoint: string;
 			data?: {
 				insc?: {
@@ -51,16 +70,26 @@ interface MarketListingResponse {
 				price?: number;
 				payout?: string;
 				sale?: boolean;
+				price_per_token?: number;
+			};
+			bsv20?: {
+				id?: string;
+				tick?: string;
+				sym?: string;
+				amt?: string;
+				op?: string;
 			};
 		};
 		satoshis?: number;
+		height?: number;
 		[key: string]: unknown;
 	}>;
 	total: number;
 }
 
 /**
- * Register the Ordinals market listings tool
+ * Register the unified Ordinals market listings tool
+ * Handles NFTs, BSV20, and BSV21 tokens
  */
 export function registerMarketListingsTool(server: McpServer): void {
 	server.tool(
@@ -84,25 +113,68 @@ export function registerMarketListingsTool(server: McpServer): void {
 					num,
 					minPrice,
 					maxPrice,
+					tokenType,
+					bsv20Type,
+					id,
+					tick,
+					pending,
 				} = args;
 
+				// Determine the API endpoint based on tokenType
+				let baseUrl = "https://ordinals.gorillapool.io/api";
+				let useTokenParams = false;
+				
+				if (tokenType === "bsv20") {
+					baseUrl += "/bsv20/market";
+					useTokenParams = true;
+				} else if (tokenType === "bsv21") {
+					baseUrl += "/bsv21/market"; // Assuming BSV21 endpoint follows similar pattern
+					useTokenParams = true;
+				} else if (tokenType === "nft" || tokenType === "all") {
+					baseUrl += "/market";
+				}
+
 				// Build the URL with query parameters
-				const url = new URL("https://ordinals.gorillapool.io/api/market");
+				const url = new URL(baseUrl);
 				url.searchParams.append("limit", limit.toString());
 				url.searchParams.append("offset", offset.toString());
-				url.searchParams.append("sort", sort);
 				url.searchParams.append("dir", dir);
-
+				
+				// Add sort parameter based on token type
+				if (useTokenParams) {
+					// BSV20/BSV21 specific sort options
+					if (sort === "height" || sort === "price" || sort === "price_per_token") {
+						url.searchParams.append("sort", sort);
+					}
+					// Add token-specific parameters
+					if (bsv20Type && bsv20Type !== "all") {
+						url.searchParams.append("type", bsv20Type);
+					}
+					if (id) url.searchParams.append("id", id);
+					if (tick) url.searchParams.append("tick", tick);
+					if (pending !== undefined) url.searchParams.append("pending", pending.toString());
+					// For BSV20/21, min/max price parameters have slightly different names
+					if (minPrice !== undefined) url.searchParams.append("min_price", minPrice.toString());
+					if (maxPrice !== undefined) url.searchParams.append("max_price", maxPrice.toString());
+				} else {
+					// NFT specific sort options
+					if (sort === "recent" || sort === "price" || sort === "num") {
+						url.searchParams.append("sort", sort);
+					}
+					// Add NFT-specific parameters
+					if (origin) url.searchParams.append("origin", origin);
+					if (mime) url.searchParams.append("mime", mime);
+					if (num) url.searchParams.append("num", num);
+					// For NFTs, min/max price parameters use short names
+					if (minPrice !== undefined) url.searchParams.append("min", minPrice.toString());
+					if (maxPrice !== undefined) url.searchParams.append("max", maxPrice.toString());
+				}
+				
+				// Add common parameters
 				if (address) url.searchParams.append("address", address);
-				if (origin) url.searchParams.append("origin", origin);
-				if (mime) url.searchParams.append("mime", mime);
-				if (num) url.searchParams.append("num", num);
-				if (minPrice !== undefined)
-					url.searchParams.append("min", minPrice.toString());
-				if (maxPrice !== undefined)
-					url.searchParams.append("max", maxPrice.toString());
 
-				// Fetch market listings from GorillaPool API
+				// Make the fetch request
+				console.log(`Fetching market listings from: ${url.toString()}`);
 				const response = await fetch(url.toString());
 
 				if (!response.ok) {

package/tools/ordinals/{bsv20MarketSales.ts → marketSales.ts}

@@ -2,8 +2,9 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
 import { z } from "zod";
 
-// Schema for BSV20 market sales arguments
-export const bsv20MarketSalesArgsSchema = z.object({
+// Schema for unified market sales arguments
+export const marketSalesArgsSchema = z.object({
+	// Common parameters
 	limit: z
 		.number()
 		.int()
@@ -16,20 +17,27 @@ export const bsv20MarketSalesArgsSchema = z.object({
 		.enum(["asc", "desc"])
 		.default("desc")
 		.describe("Sort direction (asc or desc)"),
-	type: z
+	address: z.string().optional().describe("Bitcoin address"),
+
+	// Token-specific parameters
+	tokenType: z
+		.enum(["bsv20", "bsv21", "all"])
+		.default("bsv20")
+		.describe("Type of token to search for (bsv20, bsv21, or all)"),
+	bsv20Type: z
 		.enum(["v1", "v2", "all"])
 		.default("all")
-		.describe("Token type (v1, v2, or all)"),
+		.optional()
+		.describe("BSV20 token type (v1, v2, or all)"),
 	id: z.string().optional().describe("Token ID in outpoint format"),
 	tick: z.string().optional().describe("Token ticker symbol"),
-	pending: z.boolean().default(false).describe("Include pending sales"),
-	address: z.string().optional().describe("Bitcoin address"),
+	pending: z.boolean().default(false).optional().describe("Include pending sales"),
 });
 
-export type Bsv20MarketSalesArgs = z.infer<typeof bsv20MarketSalesArgsSchema>;
+export type MarketSalesArgs = z.infer<typeof marketSalesArgsSchema>;
 
-// Simplified BSV20 sale response type
-interface Bsv20SaleResponse {
+// Unified response type for token sales
+interface MarketSaleResponse {
 	results: Array<{
 		outpoint: string;
 		data?: {
@@ -48,42 +56,70 @@ interface Bsv20SaleResponse {
 		};
 		satoshis?: number;
 		height?: number;
+		owner?: string;
+		spend?: string;
+		spendHeight?: number;
+		spendIdx?: string;
 		[key: string]: unknown;
 	}>;
 	total: number;
 }
 
 /**
- * Register the BSV20 market sales tool
+ * Register the unified market sales tool
+ * Handles BSV20 and BSV21 token sales
  */
-export function registerBsv20MarketSalesTool(server: McpServer): void {
+export function registerMarketSalesTool(server: McpServer): void {
 	server.tool(
-		"ordinals_bsv20MarketSales",
+		"ordinals_marketSales",
 		{
-			args: bsv20MarketSalesArgsSchema,
+			args: marketSalesArgsSchema,
 		},
 		async (
-			{ args }: { args: Bsv20MarketSalesArgs },
+			{ args }: { args: MarketSalesArgs },
 			extra: RequestHandlerExtra,
 		) => {
 			try {
-				const { limit, offset, dir, type, id, tick, pending, address } = args;
+				const { 
+					limit, 
+					offset, 
+					dir, 
+					tokenType, 
+					bsv20Type, 
+					id, 
+					tick, 
+					pending, 
+					address 
+				} = args;
+
+				// Determine the API endpoint based on tokenType
+				let baseUrl = "https://ordinals.gorillapool.io/api";
+				
+				if (tokenType === "bsv21") {
+					baseUrl += "/bsv21/market/sales";
+				} else {
+					// Default to BSV20 for "bsv20" or "all"
+					baseUrl += "/bsv20/market/sales";
+				}
 
 				// Build the URL with query parameters
-				const url = new URL(
-					"https://ordinals.gorillapool.io/api/bsv20/market/sales",
-				);
+				const url = new URL(baseUrl);
 				url.searchParams.append("limit", limit.toString());
 				url.searchParams.append("offset", offset.toString());
 				url.searchParams.append("dir", dir);
-				url.searchParams.append("type", type);
-				url.searchParams.append("pending", pending.toString());
+				
+				// Add type parameter for bsv20 only if specified
+				if (bsv20Type && bsv20Type !== "all") {
+					url.searchParams.append("type", bsv20Type);
+				}
 
 				if (id) url.searchParams.append("id", id);
 				if (tick) url.searchParams.append("tick", tick);
+				if (pending !== undefined) url.searchParams.append("pending", pending.toString());
 				if (address) url.searchParams.append("address", address);
 
-				// Fetch BSV20 market sales from GorillaPool API
+				// Fetch market sales from GorillaPool API
+				console.log(`Fetching market sales from: ${url.toString()}`);
 				const response = await fetch(url.toString());
 
 				if (!response.ok) {
@@ -92,7 +128,7 @@ export function registerBsv20MarketSalesTool(server: McpServer): void {
 					);
 				}
 
-				const data = (await response.json()) as Bsv20SaleResponse;
+				const data = (await response.json()) as MarketSaleResponse;
 
 				return {
 					content: [

package/tools/wallet/createOrdinals.ts

@@ -0,0 +1,117 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { createOrdinals } from "js-1sat-ord";
+import type { 
+	ChangeResult, 
+	Destination, 
+	Inscription, 
+	PreMAP,
+	CreateOrdinalsCollectionMetadata,
+	CreateOrdinalsCollectionItemMetadata
+} from "js-1sat-ord";
+import { z } from "zod";
+import type { Wallet } from "./wallet";
+
+/**
+ * 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)
+	destinationAddress: z.string().optional().describe("Optional destination address for the ordinal"),
+	// Optional metadata for the inscription
+	metadata: z.any().optional().describe("Optional MAP metadata for the inscription")
+});
+
+export type CreateOrdinalsArgs = z.infer<typeof createOrdinalsArgsSchema>;
+
+/**
+ * Registers the wallet_createOrdinals tool for minting ordinals/inscriptions
+ */
+export function registerCreateOrdinalsTool(server: McpServer, wallet: Wallet) {
+	server.tool(
+		"wallet_createOrdinals",
+		{ args: createOrdinalsArgsSchema },
+		async (
+			{ args }: { args: CreateOrdinalsArgs },
+			extra: RequestHandlerExtra,
+		): Promise<CallToolResult> => {
+			try {
+				// 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: args.dataB64,
+					contentType: args.contentType,
+				};
+
+				// 5. Create the destination
+				const destinations: Destination[] = [
+					{
+						address: args.destinationAddress || walletAddress,
+						inscription,
+					},
+				];
+
+				// 6. Create and broadcast the transaction
+				const result = await createOrdinals({
+					utxos: paymentUtxos,
+					destinations,
+					paymentPk,
+					changeAddress: walletAddress,
+					metaData: args.metadata as PreMAP | CreateOrdinalsCollectionMetadata | CreateOrdinalsCollectionItemMetadata,
+				});
+
+				const changeResult = result as ChangeResult;
+				
+				// 7. Broadcast the transaction
+				await changeResult.tx.broadcast();
+				
+				// 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
+				return {
+					content: [
+						{
+							type: "text",
+							text: JSON.stringify({
+								txid: changeResult.tx.id("hex"),
+								spentOutpoints: changeResult.spentOutpoints,
+								payChange: changeResult.payChange,
+								inscriptionAddress: args.destinationAddress || walletAddress,
+								contentType: args.contentType,
+							}),
+						},
+					],
+				};
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				return { content: [{ type: "text", text: msg }], isError: true };
+			}
+		},
+	);
+}

package/tools/wallet/purchaseListing.ts

@@ -1,13 +1,24 @@
-import { PrivateKey } from "@bsv/sdk";
+// import { PrivateKey } from "@bsv/sdk"; // not used here
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import {
+	type ChangeResult,
 	type ExistingListing,
+	type Payment,
+	type TokenUtxo,
 	type Utxo,
+	TokenType,
 	oneSatBroadcaster,
 	purchaseOrdListing,
+	purchaseOrdTokenListing,
 } from "js-1sat-ord";
 import type { z } from "zod";
+import {
+	MARKET_FEE_PERCENTAGE,
+	MARKET_WALLET_ADDRESS,
+	MINIMUM_MARKET_FEE_SATOSHIS,
+} from "../constants";
 import { purchaseListingArgsSchema } from "./schemas";
 import type { Wallet } from "./wallet";
 
@@ -22,6 +33,11 @@ interface ListingResponse {
 			price: number;
 			payout: string;
 		};
+		bsv20?: {
+			amt?: string;
+			tick?: string;
+			id?: string;
+		};
 	};
 }
 
@@ -32,7 +48,7 @@ interface ListingResponse {
  * 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 to create a purchase transaction
+ * 4. Uses purchaseOrdListing or purchaseOrdTokenListing based on the listing type
  * 5. Broadcasts the transaction
  * 6. Returns the transaction details
  */
@@ -46,9 +62,10 @@ export function registerPurchaseListingTool(server: McpServer, wallet: Wallet) {
 		async (
 			{ args }: { args: z.infer<typeof purchaseListingArgsSchema> },
 			extra: RequestHandlerExtra,
-		) => {
+		): Promise<CallToolResult> => {
 			try {
 				console.log(`Attempting to purchase listing: ${args.listingOutpoint}`);
+				console.log(`Listing type: ${args.listingType}`);
 				console.log("Using wallet instance:", wallet);
 				console.log("Wallet has UTXOs:", await wallet.getUtxos());
 
@@ -74,6 +91,20 @@ export function registerPurchaseListingTool(server: McpServer, wallet: Wallet) {
 					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;
+				}
+
+				console.log(`Listing price: ${listingPrice} satoshis`);
+				console.log(
+					`Market fee: ${marketFee} satoshis (${MARKET_FEE_PERCENTAGE * 100}%)`,
+				);
+
 				// Parse the listing outpoint to get txid and vout
 				const [txid, voutStr] = args.listingOutpoint.split("_");
 				if (!txid) {
@@ -81,20 +112,6 @@ export function registerPurchaseListingTool(server: McpServer, wallet: Wallet) {
 				}
 				const vout = Number.parseInt(voutStr || "0", 10);
 
-				// Create listing UTXO object in the format required by js-1sat-ord
-				const listingUtxo: Utxo = {
-					txid,
-					vout,
-					script: listingData.script,
-					satoshis: listingData.satoshis,
-				};
-
-				// Create the ExistingListing object
-				const listing: ExistingListing = {
-					payout: listingData.data.list.payout,
-					listingUtxo,
-				};
-
 				// Get private key from the wallet
 				const paymentPk = wallet.getPrivateKey();
 				if (!paymentPk) {
@@ -112,17 +129,96 @@ export function registerPurchaseListingTool(server: McpServer, wallet: Wallet) {
 					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 transaction fees.`,
+(${listingData.data.list.price} satoshis) plus market fee (${marketFee} satoshis) and transaction fees.`,
 					);
 				}
 
-				// Create the purchase transaction using the library's config type
-				const transaction = await purchaseOrdListing({
-					utxos: paymentUtxos,
-					paymentPk,
-					ordAddress: args.ordAddress,
-					listing,
-				});
+				// 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 (args.listingType === "token") {
+					if (!args.tokenProtocol) {
+						throw new Error("tokenProtocol is required for token listings");
+					}
+					
+					if (!args.tokenID) {
+						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");
+					}
+					
+					// 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");
+					}
+					
+					// Convert the token protocol to the enum type expected by js-1sat-ord
+					const protocol = args.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: args.tokenID,
+					};
+					
+					transaction = await purchaseOrdTokenListing({
+						protocol,
+						tokenID: args.tokenID,
+						utxos: paymentUtxos,
+						paymentPk,
+						listingUtxo,
+						ordAddress: args.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,
+					};
+					
+					transaction = await purchaseOrdListing({
+						utxos: paymentUtxos,
+						paymentPk,
+						ordAddress: args.ordAddress,
+						listing,
+						additionalPayments,
+						metaData,
+					});
+				}
 
 				// After successful transaction creation, refresh the wallet's UTXOs
 				// This ensures the wallet doesn't try to reuse spent UTXOs
@@ -161,7 +257,12 @@ Please fund this wallet address with enough BSV to cover the purchase price
 								txid: transaction.tx.id("hex"),
 								listingOutpoint: args.listingOutpoint,
 								destinationAddress: args.ordAddress,
+								listingType: args.listingType,
+								tokenProtocol: args.tokenID ? args.tokenProtocol : undefined,
+								tokenID: args.tokenID,
 								price: listingData.data.list.price,
+								marketFee,
+								marketFeeAddress: MARKET_WALLET_ADDRESS,
 							}),
 						},
 					],

package/tools/wallet/schemas.ts

@@ -279,6 +279,18 @@ export const purchaseListingArgsSchema = z.object({
 		.string()
 		.optional()
 		.describe("Optional description for the transaction"),
+	listingType: z
+		.enum(["nft", "token"])
+		.default("nft")
+		.describe("Type of listing: 'nft' for ordinal NFTs, 'token' for BSV-20 tokens"),
+	tokenProtocol: z
+		.enum(["bsv-20", "bsv-21"])
+		.optional()
+		.describe("Token protocol for token listings (required when listingType is 'token')"),
+	tokenID: z
+		.string()
+		.optional()
+		.describe("Token ID for BSV-21 tokens or ticker for BSV-20 tokens (required when listingType is 'token')"),
 });
 
 export type PurchaseListingArgs = z.infer<typeof purchaseListingArgsSchema>;

package/tools/wallet/sendOrdinals.ts

@@ -0,0 +1,119 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { sendOrdinals } from "js-1sat-ord";
+import type { ChangeResult, SendOrdinalsConfig } from "js-1sat-ord";
+import { z } from "zod";
+import type { Wallet } from "./wallet";
+
+/**
+ * Schema for the sendOrdinals tool arguments
+ */
+export const sendOrdinalsArgsSchema = z.object({
+  // Outpoint of the inscription to send (txid_vout format)
+  inscriptionOutpoint: z.string().describe("Inscription outpoint in format txid_vout"),
+  // Destination address to send the inscription to
+  destinationAddress: z.string().describe("Destination address for the inscription"),
+  // Optional metadata for the ordinal transfer
+  metadata: z.any().optional().describe("Optional MAP metadata for the transfer"),
+});
+
+export type SendOrdinalsArgs = z.infer<typeof sendOrdinalsArgsSchema>;
+
+/**
+ * Registers the wallet_sendOrdinals tool for transferring ordinals
+ */
+export function registerSendOrdinalsTool(server: McpServer, wallet: Wallet) {
+  server.tool(
+    "wallet_sendOrdinals",
+    { args: sendOrdinalsArgsSchema },
+    async (
+      { args }: { args: SendOrdinalsArgs },
+      extra: RequestHandlerExtra,
+    ): Promise<CallToolResult> => {
+      try {
+        // 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, nftUtxos } = await wallet.getUtxos();
+        if (!paymentUtxos || paymentUtxos.length === 0) {
+          throw new Error("No payment UTXOs available to fund this transaction");
+        }
+
+        // 3. Get the wallet address for change
+        const walletAddress = paymentPk.toAddress().toString();
+
+        // 4. Parse the inscription outpoint
+        const [txid, voutStr] = args.inscriptionOutpoint.split('_');
+        if (!txid || !voutStr) {
+          throw new Error("Invalid inscription outpoint format. Expected txid_vout");
+        }
+        const vout = Number.parseInt(voutStr, 10);
+        
+        // 5. Find the inscription in nftUtxos
+        const inscription = nftUtxos.find(
+          (utxo) => utxo.txid === txid && utxo.vout === vout
+        );
+        
+        if (!inscription) {
+          throw new Error(
+            `Inscription ${args.inscriptionOutpoint} not found in your wallet`
+          );
+        }
+
+        // 6. Create config and transfer the inscription
+        const sendOrdinalsConfig: SendOrdinalsConfig = {
+          paymentPk,
+          paymentUtxos,
+          ordinals: [inscription],
+          destinations: [{ address: args.destinationAddress }],
+          changeAddress: walletAddress,
+        };
+
+        // Add metadata if provided
+        if (args.metadata) {
+          sendOrdinalsConfig.metaData = args.metadata;
+        }
+
+        // Using the wallet's key for both payment and ordinals
+        sendOrdinalsConfig.ordPk = paymentPk;
+
+        const result = await sendOrdinals(sendOrdinalsConfig);
+        const changeResult = result as ChangeResult;
+        
+        // 7. Broadcast the transaction
+        await changeResult.tx.broadcast();
+        
+        // 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
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                txid: changeResult.tx.id("hex"),
+                spentOutpoints: changeResult.spentOutpoints,
+                payChange: changeResult.payChange,
+                inscriptionOutpoint: args.inscriptionOutpoint,
+                destinationAddress: args.destinationAddress,
+              }),
+            },
+          ],
+        };
+      } catch (err: unknown) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: msg }], isError: true };
+      }
+    },
+  );
+} 

package/tools/wallet/sendToAddress.ts

@@ -1,6 +1,7 @@
 import { P2PKH } from "@bsv/sdk";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import { toSatoshi } from "satoshi-token";
 import type { z } from "zod";
 import { sendToAddressArgsSchema } from "./schemas";
 import type { Wallet } from "./wallet";
@@ -56,17 +57,20 @@ export function registerSendToAddressTool(server: McpServer, wallet: Wallet) {
 					description = "Send to address",
 				} = args;
 
-				// Convert USD to satoshis if needed
-				let satoshis = amount;
+				// Convert to satoshis
+				let satoshis: number;
 				if (currency === "USD") {
 					// Get current BSV price
 					const bsvPriceUsd = await getBsvPrice();
 
-					// Convert USD to BSV, then to satoshis
-					satoshis = Math.floor((amount / bsvPriceUsd) * 100000000);
+					// Convert USD to BSV
+					const bsvAmount = amount / bsvPriceUsd;
+
+					// Convert BSV to satoshis using the library
+					satoshis = toSatoshi(bsvAmount);
 				} else {
-					// Convert BSV to satoshis
-					satoshis = Math.floor(amount * 100000000);
+					// Convert BSV to satoshis using the library
+					satoshis = toSatoshi(amount);
 				}
 
 				// Create P2PKH script from address

package/tools/wallet/tools.ts

@@ -1,45 +1,46 @@
-import type {
-	McpServer,
-	ToolCallback,
-} from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ToolCallback } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
 import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import type { z } from "zod";
-import { convertData } from "../utils/conversion";
-import { registerGetAddressTool } from "./getAddress";
-import { registerPurchaseListingTool } from "./purchaseListing";
-import {
-	createSignatureArgsSchema,
-	type emptyArgsSchema,
-	getPublicKeyArgsSchema,
-	verifySignatureArgsSchema,
-	walletDecryptArgsSchema,
-	walletEncryptArgsSchema,
-} from "./schemas";
 import type {
 	abortActionArgsSchema,
 	acquireCertificateArgsSchema,
 	createHmacArgsSchema,
 	discoverByAttributesArgsSchema,
 	discoverByIdentityKeyArgsSchema,
-	getAddressArgsSchema,
 	getHeaderArgsSchema,
 	internalizeActionArgsSchema,
 	listActionsArgsSchema,
 	listCertificatesArgsSchema,
 	listOutputsArgsSchema,
 	proveCertificateArgsSchema,
-	purchaseListingArgsSchema,
 	relinquishCertificateArgsSchema,
 	relinquishOutputArgsSchema,
 	revealCounterpartyKeyLinkageArgsSchema,
 	revealSpecificKeyLinkageArgsSchema,
-	sendToAddressArgsSchema,
 	verifyHmacArgsSchema,
 } from "./schemas";
-import { registerSendToAddressTool } from "./sendToAddress";
 import type { Wallet } from "./wallet";
 
+import {
+	createSignatureArgsSchema,
+	type emptyArgsSchema,
+	type getAddressArgsSchema,
+	getPublicKeyArgsSchema,
+	type purchaseListingArgsSchema,
+	type sendToAddressArgsSchema,
+	verifySignatureArgsSchema,
+	walletDecryptArgsSchema,
+	walletEncryptArgsSchema,
+} from "./schemas";
+
+import { registerCreateOrdinalsTool } from "./createOrdinals";
+import type { createOrdinalsArgsSchema } from "./createOrdinals";
+import { registerGetAddressTool } from "./getAddress";
+import { registerPurchaseListingTool } from "./purchaseListing";
+import { registerSendToAddressTool } from "./sendToAddress";
+
 // Define mapping from tool names to argument schemas
 type ToolArgSchemas = {
 	wallet_getPublicKey: typeof getPublicKeyArgsSchema;
@@ -70,6 +71,7 @@ type ToolArgSchemas = {
 	wallet_getAddress: typeof getAddressArgsSchema;
 	wallet_sendToAddress: typeof sendToAddressArgsSchema;
 	wallet_purchaseListing: typeof purchaseListingArgsSchema;
+	wallet_createOrdinals: typeof createOrdinalsArgsSchema;
 };
 
 // Define a type for the handler function with proper argument types
@@ -202,5 +204,9 @@ export function registerWalletTools(
 		},
 	);
 
+	// Register ordinals extension tools
+	// Register the wallet_createOrdinals tool
+	registerCreateOrdinalsTool(server, wallet);
+
 	return handlers;
 }

package/tools/wallet/wallet.ts

@@ -10,7 +10,6 @@ import {
 	PrivateKey,
 	ProtoWallet,
 	Transaction,
-	Utils,
 } from "@bsv/sdk";
 import type {
 	AbortActionArgs,
@@ -19,10 +18,6 @@ import type {
 	AuthenticatedResult,
 	CreateActionArgs,
 	CreateActionResult,
-	CreateHmacArgs,
-	CreateHmacResult,
-	CreateSignatureArgs,
-	CreateSignatureResult,
 	DiscoverByAttributesArgs,
 	DiscoverByIdentityKeyArgs,
 	DiscoverCertificatesResult,
@@ -53,15 +48,7 @@ import type {
 	RevealSpecificKeyLinkageResult,
 	SignActionArgs,
 	SignActionResult,
-	VerifyHmacArgs,
-	VerifyHmacResult,
-	VerifySignatureArgs,
-	VerifySignatureResult,
 	WalletCertificate,
-	WalletDecryptArgs,
-	WalletDecryptResult,
-	WalletEncryptArgs,
-	WalletEncryptResult,
 	WalletInterface,
 } from "@bsv/sdk";
 import {
@@ -152,28 +139,29 @@ export class Wallet extends ProtoWallet implements WalletInterface {
 	): Promise<RevealSpecificKeyLinkageResult> {
 		return Promise.reject(new Error("Not implemented"));
 	}
-	async encrypt(args: WalletEncryptArgs): Promise<WalletEncryptResult> {
-		return Promise.reject(new Error("Not implemented"));
-	}
-	async decrypt(args: WalletDecryptArgs): Promise<WalletDecryptResult> {
-		return Promise.reject(new Error("Not implemented"));
-	}
-	async createHmac(args: CreateHmacArgs): Promise<CreateHmacResult> {
-		return Promise.reject(new Error("Not implemented"));
-	}
-	async verifyHmac(args: VerifyHmacArgs): Promise<VerifyHmacResult> {
-		return Promise.reject(new Error("Not implemented"));
-	}
-	async createSignature(
-		args: CreateSignatureArgs,
-	): Promise<CreateSignatureResult> {
-		return Promise.reject(new Error("Not implemented"));
-	}
-	async verifySignature(
-		args: VerifySignatureArgs,
-	): Promise<VerifySignatureResult> {
-		return Promise.reject(new Error("Not implemented"));
-	}
+	// Implemented by ProtoWallet
+	// async encrypt(args: WalletEncryptArgs): Promise<WalletEncryptResult> {
+	// 	return this.encrypt(args);
+	// }
+	// async decrypt(args: WalletDecryptArgs): Promise<WalletDecryptResult> {
+	// 	return this.decrypt(args);
+	// }
+	// async createHmac(args: CreateHmacArgs): Promise<CreateHmacResult> {
+	// 	return this.createHmac(args);
+	// }
+	// async verifyHmac(args: VerifyHmacArgs): Promise<VerifyHmacResult> {
+	// 	return this.verifyHmac(args);
+	// }
+	// async createSignature(
+	// 	args: CreateSignatureArgs,
+	// ): Promise<CreateSignatureResult> {
+	// 	return Promise.reject(new Error("Not implemented"));
+	// }
+	// async verifySignature(
+	// 	args: VerifySignatureArgs,
+	// ): Promise<VerifySignatureResult> {
+	// 	return Promise.reject(new Error("Not implemented"));
+	// }
 	async createAction(args: CreateActionArgs): Promise<CreateActionResult> {
 		console.log("createAction called with", args);