@atomiqlabs/lp-lib 14.0.0-dev.12 → 14.0.0-dev.14

package/dist/swaps/escrow/frombtcln_abstract/FromBtcLnAbs.js

@@ -55,30 +55,57 @@ class FromBtcLnAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             }
             return null;
         }
-        if (swap.state === FromBtcLnSwapAbs_1.FromBtcLnSwapState.RECEIVED) {
-            const isAuthorizationExpired = await swapContract.isInitAuthorizationExpired(swap.data, swap);
-            if (isAuthorizationExpired) {
-                const isCommited = await swapContract.isCommited(swap.data);
-                if (!isCommited) {
-                    this.swapLogger.info(swap, "processPastSwap(state=RECEIVED): swap not committed before authorization expiry, cancelling the LN invoice, invoice: " + swap.pr);
-                    await swap.setState(FromBtcLnSwapAbs_1.FromBtcLnSwapState.CANCELED);
-                    return "CANCEL";
+        if (swap.state === FromBtcLnSwapAbs_1.FromBtcLnSwapState.RECEIVED || swap.state === FromBtcLnSwapAbs_1.FromBtcLnSwapState.COMMITED) {
+            const onchainStatus = await swapContract.getCommitStatus(signer.getAddress(), swap.data);
+            const state = swap.state;
+            if (onchainStatus.type === base_1.SwapCommitStateType.PAID) {
+                //Extract the swap secret
+                if (state !== FromBtcLnSwapAbs_1.FromBtcLnSwapState.CLAIMED && state !== FromBtcLnSwapAbs_1.FromBtcLnSwapState.SETTLED) {
+                    const secretHex = await onchainStatus.getClaimResult();
+                    const secret = Buffer.from(secretHex, "hex");
+                    const paymentHash = (0, crypto_1.createHash)("sha256").update(secret).digest();
+                    const paymentHashHex = paymentHash.toString("hex");
+                    if (swap.lnPaymentHash !== paymentHashHex) {
+                        //TODO: Possibly fatal failure
+                        this.swapLogger.error(swap, "processPastSwap(state=RECEIVED|COMMITED): onchainStatus=PAID, Invalid swap secret specified: " + secretHex + " for paymentHash: " + paymentHashHex);
+                        return null;
+                    }
+                    swap.secret = secretHex;
+                    await swap.setState(FromBtcLnSwapAbs_1.FromBtcLnSwapState.CLAIMED);
+                    await this.saveSwapData(swap);
+                    this.swapLogger.warn(swap, "processPastSwap(state=RECEIVED|COMMITED): swap settled (detected from processPastSwap), invoice: " + swap.pr);
+                    return "SETTLE";
                 }
-                this.swapLogger.info(swap, "processPastSwap(state=RECEIVED): swap committed (detected from processPastSwap), invoice: " + swap.pr);
-                await swap.setState(FromBtcLnSwapAbs_1.FromBtcLnSwapState.COMMITED);
-                await this.saveSwapData(swap);
+                return null;
             }
-        }
-        if (swap.state === FromBtcLnSwapAbs_1.FromBtcLnSwapState.RECEIVED || swap.state === FromBtcLnSwapAbs_1.FromBtcLnSwapState.COMMITED) {
-            if (!await swapContract.isExpired(signer.getAddress(), swap.data))
+            if (onchainStatus.type === base_1.SwapCommitStateType.COMMITED) {
+                if (state === FromBtcLnSwapAbs_1.FromBtcLnSwapState.RECEIVED) {
+                    await swap.setState(FromBtcLnSwapAbs_1.FromBtcLnSwapState.COMMITED);
+                    await this.saveSwapData(swap);
+                    this.swapLogger.info(swap, "processPastSwap(state=RECEIVED|COMMITED): swap committed (detected from processPastSwap), invoice: " + swap.pr);
+                }
                 return null;
-            const isCommited = await swapContract.isCommited(swap.data);
-            if (isCommited) {
-                this.swapLogger.info(swap, "processPastSwap(state=COMMITED): swap timed out, refunding to self, invoice: " + swap.pr);
+            }
+            if (onchainStatus.type === base_1.SwapCommitStateType.NOT_COMMITED || onchainStatus.type === base_1.SwapCommitStateType.EXPIRED) {
+                if (swap.state === FromBtcLnSwapAbs_1.FromBtcLnSwapState.RECEIVED) {
+                    const isAuthorizationExpired = await swapContract.isInitAuthorizationExpired(swap.data, swap);
+                    if (isAuthorizationExpired) {
+                        this.swapLogger.info(swap, "processPastSwap(state=RECEIVED|COMMITED): swap not committed before authorization expiry, cancelling the LN invoice, invoice: " + swap.pr);
+                        await swap.setState(FromBtcLnSwapAbs_1.FromBtcLnSwapState.CANCELED);
+                        return "CANCEL";
+                    }
+                }
+                else {
+                    if (await swapContract.isExpired(signer.getAddress(), swap.data)) {
+                        this.swapLogger.info(swap, "processPastSwap(state=RECEIVED|COMMITED): swap timed out, refunding to self, invoice: " + swap.pr);
+                        return "REFUND";
+                    }
+                }
+            }
+            if (onchainStatus.type === base_1.SwapCommitStateType.REFUNDABLE) {
+                this.swapLogger.info(swap, "processPastSwap(state=RECEIVED|COMMITED): swap timed out, refunding to self, invoice: " + swap.pr);
                 return "REFUND";
             }
-            this.swapLogger.info(swap, "processPastSwap(state=RECEIVED): swap timed out, cancelling the LN invoice, invoice: " + swap.pr);
-            return "CANCEL";
         }
         if (swap.state === FromBtcLnSwapAbs_1.FromBtcLnSwapState.CLAIMED)
             return "SETTLE";

package/dist/swaps/escrow/frombtcln_autoinit/FromBtcLnAuto.js

@@ -65,31 +65,57 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             }
             return null;
         }
-        if (swap.state === FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.TXS_SENT) {
-            const isAuthorizationExpired = await swapContract.isInitAuthorizationExpired(swap.data, swap);
-            if (isAuthorizationExpired) {
-                const isCommited = await swapContract.isCommited(swap.data);
-                if (!isCommited) {
-                    this.swapLogger.info(swap, "processPastSwap(state=TXS_SENT): swap not committed before authorization expiry, cancelling the LN invoice, invoice: " + swap.pr);
-                    await this.cancelSwapAndInvoice(swap);
-                    return null;
+        if (swap.state === FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.TXS_SENT || swap.state === FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.COMMITED) {
+            const onchainStatus = await swapContract.getCommitStatus(signer.getAddress(), swap.data);
+            const state = swap.state;
+            if (onchainStatus.type === base_1.SwapCommitStateType.PAID) {
+                //Extract the swap secret
+                if (state !== FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.CLAIMED && state !== FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.SETTLED) {
+                    const secretHex = await onchainStatus.getClaimResult();
+                    const secret = Buffer.from(secretHex, "hex");
+                    const paymentHash = (0, crypto_1.createHash)("sha256").update(secret).digest();
+                    const paymentHashHex = paymentHash.toString("hex");
+                    if (swap.lnPaymentHash !== paymentHashHex) {
+                        //TODO: Possibly fatal failure
+                        this.swapLogger.error(swap, "processPastSwap(state=TXS_SENT|COMMITED): onchainStatus=PAID, Invalid swap secret specified: " + secretHex + " for paymentHash: " + paymentHashHex);
+                        return null;
+                    }
+                    swap.secret = secretHex;
+                    await swap.setState(FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.CLAIMED);
+                    await this.saveSwapData(swap);
+                    this.swapLogger.warn(swap, "processPastSwap(state=TXS_SENT|COMMITED): swap settled (detected from processPastSwap), invoice: " + swap.pr);
+                    return "SETTLE";
                 }
-                this.swapLogger.info(swap, "processPastSwap(state=TXS_SENT): swap committed (detected from processPastSwap), invoice: " + swap.pr);
-                await swap.setState(FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.COMMITED);
-                await this.saveSwapData(swap);
+                return null;
             }
-        }
-        if (swap.state === FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.TXS_SENT || swap.state === FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.COMMITED) {
-            if (!await swapContract.isExpired(signer.getAddress(), swap.data))
+            if (onchainStatus.type === base_1.SwapCommitStateType.COMMITED) {
+                if (state === FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.TXS_SENT) {
+                    await swap.setState(FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.COMMITED);
+                    await this.saveSwapData(swap);
+                    this.swapLogger.info(swap, "processPastSwap(state=TXS_SENT|COMMITED): swap committed (detected from processPastSwap), invoice: " + swap.pr);
+                }
                 return null;
-            const isCommited = await swapContract.isCommited(swap.data);
-            if (isCommited) {
-                this.swapLogger.info(swap, "processPastSwap(state=COMMITED): swap timed out, refunding to self, invoice: " + swap.pr);
+            }
+            if (onchainStatus.type === base_1.SwapCommitStateType.NOT_COMMITED || onchainStatus.type === base_1.SwapCommitStateType.EXPIRED) {
+                if (swap.state === FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.TXS_SENT) {
+                    const isAuthorizationExpired = await swapContract.isInitAuthorizationExpired(swap.data, swap);
+                    if (isAuthorizationExpired) {
+                        this.swapLogger.info(swap, "processPastSwap(state=TXS_SENT|COMMITED): swap not committed before authorization expiry, cancelling the LN invoice, invoice: " + swap.pr);
+                        await this.cancelSwapAndInvoice(swap);
+                        return null;
+                    }
+                }
+                else {
+                    if (await swapContract.isExpired(signer.getAddress(), swap.data)) {
+                        this.swapLogger.info(swap, "processPastSwap(state=TXS_SENT|COMMITED): swap timed out, refunding to self, invoice: " + swap.pr);
+                        return "REFUND";
+                    }
+                }
+            }
+            if (onchainStatus.type === base_1.SwapCommitStateType.REFUNDABLE) {
+                this.swapLogger.info(swap, "processPastSwap(state=TXS_SENT|COMMITED): swap timed out, refunding to self, invoice: " + swap.pr);
                 return "REFUND";
             }
-            this.swapLogger.info(swap, "processPastSwap(state=COMMITED): swap timed out, cancelling the LN invoice, invoice: " + swap.pr);
-            await this.cancelSwapAndInvoice(swap);
-            return null;
         }
         if (swap.state === FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.CLAIMED)
             return "SETTLE";

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

@@ -13,9 +13,8 @@ export declare class SpvVault<D extends SpvWithdrawalTransactionData = SpvWithdr
     data: T;
     state: SpvVaultState;
     balances: SpvVaultTokenBalance[];
-    scOpenTx: {
-        txId: string;
-        rawTx: string;
+    scOpenTxs: {
+        [txId: string]: string;
     };
     constructor(chainId: string, vault: T, btcAddress: string);
     constructor(obj: any);

package/dist/swaps/spv_vault_swap/SpvVault.js

@@ -27,7 +27,7 @@ class SpvVault extends base_1.Lockable {
             this.initialUtxo = chainIdOrObj.initialUtxo;
             this.btcAddress = chainIdOrObj.btcAddress;
             this.pendingWithdrawals = chainIdOrObj.pendingWithdrawals.map((base_1.SpvWithdrawalTransactionData.deserialize));
-            this.scOpenTx = chainIdOrObj.scOpenTx;
+            this.scOpenTxs = chainIdOrObj.scOpenTxs;
         }
         this.balances = this.data.calculateStateAfter(this.pendingWithdrawals).balances;
     }
@@ -83,7 +83,7 @@ class SpvVault extends base_1.Lockable {
             initialUtxo: this.initialUtxo,
             btcAddress: this.btcAddress,
             pendingWithdrawals: this.pendingWithdrawals.map(val => val.serialize()),
-            scOpenTx: this.scOpenTx
+            scOpenTxs: this.scOpenTxs
         };
     }
     getIdentifier() {

package/dist/swaps/spv_vault_swap/SpvVaultSwapHandler.js

@@ -23,7 +23,7 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
         this.vaultSigner = spvVaultSigner;
         this.config = config;
         this.AmountAssertions = new FromBtcAmountAssertions_1.FromBtcAmountAssertions(config, swapPricing);
-        this.Vaults = new SpvVaults_1.SpvVaults(vaultStorage, bitcoin, spvVaultSigner, bitcoinRpc, this.getChain.bind(this), config);
+        this.Vaults = new SpvVaults_1.SpvVaults(vaultStorage, bitcoin, spvVaultSigner, bitcoinRpc, this.chains, config);
     }
     async processClaimEvent(swap, event) {
         if (swap == null)
@@ -372,6 +372,7 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
                 data.executionFeeRate !== swap.executionFeeShare ||
                 data.rawAmounts[0] !== swap.rawAmountToken ||
                 data.rawAmounts[1] !== swap.rawAmountGasToken ||
+                data.getExecutionData() != null ||
                 data.getSpentVaultUtxo() !== swap.vaultUtxo ||
                 data.btcTx.outs[0].value !== SpvVaults_1.VAULT_DUST_AMOUNT ||
                 !Buffer.from(data.btcTx.outs[0].scriptPubKey.hex, "hex").equals(this.bitcoin.toOutputScript(swap.vaultAddress)) ||

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

@@ -3,7 +3,7 @@ import { BitcoinRpc, IStorageManager, SpvVaultClaimEvent, SpvVaultCloseEvent, Sp
 import { SpvVaultSwap } from "./SpvVaultSwap";
 import { IBitcoinWallet } from "../../wallets/IBitcoinWallet";
 import { ISpvVaultSigner } from "../../wallets/ISpvVaultSigner";
-import { ChainData } from "../SwapHandler";
+import { MultichainData } from "../SwapHandler";
 export declare const VAULT_DUST_AMOUNT = 600;
 export declare class SpvVaults {
     readonly vaultStorage: IStorageManager<SpvVault>;
@@ -14,9 +14,9 @@ export declare class SpvVaults {
         vaultsCheckInterval: number;
         maxUnclaimedWithdrawals?: number;
     };
-    readonly getChain: (chainId: string) => ChainData;
+    readonly chains: MultichainData;
     readonly logger: import("../../utils/Utils").LoggerType;
-    constructor(vaultStorage: IStorageManager<SpvVault>, bitcoin: IBitcoinWallet, vaultSigner: ISpvVaultSigner, bitcoinRpc: BitcoinRpc<any>, getChain: (chainId: string) => ChainData, config: {
+    constructor(vaultStorage: IStorageManager<SpvVault>, bitcoin: IBitcoinWallet, vaultSigner: ISpvVaultSigner, bitcoinRpc: BitcoinRpc<any>, chains: MultichainData, config: {
         vaultsCheckInterval: number;
         maxUnclaimedWithdrawals?: number;
     });

package/dist/swaps/spv_vault_swap/SpvVaults.js

@@ -10,14 +10,27 @@ exports.VAULT_DUST_AMOUNT = 600;
 const VAULT_INIT_CONFIRMATIONS = 2;
 const BTC_FINALIZATION_CONFIRMATIONS = 6;
 class SpvVaults {
-    constructor(vaultStorage, bitcoin, vaultSigner, bitcoinRpc, getChain, config) {
+    constructor(vaultStorage, bitcoin, vaultSigner, bitcoinRpc, chains, config) {
         this.logger = (0, Utils_1.getLogger)("SpvVaults: ");
         this.vaultStorage = vaultStorage;
         this.bitcoin = bitcoin;
         this.vaultSigner = vaultSigner;
         this.bitcoinRpc = bitcoinRpc;
-        this.getChain = getChain;
+        this.chains = chains;
         this.config = config;
+        for (let chainId in chains.chains) {
+            const { chainInterface } = chains.chains[chainId];
+            chainInterface.onBeforeTxReplace(async (oldTx, oldTxId, newTx, newTxId) => {
+                for (let key in this.vaultStorage.data) {
+                    const vaultData = this.vaultStorage.data[key];
+                    if (vaultData.scOpenTxs != null && vaultData.scOpenTxs[oldTxId] != null) {
+                        vaultData.scOpenTxs[newTxId] = newTx;
+                        await this.saveVault(vaultData);
+                        break;
+                    }
+                }
+            });
+        }
     }
     async processDepositEvent(vault, event) {
         vault.update(event);
@@ -46,7 +59,7 @@ class SpvVaults {
         await this.saveVault(vault);
     }
     async createVaults(chainId, count, token, confirmations = 2, feeRate) {
-        const { signer, chainInterface, tokenMultipliers, spvVaultContract } = this.getChain(chainId);
+        const { signer, chainInterface, tokenMultipliers, spvVaultContract } = this.chains.chains[chainId];
         const signerAddress = signer.getAddress();
         //Check vaultId of the latest saved vault
         let latestVaultId = -1n;
@@ -101,14 +114,14 @@ class SpvVaults {
         return Object.keys(this.vaultStorage.data)
             .map(key => this.vaultStorage.data[key])
             .filter(val => chainId == null ? true : val.chainId === chainId)
-            .filter(val => val.data.getOwner() === this.getChain(val.chainId)?.signer?.getAddress())
+            .filter(val => val.data.getOwner() === this.chains.chains[val.chainId]?.signer?.getAddress())
             .filter(val => token == null ? true : val.data.getTokenData()[0].token === token);
     }
     async fundVault(vault, tokenAmounts) {
         if (vault.state !== SpvVault_1.SpvVaultState.OPENED)
             throw new Error("Vault not opened!");
         this.logger.info("fundVault(): Depositing tokens to the vault " + vault.data.getVaultId().toString(10) + ", amounts: " + tokenAmounts.map(val => val.toString(10)).join(", "));
-        const { signer, spvVaultContract } = this.getChain(vault.chainId);
+        const { signer, spvVaultContract } = this.chains.chains[vault.chainId];
         const txId = await spvVaultContract.deposit(signer, vault.data, tokenAmounts, { waitForConfirmation: true });
         this.logger.info("fundVault(): Tokens deposited to vault " + vault.data.getVaultId().toString(10) + ", amounts: " + tokenAmounts.map(val => val.toString(10)).join(", ") + ", txId: " + txId);
         return txId;
@@ -122,7 +135,7 @@ class SpvVaults {
         });
         if (!vault.isReady())
             throw new Error("Vault not ready, wait for the latest swap to get at least 1 confirmation!");
-        const { signer, spvVaultContract } = this.getChain(vault.chainId);
+        const { signer, spvVaultContract } = this.chains.chains[vault.chainId];
         const latestUtxo = vault.getLatestUtxo();
         const [txId, voutStr] = latestUtxo.split(":");
         const opReturnData = spvVaultContract.toOpReturnData(signer.getAddress(), tokenAmounts);
@@ -186,7 +199,7 @@ class SpvVaults {
         const vaults = Object.keys(this.vaultStorage.data).map(key => this.vaultStorage.data[key]);
         const claimWithdrawals = [];
         for (let vault of vaults) {
-            const { signer, spvVaultContract, chainInterface } = this.getChain(vault.chainId);
+            const { signer, spvVaultContract, chainInterface } = this.chains.chains[vault.chainId];
             if (vault.data.getOwner() !== signer.getAddress())
                 continue;
             if (vault.state === SpvVault_1.SpvVaultState.BTC_INITIATED) {
@@ -204,16 +217,25 @@ class SpvVaults {
             }
             if (vault.state === SpvVault_1.SpvVaultState.BTC_CONFIRMED) {
                 //Check if open txs were sent already
-                if (vault.scOpenTx != null) {
+                if (vault.scOpenTxs != null) {
                     //Check if confirmed
-                    const status = await chainInterface.getTxStatus(vault.scOpenTx.rawTx);
-                    if (status === "pending")
-                        return;
-                    if (status === "success") {
-                        vault.state = SpvVault_1.SpvVaultState.OPENED;
-                        await this.saveVault(vault);
-                        return;
+                    let _continue = false;
+                    for (let txId in vault.scOpenTxs) {
+                        const tx = vault.scOpenTxs[txId];
+                        const status = await chainInterface.getTxStatus(tx);
+                        if (status === "pending") {
+                            _continue = true;
+                            break;
+                        }
+                        if (status === "success") {
+                            vault.state = SpvVault_1.SpvVaultState.OPENED;
+                            await this.saveVault(vault);
+                            _continue = true;
+                            break;
+                        }
                     }
+                    if (_continue)
+                        continue;
                 }
                 const txs = await spvVaultContract.txsOpen(signer.getAddress(), vault.data);
                 let numTx = 0;
@@ -221,7 +243,7 @@ class SpvVaults {
                     numTx++;
                     if (numTx === txs.length) {
                         //Final tx
-                        vault.scOpenTx = { txId, rawTx };
+                        vault.scOpenTxs = { [txId]: rawTx };
                         await this.saveVault(vault);
                     }
                 });
@@ -289,7 +311,7 @@ class SpvVaults {
         }
     }
     async claimWithdrawals(vault, withdrawal) {
-        const { signer, spvVaultContract } = this.getChain(vault.chainId);
+        const { signer, spvVaultContract } = this.chains.chains[vault.chainId];
         try {
             const txId = await spvVaultContract.claim(signer, vault.data, withdrawal.map(tx => {
                 return { tx };
@@ -317,7 +339,7 @@ class SpvVaults {
      * @protected
      */
     async findVaultForSwap(chainIdentifier, totalSats, token, amount, gasToken, gasTokenAmount) {
-        const { signer } = this.getChain(chainIdentifier);
+        const { signer } = this.chains.chains[chainIdentifier];
         const pluginResponse = await PluginManager_1.PluginManager.onVaultSelection(chainIdentifier, totalSats, { token, amount }, { token: gasToken, amount: gasTokenAmount });
         if (pluginResponse != null) {
             AmountAssertions_1.AmountAssertions.handlePluginErrorResponses(pluginResponse);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/lp-lib",
-  "version": "14.0.0-dev.12",
+  "version": "14.0.0-dev.14",
   "description": "Main functionality implementation for atomiq LP node",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",
@@ -22,7 +22,7 @@
   "author": "adambor",
   "license": "ISC",
   "dependencies": {
-    "@atomiqlabs/base": "^10.0.0-dev.7",
+    "@atomiqlabs/base": "^10.0.0-dev.9",
     "@atomiqlabs/server-base": "2.0.0",
     "@scure/btc-signer": "1.6.0",
     "express": "4.21.1",

package/src/swaps/escrow/frombtcln_abstract/FromBtcLnAbs.ts

@@ -9,6 +9,7 @@ import {
     ClaimEvent,
     InitializeEvent,
     RefundEvent,
+    SwapCommitStateType,
     SwapData
 } from "@atomiqlabs/base";
 import {expressHandlerWrapper, getAbortController, HEX_REGEX, isDefinedRuntimeError} from "../../../utils/Utils";
@@ -25,7 +26,7 @@ import {
     LightningNetworkChannel,
     LightningNetworkInvoice
 } from "../../../wallets/ILightningWallet";
-import { LightningAssertions } from "../../assertions/LightningAssertions";
+import {LightningAssertions} from "../../assertions/LightningAssertions";
 
 export type FromBtcLnConfig = FromBtcBaseConfig & {
     invoiceTimeoutSeconds?: number,
@@ -103,34 +104,61 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
             return null;
         }
 
-        if(swap.state===FromBtcLnSwapState.RECEIVED) {
-            const isAuthorizationExpired = await swapContract.isInitAuthorizationExpired(swap.data, swap);
-            if(isAuthorizationExpired) {
-                const isCommited = await swapContract.isCommited(swap.data);
-
-                if(!isCommited) {
-                    this.swapLogger.info(swap, "processPastSwap(state=RECEIVED): swap not committed before authorization expiry, cancelling the LN invoice, invoice: "+swap.pr);
-                    await swap.setState(FromBtcLnSwapState.CANCELED);
-                    return "CANCEL";
+        if(swap.state===FromBtcLnSwapState.RECEIVED || swap.state===FromBtcLnSwapState.COMMITED) {
+            const onchainStatus = await swapContract.getCommitStatus(signer.getAddress(), swap.data);
+            const state: FromBtcLnSwapState = swap.state as FromBtcLnSwapState;
+            if(onchainStatus.type===SwapCommitStateType.PAID) {
+                //Extract the swap secret
+                if(state!==FromBtcLnSwapState.CLAIMED && state!==FromBtcLnSwapState.SETTLED) {
+                    const secretHex = await onchainStatus.getClaimResult();
+                    const secret: Buffer = Buffer.from(secretHex, "hex");
+                    const paymentHash: Buffer = createHash("sha256").update(secret).digest();
+                    const paymentHashHex = paymentHash.toString("hex");
+
+                    if (swap.lnPaymentHash!==paymentHashHex) {
+                        //TODO: Possibly fatal failure
+                        this.swapLogger.error(swap, "processPastSwap(state=RECEIVED|COMMITED): onchainStatus=PAID, Invalid swap secret specified: "+secretHex+" for paymentHash: "+paymentHashHex);
+                        return null;
+                    }
+
+                    swap.secret = secretHex;
+                    await swap.setState(FromBtcLnSwapState.CLAIMED);
+                    await this.saveSwapData(swap);
+
+                    this.swapLogger.warn(swap, "processPastSwap(state=RECEIVED|COMMITED): swap settled (detected from processPastSwap), invoice: "+swap.pr);
+
+                    return "SETTLE";
                 }
-
-                this.swapLogger.info(swap, "processPastSwap(state=RECEIVED): swap committed (detected from processPastSwap), invoice: "+swap.pr);
-                await swap.setState(FromBtcLnSwapState.COMMITED);
-                await this.saveSwapData(swap);
+                return null;
             }
-        }
-
-        if(swap.state===FromBtcLnSwapState.RECEIVED || swap.state===FromBtcLnSwapState.COMMITED) {
-            if(!await swapContract.isExpired(signer.getAddress(), swap.data)) return null;
+            if(onchainStatus.type===SwapCommitStateType.COMMITED) {
+                if(state===FromBtcLnSwapState.RECEIVED) {
+                    await swap.setState(FromBtcLnSwapState.COMMITED);
+                    await this.saveSwapData(swap);
 
-            const isCommited = await swapContract.isCommited(swap.data);
-            if(isCommited) {
-                this.swapLogger.info(swap, "processPastSwap(state=COMMITED): swap timed out, refunding to self, invoice: "+swap.pr);
+                    this.swapLogger.info(swap, "processPastSwap(state=RECEIVED|COMMITED): swap committed (detected from processPastSwap), invoice: "+swap.pr);
+                }
+                return null;
+            }
+            if(onchainStatus.type===SwapCommitStateType.NOT_COMMITED || onchainStatus.type===SwapCommitStateType.EXPIRED) {
+                if(swap.state===FromBtcLnSwapState.RECEIVED) {
+                    const isAuthorizationExpired = await swapContract.isInitAuthorizationExpired(swap.data, swap);
+                    if(isAuthorizationExpired) {
+                        this.swapLogger.info(swap, "processPastSwap(state=RECEIVED|COMMITED): swap not committed before authorization expiry, cancelling the LN invoice, invoice: "+swap.pr);
+                        await swap.setState(FromBtcLnSwapState.CANCELED);
+                        return "CANCEL";
+                    }
+                } else {
+                    if(await swapContract.isExpired(signer.getAddress(), swap.data)) {
+                        this.swapLogger.info(swap, "processPastSwap(state=RECEIVED|COMMITED): swap timed out, refunding to self, invoice: "+swap.pr);
+                        return "REFUND";
+                    }
+                }
+            }
+            if(onchainStatus.type===SwapCommitStateType.REFUNDABLE) {
+                this.swapLogger.info(swap, "processPastSwap(state=RECEIVED|COMMITED): swap timed out, refunding to self, invoice: "+swap.pr);
                 return "REFUND";
             }
-
-            this.swapLogger.info(swap, "processPastSwap(state=RECEIVED): swap timed out, cancelling the LN invoice, invoice: "+swap.pr);
-            return "CANCEL";
         }
 
         if(swap.state===FromBtcLnSwapState.CLAIMED) return "SETTLE";

package/src/swaps/escrow/frombtcln_autoinit/FromBtcLnAuto.ts

@@ -3,7 +3,7 @@ import {createHash} from "crypto";
 import {FromBtcLnAutoSwap, FromBtcLnAutoSwapState} from "./FromBtcLnAutoSwap";
 import {MultichainData, SwapHandlerType} from "../../SwapHandler";
 import {ISwapPrice} from "../../../prices/ISwapPrice";
-import {ChainSwapType, ClaimEvent, InitializeEvent, RefundEvent, SwapData} from "@atomiqlabs/base";
+import {ChainSwapType, ClaimEvent, InitializeEvent, RefundEvent, SwapCommitStateType, SwapData} from "@atomiqlabs/base";
 import {expressHandlerWrapper, getAbortController, HEX_REGEX} from "../../../utils/Utils";
 import {PluginManager} from "../../../plugins/PluginManager";
 import {IIntermediaryStorage} from "../../../storage/IIntermediaryStorage";
@@ -19,6 +19,7 @@ import {
     LightningNetworkInvoice
 } from "../../../wallets/ILightningWallet";
 import {LightningAssertions} from "../../assertions/LightningAssertions";
+import {FromBtcLnSwapState} from "../frombtcln_abstract/FromBtcLnSwapAbs";
 
 export type FromBtcLnAutoConfig = FromBtcBaseConfig & {
     invoiceTimeoutSeconds?: number,
@@ -110,35 +111,61 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
             return null;
         }
 
-        if(swap.state===FromBtcLnAutoSwapState.TXS_SENT) {
-            const isAuthorizationExpired = await swapContract.isInitAuthorizationExpired(swap.data, swap);
-            if(isAuthorizationExpired) {
-                const isCommited = await swapContract.isCommited(swap.data);
+        if(swap.state===FromBtcLnAutoSwapState.TXS_SENT || swap.state===FromBtcLnAutoSwapState.COMMITED) {
+            const onchainStatus = await swapContract.getCommitStatus(signer.getAddress(), swap.data);
+            const state: FromBtcLnAutoSwapState = swap.state as FromBtcLnAutoSwapState;
+            if(onchainStatus.type===SwapCommitStateType.PAID) {
+                //Extract the swap secret
+                if(state!==FromBtcLnAutoSwapState.CLAIMED && state!==FromBtcLnAutoSwapState.SETTLED) {
+                    const secretHex = await onchainStatus.getClaimResult();
+                    const secret: Buffer = Buffer.from(secretHex, "hex");
+                    const paymentHash: Buffer = createHash("sha256").update(secret).digest();
+                    const paymentHashHex = paymentHash.toString("hex");
+
+                    if (swap.lnPaymentHash!==paymentHashHex) {
+                        //TODO: Possibly fatal failure
+                        this.swapLogger.error(swap, "processPastSwap(state=TXS_SENT|COMMITED): onchainStatus=PAID, Invalid swap secret specified: "+secretHex+" for paymentHash: "+paymentHashHex);
+                        return null;
+                    }
 
-                if(!isCommited) {
-                    this.swapLogger.info(swap, "processPastSwap(state=TXS_SENT): swap not committed before authorization expiry, cancelling the LN invoice, invoice: "+swap.pr);
-                    await this.cancelSwapAndInvoice(swap);
-                    return null;
-                }
+                    swap.secret = secretHex;
+                    await swap.setState(FromBtcLnAutoSwapState.CLAIMED);
+                    await this.saveSwapData(swap);
 
-                this.swapLogger.info(swap, "processPastSwap(state=TXS_SENT): swap committed (detected from processPastSwap), invoice: "+swap.pr);
-                await swap.setState(FromBtcLnAutoSwapState.COMMITED);
-                await this.saveSwapData(swap);
-            }
-        }
+                    this.swapLogger.warn(swap, "processPastSwap(state=TXS_SENT|COMMITED): swap settled (detected from processPastSwap), invoice: "+swap.pr);
 
-        if(swap.state===FromBtcLnAutoSwapState.TXS_SENT || swap.state===FromBtcLnAutoSwapState.COMMITED) {
-            if(!await swapContract.isExpired(signer.getAddress(), swap.data)) return null;
+                    return "SETTLE";
+                }
+                return null;
+            }
+            if(onchainStatus.type===SwapCommitStateType.COMMITED) {
+                if(state===FromBtcLnAutoSwapState.TXS_SENT) {
+                    await swap.setState(FromBtcLnAutoSwapState.COMMITED);
+                    await this.saveSwapData(swap);
 
-            const isCommited = await swapContract.isCommited(swap.data);
-            if(isCommited) {
-                this.swapLogger.info(swap, "processPastSwap(state=COMMITED): swap timed out, refunding to self, invoice: "+swap.pr);
+                    this.swapLogger.info(swap, "processPastSwap(state=TXS_SENT|COMMITED): swap committed (detected from processPastSwap), invoice: "+swap.pr);
+                }
+                return null;
+            }
+            if(onchainStatus.type===SwapCommitStateType.NOT_COMMITED || onchainStatus.type===SwapCommitStateType.EXPIRED) {
+                if(swap.state===FromBtcLnAutoSwapState.TXS_SENT) {
+                    const isAuthorizationExpired = await swapContract.isInitAuthorizationExpired(swap.data, swap);
+                    if(isAuthorizationExpired) {
+                        this.swapLogger.info(swap, "processPastSwap(state=TXS_SENT|COMMITED): swap not committed before authorization expiry, cancelling the LN invoice, invoice: "+swap.pr);
+                        await this.cancelSwapAndInvoice(swap);
+                        return null;
+                    }
+                } else {
+                    if(await swapContract.isExpired(signer.getAddress(), swap.data)) {
+                        this.swapLogger.info(swap, "processPastSwap(state=TXS_SENT|COMMITED): swap timed out, refunding to self, invoice: "+swap.pr);
+                        return "REFUND";
+                    }
+                }
+            }
+            if(onchainStatus.type===SwapCommitStateType.REFUNDABLE) {
+                this.swapLogger.info(swap, "processPastSwap(state=TXS_SENT|COMMITED): swap timed out, refunding to self, invoice: "+swap.pr);
                 return "REFUND";
             }
-
-            this.swapLogger.info(swap, "processPastSwap(state=COMMITED): swap timed out, cancelling the LN invoice, invoice: "+swap.pr);
-            await this.cancelSwapAndInvoice(swap);
-            return null;
         }
 
         if(swap.state===FromBtcLnAutoSwapState.CLAIMED) return "SETTLE";

package/src/swaps/spv_vault_swap/SpvVault.ts

@@ -34,7 +34,7 @@ export class SpvVault<
 
     balances: SpvVaultTokenBalance[];
 
-    scOpenTx: {txId: string, rawTx: string};
+    scOpenTxs: {[txId: string]: string};
 
     constructor(chainId: string, vault: T, btcAddress: string);
     constructor(obj: any);
@@ -54,7 +54,7 @@ export class SpvVault<
             this.initialUtxo = chainIdOrObj.initialUtxo;
             this.btcAddress = chainIdOrObj.btcAddress;
             this.pendingWithdrawals = chainIdOrObj.pendingWithdrawals.map(SpvWithdrawalTransactionData.deserialize<D>);
-            this.scOpenTx = chainIdOrObj.scOpenTx;
+            this.scOpenTxs = chainIdOrObj.scOpenTxs;
         }
         this.balances = this.data.calculateStateAfter(this.pendingWithdrawals).balances;
     }
@@ -113,7 +113,7 @@ export class SpvVault<
             initialUtxo: this.initialUtxo,
             btcAddress: this.btcAddress,
             pendingWithdrawals: this.pendingWithdrawals.map(val => val.serialize()),
-            scOpenTx: this.scOpenTx
+            scOpenTxs: this.scOpenTxs
         }
     }
 

package/src/swaps/spv_vault_swap/SpvVaultSwapHandler.ts

@@ -86,7 +86,7 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
         this.vaultSigner = spvVaultSigner;
         this.config = config;
         this.AmountAssertions = new FromBtcAmountAssertions(config, swapPricing);
-        this.Vaults = new SpvVaults(vaultStorage, bitcoin, spvVaultSigner, bitcoinRpc, this.getChain.bind(this), config);
+        this.Vaults = new SpvVaults(vaultStorage, bitcoin, spvVaultSigner, bitcoinRpc, this.chains, config);
     }
 
     protected async processClaimEvent(swap: SpvVaultSwap | null, event: SpvVaultClaimEvent): Promise<void> {
@@ -502,6 +502,7 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
                 data.executionFeeRate!==swap.executionFeeShare ||
                 data.rawAmounts[0]!==swap.rawAmountToken ||
                 data.rawAmounts[1]!==swap.rawAmountGasToken ||
+                data.getExecutionData()!=null ||
                 data.getSpentVaultUtxo()!==swap.vaultUtxo ||
                 data.btcTx.outs[0].value!==VAULT_DUST_AMOUNT ||
                 !Buffer.from(data.btcTx.outs[0].scriptPubKey.hex, "hex").equals(this.bitcoin.toOutputScript(swap.vaultAddress)) ||

package/src/swaps/spv_vault_swap/SpvVaults.ts

@@ -13,7 +13,7 @@ import {PluginManager} from "../../plugins/PluginManager";
 import {IBitcoinWallet} from "../../wallets/IBitcoinWallet";
 import {ISpvVaultSigner} from "../../wallets/ISpvVaultSigner";
 import {AmountAssertions} from "../assertions/AmountAssertions";
-import {ChainData} from "../SwapHandler";
+import {MultichainData} from "../SwapHandler";
 import {Transaction} from "@scure/btc-signer";
 
 export const VAULT_DUST_AMOUNT = 600;
@@ -28,7 +28,7 @@ export class SpvVaults {
     readonly vaultSigner: ISpvVaultSigner;
     readonly bitcoinRpc: BitcoinRpc<any>;
     readonly config: {vaultsCheckInterval: number, maxUnclaimedWithdrawals?: number};
-    readonly getChain: (chainId: string) => ChainData
+    readonly chains: MultichainData;
 
     readonly logger = getLogger("SpvVaults: ");
 
@@ -37,15 +37,29 @@ export class SpvVaults {
         bitcoin: IBitcoinWallet,
         vaultSigner: ISpvVaultSigner,
         bitcoinRpc: BitcoinRpc<any>,
-        getChain: (chainId: string) => ChainData,
+        chains: MultichainData,
         config: {vaultsCheckInterval: number, maxUnclaimedWithdrawals?: number}
     ) {
         this.vaultStorage = vaultStorage;
         this.bitcoin = bitcoin;
         this.vaultSigner = vaultSigner;
         this.bitcoinRpc = bitcoinRpc;
-        this.getChain = getChain;
+        this.chains = chains;
         this.config = config;
+
+        for(let chainId in chains.chains) {
+            const {chainInterface} = chains.chains[chainId];
+            chainInterface.onBeforeTxReplace(async (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => {
+                for(let key in this.vaultStorage.data) {
+                    const vaultData = this.vaultStorage.data[key];
+                    if(vaultData.scOpenTxs!=null && vaultData.scOpenTxs[oldTxId]!=null){
+                        vaultData.scOpenTxs[newTxId] = newTx;
+                        await this.saveVault(vaultData);
+                        break;
+                    }
+                }
+            });
+        }
     }
 
     async processDepositEvent(vault: SpvVault, event: SpvVaultDepositEvent): Promise<void> {
@@ -78,7 +92,7 @@ export class SpvVaults {
     }
 
     async createVaults(chainId: string, count: number, token: string, confirmations: number = 2, feeRate?: number): Promise<{vaultsCreated: bigint[], btcTxId: string}> {
-        const {signer, chainInterface, tokenMultipliers, spvVaultContract} = this.getChain(chainId);
+        const {signer, chainInterface, tokenMultipliers, spvVaultContract} = this.chains.chains[chainId];
 
         const signerAddress = signer.getAddress();
 
@@ -141,7 +155,7 @@ export class SpvVaults {
         return Object.keys(this.vaultStorage.data)
             .map(key => this.vaultStorage.data[key])
             .filter(val => chainId==null ? true : val.chainId===chainId)
-            .filter(val => val.data.getOwner()===this.getChain(val.chainId)?.signer?.getAddress())
+            .filter(val => val.data.getOwner()===this.chains.chains[val.chainId]?.signer?.getAddress())
             .filter(val => token==null ? true : val.data.getTokenData()[0].token===token);
     }
 
@@ -150,7 +164,7 @@ export class SpvVaults {
 
         this.logger.info("fundVault(): Depositing tokens to the vault "+vault.data.getVaultId().toString(10)+", amounts: "+tokenAmounts.map(val => val.toString(10)).join(", "));
 
-        const {signer, spvVaultContract} = this.getChain(vault.chainId);
+        const {signer, spvVaultContract} = this.chains.chains[vault.chainId];
 
         const txId = await spvVaultContract.deposit(signer, vault.data, tokenAmounts, {waitForConfirmation: true});
 
@@ -167,7 +181,7 @@ export class SpvVaults {
 
         if(!vault.isReady()) throw new Error("Vault not ready, wait for the latest swap to get at least 1 confirmation!");
 
-        const {signer, spvVaultContract} = this.getChain(vault.chainId);
+        const {signer, spvVaultContract} = this.chains.chains[vault.chainId];
 
         const latestUtxo = vault.getLatestUtxo();
         const [txId, voutStr] = latestUtxo.split(":");
@@ -239,7 +253,7 @@ export class SpvVaults {
         const claimWithdrawals: {vault: SpvVault, withdrawals: SpvWithdrawalTransactionData[]}[] = [];
 
         for(let vault of vaults) {
-            const {signer, spvVaultContract, chainInterface} = this.getChain(vault.chainId);
+            const {signer, spvVaultContract, chainInterface} = this.chains.chains[vault.chainId];
             if(vault.data.getOwner()!==signer.getAddress()) continue;
 
             if(vault.state===SpvVaultState.BTC_INITIATED) {
@@ -258,15 +272,24 @@ export class SpvVaults {
 
             if(vault.state===SpvVaultState.BTC_CONFIRMED) {
                 //Check if open txs were sent already
-                if(vault.scOpenTx!=null) {
+                if(vault.scOpenTxs!=null) {
                     //Check if confirmed
-                    const status = await chainInterface.getTxStatus(vault.scOpenTx.rawTx);
-                    if(status==="pending") return;
-                    if(status==="success") {
-                        vault.state = SpvVaultState.OPENED;
-                        await this.saveVault(vault);
-                        return;
+                    let _continue = false;
+                    for(let txId in vault.scOpenTxs) {
+                        const tx = vault.scOpenTxs[txId];
+                        const status = await chainInterface.getTxStatus(tx);
+                        if(status==="pending") {
+                            _continue = true;
+                            break;
+                        }
+                        if(status==="success") {
+                            vault.state = SpvVaultState.OPENED;
+                            await this.saveVault(vault);
+                            _continue = true;
+                            break;
+                        }
                     }
+                    if(_continue) continue;
                 }
 
                 const txs = await spvVaultContract.txsOpen(signer.getAddress(), vault.data);
@@ -277,7 +300,7 @@ export class SpvVaults {
                         numTx++;
                         if(numTx===txs.length) {
                             //Final tx
-                            vault.scOpenTx = {txId, rawTx};
+                            vault.scOpenTxs = {[txId]: rawTx};
                             await this.saveVault(vault);
                         }
                     }
@@ -349,7 +372,7 @@ export class SpvVaults {
     }
 
     async claimWithdrawals(vault: SpvVault, withdrawal: SpvWithdrawalTransactionData[]): Promise<boolean> {
-        const {signer, spvVaultContract} = this.getChain(vault.chainId);
+        const {signer, spvVaultContract} = this.chains.chains[vault.chainId];
 
         try {
             const txId = await spvVaultContract.claim(signer, vault.data, withdrawal.map(tx => {
@@ -379,7 +402,7 @@ export class SpvVaults {
      * @protected
      */
     async findVaultForSwap(chainIdentifier: string, totalSats: bigint, token: string, amount: bigint, gasToken: string, gasTokenAmount: bigint): Promise<SpvVault | null> {
-        const {signer} = this.getChain(chainIdentifier);
+        const {signer} = this.chains.chains[chainIdentifier];
 
         const pluginResponse = await PluginManager.onVaultSelection(
             chainIdentifier, totalSats, {token, amount}, {token: gasToken, amount: gasTokenAmount}