@paraswap/dex-lib 2.37.8-dexalot → 2.38.0

package/build/dex/dexalot/dexalot.js

@@ -1,642 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Dexalot = void 0;
-const constants_1 = require("../../constants");
-const CALLDATA_GAS_COST = __importStar(require("../../calldata-gas-cost"));
-const utils_1 = require("../../utils");
-const types_1 = require("./types");
-const types_2 = require("../generic-rfq/types");
-const simple_exchange_1 = require("../simple-exchange");
-const config_1 = require("./config");
-const rate_fetcher_1 = require("./rate-fetcher");
-const DexalotMainnetRFQ_json_1 = __importDefault(require("../../abi/dexalot/DexalotMainnetRFQ.json"));
-const utils_2 = require("ethers/lib/utils");
-const ts_essentials_1 = require("ts-essentials");
-const constants_2 = require("./constants");
-const bigint_constants_1 = require("../../bigint-constants");
-const ethers_1 = require("ethers");
-const bignumber_js_1 = __importDefault(require("bignumber.js"));
-class Dexalot extends simple_exchange_1.SimpleExchange {
-    constructor(network, dexKey, dexHelper, adapters = config_1.Adapters[network] || {}, mainnetRFQAddress = config_1.DexalotConfig['Dexalot'][network]
-        .mainnetRFQAddress, rfqInterface = new utils_2.Interface(DexalotMainnetRFQ_json_1.default)) {
-        super(dexHelper, dexKey);
-        this.network = network;
-        this.dexKey = dexKey;
-        this.dexHelper = dexHelper;
-        this.adapters = adapters;
-        this.mainnetRFQAddress = mainnetRFQAddress;
-        this.rfqInterface = rfqInterface;
-        this.isStatePollingDex = true;
-        this.hasConstantPriceLargeAmounts = false;
-        this.needWrapNative = false;
-        this.isFeeOnTransferSupported = false;
-        this.tokensMap = {};
-        this.logger = dexHelper.getLogger(dexKey);
-        const authToken = dexHelper.config.data.dexalotAuthToken;
-        (0, ts_essentials_1.assert)(authToken !== undefined, 'Dexalot auth token is not specified with env variable');
-        this.dexalotAuthToken = authToken;
-        this.pricesCacheKey = 'prices';
-        this.pairsCacheKey = 'pairs';
-        this.tokensAddrCacheKey = 'tokens_addr';
-        this.tokensCacheKey = 'tokens';
-        this.blacklistCacheKey = 'blacklist';
-        this.rateFetcher = new rate_fetcher_1.RateFetcher(this.dexHelper, this.dexKey, this.network, this.logger, {
-            rateConfig: {
-                pairsIntervalMs: constants_2.DEXALOT_API_PAIRS_POLLING_INTERVAL_MS,
-                pricesIntervalMs: constants_2.DEXALOT_API_PRICES_POLLING_INTERVAL_MS,
-                blacklistIntervalMs: constants_2.DEXALOT_API_BLACKLIST_POLLING_INTERVAL_MS,
-                pairsReqParams: this.getAPIReqParams('api/rfq/pairs', 'GET'),
-                pricesReqParams: this.getAPIReqParams('api/rfq/prices', 'GET'),
-                blacklistReqParams: this.getAPIReqParams('api/rfq/blacklist', 'GET'),
-                pairsCacheKey: this.pairsCacheKey,
-                pairsCacheTTLSecs: constants_2.DEXALOT_PAIRS_CACHES_TTL_S,
-                pricesCacheKey: this.pricesCacheKey,
-                pricesCacheTTLSecs: constants_2.DEXALOT_PRICES_CACHES_TTL_S,
-                tokensAddrCacheKey: this.tokensAddrCacheKey,
-                tokensCacheKey: this.tokensCacheKey,
-                tokensCacheTTLSecs: constants_2.DEXALOT_TOKENS_CACHES_TTL_S,
-                blacklistCacheKey: this.blacklistCacheKey,
-                blacklistCacheTTLSecs: constants_2.DEXALOT_BLACKLIST_CACHES_TTL_S,
-            },
-        });
-    }
-    async initializePricing(blockNumber) {
-        if (!this.dexHelper.config.isSlave) {
-            this.rateFetcher.start();
-        }
-        return;
-    }
-    getAdapters(side) {
-        return this.adapters[side] ? this.adapters[side] : null;
-    }
-    getPairString(baseToken, quoteToken) {
-        return `${baseToken.symbol}/${quoteToken.symbol}`.toLowerCase();
-    }
-    async getPairData(srcToken, destToken) {
-        const normalizedSrcToken = this.normalizeToken(srcToken);
-        const normalizedDestToken = this.normalizeToken(destToken);
-        if (normalizedSrcToken.address === normalizedDestToken.address) {
-            return null;
-        }
-        const cachedTokens = (await this.getCachedTokens()) || {};
-        if (!(normalizedSrcToken.address in cachedTokens) ||
-            !(normalizedDestToken.address in cachedTokens)) {
-            return null;
-        }
-        normalizedSrcToken.symbol = cachedTokens[normalizedSrcToken.address].symbol;
-        normalizedDestToken.symbol =
-            cachedTokens[normalizedDestToken.address].symbol;
-        const cachedPairs = (await this.getCachedPairs()) || {};
-        const potentialPairs = [
-            {
-                identifier: this.getPairString(normalizedSrcToken, normalizedDestToken),
-                isSrcBase: true,
-            },
-            {
-                identifier: this.getPairString(normalizedDestToken, normalizedSrcToken),
-                isSrcBase: false,
-            },
-        ];
-        for (const pair of potentialPairs) {
-            if (pair.identifier in cachedPairs) {
-                const pairData = cachedPairs[pair.identifier];
-                pairData.isSrcBase = pair.isSrcBase;
-                return pairData;
-            }
-        }
-        return null;
-    }
-    getIdentifier(srcAddress, destAddress) {
-        const sortedAddresses = srcAddress < destAddress
-            ? [srcAddress, destAddress]
-            : [destAddress, srcAddress];
-        return `${this.dexKey}_${sortedAddresses[0].toLowerCase()}_${sortedAddresses[1].toLowerCase()}`;
-    }
-    async getPoolIdentifiers(srcToken, destToken, side, blockNumber) {
-        if (!srcToken || !destToken) {
-            return [];
-        }
-        const pairData = await this.getPairData(srcToken, destToken);
-        if (!pairData) {
-            return [];
-        }
-        const tokensAddr = (await this.getCachedTokensAddr()) || {};
-        return [this.getIdentifier(tokensAddr[pairData.base.toLowerCase()], tokensAddr[pairData.quote.toLowerCase()])];
-    }
-    async getCachedPairs() {
-        const cachedPairs = await this.dexHelper.cache.get(this.dexKey, this.network, this.pairsCacheKey);
-        if (cachedPairs) {
-            return JSON.parse(cachedPairs);
-        }
-        return null;
-    }
-    async getCachedPrices() {
-        const cachedPrices = await this.dexHelper.cache.get(this.dexKey, this.network, this.pricesCacheKey);
-        if (cachedPrices) {
-            return JSON.parse(cachedPrices);
-        }
-        return null;
-    }
-    async getCachedTokensAddr() {
-        const cachedTokensAddr = await this.dexHelper.cache.get(this.dexKey, this.network, this.tokensAddrCacheKey);
-        if (cachedTokensAddr) {
-            return JSON.parse(cachedTokensAddr);
-        }
-        return null;
-    }
-    async getCachedTokens() {
-        const cachedTokens = await this.dexHelper.cache.get(this.dexKey, this.network, this.tokensCacheKey);
-        if (cachedTokens) {
-            return JSON.parse(cachedTokens);
-        }
-        return null;
-    }
-    normalizeAddress(address) {
-        return address.toLowerCase() === constants_1.ETHER_ADDRESS
-            ? constants_1.NULL_ADDRESS
-            : address.toLowerCase();
-    }
-    denormalizeAddress(address) {
-        return address.toLowerCase() === constants_1.NULL_ADDRESS
-            ? constants_1.ETHER_ADDRESS
-            : address.toLowerCase();
-    }
-    // Dexalot protocol for native token expects 0x00000... instead of 0xeeeee...
-    normalizeToken(token) {
-        return {
-            address: this.normalizeAddress(token.address),
-            decimals: token.decimals,
-        };
-    }
-    denormalizeToken(token) {
-        return {
-            address: this.denormalizeAddress(token.address),
-            decimals: token.decimals,
-        };
-    }
-    calculateOrderPrice(amounts, orderbook, baseToken, quoteToken, side) {
-        let result = [];
-        for (let i = 0; i < amounts.length; i++) {
-            let amt = amounts[i];
-            if (amt === 0n) {
-                result.push(amt);
-                continue;
-            }
-            let left = 0, right = orderbook.length;
-            let qty = BigInt(0);
-            while (left < right) {
-                let mid = Math.floor((left + right) / 2);
-                qty = BigInt(ethers_1.ethers.utils
-                    .parseUnits(orderbook[mid][1], quoteToken.decimals)
-                    .toString());
-                if (side === types_1.ClobSide.ASK) {
-                    const price = BigInt(ethers_1.ethers.utils
-                        .parseUnits(orderbook[mid][0], baseToken.decimals)
-                        .toString());
-                    qty =
-                        (qty * BigInt(10 ** (baseToken.decimals * 2))) /
-                            (price * BigInt(10 ** quoteToken.decimals));
-                }
-                if (qty <= amt) {
-                    left = mid + 1;
-                }
-                else {
-                    right = mid;
-                }
-            }
-            let price, amount = BigInt(0);
-            if (left === orderbook.length) {
-                price = BigInt(ethers_1.ethers.utils
-                    .parseUnits(orderbook[left - 1][0], baseToken.decimals)
-                    .toString());
-                amount = qty;
-            }
-            else if (amounts[i] === qty) {
-                price = BigInt(ethers_1.ethers.utils
-                    .parseUnits(orderbook[left][0], baseToken.decimals)
-                    .toString());
-                amount = amounts[i];
-            }
-            else {
-                const lPrice = BigInt(ethers_1.ethers.utils
-                    .parseUnits(orderbook[left][0], baseToken.decimals)
-                    .toString());
-                const rPrice = BigInt(ethers_1.ethers.utils
-                    .parseUnits(orderbook[left + 1][0], baseToken.decimals)
-                    .toString());
-                const lQty = qty;
-                let rQty = BigInt(ethers_1.ethers.utils
-                    .parseUnits(orderbook[left + 1][1], quoteToken.decimals)
-                    .toString());
-                if (side === types_1.ClobSide.ASK) {
-                    rQty = (rQty * rPrice) / BigInt(10 ** quoteToken.decimals);
-                }
-                price = lPrice + ((rPrice - lPrice) * (amt - lQty)) / (rQty - lQty);
-                amount = amounts[i];
-            }
-            if (side === types_1.ClobSide.BID) {
-                result.push((amount * BigInt(10 ** (baseToken.decimals * 2))) /
-                    (price * BigInt(10 ** quoteToken.decimals)));
-            }
-            else {
-                result.push((price * amount * BigInt(10 ** quoteToken.decimals)) /
-                    BigInt(10 ** (baseToken.decimals * 2)));
-            }
-        }
-        return result;
-    }
-    async getPricesVolume(srcToken, destToken, amounts, side, blockNumber, limitPools, transferFees) {
-        try {
-            if (await this.isRestricted()) {
-                return null;
-            }
-            const normalizedSrcToken = this.normalizeToken(srcToken);
-            const normalizedDestToken = this.normalizeToken(destToken);
-            this.tokensMap = (await this.getCachedTokens()) || {};
-            if (normalizedSrcToken.address === normalizedDestToken.address) {
-                return null;
-            }
-            const pools = limitPools
-                ? limitPools.filter(p => p ===
-                    this.getIdentifier(normalizedSrcToken.address, normalizedDestToken.address))
-                : await this.getPoolIdentifiers(srcToken, destToken, side, blockNumber);
-            if (pools.length === 0) {
-                return null;
-            }
-            const pairData = await this.getPairData(normalizedSrcToken, normalizedDestToken);
-            if (!pairData) {
-                return null;
-            }
-            const priceMap = await this.getCachedPrices();
-            if (!priceMap) {
-                return null;
-            }
-            const tokensAddr = (await this.getCachedTokensAddr()) || {};
-            const pairKey = `${pairData.base}/${pairData.quote}`.toLowerCase();
-            if (!(pairKey in priceMap)
-                || !pools.includes(this.getIdentifier(tokensAddr[pairData.base.toLowerCase()], tokensAddr[pairData.quote.toLowerCase()]))) {
-                return null;
-            }
-            const priceData = priceMap[pairKey];
-            const baseToken = pairData.isSrcBase
-                ? normalizedSrcToken
-                : normalizedDestToken;
-            const quoteToken = pairData.isSrcBase
-                ? normalizedDestToken
-                : normalizedSrcToken;
-            // convert from swap to clob side
-            let orderbook = priceData.asks;
-            let clobSide = types_1.ClobSide.BID;
-            if ((side === constants_1.SwapSide.SELL && pairData.isSrcBase) ||
-                (side === constants_1.SwapSide.BUY && !pairData.isSrcBase)) {
-                orderbook = priceData.bids;
-                clobSide = types_1.ClobSide.ASK;
-            }
-            if (orderbook.length === 0) {
-                throw new Error(`Empty orderbook for ${pairKey}`);
-            }
-            const prices = this.calculateOrderPrice(amounts, orderbook, baseToken, quoteToken, clobSide);
-            const outDecimals = clobSide === types_1.ClobSide.BID ? baseToken.decimals : quoteToken.decimals;
-            const poolIdentifier = this.getIdentifier(pairData.base, pairData.quote);
-            return [
-                {
-                    prices,
-                    unit: BigInt(outDecimals),
-                    data: {},
-                    poolIdentifier: poolIdentifier,
-                    exchange: this.dexKey,
-                    gasCost: constants_2.DEXALOT_GAS_COST,
-                    poolAddresses: [this.mainnetRFQAddress],
-                },
-            ];
-        }
-        catch (e) {
-            this.logger.error(`Error_getPricesVolume ${srcToken.address || srcToken.symbol}, ${destToken.address || destToken.symbol}, ${side}:`, e);
-            return null;
-        }
-    }
-    generateRFQError(errorStr, swapIdentifier) {
-        const message = `${this.dexKey}-${this.network}: Failed to fetch RFQ for ${swapIdentifier}. ${errorStr}`;
-        this.logger.warn(message);
-        throw new types_1.DexalotRfqError(message);
-    }
-    async preProcessTransaction(optimalSwapExchange, srcToken, destToken, side, options) {
-        if (await this.isBlacklisted(options.txOrigin)) {
-            this.logger.warn(`${this.dexKey}-${this.network}: blacklisted TX Origin address '${options.txOrigin}' trying to build a transaction. Bailing...`);
-            throw new Error(`${this.dexKey}-${this.network}: user=${options.txOrigin.toLowerCase()} is blacklisted`);
-        }
-        if (BigInt(optimalSwapExchange.srcAmount) === 0n) {
-            throw new Error('getFirmRate failed with srcAmount === 0');
-        }
-        const normalizedSrcToken = this.normalizeToken(srcToken);
-        const normalizedDestToken = this.normalizeToken(destToken);
-        const swapIdentifier = `${this.getIdentifier(normalizedSrcToken.address, normalizedDestToken.address)}_${side}`;
-        try {
-            const makerToken = normalizedDestToken;
-            const takerToken = normalizedSrcToken;
-            const rfqParams = {
-                makerAsset: ethers_1.ethers.utils.getAddress(makerToken.address),
-                takerAsset: ethers_1.ethers.utils.getAddress(takerToken.address),
-                makerAmount: side === constants_1.SwapSide.BUY ? optimalSwapExchange.destAmount : undefined,
-                takerAmount: side === constants_1.SwapSide.SELL ? optimalSwapExchange.srcAmount : undefined,
-                userAddress: options.txOrigin,
-                chainid: this.network,
-            };
-            const rfq = await this.dexHelper.httpRequest.post(`${constants_2.DEXALOT_API_URL}/api/rfq/firm`, rfqParams, undefined, { 'x-apikey': this.dexalotAuthToken });
-            if (!rfq) {
-                this.generateRFQError('Missing quote data', `RFQ ${swapIdentifier} ${JSON.stringify(rfq)}`);
-            }
-            else if (!rfq.signature) {
-                this.generateRFQError('Missing signature', swapIdentifier);
-            }
-            rfq.order.signature = rfq.signature;
-            const { order } = rfq;
-            (0, ts_essentials_1.assert)(order.makerAsset.toLowerCase() === makerToken.address, `QuoteData makerAsset=${order.makerAsset} is different from Paraswap makerAsset=${makerToken.address}`);
-            (0, ts_essentials_1.assert)(order.takerAsset.toLowerCase() === takerToken.address, `QuoteData takerAsset=${order.takerAsset} is different from Paraswap takerAsset=${takerToken.address}`);
-            if (side === constants_1.SwapSide.SELL) {
-                (0, ts_essentials_1.assert)(order.takerAmount === optimalSwapExchange.srcAmount, `QuoteData takerAmount=${order.takerAmount} is different from Paraswap srcAmount=${optimalSwapExchange.srcAmount}`);
-            }
-            else {
-                (0, ts_essentials_1.assert)(order.makerAmount === optimalSwapExchange.destAmount, `QuoteData makerAmount=${order.makerAmount} is different from Paraswap destAmount=${optimalSwapExchange.destAmount}`);
-            }
-            const expiryAsBigInt = BigInt(order.expiry);
-            const minDeadline = expiryAsBigInt > 0 ? expiryAsBigInt : bigint_constants_1.BI_MAX_UINT256;
-            const slippageFactor = options.slippageFactor;
-            let isFailOnSlippage = false;
-            let slippageErrorMessage = '';
-            if (side === constants_1.SwapSide.SELL) {
-                if (BigInt(order.makerAmount) <
-                    BigInt(new bignumber_js_1.default(optimalSwapExchange.destAmount.toString())
-                        .times(slippageFactor)
-                        .toFixed(0))) {
-                    isFailOnSlippage = true;
-                    const message = `${this.dexKey}-${this.network}: too much slippage on quote ${side} quoteTokenAmount ${order.makerAmount} / destAmount ${optimalSwapExchange.destAmount} < ${slippageFactor}`;
-                    slippageErrorMessage = message;
-                    this.logger.warn(message);
-                }
-            }
-            else {
-                if (BigInt(order.takerAmount) >
-                    BigInt(slippageFactor.times(optimalSwapExchange.srcAmount.toString()).toFixed(0))) {
-                    isFailOnSlippage = true;
-                    const message = `${this.dexKey}-${this.network}: too much slippage on quote ${side} baseTokenAmount ${order.takerAmount} / srcAmount ${optimalSwapExchange.srcAmount} > ${slippageFactor.toFixed()}`;
-                    slippageErrorMessage = message;
-                    this.logger.warn(message);
-                }
-            }
-            let isTooStrictSlippage = false;
-            if (isFailOnSlippage &&
-                side === constants_1.SwapSide.SELL &&
-                new bignumber_js_1.default(1)
-                    .minus(slippageFactor)
-                    .lt(constants_2.DEXALOT_MIN_SLIPPAGE_FACTOR_THRESHOLD_FOR_RESTRICTION)) {
-                isTooStrictSlippage = true;
-            }
-            else if (isFailOnSlippage &&
-                side === constants_1.SwapSide.BUY &&
-                slippageFactor
-                    .minus(1)
-                    .lt(constants_2.DEXALOT_MIN_SLIPPAGE_FACTOR_THRESHOLD_FOR_RESTRICTION)) {
-                isTooStrictSlippage = true;
-            }
-            if (isFailOnSlippage && isTooStrictSlippage) {
-                throw new types_2.TooStrictSlippageCheckError(slippageErrorMessage);
-            }
-            else if (isFailOnSlippage && !isTooStrictSlippage) {
-                throw new types_2.SlippageCheckError(slippageErrorMessage);
-            }
-            return [
-                {
-                    ...optimalSwapExchange,
-                    data: {
-                        quoteData: order,
-                    },
-                },
-                { deadline: minDeadline },
-            ];
-        }
-        catch (e) {
-            if ((0, utils_1.isAxiosError)(e) && e.response && e.response.data) {
-                const errorData = e.response.data;
-                if (errorData.ReasonCode === 'FQ-009') {
-                    this.logger.warn(`${this.dexKey}-${this.network}: Encountered rate limited user=${options.txOrigin}. Adding to local rate limit cache`);
-                    await this.setRateLimited(options.txOrigin, errorData.RetryAfter);
-                }
-                else {
-                    await this.setBlacklist(options.txOrigin);
-                    this.logger.error(`${this.dexKey}-${this.network}: Failed to fetch RFQ for ${swapIdentifier}: ${errorData.Reason}`);
-                }
-            }
-            else {
-                if (e instanceof types_2.TooStrictSlippageCheckError) {
-                    this.logger.warn(`${this.dexKey}-${this.network}: failed to build transaction on side ${side} with too strict slippage. Skipping restriction`);
-                }
-                else {
-                    this.logger.warn(`${this.dexKey}-${this.network}: protocol is restricted`);
-                    await this.restrict();
-                }
-            }
-            throw e;
-        }
-    }
-    getCalldataGasCost(poolPrices) {
-        return (CALLDATA_GAS_COST.DEX_OVERHEAD +
-            // addresses: makerAsset, takerAsset, maker, taker
-            CALLDATA_GAS_COST.ADDRESS * 4 +
-            // uint256: expiry
-            CALLDATA_GAS_COST.wordNonZeroBytes(16) +
-            // uint256: nonceAndMeta, makerAmount, takerAmount
-            CALLDATA_GAS_COST.AMOUNT * 3 +
-            // bytes: _signature (65 bytes)
-            CALLDATA_GAS_COST.FULL_WORD * 2 +
-            CALLDATA_GAS_COST.OFFSET_SMALL);
-    }
-    getTokenFromAddress(address) {
-        return this.tokensMap[this.normalizeAddress(address)];
-    }
-    getAdapterParam(srcToken, destToken, srcAmount, destAmount, data, side) {
-        const { quoteData } = data;
-        (0, ts_essentials_1.assert)(quoteData !== undefined, `${this.dexKey}-${this.network}: quoteData undefined`);
-        const params = [
-            {
-                nonceAndMeta: quoteData.nonceAndMeta,
-                expiry: quoteData.expiry,
-                makerAsset: quoteData.makerAsset,
-                takerAsset: quoteData.takerAsset,
-                maker: quoteData.maker,
-                taker: quoteData.taker,
-                makerAmount: quoteData.makerAmount,
-                takerAmount: quoteData.takerAmount,
-            },
-            quoteData.signature,
-        ];
-        const payload = this.abiCoder.encodeParameter({
-            ParentStruct: {
-                order: {
-                    nonceAndMeta: 'uint256',
-                    expiry: 'uint128',
-                    makerAsset: 'address',
-                    takerAsset: 'address',
-                    maker: 'address',
-                    taker: 'address',
-                    makerAmount: 'uint256',
-                    takerAmount: 'uint256',
-                },
-                signature: 'bytes',
-            },
-        }, {
-            order: params[0],
-            signature: params[1],
-        });
-        return {
-            targetExchange: this.mainnetRFQAddress,
-            payload,
-            networkFee: '0',
-        };
-    }
-    async restrict(ttl = constants_2.DEXALOT_RESTRICT_TTL_S) {
-        await this.dexHelper.cache.setex(this.dexKey, this.network, constants_2.DEXALOT_RESTRICTED_CACHE_KEY, ttl, 'true');
-        return true;
-    }
-    async isRestricted() {
-        const result = await this.dexHelper.cache.get(this.dexKey, this.network, constants_2.DEXALOT_RESTRICTED_CACHE_KEY);
-        return result === 'true';
-    }
-    async setBlacklist(txOrigin, ttl = constants_2.DEXALOT_BLACKLIST_CACHES_TTL_S) {
-        const cachedBlacklist = await this.dexHelper.cache.get(this.dexKey, this.network, this.blacklistCacheKey);
-        let blacklist = [];
-        if (cachedBlacklist) {
-            blacklist = JSON.parse(cachedBlacklist);
-        }
-        blacklist.push(txOrigin.toLowerCase());
-        this.dexHelper.cache.setex(this.dexKey, this.network, this.blacklistCacheKey, ttl, JSON.stringify(blacklist));
-        return true;
-    }
-    async isBlacklisted(txOrigin) {
-        const cachedBlacklist = await this.dexHelper.cache.get(this.dexKey, this.network, this.blacklistCacheKey);
-        if (cachedBlacklist) {
-            const blacklist = JSON.parse(cachedBlacklist);
-            return blacklist.includes(txOrigin.toLowerCase());
-        }
-        // To not show pricing for rate limited users
-        if (await this.isRateLimited(txOrigin)) {
-            return true;
-        }
-        return false;
-    }
-    getRateLimitedKey(address) {
-        return `rate_limited_${address}`.toLowerCase();
-    }
-    async isRateLimited(txOrigin) {
-        const result = await this.dexHelper.cache.get(this.dexKey, this.network, this.getRateLimitedKey(txOrigin));
-        return result === constants_2.DEXALOT_RATELIMIT_CACHE_VALUE;
-    }
-    async setRateLimited(txOrigin, ttl = constants_2.DEXALOT_RATE_LIMITED_TTL_S) {
-        await this.dexHelper.cache.setex(this.dexKey, this.network, this.getRateLimitedKey(txOrigin), ttl, constants_2.DEXALOT_RATELIMIT_CACHE_VALUE);
-        return true;
-    }
-    async getSimpleParam(srcToken, destToken, srcAmount, destAmount, data, side) {
-        const { quoteData } = data;
-        (0, ts_essentials_1.assert)(quoteData !== undefined, `${this.dexKey}-${this.network}: quoteData undefined`);
-        const swapFunction = 'simpleSwap';
-        const swapFunctionParams = [
-            [
-                quoteData.nonceAndMeta,
-                quoteData.expiry,
-                quoteData.makerAsset,
-                quoteData.takerAsset,
-                quoteData.maker,
-                quoteData.taker,
-                quoteData.makerAmount,
-                quoteData.takerAmount,
-            ],
-            quoteData.signature,
-        ];
-        const swapData = this.rfqInterface.encodeFunctionData(swapFunction, swapFunctionParams);
-        return this.buildSimpleParamWithoutWETHConversion(srcToken, srcAmount, destToken, destAmount, swapData, this.mainnetRFQAddress);
-    }
-    async getTopPoolsForToken(tokenAddress, limit) {
-        const normalizedTokenAddress = this.normalizeAddress(tokenAddress);
-        const pairs = (await this.getCachedPairs()) || {};
-        this.tokensMap = (await this.getCachedTokens()) || {};
-        const tokensAddr = (await this.getCachedTokensAddr()) || {};
-        const token = this.getTokenFromAddress(normalizedTokenAddress);
-        if (!token) {
-            return [];
-        }
-        const tokenSymbol = token.symbol?.toLowerCase() || '';
-        let pairsByLiquidity = [];
-        for (const pairName of Object.keys(pairs)) {
-            if (!pairName.includes(tokenSymbol)) {
-                continue;
-            }
-            const tokensInPair = pairName.split('/');
-            if (tokensInPair.length !== 2) {
-                continue;
-            }
-            const [baseToken, quoteToken] = tokensInPair;
-            const addr = tokensAddr[baseToken.toLowerCase()];
-            let outputToken = this.getTokenFromAddress(addr);
-            if (baseToken === tokenSymbol) {
-                const addr = tokensAddr[quoteToken.toLowerCase()];
-                outputToken = this.getTokenFromAddress(addr);
-            }
-            const denormalizedToken = this.denormalizeToken(outputToken);
-            pairsByLiquidity.push({
-                exchange: this.dexKey,
-                address: this.mainnetRFQAddress,
-                connectorTokens: [{
-                        address: denormalizedToken.address,
-                        decimals: denormalizedToken.decimals,
-                    }],
-                liquidityUSD: pairs[pairName].liquidityUSD,
-            });
-        }
-        pairsByLiquidity.sort((a, b) => b.liquidityUSD - a.liquidityUSD);
-        return pairsByLiquidity.slice(0, limit);
-    }
-    getAPIReqParams(endpoint, method) {
-        return {
-            url: `${constants_2.DEXALOT_API_URL}/${endpoint}`,
-            headers: { 'x-apikey': this.dexalotAuthToken },
-            params: {
-                chainid: this.network,
-            },
-            method: method,
-        };
-    }
-    releaseResources() {
-        if (this.rateFetcher) {
-            this.rateFetcher.stop();
-        }
-    }
-}
-exports.Dexalot = Dexalot;
-Dexalot.dexKeysWithNetwork = (0, utils_1.getDexKeysWithNetwork)(config_1.DexalotConfig);
-//# sourceMappingURL=dexalot.js.map