@spirobel/monero-wallet-api 0.5.4 → 0.6.0

package/dist/scanning-syncing/scanresult/scanCacheOpened.js

@@ -5,6 +5,8 @@ import { spendable } from "./scanResult";
 import { getPathPrefix, readPrivateSpendKeyFromEnv, SCAN_SETTINGS_STORE_NAME_DEFAULT, SUB_ADDRESS_INDEX_DEFAULT_VALUE, walletSettingsPlusKeys, } from "../../api";
 import { ScanSettingsOpened } from "../../scansettings/scanSettingsOpened";
 import { ConnectionStatusOpened } from "../connectionStatusOpened";
+import { ActionLogOpened, } from "../../actionlog/actionLogOpened";
+import { sendToBackground } from "../../tools/globals";
 import { findRange, lastRange, readCacheFileDefaultLocation, writeCacheFileDefaultLocationThrows, } from "./scanCache";
 import { alignScanStatsWithCache, isSelfSpent, processTxlogInputs, processTxlogPayments, writeStatsFileDefaultLocation, } from "./scanStats";
 import { readWriteConnectionStatusFile, } from "../connectionStatus";
@@ -37,11 +39,13 @@ export class ScanCacheOpened {
     /** sample sizes to try when decoyRetry is enabled, in order */
     decoyRetrySizes = [20, 50, 100, 200, 500];
     static async create(params) {
-        const theCatchToBeOpened = await readCacheFileDefaultLocation(params.primary_address, params.pathPrefix);
+        // same dir as workers / connection status: next to ScanSettings.json
+        const pathPrefix = getPathPrefix(params.scan_settings_path, params.pathPrefix);
+        const theCatchToBeOpened = await readCacheFileDefaultLocation(params.primary_address, pathPrefix);
         if (!params.primary_address)
             throw new Error(`primary_address is required, potentially half filled out wallet setting in: ${params.scan_settings_path || SCAN_SETTINGS_STORE_NAME_DEFAULT}`);
         // use ScanSettingsOpened instead of direct scanSettings calls
-        const scanSettings = await ScanSettingsOpened.create(params.scan_settings_path, params.pathPrefix);
+        const scanSettings = await ScanSettingsOpened.create(params.scan_settings_path, pathPrefix);
         const walletSettings = scanSettings.getWallet(params.primary_address);
         if (!walletSettings)
             throw new Error(`wallet not found in settings. did you call openwallet with the right params?
@@ -55,7 +59,7 @@ export class ScanCacheOpened {
         // read secret_view_key and secret_spend_key from env
         const walletSettingsWithKeys = await walletSettingsPlusKeys(walletWithSettings);
         // create viewpair + ScanCacheOpened instance
-        const scanCacheOpen = new ScanCacheOpened(scanSettings, await ViewPair.create(params.primary_address, walletSettingsWithKeys.secret_view_key, walletSettings.subaddress_index, scanSettings.node_url), walletSettings.wallet_route, walletSettings.wallet_name, walletSettings.wallet_slot, params.no_worker || false, params.masterCacheChanged || null, scanSettings.start_height, params.scan_settings_path, params.pathPrefix, params.workerError);
+        const scanCacheOpen = new ScanCacheOpened(scanSettings, await ViewPair.create(params.primary_address, walletSettingsWithKeys.secret_view_key, walletSettings.subaddress_index, scanSettings.node_url), walletSettings.wallet_route, walletSettings.wallet_name, walletSettings.wallet_slot, params.no_worker || false, params.masterCacheChanged || null, scanSettings.start_height, params.scan_settings_path, pathPrefix, params.workerError);
         if (theCatchToBeOpened)
             scanCacheOpen._cache = theCatchToBeOpened;
         if (!walletSettings.halted) {
@@ -66,7 +70,7 @@ export class ScanCacheOpened {
         scanCacheOpen._highest_subaddress_index =
             walletSettings.subaddress_index || SUB_ADDRESS_INDEX_DEFAULT_VALUE;
         if (!params.no_stats) {
-            scanCacheOpen._stats = await alignScanStatsWithCache(scanCacheOpen._cache, scanCacheOpen.view_pair, params.primary_address, getPathPrefix(params.scan_settings_path, params.pathPrefix), walletSettings.subaddress_index, lastRange(scanCacheOpen._cache.scanned_ranges)?.end);
+            scanCacheOpen._stats = await alignScanStatsWithCache(scanCacheOpen._cache, scanCacheOpen.view_pair, params.primary_address, pathPrefix, walletSettings.subaddress_index, lastRange(scanCacheOpen._cache.scanned_ranges)?.end);
         }
         else {
             scanCacheOpen._no_stats = params.no_stats; // true
@@ -83,8 +87,10 @@ export class ScanCacheOpened {
         return this._highest_subaddress_index;
     }
     get current_height() {
-        let current_range = findRange(this._cache.scanned_ranges, this._start_height || 0);
-        return current_range?.end || null;
+        // progress on the range that covers start_height (start can jump;
+        // lastRange would pick a different segment and be wrong)
+        const current_range = findRange(this._cache.scanned_ranges, this._start_height || 0);
+        return current_range == null ? null : current_range.end;
     }
     get current_top_range_height() {
         if (typeof this._stats === "undefined" || this._stats === null)
@@ -92,7 +98,7 @@ export class ScanCacheOpened {
         return this._stats.height;
     }
     async changeStartHeight(start_height) {
-        this.stopWorker();
+        await this.stopWorker();
         await this._scanSettings.setStartHeight(start_height);
         this._start_height = start_height;
         await this.unpause();
@@ -167,7 +173,7 @@ export class ScanCacheOpened {
         return this._scanSettings.logs_exclude;
     }
     async changeNodeUrlAndStartHeight(node_url, start_height) {
-        this.stopWorker();
+        await this.stopWorker();
         if (node_url !== undefined) {
             await this._scanSettings.setNodeUrl(node_url);
             this.node_url = node_url;
@@ -179,7 +185,7 @@ export class ScanCacheOpened {
         await this.unpause();
     }
     async changeNodeUrl(node_url) {
-        this.stopWorker();
+        await this.stopWorker();
         await this._scanSettings.setNodeUrl(node_url);
         this.node_url = node_url;
         await this.unpause();
@@ -188,7 +194,7 @@ export class ScanCacheOpened {
         await this._scanSettings.setMerchantConfirmations(merchant_confirmations);
     }
     async setCpuWorkerCount(cpu_worker_count) {
-        this.stopWorker();
+        await this.stopWorker();
         await this._scanSettings.setCpuWorkerCount(cpu_worker_count);
         await this.unpause();
     }
@@ -201,7 +207,7 @@ export class ScanCacheOpened {
         await this._scanSettings.setWalletName(this.view_pair.primary_address, name);
     }
     async retry() {
-        this.stopWorker();
+        await this.stopWorker();
         //  scansettings  so external changes (e.g. from a sidebar frontend instance) are picked up
         await this._scanSettings.reload();
         const walletStillExists = this._scanSettings.walletExists(this.primary_address);
@@ -385,18 +391,20 @@ export class ScanCacheOpened {
         let maybeInputs = [];
         let maybeFeeEstimate;
         let maybeSendResult;
+        let maybeSignedTx;
         try {
             const { selectedInputs, feeEstimate } = await this.calculateFeeAndSelectInputs(params);
             maybeInputs = selectedInputs;
             maybeFeeEstimate = feeEstimate;
             const unsignedTx = await this.makeTransactionFromSelectedInputs(params.payments, selectedInputs, feeEstimate);
             const signedTx = await this.signTransaction(unsignedTx);
+            maybeSignedTx = signedTx;
             const sendResult = await this.sendTransaction(signedTx);
             maybeSendResult = sendResult;
             if (sendResult.status !== "OK")
                 throw new Error("send raw transaction rpc returned error");
             // before writing the scan cache, we stop the worker to avoid a race
-            this.stopWorker();
+            await this.stopWorker();
             // write txlog to cache + update pending_spent_utxos (affects stats + spendability)
             await writeCacheFileDefaultLocationThrows({
                 primary_address: this.primary_address,
@@ -415,6 +423,8 @@ export class ScanCacheOpened {
                         inputs_index,
                         height: this.current_height,
                         timestamp: Date.now(),
+                        invocationId: params.invocationId,
+                        signed_tx: signedTx,
                     };
                     const newLen = cache.tx_logs.push(txLog);
                     const txLogIndex = newLen - 1;
@@ -440,7 +450,7 @@ export class ScanCacheOpened {
         }
         catch (e) {
             // before writing the scan cache, we stop the worker to avoid a race
-            this.stopWorker();
+            await this.stopWorker();
             // write txlog error to cache
             await writeCacheFileDefaultLocationThrows({
                 primary_address: this.primary_address,
@@ -460,17 +470,16 @@ export class ScanCacheOpened {
                         inputs_index,
                         height: this.current_height,
                         timestamp: Date.now(),
+                        invocationId: params.invocationId,
+                        signed_tx: maybeSignedTx,
                     };
-                    const newLen = cache.tx_logs.push(txLog);
+                    cache.tx_logs.push(txLog);
                 },
             });
             const newCache = await readCacheFileDefaultLocation(this.primary_address, this.pathPrefix);
             if (!newCache)
                 throw new Error(`cache not found for primary address: ${this.primary_address}, and path prefix: ${this.pathPrefix}`);
-            const changed_outputs = maybeInputs.map((input) => ({
-                change_reason: "spent",
-                output: input,
-            }));
+            const changed_outputs = [];
             await this.feed({
                 newCache,
                 changed_outputs,
@@ -480,6 +489,179 @@ export class ScanCacheOpened {
             throw e;
         }
     }
+    outputsForIndexes(indexes) {
+        const byId = new Map(this.spendableInputs().map((output) => [
+            String(output.index_on_blockchain),
+            output,
+        ]));
+        const selected = [];
+        for (const id of indexes) {
+            const output = byId.get(id);
+            if (!output)
+                throw new Error(`input not spendable: ${id}`);
+            selected.push(output);
+        }
+        if (!selected.length)
+            throw new Error("no inputs selected");
+        return selected;
+    }
+    async makeSignSend(params) {
+        // an empty list means the wallet selects the inputs
+        if (!params.input_indexes.length) {
+            return this.makeSignSendTransaction({
+                payments: params.payments,
+            });
+        }
+        return this.makeSignSendTransaction({
+            payments: params.payments,
+            inputs: this.outputsForIndexes(params.input_indexes),
+        });
+    }
+    async sweepSignSend(params) {
+        const inputs = params.input_indexes.length
+            ? this.outputsForIndexes(params.input_indexes)
+            : this.spendableInputs();
+        if (!inputs.length)
+            throw new Error("no inputs selected");
+        const feeEstimate = await this.getFeeEstimate();
+        const unsignedTx = await this.makeSweepTransactionFromSelectedInputs(params.address, inputs, feeEstimate);
+        const signedTx = await this.signTransaction(unsignedTx);
+        const payments = [{ address: params.address, amount: "0" }];
+        const sendResult = await this.sendTransaction(signedTx);
+        if (sendResult.status !== "OK") {
+            await this.recordSend({
+                payments,
+                inputs,
+                signedTx,
+                feeEstimate,
+                sendResult,
+                error: "send raw transaction rpc returned error",
+                lockInputs: false,
+            });
+            throw new Error("send raw transaction rpc returned error");
+        }
+        await this.recordSend({
+            payments,
+            inputs,
+            signedTx,
+            feeEstimate,
+            sendResult,
+            lockInputs: true,
+        });
+        return sendResult;
+    }
+    async rebroadcastTx(txLogIndex) {
+        const txlog = this._cache.tx_logs?.[txLogIndex];
+        if (!txlog?.signed_tx)
+            throw new Error("no signed tx to rebroadcast");
+        const inputs = txlog.inputs_index
+            .map((id) => this._cache.outputs[id])
+            .filter((output) => output);
+        if (inputs.length &&
+            inputs.every((output) => typeof output.spent_in_tx_hash === "string"))
+            throw new Error("inputs already spent on chain");
+        const sendResult = await this.sendTransaction(txlog.signed_tx);
+        await this.stopWorker();
+        await writeCacheFileDefaultLocationThrows({
+            primary_address: this.primary_address,
+            pathPrefix: this.pathPrefix,
+            writeCallback: async (cache) => {
+                const row = cache.tx_logs?.[txLogIndex];
+                if (!row)
+                    throw new Error("tx log missing");
+                row.sendResult = sendResult;
+                if (sendResult.status === "OK") {
+                    row.error = undefined;
+                    if (!cache.pending_spent_utxos)
+                        cache.pending_spent_utxos = {};
+                    for (const inputId of row.inputs_index)
+                        cache.pending_spent_utxos[inputId] = txLogIndex;
+                }
+                else {
+                    row.error = sendResult.reason || "rebroadcast failed";
+                }
+            },
+        });
+        const newCache = await readCacheFileDefaultLocation(this.primary_address, this.pathPrefix);
+        if (!newCache)
+            throw new Error("cache not found after rebroadcast");
+        await this.feed({ newCache, changed_outputs: [] });
+        await this.unpause();
+        return sendResult;
+    }
+    get failed_txs() {
+        const logs = this._cache.tx_logs || [];
+        const rows = [];
+        for (let index = 0; index < logs.length; index++) {
+            const txlog = logs[index];
+            if (!txlog || txlog.hidden_on_send_plate)
+                continue;
+            if (txlog.sendResult?.status === "OK")
+                continue;
+            const inputs = txlog.inputs_index
+                .map((id) => this._cache.outputs[id])
+                .filter((output) => output);
+            if (inputs.length &&
+                inputs.every((output) => typeof output.spent_in_tx_hash === "string"))
+                continue;
+            rows.push({ index, txlog, inputs });
+        }
+        return rows;
+    }
+    async recordSend(args) {
+        await this.stopWorker();
+        await writeCacheFileDefaultLocationThrows({
+            primary_address: this.primary_address,
+            pathPrefix: this.pathPrefix,
+            writeCallback: async (cache) => {
+                if (!cache.tx_logs)
+                    cache.tx_logs = [];
+                if (!cache.pending_spent_utxos)
+                    cache.pending_spent_utxos = {};
+                const inputs_index = args.inputs.map((input) => String(input.index_on_blockchain));
+                const txLog = {
+                    sendResult: args.sendResult,
+                    error: args.error,
+                    feeEstimate: args.feeEstimate,
+                    payments: args.payments,
+                    node_url: this.node_url,
+                    inputs_index,
+                    height: this.current_height,
+                    timestamp: Date.now(),
+                    signed_tx: args.signedTx,
+                };
+                const txLogIndex = cache.tx_logs.push(txLog) - 1;
+                if (!args.lockInputs)
+                    return;
+                for (const inputId of inputs_index)
+                    cache.pending_spent_utxos[inputId] = txLogIndex;
+            },
+        });
+        const newCache = await readCacheFileDefaultLocation(this.primary_address, this.pathPrefix);
+        if (!newCache)
+            throw new Error("cache not found after send");
+        const changed_outputs = args.lockInputs
+            ? args.inputs.map((output) => ({ change_reason: "spent", output }))
+            : [];
+        await this.feed({ newCache, changed_outputs });
+        await this.unpause();
+    }
+    async dismissSendPlate() {
+        await this.stopWorker();
+        await writeCacheFileDefaultLocationThrows({
+            primary_address: this.primary_address,
+            pathPrefix: this.pathPrefix,
+            writeCallback: async (cache) => {
+                for (const row of cache.tx_logs || [])
+                    row.hidden_on_send_plate = true;
+            },
+        });
+        const newCache = await readCacheFileDefaultLocation(this.primary_address, this.pathPrefix);
+        if (!newCache)
+            throw new Error("cache not found after dismiss");
+        await this.feed({ newCache, changed_outputs: [] });
+        await this.unpause();
+    }
     /**
      * makeStandardTransaction
      */
@@ -550,15 +732,35 @@ export class ScanCacheOpened {
         };
     }
     async pause() {
-        this.stopWorker();
+        await this.stopWorker();
         return await this._scanSettings.haltWallet(this.view_pair.primary_address);
     }
-    stopWorker() {
+    // debug: dump coordinator + cpu worker heaps while they are live
+    // in browser: use inspector directly, this is only useful for bun
+    async dumpWorkerHeaps(dir) {
+        if (!this.worker?.dumpHeaps)
+            return [];
+        return await this.worker.dumpHeaps(dir);
+    }
+    async stopWorker() {
         if (this.worker) {
-            this.worker.terminate();
+            const worker = this.worker;
+            // clear ref first so concurrent stop/retry cannot double shutdown
             this.worker.cpuWorkers = [];
             this.worker.fetchWorker = undefined;
             delete this.worker;
+            // drain coordinator first, then hard kill workers
+            try {
+                await worker.shutdown();
+            }
+            catch {
+                // still terminate below
+            }
+            try {
+                worker.terminate();
+            }
+            catch {
+            }
         }
     }
     async unpause() {
@@ -688,48 +890,120 @@ export class ScanCacheOpened {
     _stats = null;
     notifyListeners = [];
 }
+function defaultNotifyMasterChanged(params) {
+    void sendToBackground("walletCacheChanged", JSON.stringify(params, (_k, v) => typeof v === "bigint" ? v.toString() : v)).catch(() => { });
+}
 export class ManyScanCachesOpened {
     connectionStatusOpened;
+    actionLogOpened;
     _scanSettings;
     _options;
     get start_height() {
         if (this.wallets.length === 0)
-            return null;
+            return this._scanSettings.start_height;
         return this.wallets[0]?.start_height;
     }
+    // overall scan tip = lagging non-halted wallet (this.wallets is already non-halted)
     get current_height() {
-        if (this.wallets.length === 0)
-            return null;
-        return this.wallets[0]?.current_height;
+        let min = null;
+        for (const w of this.wallets) {
+            const h = w.current_height;
+            if (h == null)
+                continue;
+            if (min == null || h < min)
+                min = h;
+        }
+        return min;
     }
     get node_url() {
         if (this.wallets.length === 0)
-            return "";
+            return this._scanSettings.node_url ?? "";
         return this.wallets[0]?.node_url;
     }
     async changeNodeUrlAndStartHeight(node_url, start_height) {
-        if (this.wallets.length === 0)
-            throw new Error("no wallets");
-        const masterWallet = this.wallets[0];
-        return await masterWallet.changeNodeUrlAndStartHeight(node_url, start_height);
+        if (this.actionLogOpened.extensionMessageBus === "ui") {
+            await sendToBackground("worker.changeNodeUrlAndStartHeight", {
+                node_url,
+                start_height,
+            }).catch(() => { });
+            return;
+        }
+        if (this.wallets.length === 0) {
+            if (node_url !== undefined)
+                await this._scanSettings.setNodeUrl(node_url);
+            if (start_height !== undefined)
+                await this._scanSettings.setStartHeight(start_height);
+            return;
+        }
+        await this.wallets[0].changeNodeUrlAndStartHeight(node_url, start_height);
     }
     async retry() {
         if (this.wallets.length === 0)
-            throw new Error("no wallets");
+            return;
         const masterWallet = this.wallets[0];
         return await masterWallet.retry();
     }
-    stopWorker() {
+    async stopWorker() {
+        if (this.actionLogOpened.extensionMessageBus === "ui") {
+            await sendToBackground("worker.stopWorker", null).catch(() => { });
+            return;
+        }
         if (this.wallets.length === 0)
-            throw new Error("no wallets");
+            return;
         const masterWallet = this.wallets[0];
-        return masterWallet.stopWorker();
+        return await masterWallet.stopWorker();
     }
-    async changeNodeUrl(node_url) {
+    // debug: dump live coordinator + cpu worker heaps via master wallet workers
+    // in browser: use inspector directly, this is only useful for bun
+    async dumpWorkerHeaps(dir) {
         if (this.wallets.length === 0)
-            throw new Error("no wallets");
-        const masterWallet = this.wallets[0];
-        return await masterWallet.changeNodeUrl(node_url);
+            return [];
+        return await this.wallets[0].dumpWorkerHeaps(dir);
+    }
+    async changeNodeUrl(node_url) {
+        if (this.actionLogOpened.extensionMessageBus === "ui") {
+            await sendToBackground("worker.setNodeUrl", { node_url }).catch(() => { });
+            return;
+        }
+        if (this.wallets.length === 0) {
+            await this._scanSettings.setNodeUrl(node_url);
+            return;
+        }
+        await this.wallets[0].changeNodeUrl(node_url);
+    }
+    walletByAddress(primary_address) {
+        const wallet = this.wallets.find((row) => row.primary_address === primary_address);
+        if (!wallet)
+            throw new Error("wallet not found");
+        return wallet;
+    }
+    async makeSignSend(params) {
+        if (this.actionLogOpened.extensionMessageBus === "ui") {
+            await sendToBackground("worker.makeSignSend", params).catch(() => { });
+            return;
+        }
+        return this.walletByAddress(params.primary_address).makeSignSend(params);
+    }
+    async sweepSignSend(params) {
+        if (this.actionLogOpened.extensionMessageBus === "ui") {
+            await sendToBackground("worker.sweepSignSend", params).catch(() => { });
+            return;
+        }
+        return this.walletByAddress(params.primary_address).sweepSignSend(params);
+    }
+    async rebroadcastTx(params) {
+        if (this.actionLogOpened.extensionMessageBus === "ui") {
+            await sendToBackground("worker.rebroadcastTx", params).catch(() => { });
+            return;
+        }
+        return this.walletByAddress(params.primary_address).rebroadcastTx(params.tx_log_index);
+    }
+    async dismissSendPlate(params) {
+        if (this.actionLogOpened.extensionMessageBus === "ui") {
+            await sendToBackground("worker.dismissSendPlate", params).catch(() => { });
+            return;
+        }
+        return this.walletByAddress(params.primary_address).dismissSendPlate();
     }
     get merchant_confirmations() {
         if (this.wallets.length === 0)
@@ -742,19 +1016,13 @@ export class ManyScanCachesOpened {
         return this.wallets[0]?.cpu_worker_count;
     }
     get logs() {
-        if (this.wallets.length === 0)
-            return undefined;
-        return this.wallets[0]?.logs;
+        return this._scanSettings.logs;
     }
     get logs_include() {
-        if (this.wallets.length === 0)
-            return undefined;
-        return this.wallets[0]?.logs_include;
+        return this._scanSettings.logs_include;
     }
     get logs_exclude() {
-        if (this.wallets.length === 0)
-            return undefined;
-        return this.wallets[0]?.logs_exclude;
+        return this._scanSettings.logs_exclude;
     }
     get connectionStatus() {
         return this.connectionStatusOpened.connectionStatus;
@@ -770,18 +1038,29 @@ export class ManyScanCachesOpened {
     }
     async setMerchantConfirmations(merchant_confirmations) {
         if (this.wallets.length === 0)
-            throw new Error("no wallets");
+            return;
         return await this.wallets[0].setMerchantConfirmations(merchant_confirmations);
     }
     async setCpuWorkerCount(cpu_worker_count) {
         if (this.wallets.length === 0)
-            throw new Error("no wallets");
+            return;
         return await this.wallets[0].setCpuWorkerCount(cpu_worker_count);
     }
     async setLogSettings(logs, logs_include, logs_exclude) {
-        if (this.wallets.length === 0)
-            throw new Error("no wallets");
-        return await this.wallets[0].setLogSettings(logs, logs_include, logs_exclude);
+        if (this.actionLogOpened.extensionMessageBus === "ui") {
+            await sendToBackground("worker.setLogSettings", {
+                logs,
+                logs_include,
+                logs_exclude,
+            }).catch(() => { });
+        }
+        await this._scanSettings.setLogSettings(logs, logs_include, logs_exclude);
+        if (this.actionLogOpened.extensionMessageBus === "ui")
+            return;
+        for (const wallet of this.wallets)
+            await wallet.stopWorker();
+        for (const wallet of this.wallets)
+            await wallet.unpause();
     }
     async setWalletName(primary_address, name) {
         await this._scanSettings.setWalletName(primary_address, name);
@@ -790,10 +1069,17 @@ export class ManyScanCachesOpened {
         await this._scanSettings.setWalletSlot(primary_address, slot);
     }
     async changeStartHeight(start_height) {
-        if (this.wallets.length === 0)
-            throw new Error("no wallets");
-        const masterWallet = this.wallets[0];
-        return await masterWallet.changeStartHeight(start_height);
+        if (this.actionLogOpened.extensionMessageBus === "ui") {
+            await sendToBackground("worker.setStartHeight", {
+                start_height,
+            }).catch(() => { });
+            return;
+        }
+        if (this.wallets.length === 0) {
+            await this._scanSettings.setStartHeight(start_height);
+            return;
+        }
+        await this.wallets[0].changeStartHeight(start_height);
     }
     static async _buildWallets(scanSettingsOpened, options) {
         const { scan_settings_path, pathPrefix, no_worker, no_stats, workerError, notifyMasterChanged, } = options;
@@ -851,28 +1137,49 @@ export class ManyScanCachesOpened {
     static async create(options) {
         const { scan_settings_path, pathPrefix, onConnectionStatusChange, connectionStatusIntervalMs, autoRetry, retryDelayMs, } = options;
         const scanSettingsOpened = await ScanSettingsOpened.create(scan_settings_path, pathPrefix);
-        if (!scanSettingsOpened.wallets || scanSettingsOpened.wallets.length === 0)
-            throw new Error(`no wallets in settings file. Did you supply the right path?
-     are there wallets in the default '${SCAN_SETTINGS_STORE_NAME_DEFAULT}' file?`);
+        // persist log options into ScanSettings.json before workers start
+        if (options.logs !== undefined ||
+            options.logs_include !== undefined ||
+            options.logs_exclude !== undefined) {
+            await scanSettingsOpened.setLogSettings(options.logs !== undefined ? options.logs : scanSettingsOpened.logs, options.logs_include !== undefined
+                ? options.logs_include
+                : scanSettingsOpened.logs_include, options.logs_exclude !== undefined
+                ? options.logs_exclude
+                : scanSettingsOpened.logs_exclude);
+        }
         // wrap workerError with auto-retry
         let retryTimer;
         let instance = null;
+        const clearRetryTimer = () => {
+            clearTimeout(retryTimer);
+            retryTimer = undefined;
+        };
         const retryFn = async () => {
-            await instance?.buildWallets();
-            const node_url = instance?.node_url;
+            clearRetryTimer();
+            // no wallets means idle, do not rebuild or restart workers
+            if (!instance || instance.wallets.length === 0)
+                return;
+            const node_url = instance.node_url;
             if (!node_url)
-                throw new Error("No nodeurl set, can't retry connection");
+                return;
+            // probe first; only restart workers when node is reachable
             const getinfo_result = await get_info(node_url)
-                .then((r) => {
-                r?.status === "OK";
-            })
+                .then((r) => r?.status === "OK")
                 .catch(() => false);
-            if (getinfo_result)
-                await instance?.retry();
-            clearTimeout(retryTimer);
-            retryTimer = undefined;
+            if (!getinfo_result) {
+                // still down: try again later without buildWallets thrash
+                if (!retryTimer && instance.wallets.length > 0) {
+                    retryTimer = setTimeout(retryFn, retryDelayMs ?? 5000);
+                }
+                return;
+            }
+            await instance.buildWallets();
         };
         const newOptions = { ...options };
+        // browser worker (background.ts): broadcast cache to sidebar 
+        if (!newOptions.notifyMasterChanged && !newOptions.no_worker) {
+            newOptions.notifyMasterChanged = defaultNotifyMasterChanged;
+        }
         let connectionFailedShown = false;
         if (autoRetry) {
             const originalError = options.workerError;
@@ -881,7 +1188,7 @@ export class ManyScanCachesOpened {
                 const msg = err instanceof Error ? err.message : String(err);
                 if (csOpened.connectionStatus?.last_packet?.status ===
                     "catastrophic_reorg") {
-                    clearTimeout(retryTimer);
+                    clearRetryTimer();
                     instance?.stopWorker();
                     throw new Error("catastrophic reorg, aborting ...");
                 }
@@ -893,14 +1200,13 @@ export class ManyScanCachesOpened {
                         console.error("unable to connect to node ... retrying ...");
                     }
                 }
-                if (!retryTimer) {
+                // only schedule retry when we still have wallets to scan
+                if (!retryTimer && instance && instance.wallets.length > 0) {
                     retryTimer = setTimeout(retryFn, retryDelayMs ?? 5000);
                 }
             };
         }
-        const wallets = await this._buildWallets(scanSettingsOpened, newOptions);
-        if (!wallets)
-            return undefined;
+        const wallets = (await this._buildWallets(scanSettingsOpened, newOptions)) ?? [];
         const csOpened = new ConnectionStatusOpened(scan_settings_path || SCAN_SETTINGS_STORE_NAME_DEFAULT, autoRetry
             ? (status) => {
                 if (status?.last_packet?.status === "OK" && connectionFailedShown) {
@@ -912,40 +1218,73 @@ export class ManyScanCachesOpened {
             }
             : (onConnectionStatusChange ?? null));
         csOpened.watch(connectionStatusIntervalMs);
-        instance = new ManyScanCachesOpened(wallets, csOpened, scanSettingsOpened, newOptions);
+        const actionLogPath = newOptions.actionLogPath ??
+            actionLogPathFromScanSettings(scan_settings_path || SCAN_SETTINGS_STORE_NAME_DEFAULT);
+        const actionLogOpened = await ActionLogOpened.create({
+            path: actionLogPath,
+            backend: newOptions.actionLogBackend,
+            onChange: newOptions.onActionLogChange ?? null,
+            extensionMessageBus: newOptions.extensionMessageBus,
+        });
+        instance = new ManyScanCachesOpened(wallets, csOpened, actionLogOpened, scanSettingsOpened, newOptions);
         return instance;
     }
     async buildWallets() {
-        this.stopWorker();
+        if (this.actionLogOpened.extensionMessageBus === "ui") {
+            await sendToBackground("worker.buildWallets", null).catch(() => { });
+            return;
+        }
+        await this.stopWorker();
+        await this.reloadWalletsAfterStop();
+    }
+    // assumes stopWorker already ran (graceful shutdown + terminate)
+    async reloadWalletsAfterStop() {
         await this._scanSettings.reload();
+        // empty after reload: stay idle, do not open ScanCacheOpened or start workers
+        const remaining = this._scanSettings.wallets.filter((w) => !w?.halted);
+        if (remaining.length === 0) {
+            this._wallets = [];
+            return;
+        }
         const newWallets = await ManyScanCachesOpened._buildWallets(this._scanSettings, this._options);
-        if (!newWallets)
-            throw new Error("no non-halted wallets left after rebuild, use addViewWallet or addSpendWallet first");
-        this._wallets = newWallets;
+        this._wallets = newWallets ?? [];
     }
     async addViewWallet(primary_address, view_key, fields) {
+        await this.stopWorker();
         await this._scanSettings.addViewWallet(primary_address, view_key, fields);
-        await this.buildWallets();
+        await this.reloadWalletsAfterStop();
     }
     async addSpendWallet(wallet_secret, fields) {
+        await this.stopWorker();
         await this._scanSettings.addSpendWallet(wallet_secret, fields);
-        await this.buildWallets();
+        await this.reloadWalletsAfterStop();
     }
     async removeWallet(primary_address) {
+        await this.stopWorker();
         await this._scanSettings.removeWallet(primary_address);
-        await this.buildWallets();
+        await this.reloadWalletsAfterStop();
     }
     async feed(params) {
+        if (this.wallets.length === 0)
+            return;
         await this.wallets[0].feed(params);
     }
     _wallets = [];
     get wallets() {
         return this._wallets;
     }
-    constructor(wallets, connectionStatusOpened, _scanSettings, _options) {
+    constructor(wallets, connectionStatusOpened, actionLogOpened, _scanSettings, _options) {
         this.connectionStatusOpened = connectionStatusOpened;
+        this.actionLogOpened = actionLogOpened;
         this._scanSettings = _scanSettings;
         this._options = _options;
         this._wallets = wallets;
+        this.actionLogOpened.bindMco(this);
     }
 }
+function actionLogPathFromScanSettings(scan_settings_path) {
+    const base = scan_settings_path.replace(/\.json$/i, "");
+    if (globalThis.areWeInTheBrowser === true)
+        return "actionlog";
+    return `${base}-actionlog.sqlite`;
+}