@atomiqlabs/lp-lib 16.0.0 → 16.0.2

package/dist/swaps/SwapHandler.d.ts

@@ -106,13 +106,6 @@ export declare abstract class SwapHandler<V extends SwapHandlerSwap<S> = SwapHan
      * Returns data to be returned in swap handler info
      */
     abstract getInfoData(): any;
-    /**
-     * Remove swap data
-     *
-     * @param hash
-     * @param sequence
-     */
-    protected removeSwapData(hash: string, sequence: bigint): Promise<void>;
     /**
      * Remove swap data
      *

package/dist/swaps/SwapHandler.js

@@ -67,18 +67,15 @@ class SwapHandler {
             }
         }
     }
-    async removeSwapData(hashOrSwap, sequenceOrUltimateState) {
-        let swap;
-        if (typeof (hashOrSwap) === "string") {
-            if (typeof (sequenceOrUltimateState) !== "bigint")
-                throw new Error("Sequence must be a BN instance!");
-            swap = await this.storageManager.getData(hashOrSwap, sequenceOrUltimateState);
-        }
-        else {
-            swap = hashOrSwap;
-            if (sequenceOrUltimateState != null && typeof (sequenceOrUltimateState) !== "bigint")
-                await swap.setState(sequenceOrUltimateState);
-        }
+    /**
+     * Remove swap data
+     *
+     * @param swap
+     * @param ultimateState set the ultimate state of the swap before removing
+     */
+    async removeSwapData(swap, ultimateState) {
+        if (ultimateState != null)
+            await swap.setState(ultimateState);
         if (swap != null)
             await PluginManager_1.PluginManager.swapRemove(swap);
         this.swapLogger.debug(swap, "removeSwapData(): removing swap final state: " + swap.state);

package/dist/swaps/escrow/EscrowHandler.d.ts

@@ -31,7 +31,6 @@ export declare abstract class EscrowHandler<V extends EscrowHandlerSwap<SwapData
      */
     protected subscribeToEvents(): void;
     protected loadData(ctor: new (data: any) => V): Promise<void>;
-    protected removeSwapData(hash: string, sequence: bigint): Promise<void>;
     protected removeSwapData(swap: V, ultimateState?: S): Promise<void>;
     protected saveSwapData(swap: V): Promise<void>;
     protected saveSwapToEscrowHashMap(swap: V): void;

package/dist/swaps/escrow/EscrowHandler.js

@@ -73,18 +73,9 @@ class EscrowHandler extends SwapHandler_1.SwapHandler {
             this.saveSwapToEscrowHashMap(swap);
         }
     }
-    async removeSwapData(hashOrSwap, sequenceOrUltimateState) {
-        let swap;
-        if (typeof (hashOrSwap) === "string") {
-            if (typeof (sequenceOrUltimateState) !== "bigint")
-                throw new Error("Sequence must be a BN instance!");
-            swap = await this.storageManager.getData(hashOrSwap, sequenceOrUltimateState);
-        }
-        else {
-            swap = hashOrSwap;
-            if (sequenceOrUltimateState != null && typeof (sequenceOrUltimateState) !== "bigint")
-                await swap.setState(sequenceOrUltimateState);
-        }
+    async removeSwapData(swap, ultimateState) {
+        if (ultimateState != null)
+            await swap.setState(ultimateState);
         if (swap != null)
             await PluginManager_1.PluginManager.swapRemove(swap);
         this.swapLogger.debug(swap, "removeSwapData(): removing swap final state: " + swap.state);

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

@@ -8,6 +8,10 @@ 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;
@@ -33,6 +37,7 @@ export declare class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoS
     readonly type = SwapHandlerType.FROM_BTCLN_AUTO;
     readonly swapType = ChainSwapType.HTLC;
     activeSubscriptions: Set<string>;
+    swapsWithInflighHtlcs: Set<FromBtcLnAutoSwap>;
     readonly config: FromBtcLnAutoConfig;
     readonly lightning: ILightningWallet;
     readonly LightningAssertions: LightningAssertions;
@@ -105,7 +110,9 @@ 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

@@ -20,6 +20,7 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
         this.type = SwapHandler_1.SwapHandlerType.FROM_BTCLN_AUTO;
         this.swapType = base_1.ChainSwapType.HTLC;
         this.activeSubscriptions = new Set();
+        this.swapsWithInflighHtlcs = new Set();
         this.config = config;
         this.config.invoiceTimeoutSeconds = this.config.invoiceTimeoutSeconds || 90;
         this.lightning = lightning;
@@ -55,13 +56,7 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
         }
         if (swap.state === FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.RECEIVED) {
             try {
-                if (!await this.offerHtlc(swap)) {
-                    //Expired
-                    if (swap.state === FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.RECEIVED) {
-                        this.swapLogger.info(swap, "processPastSwap(state=RECEIVED): offer HTLC expired, cancelling invoice: " + swap.pr);
-                        await this.cancelSwapAndInvoice(swap);
-                    }
-                }
+                await this.offerHtlc(swap);
             }
             catch (e) {
                 this.swapLogger.error(swap, "processPastSwap(state=RECEIVED): offerHtlc error", e);
@@ -69,6 +64,7 @@ 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) {
@@ -255,7 +251,6 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
         if (invoiceData.metadata != null)
             invoiceData.metadata.times.htlcReceived = Date.now();
         const useToken = invoiceData.token;
-        const gasToken = invoiceData.gasToken;
         let expiryTimeout;
         try {
             //Check if HTLC expiry is long enough
@@ -264,6 +259,8 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
                 invoiceData.metadata.times.htlcTimeoutCalculated = Date.now();
         }
         catch (e) {
+            if ((0, Utils_1.isDefinedRuntimeError)(e) && invoiceData.metadata != null)
+                invoiceData.metadata.htlcReceiveError = e;
             if (invoiceData.state === FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.CREATED)
                 await this.cancelSwapAndInvoice(invoiceData);
             throw e;
@@ -287,6 +284,16 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
     async offerHtlc(invoiceData) {
         if (invoiceData.state !== FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.RECEIVED)
             return;
+        try {
+            this.checkTooManyInflightHtlcs();
+        }
+        catch (e) {
+            if ((0, Utils_1.isDefinedRuntimeError)(e) && invoiceData.metadata != null)
+                invoiceData.metadata.htlcOfferError = e;
+            if (invoiceData.state === FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.RECEIVED)
+                await this.cancelSwapAndInvoice(invoiceData);
+            throw e;
+        }
         this.swapLogger.debug(invoiceData, "offerHtlc(): invoice: ", invoiceData.pr);
         if (invoiceData.metadata != null)
             invoiceData.metadata.times.offerHtlc = Date.now();
@@ -295,16 +302,34 @@ 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!";
             if (invoiceData.state === FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.RECEIVED) {
                 await this.cancelSwapAndInvoice(invoiceData);
             }
             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) {
@@ -319,6 +344,8 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
         }
         catch (e) {
             if (!abortController.signal.aborted) {
+                if ((0, Utils_1.isDefinedRuntimeError)(e) && invoiceData.metadata != null)
+                    invoiceData.metadata.htlcOfferError = e;
                 if (invoiceData.state === FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.RECEIVED)
                     await this.cancelSwapAndInvoice(invoiceData);
             }
@@ -331,6 +358,19 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             signature: invoiceData.signature
         }, true);
         if (invoiceData.state === FromBtcLnAutoSwap_1.FromBtcLnAutoSwapState.RECEIVED) {
+            //Re-check the current HTLC count
+            try {
+                this.checkTooManyInflightHtlcs();
+            }
+            catch (e) {
+                if ((0, Utils_1.isDefinedRuntimeError)(e) && invoiceData.metadata != null)
+                    invoiceData.metadata.htlcOfferError = e;
+                if (invoiceData.state === FromBtcLnAutoSwap_1.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);
             //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);
@@ -471,6 +511,15 @@ 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) => {
@@ -551,16 +600,21 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             const gasToken = parsedBody.gasToken;
             //Check request params
             this.checkDescriptionHash(parsedBody.descriptionHash);
+            this.checkTooManyInflightHtlcs();
             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 channelsPrefetch = this.LightningAssertions.getChannelsPrefetch(abortController);
             //Asynchronously send the node's public key to the client
             this.sendPublicKeyAsync(responseStream);
@@ -568,6 +622,8 @@ class FromBtcLnAuto extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             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();
             const totalBtcInput = amountBD + amountBDgas;
+            //Check if we have at least the minimum needed native balance
+            await this.checkBalance(minNativeTokenReserve, nativeTokenBalancePrefetch, abortController.signal);
             //Check if we have enough funds to honor the request
             if (useToken === gasToken) {
                 await this.checkBalance(totalInToken + totalInGasToken, balancePrefetch, abortController.signal);
@@ -678,5 +734,9 @@ 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/trusted/frombtcln_trusted/FromBtcLnTrusted.js

@@ -189,7 +189,7 @@ class FromBtcLnTrusted extends SwapHandler_1.SwapHandler {
                 await this.storageManager.saveData(invoice.id, null, invoiceData);
                 await this.lightning.cancelHodlInvoice(invoice.id);
                 this.unsubscribeInvoice(invoice.id);
-                await this.removeSwapData(invoice.id, null);
+                await this.removeSwapData(invoiceData);
                 this.swapLogger.info(invoiceData, "htlcReceived(): transaction sending failed, refunding lightning: ", invoiceData.pr);
                 throw {
                     code: 20002,
@@ -221,7 +221,7 @@ class FromBtcLnTrusted extends SwapHandler_1.SwapHandler {
                 await this.storageManager.saveData(invoice.id, null, invoiceData);
                 await this.lightning.cancelHodlInvoice(invoice.id);
                 this.unsubscribeInvoice(invoice.id);
-                await this.removeSwapData(invoice.id, null);
+                await this.removeSwapData(invoiceData);
                 this.swapLogger.info(invoiceData, "htlcReceived(): transaction reverted, refunding lightning: ", invoiceData.pr);
                 throw {
                     code: 20002,

package/package.json

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

package/src/swaps/SwapHandler.ts

@@ -165,31 +165,14 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<S> = SwapHandlerSwap
      */
     abstract getInfoData(): any;
 
-    /**
-     * Remove swap data
-     *
-     * @param hash
-     * @param sequence
-     */
-    protected removeSwapData(hash: string, sequence: bigint): Promise<void>;
-
     /**
      * Remove swap data
      *
      * @param swap
      * @param ultimateState set the ultimate state of the swap before removing
      */
-    protected removeSwapData(swap: V, ultimateState?: S): Promise<void>;
-
-    protected async removeSwapData(hashOrSwap: string | V, sequenceOrUltimateState?: bigint | S) {
-        let swap: V;
-        if(typeof(hashOrSwap)==="string") {
-            if(typeof(sequenceOrUltimateState)!=="bigint") throw new Error("Sequence must be a BN instance!");
-            swap = await this.storageManager.getData(hashOrSwap, sequenceOrUltimateState);
-        } else {
-            swap = hashOrSwap;
-            if(sequenceOrUltimateState!=null && typeof(sequenceOrUltimateState)!=="bigint") await swap.setState(sequenceOrUltimateState);
-        }
+    protected async removeSwapData(swap: V, ultimateState?: S) {
+        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);
         await this.storageManager.removeData(swap.getIdentifierHash(), swap.getSequence());

package/src/swaps/escrow/EscrowHandler.ts

@@ -89,17 +89,9 @@ export abstract class EscrowHandler<V extends EscrowHandlerSwap<SwapData, S>, S>
         }
     }
 
-    protected removeSwapData(hash: string, sequence: bigint): Promise<void>;
     protected removeSwapData(swap: V, ultimateState?: S): Promise<void>;
-    protected async removeSwapData(hashOrSwap: string | V, sequenceOrUltimateState?: bigint | S) {
-        let swap: V;
-        if(typeof(hashOrSwap)==="string") {
-            if(typeof(sequenceOrUltimateState)!=="bigint") throw new Error("Sequence must be a BN instance!");
-            swap = await this.storageManager.getData(hashOrSwap, sequenceOrUltimateState);
-        } else {
-            swap = hashOrSwap;
-            if(sequenceOrUltimateState!=null && typeof(sequenceOrUltimateState)!=="bigint") await swap.setState(sequenceOrUltimateState);
-        }
+    protected async removeSwapData(swap: V, ultimateState?: S) {
+        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);
         this.removeSwapFromEscrowHashMap(swap);

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

@@ -4,7 +4,7 @@ import {FromBtcLnAutoSwap, FromBtcLnAutoSwapState} from "./FromBtcLnAutoSwap";
 import {MultichainData, SwapHandlerType} from "../../SwapHandler";
 import {ISwapPrice} from "../../../prices/ISwapPrice";
 import {ChainSwapType, ClaimEvent, InitializeEvent, RefundEvent, SwapCommitStateType, SwapData} from "@atomiqlabs/base";
-import {expressHandlerWrapper, getAbortController, HEX_REGEX} from "../../../utils/Utils";
+import {expressHandlerWrapper, getAbortController, HEX_REGEX, isDefinedRuntimeError} from "../../../utils/Utils";
 import {PluginManager} from "../../../plugins/PluginManager";
 import {IIntermediaryStorage} from "../../../storage/IIntermediaryStorage";
 import {FieldTypeEnum, verifySchema} from "../../../utils/paramcoders/SchemaVerifier";
@@ -21,6 +21,10 @@ import {
 import {LightningAssertions} from "../../assertions/LightningAssertions";
 
 export type FromBtcLnAutoConfig = FromBtcBaseConfig & {
+    maxInflightHtlcs?: number,
+    minNativeBalances?: {
+        [chainId: string]: bigint
+    },
     invoiceTimeoutSeconds?: number,
     minCltv: bigint,
     gracePeriod: bigint,
@@ -47,6 +51,7 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
     readonly swapType = ChainSwapType.HTLC;
 
     activeSubscriptions: Set<string> = new Set<string>();
+    swapsWithInflighHtlcs: Set<FromBtcLnAutoSwap> = new Set();
 
     readonly config: FromBtcLnAutoConfig;
     readonly lightning: ILightningWallet;
@@ -100,13 +105,7 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
 
         if(swap.state===FromBtcLnAutoSwapState.RECEIVED) {
             try {
-                if(!await this.offerHtlc(swap)) {
-                    //Expired
-                    if(swap.state===FromBtcLnAutoSwapState.RECEIVED) {
-                        this.swapLogger.info(swap, "processPastSwap(state=RECEIVED): offer HTLC expired, cancelling invoice: "+swap.pr);
-                        await this.cancelSwapAndInvoice(swap);
-                    }
-                }
+                await this.offerHtlc(swap);
             } catch (e) {
                 this.swapLogger.error(swap, "processPastSwap(state=RECEIVED): offerHtlc error", e);
             }
@@ -115,6 +114,8 @@ 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) {
@@ -319,7 +320,6 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
         if(invoiceData.metadata!=null) invoiceData.metadata.times.htlcReceived = Date.now();
 
         const useToken = invoiceData.token;
-        const gasToken = invoiceData.gasToken;
 
         let expiryTimeout: bigint;
         try {
@@ -327,6 +327,7 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
             expiryTimeout = await this.checkHtlcExpiry(invoice);
             if(invoiceData.metadata!=null) invoiceData.metadata.times.htlcTimeoutCalculated = Date.now();
         } catch (e) {
+            if(isDefinedRuntimeError(e) && invoiceData.metadata!=null) invoiceData.metadata.htlcReceiveError = e;
             if(invoiceData.state===FromBtcLnAutoSwapState.CREATED) await this.cancelSwapAndInvoice(invoiceData);
             throw e;
         }
@@ -369,6 +370,14 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
     private async offerHtlc(invoiceData: FromBtcLnAutoSwap) {
         if(invoiceData.state!==FromBtcLnAutoSwapState.RECEIVED) return;
 
+        try {
+            this.checkTooManyInflightHtlcs();
+        } 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(): invoice: ", invoiceData.pr);
         if(invoiceData.metadata!=null) invoiceData.metadata.times.offerHtlc = Date.now();
 
@@ -380,18 +389,34 @@ 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!";
             if(invoiceData.state===FromBtcLnAutoSwapState.RECEIVED) {
                 await this.cancelSwapAndInvoice(invoiceData);
             }
             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) {
@@ -403,6 +428,7 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
             if(invoiceData.metadata!=null) invoiceData.metadata.times.offerHtlcChecked = Date.now();
         } catch (e) {
             if(!abortController.signal.aborted) {
+                if(isDefinedRuntimeError(e) && invoiceData.metadata!=null) invoiceData.metadata.htlcOfferError = e;
                 if(invoiceData.state===FromBtcLnAutoSwapState.RECEIVED) await this.cancelSwapAndInvoice(invoiceData);
             }
             throw e;
@@ -416,6 +442,16 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
         }, true);
 
         if(invoiceData.state===FromBtcLnAutoSwapState.RECEIVED) {
+            //Re-check the current HTLC count
+            try {
+                this.checkTooManyInflightHtlcs();
+            } 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);
             //Setting the state variable is done outside the promise, so is done synchronously
             await invoiceData.setState(FromBtcLnAutoSwapState.TXS_SENT);
             await this.saveSwapData(invoiceData);
@@ -565,6 +601,14 @@ 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));
@@ -653,6 +697,7 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
 
             //Check request params
             this.checkDescriptionHash(parsedBody.descriptionHash);
+            this.checkTooManyInflightHtlcs();
             const fees = await this.AmountAssertions.preCheckFromBtcAmounts(this.type, request, requestedAmount, gasTokenAmount);
             metadata.times.requestChecked = Date.now();
 
@@ -660,6 +705,9 @@ 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,
@@ -668,6 +716,8 @@ 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 channelsPrefetch: Promise<LightningNetworkChannel[]> = this.LightningAssertions.getChannelsPrefetch(abortController);
 
             //Asynchronously send the node's public key to the client
@@ -693,6 +743,9 @@ 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);
+
             //Check if we have enough funds to honor the request
             if(useToken===gasToken) {
                 await this.checkBalance(totalInToken + totalInGasToken, balancePrefetch, abortController.signal);
@@ -843,5 +896,10 @@ 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/trusted/frombtcln_trusted/FromBtcLnTrusted.ts

@@ -234,7 +234,7 @@ export class FromBtcLnTrusted extends SwapHandler<FromBtcLnTrustedSwap, FromBtcL
                 await this.storageManager.saveData(invoice.id, null, invoiceData);
                 await this.lightning.cancelHodlInvoice(invoice.id);
                 this.unsubscribeInvoice(invoice.id);
-                await this.removeSwapData(invoice.id, null);
+                await this.removeSwapData(invoiceData);
                 this.swapLogger.info(invoiceData, "htlcReceived(): transaction sending failed, refunding lightning: ", invoiceData.pr);
                 throw {
                     code: 20002,
@@ -267,7 +267,7 @@ export class FromBtcLnTrusted extends SwapHandler<FromBtcLnTrustedSwap, FromBtcL
                 await this.storageManager.saveData(invoice.id, null, invoiceData);
                 await this.lightning.cancelHodlInvoice(invoice.id);
                 this.unsubscribeInvoice(invoice.id);
-                await this.removeSwapData(invoice.id, null);
+                await this.removeSwapData(invoiceData);
                 this.swapLogger.info(invoiceData, "htlcReceived(): transaction reverted, refunding lightning: ", invoiceData.pr);
                 throw {
                     code: 20002,