@atomiqlabs/lp-lib 14.0.0-dev.29 → 14.0.0-dev.30

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

@@ -11,6 +11,7 @@ const SchemaVerifier_1 = require("../../../utils/paramcoders/SchemaVerifier");
 const ServerParamDecoder_1 = require("../../../utils/paramcoders/server/ServerParamDecoder");
 const ToBtcBaseSwapHandler_1 = require("../ToBtcBaseSwapHandler");
 const promise_queue_ts_1 = require("promise-queue-ts");
+const BitcoinUtils_1 = require("../../../utils/BitcoinUtils");
 const OUTPUT_SCRIPT_MAX_LENGTH = 200;
 const MAX_PARALLEL_TX_PROCESSED = 10;
 /**
@@ -285,12 +286,21 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
                 };
             if (swap.metadata != null)
                 swap.metadata.times.paySignPSBT = Date.now();
-            this.swapLogger.debug(swap, "sendBitcoinPayment(): signed raw transaction: " + signResult.raw);
-            swap.txId = signResult.tx.id;
-            swap.setRealNetworkFee(BigInt(signResult.networkFee));
-            await swap.setState(ToBtcSwapAbs_1.ToBtcSwapState.BTC_SENDING);
-            await this.saveSwapData(swap);
-            await this.bitcoin.sendRawTransaction(signResult.raw);
+            try {
+                this.swapLogger.debug(swap, "sendBitcoinPayment(): signed raw transaction: " + signResult.raw);
+                swap.txId = signResult.tx.id;
+                swap.btcRawTx = signResult.raw;
+                swap.setRealNetworkFee(BigInt(signResult.networkFee));
+                swap.sending = true;
+                await swap.setState(ToBtcSwapAbs_1.ToBtcSwapState.BTC_SENDING);
+                await this.saveSwapData(swap);
+                await this.bitcoin.sendRawTransaction(signResult.raw);
+                swap.sending = false;
+            }
+            catch (e) {
+                swap.sending = false;
+                throw e;
+            }
             if (swap.metadata != null)
                 swap.metadata.times.payTxSent = Date.now();
             this.swapLogger.info(swap, "sendBitcoinPayment(): btc transaction generated, signed & broadcasted, txId: " + swap.txId + " address: " + swap.address);
@@ -305,8 +315,10 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
      */
     async processInitialized(swap) {
         if (swap.state === ToBtcSwapAbs_1.ToBtcSwapState.BTC_SENDING) {
+            if (swap.sending)
+                return;
             //Bitcoin transaction was signed (maybe also sent)
-            const tx = await this.bitcoin.getWalletTransaction(swap.txId);
+            const tx = await (0, BitcoinUtils_1.checkTransactionReplaced)(swap.txId, swap.btcRawTx, this.bitcoin);
             const isTxSent = tx != null;
             if (!isTxSent) {
                 //Reset the state to COMMITED

package/dist/swaps/escrow/tobtc_abstract/ToBtcSwapAbs.d.ts

@@ -11,11 +11,13 @@ export declare enum ToBtcSwapState {
     CLAIMED = 4
 }
 export declare class ToBtcSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T, ToBtcSwapState> {
+    sending: boolean;
     readonly address: string;
     readonly satsPerVbyte: bigint;
     readonly nonce: bigint;
     readonly requiredConfirmations: number;
     readonly preferedConfirmationTarget: number;
+    btcRawTx: string;
     txId: string;
     constructor(chainIdentifier: string, address: string, amount: bigint, swapFee: bigint, swapFeeInToken: bigint, networkFee: bigint, networkFeeInToken: bigint, satsPerVbyte: bigint, nonce: bigint, requiredConfirmations: number, preferedConfirmationTarget: number);
     constructor(obj: any);

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

@@ -34,6 +34,7 @@ class ToBtcSwapAbs extends ToBtcBaseSwap_1.ToBtcBaseSwap {
             this.requiredConfirmations = chainIdOrObj.requiredConfirmations;
             this.preferedConfirmationTarget = chainIdOrObj.preferedConfirmationTarget;
             this.txId = chainIdOrObj.txId;
+            this.btcRawTx = chainIdOrObj.btcRawTx;
             //Compatibility
             this.quotedNetworkFee ?? (this.quotedNetworkFee = (0, Utils_1.deserializeBN)(chainIdOrObj.networkFee));
         }
@@ -47,6 +48,7 @@ class ToBtcSwapAbs extends ToBtcBaseSwap_1.ToBtcBaseSwap {
         partialSerialized.nonce = this.nonce.toString(10);
         partialSerialized.preferedConfirmationTarget = this.preferedConfirmationTarget;
         partialSerialized.txId = this.txId;
+        partialSerialized.btcRawTx = this.btcRawTx;
         return partialSerialized;
     }
     isInitiated() {

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

@@ -5,7 +5,9 @@ export declare enum SpvVaultState {
     BTC_CONFIRMED = 1,
     OPENED = 2
 }
-export declare class SpvVault<D extends SpvWithdrawalTransactionData = SpvWithdrawalTransactionData, T extends SpvVaultData = SpvVaultData> extends Lockable implements StorageObject {
+export declare class SpvVault<D extends SpvWithdrawalTransactionData = SpvWithdrawalTransactionData & {
+    sending?: boolean;
+}, T extends SpvVaultData = SpvVaultData> extends Lockable implements StorageObject {
     readonly chainId: string;
     readonly initialUtxo: string;
     readonly btcAddress: string;

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

@@ -11,6 +11,7 @@ export declare enum SpvVaultSwapState {
     CLAIMED = 4
 }
 export declare class SpvVaultSwap extends SwapHandlerSwap<SpvVaultSwapState> {
+    sending: boolean;
     readonly quoteId: string;
     readonly vaultOwner: string;
     readonly vaultId: bigint;

package/dist/swaps/spv_vault_swap/SpvVaultSwapHandler.js

@@ -99,8 +99,13 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
             }
         }
         if (swap.state === SpvVaultSwap_1.SpvVaultSwapState.SIGNED) {
-            //Check if sent
-            const tx = await this.bitcoinRpc.getTransaction(swap.btcTxId);
+            if (swap.sending)
+                return;
+            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) {
                 await this.removeSwapData(swap, SpvVaultSwap_1.SpvVaultSwapState.FAILED);
                 return;
@@ -117,7 +122,13 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
         }
         if (swap.state === SpvVaultSwap_1.SpvVaultSwapState.SENT || swap.state === SpvVaultSwap_1.SpvVaultSwapState.BTC_CONFIRMED) {
             //Check if confirmed or double-spent
-            const tx = await this.bitcoinRpc.getTransaction(swap.btcTxId);
+            if (swap.sending)
+                return;
+            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) {
                 await this.removeSwapData(swap, SpvVaultSwap_1.SpvVaultSwapState.DOUBLE_SPENT);
                 return;
@@ -421,31 +432,45 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
                     msg: "Vault UTXO already spent, please try again!"
                 };
             }
-            vault.addWithdrawal(data);
-            await this.Vaults.saveVault(vault);
-            //Double-check the state to prevent race condition
-            if (swap.state !== SpvVaultSwap_1.SpvVaultSwapState.CREATED)
-                throw {
-                    code: 20505,
-                    msg: "Invalid quote ID, not found or expired!"
-                };
-            swap.btcTxId = signedTx.id;
-            swap.state = SpvVaultSwap_1.SpvVaultSwapState.SIGNED;
-            await this.saveSwapData(swap);
-            this.swapLogger.info(swap, "REST: /postQuote: BTC transaction signed, txId: " + swap.btcTxId);
             try {
-                await this.bitcoin.sendRawTransaction(Buffer.from(signedTx.toBytes(true, true)).toString("hex"));
-                await swap.setState(SpvVaultSwap_1.SpvVaultSwapState.SENT);
+                const btcRawTx = Buffer.from(signedTx.toBytes(true, true)).toString("hex");
+                //Double-check the state to prevent race condition
+                if (swap.state !== SpvVaultSwap_1.SpvVaultSwapState.CREATED) {
+                    throw {
+                        code: 20505,
+                        msg: "Invalid quote ID, not found or expired!"
+                    };
+                }
+                swap.btcTxId = signedTx.id;
+                swap.state = SpvVaultSwap_1.SpvVaultSwapState.SIGNED;
+                swap.sending = true;
+                await this.saveSwapData(swap);
+                data.btcTx.raw = btcRawTx;
+                data.sending = true;
+                vault.addWithdrawal(data);
+                await this.Vaults.saveVault(vault);
+                this.swapLogger.info(swap, "REST: /postQuote: BTC transaction signed, txId: " + swap.btcTxId);
+                try {
+                    await this.bitcoin.sendRawTransaction(btcRawTx);
+                    await swap.setState(SpvVaultSwap_1.SpvVaultSwapState.SENT);
+                    data.sending = false;
+                    swap.sending = false;
+                }
+                catch (e) {
+                    this.swapLogger.error(swap, "REST: /postQuote: Failed to send BTC transaction: ", e);
+                    throw {
+                        code: 20512,
+                        msg: "Error broadcasting bitcoin transaction!"
+                    };
+                }
             }
             catch (e) {
-                this.swapLogger.error(swap, "REST: /postQuote: Failed to send BTC transaction: ", e);
+                data.sending = false;
+                swap.sending = false;
                 vault.removeWithdrawal(data);
                 await this.Vaults.saveVault(vault);
                 await this.removeSwapData(swap, SpvVaultSwap_1.SpvVaultSwapState.FAILED);
-                throw {
-                    code: 20512,
-                    msg: "Error broadcasting bitcoin transaction!"
-                };
+                throw e;
             }
             await responseStream.writeParamsAndEnd({
                 code: 20000,

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

@@ -28,12 +28,16 @@ export declare class SpvVaults {
         vaultsCreated: bigint[];
         btcTxId: string;
     }>;
-    listVaults(chainId?: string, token?: string): Promise<SpvVault<SpvWithdrawalTransactionData, import("@atomiqlabs/base").SpvVaultData<SpvWithdrawalTransactionData>>[]>;
+    listVaults(chainId?: string, token?: string): Promise<SpvVault<SpvWithdrawalTransactionData & {
+        sending?: boolean;
+    }, import("@atomiqlabs/base").SpvVaultData<SpvWithdrawalTransactionData>>[]>;
     fundVault(vault: SpvVault, tokenAmounts: bigint[]): Promise<string>;
     withdrawFromVault(vault: SpvVault, tokenAmounts: bigint[], feeRate?: number): Promise<string>;
     checkVaults(): Promise<void>;
     claimWithdrawals(vault: SpvVault, withdrawal: SpvWithdrawalTransactionData[]): Promise<boolean>;
-    getVault(chainId: string, owner: string, vaultId: bigint): Promise<SpvVault<SpvWithdrawalTransactionData, import("@atomiqlabs/base").SpvVaultData<SpvWithdrawalTransactionData>>>;
+    getVault(chainId: string, owner: string, vaultId: bigint): Promise<SpvVault<SpvWithdrawalTransactionData & {
+        sending?: boolean;
+    }, import("@atomiqlabs/base").SpvVaultData<SpvWithdrawalTransactionData>>>;
     /**
      * Returns a ready-to-use vault for a specific request
      *

package/dist/swaps/spv_vault_swap/SpvVaults.js

@@ -6,9 +6,9 @@ const Utils_1 = require("../../utils/Utils");
 const PluginManager_1 = require("../../plugins/PluginManager");
 const AmountAssertions_1 = require("../assertions/AmountAssertions");
 const btc_signer_1 = require("@scure/btc-signer");
+const BitcoinUtils_1 = require("../../utils/BitcoinUtils");
 exports.VAULT_DUST_AMOUNT = 600;
 const VAULT_INIT_CONFIRMATIONS = 2;
-// const BTC_FINALIZATION_CONFIRMATIONS = 6;
 const MAX_PARALLEL_VAULTS_OPENING = 10;
 class SpvVaults {
     constructor(vaultStorage, bitcoin, vaultSigner, bitcoinRpc, chains, config) {
@@ -184,12 +184,15 @@ class SpvVaults {
         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;
@@ -266,9 +269,10 @@ class SpvVaults {
                 let latestConfirmedWithdrawalIndex = -1;
                 for (let i = 0; i < vault.pendingWithdrawals.length; i++) {
                     const pendingWithdrawal = vault.pendingWithdrawals[i];
+                    if (pendingWithdrawal.sending)
+                        continue;
                     //Check all the pending withdrawals that were not finalized yet
-                    // if(pendingWithdrawal.btcTx.confirmations==null || pendingWithdrawal.btcTx.confirmations < BTC_FINALIZATION_CONFIRMATIONS) {
-                    const btcTx = await this.bitcoinRpc.getTransaction(pendingWithdrawal.btcTx.txid);
+                    const btcTx = await (0, BitcoinUtils_1.checkTransactionReplacedRpc)(pendingWithdrawal.btcTx.txid, pendingWithdrawal.btcTx.raw, this.bitcoinRpc);
                     if (btcTx == null) {
                         //Probable double-spend, remove from pending withdrawals
                         const index = vault.pendingWithdrawals.indexOf(pendingWithdrawal);
@@ -289,7 +293,6 @@ class SpvVaults {
                             changed = true;
                         }
                     }
-                    // }
                     //Check it has enough confirmations
                     if (pendingWithdrawal.btcTx.confirmations >= vault.data.getConfirmations()) {
                         latestConfirmedWithdrawalIndex = i;

package/dist/utils/BitcoinUtils.d.ts

@@ -1,2 +1,6 @@
 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>;

package/dist/utils/BitcoinUtils.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isLegacyInput = void 0;
+exports.checkTransactionReplacedRpc = 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");
+const logger = (0, Utils_1.getLogger)("BitcoinUtils: ");
 function parsePushOpcode(script) {
     if (script[0] === 0x00) {
         return Uint8Array.from([]);
@@ -43,3 +45,31 @@ function isLegacyInput(input) {
     return true;
 }
 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;
+    //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.getTransaction(txId);
+}
+exports.checkTransactionReplacedRpc = checkTransactionReplacedRpc;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/lp-lib",
-  "version": "14.0.0-dev.29",
+  "version": "14.0.0-dev.30",
   "description": "Main functionality implementation for atomiq LP node",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",

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

@@ -23,6 +23,7 @@ import {ServerParamEncoder} from "../../../utils/paramcoders/server/ServerParamE
 import {ToBtcBaseConfig, ToBtcBaseSwapHandler} from "../ToBtcBaseSwapHandler";
 import {PromiseQueue} from "promise-queue-ts";
 import {IBitcoinWallet} from "../../../wallets/IBitcoinWallet";
+import {checkTransactionReplaced} from "../../../utils/BitcoinUtils";
 
 const OUTPUT_SCRIPT_MAX_LENGTH = 200;
 
@@ -372,13 +373,22 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
             }
             if(swap.metadata!=null) swap.metadata.times.paySignPSBT = Date.now();
 
-            this.swapLogger.debug(swap, "sendBitcoinPayment(): signed raw transaction: "+signResult.raw);
-            swap.txId = signResult.tx.id;
-            swap.setRealNetworkFee(BigInt(signResult.networkFee));
-            await swap.setState(ToBtcSwapState.BTC_SENDING);
-            await this.saveSwapData(swap);
+            try {
+                this.swapLogger.debug(swap, "sendBitcoinPayment(): signed raw transaction: "+signResult.raw);
+                swap.txId = signResult.tx.id;
+                swap.btcRawTx = signResult.raw;
+                swap.setRealNetworkFee(BigInt(signResult.networkFee));
+                swap.sending = true;
+                await swap.setState(ToBtcSwapState.BTC_SENDING);
+                await this.saveSwapData(swap);
+
+                await this.bitcoin.sendRawTransaction(signResult.raw);
+                swap.sending = false;
+            } catch (e) {
+                swap.sending = false;
+                throw e;
+            }
 
-            await this.bitcoin.sendRawTransaction(signResult.raw);
             if(swap.metadata!=null) swap.metadata.times.payTxSent = Date.now();
             this.swapLogger.info(swap, "sendBitcoinPayment(): btc transaction generated, signed & broadcasted, txId: "+swap.txId+" address: "+swap.address);
 
@@ -394,8 +404,9 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
      */
     private async processInitialized(swap: ToBtcSwapAbs) {
         if(swap.state===ToBtcSwapState.BTC_SENDING) {
+            if(swap.sending) return;
             //Bitcoin transaction was signed (maybe also sent)
-            const tx = await this.bitcoin.getWalletTransaction(swap.txId);
+            const tx = await checkTransactionReplaced(swap.txId, swap.btcRawTx, this.bitcoin);
 
             const isTxSent = tx!=null;
             if(!isTxSent) {

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

@@ -16,12 +16,16 @@ export enum ToBtcSwapState {
 
 export class ToBtcSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T, ToBtcSwapState> {
 
+    //Unsaved sending flag
+    sending: boolean;
+
     readonly address: string;
     readonly satsPerVbyte: bigint;
     readonly nonce: bigint;
     readonly requiredConfirmations: number;
     readonly preferedConfirmationTarget: number;
 
+    btcRawTx: string;
     txId: string;
 
     constructor(
@@ -69,6 +73,7 @@ export class ToBtcSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T
             this.preferedConfirmationTarget = chainIdOrObj.preferedConfirmationTarget;
 
             this.txId = chainIdOrObj.txId;
+            this.btcRawTx = chainIdOrObj.btcRawTx;
 
             //Compatibility
             this.quotedNetworkFee ??= deserializeBN(chainIdOrObj.networkFee);
@@ -84,6 +89,7 @@ export class ToBtcSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T
         partialSerialized.nonce = this.nonce.toString(10);
         partialSerialized.preferedConfirmationTarget = this.preferedConfirmationTarget;
         partialSerialized.txId = this.txId;
+        partialSerialized.btcRawTx = this.btcRawTx;
         return partialSerialized;
     }
 

package/src/swaps/spv_vault_swap/SpvVault.ts

@@ -18,7 +18,7 @@ export enum SpvVaultState {
 }
 
 export class SpvVault<
-    D extends SpvWithdrawalTransactionData = SpvWithdrawalTransactionData,
+    D extends SpvWithdrawalTransactionData = SpvWithdrawalTransactionData & {sending?: boolean},
     T extends SpvVaultData = SpvVaultData
 > extends Lockable implements StorageObject {
 

package/src/swaps/spv_vault_swap/SpvVaultSwap.ts

@@ -16,6 +16,9 @@ export enum SpvVaultSwapState {
 
 export class SpvVaultSwap extends SwapHandlerSwap<SpvVaultSwapState> {
 
+    //Unsaved sending flag
+    sending: boolean;
+
     readonly quoteId: string;
 
     readonly vaultOwner: string;

package/src/swaps/spv_vault_swap/SpvVaultSwapHandler.ts

@@ -29,7 +29,7 @@ import {FromBtcAmountAssertions} from "../assertions/FromBtcAmountAssertions";
 import {randomBytes} from "crypto";
 import {getInputType, OutScript, Transaction} from "@scure/btc-signer";
 import {SpvVaults, VAULT_DUST_AMOUNT} from "./SpvVaults";
-import {isLegacyInput} from "../../utils/BitcoinUtils";
+import {checkTransactionReplaced, isLegacyInput} from "../../utils/BitcoinUtils";
 
 export type SpvVaultSwapHandlerConfig = SwapBaseConfig & {
     vaultsCheckInterval: number,
@@ -166,8 +166,12 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
         }
 
         if(swap.state===SpvVaultSwapState.SIGNED) {
-            //Check if sent
-            const tx = await this.bitcoinRpc.getTransaction(swap.btcTxId);
+            if(swap.sending) return;
+            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) {
                 await this.removeSwapData(swap, SpvVaultSwapState.FAILED);
                 return;
@@ -183,7 +187,12 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
 
         if(swap.state===SpvVaultSwapState.SENT || swap.state===SpvVaultSwapState.BTC_CONFIRMED) {
             //Check if confirmed or double-spent
-            const tx = await this.bitcoinRpc.getTransaction(swap.btcTxId);
+            if(swap.sending) return;
+            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) {
                 await this.removeSwapData(swap, SpvVaultSwapState.DOUBLE_SPENT);
                 return;
@@ -555,32 +564,49 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
                     msg: "Vault UTXO already spent, please try again!"
                 };
             }
-            vault.addWithdrawal(data);
-            await this.Vaults.saveVault(vault);
 
-            //Double-check the state to prevent race condition
-            if(swap.state!==SpvVaultSwapState.CREATED) throw {
-                code: 20505,
-                msg: "Invalid quote ID, not found or expired!"
-            };
-            swap.btcTxId = signedTx.id;
-            swap.state = SpvVaultSwapState.SIGNED;
-            await this.saveSwapData(swap);
+            try {
+                const btcRawTx = Buffer.from(signedTx.toBytes(true, true)).toString("hex");
+
+                //Double-check the state to prevent race condition
+                if(swap.state!==SpvVaultSwapState.CREATED) {
+                    throw {
+                        code: 20505,
+                        msg: "Invalid quote ID, not found or expired!"
+                    };
+                }
 
-            this.swapLogger.info(swap, "REST: /postQuote: BTC transaction signed, txId: "+swap.btcTxId);
+                swap.btcTxId = signedTx.id;
+                swap.state = SpvVaultSwapState.SIGNED;
+                swap.sending = true;
+                await this.saveSwapData(swap);
 
-            try {
-                await this.bitcoin.sendRawTransaction(Buffer.from(signedTx.toBytes(true, true)).toString("hex"));
-                await swap.setState(SpvVaultSwapState.SENT);
+                data.btcTx.raw = btcRawTx;
+                (data as any).sending = true;
+                vault.addWithdrawal(data);
+                await this.Vaults.saveVault(vault);
+
+                this.swapLogger.info(swap, "REST: /postQuote: BTC transaction signed, txId: "+swap.btcTxId);
+
+                try {
+                    await this.bitcoin.sendRawTransaction(btcRawTx);
+                    await swap.setState(SpvVaultSwapState.SENT);
+                    (data as any).sending = false;
+                    swap.sending = false;
+                } catch (e) {
+                    this.swapLogger.error(swap, "REST: /postQuote: Failed to send BTC transaction: ", e);
+                    throw {
+                        code: 20512,
+                        msg: "Error broadcasting bitcoin transaction!"
+                    };
+                }
             } catch (e) {
-                this.swapLogger.error(swap, "REST: /postQuote: Failed to send BTC transaction: ", e);
+                (data as any).sending = false;
+                swap.sending = false;
                 vault.removeWithdrawal(data);
                 await this.Vaults.saveVault(vault);
                 await this.removeSwapData(swap, SpvVaultSwapState.FAILED);
-                throw {
-                    code: 20512,
-                    msg: "Error broadcasting bitcoin transaction!"
-                };
+                throw e;
             }
 
             await responseStream.writeParamsAndEnd({

package/src/swaps/spv_vault_swap/SpvVaults.ts

@@ -15,10 +15,10 @@ 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";
 
 export const VAULT_DUST_AMOUNT = 600;
 const VAULT_INIT_CONFIRMATIONS = 2;
-// const BTC_FINALIZATION_CONFIRMATIONS = 6;
 const MAX_PARALLEL_VAULTS_OPENING = 10;
 
 export class SpvVaults {
@@ -234,12 +234,15 @@ export class SpvVaults {
         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);
 
         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;
@@ -329,30 +332,31 @@ export class SpvVaults {
                 let latestConfirmedWithdrawalIndex = -1;
                 for(let i=0; i<vault.pendingWithdrawals.length; i++) {
                     const pendingWithdrawal = vault.pendingWithdrawals[i];
+                    if(pendingWithdrawal.sending) continue;
+
                     //Check all the pending withdrawals that were not finalized yet
-                    // if(pendingWithdrawal.btcTx.confirmations==null || pendingWithdrawal.btcTx.confirmations < BTC_FINALIZATION_CONFIRMATIONS) {
-                        const btcTx = await this.bitcoinRpc.getTransaction(pendingWithdrawal.btcTx.txid);
-                        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!")
-                            } else {
-                                vault.pendingWithdrawals.splice(index, 1);
-                            }
-                            changed = true;
+                    const btcTx = await checkTransactionReplacedRpc(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!")
                         } else {
-                            //Update confirmations count
-                            if(
-                                pendingWithdrawal.btcTx.confirmations !== btcTx.confirmations ||
-                                pendingWithdrawal.btcTx.blockhash !== btcTx.blockhash
-                            ) {
-                                pendingWithdrawal.btcTx.confirmations = btcTx.confirmations;
-                                pendingWithdrawal.btcTx.blockhash = btcTx.blockhash;
-                                changed = true;
-                            }
+                            vault.pendingWithdrawals.splice(index, 1);
                         }
-                    // }
+                        changed = true;
+                    } else {
+                        //Update confirmations count
+                        if(
+                            pendingWithdrawal.btcTx.confirmations !== btcTx.confirmations ||
+                            pendingWithdrawal.btcTx.blockhash !== btcTx.blockhash
+                        ) {
+                            pendingWithdrawal.btcTx.confirmations = btcTx.confirmations;
+                            pendingWithdrawal.btcTx.blockhash = btcTx.blockhash;
+                            changed = true;
+                        }
+                    }
+
                     //Check it has enough confirmations
                     if(pendingWithdrawal.btcTx.confirmations >= vault.data.getConfirmations()) {
                         latestConfirmedWithdrawalIndex = i;

package/src/utils/BitcoinUtils.ts

@@ -1,6 +1,11 @@
 import {TransactionInput} from "@scure/btc-signer/psbt";
 import {getPrevOut} from "@scure/btc-signer/utxo";
 import {OutScript} from "@scure/btc-signer";
+import {BitcoinRpc, BtcTx} from "@atomiqlabs/base";
+import {IBitcoinWallet} from "../wallets/IBitcoinWallet";
+import {getLogger} from "./Utils";
+
+const logger = getLogger("BitcoinUtils: ");
 
 function parsePushOpcode(script: Uint8Array): Uint8Array {
     if(script[0]===0x00) {
@@ -40,3 +45,27 @@ 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> {
+    const existingTx = await bitcoin.getTransaction(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.getTransaction(txId);
+}