@spirobel/monero-wallet-api 0.6.4 → 0.6.5

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)
@@ -392,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;
@@ -408,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
@@ -529,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];
@@ -603,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);
@@ -613,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({

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/package.json

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