@atomiqlabs/lp-lib 17.5.3 → 17.6.0

package/dist/swaps/assertions/FromBtcAmountAssertions.js

@@ -124,8 +124,8 @@ class FromBtcAmountAssertions extends AmountAssertions_1.AmountAssertions {
             const tooLow = amountBD < (min * 95n / 100n);
             const tooHigh = amountBD > (max * 105n / 100n);
             if (tooLow || tooHigh) {
-                const adjustedMin = min * (1000000n - fees.feePPM) / (1000000n - fees.baseFee);
-                const adjustedMax = max * (1000000n - fees.feePPM) / (1000000n - fees.baseFee);
+                const adjustedMin = min * (1000000n - fees.feePPM) / 1000000n - fees.baseFee;
+                const adjustedMax = max * (1000000n - fees.feePPM) / 1000000n - fees.baseFee;
                 const minIn = await this.swapPricing.getFromBtcSwapAmount(adjustedMin, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch);
                 const maxIn = await this.swapPricing.getFromBtcSwapAmount(adjustedMax, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch);
                 throw {

package/dist/swaps/escrow/frombtc_abstract/FromBtcAbs.js

@@ -92,8 +92,13 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
         ]);
         const refundSwaps = [];
         for (let { obj: swap } of queriedData) {
-            if (await this.processPastSwap(swap))
-                refundSwaps.push(swap);
+            try {
+                if (await this.processPastSwap(swap))
+                    refundSwaps.push(swap);
+            }
+            catch (e) {
+                this.swapLogger.error(swap, "processPastSwap(): Error executing watchdog function: ", e);
+            }
         }
         await this.refundSwaps(refundSwaps);
     }
@@ -110,10 +115,15 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             if (unlock == null)
                 continue;
             this.swapLogger.debug(refundSwap, "refundSwaps(): initiate refund of swap");
-            await swapContract.refund(signer, refundSwap.data, true, false, { waitForConfirmation: true });
-            this.swapLogger.info(refundSwap, "refundSwaps(): swap refunded, address: " + refundSwap.address);
-            //The swap should be removed by the event handler
-            await refundSwap.setState(FromBtcSwapAbs_1.FromBtcSwapState.REFUNDED);
+            try {
+                await swapContract.refund(signer, refundSwap.data, true, false, { waitForConfirmation: true });
+                this.swapLogger.info(refundSwap, "refundSwaps(): swap refunded, address: " + refundSwap.address);
+                //The swap should be removed by the event handler
+                await refundSwap.setState(FromBtcSwapAbs_1.FromBtcSwapState.REFUNDED);
+            }
+            catch (e) {
+                this.swapLogger.error(refundSwap, "refundSwaps(): error refunding swap: ", e);
+            }
             unlock();
         }
     }

package/dist/swaps/escrow/frombtcln_abstract/FromBtcLnAbs.d.ts

@@ -9,7 +9,7 @@ import { ILightningWallet } from "../../../wallets/ILightningWallet";
 import { LightningAssertions } from "../../assertions/LightningAssertions";
 export type FromBtcLnConfig = FromBtcBaseConfig & {
     invoiceTimeoutSeconds?: number;
-    minCltv: bigint;
+    destinationHtlcTimeoutSeconds: bigint;
     gracePeriod: bigint;
 };
 export type FromBtcLnRequestType = {
@@ -30,6 +30,7 @@ export declare class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAb
     readonly config: FromBtcLnConfig;
     readonly lightning: ILightningWallet;
     readonly LightningAssertions: LightningAssertions;
+    readonly minCltv: bigint;
     constructor(storageDirectory: IIntermediaryStorage<FromBtcLnSwapAbs>, path: string, chains: MultichainData, lightning: ILightningWallet, swapPricing: ISwapPrice, config: FromBtcLnConfig);
     protected processPastSwap(swap: FromBtcLnSwapAbs): Promise<"REFUND" | "SETTLE" | "CANCEL" | null>;
     protected refundSwaps(refundSwaps: FromBtcLnSwapAbs[]): Promise<void>;
@@ -90,7 +91,6 @@ export declare class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAb
      * @param blockheightPrefetch
      * @param signal
      * @throws {DefinedRuntimeError} Will throw if HTLC expires too soon and therefore cannot be processed
-     * @returns expiry timeout in seconds
      */
     private checkHtlcExpiry;
     /**

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

@@ -25,6 +25,10 @@ class FromBtcLnAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
         this.config.invoiceTimeoutSeconds = this.config.invoiceTimeoutSeconds || 90;
         this.lightning = lightning;
         this.LightningAssertions = new LightningAssertions_1.LightningAssertions(this.logger, lightning);
+        const numerator = (this.config.destinationHtlcTimeoutSeconds + this.config.gracePeriod) * this.config.safetyFactor;
+        this.minCltv = (0, Utils_1.bigIntMax)((numerator + this.config.bitcoinBlocktime - 1n)
+            / this.config.bitcoinBlocktime, //Ceil division
+        (0, Utils_1.getMinSafeBlockWindowFast)(this.config.safetyFactor));
     }
     async processPastSwap(swap) {
         const { swapContract, signer } = this.getChain(swap.chainIdentifier);
@@ -116,9 +120,14 @@ class FromBtcLnAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             if (unlock == null)
                 continue;
             this.swapLogger.debug(refundSwap, "refundSwaps(): initiate refund of swap");
-            await swapContract.refund(signer, refundSwap.data, true, false, { waitForConfirmation: true });
-            this.swapLogger.info(refundSwap, "refundsSwaps(): swap refunded, invoice: " + refundSwap.pr);
-            await refundSwap.setState(FromBtcLnSwapAbs_1.FromBtcLnSwapState.REFUNDED);
+            try {
+                await swapContract.refund(signer, refundSwap.data, true, false, { waitForConfirmation: true });
+                this.swapLogger.info(refundSwap, "refundsSwaps(): swap refunded, invoice: " + refundSwap.pr);
+                await refundSwap.setState(FromBtcLnSwapAbs_1.FromBtcLnSwapState.REFUNDED);
+            }
+            catch (e) {
+                this.swapLogger.error(refundSwap, "refundSwaps(): error refunding swap: ", e);
+            }
             unlock();
         }
     }
@@ -170,16 +179,21 @@ class FromBtcLnAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             }
         ]);
         for (let { obj: swap } of queriedData) {
-            switch (await this.processPastSwap(swap)) {
-                case "CANCEL":
-                    cancelInvoices.push(swap);
-                    break;
-                case "SETTLE":
-                    settleInvoices.push(swap);
-                    break;
-                case "REFUND":
-                    refundSwaps.push(swap);
-                    break;
+            try {
+                switch (await this.processPastSwap(swap)) {
+                    case "CANCEL":
+                        cancelInvoices.push(swap);
+                        break;
+                    case "SETTLE":
+                        settleInvoices.push(swap);
+                        break;
+                    case "REFUND":
+                        refundSwaps.push(swap);
+                        break;
+                }
+            }
+            catch (e) {
+                this.swapLogger.error(swap, "processPastSwap(): Error executing watchdog function: ", e);
             }
         }
         await this.refundSwaps(refundSwaps);
@@ -261,14 +275,13 @@ class FromBtcLnAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
         const balancePrefetch = this.getBalancePrefetch(invoiceData.chainIdentifier, useToken, abortController);
         const blockheightPrefetch = this.getBlockheightPrefetch(abortController);
         const signDataPrefetchPromise = this.getSignDataPrefetch(invoiceData.chainIdentifier, abortController);
-        let expiryTimeout;
         try {
             //Check if we have enough liquidity to proceed
             await this.checkBalance(escrowAmount, balancePrefetch, abortController.signal);
             if (invoiceData.metadata != null)
                 invoiceData.metadata.times.htlcBalanceChecked = Date.now();
             //Check if HTLC expiry is long enough
-            expiryTimeout = await this.checkHtlcExpiry(invoice, blockheightPrefetch, abortController.signal);
+            await this.checkHtlcExpiry(invoice, blockheightPrefetch, abortController.signal);
             if (invoiceData.metadata != null)
                 invoiceData.metadata.times.htlcTimeoutCalculated = Date.now();
         }
@@ -283,7 +296,7 @@ class FromBtcLnAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
         }
         const { swapContract, signer } = this.getChain(invoiceData.chainIdentifier);
         //Create real swap data
-        const payInvoiceObject = await swapContract.createSwapData(base_1.ChainSwapType.HTLC, signer.getAddress(), invoiceData.claimer, useToken, escrowAmount, invoiceData.claimHash, 0n, BigInt(Math.floor(Date.now() / 1000)) + expiryTimeout, false, true, invoiceData.securityDeposit, 0n, invoiceData.depositToken);
+        const payInvoiceObject = await swapContract.createSwapData(base_1.ChainSwapType.HTLC, signer.getAddress(), invoiceData.claimer, useToken, escrowAmount, invoiceData.claimHash, 0n, BigInt(Math.floor(Date.now() / 1000)) + this.config.destinationHtlcTimeoutSeconds, false, true, invoiceData.securityDeposit, 0n, invoiceData.depositToken);
         abortController.signal.throwIfAborted();
         if (invoiceData.metadata != null)
             invoiceData.metadata.times.htlcSwapCreated = Date.now();
@@ -402,25 +415,23 @@ class FromBtcLnAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
      * @param blockheightPrefetch
      * @param signal
      * @throws {DefinedRuntimeError} Will throw if HTLC expires too soon and therefore cannot be processed
-     * @returns expiry timeout in seconds
      */
     async checkHtlcExpiry(invoice, blockheightPrefetch, signal) {
         const timeout = this.getInvoicePaymentsTimeout(invoice);
         const current_block_height = await blockheightPrefetch;
         signal.throwIfAborted();
         const blockDelta = BigInt(timeout - current_block_height);
-        const htlcExpiresTooSoon = blockDelta < this.config.minCltv;
+        const htlcExpiresTooSoon = blockDelta < this.minCltv;
         if (htlcExpiresTooSoon) {
             throw {
                 code: 20002,
                 msg: "Not enough time to reliably process the swap",
                 data: {
-                    requiredDelta: this.config.minCltv.toString(10),
+                    requiredDelta: this.minCltv.toString(10),
                     actualDelta: blockDelta.toString(10)
                 }
             };
         }
-        return (this.config.minCltv * this.config.bitcoinBlocktime / this.config.safetyFactor) - this.config.gracePeriod;
     }
     /**
      * Cancels the swap (CANCELED state) & also cancels the LN invoice (including all pending HTLCs)
@@ -568,7 +579,7 @@ class FromBtcLnAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             //Create swap
             const hodlInvoiceObj = {
                 description: description ?? (chainIdentifier + "-" + parsedBody.address),
-                cltvDelta: Number(this.config.minCltv) + 5,
+                cltvDelta: Number(this.minCltv) + 5,
                 expiresAt: Date.now() + (this.config.invoiceTimeoutSeconds * 1000),
                 id: parsedBody.paymentHash,
                 mtokens: amountBD * 1000n,
@@ -580,8 +591,7 @@ class FromBtcLnAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             metadata.times.invoiceCreated = Date.now();
             metadata.invoiceResponse = { ...hodlInvoice };
             //Pre-compute the security deposit
-            const expiryTimeout = (this.config.minCltv * this.config.bitcoinBlocktime / this.config.safetyFactor) - this.config.gracePeriod;
-            const totalSecurityDeposit = await this.getSecurityDeposit(chainIdentifier, amountBD, swapFee, expiryTimeout, baseSDPromise, depositToken, depositTokenPricePrefetchPromise, fees, abortController.signal, metadata);
+            const totalSecurityDeposit = await this.getSecurityDeposit(chainIdentifier, amountBD, swapFee, this.config.destinationHtlcTimeoutSeconds, baseSDPromise, depositToken, depositTokenPricePrefetchPromise, fees, abortController.signal, metadata);
             metadata.times.securityDepositCalculated = Date.now();
             const createdSwap = new FromBtcLnSwapAbs_1.FromBtcLnSwapAbs(chainIdentifier, hodlInvoice.request, parsedBody.paymentHash, hodlInvoice.mtokens, swapFee, swapFeeInToken, parsedBody.address, useToken, totalInToken, swapContract.getHashForHtlc(Buffer.from(parsedBody.paymentHash, "hex")).toString("hex"), totalSecurityDeposit, depositToken);
             metadata.times.swapCreated = Date.now();
@@ -712,7 +722,7 @@ class FromBtcLnAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
     }
     getInfoData() {
         return {
-            minCltv: Number(this.config.minCltv)
+            minCltv: Number(this.minCltv)
         };
     }
 }

package/dist/swaps/escrow/frombtcln_autoinit/FromBtcLnAuto.d.ts

@@ -9,7 +9,7 @@ import { ILightningWallet } from "../../../wallets/ILightningWallet";
 import { LightningAssertions } from "../../assertions/LightningAssertions";
 export type FromBtcLnAutoConfig = FromBtcBaseConfig & {
     invoiceTimeoutSeconds?: number;
-    minCltv: bigint;
+    destinationHtlcTimeoutSeconds: bigint;
     gracePeriod: bigint;
     gasTokenMax: {
         [chainId: string]: bigint;
@@ -37,6 +37,7 @@ export declare class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoS
     readonly config: FromBtcLnAutoConfig;
     readonly lightning: ILightningWallet;
     readonly LightningAssertions: LightningAssertions;
+    readonly minCltv: bigint;
     constructor(storageDirectory: IIntermediaryStorage<FromBtcLnAutoSwap>, path: string, chains: MultichainData, lightning: ILightningWallet, swapPricing: ISwapPrice, config: FromBtcLnAutoConfig);
     protected processPastSwap(swap: FromBtcLnAutoSwap): Promise<"REFUND" | "SETTLE" | null>;
     protected refundSwaps(refundSwaps: FromBtcLnAutoSwap[]): Promise<void>;
@@ -95,7 +96,6 @@ export declare class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoS
      *
      * @param invoice
      * @throws {DefinedRuntimeError} Will throw if HTLC expires too soon and therefore cannot be processed
-     * @returns expiry timeout in seconds
      */
     private checkHtlcExpiry;
     /**

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

@@ -32,6 +32,10 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             if (!swapContract.supportsInitWithoutClaimer)
                 this.allowedTokens[chain].clear();
         }
+        const numerator = (this.config.destinationHtlcTimeoutSeconds + this.config.gracePeriod) * this.config.safetyFactor;
+        this.minCltv = (0, Utils_1.bigIntMax)((numerator + this.config.bitcoinBlocktime - 1n)
+            / this.config.bitcoinBlocktime, //Ceil division
+        (0, Utils_1.getMinSafeBlockWindowFast)(this.config.safetyFactor));
     }
     async processPastSwap(swap) {
         const { swapContract, signer } = this.getChain(swap.chainIdentifier);
@@ -134,9 +138,14 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             if (unlock == null)
                 continue;
             this.swapLogger.debug(refundSwap, "refundSwaps(): initiate refund of swap");
-            await swapContract.refund(signer, refundSwap.data, true, false, { waitForConfirmation: true });
-            this.swapLogger.info(refundSwap, "refundsSwaps(): swap refunded, invoice: " + refundSwap.pr);
-            await refundSwap.setState(FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.REFUNDED);
+            try {
+                await swapContract.refund(signer, refundSwap.data, true, false, { waitForConfirmation: true });
+                this.swapLogger.info(refundSwap, "refundsSwaps(): swap refunded, invoice: " + refundSwap.pr);
+                await refundSwap.setState(FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.REFUNDED);
+            }
+            catch (e) {
+                this.swapLogger.error(refundSwap, "refundSwaps(): error refunding swap: ", e);
+            }
             unlock();
         }
     }
@@ -174,13 +183,18 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             }
         ]);
         for (let { obj: swap } of queriedData) {
-            switch (await this.processPastSwap(swap)) {
-                case "SETTLE":
-                    settleInvoices.push(swap);
-                    break;
-                case "REFUND":
-                    refundSwaps.push(swap);
-                    break;
+            try {
+                switch (await this.processPastSwap(swap)) {
+                    case "SETTLE":
+                        settleInvoices.push(swap);
+                        break;
+                    case "REFUND":
+                        refundSwaps.push(swap);
+                        break;
+                }
+            }
+            catch (e) {
+                this.swapLogger.error(swap, "processPastSwap(): Error executing watchdog function: ", e);
             }
         }
         await this.refundSwaps(refundSwaps);
@@ -257,10 +271,9 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
         if (invoiceData.metadata != null)
             invoiceData.metadata.times.htlcReceived = Date.now();
         const useToken = invoiceData.token;
-        let expiryTimeout;
         try {
             //Check if HTLC expiry is long enough
-            expiryTimeout = await this.checkHtlcExpiry(invoice);
+            await this.checkHtlcExpiry(invoice);
             if (invoiceData.metadata != null)
                 invoiceData.metadata.times.htlcTimeoutCalculated = Date.now();
         }
@@ -273,7 +286,7 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
         }
         const { swapContract, signer } = this.getChain(invoiceData.chainIdentifier);
         //Create real swap data
-        const swapData = await swapContract.createSwapData(base_1.ChainSwapType.HTLC, signer.getAddress(), invoiceData.claimer, useToken, invoiceData.amountToken, invoiceData.claimHash, 0n, BigInt(Math.floor(Date.now() / 1000)) + expiryTimeout, false, true, invoiceData.amountGasToken + invoiceData.claimerBounty, invoiceData.claimerBounty, invoiceData.gasToken);
+        const swapData = await swapContract.createSwapData(base_1.ChainSwapType.HTLC, signer.getAddress(), invoiceData.claimer, useToken, invoiceData.amountToken, invoiceData.claimHash, 0n, BigInt(Math.floor(Date.now() / 1000)) + this.config.destinationHtlcTimeoutSeconds, false, true, invoiceData.amountGasToken + invoiceData.claimerBounty, invoiceData.claimerBounty, invoiceData.gasToken);
         if (invoiceData.metadata != null)
             invoiceData.metadata.times.htlcSwapCreated = Date.now();
         //Important to prevent race condition and issuing 2 signed init messages at the same time
@@ -440,24 +453,22 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
      *
      * @param invoice
      * @throws {DefinedRuntimeError} Will throw if HTLC expires too soon and therefore cannot be processed
-     * @returns expiry timeout in seconds
      */
     async checkHtlcExpiry(invoice) {
         const timeout = this.getInvoicePaymentsTimeout(invoice);
         const current_block_height = await this.lightning.getBlockheight();
         const blockDelta = BigInt(timeout - current_block_height);
-        const htlcExpiresTooSoon = blockDelta < this.config.minCltv;
+        const htlcExpiresTooSoon = blockDelta < this.minCltv;
         if (htlcExpiresTooSoon) {
             throw {
                 code: 20002,
                 msg: "Not enough time to reliably process the swap",
                 data: {
-                    requiredDelta: this.config.minCltv.toString(10),
+                    requiredDelta: this.minCltv.toString(10),
                     actualDelta: blockDelta.toString(10)
                 }
             };
         }
-        return (this.config.minCltv * this.config.bitcoinBlocktime / this.config.safetyFactor) - this.config.gracePeriod;
     }
     /**
      * Cancels the swap (CANCELED state) & also cancels the LN invoice (including all pending HTLCs)
@@ -630,7 +641,7 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             //Create swap
             const hodlInvoiceObj = {
                 description: description ?? (chainIdentifier + "-" + parsedBody.address),
-                cltvDelta: Number(this.config.minCltv) + 5,
+                cltvDelta: Number(this.minCltv) + 5,
                 expiresAt: Date.now() + (this.config.invoiceTimeoutSeconds * 1000),
                 id: parsedBody.paymentHash,
                 mtokens: totalBtcInput * 1000n,
@@ -721,7 +732,7 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             };
         }
         return {
-            minCltv: Number(this.config.minCltv),
+            minCltv: Number(this.minCltv),
             invoiceTimeoutSeconds: this.config.invoiceTimeoutSeconds,
             gasTokens: mappedDict
         };

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

@@ -91,7 +91,7 @@ export declare class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSw
      * @private
      * @throws DefinedRuntimeError will throw an error in case the actual fee is higher than quoted fee
      */
-    protected checkCalculatedTxFee(quotedSatsPerVbyte: bigint, actualSatsPerVbyte: bigint): void;
+    protected checkCalculatedTxFee(quotedSatsPerVbyte: number, actualSatsPerVbyte: number): void;
     /**
      * Sends a bitcoin transaction to payout BTC for a swap
      *

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

@@ -149,7 +149,8 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
             }
         ]);
         for (let { obj: swap } of queriedData) {
-            await this.processPastSwap(swap);
+            await this.processPastSwap(swap)
+                .catch(e => this.swapLogger.error(swap, "processPastSwap(): Error executing watchdog function: ", e));
         }
     }
     async processBtcTx(swap, tx) {
@@ -285,7 +286,7 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
             if (swap.metadata != null)
                 swap.metadata.times.payCLTVChecked = Date.now();
             const satsPerVbyte = await this.bitcoin.getFeeRate();
-            this.checkCalculatedTxFee(swap.satsPerVbyte, BigInt(satsPerVbyte));
+            this.checkCalculatedTxFee(swap.satsPerVbyte, satsPerVbyte);
             if (swap.metadata != null)
                 swap.metadata.times.payChainFee = Date.now();
             const signResult = await this.bitcoin.getSignedTransaction(swap.address, Number(swap.amount), satsPerVbyte, swap.nonce, Number(swap.satsPerVbyte));
@@ -332,8 +333,14 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
             const isTxSent = tx != null;
             if (!isTxSent) {
                 //Reset the state to COMMITED
-                this.swapLogger.info(swap, "processInitialized(state=BTC_SENDING): btc transaction not found, resetting to COMMITED state, txId: " + swap.txId + " address: " + swap.address);
-                await swap.setState(ToBtcSwapAbs_1.ToBtcSwapState.COMMITED);
+                const walletTx = await this.bitcoin.getWalletTransaction(swap.txId);
+                if (walletTx == null) {
+                    this.swapLogger.info(swap, "processInitialized(state=BTC_SENDING): btc transaction not found, resetting to COMMITED state, txId: " + swap.txId + " address: " + swap.address);
+                    await swap.setState(ToBtcSwapAbs_1.ToBtcSwapState.COMMITED);
+                }
+                else {
+                    this.swapLogger.error(swap, "processInitialized(state=BTC_SENDING): btc transaction not found in mempool, but known to the wallet! txId: " + swap.txId + " address: " + swap.address);
+                }
             }
             else {
                 this.swapLogger.info(swap, "processInitialized(state=BTC_SENDING): btc transaction found, advancing to BTC_SENT state, txId: " + swap.txId + " address: " + swap.address);
@@ -536,7 +543,7 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
             };
         return {
             networkFee: BigInt(chainFeeResp.networkFee),
-            satsPerVbyte: BigInt(chainFeeResp.satsPerVbyte)
+            satsPerVbyte: chainFeeResp.satsPerVbyte
         };
     }
     startRestServer(restServer) {

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

@@ -13,13 +13,13 @@ export declare enum ToBtcSwapState {
 export declare class ToBtcSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T, ToBtcSwapState> {
     sending: boolean;
     readonly address: string;
-    readonly satsPerVbyte: bigint;
+    readonly satsPerVbyte: number;
     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(chainIdentifier: string, address: string, amount: bigint, swapFee: bigint, swapFeeInToken: bigint, networkFee: bigint, networkFeeInToken: bigint, satsPerVbyte: number, nonce: bigint, requiredConfirmations: number, preferedConfirmationTarget: number);
     constructor(obj: any);
     serialize(): any;
     isInitiated(): boolean;

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

@@ -29,7 +29,7 @@ class ToBtcSwapAbs extends ToBtcBaseSwap_1.ToBtcBaseSwap {
         else {
             super(chainIdOrObj);
             this.address = chainIdOrObj.address;
-            this.satsPerVbyte = BigInt(chainIdOrObj.satsPerVbyte);
+            this.satsPerVbyte = Number(chainIdOrObj.satsPerVbyte);
             this.nonce = BigInt(chainIdOrObj.nonce);
             this.requiredConfirmations = chainIdOrObj.requiredConfirmations;
             this.preferedConfirmationTarget = chainIdOrObj.preferedConfirmationTarget;

package/dist/swaps/escrow/tobtcln_abstract/ToBtcLnAbs.js

@@ -100,7 +100,8 @@ class ToBtcLnAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
             }
         ]);
         for (let { obj: swap } of queriedData) {
-            await this.processPastSwap(swap);
+            await this.processPastSwap(swap)
+                .catch(e => this.swapLogger.error(swap, "processPastSwap(): Error executing watchdog function: ", e));
         }
     }
     /**
@@ -198,6 +199,10 @@ class ToBtcLnAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
             this.swapLogger.info(invoiceData, "subscribeToPayment(): result callback, outcome: " + result.status + " invoice: " + invoiceData.pr);
             this.processPaymentResult(invoiceData, result).catch(e => this.swapLogger.error(invoiceData, "subscribeToPayment(): process payment result", e));
             this.activeSubscriptions.delete(paymentHash);
+        }).catch(e => {
+            this.swapLogger.error(invoiceData, "subscribeToPayment(): error while waiting for invoice payment: ", e);
+            //Delete from active subscription, the watchdog will re-subscribe later
+            this.activeSubscriptions.delete(paymentHash);
         });
         this.swapLogger.info(invoiceData, "subscribeToPayment(): subscribe to payment outcome, invoice: " + invoiceData.pr);
         this.activeSubscriptions.add(paymentHash);
@@ -311,6 +316,9 @@ class ToBtcLnAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
                 else
                     throw e;
             }
+            const unlock = swap.lock(120);
+            if (unlock == null)
+                return;
             await swap.setState(ToBtcLnSwapAbs_1.ToBtcLnSwapState.COMMITED);
             await this.saveSwapData(swap);
             try {
@@ -322,13 +330,29 @@ class ToBtcLnAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
                 if ((0, Utils_1.isDefinedRuntimeError)(e)) {
                     if (swap.metadata != null)
                         swap.metadata.payError = e;
-                    await swap.setState(ToBtcLnSwapAbs_1.ToBtcLnSwapState.NON_PAYABLE);
-                    await this.saveSwapData(swap);
-                    return;
+                    const payment = await this.lightning.getPayment(swap.lnPaymentHash);
+                    if (!unlock())
+                        return;
+                    if (payment == null || payment.status === "failed") {
+                        if (swap.state === ToBtcLnSwapAbs_1.ToBtcLnSwapState.COMMITED)
+                            await swap.setState(ToBtcLnSwapAbs_1.ToBtcLnSwapState.NON_PAYABLE);
+                        await this.saveSwapData(swap);
+                        return;
+                    }
+                    else if (payment.status === "confirmed") {
+                        await this.processPaymentResult(swap, payment);
+                        return;
+                    }
+                    else {
+                        //Fall-through to subscribe
+                    }
                 }
                 else
                     throw e;
             }
+            finally {
+                unlock();
+            }
             this.subscribeToPayment(swap);
             return;
         }
@@ -832,6 +856,16 @@ class ToBtcLnAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
                         msg: "Payment expired"
                     };
                 if (data.state === ToBtcLnSwapAbs_1.ToBtcLnSwapState.NON_PAYABLE) {
+                    if (data.payInitiated) {
+                        //Check that the ln payment is indeed non-existent or failed
+                        const lnPayment = await this.lightning.getPayment(data.lnPaymentHash);
+                        if (lnPayment != null && lnPayment.status !== "failed")
+                            throw {
+                                _httpStatus: 200,
+                                code: 20008,
+                                msg: "Payment in-flight"
+                            };
+                    }
                     const refundSigData = await swapContract.getRefundSignature(signer, data.data, this.config.refundAuthorizationTimeout);
                     //Double check the state after promise result
                     if (data.state !== ToBtcLnSwapAbs_1.ToBtcLnSwapState.NON_PAYABLE)

package/dist/swaps/spv_vault_swap/SpvVaultSwapHandler.js

@@ -223,7 +223,8 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
             }
         ]);
         for (let { obj: swap } of swaps) {
-            await this.processPastSwap(swap);
+            await this.processPastSwap(swap)
+                .catch(e => this.swapLogger.error(swap, "processPastSwap(): Error executing watchdog function: ", e));
         }
     }
     getPricePrefetches(chainIdentifier, token, gasToken, abortController) {
@@ -615,14 +616,12 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
                 };
             const pluginCheckResult = await PluginManager_1.PluginManager.onHandlePreFromBtcExecute(SwapHandler_1.SwapHandlerType.FROM_BTC_SPV, swap);
             if ((0, IPlugin_1.isQuoteThrow)(pluginCheckResult)) {
-                const error = {
+                if (swap.state === SpvVaultSwap_1.SpvVaultSwapState.CREATED)
+                    await this.removeSwapData(swap, SpvVaultSwap_1.SpvVaultSwapState.FAILED);
+                throw {
                     code: 29999,
                     msg: pluginCheckResult.message
                 };
-                if (swap.metadata != null)
-                    swap.metadata.postQuoteError = error;
-                await this.removeSwapData(swap, SpvVaultSwap_1.SpvVaultSwapState.FAILED);
-                throw error;
             }
             await this.Vaults.checkVaultReplacedTransactions(vault, true);
             if (swap.vaultUtxo !== vault.getLatestUtxo()) {
@@ -631,24 +630,33 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
                     msg: "Vault UTXO already spent, please get another quote and try again!"
                 };
             }
+            const unlock = swap.lock(120);
+            if (!unlock)
+                throw {
+                    code: 20517,
+                    msg: "Bitcoin transaction submission already in progress, please retry later!"
+                };
+            let swapSendingSet = false;
+            let dataSendingSet = false;
             try {
                 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) {
+                if (swap.state !== SpvVaultSwap_1.SpvVaultSwapState.CREATED)
                     throw {
                         code: 20505,
                         msg: "Invalid quote ID, not found or expired!"
                     };
-                }
                 //Double check in-flight swap count
                 this.checkTooManyInflightSwaps();
                 swap.btcTxId = signedTx.id;
                 swap.state = SpvVaultSwap_1.SpvVaultSwapState.SIGNED;
                 swap.sending = true;
+                swapSendingSet = true;
                 await this.saveSwapData(swap);
                 data.btcTx.raw = btcRawTx;
                 data.sending = true;
                 vault.addWithdrawal(data);
+                dataSendingSet = true;
                 await this.Vaults.saveVault(vault);
                 this.swapLogger.info(swap, "REST: /postQuote: BTC transaction signed, txId: " + swap.btcTxId);
                 try {
@@ -666,15 +674,27 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
                 }
             }
             catch (e) {
-                data.sending = false;
-                swap.sending = false;
-                vault.removeWithdrawal(data);
-                await this.Vaults.saveVault(vault);
-                if ((0, Utils_1.isDefinedRuntimeError)(e) && swap.metadata != null)
-                    swap.metadata.postQuoteError = e;
-                await this.removeSwapData(swap, SpvVaultSwap_1.SpvVaultSwapState.FAILED);
+                if (swapSendingSet)
+                    swap.sending = false;
+                if (dataSendingSet) {
+                    data.sending = false;
+                    vault.removeWithdrawal(data);
+                    await this.Vaults.saveVault(vault);
+                }
+                //Check if the error is only because the state has already changed
+                if (!(0, Utils_1.isDefinedRuntimeError)(e) || e.code !== 20505) {
+                    //We only make the swap failed if the error happened in CREATED or SIGNED states
+                    if (swap.state === SpvVaultSwap_1.SpvVaultSwapState.CREATED || swap.state === SpvVaultSwap_1.SpvVaultSwapState.SIGNED) {
+                        if ((0, Utils_1.isDefinedRuntimeError)(e) && swap.metadata != null)
+                            swap.metadata.postQuoteError = e;
+                        await this.removeSwapData(swap, SpvVaultSwap_1.SpvVaultSwapState.FAILED);
+                    }
+                }
                 throw e;
             }
+            finally {
+                unlock();
+            }
             await responseStream.writeParamsAndEnd({
                 code: 20000,
                 msg: "Success",

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

@@ -246,7 +246,7 @@ class FromBtcTrusted extends SwapHandler_1.SwapHandler {
             if (swap.state !== FromBtcTrustedSwap_1.FromBtcTrustedSwapState.BTC_CONFIRMED)
                 return;
             const txns = await chainInterface.txsTransfer(signer.getAddress(), swap.token, swap.adjustedOutput, swap.dstAddress);
-            let unlock = swap.lock(30 * 1000);
+            let unlock = swap.lock(30);
             if (unlock == null)
                 return;
             const pluginCheckResult = await PluginManager_1.PluginManager.onHandlePreFromBtcExecute(SwapHandler_1.SwapHandlerType.FROM_BTC_TRUSTED, swap);
@@ -341,7 +341,7 @@ class FromBtcTrusted extends SwapHandler_1.SwapHandler {
                 await this.processPastSwap(swap, txs[0]?.tx, txs[0]?.vout);
             }
             catch (e) {
-                this.swapLogger.error(swap, "processPastSwaps(): Error ocurred while processing swap: ", e);
+                this.swapLogger.error(swap, "processPastSwap(): Error executing watchdog function: ", e);
             }
         }
     }