@atomiqlabs/lp-lib 14.0.0-dev.13 → 14.0.0-dev.16

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

@@ -1,76 +1,76 @@
-import { FromBtcLnRequestType } from "../escrow/frombtcln_abstract/FromBtcLnAbs";
-import { FromBtcRequestType } from "../escrow/frombtc_abstract/FromBtcAbs";
-import { FromBtcLnTrustedRequestType } from "../trusted/frombtcln_trusted/FromBtcLnTrusted";
-import { RequestData, SwapHandlerType } from "../SwapHandler";
-import { AmountAssertions, AmountAssertionsConfig } from "./AmountAssertions";
-import { ISwapPrice } from "../../prices/ISwapPrice";
-import { FromBtcTrustedRequestType } from "../trusted/frombtc_trusted/FromBtcTrusted";
-import { SpvVaultSwapRequestType } from "../spv_vault_swap/SpvVaultSwapHandler";
-export type FromBtcAmountAssertionsConfig = AmountAssertionsConfig & {
-    gasTokenMax?: {
-        [chainId: string]: bigint;
-    };
-};
-export declare class FromBtcAmountAssertions extends AmountAssertions {
-    readonly config: FromBtcAmountAssertionsConfig;
-    constructor(config: FromBtcAmountAssertionsConfig, swapPricing: ISwapPrice);
-    /**
-     * 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
-     */
-    preCheckFromBtcAmounts(swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV | SwapHandlerType.FROM_BTCLN_AUTO, request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType | FromBtcTrustedRequestType | SpvVaultSwapRequestType>, requestedAmount: {
-        input: boolean;
-        amount: bigint;
-        token: string;
-    }, gasAmount?: {
-        input: false;
-        amount: bigint;
-        token: string;
-    }): Promise<{
-        baseFee: bigint;
-        feePPM: bigint;
-        securityDepositApyPPM?: bigint;
-        securityDepositBaseMultiplierPPM?: bigint;
-    }>;
-    /**
-     * 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
-     */
-    checkFromBtcAmount(swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV | SwapHandlerType.FROM_BTCLN_AUTO, request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType | FromBtcTrustedRequestType | SpvVaultSwapRequestType>, requestedAmount: {
-        input: boolean;
-        amount: bigint;
-        token: string;
-        pricePrefetch?: Promise<bigint>;
-    }, fees: {
-        baseFee: bigint;
-        feePPM: bigint;
-    }, signal: AbortSignal, gasTokenAmount?: {
-        input: false;
-        amount: bigint;
-        token: string;
-        pricePrefetch?: Promise<bigint>;
-    }): Promise<{
-        amountBD: bigint;
-        swapFee: bigint;
-        swapFeeInToken: bigint;
-        totalInToken: bigint;
-        amountBDgas?: bigint;
-        gasSwapFee?: bigint;
-        gasSwapFeeInToken?: bigint;
-        totalInGasToken?: bigint;
-        securityDepositApyPPM?: bigint;
-        securityDepositBaseMultiplierPPM?: bigint;
-    }>;
-}
+import { FromBtcLnRequestType } from "../escrow/frombtcln_abstract/FromBtcLnAbs";
+import { FromBtcRequestType } from "../escrow/frombtc_abstract/FromBtcAbs";
+import { FromBtcLnTrustedRequestType } from "../trusted/frombtcln_trusted/FromBtcLnTrusted";
+import { RequestData, SwapHandlerType } from "../SwapHandler";
+import { AmountAssertions, AmountAssertionsConfig } from "./AmountAssertions";
+import { ISwapPrice } from "../../prices/ISwapPrice";
+import { FromBtcTrustedRequestType } from "../trusted/frombtc_trusted/FromBtcTrusted";
+import { SpvVaultSwapRequestType } from "../spv_vault_swap/SpvVaultSwapHandler";
+export type FromBtcAmountAssertionsConfig = AmountAssertionsConfig & {
+    gasTokenMax?: {
+        [chainId: string]: bigint;
+    };
+};
+export declare class FromBtcAmountAssertions extends AmountAssertions {
+    readonly config: FromBtcAmountAssertionsConfig;
+    constructor(config: FromBtcAmountAssertionsConfig, swapPricing: ISwapPrice);
+    /**
+     * 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
+     */
+    preCheckFromBtcAmounts(swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV | SwapHandlerType.FROM_BTCLN_AUTO, request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType | FromBtcTrustedRequestType | SpvVaultSwapRequestType>, requestedAmount: {
+        input: boolean;
+        amount: bigint;
+        token: string;
+    }, gasAmount?: {
+        input: false;
+        amount: bigint;
+        token: string;
+    }): Promise<{
+        baseFee: bigint;
+        feePPM: bigint;
+        securityDepositApyPPM?: bigint;
+        securityDepositBaseMultiplierPPM?: bigint;
+    }>;
+    /**
+     * 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
+     */
+    checkFromBtcAmount(swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV | SwapHandlerType.FROM_BTCLN_AUTO, request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType | FromBtcTrustedRequestType | SpvVaultSwapRequestType>, requestedAmount: {
+        input: boolean;
+        amount: bigint;
+        token: string;
+        pricePrefetch?: Promise<bigint>;
+    }, fees: {
+        baseFee: bigint;
+        feePPM: bigint;
+    }, signal: AbortSignal, gasTokenAmount?: {
+        input: false;
+        amount: bigint;
+        token: string;
+        pricePrefetch?: Promise<bigint>;
+    }): Promise<{
+        amountBD: bigint;
+        swapFee: bigint;
+        swapFeeInToken: bigint;
+        totalInToken: bigint;
+        amountBDgas?: bigint;
+        gasSwapFee?: bigint;
+        gasSwapFeeInToken?: bigint;
+        totalInGasToken?: bigint;
+        securityDepositApyPPM?: bigint;
+        securityDepositBaseMultiplierPPM?: bigint;
+    }>;
+}

package/dist/swaps/assertions/FromBtcAmountAssertions.js

@@ -1,172 +1,180 @@
-"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;
-        if (gasTokenAmount != null) {
-            amountBDgas = await this.swapPricing.getToBtcSwapAmount(gasTokenAmount.amount, gasTokenAmount.token, chainIdentifier, true, gasTokenAmount.pricePrefetch);
-        }
-        let amountBD;
-        if (!requestedAmount.input) {
-            amountBD = await this.swapPricing.getToBtcSwapAmount(requestedAmount.amount, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch);
-            signal.throwIfAborted();
-            // amt = (amt+base_fee)/(1-fee)
-            amountBD = (amountBD + fees.baseFee) * 1000000n / (1000000n - fees.feePPM);
-            amountBDgas = amountBDgas * 1000000n / (1000000n - fees.feePPM);
-            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;
-            if (amountBD < 0n) {
-                throw {
-                    code: 20003,
-                    msg: "Amount too low!",
-                    data: {
-                        min: this.config.min.toString(10),
-                        max: this.config.max.toString(10)
-                    }
-                };
-            }
-        }
-        const swapFee = fees.baseFee + (amountBD * fees.feePPM / 1000000n);
-        const swapFeeInToken = await this.swapPricing.getFromBtcSwapAmount(swapFee, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch);
-        signal.throwIfAborted();
-        const gasSwapFee = ((amountBDgas * fees.feePPM) + 999999n) / 1000000n;
-        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 - gasSwapFee, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch);
-            signal.throwIfAborted();
-        }
-        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 < 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();
+        }
+        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[]>;
+}