@atomiqlabs/lp-lib 14.0.0-dev.32 → 14.0.0-dev.34

package/dist/plugins/IPlugin.d.ts

@@ -1,5 +1,5 @@
 import { BitcoinRpc } from "@atomiqlabs/base";
-import { FromBtcLnRequestType, FromBtcRequestType, FromBtcTrustedRequestType, ISwapPrice, MultichainData, RequestData, SpvVaultSwapRequestType, SwapHandler, SwapHandlerType, ToBtcLnRequestType, ToBtcRequestType } from "..";
+import { FromBtcLnRequestType, FromBtcRequestType, FromBtcTrustedRequestType, ISwapPrice, MultichainData, RequestData, SpvVaultPostQuote, SpvVaultSwap, SpvVaultSwapRequestType, SwapHandler, SwapHandlerType, ToBtcLnRequestType, ToBtcRequestType } from "..";
 import { SwapHandlerSwap } from "../swaps/SwapHandlerSwap";
 import { Command } from "@atomiqlabs/server-base";
 import { FromBtcLnTrustedRequestType } from "../swaps/trusted/frombtcln_trusted/FromBtcLnTrusted";
@@ -128,6 +128,7 @@ export interface IPlugin {
         feePPM: bigint;
         networkFeeGetter: (amount: bigint) => Promise<bigint>;
     }): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | ToBtcPluginQuote>;
+    onHandlePostedFromBtcQuote?(swapType: SwapHandlerType.FROM_BTC_SPV, request: RequestData<SpvVaultPostQuote>, swap: SpvVaultSwap): Promise<QuoteThrow | null>;
     onVaultSelection?(chainIdentifier: string, totalSats: bigint, requestedAmount: {
         amount: bigint;
         token: string;

package/dist/plugins/PluginManager.d.ts

@@ -1,6 +1,6 @@
 import { BitcoinRpc, SwapData } from "@atomiqlabs/base";
 import { IPlugin, PluginQuote, QuoteAmountTooHigh, QuoteAmountTooLow, QuoteSetFees, QuoteThrow, ToBtcPluginQuote } from "./IPlugin";
-import { FromBtcLnRequestType, FromBtcRequestType, FromBtcTrustedRequestType, ISwapPrice, MultichainData, RequestData, SpvVaultSwapRequestType, SwapHandler, SwapHandlerType, ToBtcLnRequestType, ToBtcRequestType } from "..";
+import { FromBtcLnRequestType, FromBtcRequestType, FromBtcTrustedRequestType, ISwapPrice, MultichainData, RequestData, SpvVaultPostQuote, SpvVaultSwap, SpvVaultSwapRequestType, SwapHandler, SwapHandlerType, ToBtcLnRequestType, ToBtcRequestType } from "..";
 import { SwapHandlerSwap } from "../swaps/SwapHandlerSwap";
 import { FromBtcLnTrustedRequestType } from "../swaps/trusted/frombtcln_trusted/FromBtcLnTrusted";
 import { IBitcoinWallet } from "../wallets/IBitcoinWallet";
@@ -101,6 +101,7 @@ export declare class PluginManager {
         baseFeeInBtc: bigint;
         feePPM: bigint;
     }): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh>;
+    static onHandlePostedFromBtcQuote(swapType: SwapHandlerType.FROM_BTC_SPV, request: RequestData<SpvVaultPostQuote>, swap: SpvVaultSwap): Promise<QuoteThrow | null>;
     static onVaultSelection(chainIdentifier: string, totalSats: bigint, requestedAmount: {
         amount: bigint;
         token: string;

package/dist/plugins/PluginManager.js

@@ -214,6 +214,21 @@ class PluginManager {
         }
         return null;
     }
+    static async onHandlePostedFromBtcQuote(swapType, request, swap) {
+        for (let plugin of PluginManager.plugins.values()) {
+            try {
+                if (plugin.onHandlePostedFromBtcQuote != null) {
+                    const result = await plugin.onHandlePostedFromBtcQuote(swapType, request, swap);
+                    if (result != null && (0, IPlugin_1.isQuoteThrow)(result))
+                        return result;
+                }
+            }
+            catch (e) {
+                pluginLogger.error(plugin, "onHandlePostedFromBtcQuote(): plugin error", e);
+            }
+        }
+        return null;
+    }
     static async onVaultSelection(chainIdentifier, totalSats, requestedAmount, gasAmount) {
         for (let plugin of PluginManager.plugins.values()) {
             try {

package/dist/swaps/escrow/tobtc_abstract/ToBtcAbs.js

@@ -316,7 +316,7 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
             if (swap.sending)
                 return;
             //Bitcoin transaction was signed (maybe also sent)
-            const tx = await (0, BitcoinUtils_1.checkTransactionReplaced)(swap.txId, swap.btcRawTx, this.bitcoin);
+            const tx = await (0, BitcoinUtils_1.checkTransactionReplaced)(swap.txId, swap.btcRawTx, this.bitcoinRpc);
             const isTxSent = tx != null;
             if (!isTxSent) {
                 //Reset the state to COMMITED

package/dist/swaps/spv_vault_swap/SpvVault.d.ts

@@ -12,6 +12,7 @@ export declare class SpvVault<D extends SpvWithdrawalTransactionData = SpvWithdr
     readonly initialUtxo: string;
     readonly btcAddress: string;
     readonly pendingWithdrawals: D[];
+    readonly replacedWithdrawals: Map<number, D[]>;
     data: T;
     state: SpvVaultState;
     balances: SpvVaultTokenBalance[];
@@ -23,6 +24,7 @@ export declare class SpvVault<D extends SpvWithdrawalTransactionData = SpvWithdr
     update(event: SpvVaultOpenEvent | SpvVaultDepositEvent | SpvVaultCloseEvent | SpvVaultClaimEvent): void;
     addWithdrawal(withdrawalData: D): void;
     removeWithdrawal(withdrawalData: D): boolean;
+    doubleSpendPendingWithdrawal(withdrawalData: D): boolean;
     toRawAmounts(amounts: bigint[]): bigint[];
     fromRawAmounts(rawAmounts: bigint[]): bigint[];
     /**

package/dist/swaps/spv_vault_swap/SpvVault.js

@@ -19,6 +19,7 @@ class SpvVault extends base_1.Lockable {
             this.initialUtxo = vault.getUtxo();
             this.btcAddress = btcAddress;
             this.pendingWithdrawals = [];
+            this.replacedWithdrawals = new Map();
         }
         else {
             this.state = chainIdOrObj.state;
@@ -28,6 +29,12 @@ class SpvVault extends base_1.Lockable {
             this.btcAddress = chainIdOrObj.btcAddress;
             this.pendingWithdrawals = chainIdOrObj.pendingWithdrawals.map((base_1.SpvWithdrawalTransactionData.deserialize));
             this.scOpenTxs = chainIdOrObj.scOpenTxs;
+            this.replacedWithdrawals = new Map();
+            if (chainIdOrObj.replacedWithdrawals != null) {
+                chainIdOrObj.replacedWithdrawals.forEach((val) => {
+                    this.replacedWithdrawals.set(val[0], val[1].map((base_1.SpvWithdrawalTransactionData.deserialize)));
+                });
+            }
         }
         this.balances = this.data.calculateStateAfter(this.pendingWithdrawals).balances;
     }
@@ -36,6 +43,15 @@ class SpvVault extends base_1.Lockable {
             const processedWithdrawalIndex = this.pendingWithdrawals.findIndex(val => val.btcTx.txid === event.btcTxId);
             if (processedWithdrawalIndex !== -1)
                 this.pendingWithdrawals.splice(0, processedWithdrawalIndex + 1);
+            if (event instanceof base_1.SpvVaultClaimEvent) {
+                for (let key of this.replacedWithdrawals.keys()) {
+                    if (key <= event.withdrawCount)
+                        this.replacedWithdrawals.delete(key);
+                }
+            }
+            if (event instanceof base_1.SpvVaultCloseEvent) {
+                this.replacedWithdrawals.clear();
+            }
         }
         this.data.updateState(event);
         this.balances = this.data.calculateStateAfter(this.pendingWithdrawals).balances;
@@ -53,6 +69,19 @@ class SpvVault extends base_1.Lockable {
         this.balances = this.data.calculateStateAfter(this.pendingWithdrawals).balances;
         return true;
     }
+    doubleSpendPendingWithdrawal(withdrawalData) {
+        const index = this.pendingWithdrawals.indexOf(withdrawalData);
+        if (index === -1)
+            return false;
+        this.pendingWithdrawals.splice(index, 1);
+        this.balances = this.data.calculateStateAfter(this.pendingWithdrawals).balances;
+        const withdrawalIndex = this.data.getWithdrawalCount() + index + 1;
+        let arr = this.replacedWithdrawals.get(withdrawalIndex);
+        if (arr == null)
+            this.replacedWithdrawals.set(withdrawalIndex, arr = []);
+        arr.push(withdrawalData);
+        return true;
+    }
     toRawAmounts(amounts) {
         return amounts.map((amt, index) => {
             const tokenData = this.data.getTokenData()[index];
@@ -76,6 +105,10 @@ class SpvVault extends base_1.Lockable {
         return this.data.calculateStateAfter(this.pendingWithdrawals.filter(val => val.btcTx.confirmations >= 1)).balances;
     }
     serialize() {
+        const replacedWithdrawals = [];
+        this.replacedWithdrawals.forEach((value, key) => {
+            replacedWithdrawals.push([key, value.map(val => val.serialize())]);
+        });
         return {
             state: this.state,
             chainId: this.chainId,
@@ -83,6 +116,7 @@ class SpvVault extends base_1.Lockable {
             initialUtxo: this.initialUtxo,
             btcAddress: this.btcAddress,
             pendingWithdrawals: this.pendingWithdrawals.map(val => val.serialize()),
+            replacedWithdrawals,
             scOpenTxs: this.scOpenTxs
         };
     }

package/dist/swaps/spv_vault_swap/SpvVaultSwapHandler.js

@@ -13,6 +13,7 @@ const crypto_1 = require("crypto");
 const btc_signer_1 = require("@scure/btc-signer");
 const SpvVaults_1 = require("./SpvVaults");
 const BitcoinUtils_1 = require("../../utils/BitcoinUtils");
+const AmountAssertions_1 = require("../assertions/AmountAssertions");
 const TX_MAX_VSIZE = 16 * 1024;
 class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
     constructor(storageDirectory, vaultStorage, path, chainsData, swapPricing, bitcoin, bitcoinRpc, spvVaultSigner, config) {
@@ -105,7 +106,7 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
             const foundWithdrawal = vault.pendingWithdrawals.find(val => val.btcTx.txid === swap.btcTxId);
             let tx = foundWithdrawal?.btcTx;
             if (tx == null)
-                tx = await this.bitcoin.getWalletTransaction(swap.btcTxId);
+                tx = await this.bitcoinRpc.getTransaction(swap.btcTxId);
             if (tx == null) {
                 await this.removeSwapData(swap, SpvVaultSwap_1.SpvVaultSwapState.FAILED);
                 return;
@@ -128,7 +129,7 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
             const foundWithdrawal = vault.pendingWithdrawals.find(val => val.btcTx.txid === swap.btcTxId);
             let tx = foundWithdrawal?.btcTx;
             if (tx == null)
-                tx = await this.bitcoin.getWalletTransaction(swap.btcTxId);
+                tx = await this.bitcoinRpc.getTransaction(swap.btcTxId);
             if (tx == null) {
                 await this.removeSwapData(swap, SpvVaultSwap_1.SpvVaultSwapState.DOUBLE_SPENT);
                 return;
@@ -258,7 +259,11 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
             metadata.times.priceCalculated = Date.now();
             const totalBtcOutput = amountBD + amountBDgas;
             //Check if we have enough funds to honor the request
-            const vault = await this.Vaults.findVaultForSwap(chainIdentifier, totalBtcOutput, useToken, totalInToken, gasToken, totalInGasToken);
+            let vault;
+            do {
+                vault = await this.Vaults.findVaultForSwap(chainIdentifier, totalBtcOutput, useToken, totalInToken, gasToken, totalInGasToken);
+            } while (await this.Vaults.checkVaultReplacedTransactions(vault, true));
+            abortController.signal.throwIfAborted();
             metadata.times.vaultPicked = Date.now();
             //Create swap receive bitcoin address
             const btcFeeRate = await this.bitcoin.getFeeRate();
@@ -353,7 +358,6 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
                     msg: "Error parsing PSBT, hex format required!"
                 };
             }
-            //Check correct psbt
             for (let i = 1; i < transaction.inputsLength; i++) { //Skip first vault input
                 const txIn = transaction.getInput(i);
                 if ((0, BitcoinUtils_1.isLegacyInput)(txIn))
@@ -361,6 +365,12 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
                         code: 20514,
                         msg: "Legacy (pre-segwit) inputs in tx are not allowed!"
                     };
+            }
+            //Check the posted quote with the plugins
+            AmountAssertions_1.AmountAssertions.handlePluginErrorResponses(await PluginManager_1.PluginManager.onHandlePostedFromBtcQuote(this.type, { chainIdentifier: swap.chainIdentifier, raw: req, parsed: parsedBody, metadata }, swap));
+            //Check correct psbt
+            for (let i = 1; i < transaction.inputsLength; i++) { //Skip first vault input
+                const txIn = transaction.getInput(i);
                 //Check UTXOs exist and are unspent
                 if (await this.bitcoinRpc.isSpent(Buffer.from(txIn.txid).toString("hex") + ":" + txIn.index.toString(10)))
                     throw {
@@ -426,6 +436,7 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
                     code: 20516,
                     msg: "Bitcoin transaction size too large, maximum: " + TX_MAX_VSIZE + " actual: " + txVsize
                 };
+            await this.Vaults.checkVaultReplacedTransactions(vault, true);
             if (swap.vaultUtxo !== vault.getLatestUtxo()) {
                 throw {
                     code: 20510,

package/dist/swaps/spv_vault_swap/SpvVaults.d.ts

@@ -33,6 +33,13 @@ export declare class SpvVaults {
     }, import("@atomiqlabs/base").SpvVaultData<SpvWithdrawalTransactionData>>[]>;
     fundVault(vault: SpvVault, tokenAmounts: bigint[]): Promise<string>;
     withdrawFromVault(vault: SpvVault, tokenAmounts: bigint[], feeRate?: number): Promise<string>;
+    /**
+     * Call this to check whether some of the previously replaced transactions got re-introduced to the mempool
+     *
+     * @param vault
+     * @param save
+     */
+    checkVaultReplacedTransactions(vault: SpvVault, save?: boolean): Promise<boolean>;
     checkVaults(): Promise<void>;
     claimWithdrawals(vault: SpvVault, withdrawal: SpvWithdrawalTransactionData[]): Promise<boolean>;
     getVault(chainId: string, owner: string, vaultId: bigint): Promise<SpvVault<SpvWithdrawalTransactionData & {

package/dist/swaps/spv_vault_swap/SpvVaults.js

@@ -177,32 +177,119 @@ class SpvVaults {
             amount: 0n,
             script: opReturnScript
         });
-        psbt = await this.bitcoin.fundPsbt(psbt, feeRate);
-        if (psbt.inputsLength < 2)
-            throw new Error("PSBT needs at least 2 inputs!");
-        psbt.updateInput(0, { sequence: 0x80000000 });
-        psbt.updateInput(1, { sequence: 0x80000000 });
-        psbt = await this.vaultSigner.signPsbt(vault.chainId, vault.data.getVaultId(), psbt, [0]);
-        const res = await this.bitcoin.signPsbt(psbt);
-        const parsedTransaction = await this.bitcoinRpc.parseTransaction(res.raw);
-        const withdrawalData = await spvVaultContract.getWithdrawalData(parsedTransaction);
-        if (withdrawalData.getSpentVaultUtxo() !== vault.getLatestUtxo()) {
-            throw new Error("Latest vault UTXO already spent! Please try again later.");
+        let withdrawalTxId = null;
+        await this.bitcoin.execute(async () => {
+            psbt = await this.bitcoin.fundPsbt(psbt, feeRate);
+            if (psbt.inputsLength < 2)
+                throw new Error("PSBT needs at least 2 inputs!");
+            psbt.updateInput(0, { sequence: 0x80000000 });
+            psbt.updateInput(1, { sequence: 0x80000000 });
+            psbt = await this.vaultSigner.signPsbt(vault.chainId, vault.data.getVaultId(), psbt, [0]);
+            const res = await this.bitcoin.signPsbt(psbt);
+            withdrawalTxId = res.txId;
+            const parsedTransaction = await this.bitcoinRpc.parseTransaction(res.raw);
+            const withdrawalData = await spvVaultContract.getWithdrawalData(parsedTransaction);
+            if (withdrawalData.getSpentVaultUtxo() !== vault.getLatestUtxo()) {
+                throw new Error("Latest vault UTXO already spent! Please try again later.");
+            }
+            withdrawalData.sending = true;
+            vault.addWithdrawal(withdrawalData);
+            await this.saveVault(vault);
+            try {
+                await this.bitcoin.sendRawTransaction(res.raw);
+                withdrawalData.sending = false;
+            }
+            catch (e) {
+                withdrawalData.sending = false;
+                vault.removeWithdrawal(withdrawalData);
+                await this.saveVault(vault);
+                throw e;
+            }
+        });
+        return withdrawalTxId;
+    }
+    /**
+     * Call this to check whether some of the previously replaced transactions got re-introduced to the mempool
+     *
+     * @param vault
+     * @param save
+     */
+    async checkVaultReplacedTransactions(vault, save) {
+        const { spvVaultContract } = this.chains.chains[vault.chainId];
+        const initialVaultWithdrawalCount = vault.data.getWithdrawalCount();
+        let latestWithdrawalIndex = initialVaultWithdrawalCount;
+        const newPendingTxns = [];
+        const reintroducedTxIds = new Set();
+        for (let [withdrawalIndex, replacedWithdrawalGroup] of vault.replacedWithdrawals) {
+            if (withdrawalIndex <= latestWithdrawalIndex)
+                continue; //Don't check txns that should already be included
+            for (let replacedWithdrawal of replacedWithdrawalGroup) {
+                if (reintroducedTxIds.has(replacedWithdrawal.getTxId()))
+                    continue;
+                const tx = await this.bitcoinRpc.getTransaction(replacedWithdrawal.getTxId());
+                if (tx == null)
+                    continue;
+                //Re-introduce transaction to the pending withdrawals list
+                if (withdrawalIndex > latestWithdrawalIndex) {
+                    const txChain = [replacedWithdrawal];
+                    withdrawalIndex--;
+                    while (withdrawalIndex > latestWithdrawalIndex) {
+                        const tx = await this.bitcoinRpc.getTransaction(txChain[0].getSpentVaultUtxo().split(":")[0]);
+                        if (tx == null)
+                            break;
+                        reintroducedTxIds.add(tx.txid);
+                        txChain.unshift(await spvVaultContract.getWithdrawalData(tx));
+                        withdrawalIndex--;
+                    }
+                    if (withdrawalIndex > latestWithdrawalIndex) {
+                        this.logger.warn(`checkVaultReplacedTransactions(${vault.getIdentifier()}): Tried to re-introduce previously replaced TX, but one of txns in the chain not found!`);
+                        continue;
+                    }
+                    newPendingTxns.push(...txChain);
+                    latestWithdrawalIndex += txChain.length;
+                    break; //Don't check other txns at the same withdrawal index
+                }
+                else {
+                    this.logger.warn(`checkVaultReplacedTransactions(${vault.getIdentifier()}): Tried to re-introduce previously replaced TX, but vault has already processed such withdrawal!`);
+                }
+            }
         }
-        withdrawalData.sending = true;
-        vault.addWithdrawal(withdrawalData);
-        await this.saveVault(vault);
+        if (newPendingTxns.length === 0)
+            return false;
+        if (initialVaultWithdrawalCount !== vault.data.getWithdrawalCount()) {
+            this.logger.warn(`checkVaultReplacedTransactions(${vault.getIdentifier()}): Not saving vault after checking replaced transactions, due to withdrawal count changed!`);
+            return false;
+        }
+        const backup = vault.pendingWithdrawals.splice(0, newPendingTxns.length);
+        const txsToAddOnTop = vault.pendingWithdrawals.splice(0, vault.pendingWithdrawals.length);
         try {
-            await this.bitcoin.sendRawTransaction(res.raw);
-            withdrawalData.sending = false;
+            newPendingTxns.forEach(val => vault.addWithdrawal(val));
+            txsToAddOnTop.forEach(val => vault.addWithdrawal(val));
+            for (let i = 0; i < newPendingTxns.length; i++) {
+                const withdrawalIndex = initialVaultWithdrawalCount + i + 1;
+                const arr = vault.replacedWithdrawals.get(withdrawalIndex);
+                if (arr == null)
+                    continue;
+                const index = arr.indexOf(newPendingTxns[i]);
+                if (index === -1) {
+                    this.logger.warn(`checkVaultReplacedTransactions(${vault.getIdentifier()}): Cannot remove re-introduced tx ${newPendingTxns[i].getTxId()}, not found in the respective array!`);
+                    continue;
+                }
+                arr.splice(index, 1);
+                if (arr.length === 0)
+                    vault.replacedWithdrawals.delete(withdrawalIndex);
+            }
+            this.logger.info(`checkVaultReplacedTransactions(${vault.getIdentifier()}): Re-introduced back ${newPendingTxns.length} txns that were re-added to the mempool!`);
+            if (save)
+                await this.saveVault(vault);
+            return true;
         }
         catch (e) {
-            withdrawalData.sending = false;
-            vault.removeWithdrawal(withdrawalData);
-            await this.saveVault(vault);
-            throw e;
+            this.logger.error(`checkVaultReplacedTransactions(${vault.getIdentifier()}): Failed to update the vault with new pending txns (rolling back): `, e);
+            //Rollback the pending withdrawals
+            vault.pendingWithdrawals.push(...backup, ...txsToAddOnTop);
+            return false;
         }
-        return res.txId;
     }
     async checkVaults() {
         const vaults = Object.keys(this.vaultStorage.data).map(key => this.vaultStorage.data[key]);
@@ -268,24 +355,23 @@ class SpvVaults {
                 continue;
             }
             if (vault.state === SpvVault_1.SpvVaultState.OPENED) {
-                let changed = false;
+                let changed = await this.checkVaultReplacedTransactions(vault);
                 //Check if some of the pendingWithdrawals got confirmed
                 let latestOwnWithdrawalIndex = -1;
                 let latestConfirmedWithdrawalIndex = -1;
-                for (let i = 0; i < vault.pendingWithdrawals.length; i++) {
+                for (let i = vault.pendingWithdrawals.length - 1; i >= 0; i--) {
                     const pendingWithdrawal = vault.pendingWithdrawals[i];
                     if (pendingWithdrawal.sending)
                         continue;
                     //Check all the pending withdrawals that were not finalized yet
-                    const btcTx = await (0, BitcoinUtils_1.checkTransactionReplacedRpc)(pendingWithdrawal.btcTx.txid, pendingWithdrawal.btcTx.raw, this.bitcoinRpc);
+                    const btcTx = await (0, BitcoinUtils_1.checkTransactionReplaced)(pendingWithdrawal.btcTx.txid, pendingWithdrawal.btcTx.raw, this.bitcoinRpc);
                     if (btcTx == null) {
                         //Probable double-spend, remove from pending withdrawals
-                        const index = vault.pendingWithdrawals.indexOf(pendingWithdrawal);
-                        if (index === -1) {
+                        if (!vault.doubleSpendPendingWithdrawal(pendingWithdrawal)) {
                             this.logger.warn("checkVaults(): Tried to remove pending withdrawal txId: " + pendingWithdrawal.btcTx.txid + ", but doesn't exist anymore!");
                         }
                         else {
-                            vault.pendingWithdrawals.splice(index, 1);
+                            this.logger.info("checkVaults(): Successfully removed withdrawal txId: " + pendingWithdrawal.btcTx.txid + ", due to being replaced in the mempool!");
                         }
                         changed = true;
                     }

package/dist/swaps/trusted/frombtc_trusted/FromBtcTrusted.js

@@ -608,7 +608,7 @@ class FromBtcTrusted extends SwapHandler_1.SwapHandler {
     }
     async checkDoubleSpends() {
         for (let swap of this.doubleSpendWatchdogSwaps.keys()) {
-            const tx = await this.bitcoin.getWalletTransaction(swap.txId);
+            const tx = await this.bitcoinRpc.getTransaction(swap.txId);
             if (tx == null) {
                 this.swapLogger.debug(swap, "checkDoubleSpends(): Swap was double spent, burning... - original txId: " + swap.txId);
                 this.processPastSwap(swap, null, null);

package/dist/utils/BitcoinUtils.d.ts

@@ -1,6 +1,4 @@
 import { TransactionInput } from "@scure/btc-signer/psbt";
 import { BitcoinRpc, BtcTx } from "@atomiqlabs/base";
-import { IBitcoinWallet } from "../wallets/IBitcoinWallet";
 export declare function isLegacyInput(input: TransactionInput): boolean;
-export declare function checkTransactionReplaced(txId: string, txRaw: string, bitcoin: IBitcoinWallet): Promise<BtcTx>;
-export declare function checkTransactionReplacedRpc(txId: string, txRaw: string, bitcoin: BitcoinRpc<any>): Promise<BtcTx>;
+export declare function checkTransactionReplaced(txId: string, txRaw: string, bitcoin: BitcoinRpc<any>): Promise<BtcTx>;

package/dist/utils/BitcoinUtils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkTransactionReplacedRpc = exports.checkTransactionReplaced = exports.isLegacyInput = void 0;
+exports.checkTransactionReplaced = exports.isLegacyInput = void 0;
 const utxo_1 = require("@scure/btc-signer/utxo");
 const btc_signer_1 = require("@scure/btc-signer");
 const Utils_1 = require("./Utils");
@@ -46,20 +46,6 @@ function isLegacyInput(input) {
 }
 exports.isLegacyInput = isLegacyInput;
 async function checkTransactionReplaced(txId, txRaw, bitcoin) {
-    const existingTx = await bitcoin.getWalletTransaction(txId);
-    if (existingTx != null)
-        return existingTx;
-    //Try to re-broadcast
-    try {
-        await bitcoin.sendRawTransaction(txRaw);
-    }
-    catch (e) {
-        logger.error("checkTransactionReplaced(" + txId + "): Error when trying to re-broadcast raw transaction: ", e);
-    }
-    return await bitcoin.getWalletTransaction(txId);
-}
-exports.checkTransactionReplaced = checkTransactionReplaced;
-async function checkTransactionReplacedRpc(txId, txRaw, bitcoin) {
     const existingTx = await bitcoin.getTransaction(txId);
     if (existingTx != null)
         return existingTx;
@@ -72,4 +58,4 @@ async function checkTransactionReplacedRpc(txId, txRaw, bitcoin) {
     }
     return await bitcoin.getTransaction(txId);
 }
-exports.checkTransactionReplacedRpc = checkTransactionReplacedRpc;
+exports.checkTransactionReplaced = checkTransactionReplaced;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/lp-lib",
-  "version": "14.0.0-dev.32",
+  "version": "14.0.0-dev.34",
   "description": "Main functionality implementation for atomiq LP node",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",
@@ -23,7 +23,7 @@
   "license": "ISC",
   "dependencies": {
     "@atomiqlabs/base": "^10.0.0-dev.10",
-    "@atomiqlabs/server-base": "2.0.0",
+    "@atomiqlabs/server-base": "^3.0.0",
     "@scure/btc-signer": "1.6.0",
     "express": "4.21.1",
     "promise-queue-ts": "0.0.1"

package/src/plugins/IPlugin.ts

@@ -1,8 +1,8 @@
-import {BitcoinRpc, SpvWithdrawalTransactionData, SwapData} from "@atomiqlabs/base";
+import {BitcoinRpc} from "@atomiqlabs/base";
 import {
     FromBtcLnRequestType,
     FromBtcRequestType, FromBtcTrustedRequestType,
-    ISwapPrice, MultichainData, RequestData, SpvVaultSwapRequestType,
+    ISwapPrice, MultichainData, RequestData, SpvVaultPostQuote, SpvVaultSwap, SpvVaultSwapRequestType,
     SwapHandler, SwapHandlerType,
     ToBtcLnRequestType,
     ToBtcRequestType
@@ -151,6 +151,12 @@ export interface IPlugin {
         fees: {baseFeeInBtc: bigint, feePPM: bigint, networkFeeGetter: (amount: bigint) => Promise<bigint>}
     ): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | ToBtcPluginQuote>;
 
+    onHandlePostedFromBtcQuote?(
+        swapType: SwapHandlerType.FROM_BTC_SPV,
+        request: RequestData<SpvVaultPostQuote>,
+        swap: SpvVaultSwap
+    ): Promise<QuoteThrow | null>;
+
     onVaultSelection?(
         chainIdentifier: string,
         totalSats: bigint,

package/src/plugins/PluginManager.ts

@@ -1,4 +1,4 @@
-import {BitcoinRpc, SpvWithdrawalTransactionData, SwapData} from "@atomiqlabs/base";
+import {BitcoinRpc, SwapData} from "@atomiqlabs/base";
 import {
     IPlugin, isPluginQuote, isQuoteAmountTooHigh, isQuoteAmountTooLow, isQuoteSetFees,
     isQuoteThrow, isToBtcPluginQuote, PluginQuote,
@@ -10,7 +10,7 @@ import {
 import {
     FromBtcLnRequestType,
     FromBtcRequestType, FromBtcTrustedRequestType,
-    ISwapPrice, MultichainData, RequestData, SpvVaultSwapRequestType,
+    ISwapPrice, MultichainData, RequestData, SpvVaultPostQuote, SpvVaultSwap, SpvVaultSwapRequestType,
     SwapHandler, SwapHandlerType,
     ToBtcLnRequestType,
     ToBtcRequestType
@@ -291,6 +291,24 @@ export class PluginManager {
         return null;
     }
 
+    static async onHandlePostedFromBtcQuote(
+        swapType: SwapHandlerType.FROM_BTC_SPV,
+        request: RequestData<SpvVaultPostQuote>,
+        swap: SpvVaultSwap
+    ): Promise<QuoteThrow | null> {
+        for(let plugin of PluginManager.plugins.values()) {
+            try {
+                if(plugin.onHandlePostedFromBtcQuote!=null) {
+                    const result = await plugin.onHandlePostedFromBtcQuote(swapType, request, swap);
+                    if(result!=null && isQuoteThrow(result)) return result;
+                }
+            } catch (e) {
+                pluginLogger.error(plugin, "onHandlePostedFromBtcQuote(): plugin error", e);
+            }
+        }
+        return null;
+    }
+
     static async onVaultSelection(
         chainIdentifier: string,
         totalSats: bigint,

package/src/swaps/escrow/tobtc_abstract/ToBtcAbs.ts

@@ -404,7 +404,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
         if(swap.state===ToBtcSwapState.BTC_SENDING) {
             if(swap.sending) return;
             //Bitcoin transaction was signed (maybe also sent)
-            const tx = await checkTransactionReplaced(swap.txId, swap.btcRawTx, this.bitcoin);
+            const tx = await checkTransactionReplaced(swap.txId, swap.btcRawTx, this.bitcoinRpc);
 
             const isTxSent = tx!=null;
             if(!isTxSent) {

package/src/swaps/spv_vault_swap/SpvVault.ts

@@ -28,6 +28,7 @@ export class SpvVault<
     readonly btcAddress: string;
 
     readonly pendingWithdrawals: D[];
+    readonly replacedWithdrawals: Map<number, D[]>;
     data: T;
 
     state: SpvVaultState;
@@ -47,6 +48,7 @@ export class SpvVault<
             this.initialUtxo = vault.getUtxo();
             this.btcAddress = btcAddress;
             this.pendingWithdrawals = [];
+            this.replacedWithdrawals = new Map();
         } else {
             this.state = chainIdOrObj.state;
             this.chainId = chainIdOrObj.chainId;
@@ -55,6 +57,12 @@ export class SpvVault<
             this.btcAddress = chainIdOrObj.btcAddress;
             this.pendingWithdrawals = chainIdOrObj.pendingWithdrawals.map(SpvWithdrawalTransactionData.deserialize<D>);
             this.scOpenTxs = chainIdOrObj.scOpenTxs;
+            this.replacedWithdrawals = new Map();
+            if(chainIdOrObj.replacedWithdrawals!=null) {
+                chainIdOrObj.replacedWithdrawals.forEach((val: [number, any[]]) => {
+                    this.replacedWithdrawals.set(val[0], val[1].map(SpvWithdrawalTransactionData.deserialize<D>));
+                });
+            }
         }
         this.balances = this.data.calculateStateAfter(this.pendingWithdrawals).balances;
     }
@@ -63,6 +71,14 @@ export class SpvVault<
         if(event instanceof SpvVaultClaimEvent || event instanceof SpvVaultCloseEvent) {
             const processedWithdrawalIndex = this.pendingWithdrawals.findIndex(val => val.btcTx.txid === event.btcTxId);
             if(processedWithdrawalIndex!==-1) this.pendingWithdrawals.splice(0, processedWithdrawalIndex + 1);
+            if(event instanceof SpvVaultClaimEvent) {
+                for(let key of this.replacedWithdrawals.keys()) {
+                    if(key<=event.withdrawCount) this.replacedWithdrawals.delete(key);
+                }
+            }
+            if(event instanceof SpvVaultCloseEvent) {
+                this.replacedWithdrawals.clear();
+            }
         }
         this.data.updateState(event);
         this.balances = this.data.calculateStateAfter(this.pendingWithdrawals).balances;
@@ -82,6 +98,19 @@ export class SpvVault<
         return true;
     }
 
+    doubleSpendPendingWithdrawal(withdrawalData: D): boolean {
+        const index = this.pendingWithdrawals.indexOf(withdrawalData);
+        if(index===-1) return false;
+        this.pendingWithdrawals.splice(index, 1);
+        this.balances = this.data.calculateStateAfter(this.pendingWithdrawals).balances;
+
+        const withdrawalIndex = this.data.getWithdrawalCount()+index+1;
+        let arr = this.replacedWithdrawals.get(withdrawalIndex);
+        if(arr==null) this.replacedWithdrawals.set(withdrawalIndex, arr = []);
+        arr.push(withdrawalData);
+        return true;
+    }
+
     toRawAmounts(amounts: bigint[]): bigint[] {
         return amounts.map((amt, index) => {
             const tokenData = this.data.getTokenData()[index];
@@ -106,6 +135,11 @@ export class SpvVault<
     }
 
     serialize(): any {
+        const replacedWithdrawals: [number, any[]][] = [];
+        this.replacedWithdrawals.forEach((value, key) => {
+            replacedWithdrawals.push([key, value.map(val => val.serialize())])
+        });
+
         return {
             state: this.state,
             chainId: this.chainId,
@@ -113,6 +147,7 @@ export class SpvVault<
             initialUtxo: this.initialUtxo,
             btcAddress: this.btcAddress,
             pendingWithdrawals: this.pendingWithdrawals.map(val => val.serialize()),
+            replacedWithdrawals,
             scOpenTxs: this.scOpenTxs
         }
     }

package/src/swaps/spv_vault_swap/SpvVaultSwapHandler.ts

@@ -27,9 +27,10 @@ import {ServerParamEncoder} from "../../utils/paramcoders/server/ServerParamEnco
 import {FieldTypeEnum} from "../../utils/paramcoders/SchemaVerifier";
 import {FromBtcAmountAssertions} from "../assertions/FromBtcAmountAssertions";
 import {randomBytes} from "crypto";
-import {getInputType, OutScript, Transaction} from "@scure/btc-signer";
+import {Transaction} from "@scure/btc-signer";
 import {SpvVaults, VAULT_DUST_AMOUNT} from "./SpvVaults";
-import {checkTransactionReplaced, isLegacyInput} from "../../utils/BitcoinUtils";
+import {isLegacyInput} from "../../utils/BitcoinUtils";
+import {AmountAssertions} from "../assertions/AmountAssertions";
 
 export type SpvVaultSwapHandlerConfig = SwapBaseConfig & {
     vaultsCheckInterval: number,
@@ -170,7 +171,7 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
             const vault = await this.Vaults.getVault(swap.chainIdentifier, swap.vaultOwner, swap.vaultId);
             const foundWithdrawal = vault.pendingWithdrawals.find(val => val.btcTx.txid === swap.btcTxId);
             let tx = foundWithdrawal?.btcTx;
-            if(tx==null) tx = await this.bitcoin.getWalletTransaction(swap.btcTxId);
+            if(tx==null) tx = await this.bitcoinRpc.getTransaction(swap.btcTxId);
 
             if(tx==null) {
                 await this.removeSwapData(swap, SpvVaultSwapState.FAILED);
@@ -191,7 +192,7 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
             const vault = await this.Vaults.getVault(swap.chainIdentifier, swap.vaultOwner, swap.vaultId);
             const foundWithdrawal = vault.pendingWithdrawals.find(val => val.btcTx.txid === swap.btcTxId);
             let tx = foundWithdrawal?.btcTx;
-            if(tx==null) tx = await this.bitcoin.getWalletTransaction(swap.btcTxId);
+            if(tx==null) tx = await this.bitcoinRpc.getTransaction(swap.btcTxId);
 
             if(tx==null) {
                 await this.removeSwapData(swap, SpvVaultSwapState.DOUBLE_SPENT);
@@ -354,7 +355,11 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
             const totalBtcOutput = amountBD + amountBDgas;
 
             //Check if we have enough funds to honor the request
-            const vault = await this.Vaults.findVaultForSwap(chainIdentifier, totalBtcOutput, useToken, totalInToken, gasToken, totalInGasToken);
+            let vault: SpvVault;
+            do {
+                vault = await this.Vaults.findVaultForSwap(chainIdentifier, totalBtcOutput, useToken, totalInToken, gasToken, totalInGasToken);
+            } while (await this.Vaults.checkVaultReplacedTransactions(vault, true));
+            abortController.signal.throwIfAborted();
             metadata.times.vaultPicked = Date.now();
 
             //Create swap receive bitcoin address
@@ -480,13 +485,24 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
                 };
             }
 
-            //Check correct psbt
             for(let i=1;i<transaction.inputsLength;i++) { //Skip first vault input
                 const txIn = transaction.getInput(i);
-                if(isLegacyInput(txIn)) throw {
+                if (isLegacyInput(txIn)) throw {
                     code: 20514,
                     msg: "Legacy (pre-segwit) inputs in tx are not allowed!"
                 };
+            }
+
+            //Check the posted quote with the plugins
+            AmountAssertions.handlePluginErrorResponses(await PluginManager.onHandlePostedFromBtcQuote(
+                this.type,
+                {chainIdentifier: swap.chainIdentifier, raw: req, parsed: parsedBody, metadata},
+                swap
+            ));
+
+            //Check correct psbt
+            for(let i=1;i<transaction.inputsLength;i++) { //Skip first vault input
+                const txIn = transaction.getInput(i);
                 //Check UTXOs exist and are unspent
                 if(await this.bitcoinRpc.isSpent(Buffer.from(txIn.txid).toString("hex")+":"+txIn.index.toString(10))) throw {
                     code: 20515,
@@ -558,6 +574,7 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
                 msg: "Bitcoin transaction size too large, maximum: "+TX_MAX_VSIZE+" actual: "+txVsize
             };
 
+            await this.Vaults.checkVaultReplacedTransactions(vault, true);
             if(swap.vaultUtxo!==vault.getLatestUtxo()) {
                 throw {
                     code: 20510,

package/src/swaps/spv_vault_swap/SpvVaults.ts

@@ -15,7 +15,7 @@ import {ISpvVaultSigner} from "../../wallets/ISpvVaultSigner";
 import {AmountAssertions} from "../assertions/AmountAssertions";
 import {MultichainData} from "../SwapHandler";
 import {Transaction} from "@scure/btc-signer";
-import {checkTransactionReplacedRpc} from "../../utils/BitcoinUtils";
+import {checkTransactionReplaced} from "../../utils/BitcoinUtils";
 
 export const VAULT_DUST_AMOUNT = 600;
 const VAULT_INIT_CONFIRMATIONS = 2;
@@ -227,34 +227,120 @@ export class SpvVaults {
             script: opReturnScript
         });
 
-        psbt = await this.bitcoin.fundPsbt(psbt, feeRate);
-        if(psbt.inputsLength<2) throw new Error("PSBT needs at least 2 inputs!");
-        psbt.updateInput(0, {sequence: 0x80000000});
-        psbt.updateInput(1, {sequence: 0x80000000});
-        psbt = await this.vaultSigner.signPsbt(vault.chainId, vault.data.getVaultId(), psbt, [0]);
-        const res = await this.bitcoin.signPsbt(psbt);
+        let withdrawalTxId: string = null;
+        await this.bitcoin.execute(async () => {
+            psbt = await this.bitcoin.fundPsbt(psbt, feeRate);
+            if(psbt.inputsLength<2) throw new Error("PSBT needs at least 2 inputs!");
+            psbt.updateInput(0, {sequence: 0x80000000});
+            psbt.updateInput(1, {sequence: 0x80000000});
+            psbt = await this.vaultSigner.signPsbt(vault.chainId, vault.data.getVaultId(), psbt, [0]);
+            const res = await this.bitcoin.signPsbt(psbt);
+            withdrawalTxId = res.txId;
+
+            const parsedTransaction = await this.bitcoinRpc.parseTransaction(res.raw);
+            const withdrawalData = await spvVaultContract.getWithdrawalData(parsedTransaction);
+
+            if(withdrawalData.getSpentVaultUtxo()!==vault.getLatestUtxo()) {
+                throw new Error("Latest vault UTXO already spent! Please try again later.");
+            }
+            (withdrawalData as any).sending = true;
+            vault.addWithdrawal(withdrawalData);
+            await this.saveVault(vault);
 
-        const parsedTransaction = await this.bitcoinRpc.parseTransaction(res.raw);
-        const withdrawalData = await spvVaultContract.getWithdrawalData(parsedTransaction);
+            try {
+                await this.bitcoin.sendRawTransaction(res.raw);
+                (withdrawalData as any).sending = false;
+            } catch (e) {
+                (withdrawalData as any).sending = false;
+                vault.removeWithdrawal(withdrawalData);
+                await this.saveVault(vault);
+                throw e;
+            }
+        });
+
+        return withdrawalTxId;
+    }
 
-        if(withdrawalData.getSpentVaultUtxo()!==vault.getLatestUtxo()) {
-            throw new Error("Latest vault UTXO already spent! Please try again later.");
+    /**
+     * Call this to check whether some of the previously replaced transactions got re-introduced to the mempool
+     *
+     * @param vault
+     * @param save
+     */
+    async checkVaultReplacedTransactions(vault: SpvVault, save?: boolean): Promise<boolean> {
+        const {spvVaultContract} = this.chains.chains[vault.chainId];
+
+        const initialVaultWithdrawalCount = vault.data.getWithdrawalCount();
+
+        let latestWithdrawalIndex = initialVaultWithdrawalCount;
+        const newPendingTxns: SpvWithdrawalTransactionData[] = [];
+        const reintroducedTxIds: Set<string> = new Set();
+        for(let [withdrawalIndex, replacedWithdrawalGroup] of vault.replacedWithdrawals) {
+            if(withdrawalIndex<=latestWithdrawalIndex) continue; //Don't check txns that should already be included
+
+            for(let replacedWithdrawal of replacedWithdrawalGroup) {
+                if(reintroducedTxIds.has(replacedWithdrawal.getTxId())) continue;
+                const tx = await this.bitcoinRpc.getTransaction(replacedWithdrawal.getTxId());
+                if(tx==null) continue;
+
+                //Re-introduce transaction to the pending withdrawals list
+                if(withdrawalIndex>latestWithdrawalIndex) {
+                    const txChain: SpvWithdrawalTransactionData[] = [replacedWithdrawal];
+                    withdrawalIndex--;
+                    while(withdrawalIndex>latestWithdrawalIndex) {
+                        const tx = await this.bitcoinRpc.getTransaction(txChain[0].getSpentVaultUtxo().split(":")[0]);
+                        if(tx==null) break;
+                        reintroducedTxIds.add(tx.txid);
+                        txChain.unshift(await spvVaultContract.getWithdrawalData(tx));
+                        withdrawalIndex--;
+                    }
+                    if(withdrawalIndex>latestWithdrawalIndex) {
+                        this.logger.warn(`checkVaultReplacedTransactions(${vault.getIdentifier()}): Tried to re-introduce previously replaced TX, but one of txns in the chain not found!`);
+                        continue;
+                    }
+                    newPendingTxns.push(...txChain);
+                    latestWithdrawalIndex += txChain.length;
+                    break; //Don't check other txns at the same withdrawal index
+                } else {
+                    this.logger.warn(`checkVaultReplacedTransactions(${vault.getIdentifier()}): Tried to re-introduce previously replaced TX, but vault has already processed such withdrawal!`);
+                }
+            }
         }
-        (withdrawalData as any).sending = true;
-        vault.addWithdrawal(withdrawalData);
-        await this.saveVault(vault);
+
+        if(newPendingTxns.length===0) return false;
+
+        if(initialVaultWithdrawalCount!==vault.data.getWithdrawalCount()) {
+            this.logger.warn(`checkVaultReplacedTransactions(${vault.getIdentifier()}): Not saving vault after checking replaced transactions, due to withdrawal count changed!`);
+            return false;
+        }
+
+        const backup = vault.pendingWithdrawals.splice(0, newPendingTxns.length);
+        const txsToAddOnTop = vault.pendingWithdrawals.splice(0, vault.pendingWithdrawals.length);
 
         try {
-            await this.bitcoin.sendRawTransaction(res.raw);
-            (withdrawalData as any).sending = false;
+            newPendingTxns.forEach(val => vault.addWithdrawal(val));
+            txsToAddOnTop.forEach(val => vault.addWithdrawal(val));
+            for(let i=0;i<newPendingTxns.length;i++) {
+                const withdrawalIndex = initialVaultWithdrawalCount+i+1;
+                const arr = vault.replacedWithdrawals.get(withdrawalIndex);
+                if(arr==null) continue;
+                const index = arr.indexOf(newPendingTxns[i]);
+                if(index===-1) {
+                    this.logger.warn(`checkVaultReplacedTransactions(${vault.getIdentifier()}): Cannot remove re-introduced tx ${newPendingTxns[i].getTxId()}, not found in the respective array!`);
+                    continue;
+                }
+                arr.splice(index, 1);
+                if(arr.length===0) vault.replacedWithdrawals.delete(withdrawalIndex);
+            }
+            this.logger.info(`checkVaultReplacedTransactions(${vault.getIdentifier()}): Re-introduced back ${newPendingTxns.length} txns that were re-added to the mempool!`);
+            if(save) await this.saveVault(vault);
+            return true;
         } catch (e) {
-            (withdrawalData as any).sending = false;
-            vault.removeWithdrawal(withdrawalData);
-            await this.saveVault(vault);
-            throw e;
+            this.logger.error(`checkVaultReplacedTransactions(${vault.getIdentifier()}): Failed to update the vault with new pending txns (rolling back): `, e);
+            //Rollback the pending withdrawals
+            vault.pendingWithdrawals.push(...backup, ...txsToAddOnTop);
+            return false;
         }
-
-        return res.txId;
     }
 
     async checkVaults() {
@@ -332,23 +418,23 @@ export class SpvVaults {
             }
 
             if(vault.state===SpvVaultState.OPENED) {
-                let changed = false;
+                let changed = await this.checkVaultReplacedTransactions(vault);
+
                 //Check if some of the pendingWithdrawals got confirmed
                 let latestOwnWithdrawalIndex = -1;
                 let latestConfirmedWithdrawalIndex = -1;
-                for(let i=0; i<vault.pendingWithdrawals.length; i++) {
+                for(let i = vault.pendingWithdrawals.length-1; i>=0; i--) {
                     const pendingWithdrawal = vault.pendingWithdrawals[i];
                     if(pendingWithdrawal.sending) continue;
 
                     //Check all the pending withdrawals that were not finalized yet
-                    const btcTx = await checkTransactionReplacedRpc(pendingWithdrawal.btcTx.txid, pendingWithdrawal.btcTx.raw, this.bitcoinRpc);
+                    const btcTx = await checkTransactionReplaced(pendingWithdrawal.btcTx.txid, pendingWithdrawal.btcTx.raw, this.bitcoinRpc);
                     if(btcTx==null) {
                         //Probable double-spend, remove from pending withdrawals
-                        const index = vault.pendingWithdrawals.indexOf(pendingWithdrawal);
-                        if(index===-1) {
-                            this.logger.warn("checkVaults(): Tried to remove pending withdrawal txId: "+pendingWithdrawal.btcTx.txid+", but doesn't exist anymore!")
+                        if(!vault.doubleSpendPendingWithdrawal(pendingWithdrawal)) {
+                            this.logger.warn("checkVaults(): Tried to remove pending withdrawal txId: "+pendingWithdrawal.btcTx.txid+", but doesn't exist anymore!");
                         } else {
-                            vault.pendingWithdrawals.splice(index, 1);
+                            this.logger.info("checkVaults(): Successfully removed withdrawal txId: "+pendingWithdrawal.btcTx.txid+", due to being replaced in the mempool!");
                         }
                         changed = true;
                     } else {

package/src/swaps/trusted/frombtc_trusted/FromBtcTrusted.ts

@@ -702,7 +702,7 @@ export class FromBtcTrusted extends SwapHandler<FromBtcTrustedSwap, FromBtcTrust
 
     private async checkDoubleSpends(): Promise<void> {
         for(let swap of this.doubleSpendWatchdogSwaps.keys()) {
-            const tx = await this.bitcoin.getWalletTransaction(swap.txId);
+            const tx = await this.bitcoinRpc.getTransaction(swap.txId);
             if(tx==null) {
                 this.swapLogger.debug(swap, "checkDoubleSpends(): Swap was double spent, burning... - original txId: "+swap.txId);
                 this.processPastSwap(swap, null, null);

package/src/utils/BitcoinUtils.ts

@@ -46,19 +46,7 @@ export function isLegacyInput(input: TransactionInput): boolean {
     return true;
 }
 
-export async function checkTransactionReplaced(txId: string, txRaw: string, bitcoin: IBitcoinWallet): Promise<BtcTx> {
-    const existingTx = await bitcoin.getWalletTransaction(txId);
-    if(existingTx!=null) return existingTx;
-    //Try to re-broadcast
-    try {
-        await bitcoin.sendRawTransaction(txRaw);
-    } catch (e) {
-        logger.error("checkTransactionReplaced("+txId+"): Error when trying to re-broadcast raw transaction: ", e);
-    }
-    return await bitcoin.getWalletTransaction(txId);
-}
-
-export async function checkTransactionReplacedRpc(txId: string, txRaw: string, bitcoin: BitcoinRpc<any>): Promise<BtcTx> {
+export async function checkTransactionReplaced(txId: string, txRaw: string, bitcoin: BitcoinRpc<any>): Promise<BtcTx> {
     const existingTx = await bitcoin.getTransaction(txId);
     if(existingTx!=null) return existingTx;
     //Try to re-broadcast