@atomiqlabs/lp-lib 16.1.0 → 16.1.1

package/dist/swaps/assertions/FromBtcAmountAssertions.js

@@ -1,185 +1,185 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FromBtcAmountAssertions = void 0;
-const PluginManager_1 = require("../../plugins/PluginManager");
-const IPlugin_1 = require("../../plugins/IPlugin");
-const AmountAssertions_1 = require("./AmountAssertions");
-class FromBtcAmountAssertions extends AmountAssertions_1.AmountAssertions {
-    constructor(config, swapPricing) {
-        super(config, swapPricing);
-        this.config = config;
-    }
-    /**
-     * Checks minimums/maximums, calculates the fee & total amount
-     *
-     * @param swapType
-     * @param request
-     * @param requestedAmount
-     * @param gasAmount
-     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
-     */
-    async preCheckFromBtcAmounts(swapType, request, requestedAmount, gasAmount) {
-        const res = await PluginManager_1.PluginManager.onHandlePreFromBtcQuote(swapType, request, requestedAmount, request.chainIdentifier, { minInBtc: this.config.min, maxInBtc: this.config.max }, { baseFeeInBtc: this.config.baseFee, feePPM: this.config.feePPM }, gasAmount);
-        if (res != null) {
-            AmountAssertions_1.AmountAssertions.handlePluginErrorResponses(res);
-            if ((0, IPlugin_1.isQuoteSetFees)(res)) {
-                return {
-                    baseFee: res.baseFee || this.config.baseFee,
-                    feePPM: res.feePPM || this.config.feePPM,
-                    securityDepositApyPPM: res.securityDepositApyPPM,
-                    securityDepositBaseMultiplierPPM: res.securityDepositBaseMultiplierPPM
-                };
-            }
-        }
-        if (requestedAmount.input)
-            this.checkBtcAmountInBounds(requestedAmount.amount);
-        if (gasAmount != null && gasAmount.amount !== 0n) {
-            if (gasAmount.amount > (this.config.gasTokenMax?.[request.chainIdentifier] ?? 0n)) {
-                throw {
-                    code: 20504,
-                    msg: "Gas token amount too high!",
-                    data: {
-                        max: (this.config.gasTokenMax?.[request.chainIdentifier] ?? 0n).toString(10)
-                    }
-                };
-            }
-        }
-        return {
-            baseFee: this.config.baseFee,
-            feePPM: this.config.feePPM
-        };
-    }
-    /**
-     * Checks minimums/maximums, calculates the fee & total amount
-     *
-     * @param swapType
-     * @param request
-     * @param requestedAmount
-     * @param fees
-     * @param signal
-     * @param gasTokenAmount
-     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
-     */
-    async checkFromBtcAmount(swapType, request, requestedAmount, fees, signal, gasTokenAmount) {
-        const chainIdentifier = request.chainIdentifier;
-        let securityDepositApyPPM;
-        let securityDepositBaseMultiplierPPM;
-        const res = await PluginManager_1.PluginManager.onHandlePostFromBtcQuote(swapType, request, requestedAmount, chainIdentifier, { minInBtc: this.config.min, maxInBtc: this.config.max }, { baseFeeInBtc: fees.baseFee, feePPM: fees.feePPM }, gasTokenAmount);
-        signal.throwIfAborted();
-        if (res != null) {
-            AmountAssertions_1.AmountAssertions.handlePluginErrorResponses(res);
-            if ((0, IPlugin_1.isQuoteSetFees)(res)) {
-                if (res.baseFee != null)
-                    fees.baseFee = res.baseFee;
-                if (res.feePPM != null)
-                    fees.feePPM = res.feePPM;
-                if (res.securityDepositApyPPM != null)
-                    securityDepositApyPPM = res.securityDepositApyPPM;
-                if (res.securityDepositBaseMultiplierPPM != null)
-                    securityDepositBaseMultiplierPPM = res.securityDepositBaseMultiplierPPM;
-            }
-            if ((0, IPlugin_1.isPluginQuote)(res)) {
-                if (!requestedAmount.input) {
-                    return {
-                        amountBD: res.amount.amount + res.swapFee.inInputTokens,
-                        swapFee: res.swapFee.inInputTokens,
-                        swapFeeInToken: res.swapFee.inOutputTokens,
-                        totalInToken: requestedAmount.amount
-                    };
-                }
-                else {
-                    return {
-                        amountBD: requestedAmount.amount,
-                        swapFee: res.swapFee.inInputTokens,
-                        swapFeeInToken: res.swapFee.inOutputTokens,
-                        totalInToken: res.amount.amount
-                    };
-                }
-            }
-        }
-        let amountBDgas = 0n;
-        let gasSwapFee = 0n;
-        if (gasTokenAmount != null) {
-            amountBDgas = await this.swapPricing.getToBtcSwapAmount(gasTokenAmount.amount, gasTokenAmount.token, chainIdentifier, true, gasTokenAmount.pricePrefetch);
-            signal.throwIfAborted();
-            const denominator = (1000000n - fees.feePPM);
-            const _amountBDgas = (amountBDgas * 1000000n + denominator - 1n) / denominator;
-            gasSwapFee = _amountBDgas - amountBDgas;
-            amountBDgas = _amountBDgas;
-        }
-        let amountBD;
-        let swapFee;
-        if (!requestedAmount.input) {
-            amountBD = await this.swapPricing.getToBtcSwapAmount(requestedAmount.amount, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch);
-            signal.throwIfAborted();
-            // amt = (amt+base_fee)/(1-fee)
-            const denominator = (1000000n - fees.feePPM);
-            const _amountBD = ((amountBD + fees.baseFee) * 1000000n + denominator - 1n) / denominator;
-            swapFee = _amountBD - amountBD;
-            amountBD = _amountBD;
-            const tooLow = amountBD < (this.config.min * 95n / 100n);
-            const tooHigh = amountBD > (this.config.max * 105n / 100n);
-            if (tooLow || tooHigh) {
-                const adjustedMin = this.config.min * (1000000n - fees.feePPM) / (1000000n - fees.baseFee);
-                const adjustedMax = this.config.max * (1000000n - fees.feePPM) / (1000000n - fees.baseFee);
-                const minIn = await this.swapPricing.getFromBtcSwapAmount(adjustedMin, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch);
-                const maxIn = await this.swapPricing.getFromBtcSwapAmount(adjustedMax, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch);
-                throw {
-                    code: tooLow ? 20003 : 20004,
-                    msg: tooLow ? "Amount too low!" : "Amount too high!",
-                    data: {
-                        min: minIn.toString(10),
-                        max: maxIn.toString(10)
-                    }
-                };
-            }
-        }
-        else {
-            this.checkBtcAmountInBounds(requestedAmount.amount);
-            amountBD = requestedAmount.amount - amountBDgas;
-            swapFee = fees.baseFee + ((amountBD * fees.feePPM + 999999n) / 1000000n);
-            if (amountBD - swapFee < 0n) {
-                throw {
-                    code: 20003,
-                    msg: "Amount too low!",
-                    data: {
-                        min: this.config.min.toString(10),
-                        max: this.config.max.toString(10)
-                    }
-                };
-            }
-        }
-        const swapFeeInToken = await this.swapPricing.getFromBtcSwapAmount(swapFee, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch);
-        signal.throwIfAborted();
-        const gasSwapFeeInToken = gasTokenAmount == null ?
-            0n :
-            await this.swapPricing.getFromBtcSwapAmount(gasSwapFee, gasTokenAmount.token, chainIdentifier, true, gasTokenAmount.pricePrefetch);
-        signal.throwIfAborted();
-        let totalInToken;
-        if (!requestedAmount.input) {
-            totalInToken = requestedAmount.amount;
-        }
-        else {
-            totalInToken = await this.swapPricing.getFromBtcSwapAmount(amountBD - swapFee, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch);
-            signal.throwIfAborted();
-        }
-        if (totalInToken < 0n)
-            throw {
-                code: 20003,
-                msg: "Amount too low!"
-            };
-        return {
-            amountBD,
-            swapFee,
-            swapFeeInToken,
-            totalInToken,
-            amountBDgas,
-            gasSwapFee,
-            gasSwapFeeInToken,
-            totalInGasToken: gasTokenAmount?.amount,
-            securityDepositApyPPM,
-            securityDepositBaseMultiplierPPM
-        };
-    }
-}
-exports.FromBtcAmountAssertions = FromBtcAmountAssertions;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromBtcAmountAssertions = void 0;
+const PluginManager_1 = require("../../plugins/PluginManager");
+const IPlugin_1 = require("../../plugins/IPlugin");
+const AmountAssertions_1 = require("./AmountAssertions");
+class FromBtcAmountAssertions extends AmountAssertions_1.AmountAssertions {
+    constructor(config, swapPricing) {
+        super(config, swapPricing);
+        this.config = config;
+    }
+    /**
+     * Checks minimums/maximums, calculates the fee & total amount
+     *
+     * @param swapType
+     * @param request
+     * @param requestedAmount
+     * @param gasAmount
+     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
+     */
+    async preCheckFromBtcAmounts(swapType, request, requestedAmount, gasAmount) {
+        const res = await PluginManager_1.PluginManager.onHandlePreFromBtcQuote(swapType, request, requestedAmount, request.chainIdentifier, { minInBtc: this.config.min, maxInBtc: this.config.max }, { baseFeeInBtc: this.config.baseFee, feePPM: this.config.feePPM }, gasAmount);
+        if (res != null) {
+            AmountAssertions_1.AmountAssertions.handlePluginErrorResponses(res);
+            if ((0, IPlugin_1.isQuoteSetFees)(res)) {
+                return {
+                    baseFee: res.baseFee || this.config.baseFee,
+                    feePPM: res.feePPM || this.config.feePPM,
+                    securityDepositApyPPM: res.securityDepositApyPPM,
+                    securityDepositBaseMultiplierPPM: res.securityDepositBaseMultiplierPPM
+                };
+            }
+        }
+        if (requestedAmount.input)
+            this.checkBtcAmountInBounds(requestedAmount.amount);
+        if (gasAmount != null && gasAmount.amount !== 0n) {
+            if (gasAmount.amount > (this.config.gasTokenMax?.[request.chainIdentifier] ?? 0n)) {
+                throw {
+                    code: 20504,
+                    msg: "Gas token amount too high!",
+                    data: {
+                        max: (this.config.gasTokenMax?.[request.chainIdentifier] ?? 0n).toString(10)
+                    }
+                };
+            }
+        }
+        return {
+            baseFee: this.config.baseFee,
+            feePPM: this.config.feePPM
+        };
+    }
+    /**
+     * Checks minimums/maximums, calculates the fee & total amount
+     *
+     * @param swapType
+     * @param request
+     * @param requestedAmount
+     * @param fees
+     * @param signal
+     * @param gasTokenAmount
+     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
+     */
+    async checkFromBtcAmount(swapType, request, requestedAmount, fees, signal, gasTokenAmount) {
+        const chainIdentifier = request.chainIdentifier;
+        let securityDepositApyPPM;
+        let securityDepositBaseMultiplierPPM;
+        const res = await PluginManager_1.PluginManager.onHandlePostFromBtcQuote(swapType, request, requestedAmount, chainIdentifier, { minInBtc: this.config.min, maxInBtc: this.config.max }, { baseFeeInBtc: fees.baseFee, feePPM: fees.feePPM }, gasTokenAmount);
+        signal.throwIfAborted();
+        if (res != null) {
+            AmountAssertions_1.AmountAssertions.handlePluginErrorResponses(res);
+            if ((0, IPlugin_1.isQuoteSetFees)(res)) {
+                if (res.baseFee != null)
+                    fees.baseFee = res.baseFee;
+                if (res.feePPM != null)
+                    fees.feePPM = res.feePPM;
+                if (res.securityDepositApyPPM != null)
+                    securityDepositApyPPM = res.securityDepositApyPPM;
+                if (res.securityDepositBaseMultiplierPPM != null)
+                    securityDepositBaseMultiplierPPM = res.securityDepositBaseMultiplierPPM;
+            }
+            if ((0, IPlugin_1.isPluginQuote)(res)) {
+                if (!requestedAmount.input) {
+                    return {
+                        amountBD: res.amount.amount + res.swapFee.inInputTokens,
+                        swapFee: res.swapFee.inInputTokens,
+                        swapFeeInToken: res.swapFee.inOutputTokens,
+                        totalInToken: requestedAmount.amount
+                    };
+                }
+                else {
+                    return {
+                        amountBD: requestedAmount.amount,
+                        swapFee: res.swapFee.inInputTokens,
+                        swapFeeInToken: res.swapFee.inOutputTokens,
+                        totalInToken: res.amount.amount
+                    };
+                }
+            }
+        }
+        let amountBDgas = 0n;
+        let gasSwapFee = 0n;
+        if (gasTokenAmount != null) {
+            amountBDgas = await this.swapPricing.getToBtcSwapAmount(gasTokenAmount.amount, gasTokenAmount.token, chainIdentifier, true, gasTokenAmount.pricePrefetch);
+            signal.throwIfAborted();
+            const denominator = (1000000n - fees.feePPM);
+            const _amountBDgas = (amountBDgas * 1000000n + denominator - 1n) / denominator;
+            gasSwapFee = _amountBDgas - amountBDgas;
+            amountBDgas = _amountBDgas;
+        }
+        let amountBD;
+        let swapFee;
+        if (!requestedAmount.input) {
+            amountBD = await this.swapPricing.getToBtcSwapAmount(requestedAmount.amount, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch);
+            signal.throwIfAborted();
+            // amt = (amt+base_fee)/(1-fee)
+            const denominator = (1000000n - fees.feePPM);
+            const _amountBD = ((amountBD + fees.baseFee) * 1000000n + denominator - 1n) / denominator;
+            swapFee = _amountBD - amountBD;
+            amountBD = _amountBD;
+            const tooLow = amountBD < (this.config.min * 95n / 100n);
+            const tooHigh = amountBD > (this.config.max * 105n / 100n);
+            if (tooLow || tooHigh) {
+                const adjustedMin = this.config.min * (1000000n - fees.feePPM) / (1000000n - fees.baseFee);
+                const adjustedMax = this.config.max * (1000000n - fees.feePPM) / (1000000n - fees.baseFee);
+                const minIn = await this.swapPricing.getFromBtcSwapAmount(adjustedMin, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch);
+                const maxIn = await this.swapPricing.getFromBtcSwapAmount(adjustedMax, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch);
+                throw {
+                    code: tooLow ? 20003 : 20004,
+                    msg: tooLow ? "Amount too low!" : "Amount too high!",
+                    data: {
+                        min: minIn.toString(10),
+                        max: maxIn.toString(10)
+                    }
+                };
+            }
+        }
+        else {
+            this.checkBtcAmountInBounds(requestedAmount.amount);
+            amountBD = requestedAmount.amount - amountBDgas;
+            swapFee = fees.baseFee + ((amountBD * fees.feePPM + 999999n) / 1000000n);
+            if (amountBD - swapFee < 0n) {
+                throw {
+                    code: 20003,
+                    msg: "Amount too low!",
+                    data: {
+                        min: this.config.min.toString(10),
+                        max: this.config.max.toString(10)
+                    }
+                };
+            }
+        }
+        const swapFeeInToken = await this.swapPricing.getFromBtcSwapAmount(swapFee, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch);
+        signal.throwIfAborted();
+        const gasSwapFeeInToken = gasTokenAmount == null ?
+            0n :
+            await this.swapPricing.getFromBtcSwapAmount(gasSwapFee, gasTokenAmount.token, chainIdentifier, true, gasTokenAmount.pricePrefetch);
+        signal.throwIfAborted();
+        let totalInToken;
+        if (!requestedAmount.input) {
+            totalInToken = requestedAmount.amount;
+        }
+        else {
+            totalInToken = await this.swapPricing.getFromBtcSwapAmount(amountBD - swapFee, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch);
+            signal.throwIfAborted();
+        }
+        if (totalInToken < 0n)
+            throw {
+                code: 20003,
+                msg: "Amount too low!"
+            };
+        return {
+            amountBD,
+            swapFee,
+            swapFeeInToken,
+            totalInToken,
+            amountBDgas,
+            gasSwapFee,
+            gasSwapFeeInToken,
+            totalInGasToken: gasTokenAmount?.amount,
+            securityDepositApyPPM,
+            securityDepositBaseMultiplierPPM
+        };
+    }
+}
+exports.FromBtcAmountAssertions = FromBtcAmountAssertions;

package/dist/swaps/assertions/LightningAssertions.d.ts

@@ -1,44 +1,44 @@
-import { ILightningWallet, LightningNetworkChannel } from "../../wallets/ILightningWallet";
-import { LoggerType } from "../../utils/Utils";
-export declare class LightningAssertions {
-    protected readonly LIGHTNING_LIQUIDITY_CACHE_TIMEOUT: number;
-    lightningLiquidityCache: {
-        liquidity: bigint;
-        timestamp: number;
-    };
-    readonly lightning: ILightningWallet;
-    readonly logger: LoggerType;
-    constructor(logger: LoggerType, lightning: ILightningWallet);
-    /**
-     * Checks if the prior payment with the same paymentHash exists
-     *
-     * @param paymentHash
-     * @param abortSignal
-     * @throws {DefinedRuntimeError} will throw an error if payment already exists
-     */
-    checkPriorPayment(paymentHash: string, abortSignal: AbortSignal): Promise<void>;
-    /**
-     * Checks if the underlying LND backend has enough liquidity in channels to honor the swap
-     *
-     * @param amount
-     * @param abortSignal
-     * @param useCached Whether to use cached liquidity values
-     * @throws {DefinedRuntimeError} will throw an error if there isn't enough liquidity
-     */
-    checkLiquidity(amount: bigint, abortSignal: AbortSignal, useCached?: boolean): Promise<void>;
-    /**
-     * Checks if we have enough inbound liquidity to be able to receive an LN payment (without MPP)
-     *
-     * @param amountBD
-     * @param channelsPrefetch
-     * @param signal
-     * @throws {DefinedRuntimeError} will throw an error if there isn't enough inbound liquidity to receive the LN payment
-     */
-    checkInboundLiquidity(amountBD: bigint, channelsPrefetch: Promise<LightningNetworkChannel[]>, signal: AbortSignal): Promise<void>;
-    /**
-     * Starts LN channels pre-fetch
-     *
-     * @param abortController
-     */
-    getChannelsPrefetch(abortController: AbortController): Promise<LightningNetworkChannel[]>;
-}
+import { ILightningWallet, LightningNetworkChannel } from "../../wallets/ILightningWallet";
+import { LoggerType } from "../../utils/Utils";
+export declare class LightningAssertions {
+    protected readonly LIGHTNING_LIQUIDITY_CACHE_TIMEOUT: number;
+    lightningLiquidityCache: {
+        liquidity: bigint;
+        timestamp: number;
+    };
+    readonly lightning: ILightningWallet;
+    readonly logger: LoggerType;
+    constructor(logger: LoggerType, lightning: ILightningWallet);
+    /**
+     * Checks if the prior payment with the same paymentHash exists
+     *
+     * @param paymentHash
+     * @param abortSignal
+     * @throws {DefinedRuntimeError} will throw an error if payment already exists
+     */
+    checkPriorPayment(paymentHash: string, abortSignal: AbortSignal): Promise<void>;
+    /**
+     * Checks if the underlying LND backend has enough liquidity in channels to honor the swap
+     *
+     * @param amount
+     * @param abortSignal
+     * @param useCached Whether to use cached liquidity values
+     * @throws {DefinedRuntimeError} will throw an error if there isn't enough liquidity
+     */
+    checkLiquidity(amount: bigint, abortSignal: AbortSignal, useCached?: boolean): Promise<void>;
+    /**
+     * Checks if we have enough inbound liquidity to be able to receive an LN payment (without MPP)
+     *
+     * @param amountBD
+     * @param channelsPrefetch
+     * @param signal
+     * @throws {DefinedRuntimeError} will throw an error if there isn't enough inbound liquidity to receive the LN payment
+     */
+    checkInboundLiquidity(amountBD: bigint, channelsPrefetch: Promise<LightningNetworkChannel[]>, signal: AbortSignal): Promise<void>;
+    /**
+     * Starts LN channels pre-fetch
+     *
+     * @param abortController
+     */
+    getChannelsPrefetch(abortController: AbortController): Promise<LightningNetworkChannel[]>;
+}

package/dist/swaps/assertions/LightningAssertions.js

@@ -1,86 +1,86 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LightningAssertions = void 0;
-class LightningAssertions {
-    constructor(logger, lightning) {
-        this.LIGHTNING_LIQUIDITY_CACHE_TIMEOUT = 5 * 1000;
-        this.logger = logger;
-        this.lightning = lightning;
-    }
-    /**
-     * Checks if the prior payment with the same paymentHash exists
-     *
-     * @param paymentHash
-     * @param abortSignal
-     * @throws {DefinedRuntimeError} will throw an error if payment already exists
-     */
-    async checkPriorPayment(paymentHash, abortSignal) {
-        const payment = await this.lightning.getPayment(paymentHash);
-        if (payment != null)
-            throw {
-                code: 20010,
-                msg: "Already processed"
-            };
-        abortSignal.throwIfAborted();
-    }
-    /**
-     * Checks if the underlying LND backend has enough liquidity in channels to honor the swap
-     *
-     * @param amount
-     * @param abortSignal
-     * @param useCached Whether to use cached liquidity values
-     * @throws {DefinedRuntimeError} will throw an error if there isn't enough liquidity
-     */
-    async checkLiquidity(amount, abortSignal, useCached = false) {
-        if (!useCached || this.lightningLiquidityCache == null || this.lightningLiquidityCache.timestamp < Date.now() - this.LIGHTNING_LIQUIDITY_CACHE_TIMEOUT) {
-            const channelBalances = await this.lightning.getLightningBalance();
-            this.lightningLiquidityCache = {
-                liquidity: channelBalances.localBalance,
-                timestamp: Date.now()
-            };
-        }
-        if (amount > this.lightningLiquidityCache.liquidity) {
-            throw {
-                code: 20002,
-                msg: "Not enough liquidity"
-            };
-        }
-        abortSignal.throwIfAborted();
-    }
-    /**
-     * Checks if we have enough inbound liquidity to be able to receive an LN payment (without MPP)
-     *
-     * @param amountBD
-     * @param channelsPrefetch
-     * @param signal
-     * @throws {DefinedRuntimeError} will throw an error if there isn't enough inbound liquidity to receive the LN payment
-     */
-    async checkInboundLiquidity(amountBD, channelsPrefetch, signal) {
-        const channelsResponse = await channelsPrefetch;
-        signal.throwIfAborted();
-        let hasEnoughInboundLiquidity = false;
-        channelsResponse.forEach(channel => {
-            if (channel.remoteBalance >= amountBD)
-                hasEnoughInboundLiquidity = true;
-        });
-        if (!hasEnoughInboundLiquidity) {
-            throw {
-                code: 20050,
-                msg: "Not enough LN inbound liquidity"
-            };
-        }
-    }
-    /**
-     * Starts LN channels pre-fetch
-     *
-     * @param abortController
-     */
-    getChannelsPrefetch(abortController) {
-        return this.lightning.getChannels(true).catch(e => {
-            this.logger.error("getChannelsPrefetch(): error", e);
-            abortController.abort(e);
-            return null;
-        });
-    }
-}
-exports.LightningAssertions = LightningAssertions;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LightningAssertions = void 0;
+class LightningAssertions {
+    constructor(logger, lightning) {
+        this.LIGHTNING_LIQUIDITY_CACHE_TIMEOUT = 5 * 1000;
+        this.logger = logger;
+        this.lightning = lightning;
+    }
+    /**
+     * Checks if the prior payment with the same paymentHash exists
+     *
+     * @param paymentHash
+     * @param abortSignal
+     * @throws {DefinedRuntimeError} will throw an error if payment already exists
+     */
+    async checkPriorPayment(paymentHash, abortSignal) {
+        const payment = await this.lightning.getPayment(paymentHash);
+        if (payment != null)
+            throw {
+                code: 20010,
+                msg: "Already processed"
+            };
+        abortSignal.throwIfAborted();
+    }
+    /**
+     * Checks if the underlying LND backend has enough liquidity in channels to honor the swap
+     *
+     * @param amount
+     * @param abortSignal
+     * @param useCached Whether to use cached liquidity values
+     * @throws {DefinedRuntimeError} will throw an error if there isn't enough liquidity
+     */
+    async checkLiquidity(amount, abortSignal, useCached = false) {
+        if (!useCached || this.lightningLiquidityCache == null || this.lightningLiquidityCache.timestamp < Date.now() - this.LIGHTNING_LIQUIDITY_CACHE_TIMEOUT) {
+            const channelBalances = await this.lightning.getLightningBalance();
+            this.lightningLiquidityCache = {
+                liquidity: channelBalances.localBalance,
+                timestamp: Date.now()
+            };
+        }
+        if (amount > this.lightningLiquidityCache.liquidity) {
+            throw {
+                code: 20002,
+                msg: "Not enough liquidity"
+            };
+        }
+        abortSignal.throwIfAborted();
+    }
+    /**
+     * Checks if we have enough inbound liquidity to be able to receive an LN payment (without MPP)
+     *
+     * @param amountBD
+     * @param channelsPrefetch
+     * @param signal
+     * @throws {DefinedRuntimeError} will throw an error if there isn't enough inbound liquidity to receive the LN payment
+     */
+    async checkInboundLiquidity(amountBD, channelsPrefetch, signal) {
+        const channelsResponse = await channelsPrefetch;
+        signal.throwIfAborted();
+        let hasEnoughInboundLiquidity = false;
+        channelsResponse.forEach(channel => {
+            if (channel.remoteBalance >= amountBD)
+                hasEnoughInboundLiquidity = true;
+        });
+        if (!hasEnoughInboundLiquidity) {
+            throw {
+                code: 20050,
+                msg: "Not enough LN inbound liquidity"
+            };
+        }
+    }
+    /**
+     * Starts LN channels pre-fetch
+     *
+     * @param abortController
+     */
+    getChannelsPrefetch(abortController) {
+        return this.lightning.getChannels(true).catch(e => {
+            this.logger.error("getChannelsPrefetch(): error", e);
+            abortController.abort(e);
+            return null;
+        });
+    }
+}
+exports.LightningAssertions = LightningAssertions;