@atomiqlabs/lp-lib 10.3.11

package/dist/swaps/SwapHandlerSwap.d.ts

@@ -0,0 +1,75 @@
+import { Lockable, StorageObject, SwapData } from "@atomiqlabs/base";
+import { SwapHandlerType } from "./SwapHandler";
+import * as BN from "bn.js";
+export declare abstract class SwapHandlerSwap<T extends SwapData = SwapData, S = any> extends Lockable implements StorageObject {
+    chainIdentifier: string;
+    state: S;
+    type: SwapHandlerType;
+    data: T;
+    metadata: {
+        request: any;
+        times: {
+            [key: string]: number;
+        };
+        [key: string]: any;
+    };
+    txIds: {
+        init?: string;
+        claim?: string;
+        refund?: string;
+    };
+    readonly swapFee: BN;
+    readonly swapFeeInToken: BN;
+    protected constructor(chainIdentifier: string, swapFee: BN, swapFeeInToken: BN);
+    protected constructor(obj: any);
+    serialize(): any;
+    /**
+     * Sets the state of the swap and also calls swap change listener on plugins
+     *
+     * @param newState
+     */
+    setState(newState: S): Promise<void>;
+    getHash(): string;
+    getSequence(): BN;
+    /**
+     * Returns unique identifier of the swap in the form <hash>_<sequence> or just <hash> if the swap type doesn't
+     *  use sequence number
+     */
+    getIdentifier(): string;
+    /**
+     * Checks whether the swap is finished, such that it is final and either successful or failed
+     */
+    isFinished(): boolean;
+    /**
+     * Checks whether the swap was initiated by the user
+     */
+    abstract isInitiated(): boolean;
+    /**
+     * Checks whether the swap was finished and was successful
+     */
+    abstract isSuccess(): boolean;
+    /**
+     * Checks whether the swap was finished and was failed
+     */
+    abstract isFailed(): boolean;
+    /**
+     * Returns the input amount paid by the user (excluding fees)
+     */
+    abstract getInputAmount(): BN;
+    /**
+     * Returns the total input amount paid by the user (including all fees)
+     */
+    abstract getTotalInputAmount(): BN;
+    /**
+     * Returns the actual output amount paid out to the user
+     */
+    abstract getOutputAmount(): BN;
+    /**
+     * Returns swap fee, denominated in input & output tokens (the fee is paid only once, it is just represented here in
+     *  both denomination for ease of use)
+     */
+    abstract getSwapFee(): {
+        inInputToken: BN;
+        inOutputToken: BN;
+    };
+}

package/dist/swaps/SwapHandlerSwap.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapHandlerSwap = void 0;
+const base_1 = require("@atomiqlabs/base");
+const PluginManager_1 = require("../plugins/PluginManager");
+const BN = require("bn.js");
+const Utils_1 = require("../utils/Utils");
+class SwapHandlerSwap extends base_1.Lockable {
+    constructor(obj, swapFee, swapFeeInToken) {
+        super();
+        this.txIds = {};
+        if (typeof (obj) === "string" && BN.isBN(swapFee) && BN.isBN(swapFeeInToken)) {
+            this.chainIdentifier = obj;
+            this.swapFee = swapFee;
+            this.swapFeeInToken = swapFeeInToken;
+            return;
+        }
+        else {
+            this.data = obj.data == null ? null : base_1.SwapData.deserialize(obj.data);
+            this.metadata = obj.metadata;
+            this.chainIdentifier = obj.chainIdentifier;
+            this.txIds = obj.txIds || {};
+            this.state = obj.state;
+            this.swapFee = (0, Utils_1.deserializeBN)(obj.swapFee);
+            this.swapFeeInToken = (0, Utils_1.deserializeBN)(obj.swapFeeInToken);
+        }
+    }
+    serialize() {
+        return {
+            state: this.state,
+            data: this.data == null ? null : this.data.serialize(),
+            chainIdentifier: this.chainIdentifier,
+            metadata: this.metadata,
+            txIds: this.txIds,
+            swapFee: (0, Utils_1.serializeBN)(this.swapFee),
+            swapFeeInToken: (0, Utils_1.serializeBN)(this.swapFeeInToken)
+        };
+    }
+    /**
+     * Sets the state of the swap and also calls swap change listener on plugins
+     *
+     * @param newState
+     */
+    setState(newState) {
+        const oldState = this.state;
+        this.state = newState;
+        return PluginManager_1.PluginManager.swapStateChange(this, oldState);
+    }
+    getHash() {
+        return this.data.getHash();
+    }
+    getSequence() {
+        return this.data.getSequence();
+    }
+    /**
+     * Returns unique identifier of the swap in the form <hash>_<sequence> or just <hash> if the swap type doesn't
+     *  use sequence number
+     */
+    getIdentifier() {
+        if (this.getSequence() != null) {
+            return this.chainIdentifier + "_" + this.getHash() + "_" + this.getSequence().toString(16);
+        }
+        return this.getHash();
+    }
+    /**
+     * Checks whether the swap is finished, such that it is final and either successful or failed
+     */
+    isFinished() {
+        return this.isSuccess() || this.isFailed();
+    }
+}
+exports.SwapHandlerSwap = SwapHandlerSwap;

package/dist/swaps/ToBtcBaseSwap.d.ts

@@ -0,0 +1,35 @@
+import { SwapHandlerSwap } from "./SwapHandlerSwap";
+import { SwapData } from "@atomiqlabs/base";
+import * as BN from "bn.js";
+export declare abstract class ToBtcBaseSwap<T extends SwapData = SwapData, S = any> extends SwapHandlerSwap<T, S> {
+    quotedNetworkFee: BN;
+    readonly quotedNetworkFeeInToken: BN;
+    realNetworkFee: BN;
+    realNetworkFeeInToken: BN;
+    protected constructor(chainIdentifier: string, swapFee: BN, swapFeeInToken: BN, quotedNetworkFee: BN, quotedNetworkFeeInToken: BN);
+    protected constructor(obj: any);
+    serialize(): any;
+    setRealNetworkFee(networkFeeInBtc: BN): void;
+    getInputAmount(): BN;
+    getTotalInputAmount(): BN;
+    getSwapFee(): {
+        inInputToken: BN;
+        inOutputToken: BN;
+    };
+    /**
+     * Returns quoted (expected) network fee, denominated in input & output tokens (the fee is paid only once, it is
+     *  just represented here in both denomination for ease of use)
+     */
+    getQuotedNetworkFee(): {
+        inInputToken: BN;
+        inOutputToken: BN;
+    };
+    /**
+     * Returns real network fee paid for the swap, denominated in input & output tokens (the fee is paid only once, it is
+     *  just represented here in both denomination for ease of use)
+     */
+    getRealNetworkFee(): {
+        inInputToken: BN;
+        inOutputToken: BN;
+    };
+}

package/dist/swaps/ToBtcBaseSwap.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToBtcBaseSwap = void 0;
+const SwapHandlerSwap_1 = require("./SwapHandlerSwap");
+const BN = require("bn.js");
+const Utils_1 = require("../utils/Utils");
+class ToBtcBaseSwap extends SwapHandlerSwap_1.SwapHandlerSwap {
+    constructor(obj, swapFee, swapFeeInToken, quotedNetworkFee, quotedNetworkFeeInToken) {
+        if (typeof (obj) === "string" && BN.isBN(swapFee) && BN.isBN(swapFeeInToken) && BN.isBN(quotedNetworkFee) && BN.isBN(quotedNetworkFeeInToken)) {
+            super(obj, swapFee, swapFeeInToken);
+            this.quotedNetworkFee = quotedNetworkFee;
+            this.quotedNetworkFeeInToken = quotedNetworkFeeInToken;
+            return;
+        }
+        else {
+            super(obj);
+            this.quotedNetworkFee = (0, Utils_1.deserializeBN)(obj.quotedNetworkFee);
+            this.quotedNetworkFeeInToken = (0, Utils_1.deserializeBN)(obj.quotedNetworkFeeInToken);
+            this.realNetworkFee = (0, Utils_1.deserializeBN)(obj.realNetworkFee);
+            this.realNetworkFeeInToken = (0, Utils_1.deserializeBN)(obj.realNetworkFeeInToken);
+        }
+    }
+    serialize() {
+        const obj = super.serialize();
+        obj.quotedNetworkFee = (0, Utils_1.serializeBN)(this.quotedNetworkFee);
+        obj.quotedNetworkFeeInToken = (0, Utils_1.serializeBN)(this.quotedNetworkFeeInToken);
+        obj.realNetworkFee = (0, Utils_1.serializeBN)(this.realNetworkFee);
+        obj.realNetworkFeeInToken = (0, Utils_1.serializeBN)(this.realNetworkFeeInToken);
+        return obj;
+    }
+    setRealNetworkFee(networkFeeInBtc) {
+        this.realNetworkFee = networkFeeInBtc;
+        if (this.quotedNetworkFee != null && this.quotedNetworkFeeInToken != null) {
+            this.realNetworkFeeInToken = this.realNetworkFee.mul(this.quotedNetworkFeeInToken).div(this.quotedNetworkFee);
+        }
+    }
+    getInputAmount() {
+        return this.data.getAmount().sub(this.getSwapFee().inInputToken).sub(this.getQuotedNetworkFee().inInputToken);
+    }
+    getTotalInputAmount() {
+        return this.data.getAmount();
+    }
+    getSwapFee() {
+        return { inInputToken: this.swapFeeInToken, inOutputToken: this.swapFee };
+    }
+    /**
+     * Returns quoted (expected) network fee, denominated in input & output tokens (the fee is paid only once, it is
+     *  just represented here in both denomination for ease of use)
+     */
+    getQuotedNetworkFee() {
+        return { inInputToken: this.quotedNetworkFeeInToken, inOutputToken: this.quotedNetworkFee };
+    }
+    /**
+     * Returns real network fee paid for the swap, denominated in input & output tokens (the fee is paid only once, it is
+     *  just represented here in both denomination for ease of use)
+     */
+    getRealNetworkFee() {
+        return { inInputToken: this.realNetworkFeeInToken, inOutputToken: this.realNetworkFee };
+    }
+}
+exports.ToBtcBaseSwap = ToBtcBaseSwap;

package/dist/swaps/ToBtcBaseSwapHandler.d.ts

@@ -0,0 +1,94 @@
+import { RequestData, SwapBaseConfig, SwapHandler } from "./SwapHandler";
+import { SwapHandlerSwap } from "./SwapHandlerSwap";
+import { SwapData } from "@atomiqlabs/base";
+import * as BN from "bn.js";
+import { ServerParamEncoder } from "../utils/paramcoders/server/ServerParamEncoder";
+import { IParamReader } from "../utils/paramcoders/IParamReader";
+import { ToBtcLnRequestType } from "./tobtcln_abstract/ToBtcLnAbs";
+import { ToBtcRequestType } from "./tobtc_abstract/ToBtcAbs";
+import { Request } from "express";
+export type ToBtcBaseConfig = SwapBaseConfig & {
+    gracePeriod: BN;
+};
+export declare abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S>, S> extends SwapHandler<V, S> {
+    readonly pdaExistsForToken: {
+        [chainIdentifier: string]: {
+            [token: string]: boolean;
+        };
+    };
+    abstract config: ToBtcBaseConfig;
+    protected checkVaultInitialized(chainIdentifier: string, token: string): 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<ToBtcLnRequestType | ToBtcRequestType>, requestedAmount: {
+        input: boolean;
+        amount: BN;
+    }, useToken: string): Promise<{
+        baseFee: BN;
+        feePPM: BN;
+    }>;
+    /**
+     * Checks minimums/maximums, calculates network fee (based on the callback passed), swap fee & total amount
+     *
+     * @param request
+     * @param requestedAmount
+     * @param fees
+     * @param useToken
+     * @param getNetworkFee
+     * @param signal
+     * @param pricePrefetchPromise
+     * @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)
+     */
+    protected checkToBtcAmount<T extends {
+        networkFee: BN;
+    }>(request: RequestData<ToBtcLnRequestType | ToBtcRequestType>, requestedAmount: {
+        input: boolean;
+        amount: BN;
+    }, fees: {
+        baseFee: BN;
+        feePPM: BN;
+    }, useToken: string, getNetworkFee: (amount: BN) => Promise<T>, signal: AbortSignal, pricePrefetchPromise?: Promise<BN>): Promise<{
+        amountBD: BN;
+        networkFeeData: T;
+        swapFee: BN;
+        swapFeeInToken: BN;
+        networkFee: BN;
+        networkFeeInToken: BN;
+        totalInToken: BN;
+    }>;
+    /**
+     * Starts pre-fetches for swap pricing & signature data
+     *
+     * @param chainIdentifier
+     * @param token
+     * @param responseStream
+     * @param abortController
+     */
+    protected getToBtcPrefetches(chainIdentifier: string, token: string, responseStream: ServerParamEncoder, abortController: AbortController): {
+        pricePrefetchPromise?: Promise<BN>;
+        signDataPrefetchPromise?: Promise<any>;
+    };
+    /**
+     * Signs the created swap
+     *
+     * @param chainIdentifier
+     * @param swapObject
+     * @param req
+     * @param abortSignal
+     * @param signDataPrefetchPromise
+     */
+    protected getToBtcSignatureData(chainIdentifier: string, swapObject: SwapData, req: Request & {
+        paramReader: IParamReader;
+    }, abortSignal: AbortSignal, signDataPrefetchPromise?: Promise<any>): Promise<{
+        prefix: string;
+        timeout: string;
+        signature: string;
+    }>;
+}

package/dist/swaps/ToBtcBaseSwapHandler.js

@@ -0,0 +1,233 @@
+"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.ToBtcBaseSwapHandler = 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");
+class ToBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
+    constructor() {
+        super(...arguments);
+        this.pdaExistsForToken = {};
+    }
+    checkVaultInitialized(chainIdentifier, token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.pdaExistsForToken[chainIdentifier] || !this.pdaExistsForToken[chainIdentifier][token]) {
+                this.logger.debug("checkVaultInitialized(): checking vault exists for chain: " + chainIdentifier + " token: " + token);
+                const { swapContract, signer } = this.getChain(chainIdentifier);
+                const reputation = yield swapContract.getIntermediaryReputation(signer.getAddress(), token);
+                this.logger.debug("checkVaultInitialized(): vault state, chain: " + chainIdentifier + " token: " + token + " exists: " + (reputation != null));
+                if (reputation != null) {
+                    if (this.pdaExistsForToken[chainIdentifier] == null)
+                        this.pdaExistsForToken[chainIdentifier] = {};
+                    this.pdaExistsForToken[chainIdentifier][token] = true;
+                }
+                else {
+                    throw {
+                        code: 20201,
+                        msg: "Token not supported!"
+                    };
+                }
+            }
+        });
+    }
+    /**
+     * 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.onHandlePreToBtcQuote(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 network fee (based on the callback passed), swap fee & total amount
+     *
+     * @param request
+     * @param requestedAmount
+     * @param fees
+     * @param useToken
+     * @param getNetworkFee
+     * @param signal
+     * @param pricePrefetchPromise
+     * @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)
+     */
+    checkToBtcAmount(request, requestedAmount, fees, useToken, getNetworkFee, signal, pricePrefetchPromise) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const chainIdentifier = request.chainIdentifier;
+            const res = yield PluginManager_1.PluginManager.onHandlePostToBtcQuote(request, requestedAmount, request.chainIdentifier, useToken, { minInBtc: this.config.min, maxInBtc: this.config.max }, { baseFeeInBtc: fees.baseFee, feePPM: fees.feePPM, networkFeeGetter: getNetworkFee }, 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.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.add(res.swapFee.inInputTokens).add(res.networkFee.inInputTokens)
+                        };
+                    }
+                }
+            }
+            let amountBD;
+            let tooLow = false;
+            if (requestedAmount.input) {
+                amountBD = yield this.swapPricing.getToBtcSwapAmount(requestedAmount.amount, useToken, chainIdentifier, null, pricePrefetchPromise);
+                signal.throwIfAborted();
+                //Decrease by base fee
+                amountBD = amountBD.sub(fees.baseFee);
+                //If it's already smaller than minimum, set it to minimum so we can calculate the network fee
+                if (amountBD.lt(this.config.min)) {
+                    amountBD = this.config.min;
+                    tooLow = true;
+                }
+            }
+            else {
+                amountBD = requestedAmount.amount;
+                this.checkBtcAmountInBounds(amountBD);
+            }
+            const resp = yield getNetworkFee(amountBD);
+            this.logger.debug("checkToBtcAmount(): network fee calculated, amount: " + amountBD.toString(10) + " fee: " + resp.networkFee.toString(10));
+            signal.throwIfAborted();
+            if (requestedAmount.input) {
+                //Decrease by network fee
+                amountBD = amountBD.sub(resp.networkFee);
+                //Decrease by percentage fee
+                amountBD = amountBD.mul(new BN(1000000)).div(fees.feePPM.add(new BN(1000000)));
+                const tooHigh = amountBD.gt(this.config.max.mul(new BN(105)).div(new BN(100)));
+                tooLow || (tooLow = amountBD.lt(this.config.min.mul(new BN(95)).div(new BN(100))));
+                if (tooLow || tooHigh) {
+                    //Compute min/max
+                    let adjustedMin = this.config.min.mul(fees.feePPM.add(new BN(1000000))).div(new BN(1000000));
+                    let adjustedMax = this.config.max.mul(fees.feePPM.add(new BN(1000000))).div(new BN(1000000));
+                    adjustedMin = adjustedMin.add(fees.baseFee).add(resp.networkFee);
+                    adjustedMax = adjustedMax.add(fees.baseFee).add(resp.networkFee);
+                    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 : 2004,
+                        msg: tooLow ? "Amount too low!" : "Amount too high!",
+                        data: {
+                            min: minIn.toString(10),
+                            max: maxIn.toString(10)
+                        }
+                    };
+                }
+            }
+            const swapFee = fees.baseFee.add(amountBD.mul(fees.feePPM).div(new BN(1000000)));
+            const networkFeeInToken = yield this.swapPricing.getFromBtcSwapAmount(resp.networkFee, useToken, chainIdentifier, true, pricePrefetchPromise);
+            const swapFeeInToken = yield this.swapPricing.getFromBtcSwapAmount(swapFee, useToken, chainIdentifier, true, pricePrefetchPromise);
+            signal.throwIfAborted();
+            let total;
+            if (requestedAmount.input) {
+                total = requestedAmount.amount;
+            }
+            else {
+                const amountInToken = yield this.swapPricing.getFromBtcSwapAmount(requestedAmount.amount, useToken, chainIdentifier, true, pricePrefetchPromise);
+                signal.throwIfAborted();
+                total = amountInToken.add(swapFeeInToken).add(networkFeeInToken);
+            }
+            return { amountBD, networkFeeData: resp, swapFee, swapFeeInToken, networkFee: resp.networkFee, networkFeeInToken, totalInToken: total };
+        });
+    }
+    /**
+     * Starts pre-fetches for swap pricing & signature data
+     *
+     * @param chainIdentifier
+     * @param token
+     * @param responseStream
+     * @param abortController
+     */
+    getToBtcPrefetches(chainIdentifier, token, responseStream, abortController) {
+        //Fetch pricing & signature data in parallel
+        const pricePrefetchPromise = this.swapPricing.preFetchPrice(token, chainIdentifier).catch(e => {
+            this.logger.error("getToBtcPrefetches(): pricePrefetch error", e);
+            abortController.abort(e);
+            return null;
+        });
+        return {
+            pricePrefetchPromise,
+            signDataPrefetchPromise: this.getSignDataPrefetch(chainIdentifier, abortController, responseStream)
+        };
+    }
+    /**
+     * Signs the created swap
+     *
+     * @param chainIdentifier
+     * @param swapObject
+     * @param req
+     * @param abortSignal
+     * @param signDataPrefetchPromise
+     */
+    getToBtcSignatureData(chainIdentifier, swapObject, req, abortSignal, signDataPrefetchPromise) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const prefetchedSignData = signDataPrefetchPromise != null ? yield signDataPrefetchPromise : null;
+            if (prefetchedSignData != null)
+                this.logger.debug("getToBtcSignatureData(): 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("getToBtcSignatureData(): using fee rate from client: ", feeRate);
+            const { swapContract, signer } = this.getChain(chainIdentifier);
+            const sigData = yield swapContract.getInitSignature(signer, swapObject, this.config.authorizationTimeout, prefetchedSignData, feeRate);
+            abortSignal.throwIfAborted();
+            return sigData;
+        });
+    }
+}
+exports.ToBtcBaseSwapHandler = ToBtcBaseSwapHandler;

package/dist/swaps/frombtc_abstract/FromBtcAbs.d.ts

@@ -0,0 +1,92 @@
+import * as BN from "bn.js";
+import { Express } from "express";
+import { FromBtcSwapAbs, FromBtcSwapState } from "./FromBtcSwapAbs";
+import { MultichainData, SwapHandlerType } from "../SwapHandler";
+import { ISwapPrice } from "../ISwapPrice";
+import { ClaimEvent, InitializeEvent, RefundEvent, SwapData } from "@atomiqlabs/base";
+import { AuthenticatedLnd } from "lightning";
+import * as bitcoin from "bitcoinjs-lib";
+import { IIntermediaryStorage } from "../../storage/IIntermediaryStorage";
+import { FromBtcBaseConfig, FromBtcBaseSwapHandler } from "../FromBtcBaseSwapHandler";
+export type FromBtcConfig = FromBtcBaseConfig & {
+    bitcoinNetwork: bitcoin.networks.Network;
+    confirmations: number;
+    swapCsvDelta: number;
+};
+export type FromBtcRequestType = {
+    address: string;
+    amount: BN;
+    token: string;
+    sequence: BN;
+    exactOut?: boolean;
+};
+/**
+ * Swap handler handling from BTC swaps using PTLCs (proof-time locked contracts) and btc relay (on-chain bitcoin SPV)
+ */
+export declare class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSwapState> {
+    readonly type = SwapHandlerType.FROM_BTC;
+    readonly config: FromBtcConfig & {
+        swapTsCsvDelta: BN;
+    };
+    constructor(storageDirectory: IIntermediaryStorage<FromBtcSwapAbs>, path: string, chains: MultichainData, lnd: AuthenticatedLnd, swapPricing: ISwapPrice, config: FromBtcConfig);
+    /**
+     * Returns the TXO hash of the specific address and amount - sha256(u64le(amount) + outputScript(address))
+     *
+     * @param address
+     * @param amount
+     * @param bitcoinNetwork
+     */
+    private getTxoHash;
+    /**
+     * Returns the payment hash of the swap, takes swap nonce into account. Payment hash is chain-specific.
+     *
+     * @param chainIdentifier
+     * @param address
+     * @param amount
+     */
+    private getHash;
+    /**
+     * Processes past swap
+     *
+     * @param swap
+     * @protected
+     * @returns true if the swap should be refunded, false if nothing should be done
+     */
+    protected processPastSwap(swap: FromBtcSwapAbs): Promise<boolean>;
+    /**
+     * Checks past swaps, refunds and deletes ones that are already expired.
+     */
+    protected processPastSwaps(): Promise<void>;
+    /**
+     * Refunds all swaps (calls SC on-chain refund function)
+     *
+     * @param refundSwaps
+     * @protected
+     */
+    protected refundSwaps(refundSwaps: FromBtcSwapAbs[]): Promise<void>;
+    protected processInitializeEvent(chainIdentifier: string, event: InitializeEvent<SwapData>): Promise<void>;
+    protected processClaimEvent(chainIdentifier: string, event: ClaimEvent<SwapData>): Promise<void>;
+    protected processRefundEvent(chainIdentifier: string, event: RefundEvent<SwapData>): Promise<void>;
+    /**
+     * Calculates the requested claimer bounty, based on client's request
+     *
+     * @param req
+     * @param expiry
+     * @param signal
+     * @throws {DefinedRuntimeError} will throw an error if the plugin cancelled the request
+     * @returns {Promise<BN>} resulting claimer bounty to be used with the swap
+     */
+    private getClaimerBounty;
+    private getDummySwapData;
+    /**
+     * Sets up required listeners for the REST server
+     *
+     * @param restServer
+     */
+    startRestServer(restServer: Express): void;
+    /**
+     * Initializes swap handler, loads data and subscribes to chain events
+     */
+    init(): Promise<void>;
+    getInfoData(): any;
+}