@atomiqlabs/lp-lib 16.0.2 → 16.0.4

package/dist/swaps/SwapHandler.d.ts

@@ -30,6 +30,10 @@ export type SwapBaseConfig = {
     initAuthorizationTimeouts?: {
         [chainId: string]: number;
     };
+    minNativeBalances?: {
+        [chainId: string]: bigint;
+    };
+    maxInflightSwaps?: number;
     bitcoinBlocktime: bigint;
     baseFee: bigint;
     feePPM: bigint;
@@ -76,7 +80,9 @@ export declare abstract class SwapHandler<V extends SwapHandlerSwap<S> = SwapHan
         [chainId: string]: Set<string>;
     };
     readonly swapPricing: ISwapPrice;
+    abstract readonly inflightSwapStates: Set<S>;
     abstract config: SwapBaseConfig;
+    inflightSwaps: Set<string>;
     logger: LoggerType;
     protected swapLogger: {
         debug: (swap: SwapHandlerSwap, msg: string, ...args: any) => void;
@@ -114,6 +120,28 @@ export declare abstract class SwapHandler<V extends SwapHandlerSwap<S> = SwapHan
      */
     protected removeSwapData(swap: V, ultimateState?: S): Promise<void>;
     protected saveSwapData(swap: V): Promise<void>;
+    /**
+     * Pre-fetches native balance to further check if we have enough reserve in a native token
+     *
+     * @param chainIdentifier
+     * @param abortController
+     * @protected
+     */
+    protected prefetchNativeBalanceIfNeeded(chainIdentifier: string, abortController: AbortController): Promise<bigint> | null;
+    /**
+     * Checks if we have enough native balance to facilitate swaps
+     *
+     * @param chainIdentifier
+     * @param balancePrefetch
+     * @param signal
+     * @throws {DefinedRuntimeError} will throw an error if there are not enough funds in the vault
+     */
+    protected checkNativeBalance(chainIdentifier: string, balancePrefetch: Promise<bigint>, signal: AbortSignal | null): Promise<void>;
+    /**
+     * Checks whether there are too many swaps in-flight currently
+     * @private
+     */
+    protected checkTooManyInflightSwaps(): void;
     /**
      * Checks if we have enough balance of the token in the swap vault
      *

package/dist/swaps/SwapHandler.js

@@ -19,6 +19,7 @@ var SwapHandlerType;
  */
 class SwapHandler {
     constructor(storageDirectory, path, chainsData, swapPricing) {
+        this.inflightSwaps = new Set();
         this.logger = (0, Utils_1.getLogger)(() => "SwapHandler(" + this.type + "): ");
         this.swapLogger = {
             debug: (swap, msg, ...args) => this.logger.debug(swap.getIdentifier() + ": " + msg, ...args),
@@ -65,6 +66,8 @@ class SwapHandler {
                 await this.storageManager.removeData(hash, sequence);
                 await this.storageManager.saveData(swap.getIdentifierHash(), swap.getSequence(), swap);
             }
+            if (this.inflightSwapStates.has(swap.state))
+                this.inflightSwaps.add(swap.getIdentifier());
         }
     }
     /**
@@ -74,6 +77,8 @@ class SwapHandler {
      * @param ultimateState set the ultimate state of the swap before removing
      */
     async removeSwapData(swap, ultimateState) {
+        this.inflightSwaps.delete(swap.getIdentifier());
+        this.logger.debug("removeSwapData(): Removing in-flight swap, current in-flight swaps: " + this.inflightSwaps.size);
         if (ultimateState != null)
             await swap.setState(ultimateState);
         if (swap != null)
@@ -82,8 +87,69 @@ class SwapHandler {
         await this.storageManager.removeData(swap.getIdentifierHash(), swap.getSequence());
     }
     async saveSwapData(swap) {
+        if (this.inflightSwapStates.has(swap.state)) {
+            this.inflightSwaps.add(swap.getIdentifier());
+            this.logger.debug("removeSwapData(): Adding in-flight swap, current in-flight swaps: " + this.inflightSwaps.size);
+        }
+        else {
+            this.inflightSwaps.delete(swap.getIdentifier());
+            this.logger.debug("removeSwapData(): Removing in-flight swap, current in-flight swaps: " + this.inflightSwaps.size);
+        }
         await this.storageManager.saveData(swap.getIdentifierHash(), swap.getSequence(), swap);
     }
+    /**
+     * Pre-fetches native balance to further check if we have enough reserve in a native token
+     *
+     * @param chainIdentifier
+     * @param abortController
+     * @protected
+     */
+    prefetchNativeBalanceIfNeeded(chainIdentifier, abortController) {
+        const minNativeTokenReserve = this.config.minNativeBalances?.[chainIdentifier] ?? 0n;
+        if (minNativeTokenReserve === 0n)
+            return null;
+        const { chainInterface, signer } = this.getChain(chainIdentifier);
+        return chainInterface.getBalance(signer.getAddress(), chainInterface.getNativeCurrencyAddress()).catch(e => {
+            this.logger.error("getBalancePrefetch(): balancePrefetch error: ", e);
+            abortController.abort(e);
+            return null;
+        });
+    }
+    /**
+     * Checks if we have enough native balance to facilitate swaps
+     *
+     * @param chainIdentifier
+     * @param balancePrefetch
+     * @param signal
+     * @throws {DefinedRuntimeError} will throw an error if there are not enough funds in the vault
+     */
+    async checkNativeBalance(chainIdentifier, balancePrefetch, signal) {
+        if (signal != null)
+            signal.throwIfAborted();
+        const minNativeTokenReserve = this.config.minNativeBalances?.[chainIdentifier] ?? 0n;
+        if (minNativeTokenReserve === 0n)
+            return;
+        const balance = await balancePrefetch;
+        if (balance == null || balance < minNativeTokenReserve) {
+            throw {
+                code: 20012,
+                msg: "LP ran out of native token to cover gas fees"
+            };
+        }
+    }
+    /**
+     * Checks whether there are too many swaps in-flight currently
+     * @private
+     */
+    checkTooManyInflightSwaps() {
+        if (this.config.maxInflightSwaps == null)
+            return;
+        if (this.inflightSwaps.size >= this.config.maxInflightSwaps)
+            throw {
+                code: 20013,
+                msg: "LP has too many in-flight swaps, retry later!"
+            };
+    }
     /**
      * Checks if we have enough balance of the token in the swap vault
      *

package/dist/swaps/escrow/frombtc_abstract/FromBtcAbs.d.ts

@@ -23,6 +23,7 @@ export type FromBtcRequestType = {
 export declare class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSwapState> {
     readonly type = SwapHandlerType.FROM_BTC;
     readonly swapType = ChainSwapType.CHAIN;
+    readonly inflightSwapStates: Set<FromBtcSwapState>;
     readonly config: FromBtcConfig & {
         swapTsCsvDelta: bigint;
     };

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

@@ -18,6 +18,7 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
         super(storageDirectory, path, chains, swapPricing, config);
         this.type = SwapHandler_1.SwapHandlerType.FROM_BTC;
         this.swapType = base_1.ChainSwapType.CHAIN;
+        this.inflightSwapStates = new Set([FromBtcSwapAbs_1.FromBtcSwapState.COMMITED]);
         this.bitcoin = bitcoin;
         this.config = {
             ...config,
@@ -225,6 +226,7 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             };
             const useToken = parsedBody.token;
             //Check request params
+            this.checkTooManyInflightSwaps();
             this.checkSequence(parsedBody.sequence);
             const fees = await this.AmountAssertions.preCheckFromBtcAmounts(this.type, request, requestedAmount);
             metadata.times.requestChecked = Date.now();
@@ -235,9 +237,11 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             const { pricePrefetchPromise, gasTokenPricePrefetchPromise, depositTokenPricePrefetchPromise } = this.getFromBtcPricePrefetches(chainIdentifier, useToken, depositToken, abortController);
             const balancePrefetch = this.getBalancePrefetch(chainIdentifier, useToken, abortController);
             const signDataPrefetchPromise = this.getSignDataPrefetch(chainIdentifier, abortController, responseStream);
+            const nativeBalancePrefetch = this.prefetchNativeBalanceIfNeeded(chainIdentifier, abortController);
             const dummySwapData = await this.getDummySwapData(chainIdentifier, useToken, parsedBody.address);
             abortController.signal.throwIfAborted();
             const baseSDPromise = this.getBaseSecurityDepositPrefetch(chainIdentifier, dummySwapData, depositToken, gasTokenPricePrefetchPromise, depositTokenPricePrefetchPromise, abortController);
+            await this.checkNativeBalance(chainIdentifier, nativeBalancePrefetch, abortController.signal);
             //Check valid amount specified (min/max)
             const { amountBD, swapFee, swapFeeInToken, totalInToken, securityDepositApyPPM, securityDepositBaseMultiplierPPM } = await this.AmountAssertions.checkFromBtcAmount(this.type, request, { ...requestedAmount, pricePrefetch: pricePrefetchPromise }, fees, abortController.signal);
             metadata.times.priceCalculated = Date.now();

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

@@ -26,6 +26,7 @@ export type FromBtcLnRequestType = {
 export declare class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromBtcLnSwapState> {
     readonly type = SwapHandlerType.FROM_BTCLN;
     readonly swapType = ChainSwapType.HTLC;
+    readonly inflightSwapStates: Set<FromBtcLnSwapState>;
     readonly config: FromBtcLnConfig;
     readonly lightning: ILightningWallet;
     readonly LightningAssertions: LightningAssertions;

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

@@ -19,6 +19,7 @@ class FromBtcLnAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
         super(storageDirectory, path, chains, swapPricing, config);
         this.type = SwapHandler_1.SwapHandlerType.FROM_BTCLN;
         this.swapType = base_1.ChainSwapType.HTLC;
+        this.inflightSwapStates = new Set([FromBtcLnSwapAbs_1.FromBtcLnSwapState.RECEIVED, FromBtcLnSwapAbs_1.FromBtcLnSwapState.COMMITED, FromBtcLnSwapAbs_1.FromBtcLnSwapState.CLAIMED]);
         this.config = config;
         this.config.invoiceTimeoutSeconds = this.config.invoiceTimeoutSeconds || 90;
         this.lightning = lightning;
@@ -48,11 +49,6 @@ class FromBtcLnAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             catch (e) {
                 this.swapLogger.error(swap, "processPastSwap(state=CREATED): htlcReceived error", e);
             }
-            // @ts-ignore Previous call (htlcReceived) mutates the state of the swap, so this is valid
-            if (swap.state === FromBtcLnSwapAbs_1.FromBtcLnSwapState.CANCELED) {
-                this.swapLogger.info(swap, "processPastSwap(state=CREATED): invoice CANCELED after htlcReceived(), cancelling, invoice: " + swap.pr);
-                return "CANCEL";
-            }
             return null;
         }
         if (swap.state === FromBtcLnSwapAbs_1.FromBtcLnSwapState.RECEIVED || swap.state === FromBtcLnSwapAbs_1.FromBtcLnSwapState.COMMITED) {
@@ -248,6 +244,16 @@ class FromBtcLnAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             invoiceData.metadata.times.htlcReceived = Date.now();
         const useToken = invoiceData.token;
         const escrowAmount = invoiceData.totalTokens;
+        try {
+            this.checkTooManyInflightSwaps();
+        }
+        catch (e) {
+            if ((0, Utils_1.isDefinedRuntimeError)(e) && invoiceData.metadata != null)
+                invoiceData.metadata.htlcReceiveError = e;
+            if (invoiceData.state === FromBtcLnSwapAbs_1.FromBtcLnSwapState.CREATED)
+                await this.cancelSwapAndInvoice(invoiceData);
+            throw e;
+        }
         //Create abort controller for parallel fetches
         const abortController = new AbortController();
         //Pre-fetch data
@@ -267,6 +273,8 @@ class FromBtcLnAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
         }
         catch (e) {
             if (!abortController.signal.aborted) {
+                if ((0, Utils_1.isDefinedRuntimeError)(e) && invoiceData.metadata != null)
+                    invoiceData.metadata.htlcReceiveError = e;
                 if (invoiceData.state === FromBtcLnSwapAbs_1.FromBtcLnSwapState.CREATED)
                     await this.cancelSwapAndInvoice(invoiceData);
             }
@@ -285,6 +293,17 @@ class FromBtcLnAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             invoiceData.metadata.times.htlcSwapSigned = Date.now();
         //Important to prevent race condition and issuing 2 signed init messages at the same time
         if (invoiceData.state === FromBtcLnSwapAbs_1.FromBtcLnSwapState.CREATED) {
+            //Re-check right before signing
+            try {
+                this.checkTooManyInflightSwaps();
+            }
+            catch (e) {
+                if ((0, Utils_1.isDefinedRuntimeError)(e) && invoiceData.metadata != null)
+                    invoiceData.metadata.htlcReceiveError = e;
+                if (invoiceData.state === FromBtcLnSwapAbs_1.FromBtcLnSwapState.CREATED)
+                    await this.cancelSwapAndInvoice(invoiceData);
+                throw e;
+            }
             invoiceData.data = payInvoiceObject;
             invoiceData.prefix = sigData.prefix;
             invoiceData.timeout = sigData.timeout;
@@ -500,6 +519,7 @@ class FromBtcLnAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             };
             const useToken = parsedBody.token;
             //Check request params
+            this.checkTooManyInflightSwaps();
             this.checkDescriptionHash(parsedBody.descriptionHash);
             const fees = await this.AmountAssertions.preCheckFromBtcAmounts(this.type, request, requestedAmount);
             metadata.times.requestChecked = Date.now();
@@ -510,11 +530,13 @@ class FromBtcLnAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             const { pricePrefetchPromise, gasTokenPricePrefetchPromise, depositTokenPricePrefetchPromise } = this.getFromBtcPricePrefetches(chainIdentifier, useToken, depositToken, abortController);
             const balancePrefetch = this.getBalancePrefetch(chainIdentifier, useToken, abortController);
             const channelsPrefetch = this.LightningAssertions.getChannelsPrefetch(abortController);
+            const nativeBalancePrefetch = this.prefetchNativeBalanceIfNeeded(chainIdentifier, abortController);
             const dummySwapData = await this.getDummySwapData(chainIdentifier, useToken, parsedBody.address, parsedBody.paymentHash);
             abortController.signal.throwIfAborted();
             const baseSDPromise = this.getBaseSecurityDepositPrefetch(chainIdentifier, dummySwapData, depositToken, gasTokenPricePrefetchPromise, depositTokenPricePrefetchPromise, abortController);
             //Asynchronously send the node's public key to the client
             this.sendPublicKeyAsync(responseStream);
+            await this.checkNativeBalance(chainIdentifier, nativeBalancePrefetch, abortController.signal);
             //Check valid amount specified (min/max)
             const { amountBD, swapFee, swapFeeInToken, totalInToken, securityDepositApyPPM, securityDepositBaseMultiplierPPM } = await this.AmountAssertions.checkFromBtcAmount(this.type, request, { ...requestedAmount, pricePrefetch: pricePrefetchPromise }, fees, abortController.signal);
             metadata.times.priceCalculated = Date.now();

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

@@ -8,10 +8,6 @@ import { FromBtcBaseConfig, FromBtcBaseSwapHandler } from "../FromBtcBaseSwapHan
 import { ILightningWallet } from "../../../wallets/ILightningWallet";
 import { LightningAssertions } from "../../assertions/LightningAssertions";
 export type FromBtcLnAutoConfig = FromBtcBaseConfig & {
-    maxInflightHtlcs?: number;
-    minNativeBalances?: {
-        [chainId: string]: bigint;
-    };
     invoiceTimeoutSeconds?: number;
     minCltv: bigint;
     gracePeriod: bigint;
@@ -36,8 +32,8 @@ export type FromBtcLnAutoRequestType = {
 export declare class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, FromBtcLnAutoSwapState> {
     readonly type = SwapHandlerType.FROM_BTCLN_AUTO;
     readonly swapType = ChainSwapType.HTLC;
+    readonly inflightSwapStates: Set<FromBtcLnAutoSwapState>;
     activeSubscriptions: Set<string>;
-    swapsWithInflighHtlcs: Set<FromBtcLnAutoSwap>;
     readonly config: FromBtcLnAutoConfig;
     readonly lightning: ILightningWallet;
     readonly LightningAssertions: LightningAssertions;
@@ -110,9 +106,7 @@ export declare class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoS
      * @returns the fetched lightning invoice
      */
     private checkInvoiceStatus;
-    private checkTooManyInflightHtlcs;
     startRestServer(restServer: Express): void;
     init(): Promise<void>;
     getInfoData(): any;
-    protected removeSwapData(swap: FromBtcLnAutoSwap, ultimateState?: FromBtcLnAutoSwapState): Promise<void>;
 }

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

@@ -19,8 +19,8 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
         super(storageDirectory, path, chains, swapPricing, config);
         this.type = SwapHandler_1.SwapHandlerType.FROM_BTCLN_AUTO;
         this.swapType = base_1.ChainSwapType.HTLC;
+        this.inflightSwapStates = new Set([FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.TXS_SENT, FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.COMMITED, FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.CLAIMED]);
         this.activeSubscriptions = new Set();
-        this.swapsWithInflighHtlcs = new Set();
         this.config = config;
         this.config.invoiceTimeoutSeconds = this.config.invoiceTimeoutSeconds || 90;
         this.lightning = lightning;
@@ -64,7 +64,6 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             return null;
         }
         if (swap.state === FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.TXS_SENT || swap.state === FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.COMMITED) {
-            this.swapsWithInflighHtlcs.add(swap);
             const onchainStatus = await swapContract.getCommitStatus(signer.getAddress(), swap.data);
             const state = swap.state;
             if (onchainStatus.type === base_1.SwapCommitStateType.PAID) {
@@ -285,7 +284,7 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
         if (invoiceData.state !== FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.RECEIVED)
             return;
         try {
-            this.checkTooManyInflightHtlcs();
+            this.checkTooManyInflightSwaps();
         }
         catch (e) {
             if ((0, Utils_1.isDefinedRuntimeError)(e) && invoiceData.metadata != null)
@@ -302,14 +301,10 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
         const { swapContract, signer, chainInterface } = this.getChain(invoiceData.chainIdentifier);
         //Create abort controller for parallel fetches
         const abortController = new AbortController();
-        //Minimum reserve of native token to be kept in the wallet
-        const minNativeTokenReserve = this.config.minNativeBalances?.[invoiceData.chainIdentifier] ?? 0n;
         //Pre-fetch data
         const balancePrefetch = this.getBalancePrefetch(invoiceData.chainIdentifier, useToken, abortController);
         const gasTokenBalancePrefetch = invoiceData.getTotalOutputGasAmount() === 0n || useToken === gasToken ?
             null : this.getBalancePrefetch(invoiceData.chainIdentifier, gasToken, abortController);
-        const nativeBalancePrefetch = minNativeTokenReserve === 0n ?
-            null : this.getBalancePrefetch(invoiceData.chainIdentifier, chainInterface.getNativeCurrencyAddress(), abortController, false);
         if (await swapContract.getInitAuthorizationExpiry(invoiceData.data, invoiceData) < Date.now()) {
             if (invoiceData.metadata != null)
                 invoiceData.metadata.htlcOfferError = "Init authorization expired, before being sent!";
@@ -318,18 +313,6 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             }
             return false;
         }
-        try {
-            await this.checkBalance(minNativeTokenReserve, nativeBalancePrefetch, abortController.signal);
-        }
-        catch (e) {
-            if (!abortController.signal.aborted) {
-                if ((0, Utils_1.isDefinedRuntimeError)(e) && invoiceData.metadata != null)
-                    invoiceData.metadata.htlcOfferError = "Not enough native balance!";
-                if (invoiceData.state === FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.RECEIVED)
-                    await this.cancelSwapAndInvoice(invoiceData);
-            }
-            throw e;
-        }
         try {
             //Check if we have enough liquidity to proceed
             if (useToken === gasToken) {
@@ -360,7 +343,7 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
         if (invoiceData.state === FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.RECEIVED) {
             //Re-check the current HTLC count
             try {
-                this.checkTooManyInflightHtlcs();
+                this.checkTooManyInflightSwaps();
             }
             catch (e) {
                 if ((0, Utils_1.isDefinedRuntimeError)(e) && invoiceData.metadata != null)
@@ -369,8 +352,7 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
                     await this.cancelSwapAndInvoice(invoiceData);
                 throw e;
             }
-            this.swapLogger.debug(invoiceData, `offerHtlc(): Sending HTLC offer, current in flight HTLCs: ${this.swapsWithInflighHtlcs.size}, invoice: `, invoiceData.pr);
-            this.swapsWithInflighHtlcs.add(invoiceData);
+            this.swapLogger.debug(invoiceData, `offerHtlc(): Sending HTLC offer, current in flight swaps: ${this.inflightSwaps.size}, invoice: `, invoiceData.pr);
             //Setting the state variable is done outside the promise, so is done synchronously
             await invoiceData.setState(FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.TXS_SENT);
             await this.saveSwapData(invoiceData);
@@ -511,15 +493,6 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
                 return invoice;
         }
     }
-    checkTooManyInflightHtlcs() {
-        if (this.config.maxInflightHtlcs == null)
-            return;
-        if (this.swapsWithInflighHtlcs.size >= this.config.maxInflightHtlcs)
-            throw {
-                code: 20401,
-                msg: "Too many in-flight HTLCs, retry later!"
-            };
-    }
     startRestServer(restServer) {
         restServer.use(this.path + "/createInvoice", (0, ServerParamDecoder_1.serverParamDecoder)(10 * 1000));
         restServer.post(this.path + "/createInvoice", (0, Utils_1.expressHandlerWrapper)(async (req, res) => {
@@ -600,21 +573,18 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             const gasToken = parsedBody.gasToken;
             //Check request params
             this.checkDescriptionHash(parsedBody.descriptionHash);
-            this.checkTooManyInflightHtlcs();
+            this.checkTooManyInflightSwaps();
             const fees = await this.AmountAssertions.preCheckFromBtcAmounts(this.type, request, requestedAmount, gasTokenAmount);
             metadata.times.requestChecked = Date.now();
             //Create abortController for parallel prefetches
             const responseStream = res.responseStream;
             const abortController = (0, Utils_1.getAbortController)(responseStream);
-            //Minimum reserve of native token to be kept in the wallet
-            const minNativeTokenReserve = this.config.minNativeBalances?.[chainIdentifier] ?? 0n;
             //Pre-fetch data
             const { pricePrefetchPromise, gasTokenPricePrefetchPromise } = this.getFromBtcPricePrefetches(chainIdentifier, useToken, gasToken, abortController);
             const balancePrefetch = this.getBalancePrefetch(chainIdentifier, useToken, abortController);
             const gasTokenBalancePrefetch = gasTokenAmount.amount === 0n || useToken === gasToken ?
                 null : this.getBalancePrefetch(chainIdentifier, gasToken, abortController);
-            const nativeTokenBalancePrefetch = minNativeTokenReserve === 0n ?
-                null : this.getBalancePrefetch(chainIdentifier, chainInterface.getNativeCurrencyAddress(), abortController, false);
+            const nativeTokenBalancePrefetch = this.prefetchNativeBalanceIfNeeded(chainIdentifier, abortController);
             const channelsPrefetch = this.LightningAssertions.getChannelsPrefetch(abortController);
             //Asynchronously send the node's public key to the client
             this.sendPublicKeyAsync(responseStream);
@@ -623,7 +593,7 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             metadata.times.priceCalculated = Date.now();
             const totalBtcInput = amountBD + amountBDgas;
             //Check if we have at least the minimum needed native balance
-            await this.checkBalance(minNativeTokenReserve, nativeTokenBalancePrefetch, abortController.signal);
+            await this.checkNativeBalance(chainIdentifier, nativeTokenBalancePrefetch, abortController.signal);
             //Check if we have enough funds to honor the request
             if (useToken === gasToken) {
                 await this.checkBalance(totalInToken + totalInGasToken, balancePrefetch, abortController.signal);
@@ -734,9 +704,5 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             gasTokens: mappedDict
         };
     }
-    async removeSwapData(swap, ultimateState) {
-        this.swapsWithInflighHtlcs.delete(swap);
-        return super.removeSwapData(swap, ultimateState);
-    }
 }
 exports.FromBtcLnAuto = FromBtcLnAuto;

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

@@ -32,6 +32,7 @@ export type ToBtcRequestType = {
 export declare class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState> {
     readonly type = SwapHandlerType.TO_BTC;
     readonly swapType = ChainSwapType.CHAIN_NONCED;
+    readonly inflightSwapStates: Set<ToBtcSwapState>;
     activeSubscriptions: {
         [txId: string]: ToBtcSwapAbs;
     };

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

@@ -21,6 +21,7 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
         super(storageDirectory, path, chainData, swapPricing, config);
         this.type = SwapHandler_1.SwapHandlerType.TO_BTC;
         this.swapType = base_1.ChainSwapType.CHAIN_NONCED;
+        this.inflightSwapStates = new Set([ToBtcSwapAbs_1.ToBtcSwapState.BTC_SENDING, ToBtcSwapAbs_1.ToBtcSwapState.BTC_SENT]);
         this.activeSubscriptions = {};
         this.bitcoinRpc = bitcoinRpc;
         this.bitcoin = bitcoin;
@@ -277,6 +278,7 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
         // e.g. that 2 payouts share the same input and would effectively double-spend each other
         return this.bitcoin.execute(async () => {
             //Run checks
+            this.checkTooManyInflightSwaps();
             this.checkExpiresTooSoon(swap);
             if (swap.metadata != null)
                 swap.metadata.times.payCLTVChecked = Date.now();
@@ -563,6 +565,7 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
             };
             const useToken = parsedBody.token;
             const responseStream = res.responseStream;
+            this.checkTooManyInflightSwaps();
             this.checkNonceValid(parsedBody.nonce);
             this.checkConfirmationTarget(parsedBody.confirmationTarget);
             this.checkRequiredConfirmations(parsedBody.confirmations);
@@ -573,6 +576,8 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
             //Initialize abort controller for the parallel async operations
             const abortController = (0, Utils_1.getAbortController)(responseStream);
             const { pricePrefetchPromise, signDataPrefetchPromise } = this.getToBtcPrefetches(chainIdentifier, useToken, responseStream, abortController);
+            const nativeBalancePrefetch = this.prefetchNativeBalanceIfNeeded(chainIdentifier, abortController);
+            await this.checkNativeBalance(chainIdentifier, nativeBalancePrefetch, abortController.signal);
             const { amountBD, networkFeeData, totalInToken, swapFee, swapFeeInToken, networkFeeInToken } = await this.AmountAssertions.checkToBtcAmount(this.type, request, { ...requestedAmount, pricePrefetch: pricePrefetchPromise }, fees, async (amount) => {
                 metadata.times.amountsChecked = Date.now();
                 const resp = await this.checkAndGetNetworkFee(parsedBody.address, amount);

package/dist/swaps/escrow/tobtcln_abstract/ToBtcLnAbs.d.ts

@@ -55,9 +55,10 @@ export type ToBtcLnRequestType = {
  * Swap handler handling to BTCLN swaps using submarine swaps
  */
 export declare class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwapState> {
-    activeSubscriptions: Set<string>;
     readonly type = SwapHandlerType.TO_BTCLN;
     readonly swapType = ChainSwapType.HTLC;
+    readonly inflightSwapStates: Set<ToBtcLnSwapState>;
+    activeSubscriptions: Set<string>;
     readonly config: ToBtcLnConfig & {
         minTsSendCltv: bigint;
     };

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

@@ -18,9 +18,10 @@ const LightningAssertions_1 = require("../../assertions/LightningAssertions");
 class ToBtcLnAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
     constructor(storageDirectory, path, chainData, lightning, swapPricing, config) {
         super(storageDirectory, path, chainData, swapPricing, config);
-        this.activeSubscriptions = new Set();
         this.type = SwapHandler_1.SwapHandlerType.TO_BTCLN;
         this.swapType = base_1.ChainSwapType.HTLC;
+        this.inflightSwapStates = new Set([ToBtcLnSwapAbs_1.ToBtcLnSwapState.COMMITED, ToBtcLnSwapAbs_1.ToBtcLnSwapState.PAID]);
+        this.activeSubscriptions = new Set();
         this.exactInAuths = {};
         this.lightning = lightning;
         this.LightningAssertions = new LightningAssertions_1.LightningAssertions(this.logger, lightning);
@@ -288,6 +289,21 @@ class ToBtcLnAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
             }
         }
         if (swap.state === ToBtcLnSwapAbs_1.ToBtcLnSwapState.SAVED) {
+            try {
+                this.checkTooManyInflightSwaps();
+            }
+            catch (e) {
+                this.swapLogger.error(swap, "processInitialized(): checking too many inflight swaps error: ", e);
+                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;
+                }
+                else
+                    throw e;
+            }
             await swap.setState(ToBtcLnSwapAbs_1.ToBtcLnSwapState.COMMITED);
             await this.saveSwapData(swap);
             try {
@@ -553,10 +569,11 @@ class ToBtcLnAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
                     msg: "Invalid request body"
                 };
             }
+            this.checkTooManyInflightSwaps();
+            const parsedAuth = this.checkExactInAuthorization(parsedBody.reqId);
             const responseStream = res.responseStream;
             const abortSignal = responseStream.getAbortSignal();
             //Check request params
-            const parsedAuth = this.checkExactInAuthorization(parsedBody.reqId);
             const { parsedPR, halfConfidence } = await this.checkPaymentRequest(parsedAuth.chainIdentifier, parsedBody.pr);
             await this.checkPaymentRequestMatchesInitial(parsedBody.pr, parsedAuth);
             const metadata = parsedAuth.metadata;
@@ -650,6 +667,7 @@ class ToBtcLnAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
             const responseStream = res.responseStream;
             const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
             //Check request params
+            this.checkTooManyInflightSwaps();
             this.checkAmount(parsedBody.amount, parsedBody.exactIn);
             this.checkMaxFee(parsedBody.maxFee);
             this.checkExpiry(parsedBody.expiryTimestamp, currentTimestamp);
@@ -666,9 +684,12 @@ class ToBtcLnAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
             const abortController = (0, Utils_1.getAbortController)(responseStream);
             //Pre-fetch
             const { pricePrefetchPromise, signDataPrefetchPromise } = this.getToBtcPrefetches(chainIdentifier, useToken, responseStream, abortController);
+            const nativeBalancePrefetch = this.prefetchNativeBalanceIfNeeded(chainIdentifier, abortController);
             //Check if prior payment has been made
             await this.LightningAssertions.checkPriorPayment(parsedPR.id, abortController.signal);
             metadata.times.priorPaymentChecked = Date.now();
+            //Check if we still have enough native balance
+            await this.checkNativeBalance(chainIdentifier, nativeBalancePrefetch, abortController.signal);
             //Check amounts
             const { amountBD, networkFeeData, totalInToken, swapFee, swapFeeInToken, networkFeeInToken } = await this.AmountAssertions.checkToBtcAmount(this.type, request, { ...requestedAmount, pricePrefetch: pricePrefetchPromise }, fees, async (amountBD) => {
                 //Check if we have enough liquidity to process the swap

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

@@ -32,6 +32,7 @@ export type SpvVaultPostQuote = {
 };
 export declare class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapState> {
     readonly type = SwapHandlerType.FROM_BTC_SPV;
+    readonly inflightSwapStates: Set<SpvVaultSwapState>;
     readonly bitcoin: IBitcoinWallet;
     readonly bitcoinRpc: BitcoinRpc<BtcBlock>;
     readonly vaultSigner: ISpvVaultSigner;

package/dist/swaps/spv_vault_swap/SpvVaultSwapHandler.js

@@ -19,6 +19,7 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
     constructor(storageDirectory, vaultStorage, path, chainsData, swapPricing, bitcoin, bitcoinRpc, spvVaultSigner, config) {
         super(storageDirectory, path, chainsData, swapPricing);
         this.type = SwapHandler_1.SwapHandlerType.FROM_BTC_SPV;
+        this.inflightSwapStates = new Set([SpvVaultSwap_1.SpvVaultSwapState.SIGNED, SpvVaultSwap_1.SpvVaultSwapState.SENT, SpvVaultSwap_1.SpvVaultSwapState.BTC_CONFIRMED]);
         this.btcTxIdIndex = new Map();
         this.bitcoinRpc = bitcoinRpc;
         this.bitcoin = bitcoin;
@@ -246,6 +247,7 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
             };
             const useToken = parsedBody.token;
             const gasToken = parsedBody.gasToken;
+            this.checkTooManyInflightSwaps();
             //Check request params
             const fees = await this.AmountAssertions.preCheckFromBtcAmounts(this.type, request, requestedAmount, gasTokenAmount);
             metadata.times.requestChecked = Date.now();
@@ -254,6 +256,8 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
             const abortController = (0, Utils_1.getAbortController)(responseStream);
             //Pre-fetch data
             const { pricePrefetchPromise, gasTokenPricePrefetchPromise } = this.getPricePrefetches(chainIdentifier, useToken, gasToken, abortController);
+            const nativeBalancePrefetch = this.prefetchNativeBalanceIfNeeded(chainIdentifier, abortController);
+            await this.checkNativeBalance(chainIdentifier, nativeBalancePrefetch, abortController.signal);
             //Check valid amount specified (min/max)
             let { amountBD, swapFee, swapFeeInToken, totalInToken, amountBDgas, gasSwapFee, gasSwapFeeInToken, totalInGasToken } = await this.AmountAssertions.checkFromBtcAmount(this.type, request, { ...requestedAmount, pricePrefetch: pricePrefetchPromise }, fees, abortController.signal, { ...gasTokenAmount, pricePrefetch: gasTokenPricePrefetchPromise });
             metadata.times.priceCalculated = Date.now();
@@ -339,6 +343,7 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
             const metadata = swap.metadata;
             metadata.times ?? (metadata.times = {});
             metadata.times.requestReceived = requestReceived;
+            this.checkTooManyInflightSwaps();
             const vault = await this.Vaults.getVault(swap.chainIdentifier, swap.vaultOwner, swap.vaultId);
             if (vault == null || !vault.isReady()) {
                 throw {
@@ -452,6 +457,8 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
                         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;
@@ -480,6 +487,8 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
                 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);
                 throw e;
             }

package/dist/swaps/trusted/frombtc_trusted/FromBtcTrusted.d.ts

@@ -20,6 +20,7 @@ export type FromBtcTrustedRequestType = {
 };
 export declare class FromBtcTrusted extends SwapHandler<FromBtcTrustedSwap, FromBtcTrustedSwapState> {
     readonly type = SwapHandlerType.FROM_BTC_TRUSTED;
+    readonly inflightSwapStates: Set<FromBtcTrustedSwapState>;
     readonly config: FromBtcTrustedConfig;
     readonly bitcoin: IBitcoinWallet;
     readonly bitcoinRpc: BitcoinRpc<BtcBlock>;