bsv-mcp 0.0.1

package/tools/bsv/decodeTransaction.ts

@@ -0,0 +1,299 @@
+import { Transaction, Utils } from "@bsv/sdk";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import { z } from "zod";
+
+// Schema for decode transaction arguments
+export const decodeTransactionArgsSchema = z.object({
+	tx: z.string().describe("Transaction data or txid"),
+	encoding: z
+		.enum(["hex", "base64"])
+		.default("hex")
+		.describe("Encoding of the input data"),
+});
+
+export type DecodeTransactionArgs = z.infer<typeof decodeTransactionArgsSchema>;
+
+// Type for JungleBus API response
+interface JungleBusTransactionResponse {
+	id: string;
+	transaction: string;
+	block_hash?: string;
+	block_height?: number;
+	block_time?: number;
+	block_index?: number;
+	addresses?: string[];
+	inputs?: string[];
+	outputs?: string[];
+	input_types?: string[];
+	output_types?: string[];
+	contexts?: string[];
+	sub_contexts?: string[];
+	data?: string[];
+	merkle_proof?: unknown;
+}
+
+// Network info response type
+interface NetworkInfoResponse {
+	blocks: number;
+	[key: string]: unknown;
+}
+
+// Transaction input type
+interface TransactionInputData {
+	txid: string | undefined;
+	vout: number;
+	sequence: number | undefined;
+	script: string;
+	scriptAsm: string;
+	type?: string;
+	value?: number;
+}
+
+// Transaction output type
+interface TransactionOutputData {
+	n: number;
+	value: number | undefined;
+	scriptPubKey: {
+		hex: string;
+		asm: string;
+	};
+	type?: string;
+}
+
+// Transaction result type
+interface TransactionResult {
+	txid: string;
+	version: number;
+	locktime: number;
+	size: number;
+	inputs: TransactionInputData[];
+	outputs: TransactionOutputData[];
+	confirmations?: number;
+	block?: {
+		hash: string;
+		height: number;
+		time: number;
+		index: number;
+	} | null;
+	addresses?: string[];
+	fee?: number | null;
+	feeRate?: number | null;
+}
+
+/**
+ * Fetches transaction data from JungleBus
+ */
+async function fetchJungleBusData(
+	txid: string,
+): Promise<JungleBusTransactionResponse | null> {
+	try {
+		const response = await fetch(
+			`https://junglebus.gorillapool.io/v1/transaction/get/${txid}`,
+		);
+		if (!response.ok) {
+			console.error(
+				`JungleBus API error: ${response.status} ${response.statusText}`,
+			);
+			return null;
+		}
+		return (await response.json()) as JungleBusTransactionResponse;
+	} catch (error) {
+		console.error("Error fetching from JungleBus:", error);
+		return null;
+	}
+}
+
+/**
+ * Determines if a string is likely a txid
+ */
+function isTxid(str: string): boolean {
+	// TX IDs are 64 characters in hex (32 bytes)
+	return /^[0-9a-f]{64}$/i.test(str);
+}
+
+/**
+ * Register the BSV transaction decode tool
+ */
+export function registerDecodeTransactionTool(server: McpServer): void {
+	server.tool(
+		"bsv_decodeTransaction",
+		{
+			args: decodeTransactionArgsSchema,
+		},
+		async (
+			{ args }: { args: DecodeTransactionArgs },
+			extra: RequestHandlerExtra,
+		) => {
+			try {
+				const { tx, encoding } = args;
+				let transaction: Transaction;
+				let rawTx: string;
+				let txid: string;
+				let junglebusData: JungleBusTransactionResponse | null = null;
+
+				// Check if input is txid or raw transaction
+				if (isTxid(tx)) {
+					// It's a txid, fetch from JungleBus
+					txid = tx;
+					junglebusData = await fetchJungleBusData(txid);
+
+					if (!junglebusData) {
+						throw new Error(
+							`Failed to fetch transaction data for txid: ${txid}`,
+						);
+					}
+
+					// JungleBus returns base64, convert if needed
+					rawTx = junglebusData.transaction;
+					// Check if rawTx is in base64 format (common from JungleBus)
+					const isBase64 = /^[A-Za-z0-9+/=]+$/.test(rawTx);
+
+					if (isBase64) {
+						const txBytes = Utils.toArray(rawTx, "base64");
+						transaction = Transaction.fromBinary(txBytes);
+					} else {
+						transaction = Transaction.fromHex(rawTx);
+					}
+				} else {
+					// It's a raw transaction
+					let txBytes: number[];
+
+					if (encoding === "hex") {
+						txBytes = Utils.toArray(tx, "hex");
+					} else {
+						txBytes = Utils.toArray(tx, "base64");
+					}
+
+					transaction = Transaction.fromBinary(txBytes);
+					txid = transaction.hash("hex") as string;
+
+					// Optionally fetch additional context from JungleBus
+					junglebusData = await fetchJungleBusData(txid);
+				}
+
+				// Basic transaction data
+				const result: TransactionResult = {
+					txid,
+					version: transaction.version,
+					locktime: transaction.lockTime,
+					size: transaction.toBinary().length,
+					inputs: transaction.inputs.map((input) => ({
+						txid: input.sourceTXID,
+						vout: input.sourceOutputIndex,
+						sequence: input.sequence,
+						script: input.unlockingScript ? input.unlockingScript.toHex() : "",
+						scriptAsm: input.unlockingScript
+							? input.unlockingScript.toASM()
+							: "",
+					})),
+					outputs: transaction.outputs.map((output) => ({
+						n: transaction.outputs.indexOf(output),
+						value: output.satoshis,
+						scriptPubKey: {
+							hex: output.lockingScript.toHex(),
+							asm: output.lockingScript.toASM(),
+						},
+					})),
+				};
+
+				// Add JungleBus context if available
+				if (junglebusData) {
+					result.confirmations = junglebusData.block_height
+						? (await getCurrentBlockHeight()) - junglebusData.block_height + 1
+						: 0;
+
+					result.block = junglebusData.block_hash
+						? {
+								hash: junglebusData.block_hash,
+								height: junglebusData.block_height || 0,
+								time: junglebusData.block_time || 0,
+								index: junglebusData.block_index || 0,
+							}
+						: null;
+
+					// Add script types
+					if (
+						junglebusData.input_types &&
+						junglebusData.input_types.length > 0
+					) {
+						result.inputs = result.inputs.map((input, i) => ({
+							...input,
+							type: junglebusData.input_types?.[i] || "unknown",
+						}));
+					}
+
+					if (
+						junglebusData.output_types &&
+						junglebusData.output_types.length > 0
+					) {
+						result.outputs = result.outputs.map((output, i) => ({
+							...output,
+							type: junglebusData.output_types?.[i] || "unknown",
+						}));
+					}
+
+					// Add addresses found in transaction
+					if (junglebusData.addresses && junglebusData.addresses.length > 0) {
+						result.addresses = junglebusData.addresses;
+					}
+				}
+
+				// Calculate additional information
+				const totalInputValue = result.inputs.reduce(
+					(sum, input) => sum + (input.value || 0),
+					0,
+				);
+				const totalOutputValue = result.outputs.reduce(
+					(sum, output) => sum + (output.value || 0),
+					0,
+				);
+
+				result.fee =
+					totalInputValue > 0 ? totalInputValue - totalOutputValue : null;
+				result.feeRate =
+					result.fee !== null
+						? Math.round((result.fee / result.size) * 100000000) / 100000000
+						: null;
+
+				return {
+					content: [
+						{
+							type: "text",
+							text: JSON.stringify(result, null, 2),
+						},
+					],
+				};
+			} catch (error) {
+				return {
+					content: [
+						{
+							type: "text",
+							text: error instanceof Error ? error.message : String(error),
+						},
+					],
+					isError: true,
+				};
+			}
+		},
+	);
+}
+
+/**
+ * Get current block height
+ */
+async function getCurrentBlockHeight(): Promise<number> {
+	try {
+		const response = await fetch(
+			"https://junglebus.gorillapool.io/v1/network/info",
+		);
+		if (!response.ok) {
+			return 0;
+		}
+		const data = (await response.json()) as NetworkInfoResponse;
+		return data.blocks || 0;
+	} catch (error) {
+		console.error("Error fetching current block height:", error);
+		return 0;
+	}
+}

package/tools/bsv/getPrice.ts

@@ -0,0 +1,44 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+
+/**
+ * Register the BSV price lookup tool
+ * @param server The MCP server instance
+ */
+export function registerGetPriceTool(server: McpServer): void {
+	server.tool(
+		"bsv_getPrice",
+		{
+			args: z.object({}).optional(),
+		},
+		async () => {
+			try {
+				const res = await fetch(
+					"https://api.whatsonchain.com/v1/bsv/main/exchangerate",
+				);
+				if (!res.ok) throw new Error("Failed to fetch price");
+				const data = (await res.json()) as {
+					currency: string;
+					rate: string;
+					time: number;
+				};
+				const price = data.rate;
+				if (typeof price !== "string" && typeof price !== "number")
+					throw new Error("Price not found");
+				return {
+					content: [
+						{
+							type: "text",
+							text: `Current BSV price: $${Number(price).toFixed(2)} USD`,
+						},
+					],
+				};
+			} catch (err) {
+				return {
+					content: [{ type: "text", text: "Error fetching BSV price." }],
+					isError: true,
+				};
+			}
+		},
+	);
+}

package/tools/bsv/index.ts

@@ -0,0 +1,13 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerDecodeTransactionTool } from "./decodeTransaction";
+import { registerGetPriceTool } from "./getPrice";
+
+/**
+ * Register all BSV tools with the MCP server
+ * @param server The MCP server instance
+ */
+export function registerBsvTools(server: McpServer): void {
+	// Register BSV-related tools
+	registerGetPriceTool(server);
+	registerDecodeTransactionTool(server);
+}

package/tools/bsv/token.ts

@@ -0,0 +1,169 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import {
+	ReturnTypes,
+	toBitcoin,
+	toSatoshi,
+	toToken,
+	toTokenSat,
+} from "satoshi-token";
+import { z } from "zod";
+
+/**
+ * Register token conversion tools for BSV
+ * @param server The MCP server instance
+ */
+export function registerTokenTools(server: McpServer): void {
+	// Convert Bitcoin to Satoshis
+	server.tool(
+		"bsv_toSatoshi",
+		{
+			args: z.object({
+				bitcoin: z.union([z.number(), z.string()]),
+				returnType: z.enum(["number", "string", "bigint"]).optional(),
+			}),
+		},
+		async ({ args }) => {
+			try {
+				const { bitcoin, returnType } = args;
+				let result: number | string | bigint;
+
+				switch (returnType) {
+					case "bigint":
+						result = toSatoshi(bitcoin, ReturnTypes.BigInt);
+						return { content: [{ type: "text", text: result.toString() }] };
+					case "string":
+						result = toSatoshi(bitcoin, ReturnTypes.String);
+						return { content: [{ type: "text", text: result }] };
+					default:
+						result = toSatoshi(bitcoin);
+						return { content: [{ type: "text", text: result.toString() }] };
+				}
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				return { content: [{ type: "text", text: msg }], isError: true };
+			}
+		},
+	);
+
+	// Convert Satoshis to Bitcoin
+	server.tool(
+		"bsv_toBitcoin",
+		{
+			args: z.object({
+				satoshis: z.union([z.number(), z.string(), z.bigint()]),
+				returnType: z.enum(["number", "string", "bigint"]).optional(),
+			}),
+		},
+		async ({ args }) => {
+			try {
+				const { satoshis, returnType } = args;
+				let result: number | string | bigint;
+
+				switch (returnType) {
+					case "bigint":
+						try {
+							result = toBitcoin(satoshis, ReturnTypes.BigInt);
+							return { content: [{ type: "text", text: result.toString() }] };
+						} catch (e) {
+							return {
+								content: [
+									{
+										type: "text",
+										text: "Error: Cannot return Bitcoin amount as BigInt if it has decimal part",
+									},
+								],
+								isError: true,
+							};
+						}
+					case "string":
+						result = toBitcoin(satoshis, ReturnTypes.String);
+						return { content: [{ type: "text", text: result }] };
+					default:
+						result = toBitcoin(satoshis);
+						return { content: [{ type: "text", text: result.toString() }] };
+				}
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				return { content: [{ type: "text", text: msg }], isError: true };
+			}
+		},
+	);
+
+	// Generic token conversion (for tokens with custom decimal places)
+	server.tool(
+		"bsv_toTokenSatoshi",
+		{
+			args: z.object({
+				token: z.union([z.number(), z.string(), z.bigint()]),
+				decimals: z.number().int().min(0),
+				returnType: z.enum(["number", "string", "bigint"]).optional(),
+			}),
+		},
+		async ({ args }) => {
+			try {
+				const { token, decimals, returnType } = args;
+				let result: number | string | bigint;
+
+				switch (returnType) {
+					case "bigint":
+						result = toTokenSat(token, decimals, ReturnTypes.BigInt);
+						return { content: [{ type: "text", text: result.toString() }] };
+					case "string":
+						result = toTokenSat(token, decimals, ReturnTypes.String);
+						return { content: [{ type: "text", text: result }] };
+					default:
+						result = toTokenSat(token, decimals);
+						return { content: [{ type: "text", text: result.toString() }] };
+				}
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				return { content: [{ type: "text", text: msg }], isError: true };
+			}
+		},
+	);
+
+	// Generic token conversion (for tokens with custom decimal places)
+	server.tool(
+		"bsv_toToken",
+		{
+			args: z.object({
+				tokenSatoshi: z.union([z.number(), z.string(), z.bigint()]),
+				decimals: z.number().int().min(0),
+				returnType: z.enum(["number", "string", "bigint"]).optional(),
+			}),
+		},
+		async ({ args }) => {
+			try {
+				const { tokenSatoshi, decimals, returnType } = args;
+				let result: number | string | bigint;
+
+				switch (returnType) {
+					case "bigint":
+						try {
+							result = toToken(tokenSatoshi, decimals, ReturnTypes.BigInt);
+							return { content: [{ type: "text", text: result.toString() }] };
+						} catch (e) {
+							return {
+								content: [
+									{
+										type: "text",
+										text: "Error: Cannot return token amount as BigInt if it has decimal part",
+									},
+								],
+								isError: true,
+							};
+						}
+					case "string":
+						result = toToken(tokenSatoshi, decimals, ReturnTypes.String);
+						return { content: [{ type: "text", text: result }] };
+					default:
+						result = toToken(tokenSatoshi, decimals);
+						return { content: [{ type: "text", text: result.toString() }] };
+				}
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				return { content: [{ type: "text", text: msg }], isError: true };
+			}
+		},
+	);
+}

package/tools/index.ts

@@ -0,0 +1,21 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerBsvTools } from "./bsv";
+import { registerOrdinalsTools } from "./ordinals";
+import { registerUtilsTools } from "./utils";
+
+/**
+ * Register all tools with the MCP server
+ * @param server The MCP server instance
+ */
+export function registerAllTools(server: McpServer): void {
+	// Register BSV-related tools
+	registerBsvTools(server);
+
+	// Register Ordinals-related tools
+	registerOrdinalsTools(server);
+
+	// Register utility tools
+	registerUtilsTools(server);
+
+	// Add more tool categories as needed
+}

package/tools/ordinals/bsv20MarketSales.ts

@@ -0,0 +1,118 @@
+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({
+	limit: z
+		.number()
+		.int()
+		.min(1)
+		.max(100)
+		.default(20)
+		.describe("Number of results (1-100, default 20)"),
+	offset: z.number().int().min(0).default(0).describe("Pagination offset"),
+	dir: z
+		.enum(["asc", "desc"])
+		.default("desc")
+		.describe("Sort direction (asc or desc)"),
+	type: z
+		.enum(["v1", "v2", "all"])
+		.default("all")
+		.describe("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"),
+});
+
+export type Bsv20MarketSalesArgs = z.infer<typeof bsv20MarketSalesArgsSchema>;
+
+// Simplified BSV20 sale response type
+interface Bsv20SaleResponse {
+	results: Array<{
+		outpoint: string;
+		data?: {
+			bsv20?: {
+				id?: string;
+				tick?: string;
+				sym?: string;
+				amt?: string;
+				op?: string;
+			};
+			list?: {
+				price?: number;
+				payout?: string;
+				sale?: boolean;
+			};
+		};
+		satoshis?: number;
+		height?: number;
+		[key: string]: unknown;
+	}>;
+	total: number;
+}
+
+/**
+ * Register the BSV20 market sales tool
+ */
+export function registerBsv20MarketSalesTool(server: McpServer): void {
+	server.tool(
+		"ordinals_bsv20MarketSales",
+		{
+			args: bsv20MarketSalesArgsSchema,
+		},
+		async (
+			{ args }: { args: Bsv20MarketSalesArgs },
+			extra: RequestHandlerExtra,
+		) => {
+			try {
+				const { limit, offset, dir, type, id, tick, pending, address } = args;
+
+				// Build the URL with query parameters
+				const url = new URL(
+					"https://ordinals.gorillapool.io/api/bsv20/market/sales",
+				);
+				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());
+
+				if (id) url.searchParams.append("id", id);
+				if (tick) url.searchParams.append("tick", tick);
+				if (address) url.searchParams.append("address", address);
+
+				// Fetch BSV20 market sales from GorillaPool API
+				const response = await fetch(url.toString());
+
+				if (!response.ok) {
+					throw new Error(
+						`API error: ${response.status} ${response.statusText}`,
+					);
+				}
+
+				const data = (await response.json()) as Bsv20SaleResponse;
+
+				return {
+					content: [
+						{
+							type: "text",
+							text: JSON.stringify(data, null, 2),
+						},
+					],
+				};
+			} catch (error) {
+				return {
+					content: [
+						{
+							type: "text",
+							text: error instanceof Error ? error.message : String(error),
+						},
+					],
+					isError: true,
+				};
+			}
+		},
+	);
+}