@spirobel/monero-wallet-api 0.4.0 → 0.5.0

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

@@ -2,7 +2,7 @@ import { atomicWrite, NodeUrl, signTransaction, ViewPair, } from "../../api";
 import { prepareInput, sumPayments, } from "../../send-functionality/inputSelection";
 import { createWebworker } from "../backgroundWorker";
 import { spendable } from "./scanResult";
-import { openScanSettingsFile, readPrivateSpendKeyFromEnv, readWalletFromScanSettings, SCAN_SETTINGS_STORE_NAME_DEFAULT, walletSettingsPlusKeys, writeNodeUrlToScanSettings, writeStartHeightToScanSettings, writeWalletToScanSettings, } from "../scanSettings";
+import { getPathPrefix, openScanSettingsFile, readPrivateSpendKeyFromEnv, readWalletFromScanSettings, SCAN_SETTINGS_STORE_NAME_DEFAULT, SUB_ADDRESS_INDEX_DEFAULT_VALUE, walletSettingsPlusKeys, writeNodeUrlToScanSettings, writeStartHeightToScanSettings, writeWalletToScanSettings, } from "../scanSettings";
 import { findRange, lastRange, readCacheFileDefaultLocation, writeCacheFileDefaultLocationThrows, } from "./scanCache";
 import { alignScanStatsWithCache, isSelfSpent, processTxlogInputs, processTxlogPayments, writeStatsFileDefaultLocation, } from "./scanStats";
 import { updateSyncETA, readWriteConnectionStatusFile, } from "../connectionStatus";
@@ -53,19 +53,32 @@ export class ScanCacheOpened {
             // unpause will start scanning from this.wallet_scan_settings.start_height
             await scanCacheOpen.unpause();
         }
-        scanCacheOpen._stats = await alignScanStatsWithCache(scanCacheOpen._cache, scanCacheOpen.view_pair, params.primary_address, params.pathPrefix, walletSettings.subaddress_index, lastRange(scanCacheOpen._cache.scanned_ranges)?.end);
+        scanCacheOpen._highest_subaddress_index =
+            walletSettings.subaddress_index || SUB_ADDRESS_INDEX_DEFAULT_VALUE;
+        if (!params.no_stats) {
+            scanCacheOpen._stats = await alignScanStatsWithCache(scanCacheOpen._cache, scanCacheOpen.view_pair, params.primary_address, getPathPrefix(params.scan_settings_path, params.pathPrefix), walletSettings.subaddress_index, lastRange(scanCacheOpen._cache.scanned_ranges)?.end);
+        }
+        else {
+            scanCacheOpen._no_stats = params.no_stats; // true
+        }
         return scanCacheOpen;
     }
     get start_height() {
         return this._start_height;
     }
+    get subaddress_index() {
+        if (typeof this._highest_subaddress_index === "undefined" ||
+            this._highest_subaddress_index === null)
+            return SUB_ADDRESS_INDEX_DEFAULT_VALUE;
+        return this._highest_subaddress_index;
+    }
     get current_height() {
         let current_range = findRange(this._cache.scanned_ranges, this._start_height || 0);
         return current_range?.end || null;
     }
     get current_top_range_height() {
         if (typeof this._stats === "undefined" || this._stats === null)
-            return null;
+            return this.current_height;
         return this._stats.height;
     }
     async changeStartHeight(start_height) {
@@ -181,6 +194,21 @@ export class ScanCacheOpened {
             throw new Error("privateSpendKey not found in env");
         return await signTransaction(unsignedTx, privateSpendKey);
     }
+    async getFeeEstimate() {
+        const node = await NodeUrl.create(this.node_url);
+        const feeEstimate = await node.getFeeEstimate();
+        const feePerByte = BigInt(feeEstimate.fees[0]);
+        const max_plausible_fee = 20000000000n; // 0.02 XMR
+        const feeFor10kb = feePerByte * 10000n;
+        //2. check if fee is too high
+        if (feeFor10kb > max_plausible_fee) {
+            throw new Error(`fee too high: 
+          ${feeFor10kb} (fee for 10kb tx size) > ${max_plausible_fee} (0.001 XMR)
+          most likely your node is faulty. connect to another node.
+           preferably run one yourself locally.`);
+        }
+        return feeEstimate;
+    }
     async calculateFeeAndSelectInputs(params) {
         const sum = sumPayments(params.payments);
         const node = await NodeUrl.create(this.node_url);
@@ -243,6 +271,49 @@ export class ScanCacheOpened {
         });
         return unsignedTx;
     }
+    async makeSweepTransactionFromSelectedInputs(destination_address, selectedInputs, feeEstimate) {
+        // 4. get output distribution
+        const node = await NodeUrl.create(this.node_url);
+        const distibution = await node.getOutputDistribution();
+        const inputs = [];
+        for (const input of selectedInputs) {
+            // 5. sample decoys & get outs from node: here is where a privacy compromising event could happen
+            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.makeSweepTransaction({
+            inputs,
+            payments: [
+                {
+                    address: destination_address,
+                    amount: "0",
+                },
+            ],
+            fee_response: feeEstimate,
+            fee_priority: "unimportant",
+        });
+        return unsignedTx;
+    }
     /**
      * this function returns the unsigned transaction, throws {@link SendError}
      */
@@ -250,16 +321,30 @@ export class ScanCacheOpened {
         const { selectedInputs, feeEstimate } = await this.calculateFeeAndSelectInputs(params);
         return await this.makeTransactionFromSelectedInputs(params.payments, selectedInputs, feeEstimate);
     }
+    /**
+     * sweep inputs to external wallet address (the wallet will receive input amount - fee)
+     * @param inputs     use spendableInputs() to find inputs to put in
+     */
+    async sweepToExternalWallet(destination_address, inputs) {
+        const feeEstimate = await this.getFeeEstimate();
+        return await this.makeSweepTransactionFromSelectedInputs(destination_address, inputs, feeEstimate);
+    }
     get daemon_height() {
         return this._cache.daemon_height;
     }
     get amount() {
+        if (this.no_stats)
+            throw new Error("instance has no_stats option active");
         return this._stats?.total_spendable_amount || 0n;
     }
     get pending_amount() {
+        if (this.no_stats)
+            throw new Error("instance has no_stats option active");
         return this._stats?.total_pending_amount || 0n;
     }
     get subaddresses() {
+        if (this.no_stats)
+            throw new Error("instance has no_stats option active");
         return Object.values(this._stats?.subaddresses || {});
     }
     get tx_logs() {
@@ -403,6 +488,7 @@ export class ScanCacheOpened {
         const last_subaddress_index = walletSettings.subaddress_index || 0;
         const minor = last_subaddress_index + 1;
         const subaddress = this.view_pair.makeSubaddress(minor);
+        this._highest_subaddress_index = minor;
         await writeWalletToScanSettings({
             primary_address: this.view_pair.primary_address,
             subaddress_index: minor,
@@ -417,13 +503,14 @@ export class ScanCacheOpened {
             created_at_timestamp,
             not_yet_included: true,
         };
-        this._stats = await writeStatsFileDefaultLocation({
-            primary_address: this.primary_address,
-            pathPrefix: this.pathPrefix,
-            writeCallback: async (stats) => {
-                stats.subaddresses[minor.toString()] = new_subaddress;
-            },
-        });
+        if (!this._no_stats)
+            this._stats = await writeStatsFileDefaultLocation({
+                primary_address: this.primary_address,
+                pathPrefix: getPathPrefix(this.scan_settings_path, this.pathPrefix),
+                writeCallback: async (stats) => {
+                    stats.subaddresses[minor.toString()] = new_subaddress;
+                },
+            });
         return new_subaddress;
     }
     /**
@@ -546,7 +633,8 @@ export class ScanCacheOpened {
         if (this.view_pair.primary_address !== params.newCache.primary_address)
             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_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.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;
@@ -557,6 +645,11 @@ export class ScanCacheOpened {
                 listener(params);
         }
     }
+    _highest_subaddress_index = null;
+    _no_stats = false;
+    get no_stats() {
+        return this._no_stats;
+    }
     _cache = {
         daemon_height: 0,
         outputs: {},

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

@@ -1,9 +1,10 @@
-import { setupBlocksBufferGenerator, ViewPair, handleConnectionStatusChanges, processScanResultWITHOUT_SIDE_EFFECTS, writeCacheToFile, sleep, findTipIndex, } from "../../api";
+import { setupBlocksBufferGenerator, ViewPair, handleConnectionStatusChanges, processScanResult, writeCacheToFile, sleep, findTipIndex, } from "../../api";
 import { markWorkItemAsDone, } from "./scanLoop";
 import { makeWorkItem, scanLoop } from "./scanLoop";
 import { cullTooLargeScanHeight, getNonHaltedWallets, getPathPrefix, openScanSettingsFile, SCAN_SETTINGS_STORE_NAME_DEFAULT, walletSettingsPlusKeys, } from "../scanSettings";
 import { findRange, initScanCacheFile, lastRange, makeCacheRangeForHeight, mergeRanges, } from "./scanCache";
 import { sendToCpuWorker } from "../worker-mains/cpubound-main";
+import { log } from "../../io/logging";
 /**
  * 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
@@ -59,7 +60,7 @@ export async function findWorkToBeDone(scan_settings_path = SCAN_SETTINGS_STORE_
         for (const wallet_cache of wallet_caches) {
             // only add the range to wallets that don't already have one
             if (!findRange(wallet_cache.scanned_ranges, total_start_height)) {
-                // console.log("inserting range_at_start", range_at_start);
+                log("findWorkToBeDone", "inserting range_at_start");
                 wallet_cache.scanned_ranges.push(range_at_start);
                 wallet_cache.scanned_ranges = mergeRanges(wallet_cache.scanned_ranges);
             }
@@ -81,9 +82,9 @@ export async function findWorkToBeDone(scan_settings_path = SCAN_SETTINGS_STORE_
 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;
-    console.log("[workToBeDoneForBatch]", begin_height, end_height);
+    log("workToBeDoneForBatch", [begin_height, end_height]);
     const foundRange = findRange(cache.scanned_ranges, begin_height);
-    console.log("[workToBeDoneForBatch] foundRange", foundRange);
+    log("workToBeDoneForBatch", ["foundRange", foundRange]);
     if (foundRange) {
         const fullycovered = cache.scanned_ranges.find((r) => r.start <= begin_height && r.end > end_height);
         if (fullycovered) {
@@ -96,13 +97,13 @@ export function workToBeDoneForBatch(cache, batch_meta_infos) {
                 throw new Error("[workToBeDoneForBatch] tip not found, malformed range that covers the work to be done for this batch");
             const tipindex = findTipIndex(batch_meta_infos, tip);
             if (tipindex === "reorg_found") {
-                console.log("[workToBeDoneForBatch] reorg found");
+                log("workToBeDoneForBatch", "reorg found");
                 return { from: 0 };
             }
             else if (tipindex === "empty_blocks_array") {
                 return "skip";
             }
-            console.log("[workToBeDoneForBatch] tipindex", tipindex);
+            log("workToBeDoneForBatch", ["tipindex", tipindex]);
             return { from: tipindex }; // NORMAL case of scheduling directly in front of the tip
         }
     }
@@ -123,36 +124,14 @@ export function makeWorkItemsFromBlocksBuffer(blocksBuffer, workItemBuffer, wall
         const alreadyReferenced = workItemBuffer.some((w) => w.batch.local_uuid === batch.local_uuid &&
             w.walletConfig.primary_address === walletConfig.primary_address);
         if (!alreadyReferenced) {
-            // const begin_height =
-            //   batch.get_blocks_result_meta.block_infos[0].block_height;
-            // const end_height =
-            //   batch.get_blocks_result_meta.block_infos[
-            //     batch.get_blocks_result_meta.block_infos.length - 1
-            //   ].block_height;
-            // console.log(walletConfig.cache.scanned_ranges);
-            // console.log(begin_height);
-            // // skip batches fully covered by an existing scanned range
-            // if (
-            //   walletConfig.cache.scanned_ranges.some(
-            //     (r) => r.start <= begin_height && r.end >= end_height,
-            //   )
-            // ) {
-            //   throw new Error(
-            //     "skip" +
-            //       begin_height +
-            //       " end_height" +
-            //       end_height +
-            //       " " +
-            //       walletConfig.primary_address.slice(0, 6),
-            //   );
-            //   continue;
-            // }
             const workToBeDone = workToBeDoneForBatch(walletConfig.cache, batch.get_blocks_result_meta.block_infos);
             if (workToBeDone === "skip") {
                 continue;
             }
             const workItem = makeWorkItem(walletConfig, batch, from, to);
-            console.log(`[reconcileBlocksBufferChanged] workItem: uuid=${workItem.work_uuid.slice()} to=${workItem.to} from=${workItem.from} batchbegin_height=${batch.get_blocks_result_meta.block_infos[0].block_height} batchend_height=${batch.get_blocks_result_meta.block_infos[batch.get_blocks_result_meta.block_infos.length - 1].block_height}`);
+            log("makeWorkItemsFromBlocksBuffer", [
+                `uuid=${workItem.work_uuid.slice()} to=${workItem.to} from=${workItem.from} batchbegin_height=${batch.get_blocks_result_meta.block_infos[0].block_height} batchend_height=${batch.get_blocks_result_meta.block_infos[batch.get_blocks_result_meta.block_infos.length - 1].block_height}`,
+            ]);
             workItemBuffer.push(workItem);
         }
     }
@@ -168,16 +147,16 @@ export function makeWorkItemsForAllWallets(wallet_configs, blocksBuffer, workBuf
  * blocks buffer if no remaining work items reference it.
  */
 export function reconcileWorkItemDone(blocksBuffer, workItemBuffer) {
-    // console.log(
-    //   `[reconcileWorkItemDone] workItemBuffer.length=${workItemBuffer.length} , blocksBuffer.length=${blocksBuffer.length}`,
-    // );
+    log("reconcileWorkItemDone", [
+        `workItemBuffer.length=${workItemBuffer.length} , blocksBuffer.length=${blocksBuffer.length}`,
+    ]);
     while (workItemBuffer.length > 0 &&
         workItemBuffer[0].status === "process_result_done") {
         const removed = workItemBuffer.shift();
         const stillReferenced = workItemBuffer.some((w) => w.batch.local_uuid === removed.batch.local_uuid);
-        // console.log(
-        //   `[reconcileWorkItemDone] workItem: ${removed.work_uuid.slice()} removed. stillReferenced=${stillReferenced}`,
-        // );
+        log("reconcileWorkItemDone", [
+            `workItem: ${removed.work_uuid.slice()} removed. stillReferenced=${stillReferenced}`,
+        ]);
         if (!stillReferenced) {
             const idx = blocksBuffer.findIndex((b) => b.local_uuid === removed.batch.local_uuid);
             // this really means we have to save work items scanCache to file
@@ -218,17 +197,20 @@ export async function processScanResultForWorkItem(value, workBuffer, blocksBuff
     if (value.type !== "Ready" || !value.result || !value.work_uuid)
         return;
     const item = await markWorkItemAsDone(value, workBuffer);
-    //console.log(`[processScanResultForWorkItem] item=${JSON.stringify(item)}`);
+    log("processScanResultForWorkItem", `item_work_uuid=${item?.work_uuid}`);
     if (!item || item.status !== "scanwork_done")
         throw new Error("[processScanResultForWorkItem] item not found or not scanwork not done. item_status=" +
             item?.status);
     const firstBlock = item.batch.get_blocks_result_meta.block_infos[item.from];
-    //console.log(`
-    //  [processScanResultForWorkItem] block_infos=${JSON.stringify(item.batch.get_blocks_result_meta.block_infos)} block_infos.length=${item.batch.get_blocks_result_meta.block_infos.length} firstBlock=${firstBlock} `);
-    console.log(`[processScanResultForWorkItem] block_infos.length=${item.batch.get_blocks_result_meta.block_infos.length} from=${item.from} to=${item.to}`);
+    log("processScanResultForWorkItem", [
+        `block_infos.length=${item.batch.get_blocks_result_meta.block_infos.length} firstBlock=${firstBlock?.block_height} firstBlockHash=${firstBlock?.block_hash?.slice(0, 8)}`,
+    ]);
+    log("processScanResultForWorkItem", [
+        `block_infos.length=${item.batch.get_blocks_result_meta.block_infos.length} from=${item.from} to=${item.to}`,
+    ]);
     const lastBlock = item.batch.get_blocks_result_meta.block_infos[item.to];
     const cache = item.walletConfig.cache;
-    await processScanResultWITHOUT_SIDE_EFFECTS({
+    await processScanResult({
         from_height: firstBlock.block_height,
         to_height: lastBlock.block_height,
         result: value.result,
@@ -263,28 +245,27 @@ export async function processWorkItem(item, workBuffer, blocksBuffer, pathPrefix
         }
     }
     const firstBlock = item.batch.get_blocks_result_meta.block_infos[item.from];
-    // console.log(
-    //   `[processWorkItem] block_infos.length=${item.batch.get_blocks_result_meta.block_infos.length} from=${item.from} to=${item.to}`,
-    // );
+    log("processWorkItem", [
+        `block_infos.length=${item.batch.get_blocks_result_meta.block_infos.length} from=${item.from} to=${item.to}`,
+    ]);
     const lastBlock = item.batch.get_blocks_result_meta.block_infos[item.to];
-    // console.log(
-    //   "[processWorkItem] ",
-    //   item.walletConfig.primary_address.slice(0, 6),
-    //   "@",
-    //   firstBlock.block_height,
-    //   "-",
-    //   lastBlock.block_height,
-    // );
+    log("processWorkItem", [
+        item.walletConfig.primary_address.slice(0, 6),
+        "@",
+        firstBlock.block_height,
+        "-",
+        lastBlock.block_height,
+    ]);
     let res;
     try {
-        res = await processScanResultWITHOUT_SIDE_EFFECTS({
+        res = await processScanResult({
             from_height: firstBlock.block_height,
             to_height: lastBlock.block_height,
             result: item.result,
             scanCache: cache,
             secret_spend_key,
         });
-        // console.log("[processWorkItem] res=", res);
+        log("processWorkItem", ["res=", res]);
     }
     catch (error) {
         console.error("[processWorkItem] error=", error);
@@ -292,7 +273,7 @@ export async function processWorkItem(item, workBuffer, blocksBuffer, pathPrefix
     }
     await writeCacheToFile(cache, pathPrefix);
     item.status = "process_result_done";
-    //console.log(`[processWorkItem] process_result_done item=${JSON.stringify(item)}`);
+    log("processWorkItem", `process_result_done work_uuid=${item?.work_uuid}`);
     // remove from blocksbuffer if no more work items reference it
     reconcileWorkItemDone(blocksBuffer, workBuffer);
     //because cache is tied to the workitems by reference,
@@ -314,7 +295,9 @@ function logBufStatus(blocksBuffer, workBuffer, ports, label) {
         w.batch.get_blocks_result_meta.block_infos[w.from]?.block_height +
         "-" +
         w.batch.get_blocks_result_meta.block_infos[w.to]?.block_height);
-    console.log(`[buf] ${label} blocks=[${bb.join(",")}] work=[${wb.join(",")}] `);
+    log("logBufStatus", [
+        `[buf] ${label} blocks=[${bb.join(",")}] work=[${wb.join(",")}]`,
+    ]);
 }
 /**
  * coordinator main: async generator that drives the full scan cycle.
@@ -353,10 +336,9 @@ export async function* coordinatorMain(scanSettingsPath, pathPrefix) {
             races.push(p.then((v) => ({ src: "scan", addr, value: v })));
         }
         const winner = await Promise.race(races);
-        console.log("[coordinatorMain] winner=" +
-            winner.src +
-            " addr=" +
-            String(winner.addr ?? "").slice(0, 8));
+        log("coordinatorMain", [
+            "winner=" + winner.src + " addr=" + String(winner.addr ?? "").slice(0, 8),
+        ]);
         if (winner.src === "blocks") {
             const result = winner.value.value;
             const { isBlocksBufferChanged } = await handleBlocksYield(result, scanSettingsPath);
@@ -368,7 +350,7 @@ export async function* coordinatorMain(scanSettingsPath, pathPrefix) {
                     if (scanPromises.has(addr))
                         continue;
                     const gen = scanGens.get(addr);
-                    console.log("scanGens.get(addr)", gen);
+                    log("coordinatorMain", ["scanGens.get(addr)", gen]);
                     if (!gen)
                         continue;
                     const item = workBuffer.find((x) => x.status === "fresh" && x.walletConfig.primary_address === addr);
@@ -459,7 +441,7 @@ export async function* coordinatorMainMultithreaded(scanSettingsPath, pathPrefix
         // throw new Error(
         //   "[coordinatorMain Multithreaded] cpuPorts empty, there must be at least cpu worker",
         // );
-        console.log("[coordinatorMainMultithreaded] fallback to single-threaded");
+        log("coordinatorMainMultithreaded", "fallback to single-threaded");
         yield* coordinatorMain(scanSettingsPath, pathPrefix);
         return;
     }
@@ -482,7 +464,7 @@ export async function* coordinatorMainMultithreaded(scanSettingsPath, pathPrefix
     let race_count = 0;
     while (true) {
         race_count++;
-        console.log("[coordinatorMainMultithreaded] race_count", race_count);
+        log("coordinatorMainMultithreaded", ["race_count", race_count]);
         await scheduleWorkOnCpuPorts(freePorts, workBuffer);
         const scan_promises = freePorts
             .filter((ps) => ps.promise)
@@ -494,9 +476,9 @@ export async function* coordinatorMainMultithreaded(scanSettingsPath, pathPrefix
                 value: v,
             })),
         ];
-        console.log("[coordinatorMainMultithreaded] races", races);
+        log("coordinatorMainMultithreaded", ["races", races]);
         const winner = await Promise.race(races);
-        //console.log("[coordinatorMainMultithreaded] cpu ports status", freePorts);
+        log("coordinatorMainMultithreaded", "cpu ports status");
         if ("src" in winner && winner.src === "blocks") {
             const result = winner.value.value;
             const { isBlocksBufferChanged } = await handleBlocksYield(result, scanSettingsPath);
@@ -529,7 +511,7 @@ export async function* coordinatorMainMultithreaded(scanSettingsPath, pathPrefix
             if (!to_be_processed)
                 continue;
             const res = await processWorkItem(to_be_processed, workBuffer, blocksBuffer, getPathPrefix(scanSettingsPath, pathPrefix), wallet.secret_spend_key);
-            //  console.log("[coordinatorMainMultithreaded] processWorkItem result", res);
+            //  log("coordinatorMainMultithreaded", "processWorkItem result");
             yield {
                 type: "scan_ready",
                 address: wallet.primary_address,
@@ -561,9 +543,14 @@ export async function scheduleWorkOnCpuPorts(ports, work_buffer) {
         const onmessage = (event) => {
             const msg = event.data;
             // handle the result here:
-            console.log("[scheduleWorkOnCpuPorts] onmessage result", msg);
+            log("scheduleWorkOnCpuPorts", ["onmessage result", msg]);
             if (msg.work_uuid !== item.work_uuid) {
-                console.log("[scheduleWorkOnCpuPorts] wrong work_uuid in msg msg.work_uuid=", msg.work_uuid, "item.work_uuid=", item.work_uuid);
+                log("scheduleWorkOnCpuPorts", [
+                    "wrong work_uuid in msg msg.work_uuid=",
+                    msg.work_uuid,
+                    "item.work_uuid=",
+                    item.work_uuid,
+                ]);
                 throw new Error("[scheduleWorkOnCpuPorts] wrong work_uuid in msg");
             }
             if (msg.type === "WORKSTART") {
@@ -571,7 +558,7 @@ export async function scheduleWorkOnCpuPorts(ports, work_buffer) {
                 return;
             }
             if (item.status !== "scanwork_in_progress") {
-                console.log("[scheduleWorkOnCpuPorts] wrong status in msg");
+                log("scheduleWorkOnCpuPorts", "wrong status in msg");
                 throw new Error("[scheduleWorkOnCpuPorts] wrong status in msg");
             }
             item.result = msg.result;
@@ -581,7 +568,7 @@ export async function scheduleWorkOnCpuPorts(ports, work_buffer) {
         };
         port_status.port.onmessage = onmessage;
         item.status = "scanwork_in_progress";
-        console.log("[scheduleWorkOnCpuPorts] scheduling work item", item.work_uuid);
+        log("scheduleWorkOnCpuPorts", ["scheduling work item", item.work_uuid]);
         port_status.promise = new Promise((resolve) => {
             resolve_port = resolve;
         });
@@ -604,7 +591,11 @@ export async function scheduleWorkOnCpuPorts(ports, work_buffer) {
                 break;
             }
             catch {
-                console.log("[scheduleWorkOnCpuPorts] resend attempt", attempt, item.work_uuid);
+                log("scheduleWorkOnCpuPorts", [
+                    "resend attempt",
+                    attempt,
+                    item.work_uuid,
+                ]);
             }
         }
     }

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

@@ -22,7 +22,7 @@ export type ProcessScanResult = {
     current_range: CacheRange;
     changed_outputs: ChangedOutput[];
 };
-export declare function processScanResultWITHOUT_SIDE_EFFECTS(params: ProcessScanResultParamsWithoutSideEffects): Promise<ProcessScanResult>;
+export declare function processScanResult(params: ProcessScanResultParamsWithoutSideEffects): Promise<ProcessScanResult>;
 export declare function processResultReturnValue(cache: ScanCache, params: ProcessScanResultParamsWithoutSideEffects, changed_outputs: ChangedOutput[]): {
     current_range: CacheRange;
     changed_outputs: ChangedOutput[];

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

@@ -1,8 +1,11 @@
-import { CatastrophicReorgError, } from "../../api";
+import { CatastrophicReorgError } from "../../api";
 import { computeKeyImage } from "./computeKeyImage";
-import { mergeRanges, findRange, readCacheFileDefaultLocation, lastRange, writeCacheToFile, findRangeThrows, } from "./scanCache";
+import { log } from "../../io/logging";
+import { mergeRanges, findRange, findRangeThrows } from "./scanCache";
 import {} from "../../node-interaction/binaryEndpoints";
-export async function processScanResultWITHOUT_SIDE_EFFECTS(params) {
+import { WasmProcessor } from "../../wasm-processing/wasmProcessor";
+import { monero_wallet_api_wasm } from "../../wasm-processing/wasmFile";
+export async function processScanResult(params) {
     const { result, scanCache: cache, secret_spend_key } = params;
     let changed_outputs = [];
     if (!(result && "primary_address" in result))
@@ -25,7 +28,10 @@ export async function processScanResultWITHOUT_SIDE_EFFECTS(params) {
                 throw new CatastrophicReorgError("could not locate anchors, should not try to processResult on stale workItems");
             const split_height = result.block_infos[split_height_index];
             // we found the split height & do the reorg
-            console.log("[handleReorg] SPLIT FOUND at height", split_height.block_height);
+            log("processScanResult", [
+                "SPLIT FOUND at height",
+                split_height.block_height,
+            ]);
             if (!cache.reorg_info) {
                 cache.reorg_info = {
                     split_heights: [split_height],
@@ -41,7 +47,12 @@ export async function processScanResultWITHOUT_SIDE_EFFECTS(params) {
             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);
+            log("processScanResult", [
+                "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
@@ -128,6 +139,7 @@ export function makeNewRange(newRange, cache) {
 // Assumption: result is new, cache is still old. (this + detectOwnspends() turns the catch new, based on the scan result)
 export async function detectOutputs(result, cache, spend_private_key) {
     let changed_outputs = [];
+    const wasmProcessor = await WasmProcessor.init(monero_wallet_api_wasm);
     for (const output of result.outputs) {
         // 0. prevent burning bug and avoid overwriting earlier found outputs
         const duplicate = Object.values(cache.outputs).find((ex) => ex.stealth_address === output.stealth_address && !ex.burned);
@@ -158,7 +170,7 @@ export async function detectOutputs(result, cache, spend_private_key) {
         changed_outputs.push({ output, change_reason: "added" });
         // 3. if this is not view only, add the key image to the cache, to find transactions spent by this wallet
         if (spend_private_key) {
-            let keyImage = await computeKeyImage(output, spend_private_key);
+            let keyImage = await computeKeyImage(output, spend_private_key, wasmProcessor);
             if (keyImage) {
                 cache.own_key_images[keyImage] = globalId;
             }
@@ -214,6 +226,7 @@ export function outputStatus(output, cache, current_height) {
     if (unlock_height > current_height) {
         return { status: "pending", unlock_height };
     }
+    // TODO: check that that output is not txlog input indeces
     return { status: "spendable" };
 }
 export function spendable(output, cache, current_height) {