@atomiqlabs/lp-lib 16.2.0 → 17.0.0

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

@@ -1,53 +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;
-    }>;
-}
+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/assertions/ToBtcAmountAssertions.js

@@ -1,150 +1,150 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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
-     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
-     */
-    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) {
-            AmountAssertions_1.AmountAssertions.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 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)
-     */
-    async checkToBtcAmount(swapType, request, requestedAmount, fees, getNetworkFee, signal) {
-        const chainIdentifier = request.chainIdentifier;
-        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) {
-            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 ((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 + res.swapFee.inInputTokens + res.networkFee.inInputTokens
-                    };
-                }
-            }
-        }
-        let amountBD;
-        let tooHigh = false;
-        let tooLow = false;
-        if (requestedAmount.input) {
-            amountBD = await this.swapPricing.getToBtcSwapAmount(requestedAmount.amount, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch);
-            signal.throwIfAborted();
-            //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 * 95n / 100n)) {
-                amountBD = this.config.min;
-                tooLow = true;
-            }
-            //If it's already larger than maximum, set it to maximum so we can calculate the network fee
-            if (amountBD > (this.config.max * 105n / 100n)) {
-                amountBD = this.config.max;
-                tooHigh = true;
-            }
-        }
-        else {
-            amountBD = requestedAmount.amount;
-            this.checkBtcAmountInBounds(amountBD);
-        }
-        const resp = await getNetworkFee(amountBD);
-        signal.throwIfAborted();
-        if (requestedAmount.input) {
-            //Decrease by network fee
-            amountBD = amountBD - resp.networkFee;
-            //Decrease by percentage fee
-            amountBD = amountBD * 1000000n / (fees.feePPM + 1000000n);
-            tooHigh || (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, 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)
-                    }
-                };
-            }
-        }
-        const swapFee = fees.baseFee + (amountBD * fees.feePPM / 1000000n);
-        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, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch);
-            signal.throwIfAborted();
-            total = amountInToken + swapFeeInToken + networkFeeInToken;
-        }
-        return { amountBD, networkFeeData: resp, swapFee, swapFeeInToken, networkFee: resp.networkFee, networkFeeInToken, totalInToken: total };
-    }
-}
-exports.ToBtcAmountAssertions = ToBtcAmountAssertions;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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
+     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
+     */
+    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) {
+            AmountAssertions_1.AmountAssertions.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 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)
+     */
+    async checkToBtcAmount(swapType, request, requestedAmount, fees, getNetworkFee, signal) {
+        const chainIdentifier = request.chainIdentifier;
+        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) {
+            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 ((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 + res.swapFee.inInputTokens + res.networkFee.inInputTokens
+                    };
+                }
+            }
+        }
+        let amountBD;
+        let tooHigh = false;
+        let tooLow = false;
+        if (requestedAmount.input) {
+            amountBD = await this.swapPricing.getToBtcSwapAmount(requestedAmount.amount, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch);
+            signal.throwIfAborted();
+            //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 * 95n / 100n)) {
+                amountBD = this.config.min;
+                tooLow = true;
+            }
+            //If it's already larger than maximum, set it to maximum so we can calculate the network fee
+            if (amountBD > (this.config.max * 105n / 100n)) {
+                amountBD = this.config.max;
+                tooHigh = true;
+            }
+        }
+        else {
+            amountBD = requestedAmount.amount;
+            this.checkBtcAmountInBounds(amountBD);
+        }
+        const resp = await getNetworkFee(amountBD);
+        signal.throwIfAborted();
+        if (requestedAmount.input) {
+            //Decrease by network fee
+            amountBD = amountBD - resp.networkFee;
+            //Decrease by percentage fee
+            amountBD = amountBD * 1000000n / (fees.feePPM + 1000000n);
+            tooHigh || (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, 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)
+                    }
+                };
+            }
+        }
+        const swapFee = fees.baseFee + (amountBD * fees.feePPM / 1000000n);
+        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, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch);
+            signal.throwIfAborted();
+            total = amountInToken + swapFeeInToken + networkFeeInToken;
+        }
+        return { amountBD, networkFeeData: resp, swapFee, swapFeeInToken, networkFee: resp.networkFee, networkFeeInToken, totalInToken: total };
+    }
+}
+exports.ToBtcAmountAssertions = ToBtcAmountAssertions;

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

@@ -1,50 +1,50 @@
-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(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>;
-}
+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(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>;
+}