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

package/dist/swaps/ToBtcBaseSwap.d.ts

@@ -1,37 +1,36 @@
 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> {
-    amount: BN;
-    quotedNetworkFee: BN;
-    readonly quotedNetworkFeeInToken: BN;
-    realNetworkFee: BN;
-    realNetworkFeeInToken: BN;
-    protected constructor(chainIdentifier: string, amount: BN, swapFee: BN, swapFeeInToken: BN, quotedNetworkFee: BN, quotedNetworkFeeInToken: BN);
+    amount: bigint;
+    quotedNetworkFee: bigint;
+    readonly quotedNetworkFeeInToken: bigint;
+    realNetworkFee: bigint;
+    realNetworkFeeInToken: bigint;
+    protected constructor(chainIdentifier: string, amount: bigint, swapFee: bigint, swapFeeInToken: bigint, quotedNetworkFee: bigint, quotedNetworkFeeInToken: bigint);
     protected constructor(obj: any);
     serialize(): any;
-    setRealNetworkFee(networkFeeInBtc: BN): void;
-    getInputAmount(): BN;
-    getTotalInputAmount(): BN;
+    setRealNetworkFee(networkFeeInBtc: bigint): void;
+    getInputAmount(): bigint;
+    getTotalInputAmount(): bigint;
     getSwapFee(): {
-        inInputToken: BN;
-        inOutputToken: BN;
+        inInputToken: bigint;
+        inOutputToken: bigint;
     };
     /**
      * 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;
+        inInputToken: bigint;
+        inOutputToken: bigint;
     };
     /**
      * 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;
+        inInputToken: bigint;
+        inOutputToken: bigint;
     };
-    getOutputAmount(): BN;
+    getOutputAmount(): bigint;
 }

package/dist/swaps/ToBtcBaseSwap.js

@@ -2,11 +2,11 @@
 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, amount, swapFee, swapFeeInToken, quotedNetworkFee, quotedNetworkFeeInToken) {
-        if (typeof (obj) === "string" && BN.isBN(amount) && BN.isBN(swapFee) && BN.isBN(swapFeeInToken) && BN.isBN(quotedNetworkFee) && BN.isBN(quotedNetworkFeeInToken)) {
+        if (typeof (obj) === "string" && typeof (amount) === "bigint" && typeof (swapFee) === "bigint" && typeof (swapFeeInToken) === "bigint" &&
+            typeof (quotedNetworkFee) === "bigint" && typeof (quotedNetworkFeeInToken) === "bigint") {
             super(obj, swapFee, swapFeeInToken);
             this.amount = amount;
             this.quotedNetworkFee = quotedNetworkFee;
@@ -34,11 +34,11 @@ class ToBtcBaseSwap extends SwapHandlerSwap_1.SwapHandlerSwap {
     setRealNetworkFee(networkFeeInBtc) {
         this.realNetworkFee = networkFeeInBtc;
         if (this.quotedNetworkFee != null && this.quotedNetworkFeeInToken != null) {
-            this.realNetworkFeeInToken = this.realNetworkFee.mul(this.quotedNetworkFeeInToken).div(this.quotedNetworkFee);
+            this.realNetworkFeeInToken = this.realNetworkFee * this.quotedNetworkFeeInToken / this.quotedNetworkFee;
         }
     }
     getInputAmount() {
-        return this.data.getAmount().sub(this.getSwapFee().inInputToken).sub(this.getQuotedNetworkFee().inInputToken);
+        return this.data.getAmount() - this.getSwapFee().inInputToken - this.getQuotedNetworkFee().inInputToken;
     }
     getTotalInputAmount() {
         return this.data.getAmount();

package/dist/swaps/ToBtcBaseSwapHandler.d.ts

@@ -1,14 +1,14 @@
 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;
+    gracePeriod: bigint;
+    refundAuthorizationTimeout: number;
 };
 export declare abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S>, S> extends SwapHandler<V, S> {
     readonly pdaExistsForToken: {
@@ -28,10 +28,10 @@ export declare abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<Swa
      */
     protected preCheckAmounts(request: RequestData<ToBtcLnRequestType | ToBtcRequestType>, requestedAmount: {
         input: boolean;
-        amount: BN;
+        amount: bigint;
     }, useToken: string): Promise<{
-        baseFee: BN;
-        feePPM: BN;
+        baseFee: bigint;
+        feePPM: bigint;
     }>;
     /**
      * Checks minimums/maximums, calculates network fee (based on the callback passed), swap fee & total amount
@@ -47,21 +47,21 @@ export declare abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<Swa
      *  or if we don't have enough funds (getNetworkFee callback throws)
      */
     protected checkToBtcAmount<T extends {
-        networkFee: BN;
+        networkFee: bigint;
     }>(request: RequestData<ToBtcLnRequestType | ToBtcRequestType>, requestedAmount: {
         input: boolean;
-        amount: BN;
+        amount: bigint;
     }, fees: {
-        baseFee: BN;
-        feePPM: BN;
-    }, useToken: string, getNetworkFee: (amount: BN) => Promise<T>, signal: AbortSignal, pricePrefetchPromise?: Promise<BN>): Promise<{
-        amountBD: BN;
+        baseFee: bigint;
+        feePPM: bigint;
+    }, useToken: string, getNetworkFee: (amount: bigint) => Promise<T>, signal: AbortSignal, pricePrefetchPromise?: Promise<bigint>): Promise<{
+        amountBD: bigint;
         networkFeeData: T;
-        swapFee: BN;
-        swapFeeInToken: BN;
-        networkFee: BN;
-        networkFeeInToken: BN;
-        totalInToken: BN;
+        swapFee: bigint;
+        swapFeeInToken: bigint;
+        networkFee: bigint;
+        networkFeeInToken: bigint;
+        totalInToken: bigint;
     }>;
     /**
      * Starts pre-fetches for swap pricing & signature data
@@ -72,7 +72,7 @@ export declare abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<Swa
      * @param abortController
      */
     protected getToBtcPrefetches(chainIdentifier: string, token: string, responseStream: ServerParamEncoder, abortController: AbortController): {
-        pricePrefetchPromise?: Promise<BN>;
+        pricePrefetchPromise?: Promise<bigint>;
         signDataPrefetchPromise?: Promise<any>;
     };
     /**

package/dist/swaps/ToBtcBaseSwapHandler.js

@@ -1,17 +1,7 @@
 "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");
@@ -20,26 +10,24 @@ class ToBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
         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!"
-                    };
-                }
+    async checkVaultInitialized(chainIdentifier, token) {
+        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 = await 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
@@ -49,26 +37,24 @@ class ToBtcBaseSwapHandler 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.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);
+    async preCheckAmounts(request, requestedAmount, useToken) {
+        const res = await 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
+                };
             }
-            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 network fee (based on the callback passed), swap fee & total amount
@@ -83,104 +69,102 @@ class ToBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
      * @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)
-                        };
-                    }
-                }
+    async checkToBtcAmount(request, requestedAmount, fees, useToken, getNetworkFee, signal, pricePrefetchPromise) {
+        const chainIdentifier = request.chainIdentifier;
+        const res = await 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;
             }
-            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;
+            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 {
-                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)
-                        }
+                else {
+                    return {
+                        amountBD: requestedAmount.amount,
+                        swapFee: res.swapFee.inOutputTokens,
+                        swapFeeInToken: res.swapFee.inInputTokens,
+                        networkFee: res.networkFee.inOutputTokens,
+                        networkFeeInToken: res.networkFee.inInputTokens,
+                        networkFeeData: res.networkFeeData,
+                        totalInToken: res.amount.amount + res.swapFee.inInputTokens + res.networkFee.inInputTokens
                     };
                 }
             }
-            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);
+        }
+        let amountBD;
+        let tooLow = false;
+        if (requestedAmount.input) {
+            amountBD = await this.swapPricing.getToBtcSwapAmount(requestedAmount.amount, useToken, chainIdentifier, null, pricePrefetchPromise);
             signal.throwIfAborted();
-            let total;
-            if (requestedAmount.input) {
-                total = requestedAmount.amount;
+            //Decrease by base fee
+            amountBD = amountBD - fees.baseFee;
+            //If it's already smaller than minimum, set it to minimum so we can calculate the network fee
+            if (amountBD < this.config.min) {
+                amountBD = this.config.min;
+                tooLow = true;
             }
-            else {
-                const amountInToken = yield this.swapPricing.getFromBtcSwapAmount(requestedAmount.amount, useToken, chainIdentifier, true, pricePrefetchPromise);
-                signal.throwIfAborted();
-                total = amountInToken.add(swapFeeInToken).add(networkFeeInToken);
+        }
+        else {
+            amountBD = requestedAmount.amount;
+            this.checkBtcAmountInBounds(amountBD);
+        }
+        const resp = await 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 - resp.networkFee;
+            //Decrease by percentage fee
+            amountBD = amountBD * 1000000n / (fees.feePPM + 1000000n);
+            const tooHigh = amountBD > (this.config.max * 105n / 100n);
+            tooLow || (tooLow = amountBD < (this.config.min * 95n / 100n));
+            if (tooLow || tooHigh) {
+                //Compute min/max
+                let adjustedMin = this.config.min * (fees.feePPM + 1000000n) / 1000000n;
+                let adjustedMax = this.config.max * (fees.feePPM + 1000000n) / 1000000n;
+                adjustedMin = adjustedMin + fees.baseFee + resp.networkFee;
+                adjustedMax = adjustedMax + fees.baseFee + resp.networkFee;
+                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 : 2004,
+                    msg: tooLow ? "Amount too low!" : "Amount too high!",
+                    data: {
+                        min: minIn.toString(10),
+                        max: maxIn.toString(10)
+                    }
+                };
             }
-            return { amountBD, networkFeeData: resp, swapFee, swapFeeInToken, networkFee: resp.networkFee, networkFeeInToken, totalInToken: total };
-        });
+        }
+        const swapFee = fees.baseFee + (amountBD * fees.feePPM / 1000000n);
+        const networkFeeInToken = await this.swapPricing.getFromBtcSwapAmount(resp.networkFee, useToken, chainIdentifier, true, pricePrefetchPromise);
+        const swapFeeInToken = await this.swapPricing.getFromBtcSwapAmount(swapFee, useToken, chainIdentifier, true, pricePrefetchPromise);
+        signal.throwIfAborted();
+        let total;
+        if (requestedAmount.input) {
+            total = requestedAmount.amount;
+        }
+        else {
+            const amountInToken = await this.swapPricing.getFromBtcSwapAmount(requestedAmount.amount, useToken, chainIdentifier, true, pricePrefetchPromise);
+            signal.throwIfAborted();
+            total = amountInToken + swapFeeInToken + networkFeeInToken;
+        }
+        return { amountBD, networkFeeData: resp, swapFee, swapFeeInToken, networkFee: resp.networkFee, networkFeeInToken, totalInToken: total };
     }
     /**
      * Starts pre-fetches for swap pricing & signature data
@@ -211,23 +195,24 @@ class ToBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
      * @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 Object.assign(Object.assign({}, sigData), { feeRate });
-        });
+    async getToBtcSignatureData(chainIdentifier, swapObject, req, abortSignal, signDataPrefetchPromise) {
+        const prefetchedSignData = signDataPrefetchPromise != null ? await signDataPrefetchPromise : null;
+        if (prefetchedSignData != null)
+            this.logger.debug("getToBtcSignatureData(): 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("getToBtcSignatureData(): using fee rate from client: ", feeRate);
+        const { swapContract, signer } = this.getChain(chainIdentifier);
+        const sigData = await swapContract.getInitSignature(signer, swapObject, this.getInitAuthorizationTimeout(chainIdentifier), prefetchedSignData, feeRate);
+        abortSignal.throwIfAborted();
+        return {
+            ...sigData,
+            feeRate
+        };
     }
 }
 exports.ToBtcBaseSwapHandler = ToBtcBaseSwapHandler;

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

@@ -1,9 +1,8 @@
-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 { ChainSwapType, ClaimEvent, InitializeEvent, RefundEvent, SwapData } from "@atomiqlabs/base";
 import { IIntermediaryStorage } from "../../storage/IIntermediaryStorage";
 import { FromBtcBaseConfig, FromBtcBaseSwapHandler } from "../FromBtcBaseSwapHandler";
 import { IBitcoinWallet } from "../../wallets/IBitcoinWallet";
@@ -13,9 +12,9 @@ export type FromBtcConfig = FromBtcBaseConfig & {
 };
 export type FromBtcRequestType = {
     address: string;
-    amount: BN;
+    amount: bigint;
     token: string;
-    sequence: BN;
+    sequence: bigint;
     exactOut?: boolean;
 };
 /**
@@ -23,18 +22,12 @@ export type FromBtcRequestType = {
  */
 export declare class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSwapState> {
     readonly type = SwapHandlerType.FROM_BTC;
+    readonly swapType = ChainSwapType.CHAIN;
     readonly config: FromBtcConfig & {
-        swapTsCsvDelta: BN;
+        swapTsCsvDelta: bigint;
     };
     readonly bitcoin: IBitcoinWallet;
     constructor(storageDirectory: IIntermediaryStorage<FromBtcSwapAbs>, path: string, chains: MultichainData, bitcoin: IBitcoinWallet, swapPricing: ISwapPrice, config: FromBtcConfig);
-    /**
-     * Returns the TXO hash of the specific address and amount - sha256(u64le(amount) + outputScript(address))
-     *
-     * @param address
-     * @param amount
-     */
-    private getTxoHash;
     /**
      * Returns the payment hash of the swap, takes swap nonce into account. Payment hash is chain-specific.
      *
@@ -62,9 +55,9 @@ export declare class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, F
      * @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>;
+    protected processInitializeEvent(chainIdentifier: string, savedSwap: FromBtcSwapAbs, event: InitializeEvent<SwapData>): Promise<void>;
+    protected processClaimEvent(chainIdentifier: string, savedSwap: FromBtcSwapAbs, event: ClaimEvent<SwapData>): Promise<void>;
+    protected processRefundEvent(chainIdentifier: string, savedSwap: FromBtcSwapAbs, event: RefundEvent<SwapData>): Promise<void>;
     /**
      * Calculates the requested claimer bounty, based on client's request
      *