@spirobel/monero-wallet-api 0.5.4 → 0.5.5

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

@@ -37,11 +37,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 +57,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 +68,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 +85,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 +96,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 +171,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 +183,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 +192,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 +205,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);
@@ -396,7 +400,7 @@ export class ScanCacheOpened {
             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,
@@ -440,7 +444,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,
@@ -550,15 +554,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() {
@@ -697,10 +721,17 @@ export class ManyScanCachesOpened {
             return null;
         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)
@@ -709,25 +740,32 @@ export class ManyScanCachesOpened {
     }
     async changeNodeUrlAndStartHeight(node_url, start_height) {
         if (this.wallets.length === 0)
-            throw new Error("no wallets");
+            return;
         const masterWallet = this.wallets[0];
         return await masterWallet.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.wallets.length === 0)
-            throw new Error("no wallets");
+            return;
         const masterWallet = this.wallets[0];
-        return masterWallet.stopWorker();
+        return await masterWallet.stopWorker();
+    }
+    // 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)
+            return [];
+        return await this.wallets[0].dumpWorkerHeaps(dir);
     }
     async changeNodeUrl(node_url) {
         if (this.wallets.length === 0)
-            throw new Error("no wallets");
+            return;
         const masterWallet = this.wallets[0];
         return await masterWallet.changeNodeUrl(node_url);
     }
@@ -742,19 +780,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 +802,16 @@ 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);
+        return await this._scanSettings.setLogSettings(logs, logs_include, logs_exclude);
     }
     async setWalletName(primary_address, name) {
         await this._scanSettings.setWalletName(primary_address, name);
@@ -791,7 +821,7 @@ export class ManyScanCachesOpened {
     }
     async changeStartHeight(start_height) {
         if (this.wallets.length === 0)
-            throw new Error("no wallets");
+            return;
         const masterWallet = this.wallets[0];
         return await masterWallet.changeStartHeight(start_height);
     }
@@ -851,15 +881,34 @@ 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 retryFn = async () => {
-            await instance?.buildWallets();
-            const node_url = instance?.node_url;
+            // no wallets means idle, do not rebuild or restart workers
+            if (!instance || instance.wallets.length === 0) {
+                clearTimeout(retryTimer);
+                retryTimer = undefined;
+                return;
+            }
+            await instance.buildWallets();
+            // still empty after rebuild, stay idle
+            if (instance.wallets.length === 0) {
+                clearTimeout(retryTimer);
+                retryTimer = undefined;
+                return;
+            }
+            const node_url = instance.node_url;
             if (!node_url)
                 throw new Error("No nodeurl set, can't retry connection");
             const getinfo_result = await get_info(node_url)
@@ -893,14 +942,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) {
@@ -916,26 +964,39 @@ export class ManyScanCachesOpened {
         return instance;
     }
     async buildWallets() {
-        this.stopWorker();
+        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 = [];

package/dist/scanning-syncing/scanresult/scanCoordination.d.ts

@@ -64,7 +64,6 @@ export type CoordinatorEvent = {
 } | {
     type: "scan_ready";
     address: string;
-    result: ScanLoopYield;
     newCache: ScanCache;
     changed_outputs: {
         output: any;
@@ -72,11 +71,13 @@ export type CoordinatorEvent = {
     }[];
 } | {
     type: "all_idle";
+} | {
+    type: "shutdown_done";
 } | {
     type: "error";
     error: Error;
 };
-export declare function setupCoordinator(scanSettingsPath?: string, pathPrefix?: string): Promise<false | {
+export declare function setupCoordinator(scanSettingsPath?: string, pathPrefix?: string, stopSync?: AbortSignal): Promise<false | {
     blocksGenerator: AsyncGenerator<BlocksBufferLoopResult, any, any>;
     workBuffer: WorkItem[];
     blocksBuffer: GetBlocksBinBufferItem[];
@@ -96,10 +97,12 @@ export type BlocksBufferRacer = {
 };
 export type ScanLoopRacer = ScanLoopYield;
 export type Racers = BlocksBufferRacer | ScanLoopRacer;
+export declare function resetInProgressWorkItems(workBuffer: WorkItem[]): void;
+export declare function cancelBusyCpuPorts(ports: PortStatus[], timeoutMs?: number): Promise<void>;
 /**
  * coordinator main (multithreaded): dispatches scan work to CPU workers
  * via MessagePorts, processes results in order per wallet.
  * falls back to single-threaded coordinator if no cpuPorts provided.
  */
-export declare function coordinatorMainMultithreaded(scanSettingsPath?: string, pathPrefix?: string, cpuPorts?: MessagePort[]): AsyncGenerator<CoordinatorEvent>;
+export declare function coordinatorMainMultithreaded(scanSettingsPath?: string, pathPrefix?: string, cpuPorts?: MessagePort[], stopSync?: AbortSignal): AsyncGenerator<CoordinatorEvent>;
 export declare function scheduleWorkOnCpuPorts(ports: PortStatus[], work_buffer: WorkItem[]): Promise<void>;

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

@@ -1,5 +1,5 @@
-import { setupBlocksBufferGenerator, ViewPair, handleConnectionStatusChanges, processScanResult, writeCacheToFile, sleep, findTipIndex, readWriteConnectionStatusFile, } from "../../api";
-import { markWorkItemAsDone, } from "./scanLoop";
+import { setupBlocksBufferGenerator, ViewPair, handleConnectionStatusChanges, processScanResult, writeCacheToFile, sleep, findTipIndex, readWriteConnectionStatusFile, applyWalletScanProgress, } from "../../api";
+import {} from "./scanLoop";
 import { makeWorkItem } from "./scanLoop";
 import { cullTooLargeScanHeight, getNonHaltedWallets, getPathPrefix, openScanSettingsFile, SCAN_SETTINGS_STORE_NAME_DEFAULT, walletSettingsPlusKeys, } from "../../api";
 import { findRange, initScanCacheFile, lastRange, makeCacheRangeForHeight, mergeRanges, } from "./scanCache";
@@ -220,6 +220,9 @@ export async function processWorkItem(item, workBuffer, blocksBuffer, pathPrefix
         throw error;
     }
     await writeCacheToFile(cache, pathPrefix);
+    // raw cpu ScanResult is fully merged into cache now. drop it so workBuffer
+    // does not pin all_key_images / hash strings until left-edge free.
+    item.result = undefined;
     item.status = "process_result_done";
     log("processWorkItem", `process_result_done work_uuid=${item?.work_uuid}`);
     // remove from blocksbuffer if no more work items reference it
@@ -271,7 +274,7 @@ function computeETA(cache, totalBlocksScanned, scanStartTime) {
     const etaMs = remaining / blocksPerMs;
     return msToHHMM(etaMs);
 }
-export async function setupCoordinator(scanSettingsPath, pathPrefix) {
+export async function setupCoordinator(scanSettingsPath, pathPrefix, stopSync) {
     const work_to_be_done = await findWorkToBeDone(scanSettingsPath, pathPrefix);
     if (!work_to_be_done)
         return false;
@@ -280,6 +283,7 @@ export async function setupCoordinator(scanSettingsPath, pathPrefix) {
         startHeight: work_to_be_done.start_height,
         anchor_range: work_to_be_done.anchor_range,
         scanSettingsPath,
+        stopSync,
     });
     const workBuffer = [];
     //TODO: refactor to per wallet buffer
@@ -298,16 +302,46 @@ export async function setupCoordinator(scanSettingsPath, pathPrefix) {
         work_to_be_done,
     };
 }
+// flip inflight work back to fresh so a restart can reschedule it
+export function resetInProgressWorkItems(workBuffer) {
+    for (const item of workBuffer) {
+        if (item.status === "scanwork_in_progress") {
+            item.status = "fresh";
+            item.result = undefined;
+        }
+    }
+}
+// tell busy cpu ports to cancel and wait for their promises (with timeout)
+export async function cancelBusyCpuPorts(ports, timeoutMs = 3000) {
+    const busy = ports.filter((ps) => ps.promise);
+    for (const ps of busy) {
+        try {
+            sendToCpuWorker(ps.port, "cancel");
+        }
+        catch (err) {
+            log("cancelBusyCpuPorts", ["send cancel failed", String(err)]);
+        }
+    }
+    if (busy.length === 0)
+        return;
+    await Promise.race([
+        Promise.allSettled(busy.map((ps) => ps.promise)),
+        sleep(timeoutMs),
+    ]);
+    for (const ps of ports) {
+        ps.promise = null;
+    }
+}
 /**
  * coordinator main (multithreaded): dispatches scan work to CPU workers
  * via MessagePorts, processes results in order per wallet.
  * falls back to single-threaded coordinator if no cpuPorts provided.
  */
-export async function* coordinatorMainMultithreaded(scanSettingsPath, pathPrefix, cpuPorts) {
+export async function* coordinatorMainMultithreaded(scanSettingsPath, pathPrefix, cpuPorts, stopSync) {
     if (!cpuPorts || cpuPorts.length === 0) {
         throw new Error("[coordinatorMain Multithreaded] cpuPorts empty, there must be at least cpu worker");
     }
-    const ctx = await setupCoordinator(scanSettingsPath, pathPrefix);
+    const ctx = await setupCoordinator(scanSettingsPath, pathPrefix, stopSync);
     if (!ctx)
         throw new Error("[coordinatorMain Multithreaded] findWorkToBeDone returned false");
     const work_to_be_done = ctx.work_to_be_done;
@@ -327,6 +361,13 @@ export async function* coordinatorMainMultithreaded(scanSettingsPath, pathPrefix
     }
     let race_count = 0;
     while (true) {
+        if (stopSync?.aborted) {
+            log("coordinatorMainMultithreaded", ["shutdown signal, draining"]);
+            await cancelBusyCpuPorts(freePorts);
+            resetInProgressWorkItems(workBuffer);
+            yield { type: "shutdown_done" };
+            return;
+        }
         race_count++;
         log("coordinatorMainMultithreaded", ["race_count", race_count]);
         await scheduleWorkOnCpuPorts(freePorts, workBuffer);
@@ -344,6 +385,16 @@ export async function* coordinatorMainMultithreaded(scanSettingsPath, pathPrefix
         const winner = await Promise.race(races);
         log("coordinatorMainMultithreaded", "cpu ports status");
         if ("src" in winner && winner.src === "blocks") {
+            // fetch loop returned (done) on abort, treat as shutdown
+            if (winner.value.done) {
+                log("coordinatorMainMultithreaded", [
+                    "blocks generator done, draining",
+                ]);
+                await cancelBusyCpuPorts(freePorts);
+                resetInProgressWorkItems(workBuffer);
+                yield { type: "shutdown_done" };
+                return;
+            }
             const result = winner.value.value;
             const { isBlocksBufferChanged } = await handleBlocksYield(result, scanSettingsPath);
             if (isBlocksBufferChanged) {
@@ -376,30 +427,22 @@ export async function* coordinatorMainMultithreaded(scanSettingsPath, pathPrefix
                 continue;
             const blockCount = to_be_processed.to - to_be_processed.from + 1;
             totalBlocksScanned += blockCount;
-            const eta = computeETA(wallet.cache, totalBlocksScanned, scanStartTime);
-            // write connection status sync (includes eta)
-            if (eta) {
-                await readWriteConnectionStatusFile((cs) => {
-                    cs.sync = {
-                        ...cs.sync,
-                        scanned_ranges: wallet.cache.scanned_ranges,
-                        daemon_height: wallet.cache.daemon_height,
-                        current_scan_height: lastRange(wallet.cache.scanned_ranges)?.end || 0,
-                        eta,
-                        timestamp: new Date().toISOString(),
-                    };
-                }, scanSettingsPath);
-            }
             const res = await processWorkItem(to_be_processed, workBuffer, blocksBuffer, getPathPrefix(scanSettingsPath, pathPrefix), wallet.secret_spend_key);
+            // always persist wallet progress after process; eta only if we have a new one
+            // so missing eta does not wipe the previous value (no flicker)
+            const eta = computeETA(wallet.cache, totalBlocksScanned, scanStartTime);
+            await readWriteConnectionStatusFile((cs) => {
+                applyWalletScanProgress(cs, {
+                    current_scan_height: lastRange(wallet.cache.scanned_ranges)?.end || 0,
+                    scanned_ranges: wallet.cache.scanned_ranges,
+                    daemon_height: wallet.cache.daemon_height,
+                    eta,
+                });
+            }, scanSettingsPath);
             //  log("coordinatorMainMultithreaded", "processWorkItem result");
             yield {
                 type: "scan_ready",
                 address: wallet.primary_address,
-                result: {
-                    type: "Ready",
-                    work_uuid: to_be_processed.work_uuid,
-                    result: to_be_processed.result,
-                },
                 newCache: wallet.cache,
                 changed_outputs: res.changed_outputs,
             };
@@ -424,6 +467,17 @@ export async function scheduleWorkOnCpuPorts(ports, work_buffer) {
             const msg = event.data;
             // handle the result here:
             log("scheduleWorkOnCpuPorts", ["onmessage result", msg]);
+            // cancel ack may omit work_uuid when idle, but inflight cancel carries it
+            if (msg.type === "Canceled") {
+                if (item.status === "scanwork_in_progress") {
+                    item.status = "fresh";
+                    item.result = undefined;
+                }
+                port_status.promise = null;
+                // thin resolve: dont put full msg/result on the port promise on cancel
+                resolve_port({ type: "Canceled", work_uuid: item.work_uuid });
+                return;
+            }
             if (msg.work_uuid !== item.work_uuid) {
                 log("scheduleWorkOnCpuPorts", [
                     "wrong work_uuid in msg msg.work_uuid=",
@@ -441,10 +495,18 @@ export async function scheduleWorkOnCpuPorts(ports, work_buffer) {
                 log("scheduleWorkOnCpuPorts", "wrong status in msg");
                 throw new Error("[scheduleWorkOnCpuPorts] wrong status in msg");
             }
+            // fat ScanResult lives only on the work item until process clears it
             item.result = msg.result;
             item.status = "scanwork_done";
+            // cpu already has its own buffer copy; process only needs meta.
+            // drop work-item bytes now; blocksBuffer still owns the batch until left-edge free.
+            item.batch = {
+                ...item.batch,
+                data: new Uint8Array(0),
+            };
             port_status.promise = null;
-            resolve_port(msg);
+            // thin resolve: race/await must not retain all_key_images via promise value
+            resolve_port({ type: msg.type, work_uuid: msg.work_uuid });
         };
         port_status.port.onmessage = onmessage;
         item.status = "scanwork_in_progress";

package/dist/scanning-syncing/scanresult/scanLoop.d.ts

@@ -12,9 +12,8 @@ export declare function makeWorkItem(walletConfig: WalletConfigPlusCache, batch:
 export type ScanLoopIteratorResult = IteratorYieldResult<ScanLoopYield>;
 export type ScanLoopInput = WorkItem | "cancel" | undefined;
 export type ScanLoopYield = {
-    type: "Ready" | "InProgress";
+    type: "Ready" | "InProgress" | "Canceled";
     work_uuid?: string;
     result?: ScanResult;
 };
 export declare function scanLoop(wallet: WalletConfig): AsyncGenerator<ScanLoopYield, void, ScanLoopInput>;
-export declare function markWorkItemAsDone(loop_event: ScanLoopYield, work_buffer: WorkItem[]): Promise<WorkItem | undefined>;

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

@@ -101,16 +101,3 @@ export async function* scanLoop(wallet) {
         // will be done by processScanResult in the consumer
     }
 }
-//theoretically markWorkItemAsDone could be done in the generator as WorkItem is passed in by reference
-// but: eventually this has to be done accross CPU worker boundaries
-// so we act on the yielded scan result
-export async function markWorkItemAsDone(loop_event, work_buffer) {
-    if (loop_event.type === "Ready" && loop_event.work_uuid) {
-        const work_item = work_buffer.find((w) => w.work_uuid === loop_event.work_uuid);
-        if (work_item) {
-            work_item.result = loop_event.result;
-            work_item.status = "scanwork_done";
-            return work_item;
-        }
-    }
-}