schemas.ts•9.82 kB
import type { SecurityLevel } from "@bsv/sdk";
import { z } from "zod";
// Define SecurityLevel to match the BSV SDK exactly
const SecurityLevelEnum = z.union([z.literal(0), z.literal(1), z.literal(2)]);
// Create a custom validator without tuples
export const walletProtocolSchema = z.custom<[SecurityLevel, string]>((val) => {
return (
Array.isArray(val) &&
val.length === 2 &&
(val[0] === 0 || val[0] === 1 || val[0] === 2) &&
typeof val[1] === "string"
);
});
// Empty args schema for functions that don't take arguments
export const emptyArgsSchema = z.object({});
// Get public key arguments
export const getPublicKeyArgsSchema = z.object({});
// Create signature arguments
export const createSignatureArgsSchema = z.object({
data: z.array(z.number()).optional(),
hashToDirectlySign: z.array(z.number()).optional(),
protocolID: walletProtocolSchema,
keyID: z.string(),
privilegedReason: z.string().optional(),
counterparty: z
.union([z.string(), z.literal("self"), z.literal("anyone")])
.optional(),
privileged: z.boolean().optional(),
});
// Verify signature arguments
export const verifySignatureArgsSchema = z.object({
data: z.array(z.number()).optional(),
hashToDirectlyVerify: z.array(z.number()).optional(),
signature: z.array(z.number()),
protocolID: walletProtocolSchema,
keyID: z.string(),
privilegedReason: z.string().optional(),
counterparty: z
.union([z.string(), z.literal("self"), z.literal("anyone")])
.optional(),
forSelf: z.boolean().optional(),
privileged: z.boolean().optional(),
});
// Wallet encryption args
export const walletEncryptArgsSchema = z.object({
plaintext: z.array(z.number()),
protocolID: walletProtocolSchema,
keyID: z.string(),
privilegedReason: z.string().optional(),
counterparty: z
.union([z.string(), z.literal("self"), z.literal("anyone")])
.optional(),
privileged: z.boolean().optional(),
});
// Wallet decryption args
export const walletDecryptArgsSchema = z.object({
ciphertext: z.array(z.number()),
protocolID: walletProtocolSchema,
keyID: z.string(),
privilegedReason: z.string().optional(),
counterparty: z
.union([z.string(), z.literal("self"), z.literal("anyone")])
.optional(),
privileged: z.boolean().optional(),
});
// Combined wallet encryption/decryption args
export const walletEncryptionArgsSchema = z
.object({
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({
message: z.string(),
encoding: z.enum(["utf8", "hex", "base64"]).optional(),
});
// Verify HMAC arguments
export const verifyHmacArgsSchema = z.object({
message: z.string(),
hmac: z.string(),
publicKey: z.string(),
encoding: z.enum(["utf8", "hex", "base64"]).optional(),
});
// Transaction input schema
export const transactionInputSchema = z.object({
outpoint: z.string(),
inputDescription: z.string(), // Required field
sequence: z.number().optional(),
});
// Transaction output schema
export const transactionOutputSchema = z.object({
lockingScript: z.string(),
satoshis: z.number(),
outputDescription: z.string(), // Required field
change: z.boolean().optional(),
});
// Create action args
export const createActionArgsSchema = z.object({
description: z.string(),
labels: z.array(z.string()).optional(),
lockTime: z.number().optional(),
version: z.number().optional(),
inputBEEF: z.array(z.number()).optional(),
inputs: z.array(transactionInputSchema).optional(),
outputs: z.array(transactionOutputSchema).optional(),
options: z.record(z.union([z.string(), z.number(), z.boolean()])).optional(),
});
// Sign action args
export const signActionArgsSchema = z.object({
reference: z.string(),
spends: z.record(z.any()).optional(),
options: z.record(z.union([z.string(), z.number(), z.boolean()])).optional(),
});
// List actions args
export const listActionsArgsSchema = z.object({
labels: z.array(z.string()),
labelQueryMode: z.enum(["any", "all"]).optional(),
limit: z.number().optional(),
offset: z.number().optional(),
includeInputs: z.boolean().optional(),
includeOutputs: z.boolean().optional(),
includeLabels: z.boolean().optional(),
includeInputSourceLockingScripts: z.boolean().optional(),
includeInputUnlockingScripts: z.boolean().optional(),
seekPermission: z.boolean().optional(),
});
// List outputs args
export const listOutputsArgsSchema = z.object({
basket: z.string(),
tags: z.array(z.string()).optional(),
tagQueryMode: z.enum(["all", "any"]).optional(),
limit: z.number().optional(),
offset: z.number().optional(),
include: z.enum(["locking scripts", "entire transactions"]).optional(),
includeLabels: z.boolean().optional(),
includeTags: z.boolean().optional(),
includeCustomInstructions: z.boolean().optional(),
seekPermission: z.boolean().optional(),
});
// Reveal counterparty key linkage args
export const revealCounterpartyKeyLinkageArgsSchema = z.object({
counterparty: z.string(),
verifier: z.string(),
privileged: z.boolean().optional(),
privilegedReason: z.string().optional(),
});
// Reveal specific key linkage args
export const revealSpecificKeyLinkageArgsSchema = z.object({
keyID: z.number(),
verifier: z.string(),
privileged: z.boolean().optional(),
privilegedReason: z.string().optional(),
});
// Abort action args
export const abortActionArgsSchema = z.object({
reference: z.string(),
});
// Internalize action args
export const internalizeActionArgsSchema = z.object({
tx: z.array(z.number()),
outputs: z.array(
z.object({
outputIndex: z.number(),
protocol: z.enum(["wallet payment", "basket insertion"]),
lockingScript: z.string(),
satoshis: z.number(),
}),
),
description: z.string(),
labels: z.array(z.string()).optional(),
seekPermission: z.boolean().optional(),
});
// Relinquish output args
export const relinquishOutputArgsSchema = z.object({
basket: z.string(),
output: z.string(),
});
// Acquire certificate args
export const acquireCertificateArgsSchema = z.object({
type: z.string(),
certifier: z.string(),
acquisitionProtocol: z.enum(["direct", "issuance"]),
fields: z.record(z.string()),
certifierUrl: z.string().optional(),
serialNumber: z.string().optional(),
signature: z.string().optional(),
revocationOutpoint: z.string().optional(),
keyringForSubject: z.record(z.string()).optional(),
keyringRevealer: z.string().optional(),
privileged: z.boolean().optional(),
privilegedReason: z.string().optional(),
});
// List certificates args
export const listCertificatesArgsSchema = z.object({
certifiers: z.array(z.string()),
types: z.array(z.string()),
limit: z.number().optional(),
offset: z.number().optional(),
privileged: z.boolean().optional(),
privilegedReason: z.string().optional(),
});
// Prove certificate args
export const proveCertificateArgsSchema = z.object({
certificate: z.object({}),
fieldsToReveal: z.array(z.string()),
verifier: z.string(),
privileged: z.boolean().optional(),
privilegedReason: z.string().optional(),
});
// Relinquish certificate args
export const relinquishCertificateArgsSchema = z.object({
type: z.string(),
serialNumber: z.string(),
certifier: z.string(),
});
// Discover by identity key args
export const discoverByIdentityKeyArgsSchema = z.object({
identityKey: z.string(),
limit: z.number().optional(),
offset: z.number().optional(),
seekPermission: z.boolean().optional(),
});
// Discover by attributes args
export const discoverByAttributesArgsSchema = z.object({
attributes: z.record(z.string()),
limit: z.number().optional(),
offset: z.number().optional(),
seekPermission: z.boolean().optional(),
});
// Get header for height args
export const getHeaderArgsSchema = z.object({
height: z.number(),
});
// Get address args
export const getAddressArgsSchema = z.object({});
// Send to address args
export const sendToAddressArgsSchema = z.object({
address: z.string(),
amount: z.number(),
currency: z.enum(["BSV", "USD"]).optional().default("BSV"),
description: z.string().optional(),
});
/**
* Schema for purchase listing arguments
*/
export const purchaseListingArgsSchema = z
.object({
listingOutpoint: z
.string()
.describe("The outpoint of the listing to purchase (txid_vout format)"),
ordAddress: z
.string()
.describe("The ordinal address to receive the purchased item"),
listingType: z
.enum(["nft", "token"])
.default("nft")
.describe(
"Type of listing: 'nft' for ordinal NFTs, 'token' for BSV-20 tokens",
),
tokenProtocol: z
.enum(["bsv-20", "bsv-21"])
.optional()
.default("bsv-21")
.describe(
"Token protocol for token listings (required when listingType is 'token')",
),
tokenID: z
.string()
.optional()
.describe(
"Token ID for BSV-21 tokens or ticker for BSV-20 tokens (required when listingType is 'token')",
),
description: z
.string()
.optional()
.describe("Optional description for the transaction"),
})
.describe(
"Schema for the wallet_purchaseListing tool arguments (purchase NFTs or tokens), with detailed field descriptions.",
);
// Export types
export type SendToAddressArgs = z.infer<typeof sendToAddressArgsSchema>;
export type PurchaseListingArgs = z.infer<typeof purchaseListingArgsSchema>;
export type WalletEncryptionArgs = z.infer<typeof walletEncryptionArgsSchema>;