@1sat/wallet-toolbox 0.0.65 → 0.0.68

package/dist/api/payments/index.js

@@ -5,7 +5,11 @@
  */
 import { Inscription } from "@bopen-io/templates";
 import { P2PKH, Script, Utils } from "@bsv/sdk";
-import { FUNDING_BASKET } from "../constants";
+/**
+ * Magic constant that tells the wallet to send all available funds minus fees.
+ * When an output has this satoshis value, it's adjusted to the maximum fundable amount.
+ */
+const maxPossibleSatoshis = 2099999999999999;
 // ============================================================================
 // Internal helpers
 // ============================================================================
@@ -153,32 +157,14 @@ export const sendAllBsv = {
             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,
+                        satoshis: maxPossibleSatoshis,
                         outputDescription: "Sweep all funds",
+                        tags: [],
                     },
                 ],
                 options: { signAndProcess: true, acceptDelayedBroadcast: false },

package/dist/wallet/factory.js

@@ -95,76 +95,71 @@ export async function createWebWallet(config) {
             // Add remote storage to the existing storage manager using public API
             await storage.addWalletStorageProvider(remoteClient);
             console.log("[createWebWallet] Remote storage connected successfully");
-            // Pull changes from remote to sync with other devices
-            console.log("[createWebWallet] Syncing from remote...");
-            const syncResult = await storage.syncFromReader(identityPubKey, remoteClient);
-            console.log(`[createWebWallet] Synced from remote: ${syncResult.inserts} inserts, ${syncResult.updates} updates`);
+            // Bidirectional sync: pull first, then push
+            // Pull builds idMap via natural key matching (reference for transactions)
+            // Push sends local changes to remote
+            console.log("[createWebWallet] Pulling from remote...");
+            const pullResult = await storage.syncFromReader(identityPubKey, remoteClient);
+            console.log(`[createWebWallet] Pulled: ${pullResult.inserts} inserts, ${pullResult.updates} updates`);
+            console.log("[createWebWallet] Pushing to remote...");
+            await storage.updateBackups(undefined, (msg) => {
+                console.log("[createWebWallet] Push:", msg);
+                return msg;
+            });
+            console.log("[createWebWallet] Push complete");
         }
         catch (err) {
             console.log("[createWebWallet] Remote storage connection failed:", err instanceof Error ? err.message : err);
             remoteClient = undefined;
         }
     }
-    // Log storage state using public APIs
-    const stores = storage.getStores();
+    // Log storage state for debugging
     console.log("[createWebWallet] Storage state:", {
         activeKey: storage.getActiveStore(),
-        backups: storage.getBackupStores(),
-        conflictingActives: storage.getConflictingStores(),
+        backups: storage.getBackupStores().length,
+        conflictingActives: storage.getConflictingStores().length,
         isActiveEnabled: storage.isActiveEnabled,
-        allStores: stores.map((s) => ({
-            name: s.storageName,
-            key: s.storageIdentityKey.slice(0, 16) + "...",
-        })),
     });
-    // 7. Handle conflicting actives or sync to backups
-    let conflictingStores = storage.getConflictingStores();
-    let backupStores = storage.getBackupStores();
-    if (conflictingStores.length > 0) {
-        const localKey = storage.getActiveStore();
-        console.log("[createWebWallet] Resolving conflicting actives...");
-        try {
-            await storage.setActive(localKey, (msg) => {
-                console.log("[createWebWallet] Conflict resolution:", msg);
+    // Helper to sync to remote backup using public updateBackups API
+    const syncToBackup = async (context) => {
+        if (storage.getBackupStores().length > 0) {
+            await storage.updateBackups(undefined, (msg) => {
+                console.log(`[createWebWallet] ${context}:`, msg);
                 return msg;
             });
-            console.log("[createWebWallet] Conflict resolution complete");
-        }
-        catch (err) {
-            console.log("[createWebWallet] Conflict resolution failed:", err instanceof Error ? err.message : err);
-            // FALLBACK: If conflict resolution fails, operate in local-only mode
-            // This allows the wallet to function even when remote sync is broken
-            console.log("[createWebWallet] Falling back to local-only mode (remote disabled)");
-            // Recreate storage manager with only local storage to clear conflicts
-            storage = new WalletStorageManager(identityPubKey, localStorage, []);
-            await storage.makeAvailable();
-            // Update the wallet's storage reference
-            underlyingWallet.storage = storage;
-            remoteClient = undefined;
-            // Refresh conflict state
-            conflictingStores = storage.getConflictingStores();
-            backupStores = storage.getBackupStores();
-            console.log("[createWebWallet] Local-only mode active, isActiveEnabled:", storage.isActiveEnabled);
         }
+    };
+    // 8. Intercept createAction/signAction to sync after immediate broadcasts
+    // With acceptDelayedBroadcast: false, broadcasts happen synchronously and
+    // bypass the monitor's onTransactionBroadcasted callback. We detect broadcasts
+    // by checking for txid in the result and sync to backup immediately.
+    if (remoteClient) {
+        const originalCreateAction = underlyingWallet.createAction.bind(underlyingWallet);
+        underlyingWallet.createAction = async (args) => {
+            const result = await originalCreateAction(args);
+            if (result.txid) {
+                console.log("[createWebWallet] Broadcast detected in createAction:", result.txid);
+                syncToBackup("Backup after createAction").catch((err) => {
+                    console.warn("[createWebWallet] Failed to sync after createAction:", err);
+                });
+            }
+            return result;
+        };
+        const originalSignAction = underlyingWallet.signAction.bind(underlyingWallet);
+        underlyingWallet.signAction = async (args) => {
+            const result = await originalSignAction(args);
+            if (result.txid) {
+                console.log("[createWebWallet] Broadcast detected in signAction:", result.txid);
+                syncToBackup("Backup after signAction").catch((err) => {
+                    console.warn("[createWebWallet] Failed to sync after signAction:", err);
+                });
+            }
+            return result;
+        };
     }
-    else if (backupStores.length > 0) {
-        // No conflicts - push local state to remote backup (fire-and-forget)
-        console.log("[createWebWallet] Pushing local state to remote backup...");
-        storage
-            .updateBackups(undefined, (msg) => {
-            console.log("[createWebWallet] Backup:", msg);
-            return msg;
-        })
-            .then(() => {
-            console.log("[createWebWallet] Backup complete");
-        })
-            .catch((err) => {
-            console.log("[createWebWallet] Backup failed:", err instanceof Error ? err.message : err);
-        });
-    }
-    // 8. Wrap with permissions manager
+    // 9. Wrap with permissions manager
     const wallet = new WalletPermissionsManager(underlyingWallet, adminOriginator, permissionsConfig);
-    // 9. Create monitor (not started - consumer calls startTasks() when ready)
+    // 10. Create monitor (not started - consumer calls startTasks() when ready)
     const monitor = new Monitor({
         chain,
         services: oneSatServices,
@@ -178,26 +173,20 @@ export async function createWebWallet(config) {
     });
     monitor.addDefaultTasks();
     console.log("[createWebWallet] Monitor created with tasks:", monitor["_tasks"].map((t) => t.name));
-    // Helper to sync to remote backup using public updateBackups API
-    const syncToBackup = async (context) => {
-        if (storage.getBackupStores().length > 0) {
-            await storage.updateBackups(undefined, (msg) => {
-                console.log(`[Monitor] ${context}:`, msg);
-                return msg;
-            });
-        }
-    };
-    // 10. Wire up monitor callbacks - sync to remote first, then call user callbacks
+    // 11. Wire up monitor callbacks - sync to remote first, then call user callbacks
+    // Note: For delayed broadcasts, the monitor triggers these. For immediate broadcasts,
+    // the interception in step 8 handles the sync, but these still fire for the user callback.
     monitor.onTransactionBroadcasted = async (result) => {
-        console.log("[Monitor] Transaction broadcasted:", result.txid);
+        console.log("[createWebWallet] Monitor detected broadcast:", result.txid);
         // Sync to remote backup first (if connected)
+        // Note: For immediate broadcasts, step 8 already synced, but this is harmless
         if (remoteClient) {
             try {
-                await syncToBackup("Backup after broadcast");
-                console.log("[Monitor] Synced to backup after broadcast");
+                await syncToBackup("Backup after monitor broadcast");
+                console.log("[createWebWallet] Synced to backup after monitor broadcast");
             }
             catch (err) {
-                console.warn("[Monitor] Failed to sync after broadcast:", err);
+                console.warn("[createWebWallet] Failed to sync after monitor broadcast:", err);
             }
         }
         // Then call user callback (if provided)
@@ -206,20 +195,20 @@ export async function createWebWallet(config) {
                 config.onTransactionBroadcasted(result.txid);
             }
             catch (err) {
-                console.warn("[Monitor] User callback error after broadcast:", err);
+                console.warn("[createWebWallet] User callback error after broadcast:", err);
             }
         }
     };
     monitor.onTransactionProven = async (status) => {
-        console.log("[Monitor] Transaction proven:", status.txid, "block", status.blockHeight);
+        console.log("[createWebWallet] Transaction proven:", status.txid, "block", status.blockHeight);
         // Sync to remote backup first (if connected)
         if (remoteClient) {
             try {
                 await syncToBackup("Backup after confirmation");
-                console.log("[Monitor] Synced to backup after confirmation");
+                console.log("[createWebWallet] Synced to backup after confirmation");
             }
             catch (err) {
-                console.warn("[Monitor] Failed to sync after confirmation:", err);
+                console.warn("[createWebWallet] Failed to sync after confirmation:", err);
             }
         }
         // Then call user callback (if provided)
@@ -228,17 +217,17 @@ export async function createWebWallet(config) {
                 config.onTransactionProven(status.txid, status.blockHeight);
             }
             catch (err) {
-                console.warn("[Monitor] User callback error after proven:", err);
+                console.warn("[createWebWallet] User callback error after proven:", err);
             }
         }
     };
-    // 11. Create cleanup function
+    // 12. Create cleanup function
     const destroy = async () => {
         monitor.stopTasks();
         await monitor.destroy();
         await underlyingWallet.destroy();
     };
-    // 12. Create fullSync function if remote storage is connected
+    // 13. Create fullSync function if remote storage is connected
     const fullSyncFn = remoteClient
         ? async (onProgress) => {
             return fullSync({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1sat/wallet-toolbox",
-  "version": "0.0.65",
+  "version": "0.0.68",
   "description": "BSV wallet library extending @bsv/wallet-toolbox with 1Sat Ordinals protocol support",
   "author": "1Sat Team",
   "license": "MIT",