@atomiqlabs/lp-lib 10.3.11

package/dist/storagemanager/IntermediaryStorageManager.js

@@ -0,0 +1,113 @@
+"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.IntermediaryStorageManager = void 0;
+const fs = require("fs/promises");
+const BN = require("bn.js");
+class IntermediaryStorageManager {
+    constructor(directory) {
+        this.data = {};
+        this.directory = directory;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield fs.mkdir(this.directory);
+            }
+            catch (e) { }
+        });
+    }
+    query(params) {
+        return Promise.resolve(Object.keys(this.data).map((val) => this.data[val]).filter((val) => {
+            for (let param of params) {
+                if (param.value != null) {
+                    if (typeof param.value === "object") {
+                        if (param.value.eq != null && !param.value.eq(val[param.key]))
+                            return false;
+                        if (param.value.equals != null && !param.value.equals(val[param.key]))
+                            return false;
+                    }
+                    else {
+                        if (param.value !== val[param.key])
+                            return false;
+                    }
+                }
+                else if (param.values != null) {
+                    let hasSome = false;
+                    for (let expectedValue of param.values) {
+                        if (typeof expectedValue === "object") {
+                            if (expectedValue.eq != null && !expectedValue.eq(val[param.key]))
+                                hasSome = true;
+                            if (expectedValue.equals != null && !expectedValue.equals(val[param.key]))
+                                hasSome = true;
+                        }
+                        else {
+                            if (expectedValue === val[param.key])
+                                hasSome = true;
+                        }
+                    }
+                    if (!hasSome)
+                        return false;
+                }
+            }
+            return true;
+        }));
+    }
+    getData(paymentHash, sequence) {
+        return Promise.resolve(this.data[paymentHash + "_" + (sequence || new BN(0)).toString("hex", 8)]);
+    }
+    saveData(hash, sequence, object) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _sequence = (sequence || new BN(0)).toString("hex", 8);
+            try {
+                yield fs.mkdir(this.directory);
+            }
+            catch (e) { }
+            this.data[hash + "_" + _sequence] = object;
+            const cpy = object.serialize();
+            yield fs.writeFile(this.directory + "/" + hash + "_" + _sequence + ".json", JSON.stringify(cpy));
+        });
+    }
+    removeData(hash, sequence) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const identifier = hash + "_" + (sequence || new BN(0)).toString("hex", 8);
+            try {
+                if (this.data[identifier] != null)
+                    delete this.data[identifier];
+                yield fs.rm(this.directory + "/" + identifier + ".json");
+            }
+            catch (e) {
+                console.error(e);
+            }
+        });
+    }
+    loadData(type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.type = type;
+            let files;
+            try {
+                files = yield fs.readdir(this.directory);
+            }
+            catch (e) {
+                console.error(e);
+                return;
+            }
+            for (let file of files) {
+                const indentifier = file.split(".")[0];
+                const result = yield fs.readFile(this.directory + "/" + file);
+                const obj = JSON.parse(result.toString());
+                const parsed = new type(obj);
+                this.data[indentifier] = parsed;
+            }
+        });
+    }
+}
+exports.IntermediaryStorageManager = IntermediaryStorageManager;

package/dist/storagemanager/StorageManager.d.ts

@@ -0,0 +1,12 @@
+import { StorageObject, IStorageManager } from "@atomiqlabs/base";
+export declare class StorageManager<T extends StorageObject> implements IStorageManager<T> {
+    private readonly directory;
+    data: {
+        [key: string]: T;
+    };
+    constructor(directory: string);
+    init(): Promise<void>;
+    saveData(hash: string, object: T): Promise<void>;
+    removeData(hash: string): Promise<void>;
+    loadData(type: new (data: any) => T): Promise<T[]>;
+}

package/dist/storagemanager/StorageManager.js

@@ -0,0 +1,74 @@
+"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.StorageManager = void 0;
+const fs = require("fs/promises");
+class StorageManager {
+    constructor(directory) {
+        this.data = {};
+        this.directory = directory;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield fs.mkdir(this.directory);
+            }
+            catch (e) { }
+        });
+    }
+    saveData(hash, object) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield fs.mkdir(this.directory);
+            }
+            catch (e) { }
+            this.data[hash] = object;
+            const cpy = object.serialize();
+            yield fs.writeFile(this.directory + "/" + hash + ".json", JSON.stringify(cpy));
+        });
+    }
+    removeData(hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const paymentHash = hash;
+            try {
+                if (this.data[paymentHash] != null)
+                    delete this.data[paymentHash];
+                yield fs.rm(this.directory + "/" + paymentHash + ".json");
+            }
+            catch (e) {
+                console.error(e);
+            }
+        });
+    }
+    loadData(type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let files;
+            try {
+                files = yield fs.readdir(this.directory);
+            }
+            catch (e) {
+                console.error(e);
+                return [];
+            }
+            const arr = [];
+            for (let file of files) {
+                const paymentHash = file.split(".")[0];
+                const result = yield fs.readFile(this.directory + "/" + file);
+                const obj = JSON.parse(result.toString());
+                const parsed = new type(obj);
+                arr.push(parsed);
+                this.data[paymentHash] = parsed;
+            }
+            return arr;
+        });
+    }
+}
+exports.StorageManager = StorageManager;

package/dist/swaps/FromBtcBaseSwap.d.ts

@@ -0,0 +1,12 @@
+import { SwapData } from "@atomiqlabs/base";
+import { SwapHandlerSwap } from "./SwapHandlerSwap";
+import * as BN from "bn.js";
+export declare abstract class FromBtcBaseSwap<T extends SwapData, S = any> extends SwapHandlerSwap<T, S> {
+    getInputAmount(): BN;
+    abstract getTotalInputAmount(): BN;
+    getOutputAmount(): BN;
+    getSwapFee(): {
+        inInputToken: BN;
+        inOutputToken: BN;
+    };
+}

package/dist/swaps/FromBtcBaseSwap.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromBtcBaseSwap = void 0;
+const SwapHandlerSwap_1 = require("./SwapHandlerSwap");
+class FromBtcBaseSwap extends SwapHandlerSwap_1.SwapHandlerSwap {
+    getInputAmount() {
+        return this.getTotalInputAmount().sub(this.getSwapFee().inInputToken);
+    }
+    getOutputAmount() {
+        return this.data.getAmount();
+    }
+    getSwapFee() {
+        return { inInputToken: this.swapFee, inOutputToken: this.swapFeeInToken };
+    }
+}
+exports.FromBtcBaseSwap = FromBtcBaseSwap;

package/dist/swaps/FromBtcBaseSwapHandler.d.ts

@@ -0,0 +1,118 @@
+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";
+import { Request } from "express";
+import { FromBtcLnTrustedRequestType } from "./frombtcln_trusted/FromBtcLnTrusted";
+export type FromBtcBaseConfig = SwapBaseConfig & {
+    securityDepositAPY: number;
+};
+export declare abstract class FromBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S>, S> extends SwapHandler<V, S> {
+    abstract config: FromBtcBaseConfig;
+    /**
+     * Starts a pre-fetch for swap price & security deposit price
+     *
+     * @param chainIdentifier
+     * @param useToken
+     * @param abortController
+     */
+    protected getFromBtcPricePrefetches(chainIdentifier: string, useToken: string, abortController: AbortController): {
+        pricePrefetchPromise: Promise<BN>;
+        securityDepositPricePrefetchPromise: Promise<BN>;
+    };
+    /**
+     * Starts a pre-fetch for base security deposit (transaction fee for refunding transaction on our side)
+     *
+     * @param chainIdentifier
+     * @param dummySwapData
+     * @param abortController
+     */
+    protected getBaseSecurityDepositPrefetch(chainIdentifier: string, dummySwapData: SwapData, abortController: AbortController): Promise<BN>;
+    /**
+     * Starts a pre-fetch for vault balance
+     *
+     * @param chainIdentifier
+     * @param useToken
+     * @param abortController
+     */
+    protected getBalancePrefetch(chainIdentifier: string, useToken: string, abortController: AbortController): Promise<BN>;
+    /**
+     * Checks if we have enough balance of the token in the swap vault
+     *
+     * @param totalInToken
+     * @param balancePrefetch
+     * @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>;
+    /**
+     * Checks minimums/maximums, calculates the fee & total amount
+     *
+     * @param request
+     * @param requestedAmount
+     * @param useToken
+     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
+     */
+    protected preCheckAmounts(request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>, requestedAmount: {
+        input: boolean;
+        amount: BN;
+    }, useToken: string): Promise<{
+        baseFee: BN;
+        feePPM: BN;
+    }>;
+    /**
+     * Checks minimums/maximums, calculates the fee & total amount
+     *
+     * @param request
+     * @param requestedAmount
+     * @param fees
+     * @param useToken
+     * @param signal
+     * @param pricePrefetchPromise
+     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
+     */
+    protected checkFromBtcAmount(request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>, requestedAmount: {
+        input: boolean;
+        amount: BN;
+    }, fees: {
+        baseFee: BN;
+        feePPM: BN;
+    }, useToken: string, signal: AbortSignal, pricePrefetchPromise?: Promise<BN>): Promise<{
+        amountBD: BN;
+        swapFee: BN;
+        swapFeeInToken: BN;
+        totalInToken: BN;
+    }>;
+    /**
+     * 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
+     *
+     * @param chainIdentifier
+     * @param swapObject
+     * @param req
+     * @param abortSignal
+     * @param signDataPrefetchPromise
+     */
+    protected getFromBtcSignatureData(chainIdentifier: string, swapObject: SwapData, req: Request & {
+        paramReader: IParamReader;
+    }, abortSignal: AbortSignal, signDataPrefetchPromise?: Promise<any>): Promise<{
+        prefix: string;
+        timeout: string;
+        signature: string;
+    }>;
+}

package/dist/swaps/FromBtcBaseSwapHandler.js

@@ -0,0 +1,294 @@
+"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);
+class FromBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
+    /**
+     * Starts a pre-fetch for swap price & security deposit price
+     *
+     * @param chainIdentifier
+     * @param useToken
+     * @param abortController
+     */
+    getFromBtcPricePrefetches(chainIdentifier, useToken, 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() ?
+            pricePrefetchPromise :
+            this.swapPricing.preFetchPrice(swapContract.getNativeCurrencyAddress(), chainIdentifier).catch(e => {
+                this.logger.error("getFromBtcPricePrefetches(): securityDepositPricePrefetch error: ", e);
+                abortController.abort(e);
+                return null;
+            });
+        return { pricePrefetchPromise, securityDepositPricePrefetchPromise };
+    }
+    /**
+     * Starts a pre-fetch for base security deposit (transaction fee for refunding transaction on our side)
+     *
+     * @param chainIdentifier
+     * @param dummySwapData
+     * @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;
+                }
+            }
+            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;
+                }
+            }
+        });
+    }
+    /**
+     * Starts a pre-fetch for vault balance
+     *
+     * @param chainIdentifier
+     * @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;
+            }
+        });
+    }
+    /**
+     * Checks if we have enough balance of the token in the swap vault
+     *
+     * @param totalInToken
+     * @param balancePrefetch
+     * @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)) {
+                throw {
+                    code: 20002,
+                    msg: "Not enough liquidity"
+                };
+            }
+        });
+    }
+    /**
+     * Checks minimums/maximums, calculates the fee & total amount
+     *
+     * @param request
+     * @param requestedAmount
+     * @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
+                    };
+                }
+            }
+            if (requestedAmount.input)
+                this.checkBtcAmountInBounds(requestedAmount.amount);
+            return {
+                baseFee: this.config.baseFee,
+                feePPM: this.config.feePPM
+            };
+        });
+    }
+    /**
+     * Checks minimums/maximums, calculates the fee & total amount
+     *
+     * @param request
+     * @param requestedAmount
+     * @param fees
+     * @param useToken
+     * @param signal
+     * @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
+                        };
+                    }
+                }
+            }
+            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)
+                        }
+                    };
+                }
+            }
+            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);
+            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();
+            }
+            return {
+                amountBD,
+                swapFee,
+                swapFeeInToken,
+                totalInToken
+            };
+        });
+    }
+    /**
+     * Calculates the required security deposit
+     *
+     * @param chainIdentifier
+     * @param amountBD
+     * @param swapFee
+     * @param expiryTimeout
+     * @param baseSecurityDepositPromise
+     * @param securityDepositPricePrefetchPromise
+     * @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 sigData;
+        });
+    }
+}
+exports.FromBtcBaseSwapHandler = FromBtcBaseSwapHandler;

package/dist/swaps/FromBtcLnBaseSwapHandler.d.ts

@@ -0,0 +1,25 @@
+import { SwapHandlerSwap } from "./SwapHandlerSwap";
+import { SwapData } from "@atomiqlabs/base";
+import { FromBtcBaseSwapHandler } from "./FromBtcBaseSwapHandler";
+import * as BN from "bn.js";
+export declare abstract class FromBtcLnBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S>, S> extends FromBtcBaseSwapHandler<V, S> {
+    /**
+     * 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
+     */
+    protected checkInboundLiquidity(amountBD: BN, channelsPrefetch: Promise<{
+        channels: any[];
+    }>, signal: AbortSignal): Promise<void>;
+    /**
+     * Starts LN channels pre-fetch
+     *
+     * @param abortController
+     */
+    protected getChannelsPrefetch(abortController: AbortController): Promise<{
+        channels: any[];
+    }>;
+}