@spirobel/monero-wallet-api 0.5.3 → 0.5.4

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/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

@@ -7,5 +7,4 @@ export type WorkerSet = {
 };
 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,9 +41,7 @@ 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,
@@ -60,9 +60,17 @@ export async function createWebworker(handle_result, scan_settings_path, pathPre
             fetchWorker: coordinationWorker,
             cpuWorkers,
             terminate: () => {
-                coordinationWorker.terminate();
-                for (const w of cpuWorkers)
+                for (const p of cpuPorts) {
+                    p.close();
+                }
+                coordinationWorker.onmessage = null;
+                coordinationWorker.onerror = null;
+                for (const w of cpuWorkers) {
+                    w.onerror = null;
+                    w.onmessage = null;
                     w.terminate();
+                }
+                coordinationWorker.terminate();
             },
         };
     }
@@ -73,36 +81,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/connectionStatusOpened.d.ts

@@ -6,7 +6,7 @@ export declare class ConnectionStatusOpened {
     private _prevConnected;
     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;

package/dist/scanning-syncing/connectionStatusOpened.js

@@ -9,10 +9,10 @@ export class ConnectionStatusOpened {
         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() {

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

@@ -131,6 +131,7 @@ export declare class ScanCacheOpened {
     pause(): Promise<void>;
     stopWorker(): 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
@@ -202,6 +203,7 @@ 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>;

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

@@ -1,4 +1,4 @@
-import { NodeUrl, signTransaction, ViewPair, } from "../../api";
+import { get_info, NodeUrl, signTransaction, ViewPair, } from "../../api";
 import { prepareInput, sumPayments, } from "../../send-functionality/inputSelection";
 import { createWebworker } from "../backgroundWorker";
 import { spendable } from "./scanResult";
@@ -92,10 +92,7 @@ export class ScanCacheOpened {
         return this._stats.height;
     }
     async changeStartHeight(start_height) {
-        if (this.worker) {
-            this.worker.terminate();
-            delete this.worker;
-        }
+        this.stopWorker();
         await this._scanSettings.setStartHeight(start_height);
         this._start_height = start_height;
         await this.unpause();
@@ -170,10 +167,7 @@ export class ScanCacheOpened {
         return this._scanSettings.logs_exclude;
     }
     async changeNodeUrlAndStartHeight(node_url, start_height) {
-        if (this.worker) {
-            this.worker.terminate();
-            delete this.worker;
-        }
+        this.stopWorker();
         if (node_url !== undefined) {
             await this._scanSettings.setNodeUrl(node_url);
             this.node_url = node_url;
@@ -185,18 +179,13 @@ export class ScanCacheOpened {
         await this.unpause();
     }
     async changeNodeUrl(node_url) {
-        if (this.worker) {
-            this.worker.terminate();
-            delete this.worker;
-        }
+        this.stopWorker();
         await this._scanSettings.setNodeUrl(node_url);
         this.node_url = node_url;
         await this.unpause();
     }
     async setMerchantConfirmations(merchant_confirmations) {
-        this.stopWorker();
         await this._scanSettings.setMerchantConfirmations(merchant_confirmations);
-        await this.unpause();
     }
     async setCpuWorkerCount(cpu_worker_count) {
         this.stopWorker();
@@ -204,7 +193,7 @@ export class ScanCacheOpened {
         await this.unpause();
     }
     async setLogSettings(logs, logs_include, logs_exclude) {
-        this.stopWorker();
+        await this.stopWorker();
         await this._scanSettings.setLogSettings(logs, logs_include, logs_exclude);
         await this.unpause();
     }
@@ -212,10 +201,7 @@ export class ScanCacheOpened {
         await this._scanSettings.setWalletName(this.view_pair.primary_address, name);
     }
     async retry() {
-        if (this.worker) {
-            this.worker.terminate();
-            delete this.worker;
-        }
+        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);
@@ -247,7 +233,7 @@ export class ScanCacheOpened {
         const feeFor10kb = feePerByte * 10000n;
         //2. check if fee is too high
         if (feeFor10kb > max_plausible_fee) {
-            throw new Error(`fee too high: 
+            throw new Error(`fee too high:
           ${feeFor10kb} (fee for 10kb tx size) > ${max_plausible_fee} (0.001 XMR)
           most likely your node is faulty. connect to another node.
            preferably run one yourself locally.`);
@@ -266,7 +252,7 @@ export class ScanCacheOpened {
             const feeFor10kb = feePerByte * 10000n;
             //2. check if fee is too high
             if (feeFor10kb > max_plausible_fee) {
-                throw new Error(`fee too high: 
+                throw new Error(`fee too high:
           ${feeFor10kb} (fee for 10kb tx size) > ${max_plausible_fee} (0.001 XMR)
           most likely your node is faulty. connect to another node.
            preferably run one yourself locally.`);
@@ -410,10 +396,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
-            if (this.worker) {
-                this.worker.terminate();
-                delete this.worker;
-            }
+            this.stopWorker();
             // write txlog to cache + update pending_spent_utxos (affects stats + spendability)
             await writeCacheFileDefaultLocationThrows({
                 primary_address: this.primary_address,
@@ -457,10 +440,7 @@ export class ScanCacheOpened {
         }
         catch (e) {
             // before writing the scan cache, we stop the worker to avoid a race
-            if (this.worker) {
-                this.worker.terminate();
-                delete this.worker;
-            }
+            this.stopWorker();
             // write txlog error to cache
             await writeCacheFileDefaultLocationThrows({
                 primary_address: this.primary_address,
@@ -570,43 +550,45 @@ export class ScanCacheOpened {
         };
     }
     async pause() {
-        if (this.worker)
-            this.worker.terminate();
+        this.stopWorker();
         return await this._scanSettings.haltWallet(this.view_pair.primary_address);
     }
     stopWorker() {
         if (this.worker) {
             this.worker.terminate();
+            this.worker.cpuWorkers = [];
+            this.worker.fetchWorker = undefined;
             delete this.worker;
         }
     }
     async unpause() {
         // if worker does not exist yet, start it (if we are not slave / no_worker)
         if (!this.worker && !this.no_worker) {
-            this.worker = await createWebworker(async (params) => await this.feed(params), this.scan_settings_path, this.pathPrefix, (error) => {
-                const workerErrCB = this.workerError;
-                this.stopWorker();
-                readWriteConnectionStatusFile((cs) => {
-                    if (cs?.last_packet.status === "catastrophic_reorg")
-                        return;
-                    const connectionStatus = {
-                        ...cs,
-                        last_packet: {
-                            status: "connection_failed",
-                            bytes_read: 0,
-                            node_url: this.node_url,
-                            timestamp: new Date().toISOString(),
-                        },
-                    };
-                    return connectionStatus;
-                }, this.scan_settings_path).then(() => {
-                    if (workerErrCB)
-                        workerErrCB(error);
-                });
-            });
+            this.worker = await createWebworker(async (params) => await this.feed(params), this.scan_settings_path, this.pathPrefix, (params) => this._onWorkerError(params));
         }
         return await this._scanSettings.unhaltWallet(this.view_pair.primary_address);
     }
+    _onWorkerError = (error) => {
+        const workerErrCB = this.workerError;
+        this.stopWorker();
+        readWriteConnectionStatusFile((cs) => {
+            if (cs?.last_packet.status === "catastrophic_reorg")
+                return;
+            const connectionStatus = {
+                ...cs,
+                last_packet: {
+                    status: "connection_failed",
+                    bytes_read: 0,
+                    node_url: this.node_url,
+                    timestamp: new Date().toISOString(),
+                },
+            };
+            return connectionStatus;
+        }, this.scan_settings_path).then(() => {
+            if (workerErrCB)
+                workerErrCB(error);
+        });
+    };
     /**
      * selectInputs returns array of inputs, whose sum is larger than amount
      * adds approximate fee for 10kb transaction to amount if feePerByte is supplied
@@ -804,6 +786,9 @@ export class ManyScanCachesOpened {
     async setWalletName(primary_address, name) {
         await this._scanSettings.setWalletName(primary_address, name);
     }
+    async setWalletSlot(primary_address, slot) {
+        await this._scanSettings.setWalletSlot(primary_address, slot);
+    }
     async changeStartHeight(start_height) {
         if (this.wallets.length === 0)
             throw new Error("no wallets");
@@ -872,31 +857,66 @@ export class ManyScanCachesOpened {
         // wrap workerError with auto-retry
         let retryTimer;
         let instance = null;
+        const retryFn = async () => {
+            await instance?.buildWallets();
+            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)
+                .then((r) => {
+                r?.status === "OK";
+            })
+                .catch(() => false);
+            if (getinfo_result)
+                await instance?.retry();
+            clearTimeout(retryTimer);
+            retryTimer = undefined;
+        };
         const newOptions = { ...options };
+        let connectionFailedShown = false;
         if (autoRetry) {
             const originalError = options.workerError;
             newOptions.workerError = (err) => {
                 originalError?.(err);
+                const msg = err instanceof Error ? err.message : String(err);
+                if (csOpened.connectionStatus?.last_packet?.status ===
+                    "catastrophic_reorg") {
+                    clearTimeout(retryTimer);
+                    instance?.stopWorker();
+                    throw new Error("catastrophic reorg, aborting ...");
+                }
+                if (msg.includes("connect") ||
+                    msg.includes("fetch") ||
+                    msg.includes("NetworkError")) {
+                    if (!connectionFailedShown) {
+                        connectionFailedShown = true;
+                        console.error("unable to connect to node ... retrying ...");
+                    }
+                }
                 if (!retryTimer) {
-                    retryTimer = setTimeout(() => {
-                        retryTimer = undefined;
-                        instance?.retry();
-                    }, retryDelayMs ?? 1000);
+                    retryTimer = setTimeout(retryFn, retryDelayMs ?? 5000);
                 }
             };
         }
         const wallets = await this._buildWallets(scanSettingsOpened, newOptions);
         if (!wallets)
             return undefined;
-        const csOpened = new ConnectionStatusOpened(scan_settings_path || SCAN_SETTINGS_STORE_NAME_DEFAULT, onConnectionStatusChange ?? null);
+        const csOpened = new ConnectionStatusOpened(scan_settings_path || SCAN_SETTINGS_STORE_NAME_DEFAULT, autoRetry
+            ? (status) => {
+                if (status?.last_packet?.status === "OK" && connectionFailedShown) {
+                    connectionFailedShown = false;
+                    console.log("connection to node established");
+                }
+                if (onConnectionStatusChange)
+                    onConnectionStatusChange(status);
+            }
+            : (onConnectionStatusChange ?? null));
         csOpened.watch(connectionStatusIntervalMs);
         instance = new ManyScanCachesOpened(wallets, csOpened, scanSettingsOpened, newOptions);
         return instance;
     }
     async buildWallets() {
-        for (const w of this._wallets) {
-            w.stopWorker();
-        }
+        this.stopWorker();
         await this._scanSettings.reload();
         const newWallets = await ManyScanCachesOpened._buildWallets(this._scanSettings, this._options);
         if (!newWallets)

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

@@ -45,26 +45,12 @@ export declare function makeWorkItemsForAllWallets(wallet_configs: WalletConfigP
  * blocks buffer if no remaining work items reference it.
  */
 export declare function reconcileWorkItemDone(blocksBuffer: GetBlocksBinBufferItem[], workItemBuffer: WorkItem[]): void;
-/**
- * one round of the select race. takes two primed promises (blocks, scan),
- * races them, returns winner info. the loser stays in flight.
- */
-export declare function raceStep(blocksPromise: Promise<IteratorResult<BlocksBufferLoopResult>>, scanPromise: Promise<IteratorResult<ScanLoopYield, void>>): Promise<{
-    src: "blocks" | "scan";
-    value: IteratorResult<BlocksBufferLoopResult> | IteratorResult<ScanLoopYield, void>;
-    done: boolean;
-}>;
 /**
  * handle a yield from the blocks buffer fetch loop.
  */
 export declare function handleBlocksYield(value: BlocksBufferLoopResult, scanSettingsPath?: string): Promise<{
     isBlocksBufferChanged: boolean;
 }>;
-/**
- * process a scan result for a completed work item.
- * updates the cache, writes to disk, marks work item done, reconciles.
- */
-export declare function processScanResultForWorkItem(value: ScanLoopYield, workBuffer: WorkItem[], blocksBuffer: GetBlocksBinBufferItem[], pathPrefix: string, secret_spend_key?: string): Promise<void>;
 /**
  * process a scan result for a completed work item.
  * updates the cache, writes to disk, marks work item done, reconciles blockbuffer with this.
@@ -90,14 +76,6 @@ export type CoordinatorEvent = {
     type: "error";
     error: Error;
 };
-/**
- * coordinator main: async generator that drives the full scan cycle.
- * takes only scanSettingsPath, derives everything else internally.
- * yields events for some of the underlying generator events,
- * look at CoordinatorEvent, processing not decoupled from cpu bound scan work,
- * as this single threaded, there is no point
- */
-export declare function coordinatorMain(scanSettingsPath?: string, pathPrefix?: string): AsyncGenerator<CoordinatorEvent>;
 export declare function setupCoordinator(scanSettingsPath?: string, pathPrefix?: string): Promise<false | {
     blocksGenerator: AsyncGenerator<BlocksBufferLoopResult, any, any>;
     workBuffer: WorkItem[];