@spirobel/monero-wallet-api 0.5.3 → 0.5.5

package/README.md

@@ -1,5 +1,11 @@
 # @spirobel/monero-wallet-api
 
+## install 
+
+```bash
+bun add @spirobel/monero-wallet-api
+```
+
 ## quick start
 
 ```ts

package/dist/api.d.ts

@@ -14,7 +14,7 @@ export * from "./multisig/multisig";
 export * from "./multisig/DistributedKeyGenerator";
 export * from "./multisig/escrow";
 export * from "./multisig/MultiSigTxSigner";
-export { startWebworker, createWebworker, makeWebworkerScript, } from "./scanning-syncing/backgroundWorker";
+export { createWebworker, makeWebworkerScript, } from "./scanning-syncing/backgroundWorker";
 export { spendable } from "./scanning-syncing/scanresult/scanResult";
 export { openWallets, openWallet } from "./scanning-syncing/openWallet";
 export * from "./scanning-syncing/blocksbuffer/blocksBufferFetchLoop";

package/dist/api.js

@@ -13,7 +13,7 @@ export * from "./multisig/multisig";
 export * from "./multisig/DistributedKeyGenerator";
 export * from "./multisig/escrow";
 export * from "./multisig/MultiSigTxSigner";
-export { startWebworker, createWebworker, makeWebworkerScript, } from "./scanning-syncing/backgroundWorker";
+export { createWebworker, makeWebworkerScript, } from "./scanning-syncing/backgroundWorker";
 export { spendable } from "./scanning-syncing/scanresult/scanResult";
 export { openWallets, openWallet } from "./scanning-syncing/openWallet";
 export * from "./scanning-syncing/blocksbuffer/blocksBufferFetchLoop";

package/dist/io/logging.d.ts

@@ -13,7 +13,7 @@
  *   "logs_include": ["blocksBufferFetchLoop", "makeWorkItemsFromBlocksBuffer", "logBufStatus"]
  *     -> block fetching, reconciliation, buffer state.
  *
- *   "logs_include": ["processScanResult", "processWorkItem", "processScanResultForWorkItem"]
+ *   "logs_include": ["processScanResult", "processWorkItem"]
  *     -> result processing, cache updates, reorg detection.
  *
  *   "logs_include": ["handleConnectionStatusChanges", "handleScanError"]
@@ -23,7 +23,7 @@
  *   "logs": "file"  writes to `<coordinator|cpubound|mainthread>-<id>-<timestamp>.log`.
  *   "logs": "console-and-file"  writes to file and console.
  */
-export declare const LOGGING_FUNCTIONS: readonly ["findWorkToBeDone", "workToBeDoneForBatch", "makeWorkItemsFromBlocksBuffer", "reconcileWorkItemDone", "processScanResultForWorkItem", "processWorkItem", "logBufStatus", "coordinatorMain", "coordinatorMainMultithreaded", "scheduleWorkOnCpuPorts", "processScanResult", "handleScanError", "createWebworker", "startWebworker", "blocksBufferFetchLoop", "reduceStartHeightToTip", "handleConnectionStatusChanges", "handleCpuboundScan", "coordinatorMainWorker", "CPU_PORT_HANDLER", "atomicWrite", "multisigMainWorkerCall"];
+export declare const LOGGING_FUNCTIONS: readonly ["findWorkToBeDone", "workToBeDoneForBatch", "makeWorkItemsFromBlocksBuffer", "reconcileWorkItemDone", "processWorkItem", "logBufStatus", "coordinatorMain", "coordinatorMainMultithreaded", "scheduleWorkOnCpuPorts", "processScanResult", "handleScanError", "createWebworker", "startWebworker", "blocksBufferFetchLoop", "reduceStartHeightToTip", "handleConnectionStatusChanges", "handleCpuboundScan", "coordinatorMainWorker", "CPU_PORT_HANDLER", "atomicWrite", "multisigMainWorkerCall"];
 export type PossibleLogs = (typeof LOGGING_FUNCTIONS)[number];
 export type LogSetting = "console" | "file" | "console-and-file" | "off";
 export type FileLogMessage = {
@@ -31,10 +31,10 @@ export type FileLogMessage = {
     message: any;
 };
 export declare function setupLoggingPath(scan_settings_path: string, path_prefix: string, role: "coordinator" | "cpubound" | "mainthread" | "multisig", cpu_worker_id?: number): Promise<{
-    logs: LogSetting | undefined;
-    logs_include: ("findWorkToBeDone" | "workToBeDoneForBatch" | "makeWorkItemsFromBlocksBuffer" | "reconcileWorkItemDone" | "processScanResultForWorkItem" | "processWorkItem" | "logBufStatus" | "coordinatorMain" | "coordinatorMainMultithreaded" | "scheduleWorkOnCpuPorts" | "processScanResult" | "handleScanError" | "createWebworker" | "startWebworker" | "blocksBufferFetchLoop" | "reduceStartHeightToTip" | "handleConnectionStatusChanges" | "handleCpuboundScan" | "coordinatorMainWorker" | "CPU_PORT_HANDLER" | "atomicWrite" | "multisigMainWorkerCall")[] | undefined;
-    logs_exclude: ("findWorkToBeDone" | "workToBeDoneForBatch" | "makeWorkItemsFromBlocksBuffer" | "reconcileWorkItemDone" | "processScanResultForWorkItem" | "processWorkItem" | "logBufStatus" | "coordinatorMain" | "coordinatorMainMultithreaded" | "scheduleWorkOnCpuPorts" | "processScanResult" | "handleScanError" | "createWebworker" | "startWebworker" | "blocksBufferFetchLoop" | "reduceStartHeightToTip" | "handleConnectionStatusChanges" | "handleCpuboundScan" | "coordinatorMainWorker" | "CPU_PORT_HANDLER" | "atomicWrite" | "multisigMainWorkerCall")[] | undefined;
+    logs: "console" | "file" | "console-and-file";
+    logs_include: ("findWorkToBeDone" | "workToBeDoneForBatch" | "makeWorkItemsFromBlocksBuffer" | "reconcileWorkItemDone" | "processWorkItem" | "logBufStatus" | "coordinatorMain" | "coordinatorMainMultithreaded" | "scheduleWorkOnCpuPorts" | "processScanResult" | "handleScanError" | "createWebworker" | "startWebworker" | "blocksBufferFetchLoop" | "reduceStartHeightToTip" | "handleConnectionStatusChanges" | "handleCpuboundScan" | "coordinatorMainWorker" | "CPU_PORT_HANDLER" | "atomicWrite" | "multisigMainWorkerCall")[] | undefined;
+    logs_exclude: ("findWorkToBeDone" | "workToBeDoneForBatch" | "makeWorkItemsFromBlocksBuffer" | "reconcileWorkItemDone" | "processWorkItem" | "logBufStatus" | "coordinatorMain" | "coordinatorMainMultithreaded" | "scheduleWorkOnCpuPorts" | "processScanResult" | "handleScanError" | "createWebworker" | "startWebworker" | "blocksBufferFetchLoop" | "reduceStartHeightToTip" | "handleConnectionStatusChanges" | "handleCpuboundScan" | "coordinatorMainWorker" | "CPU_PORT_HANDLER" | "atomicWrite" | "multisigMainWorkerCall")[] | undefined;
     file_logbuffer: FileLogMessage[];
     global_logging_path: string;
-}>;
+} | undefined>;
 export declare function log(fnname: string, message: any): void;

package/dist/io/logging.js

@@ -15,7 +15,7 @@ import { atomicWrite } from "./atomicWrite";
  *   "logs_include": ["blocksBufferFetchLoop", "makeWorkItemsFromBlocksBuffer", "logBufStatus"]
  *     -> block fetching, reconciliation, buffer state.
  *
- *   "logs_include": ["processScanResult", "processWorkItem", "processScanResultForWorkItem"]
+ *   "logs_include": ["processScanResult", "processWorkItem"]
  *     -> result processing, cache updates, reorg detection.
  *
  *   "logs_include": ["handleConnectionStatusChanges", "handleScanError"]
@@ -31,7 +31,6 @@ export const LOGGING_FUNCTIONS = [
     "workToBeDoneForBatch",
     "makeWorkItemsFromBlocksBuffer",
     "reconcileWorkItemDone",
-    "processScanResultForWorkItem",
     "processWorkItem",
     "logBufStatus",
     "coordinatorMain",
@@ -63,6 +62,8 @@ export const LOGGING_FUNCTIONS = [
 export async function setupLoggingPath(scan_settings_path, path_prefix, role, cpu_worker_id) {
     const scanSettings = await openScanSettingsFile(scan_settings_path);
     const logs = scanSettings?.logs;
+    if (logs === "off" || typeof logs === "undefined")
+        return;
     const logs_include = scanSettings?.logs_include;
     const logs_exclude = scanSettings?.logs_exclude;
     const file_logbuffer = [];
@@ -147,7 +148,7 @@ export function log(fnname, message) {
     if (!setup)
         return;
     const { logs, logs_include, logs_exclude, file_logbuffer } = setup;
-    if (logs === "off")
+    if (logs === "off" || typeof logs === "undefined")
         return;
     // Apply include/exclude filters
     if (logs_include && logs_include.length > 0 && !logs_include.includes(fnname))

package/dist/io/sleep.d.ts

@@ -1 +1 @@
-export declare const sleep: (ms: number) => Promise<unknown>;
+export declare const sleep: (ms: number, signal?: AbortSignal) => Promise<void>;

package/dist/io/sleep.js

@@ -1 +1,16 @@
-export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export const sleep = (ms, signal) => new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+        reject(signal.reason ?? new DOMException("aborted", "AbortError"));
+        return;
+    }
+    const onAbort = () => {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+        reject(signal?.reason ?? new DOMException("aborted", "AbortError"));
+    };
+    const timer = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+});

package/dist/multisig/escrow.js

@@ -1,5 +1,4 @@
 import { ed25519, x25519 } from "@noble/curves/ed25519.js";
-import { numberToBytesLE } from "@noble/curves/utils.js";
 import { blake3 } from "@noble/hashes/blake3.js";
 import { vk_from_entropy } from "../api";
 export function makeEscrowContext(context_index) {

package/dist/scanning-syncing/backgroundWorker.d.ts

@@ -3,9 +3,10 @@ export declare const CPU_POOL_SIZE = 4;
 export type WorkerSet = {
     fetchWorker: Worker;
     cpuWorkers: Worker[];
+    shutdown: (timeoutMs?: number) => Promise<void>;
     terminate: () => void;
+    dumpHeaps: (dir?: string) => Promise<string[]>;
 };
 export declare function createWebworker(handle_result?: (result: CacheChangedCallbackParameters) => void, scan_settings_path?: string, pathPrefix?: string, handle_error?: (error: unknown) => void): Promise<WorkerSet | undefined>;
 export declare function makeWebworkerScript(): string;
-export declare function startWebworker(handle_result?: (result: unknown) => void, handle_error?: (error: unknown) => void): Worker;
 export declare function startWebworkerReady(): Promise<Worker>;

package/dist/scanning-syncing/backgroundWorker.js

@@ -1,6 +1,6 @@
 import { LOCAL_NODE_DEFAULT_URL } from "../node-interaction/nodeUrl";
 import {} from "./scanresult/scanCache";
-import { openScanSettingsFile, SCAN_SETTINGS_STORE_NAME_DEFAULT } from "../api";
+import { openScanSettingsFile, SCAN_SETTINGS_STORE_NAME_DEFAULT, sleep, } from "../api";
 import { log, setupLoggingPath } from "../io/logging";
 import { workerMainCode } from "./worker-entrypoints/worker";
 export const CPU_POOL_SIZE = 4;
@@ -8,10 +8,11 @@ export async function createWebworker(handle_result, scan_settings_path, pathPre
     try {
         const resolvedPath = scan_settings_path || SCAN_SETTINGS_STORE_NAME_DEFAULT;
         const scanSettings = await openScanSettingsFile(resolvedPath);
-        await setupLoggingPath(resolvedPath, pathPrefix ?? "", "mainthread");
+        if (scanSettings?.logs !== "off" && scanSettings?.logs)
+            await setupLoggingPath(resolvedPath, pathPrefix ?? "", "mainthread");
         const node_url = scanSettings?.node_url || LOCAL_NODE_DEFAULT_URL;
         const cpu_worker_count = typeof scanSettings?.cpu_worker_count !== "undefined"
-            ? scanSettings?.cpu_worker_count
+            ? scanSettings?.cpu_worker_count || 1
             : CPU_POOL_SIZE;
         // spawn CPU workers
         const cpuWorkers = [];
@@ -32,6 +33,7 @@ export async function createWebworker(handle_result, scan_settings_path, pathPre
             };
             cpuWorkers.push(cpuWorker);
             cpuPorts.push(channel.port2);
+            await sleep(50);
         }
         const coordinationWorker = await startWebworkerReady();
         coordinationWorker.postMessage({
@@ -39,13 +41,41 @@ export async function createWebworker(handle_result, scan_settings_path, pathPre
             scan_settings_path: resolvedPath,
             pathPrefix,
             role: "coordinator",
-            node_url,
-            start_height: 0,
-        }, cpuPorts); // transfer CPU port2s to coordination worker
+        }, cpuPorts); // transfer CPU ports to coordination worker
         log("createWebworker", [
             "coordinator worker started, node_url=" + node_url,
             ", cpuPorts=" + cpuPorts.length,
         ]);
+        let shutdownResolve;
+        let shuttingDown = false;
+        const hardTerminate = () => {
+            for (const p of cpuPorts) {
+                try {
+                    p.close();
+                }
+                catch {
+                    // port may already be closed
+                }
+            }
+            coordinationWorker.onmessage = null;
+            coordinationWorker.onerror = null;
+            for (const w of cpuWorkers) {
+                w.onerror = null;
+                w.onmessage = null;
+                try {
+                    w.terminate();
+                }
+                catch {
+                    // already dead
+                }
+            }
+            try {
+                coordinationWorker.terminate();
+            }
+            catch {
+                // already dead
+            }
+        };
         coordinationWorker.onmessage = (event) => {
             if (event.data.type === "ERROR") {
                 if (handle_error)
@@ -55,14 +85,74 @@ export async function createWebworker(handle_result, scan_settings_path, pathPre
                 if (handle_result)
                     handle_result(event.data.payload);
             }
+            else if (event.data.type === "SHUTDOWN_DONE") {
+                log("createWebworker", ["SHUTDOWN_DONE received"]);
+                shutdownResolve?.();
+                shutdownResolve = undefined;
+            }
         };
+        // wait for one HEAP_SNAPSHOT_DONE / ERROR from a worker
+        const waitHeap = (w, path, timeoutMs = 15000) => new Promise((resolve, reject) => {
+            const t = setTimeout(() => {
+                w.removeEventListener("message", onMsg);
+                reject(new Error("heap snapshot timeout: " + path));
+            }, timeoutMs);
+            const onMsg = (event) => {
+                if (event.data?.type === "HEAP_SNAPSHOT_DONE") {
+                    clearTimeout(t);
+                    w.removeEventListener("message", onMsg);
+                    resolve(event.data.path || path);
+                }
+                else if (event.data?.type === "HEAP_SNAPSHOT_ERROR") {
+                    clearTimeout(t);
+                    w.removeEventListener("message", onMsg);
+                    reject(new Error(String(event.data.error || "heap snapshot failed")));
+                }
+            };
+            w.addEventListener("message", onMsg);
+            try {
+                w.postMessage({ type: "heap_snapshot", path });
+            }
+            catch (err) {
+                clearTimeout(t);
+                w.removeEventListener("message", onMsg);
+                reject(err);
+            }
+        });
         return {
             fetchWorker: coordinationWorker,
             cpuWorkers,
+            // graceful only: abort fetch, cancel cpus, wait. does not terminate.
+            shutdown: async (timeoutMs = 5000) => {
+                if (shuttingDown)
+                    return;
+                shuttingDown = true;
+                log("createWebworker", ["shutdown start, timeoutMs=", timeoutMs]);
+                const done = new Promise((resolve) => {
+                    shutdownResolve = resolve;
+                });
+                try {
+                    coordinationWorker.postMessage({ type: "shutdown" });
+                }
+                catch (err) {
+                    log("createWebworker", ["post shutdown failed", String(err)]);
+                    return;
+                }
+                await Promise.race([done, sleep(timeoutMs)]);
+            },
             terminate: () => {
-                coordinationWorker.terminate();
-                for (const w of cpuWorkers)
-                    w.terminate();
+                hardTerminate();
+            },
+            dumpHeaps: async (dir = ".") => {
+                const stamp = Date.now();
+                const paths = [];
+                const coordPath = `${dir}/coordinator-${stamp}.heapsnapshot`;
+                paths.push(await waitHeap(coordinationWorker, coordPath));
+                for (let i = 0; i < cpuWorkers.length; i++) {
+                    const p = `${dir}/cpubound-${i}-${stamp}.heapsnapshot`;
+                    paths.push(await waitHeap(cpuWorkers[i], p));
+                }
+                return paths;
             },
         };
     }
@@ -73,36 +163,16 @@ export async function createWebworker(handle_result, scan_settings_path, pathPre
 export function makeWebworkerScript() {
     return workerMainCode;
 }
-export function startWebworker(handle_result, handle_error) {
-    const blob = new Blob([workerMainCode], {
-        type: "text/javascript",
-    });
-    const url = URL.createObjectURL(blob);
-    const worker = new Worker(url, { type: "module" });
-    worker.onmessage = (event) => {
-        switch (event.data.type) {
-            case "RESULT":
-                if (handle_result)
-                    handle_result(event.data.payload);
-                break;
-            case "ERROR":
-            case "scan_error":
-                if (handle_error)
-                    handle_error(event.data.payload ?? event.data.error);
-                break;
-            case "DEBUG":
-                log("startWebworker", ["worker debug:", event.data.payload]);
-                break;
-        }
-    };
-    return worker;
-}
+const blob = new Blob([workerMainCode], {
+    type: "text/javascript",
+});
+const url = URL.createObjectURL(blob);
 // creates a worker via startWebworker, then waits for it to signal
 // WORKER_READY (meaning self.onmessage = handleMessage has executed).
 // after that, postMessage is safe, no race between worker startup
 // and message delivery.
 export function startWebworkerReady() {
-    const worker = startWebworker();
+    const worker = new Worker(url, { type: "module" });
     return new Promise((resolve) => {
         const onReady = (e) => {
             if (e.data?.type === "WORKER_READY") {

package/dist/scanning-syncing/blocksbuffer/blocksBufferFetchLoop.js

@@ -27,6 +27,10 @@ max_blocks_buffer_size = MAX_BLOCKS_BUFFER_SIZE, anchor_range, stopSync) {
     };
     yield connection_status.last_packet;
     while (true) {
+        if (stopSync?.aborted) {
+            log("blocksBufferFetchLoop", ["aborted, exiting fetch loop"]);
+            return;
+        }
         // avoid overwriting last_packet in case of catastrophic reorg
         // this generator will block on this. coordinator should rethrow the CatastrophicReorgError
         if (connection_status.last_packet.status === "catastrophic_reorg") {
@@ -39,9 +43,17 @@ max_blocks_buffer_size = MAX_BLOCKS_BUFFER_SIZE, anchor_range, stopSync) {
                 bytes_read: 0,
                 node_url: node_url,
                 timestamp: new Date().toISOString(),
+                daemon_height: connection_status.sync.daemon_height ||
+                    connection_status.last_packet.daemon_height,
             };
             yield connection_status.last_packet;
-            await sleep(5000);
+            try {
+                await sleep(1000, stopSync);
+            }
+            catch {
+                log("blocksBufferFetchLoop", ["aborted during buffer-full sleep"]);
+                return;
+            }
             continue;
         }
         log("blocksBufferFetchLoop", [
@@ -56,11 +68,18 @@ max_blocks_buffer_size = MAX_BLOCKS_BUFFER_SIZE, anchor_range, stopSync) {
             get_blocks_bin = await doRPCrequest(nodeUrl, current_range, stopSync);
         }
         catch (error) {
+            // abort is intentional shutdown, not a connection failure
+            if (stopSync?.aborted || isAbortError(error)) {
+                log("blocksBufferFetchLoop", ["aborted during rpc request"]);
+                return;
+            }
             connection_status.last_packet = {
                 status: "connection_failed",
                 bytes_read: 0,
                 node_url,
                 timestamp: new Date().toISOString(),
+                daemon_height: connection_status.sync.daemon_height ||
+                    connection_status.last_packet.daemon_height,
             };
             yield connection_status.last_packet;
             throw error;
@@ -78,7 +97,13 @@ max_blocks_buffer_size = MAX_BLOCKS_BUFFER_SIZE, anchor_range, stopSync) {
         yield connection_status.last_packet;
         // no new blocks: at tip, sleep and retry
         if (!result_meta.block_infos.length) {
-            await sleep(1000);
+            try {
+                await sleep(1000, stopSync);
+            }
+            catch {
+                log("blocksBufferFetchLoop", ["aborted during tip sleep"]);
+                return;
+            }
             continue;
         }
         const bufferItem = makeBlocksBufferItem(result_meta, get_blocks_bin);
@@ -379,3 +404,9 @@ export async function reduceStartHeightToTip(start_height, node_url) {
 export class CatastrophicReorgError extends Error {
     name = "CatastrophicReorgError";
 }
+function isAbortError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const name = error.name;
+    return name === "AbortError" || name === "DOMException";
+}

package/dist/scanning-syncing/connectionStatus.d.ts

@@ -19,6 +19,12 @@ export type ConnectionStatus = {
     last_packet: ConnectionSatusLastPacket;
     sync: ConnectionStatusSync;
 };
+export declare function applyWalletScanProgress(cs: ConnectionStatus, progress: {
+    current_scan_height: number;
+    scanned_ranges?: CacheRange[];
+    daemon_height?: number;
+    eta?: string;
+}): void;
 export declare const DEFAULT_CONNECTION_STATUS_PREFIX = "ConnectionStatus-";
 export declare function msToHHMM(ms: number): string;
 export declare function emptyConnectionStatus(overrides?: Partial<ConnectionStatus>): ConnectionStatus;

package/dist/scanning-syncing/connectionStatus.js

@@ -1,5 +1,20 @@
 import { atomicWrite, } from "../api";
 import { SCAN_SETTINGS_STORE_NAME_DEFAULT } from "../api";
+// wallet progress write: always set scan fields; only replace eta when a new one is provided
+// so a missing eta does not wipe / flicker the previous value.
+export function applyWalletScanProgress(cs, progress) {
+    cs.sync.current_scan_height = progress.current_scan_height;
+    if (progress.scanned_ranges) {
+        cs.sync.scanned_ranges = progress.scanned_ranges;
+    }
+    if (typeof progress.daemon_height === "number") {
+        cs.sync.daemon_height = progress.daemon_height;
+    }
+    if (progress.eta !== undefined) {
+        cs.sync.eta = progress.eta;
+    }
+    cs.sync.timestamp = new Date().toISOString();
+}
 export const DEFAULT_CONNECTION_STATUS_PREFIX = "ConnectionStatus-";
 export function msToHHMM(ms) {
     const totalSeconds = Math.floor(ms / 1000);

package/dist/scanning-syncing/connectionStatusOpened.d.ts

@@ -4,12 +4,14 @@ export declare class ConnectionStatusOpened {
     private _timer;
     private _cached;
     private _prevConnected;
+    private _prevSyncKey;
     private _path;
     constructor(scan_settings_path: string, _onChange?: ((status: ConnectionStatus | null) => void) | null | undefined);
-    watch(intervalMs?: number): void;
+    watch(intervalMs?: number): Promise<void>;
     unwatch(): void;
     get connectionStatus(): ConnectionStatus | null;
     get isConnected(): boolean;
     get daemonHeight(): number | undefined;
+    private _syncKey;
     private _poll;
 }

package/dist/scanning-syncing/connectionStatusOpened.js

@@ -4,15 +4,17 @@ export class ConnectionStatusOpened {
     _timer;
     _cached = null;
     _prevConnected = false;
+    // notify when sync progress fields change, not only connect flip
+    _prevSyncKey = "";
     _path;
     constructor(scan_settings_path, _onChange) {
         this._onChange = _onChange;
         this._path = connectionStatusFilePath(scan_settings_path);
     }
-    watch(intervalMs = 2500) {
+    async watch(intervalMs = 2500) {
         if (this._timer)
             return;
-        this._poll();
+        await this._poll();
         this._timer = setInterval(() => this._poll(), intervalMs);
     }
     unwatch() {
@@ -37,14 +39,29 @@ export class ConnectionStatusOpened {
         return age >= 0 && age <= 10_000;
     }
     get daemonHeight() {
-        return this._cached?.last_packet?.daemon_height;
+        return this._cached?.sync?.daemon_height;
+    }
+    _syncKey(cs) {
+        const s = cs?.sync;
+        if (!s)
+            return "";
+        return [
+            s.daemon_height ?? "",
+            s.current_scan_height ?? "",
+            s.eta ?? "",
+            s.timestamp ?? "",
+        ].join("|");
     }
     async _poll() {
         this._cached =
             (await readConnectionStatusFile(this._path).catch(() => null)) || null;
         const now = this.isConnected;
-        if (now !== this._prevConnected) {
-            this._prevConnected = now;
+        const syncKey = this._syncKey(this._cached);
+        const connectedChanged = now !== this._prevConnected;
+        const syncChanged = syncKey !== this._prevSyncKey;
+        this._prevConnected = now;
+        this._prevSyncKey = syncKey;
+        if (connectedChanged || syncChanged) {
             this._onChange?.(this._cached);
         }
     }

package/dist/scanning-syncing/openWallet.d.ts

@@ -7,9 +7,12 @@ import { ManyScanCachesOpened, ScanCacheOpened, type ManyScanCachesOpenedCreateO
  * @param options.no_worker to feed the ManyScanCachesOpened manually with .feed(params) from CacheChangedCallbackParams
  * @param options.no_stats to disable creation of stats file with aggregated information e.g. amount per wallet / subaddress
  * @param options.notifyMasterChanged pass the output of this to another (no_worker) instance to feed
+ * @param options.logs "console" | "file" | "console-and-file" | "off"
+ * @param options.logs_include function names to include (e.g. handleCpuboundScan, blocksBufferFetchLoop)
+ * @param options.logs_exclude function names to exclude
  * @returns Promise<ManyScanCachesOpened>
  */
-export declare function openWallets(options?: ManyScanCachesOpenedCreateOptions): Promise<ManyScanCachesOpened | undefined>;
+export declare function openWallets(options?: ManyScanCachesOpenedCreateOptions): Promise<ManyScanCachesOpened>;
 /**
  * Opens a **single wallet** for scanning.
  * **Touches ScanSettings.json**,

package/dist/scanning-syncing/openWallet.js

@@ -8,6 +8,9 @@ import { openScanSettingsFile, writeWalletToScanSettings } from "../api";
  * @param options.no_worker to feed the ManyScanCachesOpened manually with .feed(params) from CacheChangedCallbackParams
  * @param options.no_stats to disable creation of stats file with aggregated information e.g. amount per wallet / subaddress
  * @param options.notifyMasterChanged pass the output of this to another (no_worker) instance to feed
+ * @param options.logs "console" | "file" | "console-and-file" | "off"
+ * @param options.logs_include function names to include (e.g. handleCpuboundScan, blocksBufferFetchLoop)
+ * @param options.logs_exclude function names to exclude
  * @returns Promise<ManyScanCachesOpened>
  */
 export async function openWallets(options) {

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

@@ -129,8 +129,10 @@ export declare class ScanCacheOpened {
         remove: () => null;
     };
     pause(): Promise<void>;
-    stopWorker(): void;
+    dumpWorkerHeaps(dir?: string): Promise<string[]>;
+    stopWorker(): Promise<void>;
     unpause(): Promise<void>;
+    private _onWorkerError;
     /**
      * selectInputs returns array of inputs, whose sum is larger than amount
      * adds approximate fee for 10kb transaction to amount if feePerByte is supplied
@@ -177,6 +179,9 @@ export type ManyScanCachesOpenedCreateOptions = {
     retryDelayMs?: number;
     connectionStatusIntervalMs?: number;
     onConnectionStatusChange?: ((status: ConnectionStatus | null) => void) | null;
+    logs?: LogSetting;
+    logs_include?: PossibleLogs[];
+    logs_exclude?: PossibleLogs[];
 };
 export declare class ManyScanCachesOpened {
     readonly connectionStatusOpened: ConnectionStatusOpened;
@@ -186,8 +191,9 @@ export declare class ManyScanCachesOpened {
     get current_height(): number | null;
     get node_url(): string;
     changeNodeUrlAndStartHeight(node_url?: string, start_height?: number | null): Promise<void>;
-    retry(): Promise<boolean>;
-    stopWorker(): void;
+    retry(): Promise<boolean | undefined>;
+    stopWorker(): Promise<void>;
+    dumpWorkerHeaps(dir?: string): Promise<string[]>;
     changeNodeUrl(node_url: string): Promise<void>;
     get merchant_confirmations(): number | null | undefined;
     get cpu_worker_count(): number | undefined;
@@ -202,10 +208,12 @@ export declare class ManyScanCachesOpened {
     setCpuWorkerCount(cpu_worker_count: number | undefined): Promise<void>;
     setLogSettings(logs?: LogSetting | null, logs_include?: PossibleLogs[] | null, logs_exclude?: PossibleLogs[] | null): Promise<void>;
     setWalletName(primary_address: string, name?: string): Promise<void>;
+    setWalletSlot(primary_address: string, slot?: number): Promise<void>;
     changeStartHeight(start_height: number | null): Promise<void>;
     private static _buildWallets;
-    static create(options: ManyScanCachesOpenedCreateOptions): Promise<ManyScanCachesOpened | undefined>;
+    static create(options: ManyScanCachesOpenedCreateOptions): Promise<ManyScanCachesOpened>;
     buildWallets(): Promise<void>;
+    private reloadWalletsAfterStop;
     addViewWallet(primary_address: string, view_key: string, fields?: {
         wallet_name?: string;
         wallet_slot?: number;