@atomiqlabs/lp-lib 16.0.2 → 16.0.4

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

@@ -12,6 +12,7 @@ class FromBtcTrusted extends SwapHandler_1.SwapHandler {
         var _a;
         super(storageDirectory, path, chains, swapPricing);
         this.type = SwapHandler_1.SwapHandlerType.FROM_BTC_TRUSTED;
+        this.inflightSwapStates = new Set([FromBtcTrustedSwap_1.FromBtcTrustedSwapState.RECEIVED, FromBtcTrustedSwap_1.FromBtcTrustedSwapState.BTC_CONFIRMED, FromBtcTrustedSwap_1.FromBtcTrustedSwapState.SENT, FromBtcTrustedSwap_1.FromBtcTrustedSwapState.CONFIRMED]);
         this.subscriptions = new Map();
         this.doubleSpendWatchdogSwaps = new Set();
         this.refundedSwaps = new Map();
@@ -148,6 +149,13 @@ class FromBtcTrusted extends SwapHandler_1.SwapHandler {
             swap.txId = tx.txid;
             swap.vout = vout;
             this.subscriptions.delete(outputScript);
+            try {
+                this.checkTooManyInflightSwaps();
+            }
+            catch (e) {
+                await this.refundSwap(swap);
+                return;
+            }
             await swap.setState(FromBtcTrustedSwap_1.FromBtcTrustedSwapState.RECEIVED);
             await this.storageManager.saveData(swap.getIdentifierHash(), swap.getSequence(), swap);
         }
@@ -373,6 +381,7 @@ class FromBtcTrusted extends SwapHandler_1.SwapHandler {
                 metadata
             };
             const useToken = parsedBody.token;
+            this.checkTooManyInflightSwaps();
             //Check request params
             const fees = await this.AmountAssertions.preCheckFromBtcAmounts(this.type, request, requestedAmount);
             metadata.times.requestChecked = Date.now();
@@ -390,6 +399,9 @@ class FromBtcTrusted extends SwapHandler_1.SwapHandler {
                 abortController.abort(e);
                 return null;
             });
+            const nativeBalancePrefetch = useToken === chainInterface.getNativeCurrencyAddress() ?
+                balancePrefetch : this.prefetchNativeBalanceIfNeeded(chainIdentifier, abortController);
+            await this.checkNativeBalance(chainIdentifier, nativeBalancePrefetch, abortController.signal);
             //Check valid amount specified (min/max)
             const { amountBD, swapFee, swapFeeInToken, totalInToken } = await this.AmountAssertions.checkFromBtcAmount(this.type, request, { ...requestedAmount, pricePrefetch: pricePrefetchPromise }, fees, abortController.signal);
             metadata.times.priceCalculated = Date.now();

package/dist/swaps/trusted/frombtcln_trusted/FromBtcLnTrusted.d.ts

@@ -21,6 +21,7 @@ export type FromBtcLnTrustedRequestType = {
  */
 export declare class FromBtcLnTrusted extends SwapHandler<FromBtcLnTrustedSwap, FromBtcLnTrustedSwapState> {
     readonly type = SwapHandlerType.FROM_BTCLN_TRUSTED;
+    readonly inflightSwapStates: Set<FromBtcLnTrustedSwapState>;
     activeSubscriptions: Map<string, AbortController>;
     processedTxIds: Map<string, string>;
     readonly config: SwapForGasServerConfig;

package/dist/swaps/trusted/frombtcln_trusted/FromBtcLnTrusted.js

@@ -16,6 +16,7 @@ class FromBtcLnTrusted extends SwapHandler_1.SwapHandler {
     constructor(storageDirectory, path, chains, lightning, swapPricing, config) {
         super(storageDirectory, path, chains, swapPricing);
         this.type = SwapHandler_1.SwapHandlerType.FROM_BTCLN_TRUSTED;
+        this.inflightSwapStates = new Set([FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.RECEIVED, FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.SENT, FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.CONFIRMED]);
         this.activeSubscriptions = new Map();
         this.processedTxIds = new Map();
         this.lightning = lightning;
@@ -153,6 +154,13 @@ class FromBtcLnTrusted extends SwapHandler_1.SwapHandler {
         const { signer, chainInterface } = this.getChain(invoiceData.chainIdentifier);
         //Important to prevent race condition and issuing 2 signed init messages at the same time
         if (invoiceData.state === FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.CREATED) {
+            try {
+                this.checkTooManyInflightSwaps();
+            }
+            catch (e) {
+                await this.cancelSwapAndInvoice(invoiceData);
+                throw e;
+            }
             if (invoiceData.metadata != null)
                 invoiceData.metadata.times.htlcReceived = Date.now();
             await invoiceData.setState(FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.RECEIVED);
@@ -344,6 +352,7 @@ class FromBtcLnTrusted extends SwapHandler_1.SwapHandler {
                 metadata
             };
             const useToken = parsedBody.token;
+            this.checkTooManyInflightSwaps();
             //Check request params
             const fees = await this.AmountAssertions.preCheckFromBtcAmounts(this.type, request, requestedAmount);
             metadata.times.requestChecked = Date.now();
@@ -361,7 +370,10 @@ class FromBtcLnTrusted extends SwapHandler_1.SwapHandler {
                 abortController.abort(e);
                 return null;
             });
+            const nativeBalancePrefetch = useToken === chainInterface.getNativeCurrencyAddress() ?
+                balancePrefetch : this.prefetchNativeBalanceIfNeeded(chainIdentifier, abortController);
             const channelsPrefetch = this.LightningAssertions.getChannelsPrefetch(abortController);
+            await this.checkNativeBalance(chainIdentifier, nativeBalancePrefetch, abortController.signal);
             //Check valid amount specified (min/max)
             const { amountBD, swapFee, swapFeeInToken, totalInToken } = await this.AmountAssertions.checkFromBtcAmount(this.type, request, { ...requestedAmount, pricePrefetch: pricePrefetchPromise }, fees, abortController.signal);
             metadata.times.priceCalculated = Date.now();

package/package.json

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

package/src/swaps/SwapHandler.ts

@@ -1,7 +1,6 @@
 import {Express, Request} from "express";
 import {ISwapPrice} from "../prices/ISwapPrice";
 import {
-    ChainSwapType,
     ChainType
 } from "@atomiqlabs/base";
 import {SwapHandlerSwap} from "./SwapHandlerSwap";
@@ -35,6 +34,10 @@ export type SwapBaseConfig = {
     initAuthorizationTimeouts?: {
         [chainId: string]: number
     },
+    minNativeBalances?: {
+        [chainId: string]: bigint
+    },
+    maxInflightSwaps?: number,
     bitcoinBlocktime: bigint,
     baseFee: bigint,
     feePPM: bigint,
@@ -83,8 +86,11 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<S> = SwapHandlerSwap
     readonly allowedTokens: {[chainId: string]: Set<string>};
     readonly swapPricing: ISwapPrice;
 
+    abstract readonly inflightSwapStates: Set<S>;
     abstract config: SwapBaseConfig;
 
+    inflightSwaps: Set<string> = new Set();
+
     logger: LoggerType = getLogger(() => "SwapHandler("+this.type+"): ");
 
     protected swapLogger = {
@@ -150,6 +156,7 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<S> = SwapHandlerSwap
                 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());
         }
     }
 
@@ -172,6 +179,8 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<S> = SwapHandlerSwap
      * @param ultimateState set the ultimate state of the swap before removing
      */
     protected async removeSwapData(swap: V, ultimateState?: S) {
+        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) await PluginManager.swapRemove(swap);
         this.swapLogger.debug(swap, "removeSwapData(): removing swap final state: "+swap.state);
@@ -179,9 +188,71 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<S> = SwapHandlerSwap
     }
 
     protected async saveSwapData(swap: V) {
+        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
+     */
+    protected prefetchNativeBalanceIfNeeded(chainIdentifier: string, abortController: AbortController): Promise<bigint> | null {
+        const minNativeTokenReserve: bigint = 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
+     */
+    protected async checkNativeBalance(chainIdentifier: string, balancePrefetch: Promise<bigint>, signal: AbortSignal | null): Promise<void> {
+        if(signal!=null) signal.throwIfAborted();
+
+        const minNativeTokenReserve: bigint = 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
+     */
+    protected 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/src/swaps/escrow/frombtc_abstract/FromBtcAbs.ts

@@ -40,6 +40,7 @@ export type FromBtcRequestType = {
 export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSwapState> {
     readonly type = SwapHandlerType.FROM_BTC;
     readonly swapType = ChainSwapType.CHAIN;
+    readonly inflightSwapStates = new Set([FromBtcSwapState.COMMITED]);
 
     readonly config: FromBtcConfig & {swapTsCsvDelta: bigint};
 
@@ -303,6 +304,7 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
             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();
@@ -319,6 +321,7 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
             } = this.getFromBtcPricePrefetches(chainIdentifier, useToken, depositToken, abortController);
             const balancePrefetch: Promise<bigint> = this.getBalancePrefetch(chainIdentifier, useToken, abortController);
             const signDataPrefetchPromise: Promise<any> = this.getSignDataPrefetch(chainIdentifier, abortController, responseStream);
+            const nativeBalancePrefetch = this.prefetchNativeBalanceIfNeeded(chainIdentifier, abortController);
 
             const dummySwapData = await this.getDummySwapData(chainIdentifier, useToken, parsedBody.address);
             abortController.signal.throwIfAborted();
@@ -328,6 +331,8 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
                 abortController
             );
 
+            await this.checkNativeBalance(chainIdentifier, nativeBalancePrefetch, abortController.signal);
+
             //Check valid amount specified (min/max)
             const {
                 amountBD,

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

@@ -27,6 +27,7 @@ import {
     LightningNetworkInvoice
 } from "../../../wallets/ILightningWallet";
 import {LightningAssertions} from "../../assertions/LightningAssertions";
+import {FromBtcLnAutoSwapState} from "../frombtcln_autoinit/FromBtcLnAutoSwap";
 
 export type FromBtcLnConfig = FromBtcBaseConfig & {
     invoiceTimeoutSeconds?: number,
@@ -49,6 +50,7 @@ export type FromBtcLnRequestType = {
 export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromBtcLnSwapState> {
     readonly type = SwapHandlerType.FROM_BTCLN;
     readonly swapType = ChainSwapType.HTLC;
+    readonly inflightSwapStates = new Set([FromBtcLnSwapState.RECEIVED, FromBtcLnSwapState.COMMITED, FromBtcLnSwapState.CLAIMED]);
 
     readonly config: FromBtcLnConfig;
     readonly lightning: ILightningWallet;
@@ -95,12 +97,6 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
                 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===FromBtcLnSwapState.CANCELED) {
-                this.swapLogger.info(swap, "processPastSwap(state=CREATED): invoice CANCELED after htlcReceived(), cancelling, invoice: "+swap.pr);
-                return "CANCEL";
-            }
-
             return null;
         }
 
@@ -314,6 +310,14 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
         const useToken = invoiceData.token;
         const escrowAmount: bigint = invoiceData.totalTokens;
 
+        try {
+            this.checkTooManyInflightSwaps();
+        } catch (e) {
+            if(isDefinedRuntimeError(e) && invoiceData.metadata!=null) invoiceData.metadata.htlcReceiveError = e;
+            if(invoiceData.state===FromBtcLnSwapState.CREATED) await this.cancelSwapAndInvoice(invoiceData);
+            throw e;
+        }
+
         //Create abort controller for parallel fetches
         const abortController = new AbortController();
 
@@ -333,6 +337,7 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
             if(invoiceData.metadata!=null) invoiceData.metadata.times.htlcTimeoutCalculated = Date.now();
         } catch (e) {
             if(!abortController.signal.aborted) {
+                if(isDefinedRuntimeError(e) && invoiceData.metadata!=null) invoiceData.metadata.htlcReceiveError = e;
                 if(invoiceData.state===FromBtcLnSwapState.CREATED) await this.cancelSwapAndInvoice(invoiceData);
             }
             throw e;
@@ -372,6 +377,15 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
 
         //Important to prevent race condition and issuing 2 signed init messages at the same time
         if(invoiceData.state===FromBtcLnSwapState.CREATED) {
+            //Re-check right before signing
+            try {
+                this.checkTooManyInflightSwaps();
+            } catch (e) {
+                if(isDefinedRuntimeError(e) && invoiceData.metadata!=null) invoiceData.metadata.htlcReceiveError = e;
+                if(invoiceData.state===FromBtcLnSwapState.CREATED) await this.cancelSwapAndInvoice(invoiceData);
+                throw e;
+            }
+
             invoiceData.data = payInvoiceObject;
             invoiceData.prefix = sigData.prefix;
             invoiceData.timeout = sigData.timeout;
@@ -622,6 +636,7 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
             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();
@@ -638,6 +653,7 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
             } = this.getFromBtcPricePrefetches(chainIdentifier, useToken, depositToken, abortController);
             const balancePrefetch: Promise<bigint> = this.getBalancePrefetch(chainIdentifier, useToken, abortController);
             const channelsPrefetch: Promise<LightningNetworkChannel[]> = this.LightningAssertions.getChannelsPrefetch(abortController);
+            const nativeBalancePrefetch = this.prefetchNativeBalanceIfNeeded(chainIdentifier, abortController);
 
             const dummySwapData = await this.getDummySwapData(chainIdentifier, useToken, parsedBody.address, parsedBody.paymentHash);
             abortController.signal.throwIfAborted();
@@ -650,6 +666,8 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
             //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,

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

@@ -21,10 +21,6 @@ import {
 import {LightningAssertions} from "../../assertions/LightningAssertions";
 
 export type FromBtcLnAutoConfig = FromBtcBaseConfig & {
-    maxInflightHtlcs?: number,
-    minNativeBalances?: {
-        [chainId: string]: bigint
-    },
     invoiceTimeoutSeconds?: number,
     minCltv: bigint,
     gracePeriod: bigint,
@@ -49,9 +45,9 @@ export type FromBtcLnAutoRequestType = {
 export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, FromBtcLnAutoSwapState> {
     readonly type = SwapHandlerType.FROM_BTCLN_AUTO;
     readonly swapType = ChainSwapType.HTLC;
+    readonly inflightSwapStates = new Set([FromBtcLnAutoSwapState.TXS_SENT, FromBtcLnAutoSwapState.COMMITED, FromBtcLnAutoSwapState.CLAIMED]);
 
     activeSubscriptions: Set<string> = new Set<string>();
-    swapsWithInflighHtlcs: Set<FromBtcLnAutoSwap> = new Set();
 
     readonly config: FromBtcLnAutoConfig;
     readonly lightning: ILightningWallet;
@@ -114,8 +110,6 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
         }
 
         if(swap.state===FromBtcLnAutoSwapState.TXS_SENT || swap.state===FromBtcLnAutoSwapState.COMMITED) {
-            this.swapsWithInflighHtlcs.add(swap);
-
             const onchainStatus = await swapContract.getCommitStatus(signer.getAddress(), swap.data);
             const state: FromBtcLnAutoSwapState = swap.state as FromBtcLnAutoSwapState;
             if(onchainStatus.type===SwapCommitStateType.PAID) {
@@ -371,7 +365,7 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
         if(invoiceData.state!==FromBtcLnAutoSwapState.RECEIVED) return;
 
         try {
-            this.checkTooManyInflightHtlcs();
+            this.checkTooManyInflightSwaps();
         } catch (e) {
             if(isDefinedRuntimeError(e) && invoiceData.metadata!=null) invoiceData.metadata.htlcOfferError = e;
             if(invoiceData.state===FromBtcLnAutoSwapState.RECEIVED) await this.cancelSwapAndInvoice(invoiceData);
@@ -389,15 +383,10 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
         //Create abort controller for parallel fetches
         const abortController = new AbortController();
 
-        //Minimum reserve of native token to be kept in the wallet
-        const minNativeTokenReserve: bigint = this.config.minNativeBalances?.[invoiceData.chainIdentifier] ?? 0n;
-
         //Pre-fetch data
         const balancePrefetch: Promise<bigint> = this.getBalancePrefetch(invoiceData.chainIdentifier, useToken, abortController);
         const gasTokenBalancePrefetch: Promise<bigint> = invoiceData.getTotalOutputGasAmount()===0n || useToken===gasToken ?
             null : this.getBalancePrefetch(invoiceData.chainIdentifier, gasToken, abortController);
-        const nativeBalancePrefetch: Promise<bigint> = 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!";
@@ -407,16 +396,6 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
             return false;
         }
 
-        try {
-            await this.checkBalance(minNativeTokenReserve, nativeBalancePrefetch, abortController.signal);
-        } catch (e) {
-            if(!abortController.signal.aborted) {
-                if(isDefinedRuntimeError(e) && invoiceData.metadata!=null) invoiceData.metadata.htlcOfferError = "Not enough native balance!";
-                if(invoiceData.state===FromBtcLnAutoSwapState.RECEIVED) await this.cancelSwapAndInvoice(invoiceData);
-            }
-            throw e;
-        }
-
         try {
             //Check if we have enough liquidity to proceed
             if(useToken===gasToken) {
@@ -444,14 +423,13 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
         if(invoiceData.state===FromBtcLnAutoSwapState.RECEIVED) {
             //Re-check the current HTLC count
             try {
-                this.checkTooManyInflightHtlcs();
+                this.checkTooManyInflightSwaps();
             } catch (e) {
                 if(isDefinedRuntimeError(e) && invoiceData.metadata!=null) invoiceData.metadata.htlcOfferError = e;
                 if(invoiceData.state===FromBtcLnAutoSwapState.RECEIVED) 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(FromBtcLnAutoSwapState.TXS_SENT);
             await this.saveSwapData(invoiceData);
@@ -601,14 +579,6 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
         }
     }
 
-    private 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: Express) {
 
         restServer.use(this.path+"/createInvoice", serverParamDecoder(10*1000));
@@ -697,7 +667,7 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
 
             //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();
 
@@ -705,9 +675,6 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
             const responseStream = res.responseStream;
             const abortController = getAbortController(responseStream);
 
-            //Minimum reserve of native token to be kept in the wallet
-            const minNativeTokenReserve: bigint = this.config.minNativeBalances?.[chainIdentifier] ?? 0n;
-
             //Pre-fetch data
             const {
                 pricePrefetchPromise,
@@ -716,8 +683,7 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
             const balancePrefetch: Promise<bigint> = this.getBalancePrefetch(chainIdentifier, useToken, abortController);
             const gasTokenBalancePrefetch: Promise<bigint> = gasTokenAmount.amount===0n || useToken===gasToken ?
                 null : this.getBalancePrefetch(chainIdentifier, gasToken, abortController);
-            const nativeTokenBalancePrefetch: Promise<bigint> = minNativeTokenReserve===0n ?
-                null : this.getBalancePrefetch(chainIdentifier, chainInterface.getNativeCurrencyAddress(), abortController, false);
+            const nativeTokenBalancePrefetch: Promise<bigint> = this.prefetchNativeBalanceIfNeeded(chainIdentifier, abortController);
             const channelsPrefetch: Promise<LightningNetworkChannel[]> = this.LightningAssertions.getChannelsPrefetch(abortController);
 
             //Asynchronously send the node's public key to the client
@@ -744,7 +710,7 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
             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) {
@@ -896,10 +862,5 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
         };
     }
 
-    protected async removeSwapData(swap: FromBtcLnAutoSwap, ultimateState?: FromBtcLnAutoSwapState) {
-        this.swapsWithInflighHtlcs.delete(swap);
-        return super.removeSwapData(swap, ultimateState);
-    }
-
 }
 

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

@@ -59,6 +59,7 @@ const MAX_PARALLEL_TX_PROCESSED = 10;
 export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>  {
     readonly type = SwapHandlerType.TO_BTC;
     readonly swapType = ChainSwapType.CHAIN_NONCED;
+    readonly inflightSwapStates = new Set([ToBtcSwapState.BTC_SENDING, ToBtcSwapState.BTC_SENT]);
 
     activeSubscriptions: {[txId: string]: ToBtcSwapAbs} = {};
     bitcoinRpc: BitcoinRpc<BtcBlock>;
@@ -358,6 +359,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
         // 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();
 
@@ -672,6 +674,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
 
             const responseStream = res.responseStream;
 
+            this.checkTooManyInflightSwaps();
             this.checkNonceValid(parsedBody.nonce);
             this.checkConfirmationTarget(parsedBody.confirmationTarget);
             this.checkRequiredConfirmations(parsedBody.confirmations);
@@ -685,6 +688,9 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
             const abortController = 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,

package/src/swaps/escrow/tobtcln_abstract/ToBtcLnAbs.ts

@@ -86,11 +86,11 @@ export type ToBtcLnRequestType = {
  * Swap handler handling to BTCLN swaps using submarine swaps
  */
 export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwapState> {
-
-    activeSubscriptions: Set<string> = new Set<string>();
-
     readonly type = SwapHandlerType.TO_BTCLN;
     readonly swapType = ChainSwapType.HTLC;
+    readonly inflightSwapStates = new Set([ToBtcLnSwapState.COMMITED, ToBtcLnSwapState.PAID]);
+
+    activeSubscriptions: Set<string> = new Set<string>();
 
     readonly config: ToBtcLnConfig & {minTsSendCltv: bigint};
 
@@ -391,6 +391,18 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
         }
 
         if(swap.state===ToBtcLnSwapState.SAVED) {
+            try {
+                this.checkTooManyInflightSwaps();
+            } catch (e) {
+                this.swapLogger.error(swap, "processInitialized(): checking too many inflight swaps error: ", e);
+                if(isDefinedRuntimeError(e)) {
+                    if(swap.metadata!=null) swap.metadata.payError = e;
+                    await swap.setState(ToBtcLnSwapState.NON_PAYABLE);
+                    await this.saveSwapData(swap);
+                    return;
+                } else throw e;
+            }
+
             await swap.setState(ToBtcLnSwapState.COMMITED);
             await this.saveSwapData(swap);
             try {
@@ -690,11 +702,13 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
                 };
             }
 
+            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);
 
@@ -836,6 +850,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
             const currentTimestamp: bigint = 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);
@@ -854,11 +869,15 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
 
             //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,