@spirobel/monero-wallet-api 0.3.16 → 0.4.0

package/dist/scanning-syncing/connectionStatus.js

@@ -1,10 +1,72 @@
-import { atomicWrite } from "../api";
+import { atomicWrite, } from "../api";
 import { SCAN_SETTINGS_STORE_NAME_DEFAULT } from "./scanSettings";
 export const DEFAULT_CONNECTION_STATUS_PREFIX = "ConnectionStatus-";
-export function connectionStatusFilePath(scan_settings_path) {
-    if (!scan_settings_path)
-        scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT;
-    return `${DEFAULT_CONNECTION_STATUS_PREFIX}${scan_settings_path}`;
+export function msToHHMM(ms) {
+    const totalSeconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(totalSeconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    if (!Number.isFinite(hours) || !Number.isFinite(minutes)) {
+        return "00:00";
+    }
+    const paddedHours = String(hours).padStart(2, "0");
+    const paddedMinutes = String(remainingMinutes).padStart(2, "0");
+    return `${paddedHours}:${paddedMinutes}`;
+}
+export function emptyConnectionStatus(overrides) {
+    const defaultStatus = {
+        last_packet: {
+            status: "no_connection_yet",
+            bytes_read: 0,
+            node_url: "",
+            timestamp: new Date().toISOString(),
+        },
+        sync: {
+            scanned_ranges: [],
+            daemon_height: 0,
+            current_scan_height: 0,
+            eta: "00:00",
+            timestamp: new Date().toISOString(),
+        },
+    };
+    return overrides ? { ...defaultStatus, ...overrides } : defaultStatus;
+}
+export async function updateSyncETA(daemon_height, current_scan_height, last_height, last_timestamp, scan_settings_path) {
+    const blocks_till_tip = daemon_height - current_scan_height;
+    let blocks_since_last_update = null;
+    let duration = null;
+    if (typeof last_height === "number") {
+        blocks_since_last_update = current_scan_height - last_height;
+    }
+    if (typeof last_timestamp === "number") {
+        duration = Date.now() - last_timestamp;
+    }
+    let eta = "00:00";
+    if (blocks_since_last_update !== null &&
+        duration !== null &&
+        duration > 0 &&
+        blocks_till_tip > 0) {
+        const blocks_per_ms = blocks_since_last_update / duration;
+        const eta_ms = blocks_till_tip / blocks_per_ms;
+        eta = msToHHMM(eta_ms);
+    }
+    await readWriteConnectionStatusFile((cs) => {
+        cs.sync = {
+            ...cs.sync,
+            daemon_height,
+            current_scan_height,
+            eta,
+            timestamp: new Date().toISOString(),
+        };
+    }, scan_settings_path);
+    return { last_height: current_scan_height, last_timestamp: Date.now() };
+}
+export function connectionStatusFilePath(scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    const parts = scan_settings_path.split("/");
+    const basename = parts.pop();
+    const dir = parts.join("/");
+    const prefix = dir ? `${dir}/` : "";
+    return `${prefix}${DEFAULT_CONNECTION_STATUS_PREFIX}${basename}`;
 }
 export async function readConnectionStatusDefaultLocation(scan_settings_path) {
     return await readConnectionStatusFile(connectionStatusFilePath(scan_settings_path));
@@ -15,21 +77,29 @@ export async function readConnectionStatusFile(connectionStatusFilePath) {
         .catch(() => undefined);
     return jsonString ? JSON.parse(jsonString) : undefined;
 }
-export async function writeConnectionStatusFile(status, node_url, bytes_read = 0, scan_settings_path) {
-    const connectionStatus = {
-        last_packet: {
-            status,
-            bytes_read,
-            node_url,
-            timestamp: new Date().toISOString(),
-        },
-    };
+export async function writeConnectionStatusFile(connectionStatus, scan_settings_path) {
     return await atomicWrite(connectionStatusFilePath(scan_settings_path), JSON.stringify(connectionStatus, null, 2));
 }
 export async function readWriteConnectionStatusFile(writeCB, scan_settings_path) {
-    const connectionStatus = await readConnectionStatusDefaultLocation(scan_settings_path);
-    const cb = await writeCB(connectionStatus);
-    if (typeof cb === "undefined")
-        return;
-    return await writeConnectionStatusFile(cb.last_packet.status, cb.last_packet.node_url, cb.last_packet.bytes_read, scan_settings_path);
+    let connectionStatus = await readConnectionStatusDefaultLocation(scan_settings_path);
+    if (!connectionStatus)
+        connectionStatus = emptyConnectionStatus();
+    await writeCB(connectionStatus);
+    await writeConnectionStatusFile(connectionStatus, scan_settings_path);
+    return connectionStatus;
+}
+/**
+ * read the connection status from disk (typical /path/to/ConnectionStatus-ScanSettings.json)
+ * and persist empty inital status if not found
+ * @param scan_settings_path  path to the scan settings file /path/to/ScanSettings.json
+ * @returns connection status or empty initalized connection status
+ */
+export async function readOrInitConnectionStatus(scan_settings_path) {
+    const cs = await readConnectionStatusFile(connectionStatusFilePath(scan_settings_path));
+    if (typeof cs === "undefined") {
+        const emptyInitial = emptyConnectionStatus();
+        await writeConnectionStatusFile(emptyInitial, scan_settings_path);
+        return emptyInitial;
+    }
+    return cs;
 }

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

@@ -34,11 +34,15 @@ export type ScanSettings = {
     wallets: ScanSetting[];
     node_url: string;
     start_height: number | null;
+    merchant_confirmations?: number | null;
+    cpu_worker_count?: number;
 };
 export type ScanSettingsOpened = {
     wallets: (ScanSettingOpened | undefined)[];
     node_url: string;
     start_height: number | null;
+    merchant_confirmations?: number | null;
+    cpu_worker_count?: number;
 };
 /**
  * Writes scan settings to the default or specified storage file in json.
@@ -71,6 +75,38 @@ export declare function writeDaemonHeightAsStartHeightToScanSettings(node_url: s
 export declare function cullTooLargeScanHeight(node_url: string, settingsStorePath?: string): Promise<number>;
 export declare function writeNodeUrlToScanSettings(node_url: string, settingsStorePath?: string): Promise<number>;
 export declare function readNodeUrlFromScanSettings(settingsStorePath?: string): Promise<string | undefined>;
+/**
+ * Writes the merchant confirmation threshold to scan settings.
+ *
+ * This setting only has effect when the wallet is run as part of a checkout system,
+ * that accepts payments.
+ * It determines after how many confirmations a transaction is accepted
+ * for a payment. The actual enforcement of this policy is left to the
+ * custom payment-system code that consumes this library.
+ *
+ * @param merchant_confirmations - Number of confirmations required before
+ *   accepting a payment, or `null` to leave it unset.
+ * @param settingsStorePath - Optional path for the settings file.
+ *   Defaults to `SCAN_SETTINGS_STORE_NAME_DEFAULT`.
+ * @returns A promise that resolves when the file is successfully written.
+ */
+export declare function writeMerchantConfirmationsToScanSettings(merchant_confirmations: number | null, settingsStorePath?: string): Promise<number>;
+/**
+ * Reads the merchant confirmation threshold from scan settings.
+ *
+ * This setting only has effect when the wallet is run as part of a checkout system,
+ * that accepts payments.
+ *
+ * It determines after how many confirmations a transaction is accepted
+ * for a payment. The actual enforcement of this policy is left to the
+ * custom payment-system code that consumes this library.
+ *
+ * @param settingsStorePath - Optional path for the settings file.
+ *   Defaults to `SCAN_SETTINGS_STORE_NAME_DEFAULT`.
+ * @returns The configured number of confirmations, null, or `undefined`
+ *   if the setting has not been persisted yet.
+ */
+export declare function readMerchantConfirmationsFromScanSettings(settingsStorePath?: string): Promise<number | null | undefined>;
 /**
  * Reads scan settings from the default or specified storage file.
  * secret_view_key and spend_private_key are read from environment variables
@@ -106,4 +142,13 @@ export declare function walletSettingsPlusKeys(wallet_settings: ScanSettingOpene
 export declare function writeWalletToScanSettings(params: WriteScanSettingParams): Promise<number>;
 export declare function openScanSettingsFile(scan_settings_path?: string): Promise<ScanSettings | undefined>;
 export declare function openNonHaltedWallets(scan_settings_path?: string): Promise<ScanSettingOpened[]>;
+export declare function getNonHaltedWallets(scan_settings?: ScanSettings): ScanSetting[];
 export declare function doesScanSettingsFileExist(scan_settings_path?: string): Promise<boolean>;
+/**
+ * Either 1. the consumer explicitly sets a pathprefix, we extract it from the scan_settings_path
+ * or we pick the default which is nothing
+ * @param scan_settings_path optional scan settings path
+ * @param pathPrefix optional path prefix
+ * @returns definite path prefix
+ */
+export declare function getPathPrefix(scan_settings_path?: string, pathPrefix?: string): string;

package/dist/scanning-syncing/scanSettings.js

@@ -87,6 +87,49 @@ export async function readNodeUrlFromScanSettings(settingsStorePath = SCAN_SETTI
     const scanSettings = await openScanSettingsFile(settingsStorePath);
     return scanSettings?.node_url;
 }
+/**
+ * Writes the merchant confirmation threshold to scan settings.
+ *
+ * This setting only has effect when the wallet is run as part of a checkout system,
+ * that accepts payments.
+ * It determines after how many confirmations a transaction is accepted
+ * for a payment. The actual enforcement of this policy is left to the
+ * custom payment-system code that consumes this library.
+ *
+ * @param merchant_confirmations - Number of confirmations required before
+ *   accepting a payment, or `null` to leave it unset.
+ * @param settingsStorePath - Optional path for the settings file.
+ *   Defaults to `SCAN_SETTINGS_STORE_NAME_DEFAULT`.
+ * @returns A promise that resolves when the file is successfully written.
+ */
+export async function writeMerchantConfirmationsToScanSettings(merchant_confirmations, settingsStorePath = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    const scanSettings = (await openScanSettingsFile(settingsStorePath)) || {
+        node_url: LOCAL_NODE_DEFAULT_URL,
+        wallets: [],
+        start_height: null,
+    };
+    scanSettings.merchant_confirmations = merchant_confirmations;
+    return await atomicWrite(settingsStorePath, JSON.stringify(scanSettings, null, 2));
+}
+/**
+ * Reads the merchant confirmation threshold from scan settings.
+ *
+ * This setting only has effect when the wallet is run as part of a checkout system,
+ * that accepts payments.
+ *
+ * It determines after how many confirmations a transaction is accepted
+ * for a payment. The actual enforcement of this policy is left to the
+ * custom payment-system code that consumes this library.
+ *
+ * @param settingsStorePath - Optional path for the settings file.
+ *   Defaults to `SCAN_SETTINGS_STORE_NAME_DEFAULT`.
+ * @returns The configured number of confirmations, null, or `undefined`
+ *   if the setting has not been persisted yet.
+ */
+export async function readMerchantConfirmationsFromScanSettings(settingsStorePath = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    const scanSettings = await openScanSettingsFile(settingsStorePath);
+    return scanSettings?.merchant_confirmations;
+}
 /**
  * Reads scan settings from the default or specified storage file.
  * secret_view_key and spend_private_key are read from environment variables
@@ -247,6 +290,12 @@ export async function openNonHaltedWallets(scan_settings_path = SCAN_SETTINGS_ST
         throw new Error("no non halted wallets in scan settings");
     return nonHaltedWallets;
 }
+export function getNonHaltedWallets(scan_settings) {
+    if (!scan_settings)
+        return [];
+    const nonHaltedWallets = scan_settings.wallets.filter((wallet) => !wallet?.halted);
+    return nonHaltedWallets;
+}
 export async function doesScanSettingsFileExist(scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
     const scan_settings_file_content = await Bun.file(scan_settings_path)
         .text()
@@ -258,3 +307,17 @@ export async function doesScanSettingsFileExist(scan_settings_path = SCAN_SETTIN
         return false;
     }
 }
+/**
+ * Either 1. the consumer explicitly sets a pathprefix, we extract it from the scan_settings_path
+ * or we pick the default which is nothing
+ * @param scan_settings_path optional scan settings path
+ * @param pathPrefix optional path prefix
+ * @returns definite path prefix
+ */
+export function getPathPrefix(scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT, pathPrefix) {
+    const parts = scan_settings_path.split("/");
+    const basename = parts.pop();
+    const dir = parts.join("/");
+    const prefix = dir ? `${dir}/` : "";
+    return pathPrefix ?? prefix;
+}

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

@@ -1,14 +1,3 @@
-import type { BlockInfo, Output } from "../../api";
-import type { KeyImage } from "./computeKeyImage";
 import { type ScanResult } from "./scanResult";
 import type { CacheRange, ChangedOutput, ScanCache } from "./scanCache";
-export type ReorgInfo = {
-    split_height: BlockInfo;
-    removed_outputs: ReorgedOutput[];
-    reverted_spends: ReorgedOutput[];
-};
-export type ReorgedOutput = {
-    old_output_state: Output;
-    key_image: KeyImage;
-};
 export declare function handleReorg(current_range: CacheRange, result: ScanResult, cache: ScanCache, oldRange: CacheRange): [CacheRange, ChangedOutput[]];

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

@@ -1,25 +1,48 @@
 import { makeNewRange } from "./scanResult";
 export function handleReorg(current_range, result, cache, oldRange) {
     let changed_outputs = [];
+    console.log("[handleReorg] oldRange hashes:", oldRange.block_hashes.map((h) => h.block_height + ":" + h.block_hash.slice(0, 8)));
+    console.log("[handleReorg] cache outputs:", Object.entries(cache.outputs).map(([id, o]) => "h=" + o.block_height + " spent=" + (o.spent_block_height ?? "no")));
+    console.log("[handleReorg] result infos:", result.block_infos.length +
+        " blocks, first=" +
+        result.block_infos[0]?.block_height, "last=" + result.block_infos.at(-1)?.block_height);
     // we need to check where anchor candidate is and if not found, try the same for anchor
     // if else throw on catastrophic reorg
     for (const block_hash of oldRange.block_hashes) {
         const split_height_index = result.block_infos.findIndex((b) => b.block_hash === block_hash.block_hash);
+        if (!(split_height_index > 0))
+            continue;
+        console.log("[handleReorg] trying hash", block_hash.block_height, block_hash.block_hash.slice(0, 8), "found at idx", split_height_index);
         const split_height = result.block_infos[split_height_index];
         // still a chance to find the split height, (could be candidate_anchor or anchor)
         if (!split_height)
             continue;
         // we found the split height & do the reorg
-        const reorg_info = {
-            split_height,
-            removed_outputs: [],
-            reverted_spends: [],
-        };
+        console.log("[handleReorg] SPLIT FOUND at height", split_height.block_height);
+        if (!cache.reorg_info) {
+            cache.reorg_info = {
+                split_heights: [split_height],
+                removed_outputs: [],
+                reverted_spends: [],
+            };
+        }
+        else {
+            cache.reorg_info.split_heights.push(split_height);
+        }
+        // First, collect reverted spends from all outputs (before any removals)
+        // so that outputs with block_height < split_height but spent_block_height >= split_height are captured
+        const reverted_outputs = Object.entries(cache.outputs).filter(([id, output]) => output.spent_block_height !== undefined &&
+            output.spent_block_height >= split_height.block_height);
         const removed_outputs = Object.entries(cache.outputs).filter(([id, output]) => output.block_height >= split_height.block_height);
+        console.log("[handleReorg] removed_outputs count:", removed_outputs.length, "reverted count:", reverted_outputs.length);
         for (const [id, old_output_state] of removed_outputs) {
             // 1. find key_image of output to be removed (as it was reorged)
             const [key_image] = Object.entries(cache.own_key_images).find(([own_key_image, globalid]) => globalid === id) || [""]; // if this is viewonly the key_image will be empty
-            reorg_info.removed_outputs.push({ old_output_state, key_image });
+            cache.reorg_info.removed_outputs.push({
+                old_output_state,
+                key_image,
+                split_height,
+            });
             // 2. remove from outputs and own_key_images
             delete cache.outputs[id];
             delete cache.own_key_images[key_image];
@@ -28,21 +51,22 @@ export function handleReorg(current_range, result, cache, oldRange) {
                 change_reason: "reorged",
             });
         }
-        //for reverted spents, just do the same again with spent_height
-        const reverted_outputs = Object.entries(cache.outputs).filter(([id, output]) => output.spent_block_height !== undefined &&
-            output.spent_block_height >= split_height.block_height);
         for (const [id, old_output_state_pointer] of reverted_outputs) {
             const [key_image] = Object.entries(cache.own_key_images).find(([own_key_image, globalid]) => globalid === id) || [""]; // if this is viewonly the key_image will be empty
             const old_output_state = Object.assign({}, old_output_state_pointer);
-            reorg_info.reverted_spends.push({
+            cache.reorg_info.reverted_spends.push({
                 old_output_state,
                 key_image, // in this case key_image only used here, does not get removed
+                split_height,
             });
-            // remove spend info from original cache
-            delete cache.outputs[id].spent_relative_index;
-            delete cache.outputs[id].spent_in_tx_hash;
-            delete cache.outputs[id].spent_block_height;
-            delete cache.outputs[id].spent_block_timestamp;
+            // remove spend info from original cache (if output still exists
+            // it may have been deleted above in the removed_outputs loop)
+            if (cache.outputs[id]) {
+                delete cache.outputs[id].spent_relative_index;
+                delete cache.outputs[id].spent_in_tx_hash;
+                delete cache.outputs[id].spent_block_height;
+                delete cache.outputs[id].spent_block_timestamp;
+            }
             changed_outputs.push({
                 output: old_output_state,
                 change_reason: "reorged_spent",
@@ -51,7 +75,6 @@ export function handleReorg(current_range, result, cache, oldRange) {
         // find current range in scanned ranges and change its end value + latest_block_hash
         oldRange.end = split_height.block_height;
         oldRange.block_hashes[0] = split_height;
-        cache.reorg_info = reorg_info;
         // fix current_range
         let anchor = result.block_infos.slice(-100)[0]; // if we got lots of new blocks
         const old_anchor = oldRange.block_hashes.at(-1);

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

@@ -1,8 +1,10 @@
 import { type KeyImage } from "./computeKeyImage";
-import type { ReorgInfo } from "./reorg";
-import type { BlockInfo, FeeEstimateResponse, GetBlockHeadersRange, GetBlockHeadersRangeParams, Output, SendRawTransactionResult, ViewPair } from "../../api";
+import { type BlockInfo, type FeeEstimateResponse, type GetBlockHeadersRange, type GetBlockHeadersRangeParams, type Output, type SendRawTransactionResult, type ViewPair } from "../../api";
 import type { Payment } from "../../send-functionality/inputSelection";
 export declare function initScanCache(viewpair: ViewPair, start_height: number, scan_settings_path?: string, pathPrefix?: string): Promise<CacheRange>;
+export declare function getBlockInfoForHeight(height: number, node_url: string): Promise<BlockInfo>;
+export declare function makeCacheRangeForHeight(height: number, node_url: string): Promise<CacheRange>;
+export declare function initScanCacheFile(viewpair: ViewPair, scan_settings_path?: string, pathPrefix?: string): Promise<ScanCache>;
 export declare function readCacheFile(cacheFilePath: string): Promise<ScanCache | undefined>;
 export declare function cacheFileDefaultLocation(primary_address: string, pathPrefix?: string): string;
 export declare function readCacheFileDefaultLocation(primary_address: string, pathPrefix?: string): Promise<ScanCache | undefined>;
@@ -14,8 +16,10 @@ export type WriteCacheFileParams = {
 export declare function writeCacheFileDefaultLocationThrows(params: WriteCacheFileParams): Promise<void>;
 export declare function writeCacheToFile(cache: ScanCache, pathPrefix?: string): Promise<number>;
 export declare function lastRange(ranges: CacheRange[]): CacheRange | undefined;
+export declare function lastRangeThrows(ranges: CacheRange[]): CacheRange;
 export declare function mergeRanges(ranges: CacheRange[]): CacheRange[];
 export declare const findRange: (ranges: CacheRange[], value: number) => CacheRange | null;
+export declare function findRangeThrows(ranges: CacheRange[], value: number): CacheRange;
 export type CacheRange = {
     start: number;
     end: number;
@@ -44,6 +48,16 @@ export type ScanCache = {
     reorg_info?: ReorgInfo;
     daemon_height: number;
 };
+export type ReorgInfo = {
+    split_heights: BlockInfo[];
+    removed_outputs: ReorgedOutput[];
+    reverted_spends: ReorgedOutput[];
+};
+export type ReorgedOutput = {
+    old_output_state: Output;
+    key_image: KeyImage;
+    split_height: BlockInfo;
+};
 export type TxLog = {
     inputs_index: string[];
     payments: Payment[];

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

@@ -1,4 +1,5 @@
 import {} from "./computeKeyImage";
+import { get_block_headers_range, } from "../../api";
 import { atomicWrite } from "../../io/atomicWrite";
 export async function initScanCache(viewpair, start_height, scan_settings_path, pathPrefix) {
     const initialCache = await readCacheFileDefaultLocation(viewpair.primary_address, pathPrefix);
@@ -43,6 +44,44 @@ export async function initScanCache(viewpair, start_height, scan_settings_path,
     await writeCacheToFile(cache, pathPrefix);
     return current_range;
 }
+export async function getBlockInfoForHeight(height, node_url) {
+    const blockHeaderResponse = await get_block_headers_range(node_url, {
+        start_height: height,
+        end_height: height,
+    });
+    const header = blockHeaderResponse.headers[0];
+    return {
+        block_hash: header.hash,
+        block_height: header.height,
+        block_timestamp: header.timestamp,
+    };
+}
+export async function makeCacheRangeForHeight(height, node_url) {
+    const hash_at_height = await getBlockInfoForHeight(height, node_url);
+    const newRange = {
+        start: height,
+        end: height,
+        block_hashes: [hash_at_height, hash_at_height, hash_at_height],
+    };
+    return newRange;
+}
+export async function initScanCacheFile(viewpair, scan_settings_path, pathPrefix) {
+    const initialCache = await readCacheFileDefaultLocation(viewpair.primary_address, pathPrefix);
+    let cache = {
+        daemon_height: 0,
+        outputs: {},
+        own_key_images: {},
+        scanned_ranges: [],
+        primary_address: viewpair.primary_address,
+    };
+    if (initialCache)
+        cache = initialCache;
+    cache.scanned_ranges = mergeRanges(cache.scanned_ranges);
+    await viewpair.addSubaddressesToScanCache(cache, scan_settings_path);
+    // write to cache
+    await writeCacheToFile(cache, pathPrefix);
+    return cache;
+}
 export async function readCacheFile(cacheFilePath) {
     const jsonString = await Bun.file(cacheFilePath)
         .text()
@@ -56,6 +95,10 @@ export async function readCacheFile(cacheFilePath) {
         : undefined;
 }
 export function cacheFileDefaultLocation(primary_address, pathPrefix) {
+    if (pathPrefix && pathPrefix.endsWith("/"))
+        pathPrefix = pathPrefix.slice(0, -1);
+    if (pathPrefix)
+        pathPrefix += "/";
     return `${pathPrefix ?? ""}${primary_address}_cache.json`;
 }
 export async function readCacheFileDefaultLocation(primary_address, pathPrefix) {
@@ -78,6 +121,11 @@ export function lastRange(ranges) {
         return undefined;
     return ranges.reduce((maxRange, current) => (current.end > maxRange.end ? current : maxRange), ranges[0]);
 }
+export function lastRangeThrows(ranges) {
+    if (!ranges.length)
+        throw new Error("ranges is empty");
+    return ranges.reduce((maxRange, current) => (current.end > maxRange.end ? current : maxRange), ranges[0]);
+}
 export function mergeRanges(ranges) {
     if (ranges.length <= 1)
         return ranges.map((r) => ({ ...r }));
@@ -89,8 +137,10 @@ export function mergeRanges(ranges) {
         // If last range overlaps or touches current range
         if (curr.start <= last.end) {
             // Extend last range to cover both (take max end value)
-            last.end = Math.max(last.end, curr.end);
-            last.block_hashes = curr.block_hashes;
+            if (curr.end > last.end) {
+                last.end = curr.end;
+                last.block_hashes = curr.block_hashes;
+            }
         }
         else {
             // No overlap: add current range as new merged interval
@@ -101,6 +151,12 @@ export function mergeRanges(ranges) {
 }
 // find the cache range that contains the given height, if not found return null
 export const findRange = (ranges, value) => ranges.find((r) => value >= r.start && value <= r.end) ?? null;
+export function findRangeThrows(ranges, value) {
+    const range = findRange(ranges, value);
+    if (!range)
+        throw new Error(`range not found for value: ${value}`);
+    return range;
+}
 export function handleScanError(error) {
     // treat errno 0 code "ConnectionRefused" as non fatal outcome, and rethrow,
     // so that UI can be informed after catching it higher up

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

@@ -28,6 +28,22 @@ export declare class ScanCacheOpened {
     private scan_settings_path?;
     private pathPrefix?;
     private workerError?;
+    /** how many decoys to sample per input (default 20, ring size is 11) */
+    decoySampleCount: number;
+    /**
+     * when true, retry makeInput with higher sample counts on failure.
+     *
+     * PRIVACY WARNING: retrying contacts the node multiple times for the same
+     * input, each time with a different set of candidate indices. this lets the
+     * node correlate which output is the real spend across the retries.
+     * only ever enable this on your own local trusted node, never on a remote
+     * public node.
+     *
+     * defaults to false, on failure the original error propagates.
+     */
+    decoyRetry: boolean;
+    /** sample sizes to try when decoyRetry is enabled, in order */
+    readonly decoyRetrySizes: number[];
     static create(params: ScanCacheOpenedCreateParams): Promise<ScanCacheOpened>;
     get start_height(): number | null;
     get current_height(): number | null;
@@ -120,6 +136,8 @@ export declare class ScanCacheOpened {
     feed(params: CacheChangedCallbackParameters): Promise<void>;
     private _cache;
     private worker?;
+    private last_eta_height;
+    private last_eta_timestamp;
     private constructor();
     private _stats;
     private notifyListeners;