@1sat/wallet-toolbox 0.0.9 → 0.0.11

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

@@ -0,0 +1,23 @@
+/**
+ * Sweep Module
+ *
+ * Functions for sweeping assets from external wallets into a BRC-100 wallet.
+ */
+import type { OneSatContext, Skill } from "../skills/types";
+import type { IndexedOutput } from "../../services/types";
+import type { SweepBsvRequest, SweepBsvResponse, SweepInput } from "./types";
+export * from "./types";
+/**
+ * Prepare sweep inputs from IndexedOutput objects by fetching locking scripts.
+ * This extracts locking scripts from the raw transactions in BEEF format.
+ */
+export declare function prepareSweepInputs(ctx: OneSatContext, utxos: IndexedOutput[]): Promise<SweepInput[]>;
+/**
+ * Sweep BSV from external inputs into the destination wallet.
+ *
+ * If amount is specified, only that amount is swept and the remainder
+ * is returned to the source address. If amount is omitted, all input
+ * value is swept (minus fees).
+ */
+export declare const sweepBsv: Skill<SweepBsvRequest, SweepBsvResponse>;
+export declare const sweepSkills: Skill<SweepBsvRequest, SweepBsvResponse>[];

package/dist/api/sweep/index.js

@@ -0,0 +1,221 @@
+/**
+ * Sweep Module
+ *
+ * Functions for sweeping assets from external wallets into a BRC-100 wallet.
+ */
+import { P2PKH, PrivateKey, Transaction, } from "@bsv/sdk";
+export * from "./types";
+/**
+ * Prepare sweep inputs from IndexedOutput objects by fetching locking scripts.
+ * This extracts locking scripts from the raw transactions in BEEF format.
+ */
+export async function prepareSweepInputs(ctx, utxos) {
+    if (!ctx.services) {
+        throw new Error("Services required for prepareSweepInputs");
+    }
+    // Group UTXOs by txid to minimize BEEF fetches
+    const byTxid = new Map();
+    for (const utxo of utxos) {
+        const [txid, voutStr] = utxo.outpoint.split("_");
+        const vout = Number.parseInt(voutStr, 10);
+        const existing = byTxid.get(txid) ?? [];
+        existing.push({ vout, utxo });
+        byTxid.set(txid, existing);
+    }
+    const results = [];
+    // Fetch BEEF for each txid and extract locking scripts
+    for (const [txid, outputs] of byTxid) {
+        const beef = await ctx.services.getBeefForTxid(txid);
+        const beefTx = beef.findTxid(txid);
+        if (!beefTx?.tx) {
+            throw new Error(`Transaction ${txid} not found in BEEF`);
+        }
+        for (const { vout, utxo } of outputs) {
+            const output = beefTx.tx.outputs[vout];
+            if (!output) {
+                throw new Error(`Output ${vout} not found in transaction ${txid}`);
+            }
+            results.push({
+                outpoint: utxo.outpoint,
+                satoshis: utxo.satoshis ?? output.satoshis ?? 0,
+                lockingScript: output.lockingScript?.toHex() ?? "",
+            });
+        }
+    }
+    return results;
+}
+/**
+ * Sweep BSV from external inputs into the destination wallet.
+ *
+ * If amount is specified, only that amount is swept and the remainder
+ * is returned to the source address. If amount is omitted, all input
+ * value is swept (minus fees).
+ */
+export const sweepBsv = {
+    meta: {
+        name: "sweepBsv",
+        description: "Sweep BSV from external wallet (via WIF) into the connected wallet",
+        category: "sweep",
+        requiresServices: true,
+        inputSchema: {
+            type: "object",
+            properties: {
+                inputs: {
+                    type: "array",
+                    description: "UTXOs to sweep (use prepareSweepInputs to build these)",
+                    items: {
+                        type: "object",
+                        properties: {
+                            outpoint: { type: "string", description: "Outpoint (txid_vout)" },
+                            satoshis: { type: "integer", description: "Satoshis in output" },
+                            lockingScript: {
+                                type: "string",
+                                description: "Locking script hex",
+                            },
+                        },
+                        required: ["outpoint", "satoshis", "lockingScript"],
+                    },
+                },
+                wif: {
+                    type: "string",
+                    description: "WIF private key controlling the inputs",
+                },
+                amount: {
+                    type: "integer",
+                    description: "Amount to sweep (satoshis). If omitted, sweeps all input value.",
+                },
+            },
+            required: ["inputs", "wif"],
+        },
+    },
+    async execute(ctx, request) {
+        if (!ctx.services) {
+            return { error: "services-required" };
+        }
+        try {
+            const { inputs, wif, amount } = request;
+            if (!inputs || inputs.length === 0) {
+                return { error: "no-inputs" };
+            }
+            // Parse WIF and derive source address
+            const privateKey = PrivateKey.fromWif(wif);
+            const sourceAddress = privateKey.toPublicKey().toAddress();
+            // Calculate totals
+            const inputTotal = inputs.reduce((sum, i) => sum + i.satoshis, 0);
+            // Validate amount if specified
+            if (amount !== undefined) {
+                if (amount <= 0) {
+                    return { error: "invalid-amount" };
+                }
+                if (amount > inputTotal) {
+                    return { error: "insufficient-funds" };
+                }
+            }
+            // Fetch BEEF for all input transactions and merge them
+            const txids = [
+                ...new Set(inputs.map((i) => i.outpoint.split("_")[0])),
+            ];
+            console.log(`[sweep] Fetching BEEF for ${txids.length} transactions`);
+            // Get first BEEF, then merge others into it
+            const firstBeef = await ctx.services.getBeefForTxid(txids[0]);
+            for (let i = 1; i < txids.length; i++) {
+                const additionalBeef = await ctx.services.getBeefForTxid(txids[i]);
+                firstBeef.mergeBeef(additionalBeef);
+            }
+            console.log(`[sweep] Merged BEEF valid=${firstBeef.isValid()}, txs=${firstBeef.txs.length}`);
+            // Build input descriptors (we'll sign after getting the final transaction)
+            const inputDescriptors = inputs.map((input) => {
+                const [txid, voutStr] = input.outpoint.split("_");
+                // Convert outpoint format: our format uses "_" but SDK expects "."
+                return {
+                    outpoint: `${txid}.${voutStr}`,
+                    inputDescription: "Sweep input",
+                    unlockingScriptLength: 108, // P2PKH unlocking script length
+                    sequenceNumber: 0xffffffff,
+                };
+            });
+            const beefData = firstBeef.toBinary();
+            // Build outputs array
+            const outputs = [];
+            // If amount specified, create return output for the difference
+            if (amount !== undefined) {
+                const returnAmount = inputTotal - amount;
+                if (returnAmount > 0) {
+                    outputs.push({
+                        lockingScript: new P2PKH().lock(sourceAddress).toHex(),
+                        satoshis: returnAmount,
+                        outputDescription: "Return to source",
+                    });
+                }
+            }
+            // If no amount specified, no outputs - wallet creates change for everything
+            // Step 1: Create action to get the signable transaction
+            const createResult = await ctx.wallet.createAction({
+                description: amount
+                    ? `Sweep ${amount} sats`
+                    : `Sweep ${inputTotal} sats`,
+                inputBEEF: beefData,
+                inputs: inputDescriptors,
+                outputs,
+                options: { signAndProcess: false },
+            });
+            if ("error" in createResult && createResult.error) {
+                return { error: String(createResult.error) };
+            }
+            if (!createResult.signableTransaction) {
+                return { error: "no-signable-transaction" };
+            }
+            // Step 2: Sign each input with our external key
+            const tx = Transaction.fromBEEF(createResult.signableTransaction.tx);
+            console.log(`[sweep] Transaction has ${tx.inputs.length} inputs, ${tx.outputs.length} outputs`);
+            // Build a set of outpoints we control (using SDK format with ".")
+            const ourOutpoints = new Set(inputs.map((input) => {
+                const [txid, vout] = input.outpoint.split("_");
+                return `${txid}.${vout}`;
+            }));
+            // Find and set up P2PKH unlocker on each input we control
+            for (let i = 0; i < tx.inputs.length; i++) {
+                const txInput = tx.inputs[i];
+                const inputOutpoint = `${txInput.sourceTXID}.${txInput.sourceOutputIndex}`;
+                const hasSourceTx = !!txInput.sourceTransaction;
+                const sourceSatoshis = txInput.sourceTransaction?.outputs[txInput.sourceOutputIndex]?.satoshis;
+                console.log(`[sweep] Input ${i}: ${inputOutpoint}, hasSourceTx=${hasSourceTx}, satoshis=${sourceSatoshis}, isOurs=${ourOutpoints.has(inputOutpoint)}`);
+                if (ourOutpoints.has(inputOutpoint)) {
+                    const p2pkh = new P2PKH();
+                    txInput.unlockingScriptTemplate = p2pkh.unlock(privateKey, "all", // SIGHASH_ALL - commit to outputs (we know them now)
+                    true);
+                }
+            }
+            // Sign all inputs
+            await tx.sign();
+            // Extract unlocking scripts for signAction (only for our inputs)
+            const spends = {};
+            for (let i = 0; i < tx.inputs.length; i++) {
+                const txInput = tx.inputs[i];
+                const inputOutpoint = `${txInput.sourceTXID}.${txInput.sourceOutputIndex}`;
+                if (ourOutpoints.has(inputOutpoint)) {
+                    spends[i] = { unlockingScript: txInput.unlockingScript?.toHex() ?? "" };
+                }
+            }
+            // Step 3: Complete the action with our signatures
+            const signResult = await ctx.wallet.signAction({
+                reference: createResult.signableTransaction.reference,
+                spends,
+            });
+            if ("error" in signResult) {
+                return { error: String(signResult.error) };
+            }
+            return {
+                txid: signResult.txid,
+                beef: signResult.tx ? Array.from(signResult.tx) : undefined,
+            };
+        }
+        catch (error) {
+            return {
+                error: error instanceof Error ? error.message : "unknown-error",
+            };
+        }
+    },
+};
+// Export skills array for registry
+export const sweepSkills = [sweepBsv];

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

@@ -0,0 +1,30 @@
+/**
+ * Sweep Module Types
+ */
+/** Input for sweep operations - a UTXO to be swept */
+export interface SweepInput {
+    /** Outpoint in format "txid_vout" */
+    outpoint: string;
+    /** Satoshis in this output */
+    satoshis: number;
+    /** Locking script hex */
+    lockingScript: string;
+}
+/** Request to sweep BSV funds */
+export interface SweepBsvRequest {
+    /** UTXOs to spend from source wallet */
+    inputs: SweepInput[];
+    /** WIF private key controlling the inputs */
+    wif: string;
+    /** Amount to sweep (in satoshis). If omitted, sweeps all input value. */
+    amount?: number;
+}
+/** Response from sweep operation */
+export interface SweepBsvResponse {
+    /** Transaction ID if successful */
+    txid?: string;
+    /** BEEF (transaction with validity proof) */
+    beef?: number[];
+    /** Error message if failed */
+    error?: string;
+}

package/dist/api/sweep/types.js

@@ -0,0 +1,4 @@
+/**
+ * Sweep Module Types
+ */
+export {};

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

@@ -1,10 +1,11 @@
 /**
  * Tokens Module
  *
- * Functions for managing BSV21 tokens.
+ * Skills for managing BSV21 tokens.
  */
-import { type WalletInterface, type WalletOutput } from "@bsv/sdk";
-import type { OneSatServices } from "../../services/OneSatServices";
+import { type WalletOutput } from "@bsv/sdk";
+import type { Skill } from "../skills/types";
+type PubKeyHex = string;
 export interface Bsv21Balance {
     /** Token protocol (bsv-20) */
     p: string;
@@ -32,57 +33,55 @@ export interface Bsv21Balance {
 export interface SendBsv21Request {
     /** Token ID (txid_vout format) */
     tokenId: string;
-    /** Destination address */
-    address: string;
     /** Amount to send (as bigint or string) */
     amount: bigint | string;
+    /** Recipient's identity public key (preferred) */
+    counterparty?: PubKeyHex;
+    /** Legacy: raw P2PKH address */
+    address?: string;
+    /** Paymail address */
+    paymail?: string;
+}
+export interface PurchaseBsv21Request {
+    /** Token ID (txid_vout format of the deploy transaction) */
+    tokenId: string;
+    /** Outpoint of listed token UTXO (OrdLock containing BSV21) */
+    outpoint: string;
+    /** Amount of tokens in the listing */
+    amount: bigint | string;
+    /** Optional marketplace fee address */
+    marketplaceAddress?: string;
+    /** Optional marketplace fee rate (0-1) */
+    marketplaceRate?: number;
 }
 export interface TokenOperationResponse {
     txid?: string;
     rawtx?: string;
     error?: string;
 }
+/** Input for listTokens skill */
+export interface ListTokensInput {
+    /** Max number of tokens to return */
+    limit?: number;
+}
 /**
- * List BSV21 token outputs from the bsv21 basket.
- * Returns WalletOutput[] directly - use tags for metadata.
+ * List BSV21 token outputs from the wallet.
  */
-export declare function listTokens(cwi: WalletInterface, limit?: number): Promise<WalletOutput[]>;
+export declare const listTokens: Skill<ListTokensInput, WalletOutput[]>;
+/** Input for getBsv21Balances skill (no required params) */
+export type GetBsv21BalancesInput = Record<string, never>;
 /**
  * Get aggregated BSV21 token balances.
- * Groups outputs by token ID and sums amounts.
  */
-export declare function getBsv21Balances(cwi: WalletInterface): Promise<Bsv21Balance[]>;
+export declare const getBsv21Balances: Skill<GetBsv21BalancesInput, Bsv21Balance[]>;
 /**
  * Send BSV21 tokens to an address.
- *
- * Flow:
- * 1. Get token UTXOs from basket
- * 2. Validate each with BSV21 service
- * 3. Select UTXOs until we have enough tokens
- * 4. Build transfer inscription outputs
- * 5. Create and sign transaction
  */
-export declare function sendBsv21(cwi: WalletInterface, request: SendBsv21Request, services?: OneSatServices): Promise<TokenOperationResponse>;
-export interface PurchaseBsv21Request {
-    /** Token ID (txid_vout format of the deploy transaction) */
-    tokenId: string;
-    /** Outpoint of listed token UTXO (OrdLock containing BSV21) */
-    outpoint: string;
-    /** Amount of tokens in the listing */
-    amount: bigint | string;
-    /** Optional marketplace fee address */
-    marketplaceAddress?: string;
-    /** Optional marketplace fee rate (0-1) */
-    marketplaceRate?: number;
-}
+export declare const sendBsv21: Skill<SendBsv21Request, TokenOperationResponse>;
 /**
  * Purchase BSV21 tokens from marketplace.
- *
- * Flow:
- * 1. Fetch listing BEEF to get the locking script
- * 2. Decode OrdLock to get price and payout
- * 3. Build BSV21 transfer output for buyer
- * 4. Build payment output for seller
- * 5. Build custom OrdLock purchase unlock (preimage only, no signature)
  */
-export declare function purchaseBsv21(cwi: WalletInterface, request: PurchaseBsv21Request, services?: OneSatServices): Promise<TokenOperationResponse>;
+export declare const purchaseBsv21: Skill<PurchaseBsv21Request, TokenOperationResponse>;
+/** All token skills for registry */
+export declare const tokensSkills: (Skill<ListTokensInput, WalletOutput[]> | Skill<GetBsv21BalancesInput, Bsv21Balance[]> | Skill<SendBsv21Request, TokenOperationResponse> | Skill<PurchaseBsv21Request, TokenOperationResponse>)[];
+export {};