@spirobel/monero-wallet-api 0.4.1 → 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/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) {