@paraswap/dex-lib 3.11.5-fluid-dex-changes.2 → 3.11.5

package/build/dex/cables/cables.d.ts

@@ -1,59 +0,0 @@
-import { Address, NumberAsString, OptimalSwapExchange, SwapSide } from '@paraswap/core';
-import { AsyncOrSync } from 'ts-essentials';
-import { Network } from '../../constants';
-import { IDexHelper } from '../../dex-helper';
-import { AdapterExchangeParam, DexExchangeParam, ExchangePrices, ExchangeTxInfo, Logger, PoolLiquidity, PoolPrices, PreprocessTransactionOptions, Token, TransferFeeParams } from '../../types';
-import { IDex } from '../idex';
-import { SimpleExchange } from '../simple-exchange';
-import { CablesData } from './types';
-import { Interface } from 'ethers/lib/utils';
-export declare class Cables extends SimpleExchange implements IDex<any> {
-    readonly network: Network;
-    readonly dexKey: string;
-    readonly dexHelper: IDexHelper;
-    readonly mainnetRFQAddress: string;
-    protected rfqInterface: Interface;
-    static dexKeysWithNetwork: {
-        key: string;
-        networks: Network[];
-    }[];
-    readonly isStatePollingDex = true;
-    private rateFetcher;
-    logger: Logger;
-    private tokensMap;
-    hasConstantPriceLargeAmounts: boolean;
-    constructor(network: Network, dexKey: string, dexHelper: IDexHelper, mainnetRFQAddress?: string, rfqInterface?: Interface);
-    preProcessTransaction?(optimalSwapExchange: OptimalSwapExchange<CablesData>, srcToken: Token, destToken: Token, side: SwapSide, options: PreprocessTransactionOptions): Promise<[OptimalSwapExchange<CablesData>, ExchangeTxInfo]>;
-    getDexParam(srcToken: Address, destToken: Address, srcAmount: NumberAsString, destAmount: NumberAsString, recipient: Address, data: CablesData, side: SwapSide): DexExchangeParam;
-    getAdapterParam(srcToken: string, destToken: string, srcAmount: string, destAmount: string, data: CablesData, side: SwapSide): AdapterExchangeParam;
-    normalizeToken(token: Token): Token;
-    normalizeTokenAddress(address: Address): Address;
-    getTokenFromAddress(address: Address): Token;
-    getPoolIdentifier(srcAddress: Address, destAddress: Address, mm?: string): string;
-    getPoolIdentifiers(srcToken: Token, destToken: Token, side: SwapSide, blockNumber: number): Promise<string[]>;
-    calculateOrderPrice(amounts: bigint[], orderbook: string[][], baseToken: Token, quoteToken: Token, isInputQuote: boolean): bigint[];
-    calculatePriceSwap(prices: string[][], requiredQty: number, qtyMode: Boolean): number;
-    getPricesVolume(srcToken: Token, destToken: Token, amounts: bigint[], side: SwapSide, blockNumber: number, limitPools?: string[], transferFees?: TransferFeeParams, isFirstSwap?: boolean): Promise<ExchangePrices<CablesData> | null>;
-    getCalldataGasCost(poolPrices: PoolPrices<CablesData>): number | number[];
-    initializePricing(blockNumber: number): Promise<void>;
-    getAdapters(side: SwapSide): {
-        name: string;
-        index: number;
-    }[] | null;
-    releaseResources?(): AsyncOrSync<void>;
-    normalizeAddress(address: string): string;
-    getTopPoolsForToken(tokenAddress: Address, limit: number): Promise<PoolLiquidity[]>;
-    /**
-     * CACHED UTILS
-     */
-    getCachedTokens(): Promise<any>;
-    getCachedPairs(): Promise<any>;
-    getCachedPrices(): Promise<any>;
-    getCachedTokensAddr(): Promise<any>;
-    getPairString(baseToken: Token, quoteToken: Token): string;
-    private findKeyByAddress;
-    getPairData(srcToken: Token, destToken: Token): Promise<any>;
-    isBlacklisted(txOrigin: Address): Promise<boolean>;
-    isRestricted(): Promise<boolean>;
-    restrict(): Promise<void>;
-}

package/build/dex/cables/cables.js

@@ -1,599 +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.Cables = void 0;
-const core_1 = require("@paraswap/core");
-const ts_essentials_1 = require("ts-essentials");
-const CALLDATA_GAS_COST = __importStar(require("../../calldata-gas-cost"));
-const constants_1 = require("../../constants");
-const utils_1 = require("../../utils");
-const simple_exchange_1 = require("../simple-exchange");
-const config_1 = require("./config");
-const constants_2 = require("./constants");
-const rate_fetcher_1 = require("./rate-fetcher");
-const types_1 = require("./types");
-const CablesMainnetRFQ_json_1 = __importDefault(require("../../abi/cables/CablesMainnetRFQ.json"));
-const utils_2 = require("ethers/lib/utils");
-const bignumber_js_1 = __importDefault(require("bignumber.js"));
-const ethers_1 = require("ethers");
-const bigint_constants_1 = require("../../bigint-constants");
-class Cables extends simple_exchange_1.SimpleExchange {
-    constructor(network, dexKey, dexHelper, mainnetRFQAddress = config_1.CablesConfig['Cables'][network]
-        .mainnetRFQAddress, rfqInterface = new utils_2.Interface(CablesMainnetRFQ_json_1.default)) {
-        super(dexHelper, dexKey);
-        this.network = network;
-        this.dexKey = dexKey;
-        this.dexHelper = dexHelper;
-        this.mainnetRFQAddress = mainnetRFQAddress;
-        this.rfqInterface = rfqInterface;
-        this.isStatePollingDex = true;
-        this.tokensMap = {};
-        this.hasConstantPriceLargeAmounts = false;
-        // Function to find a key by address
-        this.findKeyByAddress = (jsonData, targetAddress) => {
-            const entries = Object.entries(jsonData);
-            const foundEntry = entries.find(([_, value]) => value.address.toLowerCase() === targetAddress.toLowerCase());
-            return foundEntry ? foundEntry[0] : undefined;
-        };
-        this.logger = dexHelper.getLogger(dexKey);
-        this.rateFetcher = new rate_fetcher_1.CablesRateFetcher(this.dexHelper, this.dexKey, this.network, this.logger, {
-            rateConfig: {
-                pairsReqParams: {
-                    url: constants_2.CABLES_API_URL + '/pairs',
-                },
-                pricesReqParams: {
-                    url: constants_2.CABLES_API_URL + '/prices',
-                },
-                blacklistReqParams: {
-                    url: constants_2.CABLES_API_URL + '/blacklist',
-                },
-                tokensReqParams: {
-                    url: constants_2.CABLES_API_URL + '/tokens',
-                },
-                pricesIntervalMs: constants_2.CABLES_API_PRICES_POLLING_INTERVAL_MS,
-                pricesCacheTTLSecs: constants_2.CABLES_PRICES_CACHES_TTL_S,
-                pricesCacheKey: 'cablesPricesCacheKey',
-                pairsIntervalMs: constants_2.CABLES_API_PAIRS_POLLING_INTERVAL_MS,
-                pairsCacheTTLSecs: constants_2.CABLES_PAIRS_CACHES_TTL_S,
-                pairsCacheKey: 'cablesPairsCacheKey',
-                tokensIntervalMs: constants_2.CABLES_API_TOKENS_POLLING_INTERVAL_MS,
-                tokensCacheTTLSecs: constants_2.CABLES_TOKENS_CACHES_TTL_S,
-                tokensCacheKey: 'cablesTokensCacheKey',
-                blacklistIntervalMs: constants_2.CABLES_API_BLACKLIST_POLLING_INTERVAL_MS,
-                blacklistCacheTTLSecs: constants_2.CABLES_BLACKLIST_CACHES_TTL_S,
-                blacklistCacheKey: constants_2.CABLES_BLACKLIST_CACHE_KEY,
-            },
-        });
-    }
-    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.dexKey}_${normalizedSrcToken.address}_${normalizedDestToken.address}_${side}`;
-        try {
-            const makerToken = normalizedDestToken;
-            const takerToken = normalizedSrcToken;
-            const isSell = side === core_1.SwapSide.SELL;
-            const isBuy = side === core_1.SwapSide.BUY;
-            const rfqParams = {
-                makerAsset: ethers_1.ethers.utils.getAddress(makerToken.address),
-                takerAsset: ethers_1.ethers.utils.getAddress(takerToken.address),
-                ...(isBuy && { makerAmount: optimalSwapExchange.destAmount }),
-                ...(isSell && { takerAmount: optimalSwapExchange.srcAmount }),
-                userAddress: options.executionContractAddress,
-                chainId: String(this.network),
-            };
-            const rfq = await this.dexHelper.httpRequest.post(`${constants_2.CABLES_API_URL}/quote`, rfqParams, constants_2.CABLES_FIRM_QUOTE_TIMEOUT_MS);
-            if (!rfq) {
-                throw new Error('Failed to fetch RFQ' +
-                    swapIdentifier +
-                    JSON.stringify(rfq + 'params' + rfqParams));
-            }
-            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 (isSell) {
-                (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;
-            if (side === core_1.SwapSide.SELL) {
-                const requiredAmount = BigInt(optimalSwapExchange.destAmount);
-                const quoteAmount = BigInt(order.makerAmount);
-                const requiredAmountWithSlippage = new bignumber_js_1.default(requiredAmount.toString())
-                    .times(options.slippageFactor)
-                    .toFixed(0);
-                if (quoteAmount < BigInt(requiredAmountWithSlippage)) {
-                    throw new types_1.SlippageError(`Slipped, factor: ${quoteAmount.toString()} < ${requiredAmountWithSlippage}`);
-                }
-            }
-            else {
-                const requiredAmount = BigInt(optimalSwapExchange.srcAmount);
-                const quoteAmount = BigInt(order.takerAmount);
-                const requiredAmountWithSlippage = new bignumber_js_1.default(requiredAmount.toString())
-                    .times(options.slippageFactor)
-                    .toFixed(0);
-                if (quoteAmount > BigInt(requiredAmountWithSlippage)) {
-                    throw new types_1.SlippageError(`Slipped, factor: ${options.slippageFactor} ${quoteAmount.toString()} > ${requiredAmountWithSlippage}`);
-                }
-            }
-            // Correction of the srcAmount
-            // because flag specialDexSupportsInsertFromAmount: false
-            // is not working for Buy in test
-            if (isBuy) {
-                optimalSwapExchange.srcAmount = (0, bignumber_js_1.default)((Number(optimalSwapExchange.srcAmount) * 10000) /
-                    (10000 + Number(options.slippageFactor))).toFixed(0);
-            }
-            return [
-                {
-                    ...optimalSwapExchange,
-                    data: {
-                        quoteData: order,
-                    },
-                },
-                { deadline: minDeadline },
-            ];
-        }
-        catch (e) {
-            const message = `${this.dexKey}-${this.network}: ${e}`;
-            this.logger.error(message);
-            if (!e?.isSlippageError) {
-                this.restrict();
-            }
-            throw new Error(message);
-        }
-    }
-    getDexParam(srcToken, destToken, srcAmount, destAmount, recipient, data, side) {
-        const { quoteData } = data;
-        (0, ts_essentials_1.assert)(quoteData !== undefined, `${this.dexKey}-${this.network}: quoteData undefined`);
-        const swapFunction = 'partialSwap';
-        const swapFunctionParams = [
-            [
-                quoteData.nonceAndMeta,
-                quoteData.expiry,
-                quoteData.makerAsset,
-                quoteData.takerAsset,
-                quoteData.maker,
-                quoteData.taker,
-                quoteData.makerAmount,
-                quoteData.takerAmount,
-            ],
-            quoteData.signature,
-            quoteData.takerAmount,
-        ];
-        const exchangeData = this.rfqInterface.encodeFunctionData(swapFunction, swapFunctionParams);
-        return {
-            exchangeData,
-            needWrapNative: this.needWrapNative,
-            dexFuncHasRecipient: false,
-            targetExchange: this.mainnetRFQAddress,
-            returnAmountPos: undefined,
-        };
-    }
-    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',
-        };
-    }
-    normalizeToken(token) {
-        return {
-            ...token,
-            address: this.normalizeTokenAddress(token.address),
-        };
-    }
-    normalizeTokenAddress(address) {
-        return address.toLowerCase();
-    }
-    getTokenFromAddress(address) {
-        return this.tokensMap[this.normalizeAddress(address)];
-    }
-    getPoolIdentifier(srcAddress, destAddress, mm) {
-        return `${this.dexKey}_${srcAddress}_${destAddress}`.toLowerCase();
-        return `${this.dexKey}_${srcAddress}_${destAddress}_${mm}`.toLowerCase();
-    }
-    async getPoolIdentifiers(srcToken, destToken, side, blockNumber) {
-        if (!srcToken || !destToken) {
-            return [];
-        }
-        if (srcToken.address.toLowerCase() === destToken.address.toLowerCase()) {
-            return [];
-        }
-        const pairData = await this.getPairData(srcToken, destToken);
-        if (!pairData) {
-            return [];
-        }
-        const tokensAddr = (await this.getCachedTokensAddr()) || {};
-        return [
-            this.getPoolIdentifier(tokensAddr[pairData.base.toLowerCase()], tokensAddr[pairData.quote.toLowerCase()]),
-        ];
-    }
-    calculateOrderPrice(amounts, orderbook, baseToken, quoteToken, isInputQuote) {
-        let result = [];
-        for (let i = 0; i < amounts.length; i++) {
-            let amt = amounts[i];
-            if (amt === 0n) {
-                result.push(amt);
-                continue;
-            }
-            let decimals = baseToken.decimals;
-            if (isInputQuote) {
-                decimals = quoteToken.decimals;
-            }
-            let price = this.calculatePriceSwap(orderbook, Number(amt) / 10 ** decimals, isInputQuote);
-            result.push(BigInt(Math.round(price * 10 ** decimals)));
-        }
-        return result;
-    }
-    calculatePriceSwap(prices, requiredQty, qtyMode) {
-        let sumBaseQty = 0;
-        let sumQuoteQty = 0;
-        const selectedRows = [];
-        const isBase = !qtyMode;
-        const isQuote = qtyMode;
-        for (const [price, volume] of prices) {
-            if (isBase) {
-                if (sumBaseQty >= requiredQty) {
-                    break;
-                }
-            }
-            if (isQuote) {
-                if (sumQuoteQty >= requiredQty) {
-                    break;
-                }
-            }
-            let currentBaseQty = Number(volume);
-            let currentQuoteQty = Number(volume) * Number(price);
-            const overQty = isBase
-                ? currentBaseQty + sumBaseQty > requiredQty
-                : currentQuoteQty + sumQuoteQty > requiredQty;
-            if (overQty) {
-                if (isBase) {
-                    currentBaseQty = requiredQty - sumBaseQty;
-                    currentQuoteQty = currentBaseQty * Number(price);
-                }
-                if (isQuote) {
-                    currentQuoteQty = requiredQty - sumQuoteQty;
-                    currentBaseQty =
-                        currentQuoteQty *
-                            new bignumber_js_1.default(1).dividedBy(new bignumber_js_1.default(price)).toNumber();
-                }
-            }
-            sumBaseQty += currentBaseQty;
-            sumQuoteQty += currentQuoteQty;
-            selectedRows.push([price, currentBaseQty.toString()]);
-        }
-        const vSumBase = selectedRows.reduce((sum, [price, volume]) => {
-            return sum + Number(price) * Number(volume);
-        }, 0);
-        if (isBase) {
-            return sumBaseQty;
-        }
-        else {
-            return sumQuoteQty;
-        }
-    }
-    async getPricesVolume(srcToken, destToken, amounts, side, blockNumber, limitPools, transferFees, isFirstSwap) {
-        const isRestricted = await this.isRestricted();
-        if (isRestricted) {
-            return null;
-        }
-        try {
-            const normalizedSrcToken = this.normalizeToken(srcToken);
-            const normalizedDestToken = this.normalizeToken(destToken);
-            // If: same token, return null
-            if (normalizedSrcToken.address.toLowerCase() ===
-                normalizedDestToken.address.toLowerCase()) {
-                return null;
-            }
-            // Ensure that "symbol" is set
-            const tokens = await this.getCachedTokens();
-            this.tokensMap = Object.keys(tokens).reduce((acc, key) => {
-                //@ts-ignore
-                acc[tokens[key].address.toLowerCase()] = tokens[key];
-                return acc;
-            }, {});
-            for (const symbol of Object.keys(tokens)) {
-                const normalizedTokenAddress = tokens[symbol].address.toLowerCase();
-                if (normalizedSrcToken.address === normalizedTokenAddress) {
-                    normalizedSrcToken.symbol = tokens[symbol].symbol;
-                }
-                if (normalizedDestToken.address === normalizedTokenAddress) {
-                    normalizedDestToken.symbol = tokens[symbol].symbol;
-                }
-            }
-            // ---------- Pools ----------
-            let pools = await this.getPoolIdentifiers(srcToken, destToken, side, blockNumber);
-            if (pools.length === 0)
-                return null;
-            // ---------- Prices ----------
-            const priceMap = await this.getCachedPrices();
-            if (!priceMap)
-                return null;
-            let pairKey = `${normalizedSrcToken.symbol}/${normalizedDestToken.symbol}`;
-            const pairsKeys = Object.keys(priceMap);
-            if (!pairsKeys.includes(pairKey)) {
-                // Revert
-                pairKey = `${normalizedDestToken.symbol}/${normalizedSrcToken.symbol}`;
-                if (!pairsKeys.includes(pairKey)) {
-                    return null;
-                }
-            }
-            /**
-             * Orderbook
-             */
-            const priceData = priceMap[pairKey];
-            let orderbook = [];
-            if (side === core_1.SwapSide.BUY) {
-                orderbook = priceData.asks;
-            }
-            else {
-                orderbook = priceData.bids;
-            }
-            if (orderbook?.length === 0) {
-                throw new Error(`Empty orderbook for ${pairKey}`);
-            }
-            const isInputQuote = side === core_1.SwapSide.BUY;
-            const prices = this.calculateOrderPrice(amounts, orderbook, srcToken, destToken, isInputQuote);
-            const outDecimals = side === core_1.SwapSide.BUY
-                ? normalizedSrcToken.decimals
-                : normalizedDestToken.decimals;
-            const result = [
-                {
-                    prices: prices,
-                    unit: BigInt(outDecimals),
-                    exchange: this.dexKey,
-                    gasCost: constants_2.CABLES_GAS_COST,
-                    poolAddresses: [this.mainnetRFQAddress],
-                    data: {},
-                },
-            ];
-            return result;
-        }
-        catch (e) {
-            this.logger.error(`Error in getPricesVolume`, {
-                srcToken: srcToken.address || srcToken.symbol,
-                destToken: destToken.address || destToken.symbol,
-                side,
-            }, e);
-            return null;
-        }
-    }
-    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);
-    }
-    async initializePricing(blockNumber) {
-        if (!this.dexHelper.config.isSlave) {
-            this.rateFetcher.start();
-        }
-        return;
-    }
-    getAdapters(side) {
-        return null;
-    }
-    releaseResources() {
-        if (this.rateFetcher) {
-            this.rateFetcher.stop();
-        }
-    }
-    normalizeAddress(address) {
-        return address.toLowerCase() === constants_1.ETHER_ADDRESS
-            ? constants_1.NULL_ADDRESS
-            : address.toLowerCase();
-    }
-    async getTopPoolsForToken(tokenAddress, limit) {
-        const tokens = (await this.getCachedTokens());
-        const token = Object.values(tokens).find(token => token.address.toLowerCase() === tokenAddress.toLowerCase());
-        if (!token) {
-            return [];
-        }
-        const tokenPriceUsd = await this.dexHelper.getTokenUSDPrice(token, BigInt(10 ** token.decimals));
-        const erc20BalanceCalldata = this.erc20Interface.encodeFunctionData('balanceOf', [this.mainnetRFQAddress]);
-        const tokenBalanceMultiCall = [
-            {
-                target: token.address,
-                callData: erc20BalanceCalldata,
-            },
-        ];
-        const res = (await this.dexHelper.multiContract.methods
-            .aggregate(tokenBalanceMultiCall)
-            .call()).returnData[0];
-        let tokenLiquidity = BigInt(res);
-        let tokenLiquidityUsd = (tokenLiquidity * BigInt(tokenPriceUsd * 1000000)) /
-            BigInt(1000000 * 10 ** token.decimals);
-        let tokenWithLiquidity = [];
-        tokenWithLiquidity.push({
-            exchange: this.dexKey,
-            address: this.mainnetRFQAddress,
-            connectorTokens: [
-                {
-                    address: token.address,
-                    decimals: token.decimals,
-                },
-            ],
-            liquidityUSD: Number(tokenLiquidityUsd),
-        });
-        return tokenWithLiquidity;
-    }
-    /**
-     * CACHED UTILS
-     */
-    async getCachedTokens() {
-        const cachedTokens = await this.dexHelper.cache.get(this.dexKey, this.network, this.rateFetcher.tokensCacheKey);
-        return cachedTokens ? JSON.parse(cachedTokens) : {};
-    }
-    async getCachedPairs() {
-        const cachedPairs = await this.dexHelper.cache.get(this.dexKey, this.network, this.rateFetcher.pairsCacheKey);
-        return cachedPairs ? JSON.parse(cachedPairs) : {};
-    }
-    async getCachedPrices() {
-        const cachedPrices = await this.dexHelper.cache.get(this.dexKey, this.network, this.rateFetcher.pricesCacheKey);
-        return cachedPrices ? JSON.parse(cachedPrices) : {};
-    }
-    async getCachedTokensAddr() {
-        const tokens = await this.getCachedTokens();
-        const tokensAddr = {};
-        for (const key of Object.keys(tokens)) {
-            tokensAddr[tokens[key].symbol.toLowerCase()] = tokens[key].address;
-        }
-        return tokensAddr;
-    }
-    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();
-        normalizedSrcToken.symbol = this.findKeyByAddress(cachedTokens, normalizedSrcToken.address);
-        normalizedDestToken.symbol = this.findKeyByAddress(cachedTokens, normalizedDestToken.address);
-        const cachedPairs = await this.getCachedPairs();
-        const potentialPairs = [
-            {
-                base: normalizedSrcToken.symbol,
-                quote: normalizedDestToken.symbol,
-                identifier: this.getPairString(normalizedSrcToken, normalizedDestToken),
-                isSrcBase: true,
-            },
-            {
-                base: normalizedDestToken.symbol,
-                quote: normalizedSrcToken.symbol,
-                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;
-    }
-    async isBlacklisted(txOrigin) {
-        const cachedBlacklist = await this.dexHelper.cache.get(this.dexKey, this.network, constants_2.CABLES_BLACKLIST_CACHE_KEY);
-        if (cachedBlacklist) {
-            const blacklist = JSON.parse(cachedBlacklist);
-            return blacklist.includes(txOrigin.toLowerCase());
-        }
-        return false;
-    }
-    async isRestricted() {
-        const result = await this.dexHelper.cache.get(this.dexKey, this.network, constants_2.CABLES_RESTRICTED_CACHE_KEY);
-        return result === 'true';
-    }
-    async restrict() {
-        const errorsDataRaw = await this.dexHelper.cache.get(this.dexKey, this.network, constants_2.CABLES_ERRORS_CACHE_KEY);
-        const errorsData = utils_1.Utils.Parse(errorsDataRaw);
-        const ERRORS_TTL_S = Math.floor(constants_2.CABLES_RESTRICT_CHECK_INTERVAL_MS / 1000);
-        if (!errorsData ||
-            errorsData?.addedDatetimeMs + constants_2.CABLES_RESTRICT_CHECK_INTERVAL_MS <
-                Date.now()) {
-            this.logger.warn(`${this.dexKey}-${this.network}: First encounter of error OR error ocurred outside of threshold, setting up counter`);
-            const data = {
-                count: 1,
-                addedDatetimeMs: Date.now(),
-            };
-            await this.dexHelper.cache.setex(this.dexKey, this.network, constants_2.CABLES_ERRORS_CACHE_KEY, ERRORS_TTL_S, utils_1.Utils.Serialize(data));
-            return;
-        }
-        else {
-            if (errorsData.count + 1 >= constants_2.CABLES_RESTRICT_COUNT_THRESHOLD) {
-                this.logger.warn(`${this.dexKey}-${this.network}: Restricting due to error count=${errorsData.count + 1} within ${constants_2.CABLES_RESTRICT_CHECK_INTERVAL_MS / 1000 / 60} minutes`);
-                await this.dexHelper.cache.setex(this.dexKey, this.network, constants_2.CABLES_RESTRICTED_CACHE_KEY, constants_2.CABLES_RESTRICT_TTL_S, 'true');
-            }
-            else {
-                this.logger.warn(`${this.dexKey}-${this.network}: Error count increased`);
-                const data = {
-                    count: errorsData.count + 1,
-                    addedDatetimeMs: errorsData.addedDatetimeMs,
-                };
-                await this.dexHelper.cache.setex(this.dexKey, this.network, constants_2.CABLES_RESTRICTED_CACHE_KEY, ERRORS_TTL_S, utils_1.Utils.Serialize(data));
-            }
-        }
-    }
-}
-exports.Cables = Cables;
-Cables.dexKeysWithNetwork = (0, utils_1.getDexKeysWithNetwork)(config_1.CablesConfig);
-//# sourceMappingURL=cables.js.map