@atomiqlabs/lp-lib 15.0.7 → 15.0.8

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[];
@@ -24,6 +25,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.scOpenTx = chainIdOrObj.scOpenTx;
+            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,
             scOpenTx: this.scOpenTx
         };
     }

package/dist/swaps/spv_vault_swap/SpvVaultSwapHandler.js

@@ -256,7 +256,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();

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

@@ -38,6 +38,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

@@ -190,6 +190,89 @@ class SpvVaults {
         }
         return res.txId;
     }
+    /**
+     * 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.getChain(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!`);
+                }
+            }
+        }
+        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 {
+            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) {
+            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;
+        }
+    }
     async checkVaults() {
         const vaults = Object.keys(this.vaultStorage.data).map(key => this.vaultStorage.data[key]);
         const claimWithdrawals = [];
@@ -238,11 +321,11 @@ class SpvVaults {
                 await this.saveVault(vault);
             }
             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;
@@ -250,9 +333,12 @@ class SpvVaults {
                     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
-                        if (!vault.removeWithdrawal(pendingWithdrawal)) {
+                        if (!vault.doubleSpendPendingWithdrawal(pendingWithdrawal)) {
                             this.logger.warn("checkVaults(): Tried to remove pending withdrawal txId: " + pendingWithdrawal.btcTx.txid + ", but doesn't exist anymore!");
                         }
+                        else {
+                            this.logger.info("checkVaults(): Successfully removed withdrawal txId: " + pendingWithdrawal.btcTx.txid + ", due to being replaced in the mempool!");
+                        }
                         changed = true;
                     }
                     else {

package/package.json

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

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.scOpenTx = chainIdOrObj.scOpenTx;
+            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,
             scOpenTx: this.scOpenTx
         }
     }

package/src/swaps/spv_vault_swap/SpvVaultSwapHandler.ts

@@ -352,7 +352,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

package/src/swaps/spv_vault_swap/SpvVaults.ts

@@ -241,6 +241,88 @@ export class SpvVaults {
         return res.txId;
     }
 
+    /**
+     * 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.getChain(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!`);
+                }
+            }
+        }
+
+        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 {
+            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) {
+            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;
+        }
+    }
+
     async checkVaults() {
         const vaults = Object.keys(this.vaultStorage.data).map(key => this.vaultStorage.data[key]);
 
@@ -297,11 +379,12 @@ 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;
 
@@ -309,8 +392,10 @@ export class SpvVaults {
                     const btcTx = await checkTransactionReplacedRpc(pendingWithdrawal.btcTx.txid, pendingWithdrawal.btcTx.raw, this.bitcoinRpc);
                     if(btcTx==null) {
                         //Probable double-spend, remove from pending withdrawals
-                        if(!vault.removeWithdrawal(pendingWithdrawal)) {
-                            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 {
+                            this.logger.info("checkVaults(): Successfully removed withdrawal txId: "+pendingWithdrawal.btcTx.txid+", due to being replaced in the mempool!");
                         }
                         changed = true;
                     } else {