@paraswap/dex-lib 3.8.33 → 3.8.34-inception

package/src/dex/aave-gsm/aave-gsm.ts

@@ -130,11 +130,6 @@ export class AaveGsm extends SimpleExchange implements IDex<AaveGsmData> {
     }
   }
 
-  async updatePoolState(): Promise<void> {
-    const blockNumber = await this.dexHelper.web3Provider.eth.getBlockNumber();
-    await this.initializePricing(blockNumber);
-  }
-
   async getPoolState(gsm: string, blockNumber?: number): Promise<PoolState> {
     if (!blockNumber) {
       return this.eventPools[gsm].getStaleState()!;

package/src/dex/inception/config.ts

@@ -0,0 +1,109 @@
+import { DexParams, PricePoolParams } from './types';
+import { DexConfigMap } from '../../types';
+import { Network } from '../../constants';
+
+export const InceptionConfig: DexConfigMap<DexParams[]> = {
+  InceptionLRT: {
+    [Network.MAINNET]: [
+      {
+        symbol: 'instETH',
+        token: '0x7FA768E035F956c41d6aeaa3Bd857e7E5141CAd5',
+        vault: '0x814CC6B8fd2555845541FB843f37418b05977d8d',
+        baseToken: '0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84',
+        baseTokenSlug: 'STETH',
+      },
+      {
+        symbol: 'inrETH',
+        token: '0x80d69e79258FE9D056c822461c4eb0B4ca8802E2',
+        vault: '0x1Aa53BC4Beb82aDf7f5EDEE9e3bBF3434aD59F12',
+        baseToken: '0xae78736Cd615f374D3085123A210448E74Fc6393',
+        baseTokenSlug: 'rETH',
+      },
+      {
+        symbol: 'inoETH',
+        token: '0x9181f633e9b9f15a32d5e37094f4c93b333e0e92',
+        vault: '0x4878F636A9Aa314B776Ac51A25021C44CAF86bEd',
+        baseToken: '0x856c4Efb76C1D1AE02e20CEB03A2A6a08b0b8dC3',
+        baseTokenSlug: 'oETH',
+      },
+      {
+        symbol: 'inosETH',
+        token: '0xfD07fD5EBEa6F24888a397997E262179Bf494336',
+        vault: '0xA9F8c770661BeE8DF2D026edB1Cb6FF763C780FF',
+        baseToken: '0xf1C9acDc66974dFB6dEcB12aA385b9cD01190E38',
+        baseTokenSlug: 'osETH',
+      },
+      {
+        symbol: 'inankrETH',
+        token: '0xfa2629B9cF3998D52726994E0FcdB750224D8B9D',
+        vault: '0x36B429439AB227fAB170A4dFb3321741c8815e55',
+        baseToken: '0xE95A203B1a91a908F9B9CE46459d101078c2c3cb',
+        baseTokenSlug: 'AnkETH',
+      },
+      {
+        symbol: 'incbETH',
+        token: '0xbf19eead55a6b100667f04f8fbc5371e03e8ab2e',
+        vault: '0xfE715358368416E01d3A961D3a037b7359735d5e',
+        baseToken: '0xBe9895146f7AF43049ca1c1AE358B0541Ea49704',
+        baseTokenSlug: 'cbETH',
+      },
+      {
+        symbol: 'inwbETH',
+        token: '0xda9b11cd701e10c2ec1a284f80820edd128c5246',
+        vault: '0xC0660932C5dCaD4A1409b7975d147203B1e9A2B6',
+        baseToken: '0xa2E3356610840701BDf5611a53974510Ae27E2e1',
+        baseTokenSlug: 'wbETH',
+      },
+      {
+        symbol: 'inswETH',
+        token: '0xc3ade5ace1bbb033ccae8177c12ecbfa16bd6a9d',
+        vault: '0xc4181dC7BB31453C4A48689ce0CBe975e495321c',
+        baseToken: '0xf951E335afb289353dc249e82926178EaC7DEd78',
+        baseTokenSlug: 'SWETH',
+      },
+      {
+        symbol: 'inETHx',
+        token: '0x57a5a0567187ff4a8dcc1a9bba86155e355878f2',
+        vault: '0x90E80E25ABDB6205B08DeBa29a87f7eb039023C2',
+        baseToken: '0xA35b1B31Ce002FBF2058D22F30f95D405200A15b',
+        baseTokenSlug: 'ETHx',
+      },
+      {
+        symbol: 'insfrxETH',
+        token: '0x668308d77be3533c909a692302cb4d135bf8041c',
+        vault: '0x295234B7E370a5Db2D2447aCA83bc7448f151161',
+        baseToken: '0xac3E018457B222d93114458476f3E3416Abbe38F',
+        baseTokenSlug: 'sfrxETH',
+      },
+      {
+        symbol: 'inmETH',
+        token: '0xeCf3672A6d2147E2A77f07069Fb48d8Cf6F6Fbf9',
+        vault: '0xd0ee89d82183D7Ddaef14C6b4fC0AA742F426355',
+        baseToken: '0xd5F7838F5C461fefF7FE49ea5ebaF7728bB0ADfa',
+        baseTokenSlug: 'mETH',
+      },
+      {
+        symbol: 'inlsETH',
+        token: '0x94b888e11a9e960a9c3b3528eb6ac807b27ca62e',
+        vault: '0x6E17a8b5D33e6DBdB9fC61d758BF554b6AD93322',
+        baseToken: '0x8c1BEd5b9a0928467c9B1341Da1D7BD5e10b6549',
+        baseTokenSlug: 'lsETH',
+      },
+      {
+        symbol: 'inETH',
+        token: '0xf073bAC22DAb7FaF4a3Dd6c6189a70D54110525C',
+        vault: '0x46199cAa0e453971cedf97f926368d9E5415831a',
+        baseToken: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
+        baseTokenSlug: 'ETH',
+      },
+    ],
+  },
+};
+
+export const InceptionPricePoolConfig: DexConfigMap<PricePoolParams> = {
+  InceptionLRT: {
+    [Network.MAINNET]: {
+      ratioFeed: '0xFd73Be536503B5Aa80Bf99D1Fd65b1306c69B191',
+    },
+  },
+};

package/src/dex/inception/inception-e2e.test.ts

@@ -0,0 +1,67 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import { Holders, Tokens } from '../../../tests/constants-e2e';
+import { ContractMethod, Network, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+import { InceptionConfig } from './config';
+import { DexParams } from './types';
+
+function testForNetwork(
+  network: Network,
+  inceptionName: string,
+  configs: DexParams[],
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+
+  for (const config of configs) {
+    const baseSlug = config.baseTokenSlug;
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+    const inceptionSlug = config.symbol;
+
+    const sideToContractMethods = new Map([
+      [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    ]);
+
+    describe(`${inceptionSlug}`, () => {
+      sideToContractMethods.forEach((contractMethods, side) =>
+        describe(`${side}`, () => {
+          contractMethods.forEach((contractMethod: ContractMethod) => {
+            describe(`${contractMethod}`, () => {
+              it(`${baseSlug} -> ${inceptionSlug}`, async () => {
+                await testE2E(
+                  tokens[baseSlug],
+                  tokens[inceptionSlug],
+                  holders[baseSlug],
+                  '100000000',
+                  side,
+                  inceptionName,
+                  contractMethod,
+                  network,
+                  provider,
+                );
+              });
+            });
+          });
+        }),
+      );
+    });
+  }
+}
+
+describe('Inception E2E', () => {
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+
+    Object.entries(InceptionConfig).forEach(([inceptionName, chainConfig]) => {
+      testForNetwork(network, inceptionName, chainConfig[network]);
+    });
+  });
+});

package/src/dex/inception/inception-event-pool.ts

@@ -0,0 +1,62 @@
+import _ from 'lodash';
+import { AsyncOrSync, DeepReadonly } from 'ts-essentials';
+import { Address, BlockHeader, Log, Logger } from '../../types';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { PoolConfig, PoolState } from './types';
+import { getOnChainState } from './utils';
+import { Interface } from '@ethersproject/abi';
+import INCEPTION_RATIO_FEED from '../../abi/inception/inception-ratio-feed.json';
+import { getTokenFromAddress } from './tokens';
+
+export class InceptionEventPool extends StatefulEventSubscriber<PoolState> {
+  protected ratioFeedInterface: Interface = new Interface(INCEPTION_RATIO_FEED);
+  constructor(
+    parentName: string,
+    protected network: number,
+    protected dexHelper: IDexHelper,
+    logger: Logger,
+    protected ratioFeedAddress: Address,
+    public poolInterface: Interface,
+  ) {
+    super(parentName, ratioFeedAddress, dexHelper, logger);
+
+    this.addressesSubscribed = [ratioFeedAddress];
+  }
+
+  protected processLog(
+    state: DeepReadonly<PoolState>,
+    log: Readonly<Log>,
+    blockHeader: Readonly<BlockHeader>,
+  ): AsyncOrSync<DeepReadonly<PoolState> | null> {
+    try {
+      const parsed = this.ratioFeedInterface.parseLog(log);
+      const _state: PoolState = _.cloneDeep(state);
+      switch (parsed.name) {
+        case 'RatioUpdated': {
+          const tokenInfo = getTokenFromAddress(this.network, parsed.args[0]);
+          if (tokenInfo) {
+            _state[tokenInfo.symbol.toLowerCase()] = {
+              ratio: BigInt(parsed.args[2].toString()),
+            };
+          }
+          return _state;
+        }
+        default:
+          return _state;
+      }
+    } catch (e) {
+      this.logger.error('Failed to parse log', e);
+      return null;
+    }
+  }
+
+  async generateState(blockNumber: number): Promise<Readonly<PoolState>> {
+    return getOnChainState(
+      this.dexHelper.multiContract,
+      this.poolInterface,
+      this.network,
+      blockNumber,
+    );
+  }
+}

package/src/dex/inception/inception-events.test.ts

@@ -0,0 +1,64 @@
+import dotenv from 'dotenv';
+dotenv.config();
+import { InceptionEventPool } from './inception-event-pool';
+import { InceptionPricePoolConfig } from './config';
+import { Network } from '../../constants';
+import { DummyDexHelper } from '../../dex-helper/index';
+import INCEPTION_VAULT_ABI from '../../abi/inception/inception-vault.json';
+import { testEventSubscriber } from '../../../tests/utils-events';
+import { PoolState } from './types';
+import { Interface } from '@ethersproject/abi';
+import { setTokensOnNetwork } from './tokens';
+import { getTokenList } from './utils';
+
+jest.setTimeout(50 * 1000);
+const dexKey = 'InceptionLRT';
+const network = Network.MAINNET;
+const ratioFeedAddress = InceptionPricePoolConfig[dexKey][network].ratioFeed;
+const poolInterface = new Interface(INCEPTION_VAULT_ABI);
+
+async function fetchPoolState(
+  inceptionEventPool: InceptionEventPool,
+  blockNumber: number,
+): Promise<PoolState> {
+  return inceptionEventPool.generateState(blockNumber);
+}
+
+describe('Inception Event', function () {
+  const blockNumbers: { [eventName: string]: number[] } = {
+    // RatioUpdated: [20438963, 20431766, 20424602],
+    RatioUpdated: [20438962, 20431765, 20424601, 20703959, 20711125],
+  };
+
+  describe('InceptionEventPool', function () {
+    Object.keys(blockNumbers).forEach((event: string) => {
+      blockNumbers[event].forEach((blockNumber: number) => {
+        it(`Should return the correct state after the ${blockNumber}: ${event}`, async function () {
+          const dexHelper = new DummyDexHelper(network);
+          const logger = dexHelper.getLogger(dexKey);
+          const inceptionEventPool = new InceptionEventPool(
+            dexKey,
+            network,
+            dexHelper,
+            logger,
+            ratioFeedAddress,
+            poolInterface,
+          );
+
+          const tokenList = await getTokenList(network);
+          setTokensOnNetwork(network, tokenList);
+
+          await testEventSubscriber(
+            inceptionEventPool,
+            inceptionEventPool.addressesSubscribed,
+            (_blockNumber: number) =>
+              fetchPoolState(inceptionEventPool, _blockNumber),
+            blockNumber,
+            `${dexKey}_${ratioFeedAddress}`.toLowerCase(),
+            dexHelper.provider,
+          );
+        });
+      });
+    });
+  });
+});

package/src/dex/inception/inception-integration.test.ts

@@ -0,0 +1,76 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { DummyDexHelper } from '../../dex-helper/index';
+import { Network, SwapSide } from '../../constants';
+import { BI_POWS } from '../../bigint-constants';
+import { Inception } from './inception';
+import { checkPoolPrices, checkPoolsLiquidity } from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+import { InceptionConfig } from './config';
+
+const network = Network.MAINNET;
+const dexKey = 'InceptionLRT';
+const dexHelper = new DummyDexHelper(network);
+
+describe('Inception', function () {
+  let blockNumber: number;
+  let inception: Inception;
+
+  beforeAll(async () => {
+    blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+    inception = new Inception(network, dexKey, dexHelper);
+    await inception.initializePricing(blockNumber);
+  });
+
+  InceptionConfig[dexKey][network].forEach(Pair => {
+    const TokenASymbol = Pair.baseTokenSlug;
+    const TokenA = Tokens[network][TokenASymbol];
+
+    const TokenBSymbol = Pair.symbol;
+    const TokenB = Tokens[network][TokenBSymbol];
+    const TokenBAmounts = [0n, BI_POWS[6], 2000000n];
+
+    describe(`deposit() Swap Function for ${TokenBSymbol} <> ${TokenASymbol}`, () => {
+      it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+        const pools = await inception.getPoolIdentifiers(
+          TokenB,
+          TokenA,
+          SwapSide.SELL,
+          blockNumber,
+        );
+        console.log(
+          `${TokenBSymbol} <> ${TokenASymbol} Pool Identifiers: `,
+          pools,
+        );
+
+        expect(pools.length).toBeGreaterThan(0);
+
+        const poolPrices = await inception.getPricesVolume(
+          TokenB,
+          TokenA,
+          TokenBAmounts,
+          SwapSide.SELL,
+          blockNumber,
+          pools,
+        );
+        console.log(
+          `${TokenBSymbol} <> ${TokenASymbol} Pool Prices: `,
+          poolPrices,
+        );
+
+        expect(poolPrices).not.toBeNull();
+        checkPoolPrices(poolPrices!, TokenBAmounts, SwapSide.SELL, dexKey);
+      });
+
+      it('getTopPoolsForToken', async function () {
+        const poolLiquidity = await inception.getTopPoolsForToken(
+          TokenA.address,
+          10,
+        );
+
+        checkPoolsLiquidity(poolLiquidity, TokenA.address, dexKey);
+      });
+    });
+  });
+});

package/src/dex/inception/inception.ts

@@ -0,0 +1,271 @@
+import { Interface, JsonFragment } from '@ethersproject/abi';
+import { AsyncOrSync } from 'ts-essentials';
+import { NumberAsString, SwapSide } from '@paraswap/core';
+import {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  ExchangePrices,
+  Logger,
+  PoolLiquidity,
+  PoolPrices,
+  Token,
+  TransferFeeParams,
+} from '../../types';
+import INCEPTION_ABI from '../../abi/inception/inception-vault.json';
+import INCEPTION_POOL_ABI from '../../abi/inception/inception-ineth-pool.json';
+import {
+  DEST_TOKEN_PARASWAP_TRANSFERS,
+  Network,
+  NULL_ADDRESS,
+  SRC_TOKEN_PARASWAP_TRANSFERS,
+} from '../../constants';
+import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
+import { getDexKeysWithNetwork } from '../../utils';
+import { IDex } from '../../dex/idex';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { InceptionDexData, PoolState } from './types';
+import { SimpleExchange } from '../simple-exchange';
+import { InceptionConfig, InceptionPricePoolConfig } from './config';
+import { getTokenFromAddress, setTokensOnNetwork } from './tokens';
+import { getOnChainState, getTokenList } from './utils';
+import { InceptionEventPool } from './inception-event-pool';
+import { applyTransferFee } from '../../lib/token-transfer-fee';
+import { RETURN_AMOUNT_POS_0 } from '../../executor/constants';
+
+const DECIMALS = BigInt(1e18);
+
+export class Inception
+  extends SimpleExchange
+  implements IDex<InceptionDexData>
+{
+  protected vaultInterface: Interface;
+  protected poolInterface: Interface;
+
+  readonly hasConstantPriceLargeAmounts = false;
+  readonly needWrapNative = false;
+  readonly isFeeOnTransferSupported = true;
+
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(InceptionConfig);
+
+  logger: Logger;
+
+  private eventPool: InceptionEventPool;
+
+  constructor(
+    readonly network: Network,
+    readonly dexKey: string,
+    readonly dexHelper: IDexHelper,
+    protected config = InceptionConfig[dexKey][network],
+  ) {
+    super(dexHelper, dexKey);
+    this.logger = dexHelper.getLogger(dexKey);
+    this.vaultInterface = new Interface(INCEPTION_ABI as JsonFragment[]);
+    this.poolInterface = new Interface(INCEPTION_POOL_ABI as JsonFragment[]);
+    this.eventPool = new InceptionEventPool(
+      dexKey,
+      network,
+      dexHelper,
+      this.logger,
+      InceptionPricePoolConfig[dexKey][network].ratioFeed,
+      this.poolInterface,
+    );
+  }
+
+  async initializePricing(blockNumber: number) {
+    const poolState = await getOnChainState(
+      this.dexHelper.multiContract,
+      this.vaultInterface,
+      this.network,
+      blockNumber,
+    );
+
+    await this.eventPool.initialize(blockNumber, {
+      state: poolState,
+    });
+    await this.initializeTokens();
+  }
+
+  async initializeTokens() {
+    let tokenList = await getTokenList(this.network);
+
+    setTokensOnNetwork(this.network, tokenList);
+  }
+
+  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
+    return null;
+  }
+
+  async getPoolIdentifiers(
+    srcToken: Token,
+    destToken: Token,
+    side: SwapSide,
+    blockNumber: number,
+  ): Promise<string[]> {
+    return [
+      this.dexKey +
+        '-' +
+        [srcToken.address.toLowerCase(), destToken.address.toLowerCase()]
+          .sort((a, b) => (a > b ? 1 : -1))
+          .join('_'),
+    ];
+  }
+
+  async getPoolState(
+    pool: InceptionEventPool,
+    blockNumber: number,
+  ): Promise<PoolState> {
+    const eventState = pool.getState(blockNumber);
+    if (eventState) return eventState;
+    const onChainState = await pool.generateState(blockNumber);
+    pool.setState(onChainState, blockNumber);
+    return onChainState;
+  }
+
+  async getPricesVolume(
+    srcToken: Token,
+    destToken: Token,
+    amounts: bigint[],
+    side: SwapSide,
+    blockNumber: number,
+    limitPools?: string[],
+    transferFees: TransferFeeParams = {
+      srcFee: 0,
+      destFee: 0,
+      srcDexFee: 0,
+      destDexFee: 0,
+    },
+  ): Promise<null | ExchangePrices<InceptionDexData>> {
+    if (side === SwapSide.BUY) {
+      return null;
+    }
+
+    const src = getTokenFromAddress(this.network, srcToken.address);
+    const dest = getTokenFromAddress(this.network, destToken.address);
+
+    if (!src || !dest || src !== dest) {
+      return null;
+    }
+
+    const poolState = await this.getPoolState(this.eventPool, blockNumber);
+    if (!poolState) return null;
+
+    const unitPrice = DECIMALS;
+    const prices = amounts.map(amount => {
+      const ratio = poolState[src.symbol.toLowerCase()].ratio;
+      return (ratio * amount) / DECIMALS;
+    });
+
+    const [unitPriceWithFee, ...pricesWithFee] = applyTransferFee(
+      [unitPrice, ...prices],
+      side,
+      side === SwapSide.SELL ? transferFees.srcFee : transferFees.destFee,
+      side === SwapSide.SELL
+        ? SRC_TOKEN_PARASWAP_TRANSFERS
+        : DEST_TOKEN_PARASWAP_TRANSFERS,
+    );
+
+    return [
+      {
+        prices: pricesWithFee,
+        unit: unitPriceWithFee,
+        gasCost: 120_000,
+        exchange: this.dexKey,
+        data: {
+          exchange: dest.vault,
+        },
+        poolAddresses: [dest.vault],
+      },
+    ];
+  }
+
+  getCalldataGasCost(
+    poolPrices: PoolPrices<InceptionDexData>,
+  ): number | number[] {
+    return CALLDATA_GAS_COST.DEX_OVERHEAD + CALLDATA_GAS_COST.LENGTH_SMALL;
+  }
+
+  getAdapterParam(): AdapterExchangeParam {
+    return {
+      targetExchange: NULL_ADDRESS,
+      payload: '0x',
+      networkFee: '0',
+    };
+  }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: InceptionDexData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const dexParams = getTokenFromAddress(this.network, srcToken);
+
+    if (!dexParams) {
+      throw new Error('Unknown token');
+    }
+
+    const isNative = dexParams.baseTokenSlug === 'ETH';
+    let swapData;
+    let dexFuncHasRecipient;
+    let swappedAmountNotPresentInExchangeData;
+    if (isNative) {
+      swapData = this.poolInterface.encodeFunctionData('stake()', []);
+      dexFuncHasRecipient = false;
+      swappedAmountNotPresentInExchangeData = true;
+    } else {
+      swapData = this.vaultInterface.encodeFunctionData('deposit', [
+        srcAmount,
+        recipient,
+      ]);
+      dexFuncHasRecipient = true;
+      swappedAmountNotPresentInExchangeData = false;
+    }
+
+    return {
+      needWrapNative: false,
+      dexFuncHasRecipient,
+      exchangeData: swapData,
+      targetExchange: dexParams.vault,
+      swappedAmountNotPresentInExchangeData,
+      returnAmountPos: undefined,
+    };
+  }
+
+  async updatePoolState(): Promise<void> {}
+
+  async getTopPoolsForToken(
+    tokenAddress: Address,
+    limit: number,
+  ): Promise<PoolLiquidity[]> {
+    await this.initializeTokens();
+
+    const token = getTokenFromAddress(this.network, tokenAddress);
+
+    if (token) {
+      return [
+        {
+          liquidityUSD: 1e9,
+          exchange: this.dexKey,
+          address: token.vault,
+          connectorTokens: [
+            {
+              address:
+                tokenAddress.toLowerCase() === token.token.toLowerCase()
+                  ? token.baseToken
+                  : token.token,
+              decimals: 1e18,
+            },
+          ],
+        },
+      ];
+    }
+    return [];
+  }
+
+  releaseResources(): AsyncOrSync<void> {}
+}

package/src/dex/inception/tokens.ts

@@ -0,0 +1,37 @@
+import { Network } from '../../constants';
+import { DexParams } from './types';
+
+export const Tokens: { [network: number]: { [symbol: string]: DexParams } } =
+  {};
+
+const TokensByAddress: {
+  [network: number]: { [address: string]: DexParams };
+} = {};
+
+export function setTokensOnNetwork(network: Network, tokens: DexParams[]) {
+  if (Tokens[network] === undefined) {
+    Tokens[network] = {};
+  }
+
+  if (TokensByAddress[network] === undefined) {
+    TokensByAddress[network] = {};
+  }
+
+  for (let token of tokens) {
+    token.vault = token.vault.toLowerCase();
+    token.token = token.token.toLowerCase();
+    token.baseToken = token.baseToken.toLowerCase();
+
+    Tokens[network][token.symbol] = token;
+    TokensByAddress[network][token.vault] = token;
+    TokensByAddress[network][token.token] = token;
+    TokensByAddress[network][token.baseToken] = token;
+  }
+}
+
+export function getTokenFromAddress(
+  network: Network,
+  address: string,
+): DexParams | undefined {
+  return TokensByAddress[network]?.[address.toLowerCase()];
+}