@atomiqlabs/lp-lib 12.1.0 → 13.0.0-beta.1

package/dist/swaps/assertions/FromBtcAmountAssertions.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromBtcAmountAssertions = void 0;
+const PluginManager_1 = require("../../plugins/PluginManager");
+const IPlugin_1 = require("../../plugins/IPlugin");
+const AmountAssertions_1 = require("./AmountAssertions");
+class FromBtcAmountAssertions extends AmountAssertions_1.AmountAssertions {
+    constructor(config, swapPricing) {
+        super(config, swapPricing);
+        this.config = config;
+    }
+    /**
+     * Checks minimums/maximums, calculates the fee & total amount
+     *
+     * @param swapType
+     * @param request
+     * @param requestedAmount
+     * @param gasAmount
+     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
+     */
+    async preCheckFromBtcAmounts(swapType, request, requestedAmount, gasAmount) {
+        const res = await PluginManager_1.PluginManager.onHandlePreFromBtcQuote(swapType, request, requestedAmount, request.chainIdentifier, { minInBtc: this.config.min, maxInBtc: this.config.max }, { baseFeeInBtc: this.config.baseFee, feePPM: this.config.feePPM }, gasAmount);
+        if (res != null) {
+            AmountAssertions_1.AmountAssertions.handlePluginErrorResponses(res);
+            if ((0, IPlugin_1.isQuoteSetFees)(res)) {
+                return {
+                    baseFee: res.baseFee || this.config.baseFee,
+                    feePPM: res.feePPM || this.config.feePPM,
+                    securityDepositApyPPM: res.securityDepositApyPPM,
+                    securityDepositBaseMultiplierPPM: res.securityDepositBaseMultiplierPPM
+                };
+            }
+        }
+        if (requestedAmount.input)
+            this.checkBtcAmountInBounds(requestedAmount.amount);
+        if (gasAmount != null && gasAmount.amount !== 0n) {
+            if (gasAmount.amount > (this.config.gasTokenMax?.[request.chainIdentifier] ?? 0n)) {
+                throw {
+                    code: 20504,
+                    msg: "Gas token amount too high!",
+                    data: {
+                        max: (this.config.gasTokenMax?.[request.chainIdentifier] ?? 0n).toString(10)
+                    }
+                };
+            }
+        }
+        return {
+            baseFee: this.config.baseFee,
+            feePPM: this.config.feePPM
+        };
+    }
+    /**
+     * Checks minimums/maximums, calculates the fee & total amount
+     *
+     * @param swapType
+     * @param request
+     * @param requestedAmount
+     * @param fees
+     * @param signal
+     * @param gasTokenAmount
+     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
+     */
+    async checkFromBtcAmount(swapType, request, requestedAmount, fees, signal, gasTokenAmount) {
+        const chainIdentifier = request.chainIdentifier;
+        let securityDepositApyPPM;
+        let securityDepositBaseMultiplierPPM;
+        const res = await PluginManager_1.PluginManager.onHandlePostFromBtcQuote(swapType, request, requestedAmount, chainIdentifier, { minInBtc: this.config.min, maxInBtc: this.config.max }, { baseFeeInBtc: fees.baseFee, feePPM: fees.feePPM }, gasTokenAmount);
+        signal.throwIfAborted();
+        if (res != null) {
+            AmountAssertions_1.AmountAssertions.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 (res.securityDepositApyPPM != null)
+                    securityDepositApyPPM = res.securityDepositApyPPM;
+                if (res.securityDepositBaseMultiplierPPM != null)
+                    securityDepositBaseMultiplierPPM = res.securityDepositBaseMultiplierPPM;
+            }
+            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
+                    };
+                }
+            }
+        }
+        let amountBDgas = 0n;
+        if (gasTokenAmount != null) {
+            amountBDgas = await this.swapPricing.getToBtcSwapAmount(gasTokenAmount.amount, gasTokenAmount.token, chainIdentifier, true, gasTokenAmount.pricePrefetch);
+        }
+        let amountBD;
+        if (!requestedAmount.input) {
+            amountBD = await this.swapPricing.getToBtcSwapAmount(requestedAmount.amount, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch);
+            signal.throwIfAborted();
+            // amt = (amt+base_fee)/(1-fee)
+            amountBD = (amountBD + fees.baseFee) * 1000000n / (1000000n - fees.feePPM);
+            amountBDgas = amountBDgas * 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, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch);
+                const maxIn = await this.swapPricing.getFromBtcSwapAmount(adjustedMax, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch);
+                throw {
+                    code: tooLow ? 20003 : 20004,
+                    msg: tooLow ? "Amount too low!" : "Amount too high!",
+                    data: {
+                        min: minIn.toString(10),
+                        max: maxIn.toString(10)
+                    }
+                };
+            }
+        }
+        else {
+            amountBD = requestedAmount.amount - amountBDgas;
+            this.checkBtcAmountInBounds(amountBD);
+        }
+        const swapFee = fees.baseFee + (amountBD * fees.feePPM / 1000000n);
+        const swapFeeInToken = await this.swapPricing.getFromBtcSwapAmount(swapFee, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch);
+        signal.throwIfAborted();
+        const gasSwapFee = ((amountBDgas * fees.feePPM) + 999999n) / 1000000n;
+        const gasSwapFeeInToken = gasTokenAmount == null ?
+            0n :
+            await this.swapPricing.getFromBtcSwapAmount(gasSwapFee, gasTokenAmount.token, chainIdentifier, true, gasTokenAmount.pricePrefetch);
+        signal.throwIfAborted();
+        let totalInToken;
+        if (!requestedAmount.input) {
+            totalInToken = requestedAmount.amount;
+        }
+        else {
+            totalInToken = await this.swapPricing.getFromBtcSwapAmount(amountBD - swapFee - gasSwapFee, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch);
+            signal.throwIfAborted();
+        }
+        return {
+            amountBD,
+            swapFee,
+            swapFeeInToken,
+            totalInToken,
+            amountBDgas,
+            gasSwapFee,
+            gasSwapFeeInToken,
+            totalInGasToken: gasTokenAmount?.amount,
+            securityDepositApyPPM,
+            securityDepositBaseMultiplierPPM
+        };
+    }
+}
+exports.FromBtcAmountAssertions = FromBtcAmountAssertions;

package/dist/swaps/assertions/LightningAssertions.d.ts

@@ -0,0 +1,44 @@
+import { ILightningWallet, LightningNetworkChannel } from "../../wallets/ILightningWallet";
+import { LoggerType } from "../../utils/Utils";
+export declare class LightningAssertions {
+    protected readonly LIGHTNING_LIQUIDITY_CACHE_TIMEOUT: number;
+    lightningLiquidityCache: {
+        liquidity: bigint;
+        timestamp: number;
+    };
+    readonly lightning: ILightningWallet;
+    readonly logger: LoggerType;
+    constructor(logger: LoggerType, lightning: ILightningWallet);
+    /**
+     * Checks if the prior payment with the same paymentHash exists
+     *
+     * @param paymentHash
+     * @param abortSignal
+     * @throws {DefinedRuntimeError} will throw an error if payment already exists
+     */
+    checkPriorPayment(paymentHash: string, abortSignal: AbortSignal): Promise<void>;
+    /**
+     * Checks if the underlying LND backend has enough liquidity in channels to honor the swap
+     *
+     * @param amount
+     * @param abortSignal
+     * @param useCached Whether to use cached liquidity values
+     * @throws {DefinedRuntimeError} will throw an error if there isn't enough liquidity
+     */
+    checkLiquidity(amount: bigint, abortSignal: AbortSignal, useCached?: boolean): Promise<void>;
+    /**
+     * 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
+     */
+    checkInboundLiquidity(amountBD: bigint, channelsPrefetch: Promise<LightningNetworkChannel[]>, signal: AbortSignal): Promise<void>;
+    /**
+     * Starts LN channels pre-fetch
+     *
+     * @param abortController
+     */
+    getChannelsPrefetch(abortController: AbortController): Promise<LightningNetworkChannel[]>;
+}

package/dist/swaps/assertions/LightningAssertions.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LightningAssertions = void 0;
+class LightningAssertions {
+    constructor(logger, lightning) {
+        this.LIGHTNING_LIQUIDITY_CACHE_TIMEOUT = 5 * 1000;
+        this.logger = logger;
+        this.lightning = lightning;
+    }
+    /**
+     * Checks if the prior payment with the same paymentHash exists
+     *
+     * @param paymentHash
+     * @param abortSignal
+     * @throws {DefinedRuntimeError} will throw an error if payment already exists
+     */
+    async checkPriorPayment(paymentHash, abortSignal) {
+        const payment = await this.lightning.getPayment(paymentHash);
+        if (payment != null)
+            throw {
+                code: 20010,
+                msg: "Already processed"
+            };
+        abortSignal.throwIfAborted();
+    }
+    /**
+     * Checks if the underlying LND backend has enough liquidity in channels to honor the swap
+     *
+     * @param amount
+     * @param abortSignal
+     * @param useCached Whether to use cached liquidity values
+     * @throws {DefinedRuntimeError} will throw an error if there isn't enough liquidity
+     */
+    async checkLiquidity(amount, abortSignal, useCached = false) {
+        if (!useCached || this.lightningLiquidityCache == null || this.lightningLiquidityCache.timestamp < Date.now() - this.LIGHTNING_LIQUIDITY_CACHE_TIMEOUT) {
+            const channelBalances = await this.lightning.getLightningBalance();
+            this.lightningLiquidityCache = {
+                liquidity: channelBalances.localBalance,
+                timestamp: Date.now()
+            };
+        }
+        if (amount > this.lightningLiquidityCache.liquidity) {
+            throw {
+                code: 20002,
+                msg: "Not enough liquidity"
+            };
+        }
+        abortSignal.throwIfAborted();
+    }
+    /**
+     * Checks if we have enough inbound liquidity to be able to receive an LN payment (without MPP)
+     *
+     * @param amountBD
+     * @param channelsPrefetch
+     * @param signal
+     * @throws {DefinedRuntimeError} will throw an error if there isn't enough inbound liquidity to receive the LN payment
+     */
+    async checkInboundLiquidity(amountBD, channelsPrefetch, signal) {
+        const channelsResponse = await channelsPrefetch;
+        signal.throwIfAborted();
+        let hasEnoughInboundLiquidity = false;
+        channelsResponse.forEach(channel => {
+            if (channel.remoteBalance >= amountBD)
+                hasEnoughInboundLiquidity = true;
+        });
+        if (!hasEnoughInboundLiquidity) {
+            throw {
+                code: 20050,
+                msg: "Not enough LN inbound liquidity"
+            };
+        }
+    }
+    /**
+     * Starts LN channels pre-fetch
+     *
+     * @param abortController
+     */
+    getChannelsPrefetch(abortController) {
+        return this.lightning.getChannels(true).catch(e => {
+            this.logger.error("getChannelsPrefetch(): error", e);
+            abortController.abort(e);
+            return null;
+        });
+    }
+}
+exports.LightningAssertions = LightningAssertions;

package/dist/swaps/assertions/ToBtcAmountAssertions.d.ts

@@ -0,0 +1,53 @@
+import { AmountAssertions } from "./AmountAssertions";
+import { ToBtcLnRequestType } from "../escrow/tobtcln_abstract/ToBtcLnAbs";
+import { ToBtcRequestType } from "../escrow/tobtc_abstract/ToBtcAbs";
+import { RequestData, SwapHandlerType } from "../SwapHandler";
+export declare class ToBtcAmountAssertions extends AmountAssertions {
+    /**
+     * Checks minimums/maximums, calculates the fee & total amount
+     *
+     * @param swapType
+     * @param request
+     * @param requestedAmount
+     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
+     */
+    preCheckToBtcAmounts(swapType: SwapHandlerType.TO_BTCLN | SwapHandlerType.TO_BTC, request: RequestData<ToBtcLnRequestType | ToBtcRequestType>, requestedAmount: {
+        input: boolean;
+        amount: bigint;
+        token: string;
+    }): Promise<{
+        baseFee: bigint;
+        feePPM: bigint;
+    }>;
+    /**
+     * Checks minimums/maximums, calculates network fee (based on the callback passed), swap fee & total amount
+     *
+     * @param swapType
+     * @param request
+     * @param requestedAmount
+     * @param fees
+     * @param getNetworkFee
+     * @param signal
+     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds,
+     *  or if we don't have enough funds (getNetworkFee callback throws)
+     */
+    checkToBtcAmount<T extends {
+        networkFee: bigint;
+    }>(swapType: SwapHandlerType.TO_BTCLN | SwapHandlerType.TO_BTC, request: RequestData<ToBtcLnRequestType | ToBtcRequestType>, requestedAmount: {
+        input: boolean;
+        amount: bigint;
+        token: string;
+        pricePrefetch?: Promise<bigint>;
+    }, fees: {
+        baseFee: bigint;
+        feePPM: bigint;
+    }, getNetworkFee: (amount: bigint) => Promise<T>, signal: AbortSignal): Promise<{
+        amountBD: bigint;
+        networkFeeData: T;
+        swapFee: bigint;
+        swapFeeInToken: bigint;
+        networkFee: bigint;
+        networkFeeInToken: bigint;
+        totalInToken: bigint;
+    }>;
+}

package/dist/swaps/{ToBtcBaseSwapHandler.js → assertions/ToBtcAmountAssertions.js}

@@ -1,46 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToBtcBaseSwapHandler = void 0;
-const SwapHandler_1 = require("./SwapHandler");
-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 = {};
-    }
-    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!"
-                };
-            }
-        }
-    }
+exports.ToBtcAmountAssertions = void 0;
+const AmountAssertions_1 = require("./AmountAssertions");
+const PluginManager_1 = require("../../plugins/PluginManager");
+const IPlugin_1 = require("../../plugins/IPlugin");
+class ToBtcAmountAssertions extends AmountAssertions_1.AmountAssertions {
     /**
      * Checks minimums/maximums, calculates the fee & total amount
      *
+     * @param swapType
      * @param request
      * @param requestedAmount
-     * @param useToken
      * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
      */
-    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 });
+    async preCheckToBtcAmounts(swapType, request, requestedAmount) {
+        const res = await PluginManager_1.PluginManager.onHandlePreToBtcQuote(swapType, request, requestedAmount, request.chainIdentifier, { minInBtc: this.config.min, maxInBtc: this.config.max }, { baseFeeInBtc: this.config.baseFee, feePPM: this.config.feePPM });
         if (res != null) {
-            this.handlePluginErrorResponses(res);
+            AmountAssertions_1.AmountAssertions.handlePluginErrorResponses(res);
             if ((0, IPlugin_1.isQuoteSetFees)(res)) {
                 return {
                     baseFee: res.baseFee || this.config.baseFee,
@@ -59,22 +35,21 @@ class ToBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
     /**
      * Checks minimums/maximums, calculates network fee (based on the callback passed), swap fee & total amount
      *
+     * @param swapType
      * @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)
      */
-    async checkToBtcAmount(request, requestedAmount, fees, useToken, getNetworkFee, signal, pricePrefetchPromise) {
+    async checkToBtcAmount(swapType, request, requestedAmount, fees, getNetworkFee, signal) {
         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);
+        const res = await PluginManager_1.PluginManager.onHandlePostToBtcQuote(swapType, request, requestedAmount, request.chainIdentifier, { minInBtc: this.config.min, maxInBtc: this.config.max }, { baseFeeInBtc: fees.baseFee, feePPM: fees.feePPM, networkFeeGetter: getNetworkFee });
         signal.throwIfAborted();
         if (res != null) {
-            this.handlePluginErrorResponses(res);
+            AmountAssertions_1.AmountAssertions.handlePluginErrorResponses(res);
             if ((0, IPlugin_1.isQuoteSetFees)(res)) {
                 if (res.baseFee != null)
                     fees.baseFee = res.baseFee;
@@ -109,7 +84,7 @@ class ToBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
         let amountBD;
         let tooLow = false;
         if (requestedAmount.input) {
-            amountBD = await this.swapPricing.getToBtcSwapAmount(requestedAmount.amount, useToken, chainIdentifier, null, pricePrefetchPromise);
+            amountBD = await this.swapPricing.getToBtcSwapAmount(requestedAmount.amount, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch);
             signal.throwIfAborted();
             //Decrease by base fee
             amountBD = amountBD - fees.baseFee;
@@ -124,7 +99,6 @@ class ToBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
             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
@@ -139,8 +113,8 @@ class ToBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
                 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);
+                const minIn = await this.swapPricing.getFromBtcSwapAmount(adjustedMin, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch);
+                const maxIn = await this.swapPricing.getFromBtcSwapAmount(adjustedMax, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch);
                 throw {
                     code: tooLow ? 20003 : 2004,
                     msg: tooLow ? "Amount too low!" : "Amount too high!",
@@ -152,67 +126,19 @@ class ToBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
             }
         }
         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);
+        const networkFeeInToken = await this.swapPricing.getFromBtcSwapAmount(resp.networkFee, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch);
+        const swapFeeInToken = await this.swapPricing.getFromBtcSwapAmount(swapFee, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch);
         signal.throwIfAborted();
         let total;
         if (requestedAmount.input) {
             total = requestedAmount.amount;
         }
         else {
-            const amountInToken = await this.swapPricing.getFromBtcSwapAmount(requestedAmount.amount, useToken, chainIdentifier, true, pricePrefetchPromise);
+            const amountInToken = await this.swapPricing.getFromBtcSwapAmount(requestedAmount.amount, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch);
             signal.throwIfAborted();
             total = amountInToken + swapFeeInToken + networkFeeInToken;
         }
         return { amountBD, networkFeeData: resp, swapFee, swapFeeInToken, networkFee: resp.networkFee, networkFeeInToken, totalInToken: total };
     }
-    /**
-     * 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
-     */
-    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;
+exports.ToBtcAmountAssertions = ToBtcAmountAssertions;

package/dist/swaps/escrow/EscrowHandler.d.ts

@@ -0,0 +1,51 @@
+import { SwapBaseConfig, SwapHandler } from "../SwapHandler";
+import { ChainEvent, ChainSwapType, ClaimEvent, InitializeEvent, RefundEvent, SwapData, SwapEvent } from "@atomiqlabs/base";
+import { EscrowHandlerSwap } from "./EscrowHandlerSwap";
+import { ServerParamEncoder } from "../../utils/paramcoders/server/ServerParamEncoder";
+import { SwapHandlerSwap } from "../SwapHandlerSwap";
+export type ToBtcBaseConfig = SwapBaseConfig & {
+    gracePeriod: bigint;
+    refundAuthorizationTimeout: number;
+};
+export declare abstract class EscrowHandler<V extends EscrowHandlerSwap<SwapData, S>, S> extends SwapHandler<V, S> {
+    abstract readonly swapType: ChainSwapType;
+    readonly escrowHashMap: Map<string, V>;
+    protected swapLogger: {
+        debug: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => void;
+        info: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => void;
+        warn: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => void;
+        error: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => void;
+    };
+    protected abstract processInitializeEvent(chainIdentifier: string, swap: V, event: InitializeEvent<SwapData>): Promise<void>;
+    protected abstract processClaimEvent(chainIdentifier: string, swap: V, event: ClaimEvent<SwapData>): Promise<void>;
+    protected abstract processRefundEvent(chainIdentifier: string, swap: V, event: RefundEvent<SwapData>): Promise<void>;
+    /**
+     * Chain event processor
+     *
+     * @param chainIdentifier
+     * @param eventData
+     */
+    protected processEvent(chainIdentifier: string, eventData: ChainEvent<SwapData>[]): Promise<boolean>;
+    /**
+     * Initializes chain events subscription
+     */
+    protected subscribeToEvents(): void;
+    protected loadData(ctor: new (data: any) => V): Promise<void>;
+    protected removeSwapData(hash: string, sequence: bigint): Promise<void>;
+    protected removeSwapData(swap: V, ultimateState?: S): Promise<void>;
+    protected saveSwapData(swap: V): Promise<void>;
+    protected saveSwapToEscrowHashMap(swap: V): void;
+    protected removeSwapFromEscrowHashMap(swap: V): void;
+    protected getSwapByEscrowHash(chainIdentifier: string, escrowHash: string): V;
+    protected getIdentifierFromEvent(event: SwapEvent<SwapData>): string;
+    protected getIdentifierFromSwapData(swapData: SwapData): string;
+    protected getIdentifier(swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData): string;
+    /**
+     * Starts a pre-fetch for signature data
+     *
+     * @param chainIdentifier
+     * @param abortController
+     * @param responseStream
+     */
+    protected getSignDataPrefetch(chainIdentifier: string, abortController: AbortController, responseStream?: ServerParamEncoder): Promise<any>;
+}