@atomiqlabs/lp-lib 11.0.5 → 12.0.0-beta.0

package/dist/swaps/FromBtcBaseSwapHandler.d.ts

@@ -1,7 +1,6 @@
 import { SwapHandlerSwap } from "./SwapHandlerSwap";
 import { SwapData } from "@atomiqlabs/base";
 import { RequestData, SwapBaseConfig, SwapHandler } from "./SwapHandler";
-import * as BN from "bn.js";
 import { IParamReader } from "../utils/paramcoders/IParamReader";
 import { FromBtcLnRequestType } from "./frombtcln_abstract/FromBtcLnAbs";
 import { FromBtcRequestType } from "./frombtc_abstract/FromBtcAbs";
@@ -17,20 +16,25 @@ export declare abstract class FromBtcBaseSwapHandler<V extends SwapHandlerSwap<S
      *
      * @param chainIdentifier
      * @param useToken
+     * @param depositToken
      * @param abortController
      */
-    protected getFromBtcPricePrefetches(chainIdentifier: string, useToken: string, abortController: AbortController): {
-        pricePrefetchPromise: Promise<BN>;
-        securityDepositPricePrefetchPromise: Promise<BN>;
+    protected getFromBtcPricePrefetches(chainIdentifier: string, useToken: string, depositToken: string, abortController: AbortController): {
+        pricePrefetchPromise: Promise<bigint>;
+        gasTokenPricePrefetchPromise: Promise<bigint>;
+        depositTokenPricePrefetchPromise: Promise<bigint>;
     };
     /**
      * Starts a pre-fetch for base security deposit (transaction fee for refunding transaction on our side)
      *
      * @param chainIdentifier
      * @param dummySwapData
+     * @param depositToken
+     * @param gasTokenPricePrefetchPromise
+     * @param depositTokenPricePrefetchPromise
      * @param abortController
      */
-    protected getBaseSecurityDepositPrefetch(chainIdentifier: string, dummySwapData: SwapData, abortController: AbortController): Promise<BN>;
+    protected getBaseSecurityDepositPrefetch(chainIdentifier: string, dummySwapData: SwapData, depositToken: string, gasTokenPricePrefetchPromise: Promise<bigint>, depositTokenPricePrefetchPromise: Promise<bigint>, abortController: AbortController): Promise<bigint>;
     /**
      * Starts a pre-fetch for vault balance
      *
@@ -38,7 +42,7 @@ export declare abstract class FromBtcBaseSwapHandler<V extends SwapHandlerSwap<S
      * @param useToken
      * @param abortController
      */
-    protected getBalancePrefetch(chainIdentifier: string, useToken: string, abortController: AbortController): Promise<BN>;
+    protected getBalancePrefetch(chainIdentifier: string, useToken: string, abortController: AbortController): Promise<bigint>;
     /**
      * Checks if we have enough balance of the token in the swap vault
      *
@@ -47,7 +51,15 @@ export declare abstract class FromBtcBaseSwapHandler<V extends SwapHandlerSwap<S
      * @param signal
      * @throws {DefinedRuntimeError} will throw an error if there are not enough funds in the vault
      */
-    protected checkBalance(totalInToken: BN, balancePrefetch: Promise<BN>, signal: AbortSignal | null): Promise<void>;
+    protected checkBalance(totalInToken: bigint, balancePrefetch: Promise<bigint>, signal: AbortSignal | null): Promise<void>;
+    /**
+     * Checks if the specified token is allowed as a deposit token
+     *
+     * @param chainIdentifier
+     * @param depositToken
+     * @throws {DefinedRuntimeError} will throw an error if there are not enough funds in the vault
+     */
+    protected checkAllowedDepositToken(chainIdentifier: string, depositToken: string): void;
     /**
      * Checks minimums/maximums, calculates the fee & total amount
      *
@@ -58,10 +70,10 @@ export declare abstract class FromBtcBaseSwapHandler<V extends SwapHandlerSwap<S
      */
     protected preCheckAmounts(request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>, requestedAmount: {
         input: boolean;
-        amount: BN;
+        amount: bigint;
     }, useToken: string): Promise<{
-        baseFee: BN;
-        feePPM: BN;
+        baseFee: bigint;
+        feePPM: bigint;
     }>;
     /**
      * Checks minimums/maximums, calculates the fee & total amount
@@ -76,29 +88,16 @@ export declare abstract class FromBtcBaseSwapHandler<V extends SwapHandlerSwap<S
      */
     protected checkFromBtcAmount(request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>, requestedAmount: {
         input: boolean;
-        amount: BN;
+        amount: bigint;
     }, fees: {
-        baseFee: BN;
-        feePPM: BN;
-    }, useToken: string, signal: AbortSignal, pricePrefetchPromise?: Promise<BN>): Promise<{
-        amountBD: BN;
-        swapFee: BN;
-        swapFeeInToken: BN;
-        totalInToken: BN;
+        baseFee: bigint;
+        feePPM: bigint;
+    }, useToken: string, signal: AbortSignal, pricePrefetchPromise?: Promise<bigint>): Promise<{
+        amountBD: bigint;
+        swapFee: bigint;
+        swapFeeInToken: bigint;
+        totalInToken: bigint;
     }>;
-    /**
-     * Calculates the required security deposit
-     *
-     * @param chainIdentifier
-     * @param amountBD
-     * @param swapFee
-     * @param expiryTimeout
-     * @param baseSecurityDepositPromise
-     * @param securityDepositPricePrefetchPromise
-     * @param signal
-     * @param metadata
-     */
-    protected getSecurityDeposit(chainIdentifier: string, amountBD: BN, swapFee: BN, expiryTimeout: BN, baseSecurityDepositPromise: Promise<BN>, securityDepositPricePrefetchPromise: Promise<BN>, signal: AbortSignal, metadata: any): Promise<BN>;
     /**
      * Signs the created swap
      *
@@ -116,4 +115,18 @@ export declare abstract class FromBtcBaseSwapHandler<V extends SwapHandlerSwap<S
         signature: string;
         feeRate: string;
     }>;
+    /**
+     * Calculates the required security deposit
+     *
+     * @param chainIdentifier
+     * @param amountBD
+     * @param swapFee
+     * @param expiryTimeout
+     * @param baseSecurityDepositPromise
+     * @param depositToken
+     * @param depositTokenPricePrefetchPromise
+     * @param signal
+     * @param metadata
+     */
+    protected getSecurityDeposit(chainIdentifier: string, amountBD: bigint, swapFee: bigint, expiryTimeout: bigint, baseSecurityDepositPromise: Promise<bigint>, depositToken: string, depositTokenPricePrefetchPromise: Promise<bigint>, signal: AbortSignal, metadata: any): Promise<bigint>;
 }

package/dist/swaps/FromBtcBaseSwapHandler.js

@@ -1,78 +1,83 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FromBtcBaseSwapHandler = void 0;
 const SwapHandler_1 = require("./SwapHandler");
-const BN = require("bn.js");
 const SchemaVerifier_1 = require("../utils/paramcoders/SchemaVerifier");
 const PluginManager_1 = require("../plugins/PluginManager");
 const IPlugin_1 = require("../plugins/IPlugin");
-const secondsInYear = new BN(365 * 24 * 60 * 60);
+const secondsInYear = BigInt(365 * 24 * 60 * 60);
 class FromBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
     /**
      * Starts a pre-fetch for swap price & security deposit price
      *
      * @param chainIdentifier
      * @param useToken
+     * @param depositToken
      * @param abortController
      */
-    getFromBtcPricePrefetches(chainIdentifier, useToken, abortController) {
+    getFromBtcPricePrefetches(chainIdentifier, useToken, depositToken, abortController) {
         const pricePrefetchPromise = this.swapPricing.preFetchPrice(useToken, chainIdentifier).catch(e => {
             this.logger.error("getFromBtcPricePrefetches(): pricePrefetch error: ", e);
             abortController.abort(e);
             return null;
         });
         const { swapContract } = this.getChain(chainIdentifier);
-        const securityDepositPricePrefetchPromise = useToken.toString() === swapContract.getNativeCurrencyAddress().toString() ?
+        const gasTokenPricePrefetchPromise = useToken.toString() === swapContract.getNativeCurrencyAddress().toString() ?
             pricePrefetchPromise :
             this.swapPricing.preFetchPrice(swapContract.getNativeCurrencyAddress(), chainIdentifier).catch(e => {
-                this.logger.error("getFromBtcPricePrefetches(): securityDepositPricePrefetch error: ", e);
+                this.logger.error("getFromBtcPricePrefetches(): gasTokenPricePrefetchPromise error: ", e);
                 abortController.abort(e);
                 return null;
             });
-        return { pricePrefetchPromise, securityDepositPricePrefetchPromise };
+        const depositTokenPricePrefetchPromise = depositToken === swapContract.getNativeCurrencyAddress() ?
+            gasTokenPricePrefetchPromise :
+            this.swapPricing.preFetchPrice(depositToken, chainIdentifier).catch(e => {
+                this.logger.error("getFromBtcPricePrefetches(): depositTokenPricePrefetchPromise error: ", e);
+                abortController.abort(e);
+                return null;
+            });
+        return { pricePrefetchPromise, gasTokenPricePrefetchPromise, depositTokenPricePrefetchPromise };
     }
     /**
      * Starts a pre-fetch for base security deposit (transaction fee for refunding transaction on our side)
      *
      * @param chainIdentifier
      * @param dummySwapData
+     * @param depositToken
+     * @param gasTokenPricePrefetchPromise
+     * @param depositTokenPricePrefetchPromise
      * @param abortController
      */
-    getBaseSecurityDepositPrefetch(chainIdentifier, dummySwapData, abortController) {
-        return __awaiter(this, void 0, void 0, function* () {
-            //Solana workaround
-            const { swapContract } = this.getChain(chainIdentifier);
-            if (swapContract.getRawRefundFee != null) {
-                try {
-                    return yield swapContract.getRawRefundFee(dummySwapData);
-                }
-                catch (e) {
-                    this.logger.error("getBaseSecurityDepositPrefetch(): pre-fetch error: ", e);
-                    abortController.abort(e);
-                    return null;
-                }
+    async getBaseSecurityDepositPrefetch(chainIdentifier, dummySwapData, depositToken, gasTokenPricePrefetchPromise, depositTokenPricePrefetchPromise, abortController) {
+        //Solana workaround
+        const { swapContract } = this.getChain(chainIdentifier);
+        let feeResult;
+        const gasToken = swapContract.getNativeCurrencyAddress();
+        if (swapContract.getRawRefundFee != null) {
+            try {
+                feeResult = await swapContract.getRawRefundFee(dummySwapData);
             }
-            else {
-                try {
-                    const result = yield swapContract.getRefundFee(dummySwapData);
-                    return result.mul(new BN(2));
-                }
-                catch (e1) {
-                    this.logger.error("getBaseSecurityDepositPrefetch(): pre-fetch error: ", e1);
-                    abortController.abort(e1);
-                    return null;
-                }
+            catch (e) {
+                this.logger.error("getBaseSecurityDepositPrefetch(): pre-fetch error: ", e);
+                abortController.abort(e);
+                return null;
             }
-        });
+        }
+        else {
+            try {
+                feeResult = await swapContract.getRefundFee(dummySwapData);
+            }
+            catch (e1) {
+                this.logger.error("getBaseSecurityDepositPrefetch(): pre-fetch error: ", e1);
+                abortController.abort(e1);
+                return null;
+            }
+        }
+        feeResult = feeResult * 2n;
+        if (gasToken === depositToken)
+            return feeResult;
+        const btcValue = await this.swapPricing.getToBtcSwapAmount(feeResult, gasToken, chainIdentifier, true, gasTokenPricePrefetchPromise);
+        return await this.swapPricing.getFromBtcSwapAmount(btcValue, depositToken, chainIdentifier, true, depositTokenPricePrefetchPromise);
     }
     /**
      * Starts a pre-fetch for vault balance
@@ -81,18 +86,16 @@ class FromBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
      * @param useToken
      * @param abortController
      */
-    getBalancePrefetch(chainIdentifier, useToken, abortController) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { swapContract, signer } = this.getChain(chainIdentifier);
-            try {
-                return yield swapContract.getBalance(signer.getAddress(), useToken, true);
-            }
-            catch (e) {
-                this.logger.error("getBalancePrefetch(): balancePrefetch error: ", e);
-                abortController.abort(e);
-                return null;
-            }
-        });
+    async getBalancePrefetch(chainIdentifier, useToken, abortController) {
+        const { swapContract, signer } = this.getChain(chainIdentifier);
+        try {
+            return await swapContract.getBalance(signer.getAddress(), useToken, true);
+        }
+        catch (e) {
+            this.logger.error("getBalancePrefetch(): balancePrefetch error: ", e);
+            abortController.abort(e);
+            return null;
+        }
     }
     /**
      * Checks if we have enough balance of the token in the swap vault
@@ -102,18 +105,40 @@ class FromBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
      * @param signal
      * @throws {DefinedRuntimeError} will throw an error if there are not enough funds in the vault
      */
-    checkBalance(totalInToken, balancePrefetch, signal) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const balance = yield balancePrefetch;
-            if (signal != null)
-                signal.throwIfAborted();
-            if (balance == null || balance.lt(totalInToken)) {
+    async checkBalance(totalInToken, balancePrefetch, signal) {
+        const balance = await balancePrefetch;
+        if (signal != null)
+            signal.throwIfAborted();
+        if (balance == null || balance < totalInToken) {
+            throw {
+                code: 20002,
+                msg: "Not enough liquidity"
+            };
+        }
+    }
+    /**
+     * Checks if the specified token is allowed as a deposit token
+     *
+     * @param chainIdentifier
+     * @param depositToken
+     * @throws {DefinedRuntimeError} will throw an error if there are not enough funds in the vault
+     */
+    checkAllowedDepositToken(chainIdentifier, depositToken) {
+        const { swapContract, allowedDepositTokens } = this.getChain(chainIdentifier);
+        if (allowedDepositTokens == null) {
+            if (depositToken !== swapContract.getNativeCurrencyAddress())
                 throw {
-                    code: 20002,
-                    msg: "Not enough liquidity"
+                    code: 20190,
+                    msg: "Unsupported deposit token"
                 };
-            }
-        });
+        }
+        else {
+            if (!allowedDepositTokens.includes(depositToken))
+                throw {
+                    code: 20190,
+                    msg: "Unsupported deposit token"
+                };
+        }
     }
     /**
      * Checks minimums/maximums, calculates the fee & total amount
@@ -123,25 +148,23 @@ class FromBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
      * @param useToken
      * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
      */
-    preCheckAmounts(request, requestedAmount, useToken) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield PluginManager_1.PluginManager.onHandlePreFromBtcQuote(request, requestedAmount, request.chainIdentifier, useToken, { minInBtc: this.config.min, maxInBtc: this.config.max }, { baseFeeInBtc: this.config.baseFee, feePPM: this.config.feePPM });
-            if (res != null) {
-                this.handlePluginErrorResponses(res);
-                if ((0, IPlugin_1.isQuoteSetFees)(res)) {
-                    return {
-                        baseFee: res.baseFee || this.config.baseFee,
-                        feePPM: res.feePPM || this.config.feePPM
-                    };
-                }
+    async preCheckAmounts(request, requestedAmount, useToken) {
+        const res = await PluginManager_1.PluginManager.onHandlePreFromBtcQuote(request, requestedAmount, request.chainIdentifier, useToken, { minInBtc: this.config.min, maxInBtc: this.config.max }, { baseFeeInBtc: this.config.baseFee, feePPM: this.config.feePPM });
+        if (res != null) {
+            this.handlePluginErrorResponses(res);
+            if ((0, IPlugin_1.isQuoteSetFees)(res)) {
+                return {
+                    baseFee: res.baseFee || this.config.baseFee,
+                    feePPM: res.feePPM || this.config.feePPM
+                };
             }
-            if (requestedAmount.input)
-                this.checkBtcAmountInBounds(requestedAmount.amount);
-            return {
-                baseFee: this.config.baseFee,
-                feePPM: this.config.feePPM
-            };
-        });
+        }
+        if (requestedAmount.input)
+            this.checkBtcAmountInBounds(requestedAmount.amount);
+        return {
+            baseFee: this.config.baseFee,
+            feePPM: this.config.feePPM
+        };
     }
     /**
      * Checks minimums/maximums, calculates the fee & total amount
@@ -154,84 +177,110 @@ class FromBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
      * @param pricePrefetchPromise
      * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
      */
-    checkFromBtcAmount(request, requestedAmount, fees, useToken, signal, pricePrefetchPromise = Promise.resolve(null)) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const chainIdentifier = request.chainIdentifier;
-            const res = yield PluginManager_1.PluginManager.onHandlePostFromBtcQuote(request, requestedAmount, chainIdentifier, useToken, { minInBtc: this.config.min, maxInBtc: this.config.max }, { baseFeeInBtc: fees.baseFee, feePPM: fees.feePPM }, pricePrefetchPromise);
-            signal.throwIfAborted();
-            if (res != null) {
-                this.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 ((0, IPlugin_1.isPluginQuote)(res)) {
-                    if (!requestedAmount.input) {
-                        return {
-                            amountBD: res.amount.amount.add(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
-                        };
-                    }
-                }
+    async checkFromBtcAmount(request, requestedAmount, fees, useToken, signal, pricePrefetchPromise = Promise.resolve(null)) {
+        const chainIdentifier = request.chainIdentifier;
+        const res = await PluginManager_1.PluginManager.onHandlePostFromBtcQuote(request, requestedAmount, chainIdentifier, useToken, { minInBtc: this.config.min, maxInBtc: this.config.max }, { baseFeeInBtc: fees.baseFee, feePPM: fees.feePPM }, pricePrefetchPromise);
+        signal.throwIfAborted();
+        if (res != null) {
+            this.handlePluginErrorResponses(res);
+            if ((0, IPlugin_1.isQuoteSetFees)(res)) {
+                if (res.baseFee != null)
+                    fees.baseFee = res.baseFee;
+                if (res.feePPM != null)
+                    fees.feePPM = res.feePPM;
             }
-            let amountBD;
-            if (!requestedAmount.input) {
-                amountBD = yield this.swapPricing.getToBtcSwapAmount(requestedAmount.amount, useToken, chainIdentifier, true, pricePrefetchPromise);
-                signal.throwIfAborted();
-                // amt = (amt+base_fee)/(1-fee)
-                amountBD = amountBD.add(fees.baseFee).mul(new BN(1000000)).div(new BN(1000000).sub(fees.feePPM));
-                const tooLow = amountBD.lt(this.config.min.mul(new BN(95)).div(new BN(100)));
-                const tooHigh = amountBD.gt(this.config.max.mul(new BN(105)).div(new BN(100)));
-                if (tooLow || tooHigh) {
-                    const adjustedMin = this.config.min.mul(new BN(1000000).sub(fees.feePPM)).div(new BN(1000000)).sub(fees.baseFee);
-                    const adjustedMax = this.config.max.mul(new BN(1000000).sub(fees.feePPM)).div(new BN(1000000)).sub(fees.baseFee);
-                    const minIn = yield this.swapPricing.getFromBtcSwapAmount(adjustedMin, useToken, chainIdentifier, null, pricePrefetchPromise);
-                    const maxIn = yield this.swapPricing.getFromBtcSwapAmount(adjustedMax, useToken, chainIdentifier, null, pricePrefetchPromise);
-                    throw {
-                        code: tooLow ? 20003 : 20004,
-                        msg: tooLow ? "Amount too low!" : "Amount too high!",
-                        data: {
-                            min: minIn.toString(10),
-                            max: maxIn.toString(10)
-                        }
+            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
                     };
                 }
             }
-            else {
-                amountBD = requestedAmount.amount;
-                this.checkBtcAmountInBounds(amountBD);
-            }
-            const swapFee = fees.baseFee.add(amountBD.mul(fees.feePPM).div(new BN(1000000)));
-            const swapFeeInToken = yield this.swapPricing.getFromBtcSwapAmount(swapFee, useToken, chainIdentifier, true, pricePrefetchPromise);
+        }
+        let amountBD;
+        if (!requestedAmount.input) {
+            amountBD = await this.swapPricing.getToBtcSwapAmount(requestedAmount.amount, useToken, chainIdentifier, true, pricePrefetchPromise);
             signal.throwIfAborted();
-            let totalInToken;
-            if (!requestedAmount.input) {
-                totalInToken = requestedAmount.amount;
-            }
-            else {
-                const amountInToken = yield this.swapPricing.getFromBtcSwapAmount(requestedAmount.amount, useToken, chainIdentifier, null, pricePrefetchPromise);
-                totalInToken = amountInToken.sub(swapFeeInToken);
-                signal.throwIfAborted();
+            // amt = (amt+base_fee)/(1-fee)
+            amountBD = (amountBD + fees.baseFee) * 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, useToken, chainIdentifier, null, pricePrefetchPromise);
+                const maxIn = await this.swapPricing.getFromBtcSwapAmount(adjustedMax, useToken, chainIdentifier, null, pricePrefetchPromise);
+                throw {
+                    code: tooLow ? 20003 : 20004,
+                    msg: tooLow ? "Amount too low!" : "Amount too high!",
+                    data: {
+                        min: minIn.toString(10),
+                        max: maxIn.toString(10)
+                    }
+                };
             }
-            return {
-                amountBD,
-                swapFee,
-                swapFeeInToken,
-                totalInToken
-            };
-        });
+        }
+        else {
+            amountBD = requestedAmount.amount;
+            this.checkBtcAmountInBounds(amountBD);
+        }
+        const swapFee = fees.baseFee + (amountBD * fees.feePPM / 1000000n);
+        const swapFeeInToken = await this.swapPricing.getFromBtcSwapAmount(swapFee, useToken, chainIdentifier, true, pricePrefetchPromise);
+        signal.throwIfAborted();
+        let totalInToken;
+        if (!requestedAmount.input) {
+            totalInToken = requestedAmount.amount;
+        }
+        else {
+            const amountInToken = await this.swapPricing.getFromBtcSwapAmount(requestedAmount.amount, useToken, chainIdentifier, null, pricePrefetchPromise);
+            totalInToken = amountInToken - swapFeeInToken;
+            signal.throwIfAborted();
+        }
+        return {
+            amountBD,
+            swapFee,
+            swapFeeInToken,
+            totalInToken
+        };
+    }
+    /**
+     * Signs the created swap
+     *
+     * @param chainIdentifier
+     * @param swapObject
+     * @param req
+     * @param abortSignal
+     * @param signDataPrefetchPromise
+     */
+    async getFromBtcSignatureData(chainIdentifier, swapObject, req, abortSignal, signDataPrefetchPromise) {
+        const { swapContract, signer } = this.getChain(chainIdentifier);
+        const prefetchedSignData = signDataPrefetchPromise != null ? await signDataPrefetchPromise : null;
+        if (prefetchedSignData != null)
+            this.logger.debug("getFromBtcSignatureData(): pre-fetched signature data: ", prefetchedSignData);
+        abortSignal.throwIfAborted();
+        const feeRateObj = await req.paramReader.getParams({
+            feeRate: SchemaVerifier_1.FieldTypeEnum.String
+        }).catch(() => null);
+        abortSignal.throwIfAborted();
+        const feeRate = feeRateObj?.feeRate != null && typeof (feeRateObj.feeRate) === "string" ? feeRateObj.feeRate : null;
+        this.logger.debug("getFromBtcSignatureData(): using fee rate from client: ", feeRate);
+        const sigData = await swapContract.getInitSignature(signer, swapObject, this.getInitAuthorizationTimeout(chainIdentifier), prefetchedSignData, feeRate);
+        abortSignal.throwIfAborted();
+        return {
+            ...sigData,
+            feeRate
+        };
     }
     /**
      * Calculates the required security deposit
@@ -241,54 +290,26 @@ class FromBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
      * @param swapFee
      * @param expiryTimeout
      * @param baseSecurityDepositPromise
-     * @param securityDepositPricePrefetchPromise
+     * @param depositToken
+     * @param depositTokenPricePrefetchPromise
      * @param signal
      * @param metadata
      */
-    getSecurityDeposit(chainIdentifier, amountBD, swapFee, expiryTimeout, baseSecurityDepositPromise, securityDepositPricePrefetchPromise, signal, metadata) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let baseSD = yield baseSecurityDepositPromise;
-            signal.throwIfAborted();
-            metadata.times.refundFeeFetched = Date.now();
-            const { swapContract } = this.getChain(chainIdentifier);
-            const swapValueInNativeCurrency = yield this.swapPricing.getFromBtcSwapAmount(amountBD.sub(swapFee), swapContract.getNativeCurrencyAddress(), chainIdentifier, true, securityDepositPricePrefetchPromise);
-            signal.throwIfAborted();
-            const apyPPM = new BN(Math.floor(this.config.securityDepositAPY * 1000000));
-            const variableSD = swapValueInNativeCurrency.mul(apyPPM).mul(expiryTimeout).div(new BN(1000000)).div(secondsInYear);
-            this.logger.debug("getSecurityDeposit(): base security deposit: " + baseSD.toString(10) +
-                " swap output in native: " + swapValueInNativeCurrency.toString(10) +
-                " apy ppm: " + apyPPM.toString(10) +
-                " expiry timeout: " + expiryTimeout.toString(10) +
-                " variable security deposit: " + variableSD.toString(10));
-            return baseSD.add(variableSD);
-        });
-    }
-    /**
-     * Signs the created swap
-     *
-     * @param chainIdentifier
-     * @param swapObject
-     * @param req
-     * @param abortSignal
-     * @param signDataPrefetchPromise
-     */
-    getFromBtcSignatureData(chainIdentifier, swapObject, req, abortSignal, signDataPrefetchPromise) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { swapContract, signer } = this.getChain(chainIdentifier);
-            const prefetchedSignData = signDataPrefetchPromise != null ? yield signDataPrefetchPromise : null;
-            if (prefetchedSignData != null)
-                this.logger.debug("getFromBtcSignatureData(): pre-fetched signature data: ", prefetchedSignData);
-            abortSignal.throwIfAborted();
-            const feeRateObj = yield req.paramReader.getParams({
-                feeRate: SchemaVerifier_1.FieldTypeEnum.String
-            }).catch(() => null);
-            abortSignal.throwIfAborted();
-            const feeRate = (feeRateObj === null || feeRateObj === void 0 ? void 0 : feeRateObj.feeRate) != null && typeof (feeRateObj.feeRate) === "string" ? feeRateObj.feeRate : null;
-            this.logger.debug("getFromBtcSignatureData(): using fee rate from client: ", feeRate);
-            const sigData = yield swapContract.getInitSignature(signer, swapObject, this.config.authorizationTimeout, prefetchedSignData, feeRate);
-            abortSignal.throwIfAborted();
-            return Object.assign(Object.assign({}, sigData), { feeRate });
-        });
+    async getSecurityDeposit(chainIdentifier, amountBD, swapFee, expiryTimeout, baseSecurityDepositPromise, depositToken, depositTokenPricePrefetchPromise, signal, metadata) {
+        let baseSD = await baseSecurityDepositPromise;
+        signal.throwIfAborted();
+        metadata.times.refundFeeFetched = Date.now();
+        const swapValueInDepositToken = await this.swapPricing.getFromBtcSwapAmount(amountBD - swapFee, depositToken, chainIdentifier, true, depositTokenPricePrefetchPromise);
+        signal.throwIfAborted();
+        const apyPPM = BigInt(Math.floor(this.config.securityDepositAPY * 1000000));
+        const variableSD = swapValueInDepositToken * apyPPM * expiryTimeout / 1000000n / secondsInYear;
+        this.logger.debug("getSecurityDeposit(): base security deposit: " + baseSD.toString(10) +
+            " deposit token: " + depositToken +
+            " swap output in deposit token: " + swapValueInDepositToken.toString(10) +
+            " apy ppm: " + apyPPM.toString(10) +
+            " expiry timeout: " + expiryTimeout.toString(10) +
+            " variable security deposit: " + variableSD.toString(10));
+        return baseSD + variableSD;
     }
 }
 exports.FromBtcBaseSwapHandler = FromBtcBaseSwapHandler;

package/dist/swaps/FromBtcLnBaseSwapHandler.d.ts

@@ -1,7 +1,6 @@
 import { SwapHandlerSwap } from "./SwapHandlerSwap";
 import { SwapData } from "@atomiqlabs/base";
 import { FromBtcBaseSwapHandler } from "./FromBtcBaseSwapHandler";
-import * as BN from "bn.js";
 import { ILightningWallet, LightningNetworkChannel } from "../wallets/ILightningWallet";
 import { IIntermediaryStorage } from "../storage/IIntermediaryStorage";
 import { MultichainData } from "./SwapHandler";
@@ -17,7 +16,7 @@ export declare abstract class FromBtcLnBaseSwapHandler<V extends SwapHandlerSwap
      * @param signal
      * @throws {DefinedRuntimeError} will throw an error if there isn't enough inbound liquidity to receive the LN payment
      */
-    protected checkInboundLiquidity(amountBD: BN, channelsPrefetch: Promise<LightningNetworkChannel[]>, signal: AbortSignal): Promise<void>;
+    protected checkInboundLiquidity(amountBD: bigint, channelsPrefetch: Promise<LightningNetworkChannel[]>, signal: AbortSignal): Promise<void>;
     /**
      * Starts LN channels pre-fetch
      *