@paraswap/dex-lib 3.4.2-balancer-v2-single-swap.0 → 3.4.2

package/src/dex/curve-v1/curve-v1.ts

@@ -1,1315 +1,1315 @@
-import { Interface, AbiCoder, JsonFragment } from '@ethersproject/abi';
-import _ from 'lodash';
-import { NumberAsString, OptimalSwapExchange } from '@paraswap/core';
-import { assert } from 'ts-essentials';
-import BigNumber from 'bignumber.js';
-import CurveABI from '../../abi/Curve.json';
-import DirectSwapABI from '../../abi/DirectSwap.json';
-import { Adapters, CurveV1Config } from './config';
-
-import {
-  AdapterExchangeParam,
-  Address,
-  DexExchangeParam,
-  ExchangePrices,
-  ExchangeTxInfo,
-  PoolLiquidity,
-  PoolPrices,
-  PreprocessTransactionOptions,
-  SimpleExchangeParam,
-  Token,
-  TransferFeeParams,
-  TxInfo,
-} from '../../types';
-import {
-  Network,
-  NULL_ADDRESS,
-  SRC_TOKEN_PARASWAP_TRANSFERS,
-  ETHER_ADDRESS,
-  SwapSide,
-} from '../../constants';
-import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
-import StableSwapBBTC from '../../abi/curve-v1/StableSwapBBTC.json';
-import { CurvePool } from './pools/curve-pool';
-import { CurveMetapool } from './pools/curve-metapool';
-import { ThreePool, address as ThreePoolAddress } from './pools/3pool';
-import { SUSDPool, address as SUSDPoolAddress } from './pools/sUSDpool';
-import { HBTCPool, address as HBTCPoolAddress } from './pools/hBTCpool';
-import { RenPool, address as RenPoolAddress } from './pools/renpool';
-import { SBTCPool, address as SBTCPoolAddress } from './pools/sBTCpool';
-import { SETHPool, address as SETHPoolAddress } from './pools/sETHpool';
-import { STETHPool, address as STETHPoolAddress } from './pools/stETHpool';
-import { EURSPool, address as EURSPoolAddress } from './pools/EURSpool';
-import { DUSDPool, address as DUSDPoolAddress } from './pools/DUSDpool';
-import { BBTCPool, address as BBTCPoolAddress } from './pools/bBTCpool';
-import { GUSDPool, address as GUSDPoolAddress } from './pools/GUSDpool';
-import { HUSDPool, address as HUSDPoolAddress } from './pools/HUSDpool';
-import {
-  LinkUSDPool,
-  address as LinkUSDPoolAddress,
-} from './pools/LinkUSDpool';
-import { MUSDPool, address as MUSDPoolAddress } from './pools/MUSDpool';
-import { OBTCPool, address as OBTCPoolAddress } from './pools/oBTCpool';
-import { PBTCPool, address as PBTCPoolAddress } from './pools/pBTCpool';
-import { RSVPool, address as RSVPoolAddress } from './pools/rsvpool';
-import { TBTCPool, address as TBTCPoolAddress } from './pools/tBTCpool';
-import { USDKPool, address as USDKPoolAddress } from './pools/usdkpool';
-import { USTPool, address as USTPoolAddress } from './pools/ustpool';
-import { SLINKPool, address as SLINKPoolAddress } from './pools/sLinkpool';
-import {
-  getBigIntPow,
-  getDexKeysWithNetwork,
-  interpolate,
-  isDestTokenTransferFeeToBeExchanged,
-  isETHAddress,
-  isSrcTokenTransferFeeToBeExchanged,
-  Utils,
-  uuidToBytes16,
-} from '../../utils';
-import { BN_0 } from '../../bignumber-constants';
-import {
-  getLocalDeadlineAsFriendlyPlaceholder,
-  SimpleExchange,
-} from '../simple-exchange';
-import { IDex } from '../idex';
-import { IDexHelper } from '../../dex-helper';
-import { Logger } from 'log4js';
-import { uin128DecodeToInt, uin256DecodeToFloat } from '../../lib/decoders';
-import { getManyPoolStates } from './pools/getstate-multicall';
-import { MultiCallParams, MultiResult } from '../../lib/multi-wrapper';
-import {
-  PoolConfig,
-  CurveV1Data,
-  TokenWithReasonableVolume,
-  CurveSwapFunctions,
-  CurveV1SwapType,
-  DirectCurveV1Param,
-  DirectCurveV1ParamV6,
-  CurveV1DirectSwap,
-} from './types';
-import { erc20Iface } from '../../lib/utils-interfaces';
-import { applyTransferFee } from '../../lib/token-transfer-fee';
-import { DIRECT_METHOD_NAME, DIRECT_METHOD_NAME_V6 } from './constants';
-import { packCurveData } from '../../lib/curve/encoder';
-import { encodeCurveAssets } from './packer';
-import { hexConcat, hexZeroPad, hexlify } from 'ethers/lib/utils';
-
-const CURVE_DEFAULT_CHUNKS = 10;
-
-const CURVE_LENDING_POOl_GAS = 340 * 1000;
-const CURVE_POOL_GAS = 200 * 1000;
-
-const coder = new AbiCoder();
-
-export class CurveV1
-  extends SimpleExchange
-  implements IDex<CurveV1Data, DirectCurveV1Param | CurveV1DirectSwap>
-{
-  exchangeRouterInterface: Interface;
-  minConversionRate = '1';
-
-  eventPools = new Array<CurvePool | CurveMetapool>();
-  public poolInterface: Interface;
-
-  private logger: Logger;
-
-  readonly hasConstantPriceLargeAmounts = false;
-  readonly isFeeOnTransferSupported = true;
-
-  private decimalsCoinsAndUnderlying: Record<string, number> = {};
-
-  protected pools: Record<string, PoolConfig>;
-  protected eventSupportedPools: string[];
-  protected baseTokens: Record<string, TokenWithReasonableVolume>;
-
-  protected disableFeeOnTransferTokenAddresses: Set<string>;
-
-  readonly directSwapIface = new Interface(DirectSwapABI);
-
-  readonly SRC_TOKEN_DEX_TRANSFERS = 1;
-  readonly DEST_TOKEN_DEX_TRANSFERS = 1;
-
-  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
-    getDexKeysWithNetwork(CurveV1Config);
-
-  constructor(
-    protected network: Network,
-    dexKey: string,
-    protected dexHelper: IDexHelper,
-    dexConfig = CurveV1Config[dexKey][network],
-
-    protected adapters = Adapters[network],
-  ) {
-    super(dexHelper, dexKey);
-    this.pools = Object.keys(dexConfig.pools).reduce<
-      Record<string, PoolConfig>
-    >((acc, key) => {
-      const poolConf = dexConfig.pools[key];
-
-      acc[key] = {
-        underlying: poolConf.underlying.map(t => t.toLowerCase()),
-        coins: poolConf.coins.map(t => t.toLowerCase()),
-        address: poolConf.address.toLowerCase(),
-        name: poolConf.name,
-        type: poolConf.type,
-        version: poolConf.version,
-        isLending: poolConf.isLending,
-        isMetapool: poolConf.isMetapool,
-        baseToken: poolConf.baseToken
-          ? poolConf.baseToken.toLowerCase()
-          : poolConf.baseToken,
-        liquidityUSD: poolConf.liquidityUSD,
-        trackCoins: poolConf.trackCoins,
-        useLending: poolConf.useLending,
-        precisionMul: poolConf.precisionMul,
-        tokenAddress: poolConf.tokenAddress
-          ? poolConf.tokenAddress.toLowerCase()
-          : undefined,
-        isFeeOnTransferSupported: poolConf.isFeeOnTransferSupported,
-      };
-
-      return acc;
-    }, {});
-
-    this.eventSupportedPools = dexConfig.eventSupportedPools.map(addr =>
-      addr.toLowerCase(),
-    );
-
-    this.baseTokens = Object.keys(dexConfig.baseTokens).reduce<
-      Record<string, TokenWithReasonableVolume>
-    >((acc, key) => {
-      const baseToken = dexConfig.baseTokens[key];
-      acc[key.toLowerCase()] = {
-        address: baseToken.address.toLowerCase(),
-        decimals: baseToken.decimals,
-        reasonableVolume: baseToken.reasonableVolume,
-      };
-      return acc;
-    }, {});
-
-    this.disableFeeOnTransferTokenAddresses =
-      dexConfig.disableFeeOnTransferTokenAddresses
-        ? new Set<string>(
-            Array.from(
-              dexConfig.disableFeeOnTransferTokenAddresses.values(),
-            ).map(addr => addr.toLowerCase()),
-          )
-        : new Set<string>();
-
-    this.exchangeRouterInterface = new Interface(CurveABI as JsonFragment[]);
-
-    this.logger = dexHelper.getLogger(dexKey);
-
-    this.poolInterface = new Interface(StableSwapBBTC as any);
-  }
-
-  protected getPoolByAddress(address: Address) {
-    return (
-      this.eventPools.find(
-        p => p.address.toLowerCase() == address.toLowerCase(),
-      ) || null
-    );
-  }
-
-  protected getPoolConfigByAddress(address: Address) {
-    return Object.values(this.pools).find(p => p.address == address);
-  }
-
-  getPoolConfig(from: Token, to: Token): PoolConfig | undefined {
-    return this.getPoolConfigs(from, to)[0];
-  }
-
-  getPoolConfigs(from: Token, to: Token) {
-    const fromAddress = from.address.toLowerCase();
-    const toAddress = to.address.toLowerCase();
-    return Object.values(this.pools).filter(config => {
-      const underlying = config.underlying.map((add: string) =>
-        add.toLowerCase(),
-      );
-      const coins = config.coins.map((add: string) => add.toLowerCase());
-
-      // Case 0: If the swap is between the underlying first token and any underlying token
-      if (
-        underlying.length &&
-        ((underlying[0] === fromAddress && underlying.includes(toAddress)) ||
-          (underlying[0] === toAddress && underlying.includes(fromAddress)))
-      )
-        return true;
-      // Case 1: If it not a metapool and the swap is between any underlying tokens
-      if (
-        config.isLending &&
-        underlying.includes(toAddress) &&
-        underlying.includes(fromAddress)
-      )
-        return true;
-
-      // Case 2: If it a swap between any direct tokens
-      if (coins.includes(toAddress) && coins.includes(fromAddress)) return true;
-
-      return false;
-    });
-  }
-
-  async getPoolIdentifiers(
-    _from: Token,
-    _to: Token,
-    side: SwapSide,
-    blockNumber: number,
-  ): Promise<string[]> {
-    const pools = this.getPoolConfigs(_from, _to);
-    return pools.map(pool => this.getPoolIdentifier(pool.name));
-  }
-
-  getContractAddress(srcToken: Token, to: Token) {
-    const pool = this.getPoolConfig(srcToken, to);
-    return pool && pool.address;
-  }
-
-  poolConfigsByAddress() {
-    return Object.keys(this.pools).reduce((acc: any, poolName: string) => {
-      acc[this.pools[poolName].address.toLowerCase()] = this.pools[poolName];
-      return acc;
-    }, {});
-  }
-
-  // TODO: revisit to verify the chunks for BTC pools vs USD pools
-  getOnChainChunks(
-    from: Token,
-    to: Token,
-    srcAmount: bigint,
-    defaultChunks: number,
-  ) {
-    return CURVE_DEFAULT_CHUNKS;
-    //return srcAmount >= 10000n * getBigIntPow(from.decimals)
-    //  ? defaultChunks
-    //  : CURVE_DEFAULT_CHUNKS;
-  }
-
-  getEventPoolInstance(poolAddress: Address): CurvePool | CurveMetapool | null {
-    switch (poolAddress.toLowerCase()) {
-      case ThreePoolAddress:
-        return new ThreePool(this.dexKey, this.dexHelper);
-      case SUSDPoolAddress:
-        return new SUSDPool(this.dexKey, this.dexHelper);
-      case HBTCPoolAddress:
-        return new HBTCPool(this.dexKey, this.dexHelper);
-      case RenPoolAddress:
-        return new RenPool(this.dexKey, this.dexHelper);
-      case SBTCPoolAddress:
-        return new SBTCPool(this.dexKey, this.dexHelper);
-      case SETHPoolAddress:
-        return new SETHPool(this.dexKey, this.dexHelper);
-      case STETHPoolAddress:
-        return new STETHPool(this.dexKey, this.dexHelper);
-      case EURSPoolAddress:
-        return new EURSPool(this.dexKey, this.dexHelper);
-      case DUSDPoolAddress:
-        return new DUSDPool(this.dexKey, this.dexHelper);
-      case BBTCPoolAddress:
-        return new BBTCPool(this.dexKey, this.dexHelper);
-      case GUSDPoolAddress:
-        return new GUSDPool(this.dexKey, this.dexHelper);
-      case HUSDPoolAddress:
-        return new HUSDPool(this.dexKey, this.dexHelper);
-      case LinkUSDPoolAddress:
-        return new LinkUSDPool(this.dexKey, this.dexHelper);
-      case MUSDPoolAddress:
-        return new MUSDPool(this.dexKey, this.dexHelper);
-      case OBTCPoolAddress:
-        return new OBTCPool(this.dexKey, this.dexHelper);
-      case PBTCPoolAddress:
-        return new PBTCPool(this.dexKey, this.dexHelper);
-      case RSVPoolAddress:
-        return new RSVPool(this.dexKey, this.dexHelper);
-      case TBTCPoolAddress:
-        return new TBTCPool(this.dexKey, this.dexHelper);
-      case USDKPoolAddress:
-        return new USDKPool(this.dexKey, this.dexHelper);
-      case USTPoolAddress:
-        return new USTPool(this.dexKey, this.dexHelper);
-      case SLINKPoolAddress:
-        return new SLINKPool(this.dexKey, this.dexHelper);
-      default:
-        return null;
-    }
-  }
-
-  // Makes sure all the pools from poolAddress are being tracked. If a pool in not tracked yet
-  // fetch the state and setup the pool, if they are being watched but don't have a valid state
-  // add it to the list of unavailable pools. Return the list of unavailable pools.
-  async batchCatchUpPools(
-    poolAddresses: string[],
-    blockNumber: number,
-  ): Promise<string[]> {
-    const unavailablePools = new Array<string>();
-    if (!blockNumber) return unavailablePools;
-    let poolsToFetch: (CurvePool | CurveMetapool)[] = [];
-    for (const poolAddress of poolAddresses) {
-      // Check if the pool is already tracked
-      let pool = this.getPoolByAddress(poolAddress);
-      // If the pool is not stracked add it to the list of pools to fetch
-      if (!pool) {
-        let newPool = this.getEventPoolInstance(poolAddress);
-        if (!newPool)
-          throw new Error(
-            `Error_${this.dexKey} requested unsupported event pool with address ${poolAddress}`,
-          );
-
-        const addressesSubscribed = newPool.addressesSubscribed.map(address =>
-          address.toLowerCase(),
-        );
-        if (!addressesSubscribed.includes(poolAddress)) {
-          newPool.addressesSubscribed.push(poolAddress);
-        }
-
-        await newPool.initialize(blockNumber);
-        poolsToFetch.push(newPool);
-      } else if (!pool.getState(blockNumber)) {
-        unavailablePools.push(poolAddress);
-      }
-    }
-
-    if (!poolsToFetch.length) return unavailablePools;
-
-    try {
-      const poolStates = await getManyPoolStates(
-        poolsToFetch,
-        this.dexHelper.multiContract,
-        blockNumber,
-      );
-
-      for (let i = 0; i < poolsToFetch.length; i++) {
-        await poolsToFetch[i].setup(blockNumber, poolStates[i] as any);
-        this.eventPools.push(poolsToFetch[i]);
-      }
-      return unavailablePools;
-    } catch (e) {
-      this.logger.error(`Error_batchCatchUpPools`, e);
-      throw e;
-    }
-  }
-
-  async getRatesEventPools(
-    fromToken: Token,
-    toToken: Token,
-    amounts: BigNumber[],
-    fromBigNumbers: number,
-    pools: string[],
-    indexes: [number, number, number][],
-    blockNumber: number,
-  ) {
-    const unavailablePools = await this.batchCatchUpPools(pools, blockNumber);
-
-    if (unavailablePools.length) {
-      this.logger.error(
-        `Couldn't use events for ${unavailablePools.length} ${this.dexKey} pools!`,
-      );
-      pools = pools.filter(p => !unavailablePools.includes(p));
-    }
-
-    let rates = new Array(pools.length);
-    for (let i = 0; i < pools.length; i++) {
-      rates[i] = {
-        exchange: pools[i],
-        rates: this.getRatesEventPool(
-          pools[i],
-          indexes[i],
-          amounts,
-          fromBigNumbers,
-          blockNumber,
-        ),
-      };
-    }
-    return rates;
-  }
-
-  async getRatesOnChain(
-    fromToken: Token,
-    toToken: Token,
-    amounts: bigint[],
-    pools: string[],
-    indexes: [number, number, number][],
-    blockNumber: number,
-  ) {
-    const chunks = amounts.length - 1;
-    const srcAmount = amounts[chunks]!;
-
-    // The number of chunks used onchain to minimize the full node calls
-    const onChainChunks = this.getOnChainChunks(
-      fromToken,
-      toToken,
-      srcAmount,
-      chunks,
-    );
-
-    const _width = Math.floor(chunks / onChainChunks);
-
-    const unitVolume = amounts[0];
-    amounts[0] = 0n;
-
-    const _amounts = [unitVolume].concat(
-      Array.from(Array(onChainChunks).keys()).map(
-        i => amounts[(i + 1) * _width],
-      ),
-    );
-
-    const calldata = pools.map((p, i) =>
-      _amounts.map(_amount => ({
-        target: p,
-        callData: this.poolInterface.encodeFunctionData(
-          indexes[i][2] === 1 ? 'get_dy_underlying' : 'get_dy',
-          [indexes[i][0], indexes[i][1], _amount],
-        ),
-      })),
-    );
-
-    //const data = await this.multi.methods
-    //  .tryAggregate(false, calldata.flat())
-    //  .call({}, 'latest');
-    const data = (
-      await Promise.all(
-        calldata.map(async poolCalldata => {
-          try {
-            const result = await Utils.timeoutPromise<MultiResult<any>[]>(
-              this.dexHelper.multiContract.methods
-                .tryAggregate(false, poolCalldata)
-                .call({}, 'latest'),
-              2000,
-              `Timed out multicall for curve pool ${poolCalldata[0].target}`,
-            );
-            return result;
-          } catch (e) {
-            this.logger.error(e);
-            return Array<MultiResult<any>>(poolCalldata.length).fill({
-              success: false,
-              returnData: '0x',
-            });
-          }
-        }),
-      )
-    ).flat();
-
-    // Convert the on chain rates to the requested chunks, using simple interpolation
-    const correctChunks = (_r: bigint[]): bigint[] => [
-      _r[0],
-      ...interpolate(
-        _amounts.slice(1),
-        _r.slice(1),
-        amounts.slice(1),
-        SwapSide.SELL,
-      ),
-    ];
-
-    const decode = (j: number) => {
-      if (!data[j].success) return 0n;
-      const decoded = coder.decode(['uint256'], data[j].returnData);
-      return BigInt(decoded[0].toString());
-    };
-
-    let i = 0;
-    // chunks !== onChainChunks || !isAmountsLinear
-    const ratesAllPools = pools.map(p => {
-      const rates = _amounts.map(a => decode(i++));
-      return {
-        rates: correctChunks(rates),
-        exchange: p,
-      };
-    });
-
-    return ratesAllPools;
-  }
-
-  protected noMorePrice(prices: BigNumber[], index: number): boolean {
-    return index > 1 && prices[index - 1].eq(BN_0);
-  }
-
-  getRatesEventPool(
-    exchange: string,
-    curveIndexes: number[],
-    amounts: BigNumber[],
-    fromBigNumbers: number,
-    blockNumber: number,
-  ) {
-    let rates = new Array<BigNumber>(amounts.length).fill(BN_0);
-
-    let fromIndex = curveIndexes[0];
-    let toIndex = curveIndexes[1];
-    let isTokenSwap = curveIndexes[2] === 1;
-
-    let pool = this.getPoolByAddress(exchange);
-    if (!pool) {
-      throw new Error(
-        `Error_${this.dexKey}_getRatesEvent pool is not initialised`,
-      );
-    }
-
-    const state = pool.getState(blockNumber);
-    if (!state)
-      throw new Error(
-        `Error_${this.dexKey}_${pool.name} expected state at blocknumber ${blockNumber}, got none`,
-      );
-
-    if (isTokenSwap) {
-      rates[0] = pool.get_dy_underlying(
-        fromIndex,
-        toIndex,
-        amounts[0],
-        state as any,
-      );
-
-      for (let i = 1; i < amounts.length; i++) {
-        rates[i] = this.noMorePrice(rates, i)
-          ? BN_0
-          : pool.get_dy_underlying(
-              fromIndex,
-              toIndex,
-              amounts[i],
-              state as any,
-            );
-      }
-    } else {
-      rates[0] = pool.get_dy(fromIndex, toIndex, amounts[0], state as any);
-
-      for (let i = 1; i < amounts.length; i++) {
-        rates[i] = this.noMorePrice(rates, i)
-          ? BN_0
-          : pool.get_dy(fromIndex, toIndex, amounts[i], state as any);
-      }
-    }
-
-    let floatRates = rates.map(rate => BigInt(rate.toFixed(0)));
-    return floatRates;
-  }
-
-  isEventPoolSupported(poolAddress: Address): Boolean {
-    return this.eventSupportedPools.some(p => p === poolAddress.toLowerCase());
-  }
-
-  allocPools(
-    from: Token,
-    to: Token,
-    side: SwapSide,
-    routeID: number,
-    usedPools: { [poolIdentifier: string]: number },
-    isFirstSwap: boolean,
-  ) {
-    if (side === SwapSide.BUY) {
-      return;
-    }
-
-    this.getPoolConfigs(from, to).forEach(p => {
-      const poolIdentifier = this.getPoolIdentifier(p.name);
-      if (!(poolIdentifier in usedPools)) {
-        usedPools[poolIdentifier] = routeID;
-      }
-    });
-  }
-
-  public getPoolIdentifier(name: string) {
-    return `${this.dexKey}_${name.toLowerCase()}`;
-  }
-
-  async getPricesVolume(
-    _from: Token,
-    _to: Token,
-    amounts: bigint[],
-    side: SwapSide,
-    blockNumber: number,
-    // list of pool identifiers to use for pricing, if undefined use all pools
-    limitPools?: string[],
-    transferFees: TransferFeeParams = {
-      srcFee: 0,
-      destFee: 0,
-      srcDexFee: 0,
-      destDexFee: 0,
-    },
-  ): Promise<ExchangePrices<CurveV1Data> | null> {
-    try {
-      if (side === SwapSide.BUY) {
-        return null;
-      }
-
-      _from.address = _from.address.toLowerCase();
-      _to.address = _to.address.toLowerCase();
-
-      const _isSrcTokenTransferFeeToBeExchanged =
-        this.disableFeeOnTransferTokenAddresses.has(_from.address)
-          ? false
-          : isSrcTokenTransferFeeToBeExchanged(transferFees);
-
-      const _isDestTokenTransferFeeToBeExchanged =
-        this.disableFeeOnTransferTokenAddresses.has(_to.address)
-          ? false
-          : isDestTokenTransferFeeToBeExchanged(transferFees);
-
-      // We first filter out pools which were explicitly excluded and pools which are already used
-      // then for the good pools we set the boolean to be true for used pools
-      // and for each pool we take the address.
-      const goodPoolConfigs = this.getPoolConfigs(_from, _to).filter(p => {
-        if (limitPools !== undefined) {
-          const id = this.getPoolIdentifier(p.name);
-          if (!limitPools.includes(id)) {
-            return false;
-          }
-        }
-
-        if (_isSrcTokenTransferFeeToBeExchanged) {
-          // Fee on transfers supported only when flag is specified
-          return !!p.isFeeOnTransferSupported;
-        }
-        return true;
-      });
-
-      const goodPoolAddress = goodPoolConfigs.map(p => p.address);
-      const indexesByAddress = goodPoolConfigs.reduce(
-        (acc: { [address: string]: [number, number, number] }, pc) => {
-          acc[pc.address] = this.getSwapIndexes(_from, _to, pc);
-          return acc;
-        },
-        {},
-      );
-
-      if (goodPoolAddress.length === 0) {
-        return null;
-      }
-
-      const amountsWithUnit = [
-        getBigIntPow(_from.decimals),
-        ...amounts.slice(1),
-      ];
-      const amountsWithUnitAndFee = _isSrcTokenTransferFeeToBeExchanged
-        ? applyTransferFee(
-            applyTransferFee(
-              amountsWithUnit,
-              side,
-              transferFees.srcFee,
-              SRC_TOKEN_PARASWAP_TRANSFERS,
-            ),
-            side,
-            transferFees.srcDexFee,
-            this.SRC_TOKEN_DEX_TRANSFERS,
-          )
-        : amountsWithUnit;
-
-      let _prices = new Array();
-
-      const eventPools = goodPoolAddress.filter(p =>
-        this.isEventPoolSupported(p),
-      );
-      const eventPoolIndexes = eventPools.map(ep => indexesByAddress[ep]);
-      if (eventPools) {
-        const pricesEvents = await this.getRatesEventPools(
-          _from,
-          _to,
-          amountsWithUnitAndFee.map(a => new BigNumber(a.toString())),
-          _from.decimals,
-          eventPools,
-          eventPoolIndexes,
-          blockNumber,
-        );
-        _prices = _prices.concat(pricesEvents);
-      }
-
-      // if the pool rates was not available in the event pool then fallback to the onchain pool query
-      const isPoolNotInPrices = (poolAddress: Address) =>
-        !_prices.find(
-          existingPrice =>
-            existingPrice.exchange.toLowerCase() === poolAddress.toLowerCase(),
-        );
-      const onChainPools = goodPoolAddress.filter(isPoolNotInPrices);
-
-      const onChainPoolIndexes = onChainPools.map(op => indexesByAddress[op]);
-
-      // onChainPools are only supported for pools with linear price chunks
-      if (onChainPools.length) {
-        const pricesOnChain = await this.getRatesOnChain(
-          _from,
-          _to,
-          amountsWithUnitAndFee,
-          onChainPools,
-          onChainPoolIndexes,
-          blockNumber,
-        );
-        _prices = _prices.concat(pricesOnChain);
-      }
-
-      const poolConfigsByAddress = this.poolConfigsByAddress();
-
-      const poolPrices = _prices.reduce(
-        (acc: PoolPrices<CurveV1Data>[], _price: any, idx: number) => {
-          if (
-            _price.exchange === NULL_ADDRESS ||
-            !(_price.exchange.toLowerCase() in poolConfigsByAddress)
-          )
-            return acc;
-
-          const poolConfig =
-            poolConfigsByAddress[_price.exchange.toLowerCase()];
-          const indexes = this.getSwapIndexes(_from, _to, poolConfig);
-          const [i, j, swapType] = indexes;
-
-          if (_isDestTokenTransferFeeToBeExchanged) {
-            _price.rates = applyTransferFee(
-              _price.rates,
-              side,
-              transferFees.destDexFee,
-              this.DEST_TOKEN_DEX_TRANSFERS,
-            );
-          }
-
-          acc.push({
-            prices: [0n, ..._price.rates.slice(1)],
-            unit: _price.rates[0],
-            data: {
-              exchange: _price.exchange,
-              i,
-              j,
-              underlyingSwap: swapType === 1,
-              deadline: 0,
-            },
-            exchange: this.dexKey,
-            poolIdentifier: `${this.dexKey}_${poolConfig.name.toLowerCase()}`,
-            gasCost: poolConfig.isLending
-              ? CURVE_LENDING_POOl_GAS
-              : CURVE_POOL_GAS,
-            poolAddresses: [_price.exchange],
-          });
-          return acc;
-        },
-        [],
-      );
-      return poolPrices;
-    } catch (e) {
-      if (blockNumber === 0)
-        this.logger.error(
-          `Error_${this.dexKey}_getPrices: Aurelius block manager not yet instantiated`,
-        );
-      this.logger.error(`Error_${this.dexKey}_getPrices`, e);
-      return null;
-    }
-  }
-
-  getSwapIndexes(
-    from: Token,
-    to: Token,
-    pool?: PoolConfig,
-  ): [number, number, number] {
-    pool = pool || this.getPoolConfig(from, to);
-    if (!pool) {
-      return [-1, -1, -1];
-    }
-
-    const fromAddress = from.address.toLowerCase();
-    const toAddress = to.address.toLowerCase();
-    const isUnderlyingSwap =
-      pool.underlying.length &&
-      pool.underlying.some(t => t.toLowerCase() === fromAddress) &&
-      pool.underlying.some(t => t.toLowerCase() === toAddress);
-
-    const fromIndex = isUnderlyingSwap
-      ? pool.underlying.findIndex(t => t.toLowerCase() === fromAddress)
-      : pool.coins.findIndex(t => t.toLowerCase() === fromAddress);
-
-    const toIndex = isUnderlyingSwap
-      ? pool.underlying.findIndex(t => t.toLowerCase() === toAddress)
-      : pool.coins.findIndex(t => t.toLowerCase() === toAddress);
-
-    const swapType = isUnderlyingSwap ? 1 : 2;
-
-    return [fromIndex, toIndex, swapType];
-  }
-
-  getAdapterParam(
-    srcToken: string,
-    destToken: string,
-    srcAmount: string,
-    destAmount: string,
-    data: CurveV1Data,
-    side: SwapSide,
-  ): AdapterExchangeParam {
-    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
-
-    const { i, j, deadline, underlyingSwap } = data;
-    const payload = this.abiCoder.encodeParameter(
-      {
-        ParentStruct: {
-          i: 'int128',
-          j: 'int128',
-          deadline: 'uint256',
-          underlyingSwap: 'bool',
-        },
-      },
-      { i, j, deadline, underlyingSwap },
-    );
-
-    return {
-      targetExchange: data.exchange,
-      payload,
-      networkFee: '0',
-    };
-  }
-
-  getCalldataGasCost(poolPrices: PoolPrices<CurveV1Data>): number | number[] {
-    return (
-      CALLDATA_GAS_COST.DEX_OVERHEAD +
-      CALLDATA_GAS_COST.LENGTH_SMALL +
-      CALLDATA_GAS_COST.INDEX +
-      CALLDATA_GAS_COST.INDEX +
-      CALLDATA_GAS_COST.TIMESTAMP +
-      CALLDATA_GAS_COST.BOOL
-    );
-  }
-
-  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
-    return this.adapters[side];
-  }
-
-  static getDirectFunctionName(): string[] {
-    return [DIRECT_METHOD_NAME];
-  }
-
-  getTokenFromAddress(address: Address): Token {
-    // In this Dex decimals are not used
-    return { address, decimals: 0 };
-  }
-
-  async preProcessTransaction(
-    optimalSwapExchange: OptimalSwapExchange<CurveV1Data>,
-    srcToken: Token,
-    _0: Token,
-    _1: SwapSide,
-    options: PreprocessTransactionOptions,
-  ): Promise<[OptimalSwapExchange<CurveV1Data>, ExchangeTxInfo]> {
-    if (!options.isDirectMethod) {
-      return [
-        optimalSwapExchange,
-        {
-          deadline: BigInt(getLocalDeadlineAsFriendlyPlaceholder()),
-        },
-      ];
-    }
-
-    assert(
-      optimalSwapExchange.data !== undefined,
-      `preProcessTransaction: data field is missing`,
-    );
-
-    let isApproved: boolean | undefined;
-
-    try {
-      isApproved = await this.dexHelper.augustusApprovals.hasApproval(
-        options.executionContractAddress,
-        this.dexHelper.config.wrapETH(srcToken).address,
-        optimalSwapExchange.data.exchange,
-      );
-    } catch (e) {
-      this.logger.error(
-        `preProcessTransaction failed to retrieve allowance info: `,
-        e,
-      );
-    }
-
-    return [
-      {
-        ...optimalSwapExchange,
-        data: {
-          ...optimalSwapExchange.data,
-          isApproved,
-        },
-      },
-      {
-        deadline: BigInt(getLocalDeadlineAsFriendlyPlaceholder()),
-      },
-    ];
-  }
-
-  getDirectParam(
-    srcToken: Address,
-    destToken: Address,
-    srcAmount: NumberAsString,
-    destAmount: NumberAsString,
-    expectedAmount: NumberAsString,
-    data: CurveV1Data,
-    side: SwapSide,
-    permit: string,
-    uuid: string,
-    feePercent: NumberAsString,
-    deadline: NumberAsString,
-    partner: string,
-    beneficiary: string,
-    contractMethod?: string,
-  ): TxInfo<DirectCurveV1Param> {
-    if (contractMethod !== DIRECT_METHOD_NAME) {
-      throw new Error(`Invalid contract method ${contractMethod}`);
-    }
-    assert(side === SwapSide.SELL, 'Buy not supported');
-
-    let isApproved: boolean = !!data.isApproved;
-    if (data.isApproved === undefined) {
-      this.logger.warn(`isApproved is undefined, defaulting to false`);
-    }
-
-    const swapParams: DirectCurveV1Param = [
-      srcToken,
-      destToken,
-      data.exchange,
-      srcAmount,
-      destAmount,
-      expectedAmount,
-      feePercent,
-      data.i.toString(),
-      data.j.toString(),
-      partner,
-      isApproved,
-      data.underlyingSwap
-        ? CurveV1SwapType.EXCHANGE_UNDERLYING
-        : CurveV1SwapType.EXCHANGE,
-      beneficiary,
-      // For CurveV1 we work as it is, without wrapping and unwrapping
-      false,
-      permit,
-      uuidToBytes16(uuid),
-    ];
-
-    const encoder = (...params: DirectCurveV1Param) => {
-      return this.directSwapIface.encodeFunctionData(DIRECT_METHOD_NAME, [
-        params,
-      ]);
-    };
-
-    return {
-      params: swapParams,
-      encoder,
-      networkFee: '0',
-    };
-  }
-
-  getDirectParamV6(
-    srcToken: Address,
-    destToken: Address,
-    fromAmount: NumberAsString,
-    toAmount: NumberAsString,
-    quotedAmount: NumberAsString,
-    data: CurveV1Data,
-    side: SwapSide,
-    permit: string,
-    uuid: string,
-    partnerAndFee: string,
-    beneficiary: string,
-    blockNumber: number,
-    contractMethod?: string,
-  ) {
-    if (contractMethod !== DIRECT_METHOD_NAME_V6) {
-      throw new Error(`Invalid contract method ${contractMethod}`);
-    }
-    assert(side === SwapSide.SELL, 'Buy not supported');
-
-    const metadata = hexConcat([
-      hexZeroPad(uuidToBytes16(uuid), 16),
-      hexZeroPad(hexlify(blockNumber), 16),
-    ]);
-
-    const swapParams: DirectCurveV1ParamV6 = [
-      packCurveData(
-        data.exchange,
-        !data.isApproved, // approve flag, if not approved then set to true
-        isETHAddress(destToken) ? 0 : isETHAddress(srcToken) ? 3 : 0,
-        data.underlyingSwap
-          ? CurveV1SwapType.EXCHANGE_UNDERLYING
-          : CurveV1SwapType.EXCHANGE,
-      ).toString(),
-      encodeCurveAssets(data.i, data.j).toString(),
-      srcToken,
-      destToken,
-      fromAmount,
-      toAmount,
-      quotedAmount,
-      metadata,
-      beneficiary,
-    ];
-
-    const encodeParams: CurveV1DirectSwap = [swapParams, partnerAndFee, permit];
-
-    const encoder = (...params: CurveV1DirectSwap) => {
-      return this.augustusV6Interface.encodeFunctionData(
-        DIRECT_METHOD_NAME_V6,
-        [...params],
-      );
-    };
-
-    return {
-      encoder,
-      params: encodeParams,
-      networkFee: '0',
-    };
-  }
-
-  static getDirectFunctionNameV6(): string[] {
-    return [DIRECT_METHOD_NAME_V6];
-  }
-
-  getDexParam(
-    srcToken: Address,
-    destToken: Address,
-    srcAmount: NumberAsString,
-    destAmount: NumberAsString,
-    recipient: Address,
-    data: CurveV1Data,
-    side: SwapSide,
-  ): DexExchangeParam {
-    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
-
-    const { exchange, i, j, underlyingSwap } = data;
-    const defaultArgs = [i, j, srcAmount, this.minConversionRate];
-    const swapMethod = underlyingSwap
-      ? CurveSwapFunctions.exchange_underlying
-      : CurveSwapFunctions.exchange;
-    const exchangeData = this.exchangeRouterInterface.encodeFunctionData(
-      swapMethod,
-      defaultArgs,
-    );
-
-    return {
-      exchangeData,
-      needWrapNative: this.needWrapNative,
-      sendEthButSupportsInsertFromAmount: true,
-      dexFuncHasRecipient: false,
-      targetExchange: exchange,
-      returnAmountPos: undefined,
-    };
-  }
-
-  async getSimpleParam(
-    srcToken: string,
-    destToken: string,
-    srcAmount: string,
-    destAmount: string,
-    data: CurveV1Data,
-    side: SwapSide,
-  ): Promise<SimpleExchangeParam> {
-    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
-
-    const { exchange, i, j, underlyingSwap } = data;
-    const defaultArgs = [i, j, srcAmount, this.minConversionRate];
-    const swapMethod = underlyingSwap
-      ? CurveSwapFunctions.exchange_underlying
-      : CurveSwapFunctions.exchange;
-    const swapData = this.exchangeRouterInterface.encodeFunctionData(
-      swapMethod,
-      defaultArgs,
-    );
-
-    return this.buildSimpleParamWithoutWETHConversion(
-      srcToken,
-      srcAmount,
-      destToken,
-      destAmount,
-      swapData,
-      exchange,
-    );
-  }
-
-  async updateBaseTokenPrice() {
-    for (let baseToken of Object.values(this.baseTokens)) {
-      const usdPrice = await this.dexHelper.getTokenUSDPrice(
-        baseToken,
-        baseToken.reasonableVolume,
-      );
-
-      const denominator =
-        Number(baseToken.reasonableVolume) / 10 ** baseToken.decimals;
-
-      baseToken.tokenPrice = usdPrice / denominator;
-    }
-  }
-
-  async fetchDecimals() {
-    const calls = Object.values(this.pools).reduce<MultiCallParams<any>[]>(
-      (acc, pool) => {
-        const underlyingDecimalsCalls = pool.underlying.reduce<
-          MultiCallParams<any>[]
-        >((_acc, _token) => {
-          const token = _token.toLowerCase();
-          if (token === ETHER_ADDRESS) {
-            this.decimalsCoinsAndUnderlying[token] = 18;
-          } else {
-            _acc.push({
-              target: token,
-              callData: erc20Iface.encodeFunctionData('decimals'),
-              decodeFunction: uin128DecodeToInt,
-              cb: (decimals: number) => {
-                this.decimalsCoinsAndUnderlying[token.toLowerCase()] = decimals;
-              },
-            });
-          }
-
-          return _acc;
-        }, []);
-
-        const coinsDecimalsCalls = pool.coins.reduce<MultiCallParams<any>[]>(
-          (_acc, _coin) => {
-            const coin = _coin.toLowerCase();
-            if (coin === ETHER_ADDRESS) {
-              this.decimalsCoinsAndUnderlying[coin] = 18;
-            } else {
-              _acc.push({
-                target: coin,
-                callData: erc20Iface.encodeFunctionData('decimals'),
-                decodeFunction: uin128DecodeToInt,
-                cb: (decimals: number) => {
-                  this.decimalsCoinsAndUnderlying[coin.toLowerCase()] =
-                    decimals;
-                },
-              });
-            }
-            return _acc;
-          },
-          [],
-        );
-
-        acc.push(...underlyingDecimalsCalls, ...coinsDecimalsCalls);
-        return acc;
-      },
-      [],
-    );
-
-    return this.dexHelper.multiWrapper!.tryAggregate(true, calls);
-  }
-
-  async fetchAllPools() {
-    try {
-      // Hack: We choose to check the balance of the token for the pool instead of calling
-      // the balances array in the pool as it was a mess to have each curve abi
-      // Some have balances[uint128] some have balances[uint256]
-      // One of the consequence for such a hack is below for ETH Pools
-      // TODO: below can be highly optimized
-      // * we don't need to query token decimals every iteration
-      // * we can use the decimals from the tokens list using the api
-
-      const calls = Object.values(this.pools).reduce<MultiCallParams<number>[]>(
-        (acc, pool) => {
-          const coinCalls = pool.coins.map<MultiCallParams<number>>(coin => {
-            const coinLowerCase = coin.toLowerCase();
-            if (coinLowerCase === ETHER_ADDRESS) {
-              return {
-                target:
-                  this.dexHelper.config.data.multicallV2Address.toLowerCase(),
-                callData: this.dexHelper.multiContract.methods
-                  .getEthBalance(pool.address.toLowerCase())
-                  .encodeABI(),
-                decodeFunction: uin256DecodeToFloat,
-              };
-            } else {
-              return {
-                target: coinLowerCase,
-                callData: erc20Iface.encodeFunctionData('balanceOf', [
-                  pool.address,
-                ]),
-                decodeFunction: uin256DecodeToFloat,
-              };
-            }
-          });
-          acc.push(...coinCalls);
-          return acc;
-        },
-        [],
-      );
-
-      const results = await this.dexHelper.multiWrapper!.tryAggregate(
-        true,
-        calls,
-      );
-
-      let index = 0;
-      Object.values(this.pools).forEach(pool => {
-        const balances = results.slice(index, index + pool.coins.length);
-        index += pool.coins.length;
-
-        const sumLiquidity = balances.reduce((acc, balance, i) => {
-          const coin = pool.coins[i].toLowerCase();
-          const decimals = this.decimalsCoinsAndUnderlying[coin];
-
-          return acc + balance.returnData / 10 ** decimals;
-        }, 0);
-
-        let liquidityUSD = 0;
-        if (pool.baseToken) {
-          if (!this.baseTokens[pool.baseToken]) {
-            throw new Error(
-              `missing base token ${pool.baseToken} for ${this.dexKey}`,
-            );
-          }
-          liquidityUSD =
-            sumLiquidity * Number(this.baseTokens[pool.baseToken].tokenPrice!);
-        }
-
-        pool.liquidityUSD = liquidityUSD;
-      });
-    } catch (e) {
-      this.logger.error(`fetchAllPools ${this.dexKey}`, e);
-      throw e;
-    }
-  }
-
-  async updatePoolState(): Promise<void> {
-    if (!Object.keys(this.decimalsCoinsAndUnderlying).length) {
-      await this.fetchDecimals();
-    }
-
-    await this.updateBaseTokenPrice();
-    await this.fetchAllPools();
-  }
-
-  async getTopPoolsForToken(
-    tokenAddress: Address,
-    limit: number,
-  ): Promise<PoolLiquidity[]> {
-    const _tokenAddress = this.dexHelper.config.unwrapETH({
-      address: tokenAddress,
-      decimals: 18,
-    }).address;
-    // In general case a token can be in the coins or underlying
-    // In case of the metapool the token might be in both at the same time
-    // It is important to note that the connector tokens might not be
-    // compatible for exchange among themselves.
-    const selectedPool = Object.values(this.pools).reduce<PoolLiquidity[]>(
-      (acc, pool) => {
-        const inCoins = pool.coins.some(
-          _token => _token.toLowerCase() === _tokenAddress.toLowerCase(),
-        );
-        const inUnderlying = pool.underlying.some(
-          _token => _token.toLowerCase() === _tokenAddress.toLowerCase(),
-        );
-        let connectorTokens = inCoins ? pool.coins : [];
-        connectorTokens = inUnderlying
-          ? _.concat(connectorTokens, pool.underlying)
-          : connectorTokens;
-
-        if (connectorTokens.length) {
-          acc.push({
-            exchange: this.dexKey,
-            address: pool.address,
-            liquidityUSD: pool.liquidityUSD!,
-            connectorTokens: _.uniq(connectorTokens)
-              .filter(
-                (_token: string) =>
-                  _token.toLowerCase() !== _tokenAddress.toLowerCase(),
-              )
-              .map(tokenAddress => {
-                const address = tokenAddress.toLowerCase();
-                return {
-                  address,
-                  decimals: this.decimalsCoinsAndUnderlying[address],
-                };
-              }),
-          });
-        }
-        return acc;
-      },
-      [],
-    );
-    return selectedPool
-      .sort((a, b) => b.liquidityUSD - a.liquidityUSD)
-      .slice(0, limit);
-  }
-}
+import { Interface, AbiCoder, JsonFragment } from '@ethersproject/abi';
+import _ from 'lodash';
+import { NumberAsString, OptimalSwapExchange } from '@paraswap/core';
+import { assert } from 'ts-essentials';
+import BigNumber from 'bignumber.js';
+import CurveABI from '../../abi/Curve.json';
+import DirectSwapABI from '../../abi/DirectSwap.json';
+import { Adapters, CurveV1Config } from './config';
+
+import {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  ExchangePrices,
+  ExchangeTxInfo,
+  PoolLiquidity,
+  PoolPrices,
+  PreprocessTransactionOptions,
+  SimpleExchangeParam,
+  Token,
+  TransferFeeParams,
+  TxInfo,
+} from '../../types';
+import {
+  Network,
+  NULL_ADDRESS,
+  SRC_TOKEN_PARASWAP_TRANSFERS,
+  ETHER_ADDRESS,
+  SwapSide,
+} from '../../constants';
+import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
+import StableSwapBBTC from '../../abi/curve-v1/StableSwapBBTC.json';
+import { CurvePool } from './pools/curve-pool';
+import { CurveMetapool } from './pools/curve-metapool';
+import { ThreePool, address as ThreePoolAddress } from './pools/3pool';
+import { SUSDPool, address as SUSDPoolAddress } from './pools/sUSDpool';
+import { HBTCPool, address as HBTCPoolAddress } from './pools/hBTCpool';
+import { RenPool, address as RenPoolAddress } from './pools/renpool';
+import { SBTCPool, address as SBTCPoolAddress } from './pools/sBTCpool';
+import { SETHPool, address as SETHPoolAddress } from './pools/sETHpool';
+import { STETHPool, address as STETHPoolAddress } from './pools/stETHpool';
+import { EURSPool, address as EURSPoolAddress } from './pools/EURSpool';
+import { DUSDPool, address as DUSDPoolAddress } from './pools/DUSDpool';
+import { BBTCPool, address as BBTCPoolAddress } from './pools/bBTCpool';
+import { GUSDPool, address as GUSDPoolAddress } from './pools/GUSDpool';
+import { HUSDPool, address as HUSDPoolAddress } from './pools/HUSDpool';
+import {
+  LinkUSDPool,
+  address as LinkUSDPoolAddress,
+} from './pools/LinkUSDpool';
+import { MUSDPool, address as MUSDPoolAddress } from './pools/MUSDpool';
+import { OBTCPool, address as OBTCPoolAddress } from './pools/oBTCpool';
+import { PBTCPool, address as PBTCPoolAddress } from './pools/pBTCpool';
+import { RSVPool, address as RSVPoolAddress } from './pools/rsvpool';
+import { TBTCPool, address as TBTCPoolAddress } from './pools/tBTCpool';
+import { USDKPool, address as USDKPoolAddress } from './pools/usdkpool';
+import { USTPool, address as USTPoolAddress } from './pools/ustpool';
+import { SLINKPool, address as SLINKPoolAddress } from './pools/sLinkpool';
+import {
+  getBigIntPow,
+  getDexKeysWithNetwork,
+  interpolate,
+  isDestTokenTransferFeeToBeExchanged,
+  isETHAddress,
+  isSrcTokenTransferFeeToBeExchanged,
+  Utils,
+  uuidToBytes16,
+} from '../../utils';
+import { BN_0 } from '../../bignumber-constants';
+import {
+  getLocalDeadlineAsFriendlyPlaceholder,
+  SimpleExchange,
+} from '../simple-exchange';
+import { IDex } from '../idex';
+import { IDexHelper } from '../../dex-helper';
+import { Logger } from 'log4js';
+import { uin128DecodeToInt, uin256DecodeToFloat } from '../../lib/decoders';
+import { getManyPoolStates } from './pools/getstate-multicall';
+import { MultiCallParams, MultiResult } from '../../lib/multi-wrapper';
+import {
+  PoolConfig,
+  CurveV1Data,
+  TokenWithReasonableVolume,
+  CurveSwapFunctions,
+  CurveV1SwapType,
+  DirectCurveV1Param,
+  DirectCurveV1ParamV6,
+  CurveV1DirectSwap,
+} from './types';
+import { erc20Iface } from '../../lib/utils-interfaces';
+import { applyTransferFee } from '../../lib/token-transfer-fee';
+import { DIRECT_METHOD_NAME, DIRECT_METHOD_NAME_V6 } from './constants';
+import { packCurveData } from '../../lib/curve/encoder';
+import { encodeCurveAssets } from './packer';
+import { hexConcat, hexZeroPad, hexlify } from 'ethers/lib/utils';
+
+const CURVE_DEFAULT_CHUNKS = 10;
+
+const CURVE_LENDING_POOl_GAS = 340 * 1000;
+const CURVE_POOL_GAS = 200 * 1000;
+
+const coder = new AbiCoder();
+
+export class CurveV1
+  extends SimpleExchange
+  implements IDex<CurveV1Data, DirectCurveV1Param | CurveV1DirectSwap>
+{
+  exchangeRouterInterface: Interface;
+  minConversionRate = '1';
+
+  eventPools = new Array<CurvePool | CurveMetapool>();
+  public poolInterface: Interface;
+
+  private logger: Logger;
+
+  readonly hasConstantPriceLargeAmounts = false;
+  readonly isFeeOnTransferSupported = true;
+
+  private decimalsCoinsAndUnderlying: Record<string, number> = {};
+
+  protected pools: Record<string, PoolConfig>;
+  protected eventSupportedPools: string[];
+  protected baseTokens: Record<string, TokenWithReasonableVolume>;
+
+  protected disableFeeOnTransferTokenAddresses: Set<string>;
+
+  readonly directSwapIface = new Interface(DirectSwapABI);
+
+  readonly SRC_TOKEN_DEX_TRANSFERS = 1;
+  readonly DEST_TOKEN_DEX_TRANSFERS = 1;
+
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(CurveV1Config);
+
+  constructor(
+    protected network: Network,
+    dexKey: string,
+    protected dexHelper: IDexHelper,
+    dexConfig = CurveV1Config[dexKey][network],
+
+    protected adapters = Adapters[network],
+  ) {
+    super(dexHelper, dexKey);
+    this.pools = Object.keys(dexConfig.pools).reduce<
+      Record<string, PoolConfig>
+    >((acc, key) => {
+      const poolConf = dexConfig.pools[key];
+
+      acc[key] = {
+        underlying: poolConf.underlying.map(t => t.toLowerCase()),
+        coins: poolConf.coins.map(t => t.toLowerCase()),
+        address: poolConf.address.toLowerCase(),
+        name: poolConf.name,
+        type: poolConf.type,
+        version: poolConf.version,
+        isLending: poolConf.isLending,
+        isMetapool: poolConf.isMetapool,
+        baseToken: poolConf.baseToken
+          ? poolConf.baseToken.toLowerCase()
+          : poolConf.baseToken,
+        liquidityUSD: poolConf.liquidityUSD,
+        trackCoins: poolConf.trackCoins,
+        useLending: poolConf.useLending,
+        precisionMul: poolConf.precisionMul,
+        tokenAddress: poolConf.tokenAddress
+          ? poolConf.tokenAddress.toLowerCase()
+          : undefined,
+        isFeeOnTransferSupported: poolConf.isFeeOnTransferSupported,
+      };
+
+      return acc;
+    }, {});
+
+    this.eventSupportedPools = dexConfig.eventSupportedPools.map(addr =>
+      addr.toLowerCase(),
+    );
+
+    this.baseTokens = Object.keys(dexConfig.baseTokens).reduce<
+      Record<string, TokenWithReasonableVolume>
+    >((acc, key) => {
+      const baseToken = dexConfig.baseTokens[key];
+      acc[key.toLowerCase()] = {
+        address: baseToken.address.toLowerCase(),
+        decimals: baseToken.decimals,
+        reasonableVolume: baseToken.reasonableVolume,
+      };
+      return acc;
+    }, {});
+
+    this.disableFeeOnTransferTokenAddresses =
+      dexConfig.disableFeeOnTransferTokenAddresses
+        ? new Set<string>(
+            Array.from(
+              dexConfig.disableFeeOnTransferTokenAddresses.values(),
+            ).map(addr => addr.toLowerCase()),
+          )
+        : new Set<string>();
+
+    this.exchangeRouterInterface = new Interface(CurveABI as JsonFragment[]);
+
+    this.logger = dexHelper.getLogger(dexKey);
+
+    this.poolInterface = new Interface(StableSwapBBTC as any);
+  }
+
+  protected getPoolByAddress(address: Address) {
+    return (
+      this.eventPools.find(
+        p => p.address.toLowerCase() == address.toLowerCase(),
+      ) || null
+    );
+  }
+
+  protected getPoolConfigByAddress(address: Address) {
+    return Object.values(this.pools).find(p => p.address == address);
+  }
+
+  getPoolConfig(from: Token, to: Token): PoolConfig | undefined {
+    return this.getPoolConfigs(from, to)[0];
+  }
+
+  getPoolConfigs(from: Token, to: Token) {
+    const fromAddress = from.address.toLowerCase();
+    const toAddress = to.address.toLowerCase();
+    return Object.values(this.pools).filter(config => {
+      const underlying = config.underlying.map((add: string) =>
+        add.toLowerCase(),
+      );
+      const coins = config.coins.map((add: string) => add.toLowerCase());
+
+      // Case 0: If the swap is between the underlying first token and any underlying token
+      if (
+        underlying.length &&
+        ((underlying[0] === fromAddress && underlying.includes(toAddress)) ||
+          (underlying[0] === toAddress && underlying.includes(fromAddress)))
+      )
+        return true;
+      // Case 1: If it not a metapool and the swap is between any underlying tokens
+      if (
+        config.isLending &&
+        underlying.includes(toAddress) &&
+        underlying.includes(fromAddress)
+      )
+        return true;
+
+      // Case 2: If it a swap between any direct tokens
+      if (coins.includes(toAddress) && coins.includes(fromAddress)) return true;
+
+      return false;
+    });
+  }
+
+  async getPoolIdentifiers(
+    _from: Token,
+    _to: Token,
+    side: SwapSide,
+    blockNumber: number,
+  ): Promise<string[]> {
+    const pools = this.getPoolConfigs(_from, _to);
+    return pools.map(pool => this.getPoolIdentifier(pool.name));
+  }
+
+  getContractAddress(srcToken: Token, to: Token) {
+    const pool = this.getPoolConfig(srcToken, to);
+    return pool && pool.address;
+  }
+
+  poolConfigsByAddress() {
+    return Object.keys(this.pools).reduce((acc: any, poolName: string) => {
+      acc[this.pools[poolName].address.toLowerCase()] = this.pools[poolName];
+      return acc;
+    }, {});
+  }
+
+  // TODO: revisit to verify the chunks for BTC pools vs USD pools
+  getOnChainChunks(
+    from: Token,
+    to: Token,
+    srcAmount: bigint,
+    defaultChunks: number,
+  ) {
+    return CURVE_DEFAULT_CHUNKS;
+    //return srcAmount >= 10000n * getBigIntPow(from.decimals)
+    //  ? defaultChunks
+    //  : CURVE_DEFAULT_CHUNKS;
+  }
+
+  getEventPoolInstance(poolAddress: Address): CurvePool | CurveMetapool | null {
+    switch (poolAddress.toLowerCase()) {
+      case ThreePoolAddress:
+        return new ThreePool(this.dexKey, this.dexHelper);
+      case SUSDPoolAddress:
+        return new SUSDPool(this.dexKey, this.dexHelper);
+      case HBTCPoolAddress:
+        return new HBTCPool(this.dexKey, this.dexHelper);
+      case RenPoolAddress:
+        return new RenPool(this.dexKey, this.dexHelper);
+      case SBTCPoolAddress:
+        return new SBTCPool(this.dexKey, this.dexHelper);
+      case SETHPoolAddress:
+        return new SETHPool(this.dexKey, this.dexHelper);
+      case STETHPoolAddress:
+        return new STETHPool(this.dexKey, this.dexHelper);
+      case EURSPoolAddress:
+        return new EURSPool(this.dexKey, this.dexHelper);
+      case DUSDPoolAddress:
+        return new DUSDPool(this.dexKey, this.dexHelper);
+      case BBTCPoolAddress:
+        return new BBTCPool(this.dexKey, this.dexHelper);
+      case GUSDPoolAddress:
+        return new GUSDPool(this.dexKey, this.dexHelper);
+      case HUSDPoolAddress:
+        return new HUSDPool(this.dexKey, this.dexHelper);
+      case LinkUSDPoolAddress:
+        return new LinkUSDPool(this.dexKey, this.dexHelper);
+      case MUSDPoolAddress:
+        return new MUSDPool(this.dexKey, this.dexHelper);
+      case OBTCPoolAddress:
+        return new OBTCPool(this.dexKey, this.dexHelper);
+      case PBTCPoolAddress:
+        return new PBTCPool(this.dexKey, this.dexHelper);
+      case RSVPoolAddress:
+        return new RSVPool(this.dexKey, this.dexHelper);
+      case TBTCPoolAddress:
+        return new TBTCPool(this.dexKey, this.dexHelper);
+      case USDKPoolAddress:
+        return new USDKPool(this.dexKey, this.dexHelper);
+      case USTPoolAddress:
+        return new USTPool(this.dexKey, this.dexHelper);
+      case SLINKPoolAddress:
+        return new SLINKPool(this.dexKey, this.dexHelper);
+      default:
+        return null;
+    }
+  }
+
+  // Makes sure all the pools from poolAddress are being tracked. If a pool in not tracked yet
+  // fetch the state and setup the pool, if they are being watched but don't have a valid state
+  // add it to the list of unavailable pools. Return the list of unavailable pools.
+  async batchCatchUpPools(
+    poolAddresses: string[],
+    blockNumber: number,
+  ): Promise<string[]> {
+    const unavailablePools = new Array<string>();
+    if (!blockNumber) return unavailablePools;
+    let poolsToFetch: (CurvePool | CurveMetapool)[] = [];
+    for (const poolAddress of poolAddresses) {
+      // Check if the pool is already tracked
+      let pool = this.getPoolByAddress(poolAddress);
+      // If the pool is not stracked add it to the list of pools to fetch
+      if (!pool) {
+        let newPool = this.getEventPoolInstance(poolAddress);
+        if (!newPool)
+          throw new Error(
+            `Error_${this.dexKey} requested unsupported event pool with address ${poolAddress}`,
+          );
+
+        const addressesSubscribed = newPool.addressesSubscribed.map(address =>
+          address.toLowerCase(),
+        );
+        if (!addressesSubscribed.includes(poolAddress)) {
+          newPool.addressesSubscribed.push(poolAddress);
+        }
+
+        await newPool.initialize(blockNumber);
+        poolsToFetch.push(newPool);
+      } else if (!pool.getState(blockNumber)) {
+        unavailablePools.push(poolAddress);
+      }
+    }
+
+    if (!poolsToFetch.length) return unavailablePools;
+
+    try {
+      const poolStates = await getManyPoolStates(
+        poolsToFetch,
+        this.dexHelper.multiContract,
+        blockNumber,
+      );
+
+      for (let i = 0; i < poolsToFetch.length; i++) {
+        await poolsToFetch[i].setup(blockNumber, poolStates[i] as any);
+        this.eventPools.push(poolsToFetch[i]);
+      }
+      return unavailablePools;
+    } catch (e) {
+      this.logger.error(`Error_batchCatchUpPools`, e);
+      throw e;
+    }
+  }
+
+  async getRatesEventPools(
+    fromToken: Token,
+    toToken: Token,
+    amounts: BigNumber[],
+    fromBigNumbers: number,
+    pools: string[],
+    indexes: [number, number, number][],
+    blockNumber: number,
+  ) {
+    const unavailablePools = await this.batchCatchUpPools(pools, blockNumber);
+
+    if (unavailablePools.length) {
+      this.logger.error(
+        `Couldn't use events for ${unavailablePools.length} ${this.dexKey} pools!`,
+      );
+      pools = pools.filter(p => !unavailablePools.includes(p));
+    }
+
+    let rates = new Array(pools.length);
+    for (let i = 0; i < pools.length; i++) {
+      rates[i] = {
+        exchange: pools[i],
+        rates: this.getRatesEventPool(
+          pools[i],
+          indexes[i],
+          amounts,
+          fromBigNumbers,
+          blockNumber,
+        ),
+      };
+    }
+    return rates;
+  }
+
+  async getRatesOnChain(
+    fromToken: Token,
+    toToken: Token,
+    amounts: bigint[],
+    pools: string[],
+    indexes: [number, number, number][],
+    blockNumber: number,
+  ) {
+    const chunks = amounts.length - 1;
+    const srcAmount = amounts[chunks]!;
+
+    // The number of chunks used onchain to minimize the full node calls
+    const onChainChunks = this.getOnChainChunks(
+      fromToken,
+      toToken,
+      srcAmount,
+      chunks,
+    );
+
+    const _width = Math.floor(chunks / onChainChunks);
+
+    const unitVolume = amounts[0];
+    amounts[0] = 0n;
+
+    const _amounts = [unitVolume].concat(
+      Array.from(Array(onChainChunks).keys()).map(
+        i => amounts[(i + 1) * _width],
+      ),
+    );
+
+    const calldata = pools.map((p, i) =>
+      _amounts.map(_amount => ({
+        target: p,
+        callData: this.poolInterface.encodeFunctionData(
+          indexes[i][2] === 1 ? 'get_dy_underlying' : 'get_dy',
+          [indexes[i][0], indexes[i][1], _amount],
+        ),
+      })),
+    );
+
+    //const data = await this.multi.methods
+    //  .tryAggregate(false, calldata.flat())
+    //  .call({}, 'latest');
+    const data = (
+      await Promise.all(
+        calldata.map(async poolCalldata => {
+          try {
+            const result = await Utils.timeoutPromise<MultiResult<any>[]>(
+              this.dexHelper.multiContract.methods
+                .tryAggregate(false, poolCalldata)
+                .call({}, 'latest'),
+              2000,
+              `Timed out multicall for curve pool ${poolCalldata[0].target}`,
+            );
+            return result;
+          } catch (e) {
+            this.logger.error(e);
+            return Array<MultiResult<any>>(poolCalldata.length).fill({
+              success: false,
+              returnData: '0x',
+            });
+          }
+        }),
+      )
+    ).flat();
+
+    // Convert the on chain rates to the requested chunks, using simple interpolation
+    const correctChunks = (_r: bigint[]): bigint[] => [
+      _r[0],
+      ...interpolate(
+        _amounts.slice(1),
+        _r.slice(1),
+        amounts.slice(1),
+        SwapSide.SELL,
+      ),
+    ];
+
+    const decode = (j: number) => {
+      if (!data[j].success) return 0n;
+      const decoded = coder.decode(['uint256'], data[j].returnData);
+      return BigInt(decoded[0].toString());
+    };
+
+    let i = 0;
+    // chunks !== onChainChunks || !isAmountsLinear
+    const ratesAllPools = pools.map(p => {
+      const rates = _amounts.map(a => decode(i++));
+      return {
+        rates: correctChunks(rates),
+        exchange: p,
+      };
+    });
+
+    return ratesAllPools;
+  }
+
+  protected noMorePrice(prices: BigNumber[], index: number): boolean {
+    return index > 1 && prices[index - 1].eq(BN_0);
+  }
+
+  getRatesEventPool(
+    exchange: string,
+    curveIndexes: number[],
+    amounts: BigNumber[],
+    fromBigNumbers: number,
+    blockNumber: number,
+  ) {
+    let rates = new Array<BigNumber>(amounts.length).fill(BN_0);
+
+    let fromIndex = curveIndexes[0];
+    let toIndex = curveIndexes[1];
+    let isTokenSwap = curveIndexes[2] === 1;
+
+    let pool = this.getPoolByAddress(exchange);
+    if (!pool) {
+      throw new Error(
+        `Error_${this.dexKey}_getRatesEvent pool is not initialised`,
+      );
+    }
+
+    const state = pool.getState(blockNumber);
+    if (!state)
+      throw new Error(
+        `Error_${this.dexKey}_${pool.name} expected state at blocknumber ${blockNumber}, got none`,
+      );
+
+    if (isTokenSwap) {
+      rates[0] = pool.get_dy_underlying(
+        fromIndex,
+        toIndex,
+        amounts[0],
+        state as any,
+      );
+
+      for (let i = 1; i < amounts.length; i++) {
+        rates[i] = this.noMorePrice(rates, i)
+          ? BN_0
+          : pool.get_dy_underlying(
+              fromIndex,
+              toIndex,
+              amounts[i],
+              state as any,
+            );
+      }
+    } else {
+      rates[0] = pool.get_dy(fromIndex, toIndex, amounts[0], state as any);
+
+      for (let i = 1; i < amounts.length; i++) {
+        rates[i] = this.noMorePrice(rates, i)
+          ? BN_0
+          : pool.get_dy(fromIndex, toIndex, amounts[i], state as any);
+      }
+    }
+
+    let floatRates = rates.map(rate => BigInt(rate.toFixed(0)));
+    return floatRates;
+  }
+
+  isEventPoolSupported(poolAddress: Address): Boolean {
+    return this.eventSupportedPools.some(p => p === poolAddress.toLowerCase());
+  }
+
+  allocPools(
+    from: Token,
+    to: Token,
+    side: SwapSide,
+    routeID: number,
+    usedPools: { [poolIdentifier: string]: number },
+    isFirstSwap: boolean,
+  ) {
+    if (side === SwapSide.BUY) {
+      return;
+    }
+
+    this.getPoolConfigs(from, to).forEach(p => {
+      const poolIdentifier = this.getPoolIdentifier(p.name);
+      if (!(poolIdentifier in usedPools)) {
+        usedPools[poolIdentifier] = routeID;
+      }
+    });
+  }
+
+  public getPoolIdentifier(name: string) {
+    return `${this.dexKey}_${name.toLowerCase()}`;
+  }
+
+  async getPricesVolume(
+    _from: Token,
+    _to: Token,
+    amounts: bigint[],
+    side: SwapSide,
+    blockNumber: number,
+    // list of pool identifiers to use for pricing, if undefined use all pools
+    limitPools?: string[],
+    transferFees: TransferFeeParams = {
+      srcFee: 0,
+      destFee: 0,
+      srcDexFee: 0,
+      destDexFee: 0,
+    },
+  ): Promise<ExchangePrices<CurveV1Data> | null> {
+    try {
+      if (side === SwapSide.BUY) {
+        return null;
+      }
+
+      _from.address = _from.address.toLowerCase();
+      _to.address = _to.address.toLowerCase();
+
+      const _isSrcTokenTransferFeeToBeExchanged =
+        this.disableFeeOnTransferTokenAddresses.has(_from.address)
+          ? false
+          : isSrcTokenTransferFeeToBeExchanged(transferFees);
+
+      const _isDestTokenTransferFeeToBeExchanged =
+        this.disableFeeOnTransferTokenAddresses.has(_to.address)
+          ? false
+          : isDestTokenTransferFeeToBeExchanged(transferFees);
+
+      // We first filter out pools which were explicitly excluded and pools which are already used
+      // then for the good pools we set the boolean to be true for used pools
+      // and for each pool we take the address.
+      const goodPoolConfigs = this.getPoolConfigs(_from, _to).filter(p => {
+        if (limitPools !== undefined) {
+          const id = this.getPoolIdentifier(p.name);
+          if (!limitPools.includes(id)) {
+            return false;
+          }
+        }
+
+        if (_isSrcTokenTransferFeeToBeExchanged) {
+          // Fee on transfers supported only when flag is specified
+          return !!p.isFeeOnTransferSupported;
+        }
+        return true;
+      });
+
+      const goodPoolAddress = goodPoolConfigs.map(p => p.address);
+      const indexesByAddress = goodPoolConfigs.reduce(
+        (acc: { [address: string]: [number, number, number] }, pc) => {
+          acc[pc.address] = this.getSwapIndexes(_from, _to, pc);
+          return acc;
+        },
+        {},
+      );
+
+      if (goodPoolAddress.length === 0) {
+        return null;
+      }
+
+      const amountsWithUnit = [
+        getBigIntPow(_from.decimals),
+        ...amounts.slice(1),
+      ];
+      const amountsWithUnitAndFee = _isSrcTokenTransferFeeToBeExchanged
+        ? applyTransferFee(
+            applyTransferFee(
+              amountsWithUnit,
+              side,
+              transferFees.srcFee,
+              SRC_TOKEN_PARASWAP_TRANSFERS,
+            ),
+            side,
+            transferFees.srcDexFee,
+            this.SRC_TOKEN_DEX_TRANSFERS,
+          )
+        : amountsWithUnit;
+
+      let _prices = new Array();
+
+      const eventPools = goodPoolAddress.filter(p =>
+        this.isEventPoolSupported(p),
+      );
+      const eventPoolIndexes = eventPools.map(ep => indexesByAddress[ep]);
+      if (eventPools) {
+        const pricesEvents = await this.getRatesEventPools(
+          _from,
+          _to,
+          amountsWithUnitAndFee.map(a => new BigNumber(a.toString())),
+          _from.decimals,
+          eventPools,
+          eventPoolIndexes,
+          blockNumber,
+        );
+        _prices = _prices.concat(pricesEvents);
+      }
+
+      // if the pool rates was not available in the event pool then fallback to the onchain pool query
+      const isPoolNotInPrices = (poolAddress: Address) =>
+        !_prices.find(
+          existingPrice =>
+            existingPrice.exchange.toLowerCase() === poolAddress.toLowerCase(),
+        );
+      const onChainPools = goodPoolAddress.filter(isPoolNotInPrices);
+
+      const onChainPoolIndexes = onChainPools.map(op => indexesByAddress[op]);
+
+      // onChainPools are only supported for pools with linear price chunks
+      if (onChainPools.length) {
+        const pricesOnChain = await this.getRatesOnChain(
+          _from,
+          _to,
+          amountsWithUnitAndFee,
+          onChainPools,
+          onChainPoolIndexes,
+          blockNumber,
+        );
+        _prices = _prices.concat(pricesOnChain);
+      }
+
+      const poolConfigsByAddress = this.poolConfigsByAddress();
+
+      const poolPrices = _prices.reduce(
+        (acc: PoolPrices<CurveV1Data>[], _price: any, idx: number) => {
+          if (
+            _price.exchange === NULL_ADDRESS ||
+            !(_price.exchange.toLowerCase() in poolConfigsByAddress)
+          )
+            return acc;
+
+          const poolConfig =
+            poolConfigsByAddress[_price.exchange.toLowerCase()];
+          const indexes = this.getSwapIndexes(_from, _to, poolConfig);
+          const [i, j, swapType] = indexes;
+
+          if (_isDestTokenTransferFeeToBeExchanged) {
+            _price.rates = applyTransferFee(
+              _price.rates,
+              side,
+              transferFees.destDexFee,
+              this.DEST_TOKEN_DEX_TRANSFERS,
+            );
+          }
+
+          acc.push({
+            prices: [0n, ..._price.rates.slice(1)],
+            unit: _price.rates[0],
+            data: {
+              exchange: _price.exchange,
+              i,
+              j,
+              underlyingSwap: swapType === 1,
+              deadline: 0,
+            },
+            exchange: this.dexKey,
+            poolIdentifier: `${this.dexKey}_${poolConfig.name.toLowerCase()}`,
+            gasCost: poolConfig.isLending
+              ? CURVE_LENDING_POOl_GAS
+              : CURVE_POOL_GAS,
+            poolAddresses: [_price.exchange],
+          });
+          return acc;
+        },
+        [],
+      );
+      return poolPrices;
+    } catch (e) {
+      if (blockNumber === 0)
+        this.logger.error(
+          `Error_${this.dexKey}_getPrices: Aurelius block manager not yet instantiated`,
+        );
+      this.logger.error(`Error_${this.dexKey}_getPrices`, e);
+      return null;
+    }
+  }
+
+  getSwapIndexes(
+    from: Token,
+    to: Token,
+    pool?: PoolConfig,
+  ): [number, number, number] {
+    pool = pool || this.getPoolConfig(from, to);
+    if (!pool) {
+      return [-1, -1, -1];
+    }
+
+    const fromAddress = from.address.toLowerCase();
+    const toAddress = to.address.toLowerCase();
+    const isUnderlyingSwap =
+      pool.underlying.length &&
+      pool.underlying.some(t => t.toLowerCase() === fromAddress) &&
+      pool.underlying.some(t => t.toLowerCase() === toAddress);
+
+    const fromIndex = isUnderlyingSwap
+      ? pool.underlying.findIndex(t => t.toLowerCase() === fromAddress)
+      : pool.coins.findIndex(t => t.toLowerCase() === fromAddress);
+
+    const toIndex = isUnderlyingSwap
+      ? pool.underlying.findIndex(t => t.toLowerCase() === toAddress)
+      : pool.coins.findIndex(t => t.toLowerCase() === toAddress);
+
+    const swapType = isUnderlyingSwap ? 1 : 2;
+
+    return [fromIndex, toIndex, swapType];
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: CurveV1Data,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
+
+    const { i, j, deadline, underlyingSwap } = data;
+    const payload = this.abiCoder.encodeParameter(
+      {
+        ParentStruct: {
+          i: 'int128',
+          j: 'int128',
+          deadline: 'uint256',
+          underlyingSwap: 'bool',
+        },
+      },
+      { i, j, deadline, underlyingSwap },
+    );
+
+    return {
+      targetExchange: data.exchange,
+      payload,
+      networkFee: '0',
+    };
+  }
+
+  getCalldataGasCost(poolPrices: PoolPrices<CurveV1Data>): number | number[] {
+    return (
+      CALLDATA_GAS_COST.DEX_OVERHEAD +
+      CALLDATA_GAS_COST.LENGTH_SMALL +
+      CALLDATA_GAS_COST.INDEX +
+      CALLDATA_GAS_COST.INDEX +
+      CALLDATA_GAS_COST.TIMESTAMP +
+      CALLDATA_GAS_COST.BOOL
+    );
+  }
+
+  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
+    return this.adapters[side];
+  }
+
+  static getDirectFunctionName(): string[] {
+    return [DIRECT_METHOD_NAME];
+  }
+
+  getTokenFromAddress(address: Address): Token {
+    // In this Dex decimals are not used
+    return { address, decimals: 0 };
+  }
+
+  async preProcessTransaction(
+    optimalSwapExchange: OptimalSwapExchange<CurveV1Data>,
+    srcToken: Token,
+    _0: Token,
+    _1: SwapSide,
+    options: PreprocessTransactionOptions,
+  ): Promise<[OptimalSwapExchange<CurveV1Data>, ExchangeTxInfo]> {
+    if (!options.isDirectMethod) {
+      return [
+        optimalSwapExchange,
+        {
+          deadline: BigInt(getLocalDeadlineAsFriendlyPlaceholder()),
+        },
+      ];
+    }
+
+    assert(
+      optimalSwapExchange.data !== undefined,
+      `preProcessTransaction: data field is missing`,
+    );
+
+    let isApproved: boolean | undefined;
+
+    try {
+      isApproved = await this.dexHelper.augustusApprovals.hasApproval(
+        options.executionContractAddress,
+        this.dexHelper.config.wrapETH(srcToken).address,
+        optimalSwapExchange.data.exchange,
+      );
+    } catch (e) {
+      this.logger.error(
+        `preProcessTransaction failed to retrieve allowance info: `,
+        e,
+      );
+    }
+
+    return [
+      {
+        ...optimalSwapExchange,
+        data: {
+          ...optimalSwapExchange.data,
+          isApproved,
+        },
+      },
+      {
+        deadline: BigInt(getLocalDeadlineAsFriendlyPlaceholder()),
+      },
+    ];
+  }
+
+  getDirectParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    expectedAmount: NumberAsString,
+    data: CurveV1Data,
+    side: SwapSide,
+    permit: string,
+    uuid: string,
+    feePercent: NumberAsString,
+    deadline: NumberAsString,
+    partner: string,
+    beneficiary: string,
+    contractMethod?: string,
+  ): TxInfo<DirectCurveV1Param> {
+    if (contractMethod !== DIRECT_METHOD_NAME) {
+      throw new Error(`Invalid contract method ${contractMethod}`);
+    }
+    assert(side === SwapSide.SELL, 'Buy not supported');
+
+    let isApproved: boolean = !!data.isApproved;
+    if (data.isApproved === undefined) {
+      this.logger.warn(`isApproved is undefined, defaulting to false`);
+    }
+
+    const swapParams: DirectCurveV1Param = [
+      srcToken,
+      destToken,
+      data.exchange,
+      srcAmount,
+      destAmount,
+      expectedAmount,
+      feePercent,
+      data.i.toString(),
+      data.j.toString(),
+      partner,
+      isApproved,
+      data.underlyingSwap
+        ? CurveV1SwapType.EXCHANGE_UNDERLYING
+        : CurveV1SwapType.EXCHANGE,
+      beneficiary,
+      // For CurveV1 we work as it is, without wrapping and unwrapping
+      false,
+      permit,
+      uuidToBytes16(uuid),
+    ];
+
+    const encoder = (...params: DirectCurveV1Param) => {
+      return this.directSwapIface.encodeFunctionData(DIRECT_METHOD_NAME, [
+        params,
+      ]);
+    };
+
+    return {
+      params: swapParams,
+      encoder,
+      networkFee: '0',
+    };
+  }
+
+  getDirectParamV6(
+    srcToken: Address,
+    destToken: Address,
+    fromAmount: NumberAsString,
+    toAmount: NumberAsString,
+    quotedAmount: NumberAsString,
+    data: CurveV1Data,
+    side: SwapSide,
+    permit: string,
+    uuid: string,
+    partnerAndFee: string,
+    beneficiary: string,
+    blockNumber: number,
+    contractMethod?: string,
+  ) {
+    if (contractMethod !== DIRECT_METHOD_NAME_V6) {
+      throw new Error(`Invalid contract method ${contractMethod}`);
+    }
+    assert(side === SwapSide.SELL, 'Buy not supported');
+
+    const metadata = hexConcat([
+      hexZeroPad(uuidToBytes16(uuid), 16),
+      hexZeroPad(hexlify(blockNumber), 16),
+    ]);
+
+    const swapParams: DirectCurveV1ParamV6 = [
+      packCurveData(
+        data.exchange,
+        !data.isApproved, // approve flag, if not approved then set to true
+        isETHAddress(destToken) ? 0 : isETHAddress(srcToken) ? 3 : 0,
+        data.underlyingSwap
+          ? CurveV1SwapType.EXCHANGE_UNDERLYING
+          : CurveV1SwapType.EXCHANGE,
+      ).toString(),
+      encodeCurveAssets(data.i, data.j).toString(),
+      srcToken,
+      destToken,
+      fromAmount,
+      toAmount,
+      quotedAmount,
+      metadata,
+      beneficiary,
+    ];
+
+    const encodeParams: CurveV1DirectSwap = [swapParams, partnerAndFee, permit];
+
+    const encoder = (...params: CurveV1DirectSwap) => {
+      return this.augustusV6Interface.encodeFunctionData(
+        DIRECT_METHOD_NAME_V6,
+        [...params],
+      );
+    };
+
+    return {
+      encoder,
+      params: encodeParams,
+      networkFee: '0',
+    };
+  }
+
+  static getDirectFunctionNameV6(): string[] {
+    return [DIRECT_METHOD_NAME_V6];
+  }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: CurveV1Data,
+    side: SwapSide,
+  ): DexExchangeParam {
+    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
+
+    const { exchange, i, j, underlyingSwap } = data;
+    const defaultArgs = [i, j, srcAmount, this.minConversionRate];
+    const swapMethod = underlyingSwap
+      ? CurveSwapFunctions.exchange_underlying
+      : CurveSwapFunctions.exchange;
+    const exchangeData = this.exchangeRouterInterface.encodeFunctionData(
+      swapMethod,
+      defaultArgs,
+    );
+
+    return {
+      exchangeData,
+      needWrapNative: this.needWrapNative,
+      sendEthButSupportsInsertFromAmount: true,
+      dexFuncHasRecipient: false,
+      targetExchange: exchange,
+      returnAmountPos: undefined,
+    };
+  }
+
+  async getSimpleParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: CurveV1Data,
+    side: SwapSide,
+  ): Promise<SimpleExchangeParam> {
+    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
+
+    const { exchange, i, j, underlyingSwap } = data;
+    const defaultArgs = [i, j, srcAmount, this.minConversionRate];
+    const swapMethod = underlyingSwap
+      ? CurveSwapFunctions.exchange_underlying
+      : CurveSwapFunctions.exchange;
+    const swapData = this.exchangeRouterInterface.encodeFunctionData(
+      swapMethod,
+      defaultArgs,
+    );
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      srcToken,
+      srcAmount,
+      destToken,
+      destAmount,
+      swapData,
+      exchange,
+    );
+  }
+
+  async updateBaseTokenPrice() {
+    for (let baseToken of Object.values(this.baseTokens)) {
+      const usdPrice = await this.dexHelper.getTokenUSDPrice(
+        baseToken,
+        baseToken.reasonableVolume,
+      );
+
+      const denominator =
+        Number(baseToken.reasonableVolume) / 10 ** baseToken.decimals;
+
+      baseToken.tokenPrice = usdPrice / denominator;
+    }
+  }
+
+  async fetchDecimals() {
+    const calls = Object.values(this.pools).reduce<MultiCallParams<any>[]>(
+      (acc, pool) => {
+        const underlyingDecimalsCalls = pool.underlying.reduce<
+          MultiCallParams<any>[]
+        >((_acc, _token) => {
+          const token = _token.toLowerCase();
+          if (token === ETHER_ADDRESS) {
+            this.decimalsCoinsAndUnderlying[token] = 18;
+          } else {
+            _acc.push({
+              target: token,
+              callData: erc20Iface.encodeFunctionData('decimals'),
+              decodeFunction: uin128DecodeToInt,
+              cb: (decimals: number) => {
+                this.decimalsCoinsAndUnderlying[token.toLowerCase()] = decimals;
+              },
+            });
+          }
+
+          return _acc;
+        }, []);
+
+        const coinsDecimalsCalls = pool.coins.reduce<MultiCallParams<any>[]>(
+          (_acc, _coin) => {
+            const coin = _coin.toLowerCase();
+            if (coin === ETHER_ADDRESS) {
+              this.decimalsCoinsAndUnderlying[coin] = 18;
+            } else {
+              _acc.push({
+                target: coin,
+                callData: erc20Iface.encodeFunctionData('decimals'),
+                decodeFunction: uin128DecodeToInt,
+                cb: (decimals: number) => {
+                  this.decimalsCoinsAndUnderlying[coin.toLowerCase()] =
+                    decimals;
+                },
+              });
+            }
+            return _acc;
+          },
+          [],
+        );
+
+        acc.push(...underlyingDecimalsCalls, ...coinsDecimalsCalls);
+        return acc;
+      },
+      [],
+    );
+
+    return this.dexHelper.multiWrapper!.tryAggregate(true, calls);
+  }
+
+  async fetchAllPools() {
+    try {
+      // Hack: We choose to check the balance of the token for the pool instead of calling
+      // the balances array in the pool as it was a mess to have each curve abi
+      // Some have balances[uint128] some have balances[uint256]
+      // One of the consequence for such a hack is below for ETH Pools
+      // TODO: below can be highly optimized
+      // * we don't need to query token decimals every iteration
+      // * we can use the decimals from the tokens list using the api
+
+      const calls = Object.values(this.pools).reduce<MultiCallParams<number>[]>(
+        (acc, pool) => {
+          const coinCalls = pool.coins.map<MultiCallParams<number>>(coin => {
+            const coinLowerCase = coin.toLowerCase();
+            if (coinLowerCase === ETHER_ADDRESS) {
+              return {
+                target:
+                  this.dexHelper.config.data.multicallV2Address.toLowerCase(),
+                callData: this.dexHelper.multiContract.methods
+                  .getEthBalance(pool.address.toLowerCase())
+                  .encodeABI(),
+                decodeFunction: uin256DecodeToFloat,
+              };
+            } else {
+              return {
+                target: coinLowerCase,
+                callData: erc20Iface.encodeFunctionData('balanceOf', [
+                  pool.address,
+                ]),
+                decodeFunction: uin256DecodeToFloat,
+              };
+            }
+          });
+          acc.push(...coinCalls);
+          return acc;
+        },
+        [],
+      );
+
+      const results = await this.dexHelper.multiWrapper!.tryAggregate(
+        true,
+        calls,
+      );
+
+      let index = 0;
+      Object.values(this.pools).forEach(pool => {
+        const balances = results.slice(index, index + pool.coins.length);
+        index += pool.coins.length;
+
+        const sumLiquidity = balances.reduce((acc, balance, i) => {
+          const coin = pool.coins[i].toLowerCase();
+          const decimals = this.decimalsCoinsAndUnderlying[coin];
+
+          return acc + balance.returnData / 10 ** decimals;
+        }, 0);
+
+        let liquidityUSD = 0;
+        if (pool.baseToken) {
+          if (!this.baseTokens[pool.baseToken]) {
+            throw new Error(
+              `missing base token ${pool.baseToken} for ${this.dexKey}`,
+            );
+          }
+          liquidityUSD =
+            sumLiquidity * Number(this.baseTokens[pool.baseToken].tokenPrice!);
+        }
+
+        pool.liquidityUSD = liquidityUSD;
+      });
+    } catch (e) {
+      this.logger.error(`fetchAllPools ${this.dexKey}`, e);
+      throw e;
+    }
+  }
+
+  async updatePoolState(): Promise<void> {
+    if (!Object.keys(this.decimalsCoinsAndUnderlying).length) {
+      await this.fetchDecimals();
+    }
+
+    await this.updateBaseTokenPrice();
+    await this.fetchAllPools();
+  }
+
+  async getTopPoolsForToken(
+    tokenAddress: Address,
+    limit: number,
+  ): Promise<PoolLiquidity[]> {
+    const _tokenAddress = this.dexHelper.config.unwrapETH({
+      address: tokenAddress,
+      decimals: 18,
+    }).address;
+    // In general case a token can be in the coins or underlying
+    // In case of the metapool the token might be in both at the same time
+    // It is important to note that the connector tokens might not be
+    // compatible for exchange among themselves.
+    const selectedPool = Object.values(this.pools).reduce<PoolLiquidity[]>(
+      (acc, pool) => {
+        const inCoins = pool.coins.some(
+          _token => _token.toLowerCase() === _tokenAddress.toLowerCase(),
+        );
+        const inUnderlying = pool.underlying.some(
+          _token => _token.toLowerCase() === _tokenAddress.toLowerCase(),
+        );
+        let connectorTokens = inCoins ? pool.coins : [];
+        connectorTokens = inUnderlying
+          ? _.concat(connectorTokens, pool.underlying)
+          : connectorTokens;
+
+        if (connectorTokens.length) {
+          acc.push({
+            exchange: this.dexKey,
+            address: pool.address,
+            liquidityUSD: pool.liquidityUSD!,
+            connectorTokens: _.uniq(connectorTokens)
+              .filter(
+                (_token: string) =>
+                  _token.toLowerCase() !== _tokenAddress.toLowerCase(),
+              )
+              .map(tokenAddress => {
+                const address = tokenAddress.toLowerCase();
+                return {
+                  address,
+                  decimals: this.decimalsCoinsAndUnderlying[address],
+                };
+              }),
+          });
+        }
+        return acc;
+      },
+      [],
+    );
+    return selectedPool
+      .sort((a, b) => b.liquidityUSD - a.liquidityUSD)
+      .slice(0, limit);
+  }
+}