bsv-mcp 0.0.1

package/tools/wallet/tools.ts

@@ -0,0 +1,206 @@
+import type {
+	McpServer,
+	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";
+
+// Define mapping from tool names to argument schemas
+type ToolArgSchemas = {
+	wallet_getPublicKey: typeof getPublicKeyArgsSchema;
+	wallet_createSignature: typeof createSignatureArgsSchema;
+	wallet_verifySignature: typeof verifySignatureArgsSchema;
+	wallet_encrypt: typeof walletEncryptArgsSchema;
+	wallet_decrypt: typeof walletDecryptArgsSchema;
+	wallet_listActions: typeof listActionsArgsSchema;
+	wallet_listOutputs: typeof listOutputsArgsSchema;
+	wallet_getNetwork: typeof emptyArgsSchema;
+	wallet_getVersion: typeof emptyArgsSchema;
+	wallet_revealCounterpartyKeyLinkage: typeof revealCounterpartyKeyLinkageArgsSchema;
+	wallet_revealSpecificKeyLinkage: typeof revealSpecificKeyLinkageArgsSchema;
+	wallet_createHmac: typeof createHmacArgsSchema;
+	wallet_verifyHmac: typeof verifyHmacArgsSchema;
+	wallet_abortAction: typeof abortActionArgsSchema;
+	wallet_internalizeAction: typeof internalizeActionArgsSchema;
+	wallet_relinquishOutput: typeof relinquishOutputArgsSchema;
+	wallet_acquireCertificate: typeof acquireCertificateArgsSchema;
+	wallet_listCertificates: typeof listCertificatesArgsSchema;
+	wallet_proveCertificate: typeof proveCertificateArgsSchema;
+	wallet_relinquishCertificate: typeof relinquishCertificateArgsSchema;
+	wallet_discoverByIdentityKey: typeof discoverByIdentityKeyArgsSchema;
+	wallet_discoverByAttributes: typeof discoverByAttributesArgsSchema;
+	wallet_isAuthenticated: typeof emptyArgsSchema;
+	wallet_waitForAuthentication: typeof emptyArgsSchema;
+	wallet_getHeaderForHeight: typeof getHeaderArgsSchema;
+	wallet_getAddress: typeof getAddressArgsSchema;
+	wallet_sendToAddress: typeof sendToAddressArgsSchema;
+	wallet_purchaseListing: typeof purchaseListingArgsSchema;
+};
+
+// Define a type for the handler function with proper argument types
+type ToolHandler = (
+	params: { args: unknown },
+	extra: RequestHandlerExtra,
+) => Promise<CallToolResult>;
+
+// Define a map type for tool name to handler functions
+type ToolHandlerMap = {
+	[K in keyof ToolArgSchemas]: ToolHandler;
+};
+
+export function registerWalletTools(
+	server: McpServer,
+	wallet: Wallet,
+): ToolHandlerMap {
+	const handlers = {} as ToolHandlerMap;
+
+	// Handle tools registration with properly typed parameters
+	function registerTool<T extends z.ZodType>(
+		name: keyof ToolArgSchemas,
+		schema: { args: T },
+		handler: ToolCallback<{ args: T }>,
+	): void {
+		// Register all tools normally
+		server.tool(name, schema, handler);
+		handlers[name] = handler as ToolHandler;
+	}
+
+	// Register the wallet_sendToAddress tool
+	registerSendToAddressTool(server, wallet);
+
+	// Register the wallet_getAddress tool
+	registerGetAddressTool(server);
+
+	// Register the wallet_purchaseListing tool
+	registerPurchaseListingTool(server, wallet);
+
+	// Register only the minimal public-facing tools
+	// wallet_createAction, wallet_signAction and wallet_getHeight have been removed
+
+	// Register wallet_getPublicKey
+	registerTool(
+		"wallet_getPublicKey",
+		{ args: getPublicKeyArgsSchema },
+		async (
+			{ args }: { args: z.infer<typeof getPublicKeyArgsSchema> },
+			extra: RequestHandlerExtra,
+		) => {
+			try {
+				const result = await wallet.getPublicKey(args);
+				return { content: [{ type: "text", text: JSON.stringify(result) }] };
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				return { content: [{ type: "text", text: msg }], isError: true };
+			}
+		},
+	);
+
+	// Register wallet_createSignature
+	registerTool(
+		"wallet_createSignature",
+		{ args: createSignatureArgsSchema },
+		async (
+			{ args }: { args: z.infer<typeof createSignatureArgsSchema> },
+			extra: RequestHandlerExtra,
+		) => {
+			try {
+				const result = await wallet.createSignature(args);
+				return { content: [{ type: "text", text: JSON.stringify(result) }] };
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				return { content: [{ type: "text", text: msg }], isError: true };
+			}
+		},
+	);
+
+	// Register wallet_verifySignature
+	registerTool(
+		"wallet_verifySignature",
+		{ args: verifySignatureArgsSchema },
+		async (
+			{ args }: { args: z.infer<typeof verifySignatureArgsSchema> },
+			extra: RequestHandlerExtra,
+		) => {
+			try {
+				const result = await wallet.verifySignature(args);
+				return { content: [{ type: "text", text: JSON.stringify(result) }] };
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				return { content: [{ type: "text", text: msg }], isError: true };
+			}
+		},
+	);
+
+	// Register wallet_encrypt
+	registerTool(
+		"wallet_encrypt",
+		{ args: walletEncryptArgsSchema },
+		async (
+			{ args }: { args: z.infer<typeof walletEncryptArgsSchema> },
+			extra: RequestHandlerExtra,
+		) => {
+			try {
+				const result = await wallet.encrypt(args);
+				return { content: [{ type: "text", text: JSON.stringify(result) }] };
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				return { content: [{ type: "text", text: msg }], isError: true };
+			}
+		},
+	);
+
+	// Register wallet_decrypt
+	registerTool(
+		"wallet_decrypt",
+		{ args: walletDecryptArgsSchema },
+		async (
+			{ args }: { args: z.infer<typeof walletDecryptArgsSchema> },
+			extra: RequestHandlerExtra,
+		) => {
+			try {
+				const result = await wallet.decrypt(args);
+				return { content: [{ type: "text", text: JSON.stringify(result) }] };
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				return { content: [{ type: "text", text: msg }], isError: true };
+			}
+		},
+	);
+
+	return handlers;
+}

package/tools/wallet/wallet.ts

@@ -0,0 +1,290 @@
+/**
+ * Wallet implementation scaffold.
+ *
+ * Implements WalletInterface from the ts-sdk and extends ProtoWallet.
+ *
+ * See: https://github.com/bitcoin-sv/ts-sdk/blob/main/src/wallet/Wallet.interfaces.ts
+ */
+import {
+	LockingScript,
+	PrivateKey,
+	ProtoWallet,
+	Transaction,
+	Utils,
+} from "@bsv/sdk";
+import type {
+	AbortActionArgs,
+	AbortActionResult,
+	AcquireCertificateArgs,
+	AuthenticatedResult,
+	CreateActionArgs,
+	CreateActionResult,
+	CreateHmacArgs,
+	CreateHmacResult,
+	CreateSignatureArgs,
+	CreateSignatureResult,
+	DiscoverByAttributesArgs,
+	DiscoverByIdentityKeyArgs,
+	DiscoverCertificatesResult,
+	GetHeaderArgs,
+	GetHeaderResult,
+	GetHeightResult,
+	GetNetworkResult,
+	GetPublicKeyArgs,
+	GetPublicKeyResult,
+	GetVersionResult,
+	InternalizeActionArgs,
+	InternalizeActionResult,
+	ListActionsArgs,
+	ListActionsResult,
+	ListCertificatesArgs,
+	ListCertificatesResult,
+	ListOutputsArgs,
+	ListOutputsResult,
+	ProveCertificateArgs,
+	ProveCertificateResult,
+	RelinquishCertificateArgs,
+	RelinquishCertificateResult,
+	RelinquishOutputArgs,
+	RelinquishOutputResult,
+	RevealCounterpartyKeyLinkageArgs,
+	RevealCounterpartyKeyLinkageResult,
+	RevealSpecificKeyLinkageArgs,
+	RevealSpecificKeyLinkageResult,
+	SignActionArgs,
+	SignActionResult,
+	VerifyHmacArgs,
+	VerifyHmacResult,
+	VerifySignatureArgs,
+	VerifySignatureResult,
+	WalletCertificate,
+	WalletDecryptArgs,
+	WalletDecryptResult,
+	WalletEncryptArgs,
+	WalletEncryptResult,
+	WalletInterface,
+} from "@bsv/sdk";
+import {
+	type NftUtxo,
+	type Utxo,
+	fetchNftUtxos,
+	fetchPayUtxos,
+} from "js-1sat-ord";
+
+export class Wallet extends ProtoWallet implements WalletInterface {
+	private paymentUtxos: Utxo[] = [];
+	private nftUtxos: NftUtxo[] = [];
+	private lastUtxoFetch = 0;
+	private readonly utxoRefreshIntervalMs = 5 * 60 * 1000; // 5 minutes
+	private privateKey?: PrivateKey;
+
+	constructor(privKey?: PrivateKey) {
+		super(privKey);
+		this.privateKey = privKey;
+		// Initialize UTXOs
+		this.refreshUtxos().catch((err) =>
+			console.error("Error initializing UTXOs:", err),
+		);
+	}
+
+	/**
+	 * Refresh UTXOs from the network
+	 */
+	async refreshUtxos(): Promise<void> {
+		try {
+			const privateKey = this.getPrivateKey();
+			if (!privateKey) {
+				console.warn("No private key available for fetching UTXOs");
+				return;
+			}
+
+			const address = privateKey.toAddress();
+			console.log(`Fetching UTXOs for address: ${address}`);
+
+			const utxos = await fetchPayUtxos(address);
+			const nftUtxos = await fetchNftUtxos(address);
+			this.paymentUtxos = utxos;
+			this.nftUtxos = nftUtxos;
+			this.lastUtxoFetch = Date.now();
+
+			// console.log(`Fetched ${utxos.length} UTXOs for address ${address}`);
+		} catch (error) {
+			console.error("Error refreshing UTXOs:", error);
+			throw error;
+		}
+	}
+
+	/**
+	 * Get payment and NFT UTXOs, refreshing if needed
+	 */
+	async getUtxos(): Promise<{ paymentUtxos: Utxo[]; nftUtxos: NftUtxo[] }> {
+		const now = Date.now();
+		if (now - this.lastUtxoFetch > this.utxoRefreshIntervalMs) {
+			await this.refreshUtxos();
+		}
+		return { paymentUtxos: this.paymentUtxos, nftUtxos: this.nftUtxos };
+	}
+
+	/**
+	 * Get the private key if available
+	 */
+	getPrivateKey(): PrivateKey | undefined {
+		// Try to get private key from environment if not already set
+		if (!this.privateKey) {
+			const wif = process.env.PRIVATE_KEY_WIF;
+			if (wif) {
+				this.privateKey = PrivateKey.fromWif(wif);
+			}
+		}
+		return this.privateKey;
+	}
+
+	async getPublicKey(args: GetPublicKeyArgs): Promise<GetPublicKeyResult> {
+		return Promise.reject(new Error("Not implemented"));
+	}
+	async revealCounterpartyKeyLinkage(
+		args: RevealCounterpartyKeyLinkageArgs,
+	): Promise<RevealCounterpartyKeyLinkageResult> {
+		return Promise.reject(new Error("Not implemented"));
+	}
+	async revealSpecificKeyLinkage(
+		args: RevealSpecificKeyLinkageArgs,
+	): 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"));
+	}
+	async createAction(args: CreateActionArgs): Promise<CreateActionResult> {
+		console.log("createAction called with", args);
+
+		const tx = new Transaction();
+
+		// Add outputs
+		if (args.outputs) {
+			for (const output of args.outputs) {
+				const lockingScript = LockingScript.fromHex(output.lockingScript);
+				tx.addOutput({
+					lockingScript,
+					satoshis: output.satoshis,
+				});
+			}
+		}
+
+		// Add inputs (if provided)
+		if (args.inputs) {
+			for (const input of args.inputs) {
+				const [txid, outputIndexStr] = input.outpoint.split(".");
+				tx.addInput({
+					sourceTXID: txid,
+					sourceOutputIndex: Number.parseInt(outputIndexStr || "0", 10),
+				});
+			}
+		}
+
+		// Set lockTime and version if provided
+		if (args.lockTime !== undefined) tx.lockTime = args.lockTime;
+		if (args.version !== undefined) tx.version = args.version;
+
+		// Serialize the transaction using Utils
+		const txid = tx.hash("hex") as string;
+		const txArray = tx.toBinary();
+
+		return {
+			txid,
+			tx: txArray,
+			signableTransaction: undefined,
+		};
+	}
+	async signAction(args: SignActionArgs): Promise<SignActionResult> {
+		return Promise.reject(new Error("Not implemented"));
+	}
+	async abortAction(args: AbortActionArgs): Promise<AbortActionResult> {
+		return Promise.reject(new Error("Not implemented"));
+	}
+	async listActions(args: ListActionsArgs): Promise<ListActionsResult> {
+		return Promise.reject(new Error("Not implemented"));
+	}
+	async internalizeAction(
+		args: InternalizeActionArgs,
+	): Promise<InternalizeActionResult> {
+		return Promise.reject(new Error("Not implemented"));
+	}
+	async listOutputs(args: ListOutputsArgs): Promise<ListOutputsResult> {
+		return Promise.reject(new Error("Not implemented"));
+	}
+	async relinquishOutput(
+		args: RelinquishOutputArgs,
+	): Promise<RelinquishOutputResult> {
+		return Promise.reject(new Error("Not implemented"));
+	}
+	async acquireCertificate(
+		args: AcquireCertificateArgs,
+	): Promise<WalletCertificate> {
+		return Promise.reject(new Error("Not implemented"));
+	}
+	async listCertificates(
+		args: ListCertificatesArgs,
+	): Promise<ListCertificatesResult> {
+		return Promise.reject(new Error("Not implemented"));
+	}
+	async proveCertificate(
+		args: ProveCertificateArgs,
+	): Promise<ProveCertificateResult> {
+		return Promise.reject(new Error("Not implemented"));
+	}
+	async relinquishCertificate(
+		args: RelinquishCertificateArgs,
+	): Promise<RelinquishCertificateResult> {
+		return Promise.reject(new Error("Not implemented"));
+	}
+	async discoverByIdentityKey(
+		args: DiscoverByIdentityKeyArgs,
+	): Promise<DiscoverCertificatesResult> {
+		return Promise.reject(new Error("Not implemented"));
+	}
+	async discoverByAttributes(
+		args: DiscoverByAttributesArgs,
+	): Promise<DiscoverCertificatesResult> {
+		return Promise.reject(new Error("Not implemented"));
+	}
+	async isAuthenticated(args: object): Promise<AuthenticatedResult> {
+		return Promise.reject(new Error("Not implemented"));
+	}
+	async waitForAuthentication(args: object): Promise<AuthenticatedResult> {
+		return Promise.reject(new Error("Not implemented"));
+	}
+	async getHeight(args: object): Promise<GetHeightResult> {
+		return Promise.reject(new Error("Not implemented"));
+	}
+	async getHeaderForHeight(args: GetHeaderArgs): Promise<GetHeaderResult> {
+		return Promise.reject(new Error("Not implemented"));
+	}
+	async getNetwork(args: object): Promise<GetNetworkResult> {
+		return Promise.reject(new Error("Not implemented"));
+	}
+	async getVersion(args: object): Promise<GetVersionResult> {
+		return Promise.reject(new Error("Not implemented"));
+	}
+}
+
+export default Wallet;

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+	"compilerOptions": {
+		// Environment setup & latest features
+		"lib": ["ESNext"],
+		"target": "ESNext",
+		"module": "ESNext",
+		"moduleDetection": "force",
+		"jsx": "react-jsx",
+		"allowJs": true,
+
+		// Bundler mode
+		"moduleResolution": "bundler",
+		"allowImportingTsExtensions": true,
+		"verbatimModuleSyntax": true,
+		"noEmit": true,
+
+		// Best practices
+		"strict": true,
+		"skipLibCheck": true,
+		"noFallthroughCasesInSwitch": true,
+		"noUncheckedIndexedAccess": true,
+
+		// Some stricter flags (disabled by default)
+		"noUnusedLocals": false,
+		"noUnusedParameters": false,
+		"noPropertyAccessFromIndexSignature": false
+	}
+}