@1sat/wallet-toolbox 0.0.9 → 0.0.11

package/dist/api/payments/index.d.ts

@@ -1,9 +1,9 @@
 /**
  * Payments Module
  *
- * Functions for sending BSV payments.
+ * Skills for sending BSV payments.
  */
-import { type WalletInterface } from "@bsv/sdk";
+import type { Skill } from "../skills/types";
 export interface SendBsvRequest {
     /** Destination address (P2PKH) */
     address?: string;
@@ -27,11 +27,22 @@ export interface SendBsvResponse {
     rawtx?: string;
     error?: string;
 }
+/** Input for sendBsv skill */
+export interface SendBsvInput {
+    requests: SendBsvRequest[];
+}
 /**
  * Send BSV to one or more destinations.
  */
-export declare function sendBsv(cwi: WalletInterface, requests: SendBsvRequest[]): Promise<SendBsvResponse>;
+export declare const sendBsv: Skill<SendBsvInput, SendBsvResponse>;
+/** Input for sendAllBsv skill */
+export interface SendAllBsvInput {
+    /** Destination address to send all funds to */
+    destination: string;
+}
 /**
  * Send all BSV to a destination address.
  */
-export declare function sendAllBsv(cwi: WalletInterface, destination: string): Promise<SendBsvResponse>;
+export declare const sendAllBsv: Skill<SendAllBsvInput, SendBsvResponse>;
+/** All payment skills for registry */
+export declare const paymentsSkills: (Skill<SendBsvInput, SendBsvResponse> | Skill<SendAllBsvInput, SendBsvResponse>)[];

package/dist/api/payments/index.js

@@ -1,20 +1,17 @@
 /**
  * Payments Module
  *
- * Functions for sending BSV payments.
+ * Skills for sending BSV payments.
  */
-import { P2PKH, Script, Utils, } from "@bsv/sdk";
+import { P2PKH, Script, Utils } from "@bsv/sdk";
 import { Inscription } from "@bopen-io/templates";
 import { FUNDING_BASKET } from "../constants";
-/**
- * Check if address is a paymail.
- */
+// ============================================================================
+// Internal helpers
+// ============================================================================
 function isPaymail(address) {
     return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(address);
 }
-/**
- * Build an inscription locking script.
- */
 function buildInscriptionScript(address, base64Data, mimeType) {
     const content = Utils.toArray(base64Data, "base64");
     const inscription = Inscription.create(new Uint8Array(content), mimeType);
@@ -30,101 +27,159 @@ function buildInscriptionScript(address, base64Data, mimeType) {
 /**
  * Send BSV to one or more destinations.
  */
-export async function sendBsv(cwi, requests) {
-    try {
-        if (!requests || requests.length === 0) {
-            return { error: "no-requests" };
-        }
-        const outputs = [];
-        for (const req of requests) {
-            let lockingScript;
-            if (req.script) {
-                lockingScript = Script.fromHex(req.script);
+export const sendBsv = {
+    meta: {
+        name: "sendBsv",
+        description: "Send BSV to one or more destinations (addresses, scripts, or OP_RETURN)",
+        category: "payments",
+        inputSchema: {
+            type: "object",
+            properties: {
+                requests: {
+                    type: "array",
+                    description: "Array of payment requests",
+                    items: {
+                        type: "object",
+                        properties: {
+                            address: { type: "string", description: "Destination P2PKH address" },
+                            paymail: { type: "string", description: "Destination paymail address" },
+                            satoshis: { type: "integer", description: "Amount in satoshis" },
+                            script: { type: "string", description: "Custom locking script (hex)" },
+                            data: {
+                                type: "array",
+                                description: "OP_RETURN data elements",
+                                items: { type: "string" },
+                            },
+                        },
+                        required: ["satoshis"],
+                    },
+                },
+            },
+            required: ["requests"],
+        },
+    },
+    async execute(ctx, input) {
+        try {
+            const { requests } = input;
+            if (!requests || requests.length === 0) {
+                return { error: "no-requests" };
             }
-            else if (req.address) {
-                if (req.inscription) {
-                    lockingScript = buildInscriptionScript(req.address, req.inscription.base64Data, req.inscription.mimeType);
+            const outputs = [];
+            for (const req of requests) {
+                let lockingScript;
+                if (req.script) {
+                    lockingScript = Script.fromHex(req.script);
                 }
-                else {
-                    lockingScript = new P2PKH().lock(req.address);
+                else if (req.address) {
+                    if (req.inscription) {
+                        lockingScript = buildInscriptionScript(req.address, req.inscription.base64Data, req.inscription.mimeType);
+                    }
+                    else {
+                        lockingScript = new P2PKH().lock(req.address);
+                    }
                 }
-            }
-            else if (req.data && req.data.length > 0) {
-                try {
-                    lockingScript = Script.fromASM(`OP_0 OP_RETURN ${req.data.join(" ")}`);
+                else if (req.data && req.data.length > 0) {
+                    try {
+                        lockingScript = Script.fromASM(`OP_0 OP_RETURN ${req.data.join(" ")}`);
+                    }
+                    catch {
+                        return { error: "invalid-data" };
+                    }
                 }
-                catch {
-                    return { error: "invalid-data" };
+                else if (req.paymail) {
+                    return { error: "paymail-not-yet-implemented" };
                 }
+                else {
+                    return { error: "invalid-request" };
+                }
+                outputs.push({
+                    lockingScript: lockingScript.toHex(),
+                    satoshis: req.satoshis,
+                    outputDescription: `Payment of ${req.satoshis} sats`,
+                });
             }
-            else if (req.paymail) {
-                return { error: "paymail-not-yet-implemented" };
-            }
-            else {
-                return { error: "invalid-request" };
-            }
-            outputs.push({
-                lockingScript: lockingScript.toHex(),
-                satoshis: req.satoshis,
-                outputDescription: `Payment of ${req.satoshis} sats`,
+            const result = await ctx.wallet.createAction({
+                description: `Send ${requests.length} payment(s)`,
+                outputs,
+                options: { signAndProcess: true },
             });
+            if (!result.txid) {
+                return { error: "no-txid-returned" };
+            }
+            return { txid: result.txid, rawtx: result.tx ? Utils.toHex(result.tx) : undefined };
         }
-        const result = await cwi.createAction({
-            description: `Send ${requests.length} payment(s)`,
-            outputs,
-            options: { signAndProcess: true },
-        });
-        if (!result.txid) {
-            return { error: "no-txid-returned" };
+        catch (error) {
+            return { error: error instanceof Error ? error.message : "unknown-error" };
         }
-        return { txid: result.txid, rawtx: result.tx ? Utils.toHex(result.tx) : undefined };
-    }
-    catch (error) {
-        return { error: error instanceof Error ? error.message : "unknown-error" };
-    }
-}
+    },
+};
 /**
  * Send all BSV to a destination address.
  */
-export async function sendAllBsv(cwi, destination) {
-    try {
-        if (isPaymail(destination)) {
-            return { error: "paymail-not-yet-implemented" };
-        }
-        const listResult = await cwi.listOutputs({
-            basket: FUNDING_BASKET,
-            include: "locking scripts",
-            limit: 10000,
-        });
-        if (!listResult.outputs || listResult.outputs.length === 0) {
-            return { error: "no-funds" };
-        }
-        const totalSats = listResult.outputs.reduce((sum, o) => sum + o.satoshis, 0);
-        const estimatedFee = Math.ceil((listResult.outputs.length * 150 + 44) * 1);
-        const sendAmount = totalSats - estimatedFee;
-        if (sendAmount <= 0) {
-            return { error: "insufficient-funds-for-fee" };
+export const sendAllBsv = {
+    meta: {
+        name: "sendAllBsv",
+        description: "Send all BSV from wallet to a single destination address",
+        category: "payments",
+        inputSchema: {
+            type: "object",
+            properties: {
+                destination: {
+                    type: "string",
+                    description: "Destination P2PKH address to send all funds to",
+                },
+            },
+            required: ["destination"],
+        },
+    },
+    async execute(ctx, input) {
+        try {
+            const { destination } = input;
+            if (isPaymail(destination)) {
+                return { error: "paymail-not-yet-implemented" };
+            }
+            const listResult = await ctx.wallet.listOutputs({
+                basket: FUNDING_BASKET,
+                include: "locking scripts",
+                limit: 10000,
+            });
+            if (!listResult.outputs || listResult.outputs.length === 0) {
+                return { error: "no-funds" };
+            }
+            const totalSats = listResult.outputs.reduce((sum, o) => sum + o.satoshis, 0);
+            const estimatedFee = Math.ceil((listResult.outputs.length * 150 + 44) * 1);
+            const sendAmount = totalSats - estimatedFee;
+            if (sendAmount <= 0) {
+                return { error: "insufficient-funds-for-fee" };
+            }
+            const inputs = listResult.outputs.map((o) => ({
+                outpoint: o.outpoint,
+                inputDescription: "Sweep funds",
+            }));
+            const result = await ctx.wallet.createAction({
+                description: "Send all BSV",
+                inputs,
+                outputs: [
+                    {
+                        lockingScript: new P2PKH().lock(destination).toHex(),
+                        satoshis: sendAmount,
+                        outputDescription: "Sweep all funds",
+                    },
+                ],
+                options: { signAndProcess: true },
+            });
+            if (!result.txid) {
+                return { error: "no-txid-returned" };
+            }
+            return { txid: result.txid, rawtx: result.tx ? Utils.toHex(result.tx) : undefined };
         }
-        const inputs = listResult.outputs.map((o) => ({
-            outpoint: o.outpoint,
-            inputDescription: "Sweep funds",
-        }));
-        const result = await cwi.createAction({
-            description: "Send all BSV",
-            inputs,
-            outputs: [{
-                    lockingScript: new P2PKH().lock(destination).toHex(),
-                    satoshis: sendAmount,
-                    outputDescription: "Sweep all funds",
-                }],
-            options: { signAndProcess: true },
-        });
-        if (!result.txid) {
-            return { error: "no-txid-returned" };
+        catch (error) {
+            return { error: error instanceof Error ? error.message : "unknown-error" };
         }
-        return { txid: result.txid, rawtx: result.tx ? Utils.toHex(result.tx) : undefined };
-    }
-    catch (error) {
-        return { error: error instanceof Error ? error.message : "unknown-error" };
-    }
-}
+    },
+};
+// ============================================================================
+// Module exports
+// ============================================================================
+/** All payment skills for registry */
+export const paymentsSkills = [sendBsv, sendAllBsv];

package/dist/api/signing/index.d.ts

@@ -1,9 +1,9 @@
 /**
  * Signing Module
  *
- * Functions for message signing.
+ * Skills for message signing.
  */
-import { type WalletInterface } from "@bsv/sdk";
+import type { Skill } from "../skills/types";
 export interface SignMessageRequest {
     /** Message to sign */
     message: string;
@@ -24,9 +24,12 @@ export interface SignedMessage {
     sig: string;
     derivationTag?: SignMessageRequest["tag"];
 }
+export interface SignMessageResponse extends Partial<SignedMessage> {
+    error?: string;
+}
 /**
  * Sign a message using BSM (Bitcoin Signed Message) format.
  */
-export declare function signMessage(cwi: WalletInterface, request: SignMessageRequest): Promise<SignedMessage | {
-    error: string;
-}>;
+export declare const signMessage: Skill<SignMessageRequest, SignMessageResponse>;
+/** All signing skills for registry */
+export declare const signingSkills: Skill<SignMessageRequest, SignMessageResponse>[];

package/dist/api/signing/index.js

@@ -1,41 +1,78 @@
 /**
  * Signing Module
  *
- * Functions for message signing.
+ * Skills for message signing.
  */
-import { BigNumber, BSM, PublicKey, Signature, Utils, } from "@bsv/sdk";
+import { BigNumber, BSM, PublicKey, Signature, Utils } from "@bsv/sdk";
 import { MESSAGE_SIGNING_PROTOCOL } from "../constants";
+// ============================================================================
+// Skills
+// ============================================================================
 /**
  * Sign a message using BSM (Bitcoin Signed Message) format.
  */
-export async function signMessage(cwi, request) {
-    try {
-        const { message, encoding = "utf8", tag } = request;
-        const messageBytes = Utils.toArray(message, encoding);
-        const msgHash = BSM.magicHash(messageBytes);
-        const keyID = tag ? `${tag.label}:${tag.id}:${tag.domain}` : "identity";
-        const result = await cwi.createSignature({
-            protocolID: MESSAGE_SIGNING_PROTOCOL,
-            keyID,
-            hashToDirectlySign: Array.from(msgHash),
-        });
-        const pubKeyResult = await cwi.getPublicKey({
-            protocolID: MESSAGE_SIGNING_PROTOCOL,
-            keyID,
-            forSelf: true,
-        });
-        const publicKey = PublicKey.fromString(pubKeyResult.publicKey);
-        const signature = Signature.fromDER(result.signature);
-        const recovery = signature.CalculateRecoveryFactor(publicKey, new BigNumber(msgHash));
-        return {
-            address: publicKey.toAddress(),
-            pubKey: publicKey.toString(),
-            message,
-            sig: signature.toCompact(recovery, true, "base64"),
-            derivationTag: tag,
-        };
-    }
-    catch (error) {
-        return { error: error instanceof Error ? error.message : "unknown-error" };
-    }
-}
+export const signMessage = {
+    meta: {
+        name: "signMessage",
+        description: "Sign a message using BSM (Bitcoin Signed Message) format",
+        category: "signing",
+        inputSchema: {
+            type: "object",
+            properties: {
+                message: { type: "string", description: "Message to sign" },
+                encoding: {
+                    type: "string",
+                    description: "Message encoding (utf8, hex, base64)",
+                    enum: ["utf8", "hex", "base64"],
+                },
+                tag: {
+                    type: "object",
+                    description: "Derivation tag for key selection",
+                    properties: {
+                        label: { type: "string" },
+                        id: { type: "string" },
+                        domain: { type: "string" },
+                        meta: { type: "object" },
+                    },
+                },
+            },
+            required: ["message"],
+        },
+    },
+    async execute(ctx, input) {
+        try {
+            const { message, encoding = "utf8", tag } = input;
+            const messageBytes = Utils.toArray(message, encoding);
+            const msgHash = BSM.magicHash(messageBytes);
+            const keyID = tag ? `${tag.label}:${tag.id}:${tag.domain}` : "identity";
+            const result = await ctx.wallet.createSignature({
+                protocolID: MESSAGE_SIGNING_PROTOCOL,
+                keyID,
+                hashToDirectlySign: Array.from(msgHash),
+            });
+            const pubKeyResult = await ctx.wallet.getPublicKey({
+                protocolID: MESSAGE_SIGNING_PROTOCOL,
+                keyID,
+                forSelf: true,
+            });
+            const publicKey = PublicKey.fromString(pubKeyResult.publicKey);
+            const signature = Signature.fromDER(result.signature);
+            const recovery = signature.CalculateRecoveryFactor(publicKey, new BigNumber(msgHash));
+            return {
+                address: publicKey.toAddress(),
+                pubKey: publicKey.toString(),
+                message,
+                sig: signature.toCompact(recovery, true, "base64"),
+                derivationTag: tag,
+            };
+        }
+        catch (error) {
+            return { error: error instanceof Error ? error.message : "unknown-error" };
+        }
+    },
+};
+// ============================================================================
+// Module exports
+// ============================================================================
+/** All signing skills for registry */
+export const signingSkills = [signMessage];

package/dist/api/skills/registry.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Skill registry for runtime discovery and MCP integration.
+ */
+import type { Skill, SkillCategory } from "./types";
+type AnySkill = Skill<any, any>;
+/**
+ * MCP-compatible tool definition.
+ */
+export interface McpTool {
+    name: string;
+    description: string;
+    inputSchema: object;
+}
+/**
+ * Registry for collecting and discovering skills at runtime.
+ */
+export declare class SkillRegistry {
+    private skills;
+    /**
+     * Register a skill.
+     */
+    register(skill: AnySkill): void;
+    /**
+     * Register multiple skills.
+     */
+    registerAll(skills: AnySkill[]): void;
+    /**
+     * Get a skill by name.
+     */
+    get(name: string): AnySkill | undefined;
+    /**
+     * Check if a skill exists.
+     */
+    has(name: string): boolean;
+    /**
+     * List all registered skills.
+     */
+    list(): Skill[];
+    /**
+     * List skills by category.
+     */
+    listByCategory(category: SkillCategory): Skill[];
+    /**
+     * Get skill names.
+     */
+    names(): string[];
+    /**
+     * Convert to MCP-compatible tool list.
+     * Prefixes names with "1sat__" for namespace isolation.
+     */
+    toMcpTools(): McpTool[];
+    /**
+     * Number of registered skills.
+     */
+    get size(): number;
+}
+/**
+ * Global skill registry singleton.
+ */
+export declare const skillRegistry: SkillRegistry;
+export {};

package/dist/api/skills/registry.js

@@ -0,0 +1,74 @@
+/**
+ * Skill registry for runtime discovery and MCP integration.
+ */
+/**
+ * Registry for collecting and discovering skills at runtime.
+ */
+export class SkillRegistry {
+    skills = new Map();
+    /**
+     * Register a skill.
+     */
+    register(skill) {
+        this.skills.set(skill.meta.name, skill);
+    }
+    /**
+     * Register multiple skills.
+     */
+    registerAll(skills) {
+        for (const skill of skills) {
+            this.register(skill);
+        }
+    }
+    /**
+     * Get a skill by name.
+     */
+    get(name) {
+        return this.skills.get(name);
+    }
+    /**
+     * Check if a skill exists.
+     */
+    has(name) {
+        return this.skills.has(name);
+    }
+    /**
+     * List all registered skills.
+     */
+    list() {
+        return Array.from(this.skills.values());
+    }
+    /**
+     * List skills by category.
+     */
+    listByCategory(category) {
+        return this.list().filter((s) => s.meta.category === category);
+    }
+    /**
+     * Get skill names.
+     */
+    names() {
+        return Array.from(this.skills.keys());
+    }
+    /**
+     * Convert to MCP-compatible tool list.
+     * Prefixes names with "1sat__" for namespace isolation.
+     */
+    toMcpTools() {
+        return this.list().map((skill) => ({
+            name: `1sat__${skill.meta.name}`,
+            description: skill.meta.description,
+            inputSchema: skill.meta.inputSchema,
+        }));
+    }
+    /**
+     * Number of registered skills.
+     */
+    get size() {
+        return this.skills.size;
+    }
+}
+/**
+ * Global skill registry singleton.
+ */
+export const skillRegistry = new SkillRegistry();

package/dist/api/skills/types.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Core types for the skill/action pattern.
+ */
+import type { WalletInterface } from "@bsv/sdk";
+import type { OneSatServices } from "../../services/OneSatServices";
+/**
+ * Context passed to all skills.
+ * Contains the wallet and optional services for backend operations.
+ */
+export interface OneSatContext {
+    /** BRC-100 compatible wallet interface */
+    wallet: WalletInterface;
+    /** Optional services for operations requiring backend (purchases, lookups) */
+    services?: OneSatServices;
+    /** Network chain */
+    chain: "main" | "test";
+    /** Optional WhatsOnChain API key */
+    wocApiKey?: string;
+}
+/**
+ * JSON Schema property definition for skill input schemas.
+ */
+export interface JsonSchemaProperty {
+    type: "string" | "number" | "integer" | "boolean" | "object" | "array";
+    description?: string;
+    enum?: string[];
+    default?: unknown;
+    items?: JsonSchemaProperty;
+    properties?: Record<string, JsonSchemaProperty>;
+    required?: string[];
+}
+/**
+ * Skill category for grouping related operations.
+ */
+export type SkillCategory = "balance" | "payments" | "ordinals" | "tokens" | "inscriptions" | "locks" | "signing" | "broadcast" | "sweep";
+/**
+ * Metadata describing a skill for AI agents and tooling.
+ */
+export interface SkillMetadata<TInput = unknown> {
+    /** Unique skill name */
+    name: string;
+    /** Human-readable description of what the skill does */
+    description: string;
+    /** Category for grouping */
+    category: SkillCategory;
+    /** JSON Schema for the input parameters (MCP-compatible) */
+    inputSchema: {
+        type: "object";
+        properties: Record<string, JsonSchemaProperty>;
+        required?: string[];
+    };
+    /** Whether this skill requires OneSatServices to be provided in context */
+    requiresServices?: boolean;
+}
+/**
+ * A skill is a self-describing action that can be executed with a context.
+ */
+export interface Skill<TInput = unknown, TOutput = unknown> {
+    /** Metadata describing the skill */
+    meta: SkillMetadata<TInput>;
+    /** Execute the skill with context and input */
+    execute: (ctx: OneSatContext, input: TInput) => Promise<TOutput>;
+}
+/**
+ * Helper to create a context object from a wallet and options.
+ */
+export declare function createContext(wallet: WalletInterface, options?: {
+    services?: OneSatServices;
+    chain?: "main" | "test";
+    wocApiKey?: string;
+}): OneSatContext;

package/dist/api/skills/types.js

@@ -0,0 +1,14 @@
+/**
+ * Core types for the skill/action pattern.
+ */
+/**
+ * Helper to create a context object from a wallet and options.
+ */
+export function createContext(wallet, options) {
+    return {
+        wallet,
+        services: options?.services,
+        chain: options?.chain ?? "main",
+        wocApiKey: options?.wocApiKey,
+    };
+}