@spirobel/monero-wallet-api 0.6.2 → 0.6.7

package/dist/actionlog/actionLogOpened.js

@@ -245,8 +245,13 @@ export class ActionLogOpened {
             }
             case "worker.changeNodeUrlAndStartHeight": {
                 const p = env.payload;
-                await this.mco?.changeNodeUrlAndStartHeight(p?.node_url, p?.start_height);
-                return {};
+                try {
+                    await this.mco?.changeNodeUrlAndStartHeight(p?.node_url, p?.start_height);
+                    return {};
+                }
+                catch (err) {
+                    return { error: err instanceof Error ? err.message : String(err) };
+                }
             }
             case "worker.buildWallets":
                 await this.mco?.buildWallets();

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

@@ -102,6 +102,9 @@ export declare class ScanCacheOpened {
     get pending_amount(): bigint;
     get subaddresses(): Subaddress[];
     get tx_logs(): TxLog[];
+    private writeTxCache;
+    private beginInFlightSend;
+    private finishInFlightSend;
     makeSignSendTransaction(params: CreateTransactionParams): Promise<SendRawTransactionResult>;
     private outputsForIndexes;
     makeSignSend(params: {
@@ -118,7 +121,6 @@ export declare class ScanCacheOpened {
         txlog: TxLog;
         inputs: Output[];
     }[];
-    private recordSend;
     dismissSendPlate(): Promise<void>;
     /**
      * makeStandardTransaction

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

@@ -8,7 +8,7 @@ import { ConnectionStatusOpened } from "../connectionStatusOpened";
 import { ActionLogOpened, } from "../../actionlog/actionLogOpened";
 import { sendToBackground } from "../../tools/globals";
 import { findRange, lastRange, readCacheFileDefaultLocation, writeCacheFileDefaultLocationThrows, } from "./scanCache";
-import { alignScanStatsWithCache, isSelfSpent, processTxlogInputs, processTxlogPayments, writeStatsFileDefaultLocation, } from "./scanStats";
+import { alignScanStatsWithCache, isSelfSpent, processTxlogInputs, processTxlogPayments, txLogHoldsFunds, writeStatsFileDefaultLocation, } from "./scanStats";
 import { readWriteConnectionStatusFile, } from "../connectionStatus";
 export class ScanCacheOpened {
     _scanSettings;
@@ -109,9 +109,7 @@ export class ScanCacheOpened {
     get prepending_txs() {
         const txs = [];
         for (const txlog of this._cache.tx_logs || []) {
-            if (!txlog ||
-                !txlog.sendResult ||
-                (txlog.sendResult && txlog.sendResult.status !== "OK"))
+            if (!txlog || !txLogHoldsFunds(txlog))
                 continue;
             const { inputSum, alreadyRecognizedAsSpend } = processTxlogInputs(txlog, this._cache);
             if (alreadyRecognizedAsSpend)
@@ -173,14 +171,19 @@ export class ScanCacheOpened {
         return this._scanSettings.logs_exclude;
     }
     async changeNodeUrlAndStartHeight(node_url, start_height) {
-        await this.stopWorker();
-        if (node_url !== undefined) {
-            await this._scanSettings.setNodeUrl(node_url);
-            this.node_url = node_url;
+        // stop first so a live worker cannot write the old file over the new url.
+        try {
+            await this.stopWorker();
         }
-        if (start_height !== undefined) {
-            await this._scanSettings.setStartHeight(start_height);
-            this._start_height = start_height;
+        catch {
+            // stop can fail. still write the new url.
+        }
+        if (node_url !== undefined || start_height !== undefined) {
+            await this._scanSettings.setNodeUrlAndStartHeight(node_url, start_height);
+            if (node_url !== undefined)
+                this.node_url = node_url;
+            if (start_height !== undefined)
+                this._start_height = start_height;
         }
         await this.unpause();
     }
@@ -387,15 +390,91 @@ export class ScanCacheOpened {
     get tx_logs() {
         return this._cache.tx_logs || [];
     }
+    async writeTxCache(writeCallback, changed_outputs) {
+        await writeCacheFileDefaultLocationThrows({
+            primary_address: this.primary_address,
+            pathPrefix: this.pathPrefix,
+            writeCallback,
+        });
+        const newCache = await readCacheFileDefaultLocation(this.primary_address, this.pathPrefix);
+        if (!newCache)
+            throw new Error(`cache not found for primary address: ${this.primary_address}, and path prefix: ${this.pathPrefix}`);
+        await this.feed({ newCache, changed_outputs });
+    }
+    // stop the worker, lock the inputs, then let stats show pending.
+    async beginInFlightSend(args) {
+        await this.stopWorker();
+        const inputs_index = args.inputs.map((input) => String(input.index_on_blockchain));
+        let txLogIndex = 0;
+        try {
+            await this.writeTxCache(async (cache) => {
+                if (!cache.tx_logs)
+                    cache.tx_logs = [];
+                if (!cache.pending_spent_utxos)
+                    cache.pending_spent_utxos = {};
+                const txLog = {
+                    feeEstimate: args.feeEstimate,
+                    payments: args.payments,
+                    node_url: this.node_url,
+                    inputs_index,
+                    height: this.current_height,
+                    timestamp: Date.now(),
+                    invocationId: args.invocationId,
+                };
+                txLogIndex = cache.tx_logs.push(txLog) - 1;
+                for (const inputId of inputs_index)
+                    cache.pending_spent_utxos[inputId] = txLogIndex;
+            }, args.inputs.map((output) => ({ change_reason: "spent", output })));
+        }
+        catch (e) {
+            await this.unpause();
+            throw e;
+        }
+        return txLogIndex;
+    }
+    // update the same row with the node answer. unlock the inputs on failure.
+    async finishInFlightSend(args) {
+        const ok = args.sendResult?.status === "OK" && args.error === undefined;
+        try {
+            await this.writeTxCache(async (cache) => {
+                const row = cache.tx_logs?.[args.txLogIndex];
+                if (!row)
+                    throw new Error("tx log missing");
+                if (args.invocationId)
+                    row.invocationId = args.invocationId;
+                if (args.signedTx)
+                    row.signed_tx = args.signedTx;
+                if (args.sendResult)
+                    row.sendResult = args.sendResult;
+                if (!ok) {
+                    row.error = args.error || args.sendResult?.reason || "send failed";
+                    for (const inputId of row.inputs_index) {
+                        if (cache.pending_spent_utxos?.[inputId] === args.txLogIndex)
+                            delete cache.pending_spent_utxos[inputId];
+                    }
+                }
+            }, []);
+        }
+        finally {
+            await this.unpause();
+        }
+    }
     async makeSignSendTransaction(params) {
         let maybeInputs = [];
         let maybeFeeEstimate;
         let maybeSendResult;
         let maybeSignedTx;
+        let txLogIndex;
         try {
             const { selectedInputs, feeEstimate } = await this.calculateFeeAndSelectInputs(params);
             maybeInputs = selectedInputs;
             maybeFeeEstimate = feeEstimate;
+            txLogIndex = await this.beginInFlightSend({
+                payments: params.payments,
+                inputs: selectedInputs,
+                feeEstimate,
+                invocationId: params.invocationId,
+            });
             const unsignedTx = await this.makeTransactionFromSelectedInputs(params.payments, selectedInputs, feeEstimate);
             const signedTx = await this.signTransaction(unsignedTx);
             maybeSignedTx = signedTx;
@@ -403,52 +482,29 @@ export class ScanCacheOpened {
             maybeSendResult = sendResult;
             if (sendResult.status !== "OK")
                 throw new Error("send raw transaction rpc returned error");
-            // before writing the scan cache, we stop the worker to avoid a race
-            await this.stopWorker();
-            // write txlog to cache + update pending_spent_utxos (affects stats + spendability)
-            await writeCacheFileDefaultLocationThrows({
-                primary_address: this.primary_address,
-                pathPrefix: this.pathPrefix,
-                writeCallback: async (cache) => {
-                    if (!cache.tx_logs)
-                        cache.tx_logs = [];
-                    if (!cache.pending_spent_utxos)
-                        cache.pending_spent_utxos = {};
-                    const inputs_index = selectedInputs.map((input) => String(input.index_on_blockchain));
-                    const txLog = {
-                        sendResult,
-                        feeEstimate,
-                        payments: params.payments,
-                        node_url: this.node_url,
-                        inputs_index,
-                        height: this.current_height,
-                        timestamp: Date.now(),
-                        invocationId: params.invocationId,
-                        signed_tx: signedTx,
-                    };
-                    const newLen = cache.tx_logs.push(txLog);
-                    const txLogIndex = newLen - 1;
-                    for (const inputId of inputs_index) {
-                        cache.pending_spent_utxos[inputId] = txLogIndex;
-                    }
-                },
-            });
-            const newCache = await readCacheFileDefaultLocation(this.primary_address, this.pathPrefix);
-            if (!newCache)
-                throw new Error(`cache not found for primary address: ${this.primary_address}, and path prefix: ${this.pathPrefix}`);
-            const changed_outputs = selectedInputs.map((input) => ({
-                change_reason: "spent",
-                output: input,
-            }));
-            await this.feed({
-                newCache,
-                changed_outputs,
+            await this.finishInFlightSend({
+                txLogIndex,
+                sendResult,
+                signedTx,
+                invocationId: params.invocationId,
             });
-            // restart the worker
-            await this.unpause();
             return sendResult;
         }
         catch (e) {
+            if (txLogIndex !== undefined && maybeSendResult?.status !== "OK") {
+                await this.finishInFlightSend({
+                    txLogIndex,
+                    sendResult: maybeSendResult,
+                    signedTx: maybeSignedTx,
+                    error: String(e || "unknown error"),
+                    invocationId: params.invocationId,
+                });
+                throw e;
+            }
+            if (txLogIndex !== undefined) {
+                await this.unpause();
+                throw e;
+            }
             // before writing the scan cache, we stop the worker to avoid a race
             await this.stopWorker();
             // write txlog error to cache
@@ -524,31 +580,41 @@ export class ScanCacheOpened {
         if (!inputs.length)
             throw new Error("no inputs selected");
         const feeEstimate = await this.getFeeEstimate();
-        const unsignedTx = await this.makeSweepTransactionFromSelectedInputs(params.address, inputs, feeEstimate);
-        const signedTx = await this.signTransaction(unsignedTx);
         const payments = [{ address: params.address, amount: "0" }];
-        const sendResult = await this.sendTransaction(signedTx);
-        if (sendResult.status !== "OK") {
-            await this.recordSend({
-                payments,
-                inputs,
-                signedTx,
-                feeEstimate,
-                sendResult,
-                error: "send raw transaction rpc returned error",
-                lockInputs: false,
-            });
-            throw new Error("send raw transaction rpc returned error");
-        }
-        await this.recordSend({
+        const txLogIndex = await this.beginInFlightSend({
             payments,
             inputs,
-            signedTx,
             feeEstimate,
-            sendResult,
-            lockInputs: true,
         });
-        return sendResult;
+        let sendResult;
+        let signedTx;
+        try {
+            const unsignedTx = await this.makeSweepTransactionFromSelectedInputs(params.address, inputs, feeEstimate);
+            signedTx = await this.signTransaction(unsignedTx);
+            sendResult = await this.sendTransaction(signedTx);
+            if (sendResult.status !== "OK")
+                throw new Error("send raw transaction rpc returned error");
+            await this.finishInFlightSend({
+                txLogIndex,
+                sendResult,
+                signedTx,
+            });
+            return sendResult;
+        }
+        catch (e) {
+            if (sendResult?.status !== "OK") {
+                await this.finishInFlightSend({
+                    txLogIndex,
+                    sendResult,
+                    signedTx,
+                    error: e instanceof Error ? e.message : String(e),
+                });
+            }
+            else {
+                await this.unpause();
+            }
+            throw e;
+        }
     }
     async rebroadcastTx(txLogIndex) {
         const txlog = this._cache.tx_logs?.[txLogIndex];
@@ -598,6 +664,9 @@ export class ScanCacheOpened {
                 continue;
             if (txlog.sendResult?.status === "OK")
                 continue;
+            // no node answer yet. this row is still in flight.
+            if (!txlog.sendResult && !txlog.error)
+                continue;
             const inputs = txlog.inputs_index
                 .map((id) => this._cache.outputs[id])
                 .filter((output) => output);
@@ -608,44 +677,6 @@ export class ScanCacheOpened {
         }
         return rows;
     }
-    async recordSend(args) {
-        await this.stopWorker();
-        await writeCacheFileDefaultLocationThrows({
-            primary_address: this.primary_address,
-            pathPrefix: this.pathPrefix,
-            writeCallback: async (cache) => {
-                if (!cache.tx_logs)
-                    cache.tx_logs = [];
-                if (!cache.pending_spent_utxos)
-                    cache.pending_spent_utxos = {};
-                const inputs_index = args.inputs.map((input) => String(input.index_on_blockchain));
-                const txLog = {
-                    sendResult: args.sendResult,
-                    error: args.error,
-                    feeEstimate: args.feeEstimate,
-                    payments: args.payments,
-                    node_url: this.node_url,
-                    inputs_index,
-                    height: this.current_height,
-                    timestamp: Date.now(),
-                    signed_tx: args.signedTx,
-                };
-                const txLogIndex = cache.tx_logs.push(txLog) - 1;
-                if (!args.lockInputs)
-                    return;
-                for (const inputId of inputs_index)
-                    cache.pending_spent_utxos[inputId] = txLogIndex;
-            },
-        });
-        const newCache = await readCacheFileDefaultLocation(this.primary_address, this.pathPrefix);
-        if (!newCache)
-            throw new Error("cache not found after send");
-        const changed_outputs = args.lockInputs
-            ? args.inputs.map((output) => ({ change_reason: "spent", output }))
-            : [];
-        await this.feed({ newCache, changed_outputs });
-        await this.unpause();
-    }
     async dismissSendPlate() {
         await this.stopWorker();
         await writeCacheFileDefaultLocationThrows({
@@ -751,7 +782,11 @@ export class ScanCacheOpened {
             delete this.worker;
             // drain coordinator first, then hard kill workers
             try {
-                await worker.shutdown();
+                // shutdown already races 5s. this race still returns if that promise never settles.
+                await Promise.race([
+                    worker.shutdown(),
+                    new Promise((resolve) => setTimeout(resolve, 5000)),
+                ]);
             }
             catch {
                 // still terminate below
@@ -925,17 +960,25 @@ export class ManyScanCachesOpened {
     }
     async changeNodeUrlAndStartHeight(node_url, start_height) {
         if (this.actionLogOpened.extensionMessageBus === "ui") {
-            await sendToBackground("worker.changeNodeUrlAndStartHeight", {
+            // the background owns the worker. it stops, then writes. do not write here first.
+            const result = await sendToBackground("worker.changeNodeUrlAndStartHeight", {
                 node_url,
                 start_height,
-            }).catch(() => { });
+            });
+            if (result &&
+                typeof result === "object" &&
+                "error" in result &&
+                result.error) {
+                throw new Error(String(result.error));
+            }
+            if (result == null)
+                throw new Error("background did not save the node url");
             return;
         }
         if (this.wallets.length === 0) {
-            if (node_url !== undefined)
-                await this._scanSettings.setNodeUrl(node_url);
-            if (start_height !== undefined)
-                await this._scanSettings.setStartHeight(start_height);
+            if (node_url !== undefined || start_height !== undefined) {
+                await this._scanSettings.setNodeUrlAndStartHeight(node_url, start_height);
+            }
             return;
         }
         await this.wallets[0].changeNodeUrlAndStartHeight(node_url, start_height);

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

@@ -218,8 +218,10 @@ export function unlockedAtHeight(output) {
 export function outputStatus(output, cache, current_height) {
     if (
     // order matters, check this before "spent" check + "pending" check
+    // tx log index 0 is a real lock. 0 must not count as missing.
     cache.pending_spent_utxos &&
-        cache.pending_spent_utxos[output.index_on_blockchain.toString()]) {
+        cache.pending_spent_utxos[output.index_on_blockchain.toString()] !==
+            undefined) {
         return { status: "prepending" };
     }
     if (typeof output.burned === "number") {

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

@@ -58,6 +58,7 @@ export declare function processTxlogInputs(txlog: TxLog, cache: ScanCache): {
     inputSum: bigint;
     alreadyRecognizedAsSpend: boolean;
 };
+export declare function txLogHoldsFunds(txlog: TxLog): boolean;
 export declare function processTxlogs(cache: ScanCache, stats: ScanStats): void;
 export declare function alignScanStatsWithCache(cache: ScanCache, view_pair: ViewPair, primary_address: string, pathPrefix?: string, highestSubaddressMinor?: number, current_scan_tip_height?: number): Promise<ScanStats>;
 export declare function resetStats(stats: ScanStats): void;

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

@@ -241,17 +241,33 @@ export function processTxlogInputs(txlog, cache) {
     }
     return { inputSum, alreadyRecognizedAsSpend };
 }
+// an in-flight row has no node answer yet. it still locks the inputs.
+export function txLogHoldsFunds(txlog) {
+    if (txlog.error)
+        return false;
+    if (!txlog.sendResult)
+        return true;
+    return txlog.sendResult.status === "OK";
+}
 export function processTxlogs(cache, stats) {
     for (const txlog of cache.tx_logs || []) {
-        if (!txlog ||
-            !txlog.sendResult ||
-            (txlog.sendResult && txlog.sendResult.status !== "OK"))
+        if (!txlog || !txLogHoldsFunds(txlog))
             continue;
         const { inputSum, alreadyRecognizedAsSpend } = processTxlogInputs(txlog, cache);
         if (alreadyRecognizedAsSpend)
             continue;
         const outWardPaymentSum = processTxlogPayments(txlog, cache);
-        stats.total_spendable_amount -= inputSum;
+        // locked inputs are already out of the spendable sum. do not subtract them again.
+        let alreadyExcluded = 0n;
+        for (const inputId of txlog.inputs_index) {
+            if (cache.pending_spent_utxos?.[inputId] === undefined)
+                continue;
+            const input = cache.outputs[inputId];
+            if (!input || typeof input.spent_in_tx_hash === "string")
+                continue;
+            alreadyExcluded += input.amount;
+        }
+        stats.total_spendable_amount -= inputSum - alreadyExcluded;
         const newPending = inputSum - outWardPaymentSum;
         stats.total_pending_amount += newPending;
     }

package/dist/scansettings/scanSettingsOpened.d.ts

@@ -20,6 +20,7 @@ export declare class ScanSettingsOpened {
     get pathPrefix(): string;
     setNodeUrl(node_url: string): Promise<void>;
     setStartHeight(start_height: number | null): Promise<void>;
+    setNodeUrlAndStartHeight(node_url?: string, start_height?: number | null): Promise<void>;
     setMerchantConfirmations(merchant_confirmations: number | undefined | null): Promise<void>;
     setCpuWorkerCount(cpu_worker_count: number | undefined | null): Promise<void>;
     setLogSettings(logs?: LogSetting | null, logs_include?: PossibleLogs[] | null, logs_exclude?: PossibleLogs[] | null): Promise<void>;

package/dist/scansettings/scanSettingsOpened.js

@@ -54,14 +54,21 @@ export class ScanSettingsOpened {
         return this._pathPrefix;
     }
     async setNodeUrl(node_url) {
-        await this.reload();
-        this._settings.node_url = ScanSettingsOpened._validateNodeUrl(node_url);
-        await this._persist();
+        await this.setNodeUrlAndStartHeight(node_url, undefined);
     }
     async setStartHeight(start_height) {
+        await this.setNodeUrlAndStartHeight(undefined, start_height);
+    }
+    // one read and one write. a second reload must not put the old url back.
+    async setNodeUrlAndStartHeight(node_url, start_height) {
         await this.reload();
-        ScanSettingsOpened._validateStartHeight(start_height);
-        this._settings.start_height = start_height;
+        if (node_url !== undefined) {
+            this._settings.node_url = ScanSettingsOpened._validateNodeUrl(node_url);
+        }
+        if (start_height !== undefined) {
+            ScanSettingsOpened._validateStartHeight(start_height);
+            this._settings.start_height = start_height;
+        }
         await this._persist();
     }
     async setMerchantConfirmations(merchant_confirmations) {
@@ -163,7 +170,7 @@ export class ScanSettingsOpened {
     async addViewWallet(primary_address, view_key, fields) {
         primary_address = primary_address.trim();
         view_key = view_key.trim();
-        ScanSettingsOpened._validateAddress(primary_address);
+        await ScanSettingsOpened._validateAddress(primary_address);
         ScanSettingsOpened._validateViewKey(view_key);
         ScanSettingsOpened._validateWalletName(fields?.wallet_name);
         ScanSettingsOpened._validateWalletSlot(fields?.wallet_slot);
@@ -308,8 +315,8 @@ export class ScanSettingsOpened {
                 `valid options are: ${[...valid].join(", ")}`);
         }
     }
-    static _validateAddress(address) {
-        const parsed = parseAddress(address);
+    static async _validateAddress(address) {
+        const parsed = await parseAddress(address);
         if ("error" in parsed) {
             throw new Error(`invalid monero address: ${address}`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spirobel/monero-wallet-api",
-  "version": "0.6.2",
+  "version": "0.6.7",
   "main": "dist/xmr3.js",
   "module": "dist/xmr3.js",
   "devDependencies": {