@paraswap/dex-lib 4.1.9 → 4.1.10-ekubo

package/src/dex/aave-v3-stata/config.ts

@@ -17,28 +17,28 @@ import {
 export const AaveV3StataConfig: DexConfigMap<DexParams> = {
   AaveV3Stata: {
     [Network.MAINNET]: {
-      factoryAddress: AaveV3Ethereum.STATIC_A_TOKEN_FACTORY,
+      factoryAddress: AaveV3Ethereum.LEGACY_STATIC_A_TOKEN_FACTORY,
     },
     [Network.POLYGON]: {
-      factoryAddress: AaveV3Polygon.STATIC_A_TOKEN_FACTORY,
+      factoryAddress: AaveV3Polygon.LEGACY_STATIC_A_TOKEN_FACTORY,
     },
     [Network.AVALANCHE]: {
-      factoryAddress: AaveV3Avalanche.STATIC_A_TOKEN_FACTORY,
+      factoryAddress: AaveV3Avalanche.LEGACY_STATIC_A_TOKEN_FACTORY,
     },
     [Network.ARBITRUM]: {
-      factoryAddress: AaveV3Arbitrum.STATIC_A_TOKEN_FACTORY,
+      factoryAddress: AaveV3Arbitrum.LEGACY_STATIC_A_TOKEN_FACTORY,
     },
     [Network.OPTIMISM]: {
-      factoryAddress: AaveV3Optimism.STATIC_A_TOKEN_FACTORY,
+      factoryAddress: AaveV3Optimism.LEGACY_STATIC_A_TOKEN_FACTORY,
     },
     [Network.BASE]: {
-      factoryAddress: AaveV3Base.STATIC_A_TOKEN_FACTORY,
+      factoryAddress: AaveV3Base.LEGACY_STATIC_A_TOKEN_FACTORY,
     },
     [Network.BSC]: {
-      factoryAddress: AaveV3BNB.STATIC_A_TOKEN_FACTORY,
+      factoryAddress: AaveV3BNB.LEGACY_STATIC_A_TOKEN_FACTORY,
     },
     [Network.GNOSIS]: {
-      factoryAddress: AaveV3Gnosis.STATIC_A_TOKEN_FACTORY,
+      factoryAddress: AaveV3Gnosis.LEGACY_STATIC_A_TOKEN_FACTORY,
     },
     // [Network.Scroll]: {
     //   factoryAddress: AaveV3Scroll.STATIC_A_TOKEN_FACTORY,

package/src/dex/aave-v3-stata-v2/aave-v3-stata-v2-e2e.test.ts

@@ -264,28 +264,28 @@ describe('AaveV3Stata E2E', () => {
   });
 
   // no tokens yet deployed
-  describe.skip('Optimism', () => {
+  describe('Optimism', () => {
     const network = Network.OPTIMISM;
 
     const pairs: { name: string; amount: string; skipBuy?: boolean }[][] = [
       [
         {
-          name: 'USDT',
+          name: 'USDC',
           amount: '100000',
         },
         {
-          name: 'stataUSDT',
+          name: 'stataUSDC',
           amount: '100000',
         },
       ],
       [
         {
-          name: 'aaveUSDT',
+          name: 'aOptUSDCn',
           amount: '100000',
           skipBuy: true,
         },
         {
-          name: 'stataUSDT',
+          name: 'stataUSDC', // no holders
           amount: '100000',
         },
       ],

package/src/dex/aave-v3-stata-v2/aave-v3-stata-v2.ts

@@ -103,7 +103,7 @@ export class AaveV3StataV2
 
     let tokenList = await fetchTokenList(
       this.dexHelper.web3Provider,
-      this.config.factoryAddresses,
+      this.config,
       this.dexHelper.multiWrapper,
       blockNumber,
     );
@@ -216,7 +216,7 @@ export class AaveV3StataV2
         true,
         [
           {
-            target: this.config.pool,
+            target: stataToken.pool,
             callData: AaveV3StataV2.pool.encodeFunctionData(
               'getReserveNormalizedIncome',
               [stataToken.underlying],

package/src/dex/aave-v3-stata-v2/config.ts

@@ -12,29 +12,36 @@ import {
 
 export const AaveV3StataConfig: DexConfigMap<DexParams> = {
   AaveV3StataV2: {
-    [Network.MAINNET]: {
-      factoryAddresses: [
-        AaveV3Ethereum.STATA_FACTORY,
-        AaveV3EthereumLido.STATA_FACTORY,
-      ],
-      pool: AaveV3Ethereum.POOL,
-    },
-    [Network.GNOSIS]: {
-      factoryAddresses: [AaveV3Gnosis.STATA_FACTORY],
-      pool: AaveV3Gnosis.POOL,
-    },
-    // Waiting for BalancerV3 to get released on Optimism
-    // [Network.OPTIMISM]: {
-    //   factoryAddresses: [AaveV3Optimism.STATA_FACTORY],
-    //   pool: AaveV3Optimism.POOL,
-    // },
-    [Network.ARBITRUM]: {
-      factoryAddresses: [AaveV3Arbitrum.STATA_FACTORY],
-      pool: AaveV3Arbitrum.POOL,
-    },
-    [Network.BASE]: {
-      factoryAddresses: [AaveV3Base.STATA_FACTORY],
-      pool: AaveV3Base.POOL,
-    },
+    [Network.MAINNET]: [
+      { factory: AaveV3Ethereum.STATA_FACTORY, pool: AaveV3Ethereum.POOL },
+      {
+        factory: AaveV3EthereumLido.STATA_FACTORY,
+        pool: AaveV3EthereumLido.POOL,
+      },
+    ],
+    [Network.GNOSIS]: [
+      {
+        factory: AaveV3Gnosis.STATA_FACTORY,
+        pool: AaveV3Gnosis.POOL,
+      },
+    ],
+    [Network.OPTIMISM]: [
+      {
+        factory: AaveV3Optimism.STATA_FACTORY,
+        pool: AaveV3Optimism.POOL,
+      },
+    ],
+    [Network.ARBITRUM]: [
+      {
+        factory: AaveV3Arbitrum.STATA_FACTORY,
+        pool: AaveV3Arbitrum.POOL,
+      },
+    ],
+    [Network.BASE]: [
+      {
+        factory: AaveV3Base.STATA_FACTORY,
+        pool: AaveV3Base.POOL,
+      },
+    ],
   },
 };

package/src/dex/aave-v3-stata-v2/types.ts

@@ -8,9 +8,9 @@ export enum TokenType {
 }
 
 export type DexParams = {
-  factoryAddresses: string[];
+  factory: string;
   pool: string;
-};
+}[];
 
 export type AaveV3StataV2Data = {
   exchange: Address;
@@ -24,6 +24,7 @@ export type StataToken = {
   underlyingAToken: string;
   stataSymbol: string;
   decimals: number;
+  pool: string;
 };
 
 export enum StataFunctions {

package/src/dex/aave-v3-stata-v2/utils.ts

@@ -6,21 +6,26 @@ import { Interface } from '@ethersproject/abi';
 import Web3 from 'web3';
 import { MultiCallParams, MultiWrapper } from '../../lib/multi-wrapper';
 import { stringDecode, uint8ToNumber, addressDecode } from '../../lib/decoders';
-import { StataToken } from './types';
+import { StataToken, DexParams } from './types';
 import FactoryABI from '../../abi/aavev3statav2/Factory.json';
 import TokenABI from '../../abi/aavev3statav2/Token.json';
 import { AbiItem } from 'web3-utils';
 
+type PoolAndToken = {
+  token: string;
+  pool: string;
+};
+
 // const stataInterface = new Interface(IStaticATokenLM_ABI);
 const statav2Interface = new Interface(TokenABI);
 
 async function getTokenMetaData(
-  stataTokens: string[],
+  stataTokens: PoolAndToken[],
   multiWrapper: MultiWrapper,
   blockNumber?: number,
 ): Promise<StataToken[]> {
   const calls: MultiCallParams<any>[] = stataTokens
-    .map(token => {
+    .map(({ token }) => {
       return [
         {
           target: token,
@@ -54,7 +59,8 @@ async function getTokenMetaData(
   let tokenList: StataToken[] = [];
   for (let i = 0, x = 0; i < stataTokens.length; ++i, x += 4) {
     tokenList.push({
-      address: stataTokens[i].toLowerCase(),
+      address: stataTokens[i].token.toLowerCase(),
+      pool: stataTokens[i].pool.toLowerCase(),
       stataSymbol: results[x] as string,
       decimals: results[x + 1] as number,
       underlying: (results[x + 2] as string).toLowerCase(),
@@ -66,22 +72,24 @@ async function getTokenMetaData(
 
 export const fetchTokenList = async (
   web3Provider: Web3,
-  factoryAddresses: string[],
+  config: DexParams,
   multiWrapper: MultiWrapper,
   blockNumber?: number,
 ): Promise<StataToken[]> => {
-  let stataList: string[] = (
+  let stataList: PoolAndToken[] = (
     (await Promise.all(
-      factoryAddresses.map(async factoryAddress => {
+      config.map(async ({ factory, pool }) => {
         let factoryContract = new web3Provider.eth.Contract(
           FactoryABI as AbiItem[],
           // IStaticATokenFactory_ABI as any,
-          factoryAddress,
+          factory,
         );
 
-        return await factoryContract.methods.getStataTokens().call();
+        return (
+          (await factoryContract.methods.getStataTokens().call()) as string[]
+        ).map(address => ({ token: address, pool }));
       }),
-    )) as string[][]
+    )) as PoolAndToken[][]
   ).flat();
 
   return getTokenMetaData(stataList, multiWrapper, blockNumber);

package/src/dex/ekubo/config.ts

@@ -0,0 +1,15 @@
+import { DexParams } from './types';
+import { DexConfigMap } from '../../types';
+import { Network } from '../../constants';
+
+export const EkuboConfig: DexConfigMap<DexParams> = {
+  Ekubo: {
+    [Network.MAINNET]: {
+      apiUrl: 'https://eth-mainnet-api.ekubo.org',
+      core: '0xe0e0e08A6A4b9Dc7bD67BCB7aadE5cF48157d444',
+      oracle: '0x51d02a5948496a67827242eabc5725531342527c',
+      dataFetcher: '0x91cB8a896cAF5e60b1F7C4818730543f849B408c',
+      router: '0x9995855C00494d039aB6792f18e368e530DFf931',
+    },
+  },
+};

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

@@ -0,0 +1,124 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import {
+  Tokens,
+  Holders,
+  NativeTokenSymbols,
+} from '../../../tests/constants-e2e';
+import { Network, ContractMethod, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+  nativeTokenAmount: string,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+  const nativeTokenSymbol = NativeTokenSymbols[network];
+
+  const sideToContractMethods = new Map([
+    [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
+  ]);
+
+  describe(`${network}`, () => {
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          describe(`${contractMethod}`, () => {
+            it(`${nativeTokenSymbol} -> ${tokenASymbol}`, async () => {
+              await testE2E(
+                tokens[nativeTokenSymbol],
+                tokens[tokenASymbol],
+                holders[nativeTokenSymbol],
+                side === SwapSide.SELL ? nativeTokenAmount : tokenAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+            it(`${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[nativeTokenSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+            it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
+              await testE2E(
+                tokens[tokenBSymbol],
+                tokens[tokenASymbol],
+                holders[tokenBSymbol],
+                side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
+describe('Ekubo E2E', () => {
+  const dexKey = 'Ekubo';
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+
+    const tokenASymbol: string = 'USDC';
+    const tokenBSymbol: string = 'USDT';
+
+    const tokenAAmount: string = '10000000';
+    const tokenBAmount: string = '10000000';
+    const nativeTokenAmount = '1000000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+      nativeTokenAmount,
+    );
+  });
+});

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

@@ -0,0 +1,209 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { Network } from '../../constants';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { testEventSubscriber } from '../../../tests/utils-events';
+import {
+  findNearestInitializedTickIndex,
+  PoolConfig,
+  PoolKey,
+  PoolState,
+} from './types';
+import { EkuboConfig } from './config';
+import { Contract } from 'ethers';
+import CoreABI from '../../abi/ekubo/core.json';
+import DataFetcherABI from '../../abi/ekubo/data-fetcher.json';
+import { Interface } from '@ethersproject/abi';
+import { BasePool } from './pools/base-pool';
+import { OraclePool } from './pools/oracle-pool';
+
+jest.setTimeout(50 * 1000);
+
+async function fetchPoolState(
+  pool: BasePool,
+  blockNumber: number,
+): Promise<PoolState.Object> {
+  return pool.generateState(blockNumber) as Promise<PoolState.Object>;
+}
+
+type EventMappings = Record<
+  string,
+  [
+    {
+      pool: typeof BasePool;
+      key: PoolKey;
+    }[],
+    number,
+  ][]
+>;
+
+function stateCompare(actual: PoolState.Object, expected: PoolState.Object) {
+  const [lowCheckedTickActual, highCheckedTickActual] =
+    actual.checkedTicksBounds;
+  const [lowCheckedTickExpected, highCheckedTickExpected] =
+    expected.checkedTicksBounds;
+
+  const [sameLowCheckedTicks, sameHighCheckedTicks] = [
+    lowCheckedTickActual === lowCheckedTickExpected,
+    highCheckedTickActual === highCheckedTickExpected,
+  ];
+
+  if (sameLowCheckedTicks && sameHighCheckedTicks) {
+    expect(actual).toStrictEqual(expected);
+    return;
+  }
+
+  expect(actual.sqrtRatio).toStrictEqual(expected.sqrtRatio);
+  expect(actual.activeTick).toStrictEqual(expected.activeTick);
+  expect(actual.liquidity).toStrictEqual(expected.liquidity);
+
+  /**
+   * The checked tick ranges differ between the two states at this point.
+   * In order to still compare the tick arrays, we thus have to exclude the liquidity cutoff ticks
+   * from the comparison (if they differ), as well as any other ticks that could've only
+   * been discovered in one of the two checked tick ranges.
+   */
+
+  let lowTickIndexActual: number, lowTickIndexExpected: number;
+
+  if (sameLowCheckedTicks) {
+    [lowTickIndexActual, lowTickIndexExpected] = [0, 0];
+  } else if (lowCheckedTickActual > lowCheckedTickExpected) {
+    lowTickIndexActual = 1;
+    lowTickIndexExpected =
+      findNearestInitializedTickIndex(
+        expected.sortedTicks,
+        lowCheckedTickActual,
+      )! + 1;
+  } else {
+    lowTickIndexExpected = 1;
+    lowTickIndexActual =
+      findNearestInitializedTickIndex(
+        actual.sortedTicks,
+        lowCheckedTickExpected,
+      )! + 1;
+  }
+
+  let highTickIndexActual: number, highTickIndexExpected: number;
+
+  if (sameHighCheckedTicks) {
+    [highTickIndexActual, highTickIndexExpected] = [
+      actual.sortedTicks.length,
+      expected.sortedTicks.length,
+    ];
+  } else if (highCheckedTickActual > highCheckedTickExpected) {
+    highTickIndexExpected = expected.sortedTicks.length - 1;
+
+    let tickIndex = findNearestInitializedTickIndex(
+      actual.sortedTicks,
+      highCheckedTickExpected,
+    )!;
+    highTickIndexActual =
+      actual.sortedTicks[tickIndex].number === highCheckedTickExpected
+        ? tickIndex
+        : tickIndex + 1;
+  } else {
+    highTickIndexActual = actual.sortedTicks.length - 1;
+
+    let tickIndex = findNearestInitializedTickIndex(
+      expected.sortedTicks,
+      highCheckedTickActual,
+    )!;
+    highTickIndexExpected =
+      expected.sortedTicks[tickIndex].number === highCheckedTickActual
+        ? tickIndex
+        : tickIndex + 1;
+  }
+
+  expect(
+    actual.sortedTicks.slice(lowTickIndexActual, highTickIndexActual),
+  ).toStrictEqual(
+    expected.sortedTicks.slice(lowTickIndexExpected, highTickIndexExpected),
+  );
+}
+
+const dexKey = 'Ekubo';
+
+describe('Ekubo Mainnet', function () {
+  const network = Network.MAINNET;
+  const config = EkuboConfig[dexKey][network];
+  const dexHelper = new DummyDexHelper(network);
+  const core = new Contract(config.core, CoreABI, dexHelper.provider);
+  const coreIface = new Interface(CoreABI);
+  const dataFetcher = new Contract(
+    config.dataFetcher,
+    DataFetcherABI,
+    dexHelper.provider,
+  );
+  const logger = dexHelper.getLogger(dexKey);
+
+  const baseEthUsdcPoolKey = new PoolKey(
+    0n,
+    0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48n,
+    new PoolConfig(5982, 55340232221128654n, 0n),
+  );
+
+  const oracleUsdcPoolKey = new PoolKey(
+    0n,
+    0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48n,
+    new PoolConfig(0, 0n, BigInt(config.oracle)),
+  );
+
+  const eventsToTest: EventMappings = {
+    Swapped: [
+      [
+        [
+          {
+            pool: BasePool,
+            key: baseEthUsdcPoolKey,
+          },
+        ],
+        22048500, // https://etherscan.io/tx/0xc401cc3007a2c0efd705c4c0dee5690ce8592858476b32cda8a4b000ceda0f24
+      ],
+      [
+        [
+          {
+            pool: OraclePool,
+            key: oracleUsdcPoolKey,
+          },
+        ],
+        22063200, // https://etherscan.io/tx/0xe689fb49b9627504d014a9b4663a6f0ec38ebfdc5642e261bb4bcd229d58206d
+      ],
+    ],
+  };
+
+  Object.entries(eventsToTest).forEach(([eventName, eventDetails]) => {
+    describe(eventName, () => {
+      for (const [pools, blockNumber] of eventDetails) {
+        describe(blockNumber, () => {
+          for (const { pool: constructor, key } of pools) {
+            it(`State of ${key.string_id}`, async function () {
+              const pool = new constructor(
+                dexKey,
+                network,
+                dexHelper,
+                logger,
+                coreIface,
+                dataFetcher,
+                key,
+                core,
+              );
+
+              await testEventSubscriber(
+                pool,
+                pool.addressesSubscribed,
+                (blockNumber: number) => fetchPoolState(pool, blockNumber),
+                blockNumber,
+                `${dexKey}_${pool.key.string_id}`,
+                dexHelper.provider,
+                stateCompare,
+              );
+            });
+          }
+        });
+      }
+    });
+  });
+});