@1sat/wallet-toolbox 0.0.10 → 0.0.11

package/dist/api/index.d.ts

@@ -33,4 +33,5 @@ export * from "./inscriptions";
 export * from "./locks";
 export * from "./signing";
 export * from "./broadcast";
+export * from "./sweep";
 export type { WalletInterface, WalletOutput, CreateActionArgs, CreateActionResult, CreateActionOutput, CreateActionInput, ListOutputsResult, ListOutputsArgs, } from "@bsv/sdk";

package/dist/api/index.js

@@ -37,6 +37,8 @@ export * from "./inscriptions";
 export * from "./locks";
 export * from "./signing";
 export * from "./broadcast";
+// Export sweep module (uses external signing, not skill-based)
+export * from "./sweep";
 // Register all skills with the global registry
 import { skillRegistry } from "./skills/registry";
 import { balanceSkills } from "./balance";
@@ -47,6 +49,7 @@ import { inscriptionsSkills } from "./inscriptions";
 import { locksSkills } from "./locks";
 import { signingSkills } from "./signing";
 import { broadcastSkills } from "./broadcast";
+import { sweepSkills } from "./sweep";
 skillRegistry.registerAll([
     ...balanceSkills,
     ...paymentsSkills,
@@ -56,4 +59,5 @@ skillRegistry.registerAll([
     ...locksSkills,
     ...signingSkills,
     ...broadcastSkills,
+    ...sweepSkills,
 ]);

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

@@ -32,7 +32,7 @@ export interface JsonSchemaProperty {
 /**
  * Skill category for grouping related operations.
  */
-export type SkillCategory = "balance" | "payments" | "ordinals" | "tokens" | "inscriptions" | "locks" | "signing" | "broadcast";
+export type SkillCategory = "balance" | "payments" | "ordinals" | "tokens" | "inscriptions" | "locks" | "signing" | "broadcast" | "sweep";
 /**
  * Metadata describing a skill for AI agents and tooling.
  */

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/index.d.ts

@@ -1,6 +1,6 @@
 export * from "./api";
 export { OneSatServices, type SyncOutput } from "./services/OneSatServices";
-export type { OrdfsMetadata, OrdfsContentOptions, OrdfsContentResponse, OrdfsResponseHeaders, Capability, } from "./services/types";
+export type { IndexedOutput, OrdfsMetadata, OrdfsContentOptions, OrdfsContentResponse, OrdfsResponseHeaders, Capability, } from "./services/types";
 export * from "./services/client";
 export { ReadOnlySigner } from "./signers/ReadOnlySigner";
 export * from "./indexers";

package/dist/services/client/OwnerClient.js

@@ -22,6 +22,10 @@ export class OwnerClient extends BaseClient {
             limit: opts?.limit,
             rev: opts?.rev,
             unspent: opts?.unspent,
+            sats: opts?.sats,
+            spend: opts?.spend,
+            events: opts?.events,
+            block: opts?.block,
             refresh: opts?.refresh,
         });
         return this.request(`/${owner}/txos${qs}`);

package/dist/wallet/factory.js

@@ -83,6 +83,7 @@ export async function createWebWallet(config) {
     });
     // 6. Attempt remote storage connection if URL provided
     if (config.remoteStorageUrl) {
+        console.log(`[createWebWallet] Attempting remote storage connection to ${config.remoteStorageUrl}`);
         try {
             const remoteClient = new StorageClient(underlyingWallet, config.remoteStorageUrl);
             const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Remote storage connection timeout")), DEFAULT_REMOTE_STORAGE_TIMEOUT));
@@ -92,10 +93,43 @@ export async function createWebWallet(config) {
                 remoteClient,
             ]);
             await storage.makeAvailable();
+            // Check for conflicting actives and resolve if needed
+            const storageAny = storage;
+            console.log("[createWebWallet] Storage state:", {
+                activeKey: storageAny._active?.settings?.storageIdentityKey,
+                backups: storageAny._backups?.map(b => b.settings?.storageIdentityKey),
+                conflictingActives: storageAny._conflictingActives?.map(c => c.settings?.storageIdentityKey),
+            });
+            // If there are conflicting actives, resolve by setting local as active (merges remote data)
+            if (storageAny._conflictingActives && storageAny._conflictingActives.length > 0) {
+                const localKey = storageAny._active?.settings?.storageIdentityKey;
+                if (localKey && storageAny.setActive) {
+                    console.log("[createWebWallet] Resolving conflicts by merging into local storage...");
+                    await storageAny.setActive(localKey, (msg) => {
+                        console.log("[createWebWallet] Sync:", msg);
+                        return msg;
+                    });
+                    console.log("[createWebWallet] Conflict resolution complete");
+                }
+            }
+            else if (storageAny._backups && storageAny._backups.length > 0 && storageAny.updateBackups) {
+                // No conflicts - push local state to remote backup (non-blocking to avoid IDB timeout)
+                console.log("[createWebWallet] Starting background backup to remote...");
+                storageAny.updateBackups(undefined, (msg) => {
+                    console.log("[createWebWallet] Backup:", msg);
+                    return msg;
+                }).then(() => {
+                    console.log("[createWebWallet] Background backup complete");
+                }).catch((err) => {
+                    console.log("[createWebWallet] Background backup failed:", err instanceof Error ? err.message : err);
+                });
+            }
             // Update wallet's storage reference
             underlyingWallet._storage = storage;
+            console.log("[createWebWallet] Remote storage connected successfully");
         }
-        catch {
+        catch (err) {
+            console.log("[createWebWallet] Remote storage connection failed:", err instanceof Error ? err.message : err);
             // Graceful degradation - continue with local only
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1sat/wallet-toolbox",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "BSV wallet library extending @bsv/wallet-toolbox with 1Sat Ordinals protocol support",
   "author": "1Sat Team",
   "license": "MIT",
@@ -37,12 +37,12 @@
     "tester": "bun run build && bun run tester:build && bun ./tester/server.ts"
   },
   "dependencies": {
-    "@bopen-io/templates": "^1.1.4",
-    "@bsv/sdk": "^1.9.31",
+    "@bopen-io/templates": "^1.1.6",
+    "@bsv/sdk": "^1.10.1",
     "buffer": "^6.0.3"
   },
   "peerDependencies": {
-    "@bsv/wallet-toolbox-mobile": "npm:@bopen-io/wallet-toolbox-mobile@^1.7.19"
+    "@bsv/wallet-toolbox-mobile": "npm:@bopen-io/wallet-toolbox-mobile@^1.7.20-idb-fix.1"
   },
   "peerDependenciesMeta": {
     "@bsv/wallet-toolbox-mobile": {
@@ -51,8 +51,8 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^1.9.4",
-    "@bsv/wallet-toolbox": "npm:@bopen-io/wallet-toolbox@^1.7.19",
-    "@bsv/wallet-toolbox-mobile": "npm:@bopen-io/wallet-toolbox-mobile@^1.7.19",
+    "@bsv/wallet-toolbox": "npm:@bopen-io/wallet-toolbox@^1.7.20-idb-fix.1",
+    "@bsv/wallet-toolbox-mobile": "npm:@bopen-io/wallet-toolbox-mobile@^1.7.20-idb-fix.1",
     "@types/bun": "^1.3.4",
     "@types/chrome": "^0.1.32",
     "typescript": "^5.9.3"