@spirobel/monero-wallet-api 0.4.1 → 0.5.1

package/dist/scanning-syncing/scanSettings.js

@@ -3,6 +3,10 @@ import { atomicWrite } from "../io/atomicWrite";
 import { refreshEnvIndexedDB } from "../io/indexedDB";
 import { LOCAL_NODE_DEFAULT_URL } from "../node-interaction/nodeUrl";
 export const SCAN_SETTINGS_STORE_NAME_DEFAULT = "ScanSettings.json";
+// default value for subaddress highest minor index eg up to which minor index,
+// to add subaddresses to the scanner
+// (we never touch major index, having two values is just too confusing)
+export const SUB_ADDRESS_INDEX_DEFAULT_VALUE = 1;
 /**
  * Writes scan settings to the default or specified storage file in json.
  *
@@ -19,15 +23,15 @@ export const SCAN_SETTINGS_STORE_NAME_DEFAULT = "ScanSettings.json";
  * ```
  *
  * @param scan_settings - The complete {@link ScanSettings} configuration to persist.
- * @param settingsStorePath - Optional path for the settings file. Defaults to `SCAN_SETTINGS_STORE_NAME_DEFAULT`.
+ * @param scan_settings_path - Optional path for the settings file. Defaults to `SCAN_SETTINGS_STORE_NAME_DEFAULT`.
  * @returns A promise that resolves when the file is successfully written.
  * @throws Will throw if file writing fails (e.g., permissions, disk space).
  */
-export async function writeScanSettings(scan_settings, settingsStorePath = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
-    return await atomicWrite(settingsStorePath, JSON.stringify(scan_settings, null, 2));
+export async function writeScanSettings(scan_settings, scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    return await atomicWrite(scan_settings_path, JSON.stringify(scan_settings, null, 2));
 }
 export async function writeScanSettingsFileDefaultLocation(params) {
-    let settings = await openScanSettingsFile(params.settingsStorePath);
+    let settings = await openScanSettingsFile(params.scan_settings_path);
     if (!settings) {
         // Create empty ScanSettings object with default values
         settings = {
@@ -38,10 +42,10 @@ export async function writeScanSettingsFileDefaultLocation(params) {
     }
     await params.writeCallback(settings);
     // write to settings file
-    await writeScanSettings(settings, params.settingsStorePath);
+    await writeScanSettings(settings, params.scan_settings_path);
 }
-export async function writeStartHeightToScanSettings(start_height, settingsStorePath = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
-    const scanSettings = (await openScanSettingsFile(settingsStorePath)) || {
+export async function writeStartHeightToScanSettings(start_height, scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    const scanSettings = (await openScanSettingsFile(scan_settings_path)) || {
         node_url: LOCAL_NODE_DEFAULT_URL,
         wallets: [],
         start_height: null,
@@ -49,20 +53,20 @@ export async function writeStartHeightToScanSettings(start_height, settingsStore
     scanSettings.start_height = start_height;
     return await atomicWrite(SCAN_SETTINGS_STORE_NAME_DEFAULT, JSON.stringify(scanSettings, null, 2));
 }
-export async function writeDaemonHeightAsStartHeightToScanSettings(node_url, settingsStorePath = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+export async function writeDaemonHeightAsStartHeightToScanSettings(node_url, scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
     const getInfo = await get_info(node_url);
-    const scanSettings = (await openScanSettingsFile(settingsStorePath)) || {
+    const scanSettings = (await openScanSettingsFile(scan_settings_path)) || {
         node_url: LOCAL_NODE_DEFAULT_URL,
         wallets: [],
         start_height: null,
     };
     scanSettings.start_height = getInfo.height - 1;
-    await atomicWrite(settingsStorePath, JSON.stringify(scanSettings, null, 2));
+    await atomicWrite(scan_settings_path, JSON.stringify(scanSettings, null, 2));
     return getInfo.height;
 }
-export async function cullTooLargeScanHeight(node_url, settingsStorePath = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+export async function cullTooLargeScanHeight(node_url, scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
     const getInfo = await get_info(node_url);
-    const scanSettings = (await openScanSettingsFile(settingsStorePath)) || {
+    const scanSettings = (await openScanSettingsFile(scan_settings_path)) || {
         node_url: LOCAL_NODE_DEFAULT_URL,
         wallets: [],
         start_height: null,
@@ -70,21 +74,21 @@ export async function cullTooLargeScanHeight(node_url, settingsStorePath = SCAN_
     if (scanSettings.start_height === null ||
         scanSettings.start_height > getInfo.height - 1) {
         scanSettings.start_height = getInfo.height - 1;
-        await atomicWrite(settingsStorePath, JSON.stringify(scanSettings, null, 2));
+        await atomicWrite(scan_settings_path, JSON.stringify(scanSettings, null, 2));
     }
     return scanSettings.start_height;
 }
-export async function writeNodeUrlToScanSettings(node_url, settingsStorePath = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
-    const scanSettings = (await openScanSettingsFile(settingsStorePath)) || {
+export async function writeNodeUrlToScanSettings(node_url, scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    const scanSettings = (await openScanSettingsFile(scan_settings_path)) || {
         node_url: LOCAL_NODE_DEFAULT_URL,
         wallets: [],
         start_height: null,
     };
     scanSettings.node_url = node_url;
-    return await atomicWrite(settingsStorePath, JSON.stringify(scanSettings, null, 2));
+    return await atomicWrite(scan_settings_path, JSON.stringify(scanSettings, null, 2));
 }
-export async function readNodeUrlFromScanSettings(settingsStorePath = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
-    const scanSettings = await openScanSettingsFile(settingsStorePath);
+export async function readNodeUrlFromScanSettings(scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    const scanSettings = await openScanSettingsFile(scan_settings_path);
     return scanSettings?.node_url;
 }
 /**
@@ -98,18 +102,18 @@ export async function readNodeUrlFromScanSettings(settingsStorePath = SCAN_SETTI
  *
  * @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.
+ * @param scan_settings_path - 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)) || {
+export async function writeMerchantConfirmationsToScanSettings(merchant_confirmations, scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    const scanSettings = (await openScanSettingsFile(scan_settings_path)) || {
         node_url: LOCAL_NODE_DEFAULT_URL,
         wallets: [],
         start_height: null,
     };
     scanSettings.merchant_confirmations = merchant_confirmations;
-    return await atomicWrite(settingsStorePath, JSON.stringify(scanSettings, null, 2));
+    return await atomicWrite(scan_settings_path, JSON.stringify(scanSettings, null, 2));
 }
 /**
  * Reads the merchant confirmation threshold from scan settings.
@@ -121,13 +125,13 @@ export async function writeMerchantConfirmationsToScanSettings(merchant_confirma
  * 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.
+ * @param scan_settings_path - 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);
+export async function readMerchantConfirmationsFromScanSettings(scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
+    const scanSettings = await openScanSettingsFile(scan_settings_path);
     return scanSettings?.merchant_confirmations;
 }
 /**
@@ -142,7 +146,7 @@ export async function readMerchantConfirmationsFromScanSettings(settingsStorePat
  * }
  * ```
  *
- * @param settingsStorePath - Path to the settings file. Defaults to `SCAN_SETTINGS_STORE_NAME_DEFAULT`.
+ * @param scan_settings_path - Path to the settings file. Defaults to `SCAN_SETTINGS_STORE_NAME_DEFAULT`.
  * @returns The parsed {@link ScanSettings} object if file exists and is valid JSON, otherwise `undefined`.
  */
 export async function readScanSettings(scan_settings_path = SCAN_SETTINGS_STORE_NAME_DEFAULT) {
@@ -231,7 +235,7 @@ export async function writeWalletToScanSettings(params) {
             wallets: [
                 {
                     primary_address: params.primary_address,
-                    subaddress_index: params.subaddress_index || 1,
+                    subaddress_index: params.subaddress_index || SUB_ADDRESS_INDEX_DEFAULT_VALUE,
                     halted: params.halted,
                     wallet_route: params.wallet_route,
                     wallet_name: params.wallet_name,
@@ -261,7 +265,7 @@ export async function writeWalletToScanSettings(params) {
         // wallet does not exist yet in settings
         scanSettings.wallets.push({
             primary_address: params.primary_address,
-            subaddress_index: params.subaddress_index || 1,
+            subaddress_index: params.subaddress_index || SUB_ADDRESS_INDEX_DEFAULT_VALUE,
             halted: params.halted,
             wallet_route: params.wallet_route,
             wallet_name: params.wallet_name,
@@ -273,7 +277,9 @@ export async function writeWalletToScanSettings(params) {
         const wallet = scanSettings.wallets[already_has_settings];
         if (wallet) {
             wallet.subaddress_index =
-                params.subaddress_index || wallet.subaddress_index || 1;
+                params.subaddress_index ||
+                    wallet.subaddress_index ||
+                    SUB_ADDRESS_INDEX_DEFAULT_VALUE;
             wallet.halted = params.halted || wallet.halted;
             wallet.wallet_route = params.wallet_route || wallet.wallet_route;
             wallet.wallet_name = params.wallet_name || wallet.wallet_name;

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

@@ -1,3 +1,4 @@
 import type { Output } from "../../api";
+import { WasmProcessor } from "../../wasm-processing/wasmProcessor";
 export type KeyImage = string;
-export declare function computeKeyImage(output: Output, sender_spend_key: string): Promise<KeyImage | undefined>;
+export declare function computeKeyImage(output: Output, sender_spend_key: string, wasmProcessor?: WasmProcessor): Promise<KeyImage | undefined>;

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

@@ -1,6 +1,8 @@
+import { monero_wallet_api_wasm } from "../../wasm-processing/wasmFile";
 import { WasmProcessor } from "../../wasm-processing/wasmProcessor";
-export async function computeKeyImage(output, sender_spend_key) {
-    const wasmProcessor = await WasmProcessor.init();
+export async function computeKeyImage(output, sender_spend_key, wasmProcessor) {
+    if (!wasmProcessor)
+        wasmProcessor = await WasmProcessor.init(monero_wallet_api_wasm);
     wasmProcessor.writeToWasmMemory = (ptr, len) => {
         wasmProcessor.writeString(ptr, len, output.serialized);
         wasmProcessor.writeToWasmMemory = (ptr, len) => {

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

@@ -46,6 +46,7 @@ export declare class ScanCacheOpened {
     readonly decoyRetrySizes: number[];
     static create(params: ScanCacheOpenedCreateParams): Promise<ScanCacheOpened>;
     get start_height(): number | null;
+    get subaddress_index(): number;
     get current_height(): number | null;
     get current_top_range_height(): number | null;
     changeStartHeight(start_height: number | null): Promise<void>;
@@ -60,6 +61,7 @@ export declare class ScanCacheOpened {
     retry(): Promise<boolean>;
     sendTransaction(signedTx: string): Promise<SendRawTransactionResult>;
     signTransaction(unsignedTx: string): Promise<string>;
+    getFeeEstimate(): Promise<FeeEstimateResponse>;
     calculateFeeAndSelectInputs(params: CreateTransactionParams): Promise<{
         selectedInputs: Output[];
         feeEstimate: {
@@ -70,10 +72,16 @@ export declare class ScanCacheOpened {
         };
     }>;
     makeTransactionFromSelectedInputs(payments: Payment[], selectedInputs: Output[], feeEstimate: FeeEstimateResponse): Promise<string>;
+    makeSweepTransactionFromSelectedInputs(destination_address: string, selectedInputs: Output[], feeEstimate: FeeEstimateResponse): Promise<string>;
     /**
      * this function returns the unsigned transaction, throws {@link SendError}
      */
     makeTransaction(params: CreateTransactionParams): Promise<string>;
+    /**
+     * sweep inputs to external wallet address (the wallet will receive input amount - fee)
+     * @param inputs     use spendableInputs() to find inputs to put in
+     */
+    sweepToExternalWallet(destination_address: string, inputs: Output[]): Promise<string>;
     get daemon_height(): number;
     get amount(): bigint;
     get pending_amount(): bigint;
@@ -134,6 +142,9 @@ export declare class ScanCacheOpened {
      * for all primary addresses
      */
     feed(params: CacheChangedCallbackParameters): Promise<void>;
+    private _highest_subaddress_index;
+    private _no_stats;
+    get no_stats(): boolean;
     private _cache;
     private worker?;
     private last_eta_height;

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/scanResult.js

@@ -1,8 +1,10 @@
-import { CatastrophicReorgError, } from "../../api";
+import { CatastrophicReorgError } from "../../api";
 import { computeKeyImage } from "./computeKeyImage";
 import { log } from "../../io/logging";
-import { mergeRanges, findRange, readCacheFileDefaultLocation, lastRange, writeCacheToFile, findRangeThrows, } from "./scanCache";
+import { mergeRanges, findRange, findRangeThrows } from "./scanCache";
 import {} from "../../node-interaction/binaryEndpoints";
+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 = [];
@@ -137,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);
@@ -167,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;
             }
@@ -223,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) {