bsv-mcp 0.0.1 → 0.0.2

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
@@ -255,4 +259,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.2",
 	"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/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,20 @@
-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 ExistingListing,
+	type Payment,
 	type Utxo,
 	oneSatBroadcaster,
 	purchaseOrdListing,
 } 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";
 
@@ -32,7 +39,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 to create a purchase transaction with market fee
  * 5. Broadcasts the transaction
  * 6. Returns the transaction details
  */
@@ -46,7 +53,7 @@ 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("Using wallet instance:", wallet);
@@ -74,6 +81,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) {
@@ -112,16 +133,33 @@ 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.`,
 					);
 				}
 
+				// 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 using the library's config type
 				const transaction = await purchaseOrdListing({
 					utxos: paymentUtxos,
 					paymentPk,
 					ordAddress: args.ordAddress,
 					listing,
+					additionalPayments,
+					metaData,
 				});
 
 				// After successful transaction creation, refresh the wallet's UTXOs
@@ -162,6 +200,8 @@ Please fund this wallet address with enough BSV to cover the purchase price
 								listingOutpoint: args.listingOutpoint,
 								destinationAddress: args.ordAddress,
 								price: listingData.data.list.price,
+								marketFee,
+								marketFeeAddress: MARKET_WALLET_ADDRESS,
 							}),
 						},
 					],

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,48 @@
-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";
+import { registerSendOrdinalsTool } from "./sendOrdinals";
+import type { sendOrdinalsArgsSchema } from "./sendOrdinals";
+
 // Define mapping from tool names to argument schemas
 type ToolArgSchemas = {
 	wallet_getPublicKey: typeof getPublicKeyArgsSchema;
@@ -70,6 +73,8 @@ type ToolArgSchemas = {
 	wallet_getAddress: typeof getAddressArgsSchema;
 	wallet_sendToAddress: typeof sendToAddressArgsSchema;
 	wallet_purchaseListing: typeof purchaseListingArgsSchema;
+	wallet_createOrdinals: typeof createOrdinalsArgsSchema;
+	wallet_sendOrdinals: typeof sendOrdinalsArgsSchema;
 };
 
 // Define a type for the handler function with proper argument types
@@ -202,5 +207,11 @@ export function registerWalletTools(
 		},
 	);
 
+	// Register ordinals extension tools
+	// Register the wallet_createOrdinals tool
+	registerCreateOrdinalsTool(server, wallet);
+	// Register the wallet_sendOrdinals tool
+	registerSendOrdinalsTool(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);