bsv-mcp 0.2.9 → 0.2.11

package/tools/wallet/transferOrdToken.ts

@@ -1,156 +1,164 @@
-import { PrivateKey } from "@bsv/sdk";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import {
-	type Distribution,
-	type LocalSigner,
-	OneSatBroadcaster,
-	type Payment,
-	selectTokenUtxos,
-	type TokenChangeResult,
-	TokenInputMode,
-	TokenSelectionStrategy,
-	TokenType,
-	type TokenUtxo,
-	type TransferOrdTokensConfig,
-	transferOrdTokens,
-	type Utxo,
-} from "js-1sat-ord";
-import { z } from "zod";
-import { V5Broadcaster } from "../../utils/broadcaster";
-import type { Wallet } from "./wallet";
+import type { OneSatContext } from '@1sat/actions'
+import { sendBsv21, transferOrdinals } from '@1sat/actions'
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { z } from 'zod'
+
+const walletOutputSchema = z.object({
+	outpoint: z.string(),
+	satoshis: z.number().optional(),
+	tags: z.array(z.string()).optional(),
+	customInstructions: z.string().optional(),
+	lockingScript: z.string().optional(),
+})
 
-// Schema for BSV-20/BSV-21 token transfer arguments
 export const transferOrdTokenArgsSchema = z.object({
-	protocol: z.enum(["bsv-20", "bsv-21"]),
-	tokenID: z.string(),
-	sendAmount: z.number(),
-	paymentUtxos: z.array(
-		z.object({
-			txid: z.string(),
-			vout: z.number(),
-			satoshis: z.number(),
-			script: z.string(),
-		}),
-	),
-	tokenUtxos: z.array(
-		z.object({
-			txid: z.string(),
-			vout: z.number(),
-			satoshis: z.literal(1),
-			script: z.string(),
-			amt: z.string(),
-			id: z.string(),
-		}),
+	type: z.enum(['ordinal', 'bsv21']).describe(
+		"'ordinal' to transfer an inscription/NFT, 'bsv21' to send fungible BSV21 tokens",
 	),
-	distributions: z.array(z.object({ address: z.string(), tokens: z.number() })),
-	decimals: z.number(),
-	additionalPayments: z
-		.array(z.object({ to: z.string(), amount: z.number() }))
-		.optional(),
-});
-export type TransferOrdTokenArgs = z.infer<typeof transferOrdTokenArgsSchema>;
+	// ordinal fields
+	ordinal: walletOutputSchema
+		.optional()
+		.describe(
+			"WalletOutput of the ordinal to transfer (from wallet_getOrdinals). Required when type='ordinal'",
+		),
+	inputBEEF: z
+		.array(z.number())
+		.optional()
+		.describe(
+			"BEEF bytes from listOutputs (include: 'entire transactions'). Required when type='ordinal'",
+		),
+	// bsv21 fields
+	tokenId: z
+		.string()
+		.optional()
+		.describe("Token ID (txid_vout format). Required when type='bsv21'"),
+	amount: z
+		.string()
+		.optional()
+		.describe("Amount of tokens to send as a string integer. Required when type='bsv21'"),
+	// shared destination fields
+	address: z.string().optional().describe('Recipient P2PKH address'),
+	counterparty: z
+		.string()
+		.optional()
+		.describe('Recipient identity public key (hex)'),
+})
+
+export type TransferOrdTokenArgs = z.infer<typeof transferOrdTokenArgsSchema>
 
-/**
- * Register the wallet_transferOrdToken tool for transferring BSV tokens.
- */
 export function registerTransferOrdTokenTool(
 	server: McpServer,
-	wallet: Wallet,
+	ctx: OneSatContext | undefined,
 ) {
 	server.tool(
-		"wallet_transferOrdToken",
-		"Transfers BSV-20 or BSV-21 tokens from your wallet via js-1sat-ord transferOrdTokens.",
+		'wallet_transferOrdToken',
+		"Transfer an ordinal inscription or send BSV21 fungible tokens. Use type='ordinal' to transfer an NFT/inscription (requires the WalletOutput from wallet_getOrdinals and the BEEF). Use type='bsv21' to send fungible tokens by token ID and amount.",
 		{ ...transferOrdTokenArgsSchema.shape },
-		async ({ protocol, tokenID, sendAmount, paymentUtxos, tokenUtxos, distributions, decimals, additionalPayments }) => {
-			try {
-				// fetch keys
-				const paymentPk = wallet.getPaymentKey();
-				if (!paymentPk) throw new Error("No private key available");
-				const ordPk = paymentPk;
-				const changeAddress = paymentPk.toAddress().toString();
-				const ordAddress = changeAddress;
+		async ({ type, ordinal, inputBEEF, tokenId, amount, address, counterparty }) => {
+			if (!ctx) {
+				return {
+					content: [
+						{
+							type: 'text',
+							text: 'Wallet not initialized. Please configure a wallet before transferring.',
+						},
+					],
+					isError: true,
+				}
+			}
 
-				// select token UTXOs
-				const { selectedUtxos: inputTokens } = selectTokenUtxos(
-					tokenUtxos as TokenUtxo[],
-					sendAmount,
-					decimals,
-					{
-						inputStrategy: TokenSelectionStrategy.SmallestFirst,
-						outputStrategy: TokenSelectionStrategy.LargestFirst,
-					},
-				);
+			try {
+				if (type === 'ordinal') {
+					if (!ordinal) {
+						return {
+							content: [{ type: 'text', text: "ordinal is required when type='ordinal'" }],
+							isError: true,
+						}
+					}
+					if (!inputBEEF) {
+						return {
+							content: [{ type: 'text', text: "inputBEEF is required when type='ordinal'" }],
+							isError: true,
+						}
+					}
+					if (!address && !counterparty) {
+						return {
+							content: [{ type: 'text', text: 'address or counterparty is required' }],
+							isError: true,
+						}
+					}
 
-				// build config
-				const config: TransferOrdTokensConfig = {
-					protocol:
-						protocol === "bsv-20" ? TokenType.BSV20 : TokenType.BSV21,
-					tokenID,
-					utxos: paymentUtxos as Utxo[],
-					inputTokens,
-					distributions: distributions as Distribution[],
-					tokenChangeAddress: ordAddress,
-					changeAddress,
-					paymentPk,
-					ordPk,
-					additionalPayments: (additionalPayments as Payment[]) || [],
-					decimals,
-					inputMode: TokenInputMode.Needed,
-					splitConfig: {
-						outputs: inputTokens.length === 1 ? 2 : 1,
-						threshold: sendAmount,
-					},
-				};
+					const result = await transferOrdinals.execute(ctx, {
+						transfers: [
+							{
+								ordinal: ordinal as Parameters<typeof transferOrdinals.execute>[1]['transfers'][0]['ordinal'],
+								address,
+								counterparty,
+							},
+						],
+						inputBEEF,
+					})
 
-				const identityPk = process.env.IDENTITY_KEY_WIF
-					? PrivateKey.fromWif(process.env.IDENTITY_KEY_WIF)
-					: undefined;
+					if (result.error) {
+						return {
+							content: [{ type: 'text', text: result.error }],
+							isError: true,
+						}
+					}
 
-				if (identityPk) {
-					config.signer = {
-						idKey: identityPk,
-					} as LocalSigner;
+					return {
+						content: [{ type: 'text', text: JSON.stringify({ txid: result.txid }) }],
+					}
 				}
 
-				// execute transfer
-				const result: TokenChangeResult = await transferOrdTokens(config);
-				const disableBroadcasting = process.env.DISABLE_BROADCASTING === "true";
-				if (!disableBroadcasting) {
-					const broadcaster = new V5Broadcaster();
-					await result.tx.broadcast(broadcaster);
+				// bsv21
+				if (!tokenId) {
+					return {
+						content: [{ type: 'text', text: "tokenId is required when type='bsv21'" }],
+						isError: true,
+					}
+				}
+				if (!amount) {
+					return {
+						content: [{ type: 'text', text: "amount is required when type='bsv21'" }],
+						isError: true,
+					}
+				}
+				if (!address && !counterparty) {
+					return {
+						content: [{ type: 'text', text: 'address or counterparty is required' }],
+						isError: true,
+					}
+				}
 
-					// refresh UTXOs
-					try {
-						await wallet.refreshUtxos();
-					} catch {}
+				const result = await sendBsv21.execute(ctx, {
+					tokenId,
+					amount,
+					address,
+					counterparty,
+				})
 
-					// respond
+				if (result.error) {
 					return {
-						content: [
-							{
-								type: "text",
-								text: JSON.stringify({
-									txid: result.tx.id("hex"),
-									spentOutpoints: result.spentOutpoints,
-									payChange: result.payChange,
-									tokenChange: result.tokenChange,
-								}),
-							},
-						],
-					};
+						content: [{ type: 'text', text: result.error }],
+						isError: true,
+					}
 				}
+
+				return {
+					content: [{ type: 'text', text: JSON.stringify({ txid: result.txid }) }],
+				}
+			} catch (err: unknown) {
 				return {
 					content: [
 						{
-							type: "text",
-							text: result.tx.toHex(),
+							type: 'text',
+							text: err instanceof Error ? err.message : String(err),
 						},
 					],
-				};
-			} catch (err: unknown) {
-				const msg = err instanceof Error ? err.message : String(err);
-				return { content: [{ type: "text", text: msg }], isError: true };
+					isError: true,
+				}
 			}
 		},
-	);
+	)
 }

package/tools/wallet/unlockBsv.ts

@@ -0,0 +1,57 @@
+import type { OneSatContext } from '@1sat/actions'
+import { unlockBsv } from '@1sat/actions'
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+
+export function registerUnlockBsvTool(
+	server: McpServer,
+	ctx: OneSatContext | undefined,
+) {
+	server.tool(
+		'wallet_unlockBsv',
+		'Unlock all matured time-locked BSV',
+		{},
+		async () => {
+			if (!ctx) {
+				return {
+					content: [
+						{
+							type: 'text',
+							text: 'Wallet not initialized. Please configure a wallet before unlocking.',
+						},
+					],
+					isError: true,
+				}
+			}
+
+			try {
+				const result = await unlockBsv.execute(ctx, {})
+
+				if (result.error) {
+					return {
+						content: [{ type: 'text', text: result.error }],
+						isError: true,
+					}
+				}
+
+				return {
+					content: [
+						{
+							type: 'text',
+							text: JSON.stringify(result, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2),
+						},
+					],
+				}
+			} catch (err: unknown) {
+				return {
+					content: [
+						{
+							type: 'text',
+							text: err instanceof Error ? err.message : String(err),
+						},
+					],
+					isError: true,
+				}
+			}
+		},
+	)
+}

package/tools/wallet/a2bPublishAgent.ts

@@ -1,307 +0,0 @@
-import { PrivateKey, Utils } from "@bsv/sdk";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type {
-	ChangeResult,
-	CreateOrdinalsConfig,
-	Destination,
-	Inscription,
-	LocalSigner,
-	PreMAP,
-} from "js-1sat-ord";
-import { createOrdinals } from "js-1sat-ord";
-import { z } from "zod";
-import packageJson from "../../package.json";
-import { V5Broadcaster } from "../../utils/broadcaster";
-import type { Wallet } from "./wallet";
-
-const { toArray, toBase64 } = Utils;
-
-// https://raw.githubusercontent.com/google/A2A/refs/heads/main/specification/json/a2a.json
-
-// A2A AgentCard schema (per A2A spec)
-const AgentCapabilitiesSchema = z.object({
-	streaming: z.boolean().default(false),
-	pushNotifications: z.boolean().default(false),
-	stateTransitionHistory: z.boolean().default(false),
-});
-const AgentSkillSchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	description: z.string().nullable(),
-	tags: z.array(z.string()).nullable(),
-	examples: z.array(z.string()).nullable(),
-	inputModes: z.array(z.string()).nullable(),
-	outputModes: z.array(z.string()).nullable(),
-});
-
-// Provider per A2A spec
-const AgentProviderSchema = z
-	.object({
-		organization: z.string(),
-		url: z.string().url().nullable().default(null),
-	})
-	.nullable()
-	.default(null);
-
-// Authentication per A2A spec
-const AgentAuthenticationSchema = z
-	.object({
-		schemes: z.array(z.string()),
-		credentials: z.string().nullable().default(null),
-	})
-	.nullable()
-	.default(null);
-
-// Pricing plan schema
-export const PricingSchema = z.object({
-	id: z.string(),
-	description: z.string().nullable().optional(),
-	currency: z.string(),
-	amount: z
-		.number()
-		.describe(
-			"Cost in standard units of currency (e.g., BSV, USD, not satoshis)",
-		),
-	address: z.string(),
-	acceptedCurrencies: z.array(z.string()).optional(),
-	skills: z.array(z.string()).optional(),
-	interval: z.enum(["day", "week", "month", "year"]).nullable().optional(),
-	includedCalls: z.record(z.number()).optional(),
-});
-
-export type PricingConfig = z.infer<typeof PricingSchema>;
-
-export const AgentCardSchema = z.object({
-	name: z.string(),
-	description: z.string().nullable().default(null),
-	url: z.string().url(),
-	provider: AgentProviderSchema,
-	version: z.string(),
-	documentationUrl: z.string().url().nullable().default(null),
-	capabilities: AgentCapabilitiesSchema,
-	authentication: AgentAuthenticationSchema,
-	defaultInputModes: z.array(z.string()).default(["text"]),
-	defaultOutputModes: z.array(z.string()).default(["text"]),
-	skills: z.array(AgentSkillSchema),
-	"x-payment": z.array(PricingSchema).optional().default([]),
-});
-
-// Schema for on-chain agent publish parameters
-export const a2bPublishArgsSchema = z.object({
-	agentUrl: z
-		.string()
-		.url()
-		.describe("Agent base URL (e.g. https://example.com)"),
-	agentName: z.string().describe("Human-friendly agent name"),
-	description: z
-		.string()
-		.nullable()
-		.optional()
-		.describe("Optional agent description"),
-	providerOrganization: z
-		.string()
-		.optional()
-		.describe("Optional provider organization name"),
-	providerUrl: z.string().url().optional().describe("Optional provider URL"),
-	version: z.string().optional().describe("Optional agent version"),
-	documentationUrl: z
-		.string()
-		.url()
-		.nullable()
-		.optional()
-		.describe("Optional documentation URL"),
-	streaming: z
-		.boolean()
-		.default(false)
-		.describe("Supports SSE (tasks/sendSubscribe)"),
-	pushNotifications: z
-		.boolean()
-		.default(false)
-		.describe("Supports push notifications"),
-	stateTransitionHistory: z
-		.boolean()
-		.default(false)
-		.describe("Supports state transition history"),
-	defaultInputModes: z
-		.array(z.string())
-		.default(["text"])
-		.describe("Default input modes"),
-	defaultOutputModes: z
-		.array(z.string())
-		.default(["text"])
-		.describe("Default output modes"),
-	skills: z
-		.array(AgentSkillSchema)
-		.optional()
-		.default([])
-		.describe("List of agent skills"),
-	destinationAddress: z
-		.string()
-		.optional()
-		.describe("Optional target address for inscription"),
-});
-export type A2bPublishArgs = z.infer<typeof a2bPublishArgsSchema>;
-
-/**
- * Registers the wallet_a2bPublish tool for publishing an agent record on-chain
- */
-export function registerA2bPublishAgentTool(server: McpServer, wallet: Wallet) {
-	server.tool(
-		"wallet_a2bPublish",
-		"Publish an agent.json record on-chain via Ordinal inscription",
-		{ ...a2bPublishArgsSchema.shape },
-		async ({ agentUrl, agentName, description, providerOrganization, providerUrl, version, documentationUrl, streaming, pushNotifications, stateTransitionHistory, defaultInputModes, defaultOutputModes, skills, destinationAddress }) => {
-			try {
-				const paymentPk = wallet.getPaymentKey();
-				if (!paymentPk) throw new Error("No private key available");
-				const { paymentUtxos } = await wallet.getUtxos();
-				if (!paymentUtxos?.length)
-					throw new Error("No payment UTXOs available to fund inscription");
-
-				// TODO: Get the skills from actually running the MCP instead of trusting the agent args for skills
-				const walletAddress = paymentPk.toAddress().toString();
-
-				// Create pricing plans using the new schema
-				const pricingConfig: PricingConfig[] = [
-					// {
-					//   id: "subscription-premium",
-					//   description: "Premium subscription with all features",
-					//   currency: "USD",
-					//   amount: 10,
-					//   address: walletAddress,
-					//   interval: "month",
-					//   skills: ["wallet_a2bPublish", "wallet_a2bCall"],
-					// },
-					// {
-					//   id: "subscription-free",
-					//   description: "Free tier with limited features",
-					//   currency: "USD",
-					//   amount: 0,
-					//   address: walletAddress,
-					//   interval: "month",
-					//   skills: ["wallet_a2bCall"],
-					// },
-					{
-						id: "pay-per-call-default",
-						description: "Pay-per-call for publish operations",
-						currency: "USD",
-						amount: 1,
-						address: walletAddress,
-						skills: ["wallet_a2bPublish"],
-						interval: null,
-					},
-					// {
-					//   id: "pay-per-call-royalty",
-					//   description: "Royalty payment for agent",
-					//   currency: "USD",
-					//   amount: 1,
-					//   address: "1JOExxxxxxxxxxxx",
-					//   skills: ["wallet_a2bPublish"],
-					//   interval: null,
-					// }
-				];
-
-				// Assemble AgentCard with defaults and user overrides
-				const agentCard = {
-					name: agentName,
-					description: description ?? null,
-					url: agentUrl,
-					provider:
-						providerOrganization && providerUrl
-							? {
-									organization: providerOrganization,
-									url: providerUrl,
-								}
-							: null,
-					version: version ?? packageJson.version,
-					documentationUrl: documentationUrl ?? null,
-					capabilities: {
-						streaming,
-						pushNotifications,
-						stateTransitionHistory,
-					},
-					authentication: null,
-					defaultInputModes,
-					defaultOutputModes,
-					skills,
-					"x-payment-config": pricingConfig,
-				};
-				// Validate compliance
-				AgentCardSchema.parse(agentCard);
-				const fileContent = JSON.stringify(agentCard, null, 2);
-				// Base64 payload for inscription
-				const dataB64 = toBase64(toArray(fileContent));
-				const inscription: Inscription = {
-					dataB64,
-					contentType: "application/json",
-				};
-				// Destination for the ordinal
-				const targetAddress = destinationAddress ?? walletAddress;
-				const destinations: Destination[] = [
-					{ address: targetAddress, inscription },
-				];
-				// Default MAP metadata: file path, content type, encoding
-				const metaData: PreMAP = { app: "bsv-mcp", type: "a2b" };
-
-				const createOrdinalsConfig: CreateOrdinalsConfig = {
-					utxos: paymentUtxos,
-					destinations,
-					paymentPk,
-					changeAddress: walletAddress,
-					metaData,
-				};
-
-				const identityPk = process.env.IDENTITY_KEY_WIF
-					? PrivateKey.fromWif(process.env.IDENTITY_KEY_WIF)
-					: undefined;
-				if (identityPk) {
-					createOrdinalsConfig.signer = {
-						idKey: identityPk,
-					} as LocalSigner;
-				}
-
-				// Inscribe the ordinal on-chain via js-1sat-ord
-				const result = await createOrdinals(createOrdinalsConfig);
-				const changeResult = result as ChangeResult;
-
-				const disableBroadcasting = process.env.DISABLE_BROADCASTING === "true";
-				if (!disableBroadcasting) {
-					const broadcaster = new V5Broadcaster();
-					await changeResult.tx.broadcast(broadcaster);
-
-					// Refresh UTXOs
-					try {
-						await wallet.refreshUtxos();
-					} catch {}
-					// Return transaction details
-					return {
-						content: [
-							{
-								type: "text",
-								text: JSON.stringify({
-									txid: changeResult.tx.id("hex"),
-									spentOutpoints: changeResult.spentOutpoints,
-									payChange: changeResult.payChange,
-									inscriptionAddress: targetAddress,
-									agentCard,
-								}),
-							},
-						],
-					};
-				}
-
-				return {
-					content: [
-						{
-							type: "text",
-							text: changeResult.tx.toHex(),
-						},
-					],
-				};
-			} catch (err: unknown) {
-				const msg = err instanceof Error ? err.message : String(err);
-				return { content: [{ type: "text", text: msg }], isError: true };
-			}
-		},
-	);
-}