@spirobel/monero-wallet-api 0.3.16 → 0.4.0

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;

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

@@ -0,0 +1,127 @@
+import { type GetBlocksBinBufferItem, type BlocksBufferLoopResult, type BlocksBufferIteratorResult, type ProcessScanResult, type BlockInfo } from "../../api";
+import { type ScanLoopYield } from "./scanLoop";
+import { type WorkItem } from "./scanLoop";
+import { type ScanSettings } from "../scanSettings";
+import { type CacheRange, type ScanCache } from "./scanCache";
+export type WalletConfig = {
+    primary_address: string;
+    secret_view_key: string;
+    secret_spend_key?: string;
+    subaddress_index: number;
+};
+export type WalletConfigPlusCache = {
+    primary_address: string;
+    secret_view_key: string;
+    secret_spend_key?: string;
+    subaddress_index: number;
+    cache: ScanCache;
+};
+export type WorkToBeDone = {
+    start_height: number;
+    wallet_configs: WalletConfigPlusCache[];
+    anchor_range: CacheRange;
+    scan_settings: ScanSettings;
+};
+/**
+ * this depends only on ScanSettings.json start_height and wallet caches scanned_ranges
+ * side effect: will init wallet cache file if it does not exist
+ * side effect: will merge scan ranges + add subaddreses to existing cache files
+ * @param scan_settings_path
+ */
+export declare function findWorkToBeDone(scan_settings_path?: string, pathPrefix?: string): Promise<WorkToBeDone | false>;
+export declare function workToBeDoneForBatch(cache: ScanCache, batch_meta_infos: BlockInfo[]): "skip" | {
+    from: number;
+};
+/**
+ * called when the blocks buffer generator yields "blocks_buffer_changed".
+ * adds new work items for blocks buffer items not yet referenced.
+ * per wallet
+ */
+export declare function makeWorkItemsFromBlocksBuffer(blocksBuffer: GetBlocksBinBufferItem[], workItemBuffer: WorkItem[], walletConfig: WalletConfigPlusCache, from?: number, to?: number): void;
+export declare function makeWorkItemsForAllWallets(wallet_configs: WalletConfigPlusCache[], blocksBuffer: GetBlocksBinBufferItem[], workBuffer: WorkItem[]): void;
+/**
+ * called when a work item at the left end of the work buffer is done.
+ * shifts done items off the left, and removes their batch from the
+ * blocks buffer if no remaining work items reference it.
+ */
+export declare function reconcileWorkItemDone(blocksBuffer: GetBlocksBinBufferItem[], workItemBuffer: WorkItem[]): void;
+/**
+ * one round of the select race. takes two primed promises (blocks, scan),
+ * races them, returns winner info. the loser stays in flight.
+ */
+export declare function raceStep(blocksPromise: Promise<IteratorResult<BlocksBufferLoopResult>>, scanPromise: Promise<IteratorResult<ScanLoopYield, void>>): Promise<{
+    src: "blocks" | "scan";
+    value: IteratorResult<BlocksBufferLoopResult> | IteratorResult<ScanLoopYield, void>;
+    done: boolean;
+}>;
+/**
+ * handle a yield from the blocks buffer fetch loop.
+ */
+export declare function handleBlocksYield(value: BlocksBufferLoopResult, scanSettingsPath?: string): Promise<{
+    isBlocksBufferChanged: boolean;
+}>;
+/**
+ * process a scan result for a completed work item.
+ * updates the cache, writes to disk, marks work item done, reconciles.
+ */
+export declare function processScanResultForWorkItem(value: ScanLoopYield, workBuffer: WorkItem[], blocksBuffer: GetBlocksBinBufferItem[], pathPrefix: string, secret_spend_key?: string): Promise<void>;
+/**
+ * process a scan result for a completed work item.
+ * updates the cache, writes to disk, marks work item done, reconciles blockbuffer with this.
+ */
+export declare function processWorkItem(item: WorkItem, workBuffer: WorkItem[], blocksBuffer: GetBlocksBinBufferItem[], pathPrefix: string, secret_spend_key?: string): Promise<ProcessScanResult>;
+export type CoordinatorEvent = {
+    type: "blocks_buffer_changed";
+} | {
+    type: "connection_status";
+    status: any;
+} | {
+    type: "scan_ready";
+    address: string;
+    result: ScanLoopYield;
+    newCache: ScanCache;
+    changed_outputs: {
+        output: any;
+        change_reason: string;
+    }[];
+} | {
+    type: "all_idle";
+} | {
+    type: "error";
+    error: Error;
+};
+/**
+ * coordinator main: async generator that drives the full scan cycle.
+ * takes only scanSettingsPath, derives everything else internally.
+ * yields events for some of the underlying generator events,
+ * look at CoordinatorEvent, processing not decoupled from cpu bound scan work,
+ * as this single threaded, there is no point
+ */
+export declare function coordinatorMain(scanSettingsPath?: string, pathPrefix?: string): AsyncGenerator<CoordinatorEvent>;
+export declare function setupCoordinator(scanSettingsPath?: string, pathPrefix?: string): Promise<false | {
+    blocksGenerator: AsyncGenerator<BlocksBufferLoopResult, any, any>;
+    workBuffer: WorkItem[];
+    blocksBuffer: GetBlocksBinBufferItem[];
+    work_to_be_done: WorkToBeDone;
+}>;
+export type WalletSyncInfo = {
+    walletConfig: WalletConfig;
+    work_buffer: WorkItem[];
+};
+export type PortStatus = {
+    port: MessagePort;
+    promise: Promise<ScanLoopYield> | null;
+};
+export type BlocksBufferRacer = {
+    src: "blocks";
+    value: BlocksBufferIteratorResult;
+};
+export type ScanLoopRacer = ScanLoopYield;
+export type Racers = BlocksBufferRacer | ScanLoopRacer;
+/**
+ * coordinator main (multithreaded): dispatches scan work to CPU workers
+ * via MessagePorts, processes results in order per wallet.
+ * falls back to single-threaded coordinator if no cpuPorts provided.
+ */
+export declare function coordinatorMainMultithreaded(scanSettingsPath?: string, pathPrefix?: string, cpuPorts?: MessagePort[]): AsyncGenerator<CoordinatorEvent>;
+export declare function scheduleWorkOnCpuPorts(ports: PortStatus[], work_buffer: WorkItem[]): Promise<void>;