@atomiqlabs/lp-lib 13.0.0-beta.9 → 13.0.0

package/dist/swaps/SwapHandler.d.ts

@@ -1,156 +1,156 @@
-import { Express, Request } from "express";
-import { ISwapPrice } from "../prices/ISwapPrice";
-import { ChainType } from "@atomiqlabs/base";
-import { SwapHandlerSwap } from "./SwapHandlerSwap";
-import { IIntermediaryStorage } from "../storage/IIntermediaryStorage";
-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",
-    FROM_BTC_SPV = "FROM_BTC_SPV"
-}
-export type SwapHandlerInfoType = {
-    swapFeePPM: number;
-    swapBaseFee: number;
-    min: number;
-    max: number;
-    tokens: string[];
-    chainTokens: {
-        [chainId: string]: string[];
-    };
-    data?: any;
-};
-export type SwapBaseConfig = {
-    initAuthorizationTimeout: number;
-    initAuthorizationTimeouts?: {
-        [chainId: string]: number;
-    };
-    bitcoinBlocktime: bigint;
-    baseFee: bigint;
-    feePPM: bigint;
-    max: bigint;
-    min: bigint;
-    safetyFactor: bigint;
-    swapCheckInterval: number;
-};
-export type MultichainData = {
-    chains: {
-        [identifier: string]: ChainData;
-    };
-    default: string;
-};
-export type ChainData<T extends ChainType = ChainType> = {
-    signer: T["Signer"];
-    swapContract: T["Contract"];
-    spvVaultContract: T["SpvVaultContract"];
-    chainInterface: T["ChainInterface"];
-    chainEvents: T["Events"];
-    allowedTokens: string[];
-    tokenMultipliers?: {
-        [tokenAddress: string]: bigint;
-    };
-    allowedDepositTokens?: 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<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;
-    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, msg: string, ...args: any) => void;
-        info: (swap: SwapHandlerSwap, msg: string, ...args: any) => void;
-        warn: (swap: SwapHandlerSwap, msg: string, ...args: any) => void;
-        error: (swap: SwapHandlerSwap, msg: string, ...args: any) => void;
-    };
-    protected constructor(storageDirectory: IIntermediaryStorage<V>, path: string, chainsData: MultichainData, 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>;
-    /**
-     * Initializes swap handler, loads data and subscribes to chain events
-     */
-    abstract init(): Promise<void>;
-    protected loadData(ctor: new (data: any) => V): 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: bigint): 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>;
-    protected saveSwapData(swap: V): Promise<void>;
-    /**
-     * Checks if we have enough balance of the token in the swap vault
-     *
-     * @param totalInToken
-     * @param balancePrefetch
-     * @param signal
-     * @throws {DefinedRuntimeError} will throw an error if there are not enough funds in the vault
-     */
-    protected checkBalance(totalInToken: bigint, balancePrefetch: Promise<bigint>, signal: AbortSignal | null): Promise<void>;
-    /**
-     * 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: bigint): 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;
-    protected getInitAuthorizationTimeout(chainIdentifier: string): number;
-}
+import { Express, Request } from "express";
+import { ISwapPrice } from "../prices/ISwapPrice";
+import { ChainType } from "@atomiqlabs/base";
+import { SwapHandlerSwap } from "./SwapHandlerSwap";
+import { IIntermediaryStorage } from "../storage/IIntermediaryStorage";
+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",
+    FROM_BTC_SPV = "FROM_BTC_SPV"
+}
+export type SwapHandlerInfoType = {
+    swapFeePPM: number;
+    swapBaseFee: number;
+    min: number;
+    max: number;
+    tokens: string[];
+    chainTokens: {
+        [chainId: string]: string[];
+    };
+    data?: any;
+};
+export type SwapBaseConfig = {
+    initAuthorizationTimeout: number;
+    initAuthorizationTimeouts?: {
+        [chainId: string]: number;
+    };
+    bitcoinBlocktime: bigint;
+    baseFee: bigint;
+    feePPM: bigint;
+    max: bigint;
+    min: bigint;
+    safetyFactor: bigint;
+    swapCheckInterval: number;
+};
+export type MultichainData = {
+    chains: {
+        [identifier: string]: ChainData;
+    };
+    default: string;
+};
+export type ChainData<T extends ChainType = ChainType> = {
+    signer: T["Signer"];
+    swapContract: T["Contract"];
+    spvVaultContract: T["SpvVaultContract"];
+    chainInterface: T["ChainInterface"];
+    chainEvents: T["Events"];
+    allowedTokens: string[];
+    tokenMultipliers?: {
+        [tokenAddress: string]: bigint;
+    };
+    allowedDepositTokens?: 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<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;
+    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, msg: string, ...args: any) => void;
+        info: (swap: SwapHandlerSwap, msg: string, ...args: any) => void;
+        warn: (swap: SwapHandlerSwap, msg: string, ...args: any) => void;
+        error: (swap: SwapHandlerSwap, msg: string, ...args: any) => void;
+    };
+    protected constructor(storageDirectory: IIntermediaryStorage<V>, path: string, chainsData: MultichainData, 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>;
+    /**
+     * Initializes swap handler, loads data and subscribes to chain events
+     */
+    abstract init(): Promise<void>;
+    protected loadData(ctor: new (data: any) => V): 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: bigint): 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>;
+    protected saveSwapData(swap: V): Promise<void>;
+    /**
+     * Checks if we have enough balance of the token in the swap vault
+     *
+     * @param totalInToken
+     * @param balancePrefetch
+     * @param signal
+     * @throws {DefinedRuntimeError} will throw an error if there are not enough funds in the vault
+     */
+    protected checkBalance(totalInToken: bigint, balancePrefetch: Promise<bigint>, signal: AbortSignal | null): Promise<void>;
+    /**
+     * 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: bigint): 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;
+    protected getInitAuthorizationTimeout(chainIdentifier: string): number;
+}

package/dist/swaps/SwapHandler.js

@@ -1,163 +1,163 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SwapHandler = exports.SwapHandlerType = void 0;
-const PluginManager_1 = require("../plugins/PluginManager");
-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["FROM_BTC_SPV"] = "FROM_BTC_SPV";
-})(SwapHandlerType = exports.SwapHandlerType || (exports.SwapHandlerType = {}));
-/**
- * An abstract class defining a singular swap service
- */
-class SwapHandler {
-    constructor(storageDirectory, path, chainsData, 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(swap.getIdentifier() + ": " + msg, ...args),
-            info: (swap, msg, ...args) => this.logger.info(swap.getIdentifier() + ": " + msg, ...args),
-            warn: (swap, msg, ...args) => this.logger.warn(swap.getIdentifier() + ": " + msg, ...args),
-            error: (swap, msg, ...args) => this.logger.error(swap.getIdentifier() + ": " + 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.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.
-     */
-    async startWatchdog() {
-        let rerun;
-        rerun = async () => {
-            await this.processPastSwaps().catch(e => console.error(e));
-            setTimeout(rerun, this.config.swapCheckInterval);
-        };
-        await rerun();
-    }
-    async loadData(ctor) {
-        await this.storageManager.loadData(ctor);
-        //Check if all swaps contain a valid amount
-        for (let { obj: swap, hash, sequence } of await this.storageManager.query([])) {
-            if (hash !== swap.getIdentifierHash() || sequence !== (swap.getSequence() ?? 0n)) {
-                this.swapLogger.info(swap, "loadData(): Swap storage key or sequence mismatch, fixing," +
-                    " old hash: " + hash + " new hash: " + swap.getIdentifierHash() +
-                    " old seq: " + sequence.toString(10) + " new seq: " + (swap.getSequence() ?? 0n).toString(10));
-                await this.storageManager.removeData(hash, sequence);
-                await this.storageManager.saveData(swap.getIdentifierHash(), swap.getSequence(), swap);
-            }
-        }
-    }
-    async removeSwapData(hashOrSwap, sequenceOrUltimateState) {
-        let swap;
-        if (typeof (hashOrSwap) === "string") {
-            if (typeof (sequenceOrUltimateState) !== "bigint")
-                throw new Error("Sequence must be a BN instance!");
-            swap = await this.storageManager.getData(hashOrSwap, sequenceOrUltimateState);
-        }
-        else {
-            swap = hashOrSwap;
-            if (sequenceOrUltimateState != null && typeof (sequenceOrUltimateState) !== "bigint")
-                await swap.setState(sequenceOrUltimateState);
-        }
-        if (swap != null)
-            await PluginManager_1.PluginManager.swapRemove(swap);
-        this.swapLogger.debug(swap, "removeSwapData(): removing swap final state: " + swap.state);
-        await this.storageManager.removeData(swap.getIdentifierHash(), swap.getSequence());
-    }
-    async saveSwapData(swap) {
-        await this.storageManager.saveData(swap.getIdentifierHash(), swap.getSequence(), swap);
-    }
-    /**
-     * Checks if we have enough balance of the token in the swap vault
-     *
-     * @param totalInToken
-     * @param balancePrefetch
-     * @param signal
-     * @throws {DefinedRuntimeError} will throw an error if there are not enough funds in the vault
-     */
-    async checkBalance(totalInToken, balancePrefetch, signal) {
-        const balance = await balancePrefetch;
-        if (signal != null)
-            signal.throwIfAborted();
-        if (balance == null || balance < totalInToken) {
-            throw {
-                code: 20002,
-                msg: "Not enough liquidity"
-            };
-        }
-    }
-    /**
-     * 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 < 0n || sequence >= 2n ** 64n) {
-            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: Number(this.config.feePPM),
-            swapBaseFee: Number(this.config.baseFee),
-            min: Number(this.config.min),
-            max: Number(this.config.max),
-            data: this.getInfoData(),
-            tokens: Array.from(this.allowedTokens[this.chains.default]),
-            chainTokens
-        };
-    }
-    getInitAuthorizationTimeout(chainIdentifier) {
-        return this.config.initAuthorizationTimeouts?.[chainIdentifier] ?? this.config.initAuthorizationTimeout;
-    }
-}
-exports.SwapHandler = SwapHandler;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapHandler = exports.SwapHandlerType = void 0;
+const PluginManager_1 = require("../plugins/PluginManager");
+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["FROM_BTC_SPV"] = "FROM_BTC_SPV";
+})(SwapHandlerType = exports.SwapHandlerType || (exports.SwapHandlerType = {}));
+/**
+ * An abstract class defining a singular swap service
+ */
+class SwapHandler {
+    constructor(storageDirectory, path, chainsData, 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(swap.getIdentifier() + ": " + msg, ...args),
+            info: (swap, msg, ...args) => this.logger.info(swap.getIdentifier() + ": " + msg, ...args),
+            warn: (swap, msg, ...args) => this.logger.warn(swap.getIdentifier() + ": " + msg, ...args),
+            error: (swap, msg, ...args) => this.logger.error(swap.getIdentifier() + ": " + 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.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.
+     */
+    async startWatchdog() {
+        let rerun;
+        rerun = async () => {
+            await this.processPastSwaps().catch(e => console.error(e));
+            setTimeout(rerun, this.config.swapCheckInterval);
+        };
+        await rerun();
+    }
+    async loadData(ctor) {
+        await this.storageManager.loadData(ctor);
+        //Check if all swaps contain a valid amount
+        for (let { obj: swap, hash, sequence } of await this.storageManager.query([])) {
+            if (hash !== swap.getIdentifierHash() || sequence !== (swap.getSequence() ?? 0n)) {
+                this.swapLogger.info(swap, "loadData(): Swap storage key or sequence mismatch, fixing," +
+                    " old hash: " + hash + " new hash: " + swap.getIdentifierHash() +
+                    " old seq: " + sequence.toString(10) + " new seq: " + (swap.getSequence() ?? 0n).toString(10));
+                await this.storageManager.removeData(hash, sequence);
+                await this.storageManager.saveData(swap.getIdentifierHash(), swap.getSequence(), swap);
+            }
+        }
+    }
+    async removeSwapData(hashOrSwap, sequenceOrUltimateState) {
+        let swap;
+        if (typeof (hashOrSwap) === "string") {
+            if (typeof (sequenceOrUltimateState) !== "bigint")
+                throw new Error("Sequence must be a BN instance!");
+            swap = await this.storageManager.getData(hashOrSwap, sequenceOrUltimateState);
+        }
+        else {
+            swap = hashOrSwap;
+            if (sequenceOrUltimateState != null && typeof (sequenceOrUltimateState) !== "bigint")
+                await swap.setState(sequenceOrUltimateState);
+        }
+        if (swap != null)
+            await PluginManager_1.PluginManager.swapRemove(swap);
+        this.swapLogger.debug(swap, "removeSwapData(): removing swap final state: " + swap.state);
+        await this.storageManager.removeData(swap.getIdentifierHash(), swap.getSequence());
+    }
+    async saveSwapData(swap) {
+        await this.storageManager.saveData(swap.getIdentifierHash(), swap.getSequence(), swap);
+    }
+    /**
+     * Checks if we have enough balance of the token in the swap vault
+     *
+     * @param totalInToken
+     * @param balancePrefetch
+     * @param signal
+     * @throws {DefinedRuntimeError} will throw an error if there are not enough funds in the vault
+     */
+    async checkBalance(totalInToken, balancePrefetch, signal) {
+        const balance = await balancePrefetch;
+        if (signal != null)
+            signal.throwIfAborted();
+        if (balance == null || balance < totalInToken) {
+            throw {
+                code: 20002,
+                msg: "Not enough liquidity"
+            };
+        }
+    }
+    /**
+     * 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 < 0n || sequence >= 2n ** 64n) {
+            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: Number(this.config.feePPM),
+            swapBaseFee: Number(this.config.baseFee),
+            min: Number(this.config.min),
+            max: Number(this.config.max),
+            data: this.getInfoData(),
+            tokens: Array.from(this.allowedTokens[this.chains.default]),
+            chainTokens
+        };
+    }
+    getInitAuthorizationTimeout(chainIdentifier) {
+        return this.config.initAuthorizationTimeouts?.[chainIdentifier] ?? this.config.initAuthorizationTimeout;
+    }
+}
+exports.SwapHandler = SwapHandler;