@atomiqlabs/lp-lib 10.3.11

package/dist/swaps/FromBtcLnBaseSwapHandler.js

@@ -0,0 +1,55 @@
+"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.FromBtcLnBaseSwapHandler = void 0;
+const FromBtcBaseSwapHandler_1 = require("./FromBtcBaseSwapHandler");
+const BN = require("bn.js");
+const lncli = require("ln-service");
+class FromBtcLnBaseSwapHandler extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
+    /**
+     * 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, channelsPrefetch, signal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const channelsResponse = yield channelsPrefetch;
+            signal.throwIfAborted();
+            let hasEnoughInboundLiquidity = false;
+            channelsResponse.channels.forEach(channel => {
+                if (new BN(channel.remote_balance).gte(amountBD))
+                    hasEnoughInboundLiquidity = true;
+            });
+            if (!hasEnoughInboundLiquidity) {
+                throw {
+                    code: 20050,
+                    msg: "Not enough LN inbound liquidity"
+                };
+            }
+        });
+    }
+    /**
+     * Starts LN channels pre-fetch
+     *
+     * @param abortController
+     */
+    getChannelsPrefetch(abortController) {
+        return lncli.getChannels({ is_active: true, lnd: this.LND }).catch(e => {
+            this.logger.error("getChannelsPrefetch(): error", e);
+            abortController.abort(e);
+            return null;
+        });
+    }
+}
+exports.FromBtcLnBaseSwapHandler = FromBtcLnBaseSwapHandler;

package/dist/swaps/ISwapPrice.d.ts

@@ -0,0 +1,44 @@
+import * as BN from "bn.js";
+export type ISwapPriceCoinsMap<T extends {
+    decimals: number;
+}> = {
+    [chainId: string]: {
+        [address: string]: T;
+    };
+};
+export declare abstract class ISwapPrice<T extends {
+    decimals: number;
+} = {
+    decimals: number;
+}> {
+    protected coinsMap: ISwapPriceCoinsMap<T>;
+    protected constructor(coinsMap: ISwapPriceCoinsMap<T>);
+    /**
+     * Returns coin price in mSat
+     *
+     * @param tokenData
+     */
+    protected abstract getPrice(tokenData: T): Promise<BN>;
+    getTokenData(tokenAddress: string, chainId: string): T;
+    preFetchPrice(token: string, chainId: string): Promise<BN>;
+    /**
+     * Returns amount of satoshis that are equivalent to {fromAmount} of {fromToken}
+     *
+     * @param fromAmount Amount of the token
+     * @param fromToken Token
+     * @param tokenChainIdentification Chain of the token
+     * @param roundUp Whether result should be rounded up
+     * @param preFetch Price pre-fetch promise returned from preFetchPrice()
+     */
+    getToBtcSwapAmount(fromAmount: BN, fromToken: string, tokenChainIdentification: string, roundUp?: boolean, preFetch?: Promise<BN>): Promise<BN>;
+    /**
+     * Returns amount of {toToken} that are equivalent to {fromAmount} satoshis
+     *
+     * @param fromAmount Amount of satoshis
+     * @param toToken Token
+     * @param tokenChainIdentification Chain of the token
+     * @param roundUp Whether result should be rounded up
+     * @param preFetch Price pre-fetch promise returned from preFetchPrice()
+     */
+    getFromBtcSwapAmount(fromAmount: BN, toToken: string, tokenChainIdentification: string, roundUp?: boolean, preFetch?: Promise<BN>): Promise<BN>;
+}

package/dist/swaps/ISwapPrice.js

@@ -0,0 +1,73 @@
+"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.ISwapPrice = void 0;
+const BN = require("bn.js");
+class ISwapPrice {
+    constructor(coinsMap) {
+        this.coinsMap = coinsMap;
+    }
+    getTokenData(tokenAddress, chainId) {
+        const chainTokens = this.coinsMap[chainId];
+        if (chainTokens == null)
+            throw new Error("Chain not found");
+        const tokenAddr = tokenAddress.toString();
+        const coin = chainTokens[tokenAddr];
+        if (coin == null)
+            throw new Error("Token not found");
+        return coin;
+    }
+    preFetchPrice(token, chainId) {
+        const coin = this.getTokenData(token, chainId);
+        return this.getPrice(coin);
+    }
+    /**
+     * Returns amount of satoshis that are equivalent to {fromAmount} of {fromToken}
+     *
+     * @param fromAmount Amount of the token
+     * @param fromToken Token
+     * @param tokenChainIdentification Chain of the token
+     * @param roundUp Whether result should be rounded up
+     * @param preFetch Price pre-fetch promise returned from preFetchPrice()
+     */
+    getToBtcSwapAmount(fromAmount, fromToken, tokenChainIdentification, roundUp, preFetch) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const coin = this.getTokenData(fromToken, tokenChainIdentification);
+            const price = (preFetch == null ? null : yield preFetch) || (yield this.getPrice(coin));
+            return fromAmount
+                .mul(price)
+                .div(new BN(10).pow(new BN(coin.decimals)))
+                .add(roundUp ? new BN(999999) : new BN(0))
+                .div(new BN(1000000));
+        });
+    }
+    /**
+     * Returns amount of {toToken} that are equivalent to {fromAmount} satoshis
+     *
+     * @param fromAmount Amount of satoshis
+     * @param toToken Token
+     * @param tokenChainIdentification Chain of the token
+     * @param roundUp Whether result should be rounded up
+     * @param preFetch Price pre-fetch promise returned from preFetchPrice()
+     */
+    getFromBtcSwapAmount(fromAmount, toToken, tokenChainIdentification, roundUp, preFetch) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const coin = this.getTokenData(toToken, tokenChainIdentification);
+            const price = (preFetch == null ? null : yield preFetch) || (yield this.getPrice(coin));
+            return fromAmount
+                .mul(new BN(10).pow(new BN(coin.decimals)))
+                .mul(new BN(1000000)) //To usat
+                .add(roundUp ? price.sub(new BN(1)) : new BN(0))
+                .div(price);
+        });
+    }
+}
+exports.ISwapPrice = ISwapPrice;

package/dist/swaps/SwapHandler.d.ts

@@ -0,0 +1,186 @@
+import { Express, Request } from "express";
+import { ISwapPrice } from "./ISwapPrice";
+import { ChainType, ClaimEvent, InitializeEvent, RefundEvent, SwapData, SwapEvent } from "@atomiqlabs/base";
+import { AuthenticatedLnd } from "lightning";
+import { SwapHandlerSwap } from "./SwapHandlerSwap";
+import { IIntermediaryStorage } from "../storage/IIntermediaryStorage";
+import * as BN from "bn.js";
+import { ServerParamEncoder } from "../utils/paramcoders/server/ServerParamEncoder";
+import { IParamReader } from "../utils/paramcoders/IParamReader";
+export declare enum SwapHandlerType {
+    TO_BTC = "TO_BTC",
+    FROM_BTC = "FROM_BTC",
+    TO_BTCLN = "TO_BTCLN",
+    FROM_BTCLN = "FROM_BTCLN",
+    FROM_BTCLN_TRUSTED = "FROM_BTCLN_TRUSTED",
+    FROM_BTC_TRUSTED = "FROM_BTC_TRUSTED"
+}
+export type SwapHandlerInfoType = {
+    swapFeePPM: number;
+    swapBaseFee: number;
+    min: number;
+    max: number;
+    tokens: string[];
+    chainTokens: {
+        [chainId: string]: string[];
+    };
+    data?: any;
+};
+export type SwapBaseConfig = {
+    authorizationTimeout: number;
+    bitcoinBlocktime: BN;
+    baseFee: BN;
+    feePPM: BN;
+    max: BN;
+    min: BN;
+    maxSkew: number;
+    safetyFactor: BN;
+    swapCheckInterval: number;
+};
+export type MultichainData = {
+    chains: {
+        [identifier: string]: ChainData;
+    };
+    default: string;
+};
+export type ChainData<T extends ChainType = ChainType> = {
+    signer: T["Signer"];
+    swapContract: T["Contract"];
+    chainEvents: T["Events"];
+    allowedTokens: string[];
+    btcRelay?: T["BtcRelay"];
+};
+export type RequestData<T> = {
+    chainIdentifier: string;
+    raw: Request & {
+        paramReader: IParamReader;
+    };
+    parsed: T;
+    metadata: any;
+};
+/**
+ * An abstract class defining a singular swap service
+ */
+export declare abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S> = SwapHandlerSwap, S = any> {
+    abstract readonly type: SwapHandlerType;
+    readonly storageManager: IIntermediaryStorage<V>;
+    readonly path: string;
+    readonly chains: MultichainData;
+    readonly allowedTokens: {
+        [chainId: string]: Set<string>;
+    };
+    readonly swapPricing: ISwapPrice;
+    readonly LND: AuthenticatedLnd;
+    abstract config: SwapBaseConfig;
+    logger: {
+        debug: (msg: string, ...args: any) => void;
+        info: (msg: string, ...args: any) => void;
+        warn: (msg: string, ...args: any) => void;
+        error: (msg: string, ...args: any) => void;
+    };
+    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 constructor(storageDirectory: IIntermediaryStorage<V>, path: string, chainsData: MultichainData, lnd: AuthenticatedLnd, swapPricing: ISwapPrice);
+    protected getDefaultChain(): ChainData;
+    protected getChain(identifier: string): ChainData;
+    protected abstract processPastSwaps(): Promise<void>;
+    /**
+     * Starts the watchdog checking past swaps for expiry or claim eligibility.
+     */
+    startWatchdog(): Promise<void>;
+    protected abstract processInitializeEvent(chainIdentifier: string, event: InitializeEvent<SwapData>): Promise<void>;
+    protected abstract processClaimEvent(chainIdentifier: string, event: ClaimEvent<SwapData>): Promise<void>;
+    protected abstract processRefundEvent(chainIdentifier: string, event: RefundEvent<SwapData>): Promise<void>;
+    /**
+     * Chain event processor
+     *
+     * @param chainIdentifier
+     * @param eventData
+     */
+    protected processEvent(chainIdentifier: string, eventData: SwapEvent<SwapData>[]): Promise<boolean>;
+    /**
+     * Initializes chain events subscription
+     */
+    protected subscribeToEvents(): void;
+    /**
+     * Initializes swap handler, loads data and subscribes to chain events
+     */
+    abstract init(): Promise<void>;
+    /**
+     * Sets up required listeners for the REST server
+     *
+     * @param restServer
+     */
+    abstract startRestServer(restServer: Express): void;
+    /**
+     * Returns data to be returned in swap handler info
+     */
+    abstract getInfoData(): any;
+    /**
+     * Remove swap data
+     *
+     * @param hash
+     * @param sequence
+     */
+    protected removeSwapData(hash: string, sequence: BN): Promise<void>;
+    /**
+     * Remove swap data
+     *
+     * @param swap
+     * @param ultimateState set the ultimate state of the swap before removing
+     */
+    protected removeSwapData(swap: V, ultimateState?: S): Promise<void>;
+    /**
+     * Checks whether the bitcoin amount is within specified min/max bounds
+     *
+     * @param amount
+     * @protected
+     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
+     */
+    protected checkBtcAmountInBounds(amount: BN): void;
+    /**
+     * Handles and throws plugin errors
+     *
+     * @param res Response as returned from the PluginManager.onHandlePost{To,From}BtcQuote
+     * @protected
+     * @throws {DefinedRuntimeError} will throw an error if the response is an error
+     */
+    protected handlePluginErrorResponses(res: any): void;
+    /**
+     * Creates an abort controller that extends the responseStream's abort signal
+     *
+     * @param responseStream
+     */
+    protected getAbortController(responseStream: ServerParamEncoder): AbortController;
+    /**
+     * Starts a pre-fetch for signature data
+     *
+     * @param chainIdentifier
+     * @param abortController
+     * @param responseStream
+     */
+    protected getSignDataPrefetch(chainIdentifier: string, abortController: AbortController, responseStream?: ServerParamEncoder): Promise<any>;
+    protected getIdentifierFromEvent(event: SwapEvent<SwapData>): string;
+    protected getIdentifierFromSwapData(swapData: SwapData): string;
+    protected getIdentifier(swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData): string;
+    /**
+     * Checks if the sequence number is between 0-2^64
+     *
+     * @param sequence
+     * @throws {DefinedRuntimeError} will throw an error if sequence number is out of bounds
+     */
+    protected checkSequence(sequence: BN): void;
+    /**
+     * Checks whether a given token is supported on a specified chain
+     *
+     * @param chainId
+     * @param token
+     * @protected
+     */
+    protected isTokenSupported(chainId: string, token: string): boolean;
+    getInfo(): SwapHandlerInfoType;
+}

package/dist/swaps/SwapHandler.js

@@ -0,0 +1,292 @@
+"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.SwapHandler = exports.SwapHandlerType = void 0;
+const base_1 = require("@atomiqlabs/base");
+const SwapHandlerSwap_1 = require("./SwapHandlerSwap");
+const PluginManager_1 = require("../plugins/PluginManager");
+const BN = require("bn.js");
+const IPlugin_1 = require("../plugins/IPlugin");
+var SwapHandlerType;
+(function (SwapHandlerType) {
+    SwapHandlerType["TO_BTC"] = "TO_BTC";
+    SwapHandlerType["FROM_BTC"] = "FROM_BTC";
+    SwapHandlerType["TO_BTCLN"] = "TO_BTCLN";
+    SwapHandlerType["FROM_BTCLN"] = "FROM_BTCLN";
+    SwapHandlerType["FROM_BTCLN_TRUSTED"] = "FROM_BTCLN_TRUSTED";
+    SwapHandlerType["FROM_BTC_TRUSTED"] = "FROM_BTC_TRUSTED";
+})(SwapHandlerType = exports.SwapHandlerType || (exports.SwapHandlerType = {}));
+/**
+ * An abstract class defining a singular swap service
+ */
+class SwapHandler {
+    constructor(storageDirectory, path, chainsData, lnd, swapPricing) {
+        this.logger = {
+            debug: (msg, ...args) => console.debug("SwapHandler(" + this.type + "): " + msg, ...args),
+            info: (msg, ...args) => console.info("SwapHandler(" + this.type + "): " + msg, ...args),
+            warn: (msg, ...args) => console.warn("SwapHandler(" + this.type + "): " + msg, ...args),
+            error: (msg, ...args) => console.error("SwapHandler(" + this.type + "): " + msg, ...args)
+        };
+        this.swapLogger = {
+            debug: (swap, msg, ...args) => this.logger.debug(this.getIdentifier(swap) + ": " + msg, ...args),
+            info: (swap, msg, ...args) => this.logger.info(this.getIdentifier(swap) + ": " + msg, ...args),
+            warn: (swap, msg, ...args) => this.logger.warn(this.getIdentifier(swap) + ": " + msg, ...args),
+            error: (swap, msg, ...args) => this.logger.error(this.getIdentifier(swap) + ": " + msg, ...args)
+        };
+        this.storageManager = storageDirectory;
+        this.chains = chainsData;
+        if (this.chains.chains[this.chains.default] == null)
+            throw new Error("Invalid default chain specified");
+        this.path = path;
+        this.LND = lnd;
+        this.swapPricing = swapPricing;
+        this.allowedTokens = {};
+        for (let chainId in chainsData.chains) {
+            this.allowedTokens[chainId] = new Set(chainsData.chains[chainId].allowedTokens);
+        }
+    }
+    getDefaultChain() {
+        return this.chains.chains[this.chains.default];
+    }
+    getChain(identifier) {
+        if (this.chains.chains[identifier] == null)
+            throw {
+                code: 20200,
+                msg: "Invalid chain specified!"
+            };
+        return this.chains.chains[identifier];
+    }
+    /**
+     * Starts the watchdog checking past swaps for expiry or claim eligibility.
+     */
+    startWatchdog() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let rerun;
+            rerun = () => __awaiter(this, void 0, void 0, function* () {
+                yield this.processPastSwaps().catch(e => console.error(e));
+                setTimeout(rerun, this.config.swapCheckInterval);
+            });
+            yield rerun();
+        });
+    }
+    /**
+     * Chain event processor
+     *
+     * @param chainIdentifier
+     * @param eventData
+     */
+    processEvent(chainIdentifier, eventData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let event of eventData) {
+                if (event instanceof base_1.InitializeEvent) {
+                    // this.swapLogger.debug(event, "SC: InitializeEvent: swap type: "+event.swapType);
+                    yield this.processInitializeEvent(chainIdentifier, event);
+                }
+                else if (event instanceof base_1.ClaimEvent) {
+                    // this.swapLogger.debug(event, "SC: ClaimEvent: swap secret: "+event.secret);
+                    yield this.processClaimEvent(chainIdentifier, event);
+                }
+                else if (event instanceof base_1.RefundEvent) {
+                    // this.swapLogger.debug(event, "SC: RefundEvent");
+                    yield this.processRefundEvent(chainIdentifier, event);
+                }
+            }
+            return true;
+        });
+    }
+    /**
+     * Initializes chain events subscription
+     */
+    subscribeToEvents() {
+        for (let key in this.chains.chains) {
+            this.chains.chains[key].chainEvents.registerListener((events) => this.processEvent(key, events));
+        }
+        this.logger.info("SC: Events: subscribed to smartchain events");
+    }
+    removeSwapData(hashOrSwap, sequenceOrUltimateState) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let swap;
+            if (typeof (hashOrSwap) === "string") {
+                if (!BN.isBN(sequenceOrUltimateState))
+                    throw new Error("Sequence must be a BN instance!");
+                swap = yield this.storageManager.getData(hashOrSwap, sequenceOrUltimateState);
+            }
+            else {
+                swap = hashOrSwap;
+                if (sequenceOrUltimateState != null && !BN.isBN(sequenceOrUltimateState))
+                    yield swap.setState(sequenceOrUltimateState);
+            }
+            if (swap != null)
+                yield PluginManager_1.PluginManager.swapRemove(swap);
+            this.swapLogger.debug(swap, "removeSwapData(): removing swap final state: " + swap.state);
+            yield this.storageManager.removeData(swap.getHash(), swap.getSequence());
+        });
+    }
+    /**
+     * Checks whether the bitcoin amount is within specified min/max bounds
+     *
+     * @param amount
+     * @protected
+     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
+     */
+    checkBtcAmountInBounds(amount) {
+        if (amount.lt(this.config.min)) {
+            throw {
+                code: 20003,
+                msg: "Amount too low!",
+                data: {
+                    min: this.config.min.toString(10),
+                    max: this.config.max.toString(10)
+                }
+            };
+        }
+        if (amount.gt(this.config.max)) {
+            throw {
+                code: 20004,
+                msg: "Amount too high!",
+                data: {
+                    min: this.config.min.toString(10),
+                    max: this.config.max.toString(10)
+                }
+            };
+        }
+    }
+    /**
+     * Handles and throws plugin errors
+     *
+     * @param res Response as returned from the PluginManager.onHandlePost{To,From}BtcQuote
+     * @protected
+     * @throws {DefinedRuntimeError} will throw an error if the response is an error
+     */
+    handlePluginErrorResponses(res) {
+        if ((0, IPlugin_1.isQuoteThrow)(res))
+            throw {
+                code: 29999,
+                msg: res.message
+            };
+        if ((0, IPlugin_1.isQuoteAmountTooHigh)(res))
+            throw {
+                code: 20004,
+                msg: "Amount too high!",
+                data: {
+                    min: res.data.min.toString(10),
+                    max: res.data.max.toString(10)
+                }
+            };
+        if ((0, IPlugin_1.isQuoteAmountTooLow)(res))
+            throw {
+                code: 20003,
+                msg: "Amount too low!",
+                data: {
+                    min: res.data.min.toString(10),
+                    max: res.data.max.toString(10)
+                }
+            };
+    }
+    /**
+     * Creates an abort controller that extends the responseStream's abort signal
+     *
+     * @param responseStream
+     */
+    getAbortController(responseStream) {
+        const abortController = new AbortController();
+        const responseStreamAbortController = responseStream.getAbortSignal();
+        responseStreamAbortController.addEventListener("abort", () => abortController.abort(responseStreamAbortController.reason));
+        return abortController;
+    }
+    /**
+     * Starts a pre-fetch for signature data
+     *
+     * @param chainIdentifier
+     * @param abortController
+     * @param responseStream
+     */
+    getSignDataPrefetch(chainIdentifier, abortController, responseStream) {
+        const { swapContract } = this.getChain(chainIdentifier);
+        let signDataPrefetchPromise = swapContract.preFetchBlockDataForSignatures != null ? swapContract.preFetchBlockDataForSignatures().catch(e => {
+            this.logger.error("getSignDataPrefetch(): signDataPrefetch: ", e);
+            abortController.abort(e);
+            return null;
+        }) : null;
+        if (signDataPrefetchPromise != null && responseStream != null) {
+            signDataPrefetchPromise = signDataPrefetchPromise.then(val => val == null || abortController.signal.aborted ? null : responseStream.writeParams({
+                signDataPrefetch: val
+            }).then(() => val).catch(e => {
+                this.logger.error("getSignDataPrefetch(): signDataPreFetch: error when sending sign data to the client: ", e);
+                abortController.abort(e);
+                return null;
+            }));
+        }
+        return signDataPrefetchPromise;
+    }
+    getIdentifierFromEvent(event) {
+        if (event.sequence.isZero())
+            return event.paymentHash;
+        return event.paymentHash + "_" + event.sequence.toString(16);
+    }
+    getIdentifierFromSwapData(swapData) {
+        if (swapData.getSequence().isZero())
+            return swapData.getHash();
+        return swapData.getHash() + "_" + swapData.getSequence().toString(16);
+    }
+    getIdentifier(swap) {
+        if (swap instanceof SwapHandlerSwap_1.SwapHandlerSwap) {
+            return swap.getIdentifier();
+        }
+        if (swap instanceof base_1.SwapEvent) {
+            return this.getIdentifierFromEvent(swap);
+        }
+        return this.getIdentifierFromSwapData(swap);
+    }
+    /**
+     * Checks if the sequence number is between 0-2^64
+     *
+     * @param sequence
+     * @throws {DefinedRuntimeError} will throw an error if sequence number is out of bounds
+     */
+    checkSequence(sequence) {
+        if (sequence.isNeg() || sequence.gte(new BN(2).pow(new BN(64)))) {
+            throw {
+                code: 20060,
+                msg: "Invalid sequence"
+            };
+        }
+    }
+    /**
+     * Checks whether a given token is supported on a specified chain
+     *
+     * @param chainId
+     * @param token
+     * @protected
+     */
+    isTokenSupported(chainId, token) {
+        const chainTokens = this.allowedTokens[chainId];
+        if (chainTokens == null)
+            return false;
+        return chainTokens.has(token);
+    }
+    getInfo() {
+        const chainTokens = {};
+        for (let chainId in this.allowedTokens) {
+            chainTokens[chainId] = Array.from(this.allowedTokens[chainId]);
+        }
+        return {
+            swapFeePPM: this.config.feePPM.toNumber(),
+            swapBaseFee: this.config.baseFee.toNumber(),
+            min: this.config.min.toNumber(),
+            max: this.config.max.toNumber(),
+            data: this.getInfoData(),
+            tokens: Array.from(this.allowedTokens[this.chains.default]),
+            chainTokens
+        };
+    }
+}
+exports.SwapHandler = SwapHandler;