@spirobel/monero-wallet-api 0.5.5 → 0.6.1

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

@@ -1,10 +1,12 @@
-import { get_info, NodeUrl, signTransaction, ViewPair, } from "../../api";
+import { get_info, NodeUrl, signTransaction, ViewPair, } from "../../xmr3";
 import { prepareInput, sumPayments, } from "../../send-functionality/inputSelection";
 import { createWebworker } from "../backgroundWorker";
 import { spendable } from "./scanResult";
-import { getPathPrefix, readPrivateSpendKeyFromEnv, SCAN_SETTINGS_STORE_NAME_DEFAULT, SUB_ADDRESS_INDEX_DEFAULT_VALUE, walletSettingsPlusKeys, } from "../../api";
+import { getPathPrefix, readPrivateSpendKeyFromEnv, SCAN_SETTINGS_STORE_NAME_DEFAULT, SUB_ADDRESS_INDEX_DEFAULT_VALUE, walletSettingsPlusKeys, } from "../../xmr3";
 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";
@@ -389,12 +391,14 @@ 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")
@@ -419,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;
@@ -464,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,
@@ -484,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
      */
@@ -668,14 +846,17 @@ export class ScanCacheOpened {
      * for all primary addresses
      */
     async feed(params) {
-        //TODO update aggregated amount stats + height
+        // same wallet must store the new cache before a listener reads transactions
+        const sameWallet = this.view_pair.primary_address === params.newCache.primary_address;
+        if (sameWallet) {
+            this._cache = params.newCache;
+            if (!this._no_stats)
+                this._stats = await alignScanStatsWithCache(this._cache, this.view_pair, this.primary_address, getPathPrefix(this.scan_settings_path, this.pathPrefix), this.subaddress_index, lastRange(this._cache.scanned_ranges)?.end);
+        }
         if (this.masterCacheChanged)
-            this.masterCacheChanged(params);
-        if (this.view_pair.primary_address !== params.newCache.primary_address)
+            await this.masterCacheChanged(params);
+        if (!sameWallet)
             return;
-        this._cache = params.newCache;
-        if (!this._no_stats)
-            this._stats = await alignScanStatsWithCache(this._cache, this.view_pair, this.primary_address, getPathPrefix(this.scan_settings_path, this.pathPrefix), this.subaddress_index, lastRange(this._cache.scanned_ranges)?.end);
         for (const listener of this.notifyListeners) {
             if (listener)
                 listener(params);
@@ -712,13 +893,17 @@ 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)
@@ -735,14 +920,25 @@ export class ManyScanCachesOpened {
     }
     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)
+        if (this.actionLogOpened.extensionMessageBus === "ui") {
+            await sendToBackground("worker.changeNodeUrlAndStartHeight", {
+                node_url,
+                start_height,
+            }).catch(() => { });
             return;
-        const masterWallet = this.wallets[0];
-        return await masterWallet.changeNodeUrlAndStartHeight(node_url, start_height);
+        }
+        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)
@@ -751,6 +947,10 @@ export class ManyScanCachesOpened {
         return await masterWallet.retry();
     }
     async stopWorker() {
+        if (this.actionLogOpened.extensionMessageBus === "ui") {
+            await sendToBackground("worker.stopWorker", null).catch(() => { });
+            return;
+        }
         if (this.wallets.length === 0)
             return;
         const masterWallet = this.wallets[0];
@@ -764,10 +964,49 @@ export class ManyScanCachesOpened {
         return await this.wallets[0].dumpWorkerHeaps(dir);
     }
     async changeNodeUrl(node_url) {
-        if (this.wallets.length === 0)
+        if (this.actionLogOpened.extensionMessageBus === "ui") {
+            await sendToBackground("worker.setNodeUrl", { node_url }).catch(() => { });
             return;
-        const masterWallet = this.wallets[0];
-        return await masterWallet.changeNodeUrl(node_url);
+        }
+        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)
@@ -811,7 +1050,20 @@ export class ManyScanCachesOpened {
         return await this.wallets[0].setCpuWorkerCount(cpu_worker_count);
     }
     async setLogSettings(logs, logs_include, logs_exclude) {
-        return await this._scanSettings.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);
@@ -820,10 +1072,17 @@ export class ManyScanCachesOpened {
         await this._scanSettings.setWalletSlot(primary_address, slot);
     }
     async changeStartHeight(start_height) {
-        if (this.wallets.length === 0)
+        if (this.actionLogOpened.extensionMessageBus === "ui") {
+            await sendToBackground("worker.setStartHeight", {
+                start_height,
+            }).catch(() => { });
             return;
-        const masterWallet = this.wallets[0];
-        return await masterWallet.changeStartHeight(start_height);
+        }
+        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;
@@ -894,34 +1153,36 @@ export class ManyScanCachesOpened {
         // wrap workerError with auto-retry
         let retryTimer;
         let instance = null;
+        const clearRetryTimer = () => {
+            clearTimeout(retryTimer);
+            retryTimer = undefined;
+        };
         const retryFn = async () => {
+            clearRetryTimer();
             // 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;
+            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;
@@ -930,7 +1191,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 ...");
                 }
@@ -960,10 +1221,22 @@ 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() {
+        if (this.actionLogOpened.extensionMessageBus === "ui") {
+            await sendToBackground("worker.buildWallets", null).catch(() => { });
+            return;
+        }
         await this.stopWorker();
         await this.reloadWalletsAfterStop();
     }
@@ -1003,10 +1276,18 @@ export class ManyScanCachesOpened {
     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`;
+}

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

@@ -1,7 +1,7 @@
-import { type GetBlocksBinBufferItem, type BlocksBufferLoopResult, type BlocksBufferIteratorResult, type ProcessScanResult, type BlockInfo } from "../../api";
+import { type GetBlocksBinBufferItem, type BlocksBufferLoopResult, type BlocksBufferIteratorResult, type ProcessScanResult, type BlockInfo } from "../../xmr3";
 import { type ScanLoopYield } from "./scanLoop";
 import { type WorkItem } from "./scanLoop";
-import { type ScanSettings } from "../../api";
+import { type ScanSettings } from "../../xmr3";
 import { type CacheRange, type ScanCache } from "./scanCache";
 export type WalletConfig = {
     primary_address: string;
@@ -29,6 +29,7 @@ export type WorkToBeDone = {
  * @param scan_settings_path
  */
 export declare function findWorkToBeDone(scan_settings_path?: string, pathPrefix?: string): Promise<WorkToBeDone | false>;
+export declare function fastForwardFetch(wallet_configs: WalletConfigPlusCache[], start_height: number, batchEnd: number): CacheRange | null;
 export declare function workToBeDoneForBatch(cache: ScanCache, batch_meta_infos: BlockInfo[]): "skip" | {
     from: number;
 };

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

@@ -1,8 +1,8 @@
-import { setupBlocksBufferGenerator, ViewPair, handleConnectionStatusChanges, processScanResult, writeCacheToFile, sleep, findTipIndex, readWriteConnectionStatusFile, applyWalletScanProgress, } from "../../api";
+import { setupBlocksBufferGenerator, ViewPair, handleConnectionStatusChanges, processScanResult, writeCacheToFile, sleep, findTipIndex, readWriteConnectionStatusFile, applyWalletScanProgress, } from "../../xmr3";
 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";
+import { cullTooLargeScanHeight, getNonHaltedWallets, getPathPrefix, openScanSettingsFile, SCAN_SETTINGS_STORE_NAME_DEFAULT, walletSettingsPlusKeys, } from "../../xmr3";
+import { currentScanHeightFromRanges, findRange, initScanCacheFile, lastRange, makeCacheRangeForHeight, mergeRanges, } from "./scanCache";
 import { sendToCpuWorker } from "../worker-mains/cpubound-main";
 import { log } from "../../io/logging";
 /**
@@ -79,6 +79,19 @@ export async function findWorkToBeDone(scan_settings_path = SCAN_SETTINGS_STORE_
         scan_settings,
     };
 }
+// slowest wallet past this batch: return its range so fetch can restart at that tip.
+export function fastForwardFetch(wallet_configs, start_height, batchEnd) {
+    if (!wallet_configs.length)
+        return null;
+    const slowest = Math.min(...wallet_configs.map((w) => currentScanHeightFromRanges(w.cache.scanned_ranges, start_height)));
+    if (slowest <= batchEnd)
+        return null;
+    const owner = wallet_configs.find((w) => currentScanHeightFromRanges(w.cache.scanned_ranges, start_height) ===
+        slowest);
+    return owner
+        ? findRange(owner.cache.scanned_ranges, start_height)
+        : null;
+}
 export function workToBeDoneForBatch(cache, batch_meta_infos) {
     const begin_height = batch_meta_infos[0].block_height;
     const end_height = batch_meta_infos[batch_meta_infos.length - 1].block_height;
@@ -278,6 +291,12 @@ export async function setupCoordinator(scanSettingsPath, pathPrefix, stopSync) {
     const work_to_be_done = await findWorkToBeDone(scanSettingsPath, pathPrefix);
     if (!work_to_be_done)
         return false;
+    // bring connection status file scan height in line with / cache file / in memory state 
+    await readWriteConnectionStatusFile((cs) => {
+        applyWalletScanProgress(cs, {
+            current_scan_height: currentScanHeightFromRanges(work_to_be_done.wallet_configs[0]?.cache.scanned_ranges ?? [], work_to_be_done.scan_settings.start_height || 0),
+        });
+    }, scanSettingsPath);
     const { generator: blocksGenerator, blocksBuffer } = await setupBlocksBufferGenerator({
         nodeUrl: work_to_be_done.scan_settings.node_url,
         startHeight: work_to_be_done.start_height,
@@ -345,9 +364,10 @@ export async function* coordinatorMainMultithreaded(scanSettingsPath, pathPrefix
     if (!ctx)
         throw new Error("[coordinatorMain Multithreaded] findWorkToBeDone returned false");
     const work_to_be_done = ctx.work_to_be_done;
-    const blocksBuffer = ctx.blocksBuffer;
+    let blocksBuffer = ctx.blocksBuffer;
     const workBuffer = ctx.workBuffer;
-    const blocksGenerator = ctx.blocksGenerator;
+    let blocksGenerator = ctx.blocksGenerator;
+    let fetchAt = work_to_be_done.start_height;
     let totalBlocksScanned = 0;
     let scanStartTime = Date.now();
     let blocksPromise = blocksGenerator.next();
@@ -428,12 +448,28 @@ export async function* coordinatorMainMultithreaded(scanSettingsPath, pathPrefix
             const blockCount = to_be_processed.to - to_be_processed.from + 1;
             totalBlocksScanned += blockCount;
             const res = await processWorkItem(to_be_processed, workBuffer, blocksBuffer, getPathPrefix(scanSettingsPath, pathPrefix), wallet.secret_spend_key);
+            const jumped = fastForwardFetch(work_to_be_done.wallet_configs, work_to_be_done.scan_settings.start_height || 0, to_be_processed.batch.get_blocks_result_meta.block_infos[to_be_processed.to].block_height);
+            if (jumped && jumped.end > fetchAt) {
+                log("coordinatorMainMultithreaded", ["jump", fetchAt, "->", jumped.end]);
+                await blocksGenerator.return(undefined);
+                const next = await setupBlocksBufferGenerator({
+                    nodeUrl: work_to_be_done.scan_settings.node_url,
+                    startHeight: jumped.end,
+                    anchor_range: jumped,
+                    scanSettingsPath,
+                    stopSync,
+                });
+                blocksBuffer = next.blocksBuffer;
+                blocksGenerator = next.generator;
+                blocksPromise = blocksGenerator.next();
+                fetchAt = jumped.end;
+            }
             // 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,
+                    current_scan_height: currentScanHeightFromRanges(wallet.cache.scanned_ranges, work_to_be_done.scan_settings.start_height || 0),
                     scanned_ranges: wallet.cache.scanned_ranges,
                     daemon_height: wallet.cache.daemon_height,
                     eta,

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

@@ -1,4 +1,4 @@
-import { type GetBlocksBinBufferItem, type ScanResult, type WalletConfig, type WalletConfigPlusCache } from "../../api";
+import { type GetBlocksBinBufferItem, type ScanResult, type WalletConfig, type WalletConfigPlusCache } from "../../xmr3";
 export type WorkItem = {
     walletConfig: WalletConfigPlusCache;
     batch: GetBlocksBinBufferItem;

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

@@ -1,4 +1,4 @@
-import { sleep, ViewPair, } from "../../api";
+import { sleep, ViewPair, } from "../../xmr3";
 export function makeWorkItem(walletConfig, batch, from, to) {
     if (to && to > batch.get_blocks_result_meta.block_infos.length - 1) {
         // we could throw here but we dont. Off by one errors shouldnt break the application

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

@@ -1,4 +1,4 @@
-import { type BlockInfo, type Output } from "../../api";
+import { type BlockInfo, type Output } from "../../xmr3";
 import { type KeyImage } from "./computeKeyImage";
 import { type ErrorResponse } from "../../node-interaction/binaryEndpoints";
 import type { CacheChangedCallback, CacheRange, ChangedOutput, ScanCache } from "./scanCache";