@atomiqlabs/lp-lib 17.5.1 → 17.5.2

package/src/swaps/assertions/LightningAssertions.ts

@@ -1,103 +1,103 @@
-import {ILightningWallet, LightningNetworkChannel} from "../../wallets/ILightningWallet";
-import {LoggerType} from "../../utils/Utils";
-import {ISwapPrice} from "../../prices/ISwapPrice";
-
-export class LightningAssertions {
-
-    protected readonly LIGHTNING_LIQUIDITY_CACHE_TIMEOUT = 5*1000;
-    lightningLiquidityCache: {
-        liquidity: bigint,
-        timestamp: number
-    };
-
-    readonly lightning: ILightningWallet;
-    readonly logger: LoggerType;
-
-    constructor(
-        logger: LoggerType,
-        lightning: ILightningWallet
-    ) {
-        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: string, abortSignal: AbortSignal): Promise<void> {
-        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: bigint, abortSignal: AbortSignal, useCached: boolean = false): Promise<void> {
-        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: bigint, channelsPrefetch: Promise<LightningNetworkChannel[]>, signal: AbortSignal) {
-        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: AbortController): Promise<LightningNetworkChannel[]> {
-        return this.lightning.getChannels(true).catch(e => {
-            this.logger.error("getChannelsPrefetch(): error", e);
-            abortController.abort(e);
-            return null;
-        });
-    }
-
-}
+import {ILightningWallet, LightningNetworkChannel} from "../../wallets/ILightningWallet";
+import {LoggerType} from "../../utils/Utils";
+import {ISwapPrice} from "../../prices/ISwapPrice";
+
+export class LightningAssertions {
+
+    protected readonly LIGHTNING_LIQUIDITY_CACHE_TIMEOUT = 5*1000;
+    lightningLiquidityCache: {
+        liquidity: bigint,
+        timestamp: number
+    };
+
+    readonly lightning: ILightningWallet;
+    readonly logger: LoggerType;
+
+    constructor(
+        logger: LoggerType,
+        lightning: ILightningWallet
+    ) {
+        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: string, abortSignal: AbortSignal): Promise<void> {
+        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: bigint, abortSignal: AbortSignal, useCached: boolean = false): Promise<void> {
+        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: bigint, channelsPrefetch: Promise<LightningNetworkChannel[]>, signal: AbortSignal) {
+        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: AbortController): Promise<LightningNetworkChannel[]> {
+        return this.lightning.getChannels(true).catch(e => {
+            this.logger.error("getChannelsPrefetch(): error", e);
+            abortController.abort(e);
+            return null;
+        });
+    }
+
+}

package/src/swaps/assertions/ToBtcAmountAssertions.ts

@@ -1,210 +1,210 @@
-import {AmountAssertions} from "./AmountAssertions";
-import {ToBtcLnRequestType} from "../escrow/tobtcln_abstract/ToBtcLnAbs";
-import {ToBtcRequestType} from "../escrow/tobtc_abstract/ToBtcAbs";
-import {PluginManager} from "../../plugins/PluginManager";
-import {isQuoteSetFees, isToBtcPluginQuote} from "../../plugins/IPlugin";
-import {RequestData, SwapHandlerType} from "../SwapHandler";
-
-
-export class ToBtcAmountAssertions extends AmountAssertions {
-
-    /**
-     * Checks minimums/maximums, calculates the fee & total amount
-     *
-     * @param swapType
-     * @param request
-     * @param requestedAmount
-     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
-     */
-    async preCheckToBtcAmounts(
-        swapType: SwapHandlerType.TO_BTCLN | SwapHandlerType.TO_BTC,
-        request: RequestData<ToBtcLnRequestType | ToBtcRequestType>,
-        requestedAmount: {input: boolean, amount: bigint, token: string}
-    ): Promise<{baseFee: bigint, feePPM: bigint}> {
-        const min = this.getSwapMinimum(request.chainIdentifier);
-        const max = this.getSwapMaximum(request.chainIdentifier);
-
-        const res = await PluginManager.onHandlePreToBtcQuote(
-            swapType,
-            request,
-            requestedAmount,
-            request.chainIdentifier,
-            {minInBtc: min, maxInBtc: max},
-            {baseFeeInBtc: this.config.baseFee, feePPM: this.config.feePPM},
-        );
-        if(res!=null) {
-            AmountAssertions.handlePluginErrorResponses(res);
-            if(isQuoteSetFees(res)) {
-                return {
-                    baseFee: res.baseFee ?? this.config.baseFee,
-                    feePPM: res.feePPM ?? this.config.feePPM
-                }
-            }
-        }
-        if(!requestedAmount.input) {
-            this.checkBtcAmountInBounds(requestedAmount.amount, request.chainIdentifier);
-        }
-        return {
-            baseFee: this.config.baseFee,
-            feePPM: this.config.feePPM
-        };
-    }
-
-    /**
-     * Checks minimums/maximums, calculates network fee (based on the callback passed), swap fee & total amount
-     *
-     * @param swapType
-     * @param request
-     * @param requestedAmount
-     * @param fees
-     * @param getNetworkFee
-     * @param signal
-     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds,
-     *  or if we don't have enough funds (getNetworkFee callback throws)
-     */
-    async checkToBtcAmount<T extends {networkFee: bigint}>(
-        swapType: SwapHandlerType.TO_BTCLN | SwapHandlerType.TO_BTC,
-        request: RequestData<ToBtcLnRequestType | ToBtcRequestType>,
-        requestedAmount: {input: boolean, amount: bigint, token: string, pricePrefetch?: Promise<bigint>},
-        fees: {baseFee: bigint, feePPM: bigint},
-        getNetworkFee: (amount: bigint) => Promise<T>,
-        signal: AbortSignal
-    ): Promise<{
-        amountBD: bigint,
-        networkFeeData: T,
-        swapFee: bigint,
-        swapFeeInToken: bigint,
-        networkFee: bigint,
-        networkFeeInToken: bigint,
-        totalInToken: bigint
-    }> {
-        const chainIdentifier = request.chainIdentifier;
-
-        const min = this.getSwapMinimum(chainIdentifier);
-        const max = this.getSwapMaximum(chainIdentifier);
-
-        const res = await PluginManager.onHandlePostToBtcQuote<T>(
-            swapType,
-            request,
-            requestedAmount,
-            request.chainIdentifier,
-            {minInBtc: min, maxInBtc: max},
-            {baseFeeInBtc: fees.baseFee, feePPM: fees.feePPM, networkFeeGetter: getNetworkFee}
-        );
-        signal.throwIfAborted();
-        if(res!=null) {
-            AmountAssertions.handlePluginErrorResponses(res);
-            if(isQuoteSetFees(res)) {
-                if(res.baseFee!=null) fees.baseFee = res.baseFee;
-                if(res.feePPM!=null) fees.feePPM = res.feePPM;
-            }
-            if(isToBtcPluginQuote(res)) {
-                if(requestedAmount.input) {
-                    return {
-                        amountBD: res.amount.amount,
-                        swapFee: res.swapFee.inOutputTokens,
-                        swapFeeInToken: res.swapFee.inInputTokens,
-                        networkFee: res.networkFee.inOutputTokens,
-                        networkFeeInToken: res.networkFee.inInputTokens,
-                        networkFeeData: res.networkFeeData,
-                        totalInToken: requestedAmount.amount
-                    }
-                } else {
-                    return {
-                        amountBD: requestedAmount.amount,
-                        swapFee: res.swapFee.inOutputTokens,
-                        swapFeeInToken: res.swapFee.inInputTokens,
-                        networkFee: res.networkFee.inOutputTokens,
-                        networkFeeInToken: res.networkFee.inInputTokens,
-                        networkFeeData: res.networkFeeData,
-                        totalInToken: res.amount.amount + res.swapFee.inInputTokens + res.networkFee.inInputTokens
-                    }
-                }
-            }
-        }
-
-        let amountBD: bigint;
-        let tooHigh = false;
-        let tooLow = false;
-        if(requestedAmount.input) {
-            amountBD = await this.swapPricing.getToBtcSwapAmount(requestedAmount.amount, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch);
-            signal.throwIfAborted();
-
-            //Decrease by base fee
-            amountBD = amountBD - fees.baseFee;
-
-            //If it's already smaller than minimum, set it to minimum so we can calculate the network fee
-            if(amountBD < (min * 95n / 100n)) {
-                amountBD = min;
-                tooLow = true;
-            }
-            //If it's already larger than maximum, set it to maximum so we can calculate the network fee
-            if(amountBD > (max * 105n / 100n)) {
-                amountBD = max;
-                tooHigh = true;
-            }
-        } else {
-            amountBD = requestedAmount.amount;
-            this.checkBtcAmountInBounds(amountBD, chainIdentifier);
-        }
-
-        const resp = await getNetworkFee(amountBD);
-        signal.throwIfAborted();
-
-        if(requestedAmount.input) {
-            //Decrease by network fee
-            amountBD = amountBD - resp.networkFee;
-
-            //Decrease by percentage fee
-            amountBD = amountBD * 1000000n / (fees.feePPM + 1000000n);
-
-            tooHigh ||= amountBD > (max * 105n / 100n);
-            tooLow ||= amountBD < (min * 95n / 100n);
-            if(tooLow || tooHigh) {
-                //Compute min/max
-                let adjustedMin = min * (fees.feePPM + 1000000n) / 1000000n;
-                let adjustedMax = max * (fees.feePPM + 1000000n) / 1000000n;
-                adjustedMin = adjustedMin + fees.baseFee + resp.networkFee;
-                adjustedMax = adjustedMax + fees.baseFee + resp.networkFee;
-                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)
-                    }
-                };
-            }
-        }
-
-        const swapFee = fees.baseFee + (amountBD * fees.feePPM / 1000000n);
-
-        const networkFeeInToken = await this.swapPricing.getFromBtcSwapAmount(
-            resp.networkFee, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch
-        );
-        const swapFeeInToken = await this.swapPricing.getFromBtcSwapAmount(
-            swapFee, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch
-        );
-        signal.throwIfAborted();
-
-        let total: bigint;
-        if(requestedAmount.input) {
-            total = requestedAmount.amount;
-        } else {
-            const amountInToken = await this.swapPricing.getFromBtcSwapAmount(
-                requestedAmount.amount, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch
-            );
-            signal.throwIfAborted();
-            total = amountInToken + swapFeeInToken + networkFeeInToken;
-        }
-
-        return {amountBD, networkFeeData: resp, swapFee, swapFeeInToken, networkFee: resp.networkFee, networkFeeInToken, totalInToken: total};
-    }
-
+import {AmountAssertions} from "./AmountAssertions";
+import {ToBtcLnRequestType} from "../escrow/tobtcln_abstract/ToBtcLnAbs";
+import {ToBtcRequestType} from "../escrow/tobtc_abstract/ToBtcAbs";
+import {PluginManager} from "../../plugins/PluginManager";
+import {isQuoteSetFees, isToBtcPluginQuote} from "../../plugins/IPlugin";
+import {RequestData, SwapHandlerType} from "../SwapHandler";
+
+
+export class ToBtcAmountAssertions extends AmountAssertions {
+
+    /**
+     * Checks minimums/maximums, calculates the fee & total amount
+     *
+     * @param swapType
+     * @param request
+     * @param requestedAmount
+     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
+     */
+    async preCheckToBtcAmounts(
+        swapType: SwapHandlerType.TO_BTCLN | SwapHandlerType.TO_BTC,
+        request: RequestData<ToBtcLnRequestType | ToBtcRequestType>,
+        requestedAmount: {input: boolean, amount: bigint, token: string}
+    ): Promise<{baseFee: bigint, feePPM: bigint}> {
+        const min = this.getSwapMinimum(request.chainIdentifier);
+        const max = this.getSwapMaximum(request.chainIdentifier);
+
+        const res = await PluginManager.onHandlePreToBtcQuote(
+            swapType,
+            request,
+            requestedAmount,
+            request.chainIdentifier,
+            {minInBtc: min, maxInBtc: max},
+            {baseFeeInBtc: this.config.baseFee, feePPM: this.config.feePPM},
+        );
+        if(res!=null) {
+            AmountAssertions.handlePluginErrorResponses(res);
+            if(isQuoteSetFees(res)) {
+                return {
+                    baseFee: res.baseFee ?? this.config.baseFee,
+                    feePPM: res.feePPM ?? this.config.feePPM
+                }
+            }
+        }
+        if(!requestedAmount.input) {
+            this.checkBtcAmountInBounds(requestedAmount.amount, request.chainIdentifier);
+        }
+        return {
+            baseFee: this.config.baseFee,
+            feePPM: this.config.feePPM
+        };
+    }
+
+    /**
+     * Checks minimums/maximums, calculates network fee (based on the callback passed), swap fee & total amount
+     *
+     * @param swapType
+     * @param request
+     * @param requestedAmount
+     * @param fees
+     * @param getNetworkFee
+     * @param signal
+     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds,
+     *  or if we don't have enough funds (getNetworkFee callback throws)
+     */
+    async checkToBtcAmount<T extends {networkFee: bigint}>(
+        swapType: SwapHandlerType.TO_BTCLN | SwapHandlerType.TO_BTC,
+        request: RequestData<ToBtcLnRequestType | ToBtcRequestType>,
+        requestedAmount: {input: boolean, amount: bigint, token: string, pricePrefetch?: Promise<bigint>},
+        fees: {baseFee: bigint, feePPM: bigint},
+        getNetworkFee: (amount: bigint) => Promise<T>,
+        signal: AbortSignal
+    ): Promise<{
+        amountBD: bigint,
+        networkFeeData: T,
+        swapFee: bigint,
+        swapFeeInToken: bigint,
+        networkFee: bigint,
+        networkFeeInToken: bigint,
+        totalInToken: bigint
+    }> {
+        const chainIdentifier = request.chainIdentifier;
+
+        const min = this.getSwapMinimum(chainIdentifier);
+        const max = this.getSwapMaximum(chainIdentifier);
+
+        const res = await PluginManager.onHandlePostToBtcQuote<T>(
+            swapType,
+            request,
+            requestedAmount,
+            request.chainIdentifier,
+            {minInBtc: min, maxInBtc: max},
+            {baseFeeInBtc: fees.baseFee, feePPM: fees.feePPM, networkFeeGetter: getNetworkFee}
+        );
+        signal.throwIfAborted();
+        if(res!=null) {
+            AmountAssertions.handlePluginErrorResponses(res);
+            if(isQuoteSetFees(res)) {
+                if(res.baseFee!=null) fees.baseFee = res.baseFee;
+                if(res.feePPM!=null) fees.feePPM = res.feePPM;
+            }
+            if(isToBtcPluginQuote(res)) {
+                if(requestedAmount.input) {
+                    return {
+                        amountBD: res.amount.amount,
+                        swapFee: res.swapFee.inOutputTokens,
+                        swapFeeInToken: res.swapFee.inInputTokens,
+                        networkFee: res.networkFee.inOutputTokens,
+                        networkFeeInToken: res.networkFee.inInputTokens,
+                        networkFeeData: res.networkFeeData,
+                        totalInToken: requestedAmount.amount
+                    }
+                } else {
+                    return {
+                        amountBD: requestedAmount.amount,
+                        swapFee: res.swapFee.inOutputTokens,
+                        swapFeeInToken: res.swapFee.inInputTokens,
+                        networkFee: res.networkFee.inOutputTokens,
+                        networkFeeInToken: res.networkFee.inInputTokens,
+                        networkFeeData: res.networkFeeData,
+                        totalInToken: res.amount.amount + res.swapFee.inInputTokens + res.networkFee.inInputTokens
+                    }
+                }
+            }
+        }
+
+        let amountBD: bigint;
+        let tooHigh = false;
+        let tooLow = false;
+        if(requestedAmount.input) {
+            amountBD = await this.swapPricing.getToBtcSwapAmount(requestedAmount.amount, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch);
+            signal.throwIfAborted();
+
+            //Decrease by base fee
+            amountBD = amountBD - fees.baseFee;
+
+            //If it's already smaller than minimum, set it to minimum so we can calculate the network fee
+            if(amountBD < (min * 95n / 100n)) {
+                amountBD = min;
+                tooLow = true;
+            }
+            //If it's already larger than maximum, set it to maximum so we can calculate the network fee
+            if(amountBD > (max * 105n / 100n)) {
+                amountBD = max;
+                tooHigh = true;
+            }
+        } else {
+            amountBD = requestedAmount.amount;
+            this.checkBtcAmountInBounds(amountBD, chainIdentifier);
+        }
+
+        const resp = await getNetworkFee(amountBD);
+        signal.throwIfAborted();
+
+        if(requestedAmount.input) {
+            //Decrease by network fee
+            amountBD = amountBD - resp.networkFee;
+
+            //Decrease by percentage fee
+            amountBD = amountBD * 1000000n / (fees.feePPM + 1000000n);
+
+            tooHigh ||= amountBD > (max * 105n / 100n);
+            tooLow ||= amountBD < (min * 95n / 100n);
+            if(tooLow || tooHigh) {
+                //Compute min/max
+                let adjustedMin = min * (fees.feePPM + 1000000n) / 1000000n;
+                let adjustedMax = max * (fees.feePPM + 1000000n) / 1000000n;
+                adjustedMin = adjustedMin + fees.baseFee + resp.networkFee;
+                adjustedMax = adjustedMax + fees.baseFee + resp.networkFee;
+                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)
+                    }
+                };
+            }
+        }
+
+        const swapFee = fees.baseFee + (amountBD * fees.feePPM / 1000000n);
+
+        const networkFeeInToken = await this.swapPricing.getFromBtcSwapAmount(
+            resp.networkFee, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch
+        );
+        const swapFeeInToken = await this.swapPricing.getFromBtcSwapAmount(
+            swapFee, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch
+        );
+        signal.throwIfAborted();
+
+        let total: bigint;
+        if(requestedAmount.input) {
+            total = requestedAmount.amount;
+        } else {
+            const amountInToken = await this.swapPricing.getFromBtcSwapAmount(
+                requestedAmount.amount, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch
+            );
+            signal.throwIfAborted();
+            total = amountInToken + swapFeeInToken + networkFeeInToken;
+        }
+
+        return {amountBD, networkFeeData: resp, swapFee, swapFeeInToken, networkFee: resp.networkFee, networkFeeInToken, totalInToken: total};
+    }
+
 }