bsv-mcp 0.0.16 → 0.0.18

package/README.md

@@ -143,7 +143,7 @@ Wallet tools provide core BSV wallet functionality:
 | `wallet_getPublicKey` | Retrieves a public key for a specified protocol and key ID | `{"publicKey":"032d0c73eb9270e9e009fd1f9dd77e19cf764fbad5f799560c4e8fd414e40d6fc2"}` |
 | `wallet_createSignature` | Creates a cryptographic signature for the provided data | `{"signature":[144,124,85,193,226,45,140,249,9,177,11,167,33,215,209,38,...]}` |
 | `wallet_verifySignature` | Verifies a cryptographic signature against the provided data | `{"isValid":true}` |
-| `wallet_encryption` | Combined tool for encrypting and decrypting data using the wallet's cryptographic keys (replaces separate encrypt/decrypt tools) | Encrypt: `{"ciphertext":[89,32,155,38,125,22,49,226,26,...]}` <br> Decrypt: `{"plaintext":[104,101,108,108,111,32,119,111,114,108,100]}` |
+| `wallet_encryption` | Combined tool for encrypting and decrypting data using the wallet's cryptographic keys.<br><br>**Examples:**<br>1. Encrypt text: `"Encrypt this message: Hello World"`<br>2. Decrypt data: `"Decrypt this data that was previously encrypted for me"` | Encrypt: `{"ciphertext":[89,32,155,38,125,22,49,226,26,...]}` <br> Decrypt: `{"plaintext":"hello world"}` |
 | `wallet_getAddress` | Returns a BSV address for the current wallet or a derived path | `{"address":"1ExampleBsvAddressXXXXXXXXXXXXXXXXX","status":"ok"}` |
 | `wallet_sendToAddress` | Sends BSV to a specified address (supports BSV or USD amounts) | `{"status":"success","txid":"a1b2c3d4e5f6...","satoshis":1000000}` |
 | `wallet_purchaseListing` | Purchases NFTs or BSV-20/BSV-21 tokens from marketplace listings | `{"status":"success","txid":"a1b2c3d4e5f6...","type":"nft","origin":"abcdef123456..."}` |

package/index.ts

@@ -37,7 +37,7 @@ const privKey = validatePrivateKey();
 
 const server = new McpServer({
 	name: "Bitcoin SV MCP Server",
-	version: "0.0.16",
+	version: "0.0.18",
 });
 
 // Initialize wallet with the validated private key

package/package.json

@@ -2,7 +2,7 @@
 	"name": "bsv-mcp",
 	"module": "index.ts",
 	"type": "module",
-	"version": "0.0.16",
+	"version": "0.0.18",
 	"license": "MIT",
 	"author": "satchmo",
 	"description": "A collection of Bitcoin SV (BSV) tools for the Model Context Protocol (MCP) framework",

package/tools/wallet/schemas.ts

@@ -74,17 +74,13 @@ export const walletDecryptArgsSchema = z.object({
 
 // Combined wallet encryption/decryption args
 export const walletEncryptionArgsSchema = z.object({
-	mode: z.enum(["encrypt", "decrypt"]).describe("Operation mode: 'encrypt' to encrypt data or 'decrypt' to decrypt data"),
-	data: z.array(z.number()).describe("Data to process: plaintext for encryption or ciphertext for decryption"),
-	protocolID: walletProtocolSchema.describe("Protocol identifier - common values are 'aes' for symmetric encryption or 'ecies' for asymmetric encryption"),
-	keyID: z.string().describe("Key identifier - use 'default' or 'primary' for the default wallet key"),
-	privilegedReason: z.string().optional().describe("Required reason for privileged operations"),
-	counterparty: z
-		.union([z.string(), z.literal("self"), z.literal("anyone")])
-		.optional()
-		.describe("Recipient of encryption. Use 'self' for personal encryption, or provide a specific key for a recipient"),
-	privileged: z.boolean().optional().describe("Indicates if operation requires elevated privileges"),
-}).describe("Combined schema for encryption and decryption operations. Use 'mode' to specify the operation type, with required parameters data, protocolID, and keyID.");
+	mode: z.enum(["encrypt", "decrypt"]).describe("Operation mode: 'encrypt' to encrypt plaintext or 'decrypt' to decrypt data"),
+	data: z.union([
+		z.string().describe("Text data to encrypt or decrypt"),
+		z.array(z.number()).describe("Binary data to encrypt or decrypt")
+	]).describe("Data to process: text/data for encryption or decryption"),
+	encoding: z.enum(["utf8", "hex", "base64"]).optional().default("utf8").describe("Encoding of text data (default: utf8)"),
+}).describe("Schema for encryption and decryption operations");
 
 // Create HMAC arguments
 export const createHmacArgsSchema = z.object({

package/tools/wallet/tools.ts

@@ -39,6 +39,7 @@ import type { createOrdinalsArgsSchema } from "./createOrdinals";
 import { registerGetAddressTool } from "./getAddress";
 import { registerPurchaseListingTool } from "./purchaseListing";
 import { registerSendToAddressTool } from "./sendToAddress";
+import { Utils, type WalletProtocol } from "@bsv/sdk";
 
 // Define mapping from tool names to argument schemas
 type ToolArgSchemas = {
@@ -176,25 +177,18 @@ export function registerWalletTools(
 		"Combined tool for encrypting and decrypting data using the wallet's cryptographic keys.\n\n" +
 		"PARAMETERS:\n" +
 		"- mode: (required) Either \"encrypt\" to encrypt plaintext or \"decrypt\" to decrypt ciphertext\n" +
-		"- data: (required) Array of byte values to process (plaintext for encryption or ciphertext for decryption)\n" +
-		"- protocolID: (required) Protocol to use (commonly \"aes\" or \"ecies\")\n" +
-		"- keyID: (required) Key identifier (use \"default\" or \"primary\" for default wallet key)\n" +
-		"- counterparty: (optional) Set to \"self\" for personal encryption or specific key for recipient\n" +
-		"- privileged: (optional) Boolean indicating if operation requires elevated privileges\n\n" +
+		"- data: (required) Text string or array of numbers to process\n" +
+		"- encoding: (optional) For text input, the encoding format (utf8, hex, base64) - default is utf8\n\n" +
 		"EXAMPLES:\n" +
-		"1. Encrypt data:\n" +
+		"1. Encrypt text data:\n" +
 		"   {\n" +
 		"     \"mode\": \"encrypt\",\n" +
-		"     \"data\": [84, 104, 105, 115, 32, 105, 115, 32, 116, 101, 115, 116],\n" +
-		"     \"protocolID\": \"aes\",\n" +
-		"     \"keyID\": \"default\"\n" +
+		"     \"data\": \"Hello World\"\n" +
 		"   }\n\n" +
 		"2. Decrypt previously encrypted data:\n" +
 		"   {\n" +
 		"     \"mode\": \"decrypt\",\n" +
-		"     \"data\": [encrypted bytes from previous response],\n" +
-		"     \"protocolID\": \"aes\",\n" +
-		"     \"keyID\": \"default\"\n" +
+		"     \"data\": [encrypted bytes from previous response]\n" +
 		"   }",
 		{ args: walletEncryptionArgsSchema },
 		async (
@@ -202,32 +196,63 @@ export function registerWalletTools(
 			extra: RequestHandlerExtra,
 		) => {
 			try {
-				let result: { ciphertext?: number[]; plaintext?: number[] };
-				if (args.mode === "encrypt") {
-					// For encryption, the data is treated as plaintext
+				const { mode, data, encoding } = args;
+				
+				// Set default values for required parameters
+				const protocolID: WalletProtocol = [1, "aes256"];
+				const keyID = "default";
+				
+				// Convert string data to binary if needed
+				let binaryData: number[];
+				if (Array.isArray(data)) {
+					binaryData = data;
+				} else {
+					// String data with encoding
+					const { toArray } = Utils;
+					binaryData = toArray(data, encoding || "utf8");
+				}
+				
+				let result: { ciphertext?: number[]; plaintext?: number[] | string } = {};
+				if (mode === "encrypt") {
 					result = await wallet.encrypt({
-						plaintext: args.data,
-						protocolID: args.protocolID,
-						keyID: args.keyID,
-						privilegedReason: args.privilegedReason,
-						counterparty: args.counterparty,
-						privileged: args.privileged,
+						plaintext: binaryData,
+						protocolID,
+						keyID,
 					});
-				} else {
-					// For decryption, the data is treated as ciphertext
+				} else if (mode === "decrypt") {
 					result = await wallet.decrypt({
-						ciphertext: args.data,
-						protocolID: args.protocolID,
-						keyID: args.keyID,
-						privilegedReason: args.privilegedReason,
-						counterparty: args.counterparty,
-						privileged: args.privileged,
+						ciphertext: binaryData,
+						protocolID,
+						keyID,
 					});
+					
+					// For decryption, convert plaintext back to string if it's likely UTF-8 text
+					if (result.plaintext as number[]) {
+						try {
+							const { toUTF8 } = Utils;
+							const textResult = toUTF8(result.plaintext as number[]);
+							// If conversion succeeds and seems like valid text, return as string
+							if (textResult && textResult.length > 0) {
+								return { 
+									content: [{ 
+										type: "text", 
+										text: JSON.stringify({ plaintext: textResult }) 
+									}] 
+								};
+							}
+						} catch (e) {
+							// If UTF-8 conversion fails, continue with binary result
+						}
+					}
 				}
+				
 				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 };
+			} catch (error) {
+				const errorMessage = error instanceof Error ? error.message : String(error);
+				return { 
+					content: [{ type: "text", text: `Error during ${args.mode}: ${errorMessage}` }],
+					isError: true
+				};
 			}
 		},
 	);