@wardenswap/bestrate-sdk-beta 2.3.0

package/dist/index.d.ts

@@ -0,0 +1,847 @@
+import { Event, EventFilter, BytesLike, BaseContract, Signer, Overrides, ContractTransaction, BigNumberish, CallOverrides, BigNumber, PopulatedTransaction, utils, ethers } from 'ethers';
+import { FunctionFragment, Result } from '@ethersproject/abi';
+import { Listener, Provider } from '@ethersproject/providers';
+
+declare enum BESTRATE_NETWORK {
+    bsc = "bsc",
+    arbitrum = "arbitrum",
+    polygon = "polygon",
+    ethereum = "ethereum",
+    avalanche = "avalanche",
+    optimism = "optimism"
+}
+type TokenInfo = {
+    address: string;
+    decimals: number;
+};
+
+interface LinearVariableGasUsed {
+    constant: bigint;
+    multiplier: bigint;
+}
+interface L2CalldataGasUsed {
+    perRoute: bigint;
+    perPath: bigint;
+    initialSingle: bigint;
+    initialSplit: bigint;
+    ethWeth: bigint;
+    wethEth: bigint;
+}
+
+declare const GAS_TOKEN_DECIMALS = 18;
+interface GasFeeDisplay {
+    usd: string;
+    dest: string;
+    unit: string;
+}
+interface GasPriceTokenChains {
+    l1: GasPriceTokens;
+    l2?: GasPriceTokens;
+}
+type GasPriceTokens = {
+    dest: {
+        fee: bigint;
+        decimals: number;
+    };
+    usd: bigint;
+};
+interface GasPriceTokensArbitrary {
+    [token: string]: {
+        fee: bigint;
+        decimals: number;
+    };
+}
+interface GasUsedUnit {
+    variable: LinearVariableGasUsed;
+    pathVariable: bigint;
+    initial: bigint;
+}
+interface GasOptions {
+    price: GasPriceTokenChains;
+    execution: GasUsedUnit;
+    l2Calldata?: L2CalldataGasUsed;
+}
+declare function zeroGasOptions(): GasOptions;
+
+interface TypedEvent<TArgsArray extends Array<any> = any, TArgsObject = any> extends Event {
+    args: TArgsArray & TArgsObject;
+}
+interface TypedEventFilter<_TEvent extends TypedEvent> extends EventFilter {
+}
+interface TypedListener<TEvent extends TypedEvent> {
+    (...listenerArg: [...__TypechainArgsArray<TEvent>, TEvent]): void;
+}
+type __TypechainArgsArray<T> = T extends TypedEvent<infer U> ? U : never;
+interface OnEvent<TRes> {
+    <TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>, listener: TypedListener<TEvent>): TRes;
+    (eventName: string, listener: Listener): TRes;
+}
+
+interface Multicall2Interface extends utils.Interface {
+    functions: {
+        "aggregate((address,bytes)[])": FunctionFragment;
+        "blockAndAggregate((address,bytes)[])": FunctionFragment;
+        "getBlockHash(uint256)": FunctionFragment;
+        "getBlockNumber()": FunctionFragment;
+        "getCurrentBlockCoinbase()": FunctionFragment;
+        "getCurrentBlockDifficulty()": FunctionFragment;
+        "getCurrentBlockGasLimit()": FunctionFragment;
+        "getCurrentBlockTimestamp()": FunctionFragment;
+        "getEthBalance(address)": FunctionFragment;
+        "getLastBlockHash()": FunctionFragment;
+        "tryAggregate(bool,(address,bytes)[])": FunctionFragment;
+        "tryBlockAndAggregate(bool,(address,bytes)[])": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "aggregate" | "blockAndAggregate" | "getBlockHash" | "getBlockNumber" | "getCurrentBlockCoinbase" | "getCurrentBlockDifficulty" | "getCurrentBlockGasLimit" | "getCurrentBlockTimestamp" | "getEthBalance" | "getLastBlockHash" | "tryAggregate" | "tryBlockAndAggregate"): FunctionFragment;
+    encodeFunctionData(functionFragment: "aggregate", values: [Multicall2.CallStruct[]]): string;
+    encodeFunctionData(functionFragment: "blockAndAggregate", values: [Multicall2.CallStruct[]]): string;
+    encodeFunctionData(functionFragment: "getBlockHash", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getBlockNumber", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getCurrentBlockCoinbase", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getCurrentBlockDifficulty", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getCurrentBlockGasLimit", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getCurrentBlockTimestamp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getEthBalance", values: [string]): string;
+    encodeFunctionData(functionFragment: "getLastBlockHash", values?: undefined): string;
+    encodeFunctionData(functionFragment: "tryAggregate", values: [boolean, Multicall2.CallStruct[]]): string;
+    encodeFunctionData(functionFragment: "tryBlockAndAggregate", values: [boolean, Multicall2.CallStruct[]]): string;
+    decodeFunctionResult(functionFragment: "aggregate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "blockAndAggregate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getBlockHash", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getBlockNumber", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getCurrentBlockCoinbase", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getCurrentBlockDifficulty", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getCurrentBlockGasLimit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getCurrentBlockTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getEthBalance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getLastBlockHash", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "tryAggregate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "tryBlockAndAggregate", data: BytesLike): Result;
+    events: {};
+}
+declare namespace Multicall2 {
+    type CallStruct = {
+        target: string;
+        callData: BytesLike;
+    };
+    type CallStructOutput = [string, string] & {
+        target: string;
+        callData: string;
+    };
+    type ResultStruct = {
+        success: boolean;
+        returnData: BytesLike;
+    };
+    type ResultStructOutput = [boolean, string] & {
+        success: boolean;
+        returnData: string;
+    };
+}
+interface Multicall2 extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: Multicall2Interface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        aggregate(calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        blockAndAggregate(calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        getBlockHash(blockNumber: BigNumberish, overrides?: CallOverrides): Promise<[string] & {
+            blockHash: string;
+        }>;
+        getBlockNumber(overrides?: CallOverrides): Promise<[BigNumber] & {
+            blockNumber: BigNumber;
+        }>;
+        getCurrentBlockCoinbase(overrides?: CallOverrides): Promise<[string] & {
+            coinbase: string;
+        }>;
+        getCurrentBlockDifficulty(overrides?: CallOverrides): Promise<[BigNumber] & {
+            difficulty: BigNumber;
+        }>;
+        getCurrentBlockGasLimit(overrides?: CallOverrides): Promise<[BigNumber] & {
+            gaslimit: BigNumber;
+        }>;
+        getCurrentBlockTimestamp(overrides?: CallOverrides): Promise<[BigNumber] & {
+            timestamp: BigNumber;
+        }>;
+        getEthBalance(addr: string, overrides?: CallOverrides): Promise<[BigNumber] & {
+            balance: BigNumber;
+        }>;
+        getLastBlockHash(overrides?: CallOverrides): Promise<[string] & {
+            blockHash: string;
+        }>;
+        tryAggregate(requireSuccess: boolean, calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        tryBlockAndAggregate(requireSuccess: boolean, calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+    };
+    aggregate(calls: Multicall2.CallStruct[], overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    blockAndAggregate(calls: Multicall2.CallStruct[], overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    getBlockHash(blockNumber: BigNumberish, overrides?: CallOverrides): Promise<string>;
+    getBlockNumber(overrides?: CallOverrides): Promise<BigNumber>;
+    getCurrentBlockCoinbase(overrides?: CallOverrides): Promise<string>;
+    getCurrentBlockDifficulty(overrides?: CallOverrides): Promise<BigNumber>;
+    getCurrentBlockGasLimit(overrides?: CallOverrides): Promise<BigNumber>;
+    getCurrentBlockTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
+    getEthBalance(addr: string, overrides?: CallOverrides): Promise<BigNumber>;
+    getLastBlockHash(overrides?: CallOverrides): Promise<string>;
+    tryAggregate(requireSuccess: boolean, calls: Multicall2.CallStruct[], overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    tryBlockAndAggregate(requireSuccess: boolean, calls: Multicall2.CallStruct[], overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        aggregate(calls: Multicall2.CallStruct[], overrides?: CallOverrides): Promise<[
+            BigNumber,
+            string[]
+        ] & {
+            blockNumber: BigNumber;
+            returnData: string[];
+        }>;
+        blockAndAggregate(calls: Multicall2.CallStruct[], overrides?: CallOverrides): Promise<[
+            BigNumber,
+            string,
+            Multicall2.ResultStructOutput[]
+        ] & {
+            blockNumber: BigNumber;
+            blockHash: string;
+            returnData: Multicall2.ResultStructOutput[];
+        }>;
+        getBlockHash(blockNumber: BigNumberish, overrides?: CallOverrides): Promise<string>;
+        getBlockNumber(overrides?: CallOverrides): Promise<BigNumber>;
+        getCurrentBlockCoinbase(overrides?: CallOverrides): Promise<string>;
+        getCurrentBlockDifficulty(overrides?: CallOverrides): Promise<BigNumber>;
+        getCurrentBlockGasLimit(overrides?: CallOverrides): Promise<BigNumber>;
+        getCurrentBlockTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
+        getEthBalance(addr: string, overrides?: CallOverrides): Promise<BigNumber>;
+        getLastBlockHash(overrides?: CallOverrides): Promise<string>;
+        tryAggregate(requireSuccess: boolean, calls: Multicall2.CallStruct[], overrides?: CallOverrides): Promise<Multicall2.ResultStructOutput[]>;
+        tryBlockAndAggregate(requireSuccess: boolean, calls: Multicall2.CallStruct[], overrides?: CallOverrides): Promise<[
+            BigNumber,
+            string,
+            Multicall2.ResultStructOutput[]
+        ] & {
+            blockNumber: BigNumber;
+            blockHash: string;
+            returnData: Multicall2.ResultStructOutput[];
+        }>;
+    };
+    filters: {};
+    estimateGas: {
+        aggregate(calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        blockAndAggregate(calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        getBlockHash(blockNumber: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        getBlockNumber(overrides?: CallOverrides): Promise<BigNumber>;
+        getCurrentBlockCoinbase(overrides?: CallOverrides): Promise<BigNumber>;
+        getCurrentBlockDifficulty(overrides?: CallOverrides): Promise<BigNumber>;
+        getCurrentBlockGasLimit(overrides?: CallOverrides): Promise<BigNumber>;
+        getCurrentBlockTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
+        getEthBalance(addr: string, overrides?: CallOverrides): Promise<BigNumber>;
+        getLastBlockHash(overrides?: CallOverrides): Promise<BigNumber>;
+        tryAggregate(requireSuccess: boolean, calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        tryBlockAndAggregate(requireSuccess: boolean, calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        aggregate(calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        blockAndAggregate(calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        getBlockHash(blockNumber: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getBlockNumber(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getCurrentBlockCoinbase(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getCurrentBlockDifficulty(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getCurrentBlockGasLimit(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getCurrentBlockTimestamp(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getEthBalance(addr: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getLastBlockHash(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        tryAggregate(requireSuccess: boolean, calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        tryBlockAndAggregate(requireSuccess: boolean, calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+    };
+}
+
+declare enum DexModel {
+    UniswapV2 = 0,
+    UniswapV3 = 1,
+    DMM = 2,
+    CurvePlain = 3,
+    CurveMeta = 4,
+    CurvePlainSol = 5,
+    Iron = 6,
+    Synapse = 7,
+    CurveMetaSol = 8,
+    CurveCrypto = 9,
+    CurveLendingA = 10,
+    CurveLendingCryptoZap = 11,
+    CurveLendingCryptoTwoZap = 12,
+    PolyDex = 13,
+    FireBirdWeighted = 14,
+    BalancerWeighted = 15,
+    BalancerStable = 16,
+    BalancerMetaStable = 17,
+    BalancerBoostedStable = 18,
+    BalancerLinear = 19,
+    BalancerLiquidityBootstrapping = 20,
+    Biswap = 21,
+    DodoV1 = 22,
+    DodoV2 = 23,
+    Mdex = 24,
+    Mars = 25,
+    Smoothy = 26,
+    Shibaswap = 27,
+    GmxDex = 28,
+    Solidly = 29,
+    Synthetix = 30,
+    Unknown = 31
+}
+interface UniswapV2BasedModelInfo {
+    model: DexModel.UniswapV2 | DexModel.Mdex | DexModel.Biswap | DexModel.Mars | DexModel.Shibaswap;
+    pairBytecodeHash: string;
+    factory: string;
+    fee: bigint;
+    feePrecision: bigint;
+}
+interface UniswapV3ModelInfo extends Omit<UniswapV2BasedModelInfo, 'model' | 'feePrecision'> {
+    model: DexModel.UniswapV3;
+    maxInitializedTicks: number;
+    tickQuerier: string;
+    depositAddress: string;
+    gasPerInitializedTick: bigint;
+    gasPerTick: bigint;
+}
+interface PolyDexModelInfo extends Omit<UniswapV2BasedModelInfo, 'model'> {
+    model: DexModel.PolyDex | DexModel.FireBirdWeighted;
+    weight: number;
+}
+interface CurvePlainModelInfo {
+    model: DexModel.CurvePlain | DexModel.CurvePlainSol | DexModel.Iron | DexModel.Synapse;
+    poolContract: string;
+    lpToken: string;
+    tokens: string[];
+    rates: bigint[];
+    lendingPrecision: bigint;
+    precision: bigint;
+    precisionMul: bigint[];
+    feeDenominator: bigint;
+    isUnderlying: boolean;
+    aPrecision?: bigint;
+    balancesArgs?: string;
+}
+interface CurveLendingModelInfo {
+    model: DexModel.CurveLendingA;
+    poolContract: string;
+    lpToken: string;
+    tokens: string[];
+    precision: bigint;
+    precisionMul: bigint[];
+    feeDenominator: bigint;
+    aPrecision: bigint;
+}
+interface CurveMetaModelInfo extends Omit<CurvePlainModelInfo, 'isUnderlying' | 'lendingPrecision' | 'model'> {
+    model: DexModel.CurveMeta | DexModel.CurveMetaSol;
+    multicall: string;
+    baseCacheExpires: bigint;
+    basePoolRouteId: string;
+    isCacheExists: boolean;
+}
+interface CurveCryptoModelInfo {
+    model: DexModel.CurveCrypto;
+    tokens: string[];
+    precision: bigint;
+    precisions: bigint[];
+    feeDenominator: bigint;
+    noiseFee: bigint;
+    minA: bigint;
+    maxA: bigint;
+    isAPrecise: boolean;
+    minGamma: bigint;
+    maxGamma: bigint;
+    aMultiplier: bigint;
+    poolContract: string;
+    lpToken: string;
+}
+interface CurveCryptoZapModelInfo {
+    model: DexModel.CurveLendingCryptoZap;
+    basePoolId: string;
+    poolId: string;
+    tokens: string[];
+    nStablecoins: number;
+    poolContract: string;
+}
+interface CurveCryptoTwoZapModelInfo extends Omit<CurveCryptoZapModelInfo, 'model'> {
+    model: DexModel.CurveLendingCryptoTwoZap;
+    nCoins: number;
+}
+interface DMMModelInfo {
+    model: DexModel.DMM;
+    pools: {
+        [token0: string]: {
+            [token1: string]: string;
+        };
+    };
+}
+interface BalancerWeightedModelInfo extends Omit<BalancerStableModelInfo, 'model' | 'aPrecision'> {
+    model: DexModel.BalancerWeighted | DexModel.BalancerLiquidityBootstrapping;
+    weights: bigint[];
+}
+interface BalancerStableModelInfo {
+    model: DexModel.BalancerStable;
+    tokens: string[];
+    scalingFactors: bigint[];
+    vaultContract: string;
+    poolId: string;
+    aPrecision: bigint;
+    depositAddress: string;
+}
+interface BalancerBoostedStableModelInfo extends Omit<BalancerStableModelInfo, 'model'> {
+    model: DexModel.BalancerBoostedStable;
+    bptIndex: number;
+    linearPoolIds: string[];
+}
+interface BalancerLinearModelInfo {
+    model: DexModel.BalancerLinear;
+    tokens: string[];
+    scalingFactors: bigint[];
+    vaultContract: string;
+    poolId: string;
+    mainIndex: number;
+    wrappedIndex: number;
+    wrappedToken: string;
+    bptIndex: number;
+    depositAddress: string;
+}
+interface BalancerMetaStableModelInfo extends Omit<BalancerStableModelInfo, 'model'> {
+    model: DexModel.BalancerMetaStable;
+    rateProviders: string[];
+    multicall: string;
+}
+interface DodoV2ModelInfo {
+    model: DexModel.DodoV2 | DexModel.DodoV1;
+    factoryContract: string;
+    pools: {
+        [baseToken: string]: {
+            [quoteToken: string]: string;
+        };
+    };
+}
+interface SmoothyModelInfo {
+    model: DexModel.Smoothy;
+    poolContract: string;
+    expectedImplAddress: string;
+    expectedTokens: {
+        [addr: string]: number;
+    };
+}
+interface GmxDexModelInfo {
+    model: DexModel.GmxDex;
+    vaultContract: string;
+    pricePrecision: bigint;
+    debtTokenContract: string;
+}
+interface SolidlyModelInfo {
+    model: DexModel.Solidly;
+    factoryContract: string;
+    isStable: boolean;
+    pairBytecodeHash: string;
+}
+interface SynthetixModelInfo {
+    model: DexModel.Synthetix;
+    tokens: {
+        [address: string]: string;
+    };
+    sUsdContract: string;
+    exchangeRatesContract: string;
+    exchangerContract: string;
+    synthetixContract: string;
+    flexibleStorageContract: string;
+    PRECISION_UNIT: bigint;
+}
+interface RouteInfo {
+    id: string;
+    address: string;
+    name: string;
+}
+type RouteInfoModel = RouteInfo & {
+    gas: bigint;
+    isTradingAllowed: boolean;
+} & (UniswapV2BasedModelInfo | UniswapV3ModelInfo | CurvePlainModelInfo | CurveMetaModelInfo | CurveCryptoModelInfo | CurveCryptoZapModelInfo | CurveCryptoTwoZapModelInfo | CurveLendingModelInfo | DodoV2ModelInfo | SmoothyModelInfo | DMMModelInfo | BalancerWeightedModelInfo | BalancerStableModelInfo | BalancerMetaStableModelInfo | BalancerBoostedStableModelInfo | BalancerLinearModelInfo | PolyDexModelInfo | GmxDexModelInfo | SolidlyModelInfo | SynthetixModelInfo | {
+    model: DexModel.Unknown;
+});
+
+type DexRoute = RouteInfoModel[];
+
+interface MulticallBatchOption {
+    maxCallsPerBatch: number;
+}
+
+interface AmountOut {
+    amount: bigint;
+    gas: bigint;
+}
+interface IAmountOutCalculatorModel {
+    /**
+     * get a list of pair that can be traded via the model
+     */
+    getTradablePairs(): [string, string][];
+    /**
+     * Get Warden's trading route address
+     */
+    getTradingRouteIndex(): number;
+    /**
+     * Get pool address for the model
+     */
+    getPoolAddress(): string;
+    /**
+     * TODO: Let model return list of visited path for given token pair
+     * pool
+     *
+     * getVisitedPaths(src: string, dest: string): [poolAddress, Set<string>()][]
+     * For 1 model:
+     * Uniswap: [[0xpool1, new Set<string>([0xtoken1, 0xtoken2])]]
+     * CurveMetaPool: [
+     *    [0xmetaPool, new Set<string>([0xmetaToken])]
+     *    [0xbasePool, new Set<string>([0xbaseToken])]
+     * ]
+     * GMX: [
+     *    [0xgmxVault, new Set<string>([0xtoken1, token2])]
+     * ]
+     *
+     * Or, if swap a token on pool affects other tokens in the same pool, then return only list of pool tokens
+     */
+    /**
+     * Get deposit address
+     */
+    getDepositAddress(): string;
+    /**
+     * generate Multicall calls for getting current state of source
+     * @param tokens list of src/dest token addresses
+     */
+    getfetchingCurrentStateCalls(): Multicall2.CallStruct[];
+    /**
+     * Apply outputs received from Multicall
+     * @param outputs multicall's outputs
+     */
+    applyCurrentStateFromCalls(outputs: Multicall2.ResultStructOutput[]): void;
+    /**
+     * Calculate output amount based on trade direction and input amount
+     * @param src source token address
+     * @param dest destination token address
+     * @param amountIn amountIn
+     */
+    getAmountOut(src: string, dest: string, amountIn: bigint): AmountOut;
+}
+
+interface AmountOutResult {
+    amountOut: AmountOut;
+    routeIndex: number;
+    poolAddress: string;
+}
+interface TradingPath {
+    routeIndexes: number[];
+    tokens: string[];
+    pools: string[];
+    amountOut: bigint;
+    gas: bigint;
+}
+interface DexManagerOptions {
+    multicall: MulticallBatchOption;
+    maxCandidatePaths: number;
+}
+declare class DexManager {
+    private readonly DEX_ROUTES;
+    private readonly CORRESPONDENT_TOKENS;
+    private multicall;
+    private opt;
+    readonly corrTokenDecimals: {
+        [token: string]: number;
+    };
+    private models;
+    private indexedModels;
+    private DEX_ROUTES_ID_IDX;
+    private DEX_ROUTES_ADDRESS_IDX;
+    private corrTokens;
+    private amountOutCache;
+    constructor(DEX_ROUTES: DexRoute, CORRESPONDENT_TOKENS: TokenInfo[], multicall: Multicall2, opt: DexManagerOptions);
+    private updateIndexedModel;
+    private isModelIndexed;
+    private isModelTradingAllowed;
+    getModel<T extends IAmountOutCalculatorModel>(src: string, dest: string, routeIdx: number): T | undefined;
+    private getTradableModels;
+    getDepositAddress(src: string, dest: string, routeAddress: string): string;
+    generateAllTokenPairs(src: string, dest: string): [string, string][];
+    unregisterAll(): void;
+    registerSingle(pair: [string, string], routeIdx: number): void;
+    register(src: string, dest: string): void;
+    getRouteInfo(routeIdx: number): RouteInfo;
+    fetchAllReserves(): Promise<number>;
+    private tryGetAmountOut;
+    getMaxAmountOutWithCache(src: string, dest: string, amountIn: bigint, visitedRoutes?: Set<string>, gasPrice?: GasPriceTokensArbitrary): AmountOutResult;
+    getAmountOutByPath(src: string, dest: string, amountIn: bigint, routeIndexes: number[], tokens: string[]): AmountOut;
+    protected getPathCombinationRecursively(depth: number, tokens: string[], dest: string, visitedTokens: string[], amountIn: bigint, paths: TradingPath[], topNPaths: number, dexSelectorFunc: (src: string, dest: string, amountIn: bigint, visitedPools: Set<string>) => AmountOutResult): void;
+    getAllRoutesSingle(src: string, dest: string, amountIn: bigint, gasPrices?: GasPriceTokensArbitrary): TradingPath[];
+    getTokenPriceRoutes(usd: string, usdDecimal: number, additionalTokens: string[]): {
+        [token: string]: TradingPath[];
+    };
+    getCandidatePaths(topNPaths: number, src: string, dest: string, amountIn: bigint, gasPrices?: GasPriceTokensArbitrary): TradingPath[];
+    getAllRoutesSplit(src: string, dest: string, amountIn: bigint, gasPrice?: GasPriceTokensArbitrary): {
+        paths: TradingPath[];
+        amountOuts: bigint[][];
+        gas: bigint[][];
+    };
+}
+
+interface WardenBestRateOption {
+    /** Maximum number of function calls per single multicall call, lower the number may improve latency but in exchange of higher network traffic */
+    maxCallsPerFetch?: number;
+    /** Maximum number of candidate paths for split trading, lower the number may improve performance */
+    maxCandidatePathsCount?: number;
+}
+interface GetQuoteOption {
+    /** A flag indicating whether spliting trade should be enabled */
+    enableSplit?: boolean;
+    /** L2 Gas price for L2 chains e.g. Optimism, Arbitrum */
+    gasPriceL2?: ethers.BigNumberish;
+}
+type PathResult = {
+    routes: RouteInfo[];
+    tokens: string[];
+};
+type QuoteResult = {
+    type: 'split';
+    paths: PathResult[];
+    depositAddresses: string[];
+    volumns: number[];
+    amountOut: string;
+    gasFees: GasFeeDisplay;
+    blockNumber: number;
+    routerAddress: string;
+    swapAddress: string;
+} | {
+    type: 'strategies';
+    path: PathResult;
+    depositAddress: string;
+    amountOut: string;
+    gasFees: GasFeeDisplay;
+    blockNumber: number;
+    routerAddress: string;
+    swapAddress: string;
+} | {
+    type: 'ethToWeth' | 'wethToEth';
+    routerAddress: string;
+    amountOut: string;
+    gasFees: GasFeeDisplay;
+};
+/**
+ * Warden Best Rate for getting quote and swapping.
+ */
+declare class WardenBestRate {
+    private provider;
+    private multicall2;
+    private network;
+    private options;
+    /**
+     * Create new instance of WardenBestRate
+     *
+     * @param provider ethersjs' Provider instance
+     * @param networkName Chain name (supported by WardenSwap)
+     * @param options Options
+     */
+    constructor(provider: ethers.providers.Provider, networkName: `${BESTRATE_NETWORK}`, options?: WardenBestRateOption);
+    private getTradeType;
+    /**
+     * Get deposit addresses indicating the first hop to be used for starting the trade.
+     * This information is required by Wardenswap contract
+     * @param srcDestRouteTuples tuples of src, dest, and routeAddress
+     * @returns a list of deposit addresses with the same order as the input
+     */
+    getDepositAddresses(srcDestRouteTuples: {
+        src: string;
+        dest: string;
+        routeAddress: string;
+    }[], dexManager?: DexManager): string[];
+    private _fetch;
+    private _quoteETHWETH;
+    private sendTx;
+    /**
+     * Set Allowance of a token to be spendable by WardenSwap contract
+     * @param signer ethers' Signer
+     * @param src Token to be approved
+     * @param allowedAmount Allowed amount to be spendable by WardenSwap contract
+     * @param overrides ethers' overrides
+     * @returns ethers' contract transaction (no wait)
+     */
+    approve(signer: Signer, src: string, allowedAmount?: ethers.BigNumberish, overrides?: ethers.PayableOverrides): Promise<ethers.ContractTransaction | null>;
+    /**
+     * Send a swap transaction to WardenSwap based on given quote
+     * @param signer ethers' Signer
+     * @param src Source token
+     * @param dest Destination token
+     * @param amountIn Amount of source token
+     * @param minDestAmount Minimum amount of destination token
+     * @param quoteResult Best rate quote got from `getQuote` method
+     * @param partnerId Warden's partner ID
+     * @param metaData MetaWarden ID
+     * @param receiver Wallet to receive destination token, default to tx sender
+     * @param overrides ethers' transaction overrides
+     * @returns ethers' contract transaction (no wait)
+     */
+    swap(signer: Signer, src: string, dest: string, amountIn: ethers.BigNumberish, minDestAmount: ethers.BigNumberish, quoteResult: QuoteResult, partnerId?: ethers.BigNumberish, metaData?: ethers.BigNumberish, receiver?: string, overrides?: ethers.PayableOverrides): Promise<ethers.ContractTransaction>;
+    /**
+     * Get the best rate of a token pair with given amount
+     * @param src Address of src asset
+     * @param dest Address of dest asset
+     * @param amountIn Amount of src asset to be traded
+     * @param gasPrice Amount of gas price per unit in native currency (18 decimals)
+     *                 e.g. BSC = BNB, Polygon = MATIC, Ethereum = ETH. For L2 chains,
+     *                 this is Ethereum (L1) gas price.
+     * @param opts Options for getting quote
+     * @returns Trading routes which provide the best rate
+     */
+    getQuote(src: string, dest: string, amountIn: ethers.BigNumberish, gasPrice: ethers.BigNumberish, opts?: GetQuoteOption): Promise<QuoteResult>;
+}
+
+/**
+ * A class for calldata compression to be used with WardenSwap on L2 chains
+ */
+declare class WardenPayloadCompressor {
+    private networkName;
+    private provider;
+    private multicallOptions?;
+    private multicall;
+    private addressTableContract;
+    private readonly MAX_UINT24;
+    private readonly MAX_UINT32;
+    private readonly MAX_UINT64;
+    private readonly MAX_UINT80;
+    private readonly MAX_UINT96;
+    private readonly MAX_UINT112;
+    /**
+     * Create new instance of WardenPayloadCompressor
+     * @param networkName Chain name (supported by WardenSwap)
+     * @param provider ethersjs' Provider
+     * @param multicallOptions Multicall options
+     */
+    constructor(networkName: `${BESTRATE_NETWORK}`, provider: ethers.providers.Provider, multicallOptions?: MulticallBatchOption);
+    private fetchAddressIndex;
+    private encodeAddress;
+    private encodeAmount;
+    private encodePathResult;
+    private addPathResultAddressesToArray;
+    private createAddressIndexMap;
+    /**
+     * Compress swap data for L2 chains
+     * @param paths Path result(s) gathered from `getQuote`
+     * @param volumes Splitting ratio of source token amount range from 1-100
+     * @param addressIdxMap Address-index map gathered from ArbAddressTable contract
+     * @returns A hexadecimal string representing compressed swap data
+     */
+    encodeSwapDataL2(paths: PathResult | PathResult[], volumes: number[], addressIdxMap?: {
+        [address: string]: ethers.BigNumber | null;
+    }): Promise<string>;
+    /**
+     * Encode swap data for L1 chains
+     * @param paths Path result(s) gathered from `getQuote`
+     * @returns A hexadecimal string representing encoded swap data
+     */
+    encodeSwapData(paths: PathResult | PathResult[]): string;
+    /**
+     * Compress calldata for L2 chains
+     * @param src Source Token
+     * @param dest Destination Token
+     * @param amountIn Amount of source token
+     * @param minDestAmount Minimum amount of destination token required
+     * @param partnerId Warden's partner ID
+     * @param metaData MetaWarden data
+     * @param swapAddress Warden swap contract
+     * @param receiver Receiver wallet
+     * @param paths Path result(s) gathered from `getQuote`
+     * @param volumes Splitting ratio of source token amount range from 1-100
+     * @returns Serialized data to be used with swap functions with compression feature
+     */
+    compress(src: string, dest: string, amountIn: ethers.BigNumberish, minDestAmount: ethers.BigNumberish, partnerId: ethers.BigNumberish, metaData: ethers.BigNumberish, swapAddress: string, receiver: string, paths: PathResult | PathResult[], volumes: number[]): Promise<string>;
+}
+
+declare function initProvider(url: string, user?: string, password?: string): ethers.providers.JsonRpcProvider;
+
+declare enum LogLevel {
+    DEBUG = 8,
+    LOG = 4,
+    WARN = 2,
+    ERROR = 1,
+    SILENT = 0
+}
+interface LoggerService {
+    level: LogLevel;
+    /**
+     * Write a 'log' level log.
+     */
+    log(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write an 'error' level log.
+     */
+    error(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'warn' level log.
+     */
+    warn(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'debug' level log.
+     */
+    debug?(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'table' in 'debug' log level
+     * @param tabularData
+     * @param properties
+     */
+    table(tabularData?: any, properties?: string[]): void;
+    /**
+     * Set log levels.
+     * @param levels log levels
+     */
+    setLogLevels?(levels: LogLevel[]): any;
+}
+declare class Logger implements LoggerService {
+    level: LogLevel;
+    constructor(level: LogLevel);
+    static overrideLogger(logger: LoggerService): void;
+    log(message: any, ...optionalParams: any[]): void;
+    error(message: any, ...optionalParams: any[]): void;
+    warn(message: any, ...optionalParams: any[]): void;
+    debug(message: any, ...optionalParams: any[]): void;
+    table(tabularData?: any, properties?: string[]): void;
+}
+declare let log: LoggerService;
+
+export { BESTRATE_NETWORK, GAS_TOKEN_DECIMALS, LogLevel, Logger, type LoggerService, type QuoteResult, WardenBestRate, WardenPayloadCompressor, initProvider, log, zeroGasOptions };