@spirobel/monero-wallet-api 0.3.18 → 0.4.1

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

@@ -1,3 +1,4 @@
+import type { LogSetting, PossibleLogs } from "../io/logging";
 export declare const SCAN_SETTINGS_STORE_NAME_DEFAULT = "ScanSettings.json";
 export type ScanSetting = {
     primary_address: string;
@@ -17,6 +18,9 @@ export type WriteScanSettingParams = {
     wallet_route?: string;
     wallet_name?: string;
     wallet_slot?: number;
+    logs?: LogSetting;
+    logs_include?: PossibleLogs[];
+    logs_exclude?: PossibleLogs[];
 };
 export type ScanSettingOpened = {
     primary_address: string;
@@ -35,12 +39,20 @@ export type ScanSettings = {
     node_url: string;
     start_height: number | null;
     merchant_confirmations?: number | null;
+    cpu_worker_count?: number;
+    logs?: LogSetting;
+    logs_include?: PossibleLogs[];
+    logs_exclude?: PossibleLogs[];
 };
 export type ScanSettingsOpened = {
     wallets: (ScanSettingOpened | undefined)[];
     node_url: string;
     start_height: number | null;
     merchant_confirmations?: number | null;
+    cpu_worker_count?: number;
+    logs?: LogSetting;
+    logs_include?: PossibleLogs[];
+    logs_exclude?: PossibleLogs[];
 };
 /**
  * Writes scan settings to the default or specified storage file in json.
@@ -140,4 +152,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

@@ -239,10 +239,19 @@ export async function writeWalletToScanSettings(params) {
                 },
             ],
             node_url: params.node_url,
+            logs: params.logs,
+            logs_include: params.logs_include,
+            logs_exclude: params.logs_exclude,
             start_height: params.start_height || null,
         }, params.scan_settings_path);
     }
     scanSettings.node_url = params.node_url || scanSettings.node_url;
+    if (params.logs)
+        scanSettings.logs = params.logs;
+    if (params.logs_include)
+        scanSettings.logs_include = params.logs_include;
+    if (params.logs_exclude)
+        scanSettings.logs_exclude = params.logs_exclude;
     scanSettings.start_height =
         params.start_height === undefined
             ? scanSettings.start_height
@@ -290,6 +299,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()
@@ -301,3 +316,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,5 +1,7 @@
 import {} from "./computeKeyImage";
+import { get_block_headers_range, } from "../../api";
 import { atomicWrite } from "../../io/atomicWrite";
+import { log } from "../../io/logging";
 export async function initScanCache(viewpair, start_height, scan_settings_path, pathPrefix) {
     const initialCache = await readCacheFileDefaultLocation(viewpair.primary_address, pathPrefix);
     let cache = {
@@ -43,6 +45,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 +96,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 +122,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 +138,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,11 +152,17 @@ 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
     if (isConnectionError(error)) {
-        console.log("Scan stopped. node might be offline. Connection Refused");
+        log("handleScanError", "Scan stopped. node might be offline. Connection Refused");
         throw error;
     }
     // Treat AbortError as a normal, non-fatal outcome
@@ -113,11 +170,14 @@ export function handleScanError(error) {
         typeof error === "object" &&
         (("name" in error && error.name === "AbortError") ||
             ("code" in error && error.code === 20))) {
-        console.log("Scan was aborted.");
+        log("handleScanError", "Scan was aborted.");
         return;
     }
     else {
-        console.log(error, "\n, scanWithCache in scanning-syncing/scanWithCache.ts`");
+        log("handleScanError", [
+            error,
+            "\n, scanWithCache in scanning-syncing/scanWithCache.ts`",
+        ]);
         throw error;
     }
 }

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;

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

@@ -5,7 +5,7 @@ import { spendable } from "./scanResult";
 import { openScanSettingsFile, readPrivateSpendKeyFromEnv, readWalletFromScanSettings, SCAN_SETTINGS_STORE_NAME_DEFAULT, walletSettingsPlusKeys, writeNodeUrlToScanSettings, writeStartHeightToScanSettings, writeWalletToScanSettings, } from "../scanSettings";
 import { findRange, lastRange, readCacheFileDefaultLocation, writeCacheFileDefaultLocationThrows, } from "./scanCache";
 import { alignScanStatsWithCache, isSelfSpent, processTxlogInputs, processTxlogPayments, writeStatsFileDefaultLocation, } from "./scanStats";
-import { readWriteConnectionStatusFile, } from "../connectionStatus";
+import { updateSyncETA, readWriteConnectionStatusFile, } from "../connectionStatus";
 export class ScanCacheOpened {
     view_pair;
     wallet_route;
@@ -17,6 +17,22 @@ export class ScanCacheOpened {
     scan_settings_path;
     pathPrefix;
     workerError;
+    /** how many decoys to sample per input (default 20, ring size is 11) */
+    decoySampleCount = 20;
+    /**
+     * 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 = false;
+    /** sample sizes to try when decoyRetry is enabled, in order */
+    decoyRetrySizes = [20, 50, 100, 200, 500];
     static async create(params) {
         const theCatchToBeOpened = await readCacheFileDefaultLocation(params.primary_address, params.pathPrefix);
         const walletSettings = await readWalletFromScanSettings(params.primary_address, params.scan_settings_path);
@@ -193,16 +209,30 @@ export class ScanCacheOpened {
         // 4. get output distribution
         const node = await NodeUrl.create(this.node_url);
         const distibution = await node.getOutputDistribution();
-        const preparedInputs = [];
+        const inputs = [];
         for (const input of selectedInputs) {
             // 5. sample decoys & get outs from node: here is where a privacy compromising event could happen
-            preparedInputs.push(prepareInput(node, distibution, input));
-        }
-        const inputs = [];
-        for (const preparedInput of preparedInputs) {
-            // 6. make input: combine output with sampled and verified unlocked decoys
-            const input = node.makeInput(preparedInput.input, preparedInput.sample.candidates, await preparedInput.outsResponse);
-            inputs.push(input);
+            const sizesToTry = this.decoyRetry
+                ? this.decoyRetrySizes
+                : [this.decoySampleCount];
+            let madeInput;
+            for (const size of sizesToTry) {
+                if (madeInput)
+                    break;
+                try {
+                    const prepared = prepareInput(node, distibution, input, size);
+                    const wasmInput = node.makeInput(prepared.input, prepared.sample.candidates, await prepared.outsResponse);
+                    madeInput = wasmInput;
+                }
+                catch (e) {
+                    if (size === sizesToTry[sizesToTry.length - 1])
+                        throw e;
+                    // fall through to next size
+                }
+            }
+            if (!madeInput)
+                throw new Error("failed to make input");
+            inputs.push(madeInput);
         }
         // 7. make transaction: combine inputs, payments + fee info
         const unsignedTx = this.view_pair.makeTransaction({
@@ -429,10 +459,12 @@ export class ScanCacheOpened {
         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,
@@ -441,7 +473,7 @@ export class ScanCacheOpened {
                         },
                     };
                     return connectionStatus;
-                }).then(() => {
+                }, this.scan_settings_path).then(() => {
                     if (workerErrCB)
                         workerErrCB(error);
                 });
@@ -471,7 +503,13 @@ export class ScanCacheOpened {
     selectOneInput(amount) {
         return this.spendableInputs()
             .filter((output) => output.amount >= amount)
-            .sort((a, b) => b.amount > a.amount ? -1 : b.amount < a.amount ? 1 : 0)[0];
+            .sort((a, b) => {
+            if (b.amount > a.amount)
+                return -1;
+            if (b.amount < a.amount)
+                return 1;
+            return a.block_height - b.block_height;
+        })[0];
     }
     /**
      * selectMultipleInputs larger than amount, sorted from largest to smallest until total reaches amount
@@ -509,6 +547,11 @@ export class ScanCacheOpened {
             return;
         this._cache = params.newCache;
         this._stats = await alignScanStatsWithCache(this._cache, this.view_pair, this.primary_address, this.pathPrefix, undefined, lastRange(this._cache.scanned_ranges)?.end);
+        if (!this.no_worker) {
+            const etaResult = await updateSyncETA(this._cache.daemon_height, this.current_height || 0, this.last_eta_height, this.last_eta_timestamp, this.scan_settings_path);
+            this.last_eta_height = etaResult.last_height;
+            this.last_eta_timestamp = etaResult.last_timestamp;
+        }
         for (const listener of this.notifyListeners) {
             if (listener)
                 listener(params);
@@ -522,6 +565,8 @@ export class ScanCacheOpened {
         primary_address: "",
     };
     worker = undefined;
+    last_eta_height = null;
+    last_eta_timestamp = null;
     constructor(view_pair, wallet_route, wallet_name, wallet_slot, no_worker, masterCacheChanged, _start_height, scan_settings_path, pathPrefix, workerError) {
         this.view_pair = view_pair;
         this.wallet_route = wallet_route;