@paraswap/dex-lib 4.0.17-statav2 → 4.0.17-usual-pp.0

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

@@ -1,13 +1,13 @@
 import { DexParams } from './types';
 import { DexConfigMap } from '../../types';
 import { Network } from '../../constants';
-import { AaveV3Ethereum, GhoEthereum } from '@bgd-labs/aave-address-book';
+import { AaveV3Ethereum, MiscEthereum } from '@bgd-labs/aave-address-book';
 
 export const AaveGsmConfig: DexConfigMap<DexParams> = {
   AaveGsm: {
     [Network.MAINNET]: {
-      GSM_USDT: GhoEthereum.GSM_USDT,
-      GSM_USDC: GhoEthereum.GSM_USDC,
+      GSM_USDT: MiscEthereum.GSM_USDT,
+      GSM_USDC: MiscEthereum.GSM_USDC,
       USDT: AaveV3Ethereum.ASSETS.USDT.UNDERLYING,
       USDC: AaveV3Ethereum.ASSETS.USDC.UNDERLYING,
       GHO: AaveV3Ethereum.ASSETS.GHO.UNDERLYING,

package/src/dex/aave-v2/tokens.ts

@@ -1,14 +1,15 @@
 import { aToken, Token } from '../../types';
 import { Network } from '../../constants';
-import tokens from './tokenlist.json';
+import { tokenlist } from '@bgd-labs/aave-address-book';
 import { aaveLendingPool } from './config';
 
 function getTokensForPool(pool: string): aToken[] {
-  return tokens
+  return tokenlist.tokens
     .filter(
       token =>
         token.extensions?.pool &&
-        token.extensions?.pool.toLowerCase() === pool.toLowerCase(),
+        token.extensions?.pool.toLowerCase() === pool.toLowerCase() &&
+        token.tags.includes('aTokenV2'),
     )
     .map(token => ({
       aSymbol: token.symbol,

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

@@ -10,6 +10,7 @@ import {
   AaveV3Fantom,
   AaveV3Optimism,
   AaveV3Polygon,
+  AaveV3PolygonZkEvm,
   AaveV3Gnosis,
 } from '@bgd-labs/aave-address-book';
 
@@ -64,12 +65,12 @@ export const Config: DexConfigMap<DexParam> = {
       poolAddress: AaveV3BNB.POOL,
       wethGatewayAddress: AaveV3BNB.WETH_GATEWAY,
     },
-    // [Network.ZKEVM]: {
-    //   ethGasCost: 246 * 100,
-    //   lendingGasCost: 328 * 1000,
-    //   poolAddress: AaveV3PolygonZkEvm.POOL,
-    //   wethGatewayAddress: AaveV3PolygonZkEvm.WETH_GATEWAY,
-    // },
+    [Network.ZKEVM]: {
+      ethGasCost: 246 * 100,
+      lendingGasCost: 328 * 1000,
+      poolAddress: AaveV3PolygonZkEvm.POOL,
+      wethGatewayAddress: AaveV3PolygonZkEvm.WETH_GATEWAY,
+    },
     [Network.GNOSIS]: {
       ethGasCost: 246 * 100,
       lendingGasCost: 328 * 1000,

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

@@ -19,16 +19,6 @@ import { FluidDex } from './fluid-dex';
   README
   ======
 
-  This test script should add e2e tests for FluidDex. The tests
-  should cover as many cases as possible. Most of the DEXes follow
-  the following test structure:
-    - DexName
-      - ForkName + Network
-        - ContractMethod
-          - ETH -> Token swap
-          - Token -> ETH swap
-          - Token -> Token swap
-
   The template already enumerates the basic structure which involves
   testing simpleSwap, multiSwap, megaSwap contract methods for
   ETH <> TOKEN and TOKEN <> TOKEN swaps. You should replace tokenA and
@@ -118,24 +108,6 @@ describe('FluidDex E2E', () => {
   describe('Mainnet', () => {
     const network = Network.MAINNET;
 
-    // TODO: Uncomment & test when the issue is resolved. Currently no price as expected.
-    // describe.only('FLUID -> ETH', () => {
-    //   const tokenASymbol: string = 'FLUID';
-    //   const tokenBSymbol: string = 'ETH';
-    //
-    //   const tokenAAmount: string = '160097047322810379';
-    //   const tokenBAmount: string = '79923068733005505624';
-    //
-    //   testForNetwork(
-    //     network,
-    //     dexKey,
-    //     tokenASymbol,
-    //     tokenBSymbol,
-    //     tokenAAmount,
-    //     tokenBAmount,
-    //   );
-    // });
-
     describe('ETH -> INST', () => {
       const tokenASymbol: string = 'ETH';
       const tokenBSymbol: string = 'INST';

package/src/dex/fluid-dex/fluid-dex.ts

@@ -48,11 +48,6 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
 
   pools: FluidDexPool[] = [];
 
-  // temporarily limit FLUID-ETH Dex Pool.
-  restrictedIds: string[] = [
-    'FluidDex_0xc800b0e15c40a1ff0539218100c86f4c1bac8d9c',
-  ];
-
   eventPools: FluidDexEventPool[] = [];
 
   readonly factory: FluidDexFactory;
@@ -115,9 +110,8 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
   // implement this function
   async initializePricing(blockNumber: number) {
     await this.factory.initialize(blockNumber);
-    this.pools = (await this.fetchFluidDexPools(blockNumber)).filter(
-      pool => !this.restrictedIds.includes(pool.id),
-    );
+    this.pools = await this.fetchFluidDexPools(blockNumber);
+
     this.eventPools = await Promise.all(
       this.pools.map(async pool => {
         const eventPool = new FluidDexEventPool(
@@ -140,9 +134,7 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
   }
 
   protected onPoolCreatedUpdatePools(poolsFromFactory: readonly Pool[]) {
-    this.pools = this.generateFluidDexPoolsFromPoolsFactory(
-      poolsFromFactory,
-    ).filter(pool => !this.restrictedIds.includes(pool.id));
+    this.pools = this.generateFluidDexPoolsFromPoolsFactory(poolsFromFactory);
     this.logger.info(`${this.dexKey}: pools list was updated ...`);
   }
 
@@ -182,9 +174,6 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
     // A pair must have 2 different tokens.
     if (srcAddress === destAddress) return [];
 
-    this.pools = this.pools.filter(
-      pool => !this.restrictedIds.includes(pool.id),
-    );
     const pools = this.pools.filter(
       pool =>
         (srcAddress === pool.token0 && destAddress === pool.token1) ||
@@ -217,6 +206,12 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
         pools = pools.filter(pool => limitPools.includes(pool.id));
       }
 
+      // temporarily limit FLUID-ETH Dex Pool.
+      pools = pools.filter(
+        pool =>
+          pool.id != 'FluidDex_0xc800b0e15c40a1ff0539218100c86f4c1bac8d9c',
+      );
+
       if (!pools.length) return null;
 
       const liquidityProxyState = await this.liquidityProxy.getStateOrGenerate(

package/src/dex/index.ts

@@ -85,7 +85,6 @@ import { EtherFi } from './etherfi';
 import { Spark } from './spark/spark';
 import { VelodromeSlipstream } from './uniswap-v3/forks/velodrome-slipstream/velodrome-slipstream';
 import { AaveV3Stata } from './aave-v3-stata/aave-v3-stata';
-import { AaveV3StataV2 } from './aave-v3-stata-v2/aave-v3-stata-v2';
 import { OSwap } from './oswap/oswap';
 import { FluidDex } from './fluid-dex/fluid-dex';
 import { ConcentratorArusd } from './concentrator-arusd/concentrator-arusd';
@@ -101,6 +100,7 @@ import { Stader } from './stader/stader';
 import { UsualBond } from './usual/usual-bond';
 import { UsualMWrappedM } from './usual/usual-m-wrapped-m';
 import { UsualMUsd0 } from './usual/usual-m-usd0';
+import { UsualPP } from './usual-pp/usual-pp';
 
 const LegacyDexes = [
   CurveV2,
@@ -183,7 +183,6 @@ const Dexes = [
   PharaohV1,
   Spark,
   AaveV3Stata,
-  AaveV3StataV2,
   OSwap,
   ConcentratorArusd,
   FxProtocolRusd,
@@ -196,6 +195,7 @@ const Dexes = [
   FluidDex,
   UsualMWrappedM,
   UsualMUsd0,
+  UsualPP,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<

package/src/dex/pancakeswap-v3/pancakeswap-v3-pool.ts

@@ -265,15 +265,15 @@ export class PancakeSwapV3EventPool extends StatefulEventSubscriber<PoolState> {
   }
 
   _setState(state: any, blockNumber: number, reason?: string): void {
-    // if (this.parentName === 'PancakeswapV3') {
-    //   this.logger.info(
-    //     `PancakeV3: Setting state: ${!!state ? 'non-empty' : 'empty'} for '${
-    //       this.name
-    //     }' for bn: '${blockNumber}' due to reason: '${
-    //       reason ?? 'outside_of_event_subscriber'
-    //     }'`,
-    //   );
-    // }
+    if (this.parentName === 'PancakeswapV3') {
+      this.logger.info(
+        `PancakeV3: Setting state: ${!!state ? 'non-empty' : 'empty'} for '${
+          this.name
+        }' for bn: '${blockNumber}' due to reason: '${
+          reason ?? 'outside_of_event_subscriber'
+        }'`,
+      );
+    }
     super._setState(state, blockNumber);
   }
 

package/src/dex/stkgho/config.ts

@@ -2,13 +2,13 @@ import { DexParams } from './types';
 import { DexConfigMap } from '../../types';
 import { Network } from '../../constants';
 
-import { GhoEthereum, AaveSafetyModule } from '@bgd-labs/aave-address-book';
+import { MiscEthereum } from '@bgd-labs/aave-address-book';
 
 export const StkGHOConfig: DexConfigMap<DexParams> = {
   StkGHO: {
     [Network.MAINNET]: {
-      stkGHO: AaveSafetyModule.STK_GHO,
-      GHO: GhoEthereum.GHO_TOKEN,
+      stkGHO: '0x1a88Df1cFe15Af22B3c4c783D4e6F7F9e0C1885d',
+      GHO: MiscEthereum.GHO_TOKEN,
     },
   },
 };

package/src/dex/uniswap-v3/config.ts

@@ -359,6 +359,32 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
       subgraphURL: 'Dimv1udMsJu1DqirVM4G2vNRvH8CWzWTn7GffQQCGAaq',
     },
   },
+  VelodromeSlipstream: {
+    [Network.OPTIMISM]: {
+      factory: '0x548118C7E0B865C2CfA94D15EC86B666468ac758',
+      quoter: '0xA2DEcF05c16537C702779083Fe067e308463CE45',
+      router: '0x93A3b44C38A8557E935B3e2549B2809a582c28EE',
+      supportedFees: SUPPORTED_FEES,
+      tickSpacings: [1n, 50n, 100n, 200n, 2000n],
+      tickSpacingsToFees: {
+        '1': 100n,
+        '50': 500n,
+        '100': 500n,
+        '200': 3000n,
+        '2000': 10000n,
+      },
+      stateMulticall: '0xc055b23319b3a140D4De2d0001bd0A885B3d7DbB',
+      stateMultiCallAbi: VelodromeSlipstreamMulticallABi as AbiItem[],
+      eventPoolImplementation: VelodromeSlipstreamEventPool,
+      factoryImplementation: VelodromeSlipstreamFactory,
+      decodeStateMultiCallResultWithRelativeBitmaps:
+        decodeStateMultiCallResultWithRelativeBitmapsForVelodromeSlipstream,
+      uniswapMulticall: '0x1F98415757620B543A52E61c46B32eB19261F984',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash: '0xE0A596c403E854FFb9C828aB4f07eEae04A05D37', // pool implementation address from factory contract is used instead of initHash here
+    },
+  },
   VelodromeSlipstreamNewFactory: {
     [Network.OPTIMISM]: {
       factory: '0xCc0bDDB707055e04e497aB22a59c2aF4391cd12F',

package/src/dex/uniswap-v3/uniswap-v3-pool.ts

@@ -269,15 +269,15 @@ export class UniswapV3EventPool extends StatefulEventSubscriber<PoolState> {
   }
 
   _setState(state: any, blockNumber: number, reason?: string): void {
-    // if (this.parentName === 'UniswapV3') {
-    // this.logger.info(
-    //   `UniV3: Setting state: '${!!state ? 'non-empty' : 'empty'}' for '${
-    //     this.name
-    //   }' for bn: '${blockNumber}' due to reason: '${
-    //     reason ?? 'outside_of_event_subscriber'
-    //   }'`,
-    // );
-    // }
+    if (this.parentName === 'UniswapV3') {
+      this.logger.info(
+        `UniV3: Setting state: '${!!state ? 'non-empty' : 'empty'}' for '${
+          this.name
+        }' for bn: '${blockNumber}' due to reason: '${
+          reason ?? 'outside_of_event_subscriber'
+        }'`,
+      );
+    }
     super._setState(state, blockNumber);
   }
 

package/src/dex/usual/usual.ts

@@ -72,7 +72,7 @@ export class Usual extends SimpleExchange implements IDex<UsualBondData> {
     }
 
     if (this.isValidTokens(srcTokenAddress, destTokenAddress)) {
-      return [`${this.dexKey}_${this.config.toToken}`];
+      return [`${this.dexKey}_${this.config.toToken.address}`];
     }
 
     return [];

package/src/dex/usual-pp/config.ts

@@ -0,0 +1,18 @@
+import { Network } from '../../constants';
+import { DexConfigMap } from '../../types';
+import { DexParams } from './types';
+
+export const Config: DexConfigMap<DexParams> = {
+  UsualPP: {
+    [Network.MAINNET]: {
+      USD0: {
+        address: '0x73a15fed60bf67631dc6cd7bc5b6e8da8190acf5',
+        decimals: 18,
+      },
+      USD0PP: {
+        address: '0x35d8949372d46b7a3d5a56006ae77b215fc69bc0',
+        decimals: 18,
+      },
+    },
+  },
+};

package/src/dex/usual-pp/pool.ts

@@ -0,0 +1,77 @@
+import _ from 'lodash';
+import { Interface } from '@ethersproject/abi';
+import { IDexHelper } from '../../dex-helper';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import { Address, Log, Logger } from '../../types';
+import { AsyncOrSync, DeepReadonly } from 'ts-essentials';
+import { PoolState } from './types';
+import { getOnChainState } from './utils';
+
+export class UsualPool extends StatefulEventSubscriber<PoolState> {
+  decoder = (log: Log) => this.poolInterface.parseLog(log);
+
+  constructor(
+    parentName: string,
+    protected dexHelper: IDexHelper,
+    private poolAddress: Address,
+    private poolInterface: Interface,
+    logger: Logger,
+  ) {
+    super(parentName, 'UsualPool', dexHelper, logger);
+    this.addressesSubscribed = [poolAddress];
+  }
+
+  protected processLog(
+    state: DeepReadonly<PoolState>,
+    log: Readonly<Log>,
+  ): AsyncOrSync<DeepReadonly<PoolState> | null> {
+    const event = this.decoder(log);
+    const _state: PoolState = _.cloneDeep(state);
+    if (event.name === 'FloorPriceUpdated') {
+      _state.price = BigInt(event.args.newFloorPrice);
+      return _state;
+    }
+    return null;
+  }
+
+  async generateState(
+    blockNumber: number | 'latest' = 'latest',
+  ): Promise<DeepReadonly<PoolState>> {
+    const state = await getOnChainState(
+      this.dexHelper.multiContract,
+      this.poolAddress,
+      this.poolInterface,
+      blockNumber,
+    );
+    return state;
+  }
+
+  async getPrice(blockNumber: number): Promise<bigint> {
+    const state = await this.getOrGenerateState(blockNumber);
+    if (!state) throw new Error('Cannot compute state');
+    return state.price;
+  }
+
+  async getOrGenerateState(
+    blockNumber: number,
+  ): Promise<DeepReadonly<PoolState> | null> {
+    const state = this.getState(blockNumber);
+    if (state) {
+      return state;
+    }
+
+    this.logger.debug(
+      `No state found for ${this.addressesSubscribed[0]}, generating new one`,
+    );
+    const newState = await this.generateState(blockNumber);
+
+    if (!newState) {
+      this.logger.debug(
+        `Could not regenerate state for ${this.addressesSubscribed[0]}`,
+      );
+      return null;
+    }
+    this.setState(newState, blockNumber);
+    return newState;
+  }
+}

package/src/dex/usual-pp/types.ts

@@ -0,0 +1,12 @@
+import { Address } from '../../types';
+
+export type PoolState = {
+  price: bigint;
+};
+
+export type UsualPPData = {};
+
+export type DexParams = {
+  USD0: { address: Address; decimals: number };
+  USD0PP: { address: Address; decimals: number };
+};

package/src/dex/usual-pp/usual-events.test.ts

@@ -0,0 +1,70 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { Network } from '../../constants';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { testEventSubscriber } from '../../../tests/utils-events';
+import { PoolState } from './types';
+import { Config } from './config';
+import { UsualPool } from './pool';
+import { PoolConfig } from '../curve-v1/types';
+import UsualPoolAbi from '../../abi/usual-pp/abi.json';
+import { Interface } from '@ethersproject/abi';
+
+jest.setTimeout(50 * 1000);
+const dexKey = 'UsualPP';
+const network = Network.MAINNET;
+const config = Config[dexKey][network];
+const dexHelper = new DummyDexHelper(network);
+const logger = dexHelper.getLogger(dexKey);
+
+async function fetchPoolState(
+  usualPool: UsualPool,
+  blockNumber: number,
+): Promise<PoolState> {
+  return usualPool.generateState(blockNumber);
+}
+
+function compareState(state: PoolState, expectedState: PoolState) {
+  expect(state).toEqual(expectedState);
+}
+
+describe('UsualPP Event', function () {
+  const blockNumbers: { [eventName: string]: number[] } = {
+    FloorPriceUpdated: [21589702],
+  };
+
+  describe('UsualPool', function () {
+    let usualPool: UsualPool;
+    let blockNumber: number;
+
+    const usualPoolIface = new Interface(UsualPoolAbi);
+
+    beforeAll(async function () {
+      blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+    });
+
+    Object.keys(blockNumbers).forEach((event: string) => {
+      blockNumbers[event].forEach((blockNumber: number) => {
+        it(`Should return the correct state after the ${blockNumber}:${event}`, async function () {
+          usualPool = new UsualPool(
+            dexKey,
+            dexHelper,
+            config.USD0PP.address,
+            usualPoolIface,
+            logger,
+          );
+          await testEventSubscriber(
+            usualPool,
+            usualPool.addressesSubscribed,
+            (_blockNumber: number) => fetchPoolState(usualPool, _blockNumber),
+            blockNumber,
+            `${dexKey}_${config.USD0PP.address}`,
+            dexHelper.provider,
+            compareState,
+          );
+        });
+      });
+    });
+  });
+});

package/src/dex/usual-pp/usual-integration.test.ts

@@ -0,0 +1,143 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { Interface } from '@ethersproject/abi';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { Network, SwapSide } from '../../constants';
+import { BI_POWS } from '../../bigint-constants';
+import {
+  checkPoolPrices,
+  checkConstantPoolPrices,
+  checkPoolsLiquidity,
+} from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+import { UsualPP } from './usual-pp';
+
+async function testPricingOnNetwork(
+  usual: UsualPP,
+  network: Network,
+  dexKey: string,
+  blockNumber: number,
+  srcTokenSymbol: string,
+  destTokenSymbol: string,
+  side: SwapSide,
+  amounts: bigint[],
+  funcNameToCheck: string,
+) {
+  const networkTokens = Tokens[network];
+
+  console.log(amounts);
+
+  const pools = await usual.getPoolIdentifiers(
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    side,
+    blockNumber,
+  );
+  console.log(
+    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Identifiers: `,
+    pools,
+  );
+
+  expect(pools.length).toBeGreaterThan(0);
+
+  const poolPrices = await usual.getPricesVolume(
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    amounts,
+    side,
+    blockNumber,
+    pools,
+  );
+  console.log(
+    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Prices: `,
+    poolPrices,
+  );
+
+  expect(poolPrices).not.toBeNull();
+  // Check if onchain pricing equals to calculated ones
+}
+
+describe('UsualPP', function () {
+  const dexKey = 'UsualPP';
+  let blockNumber: number;
+  let usualPP: UsualPP;
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+    const dexHelper = new DummyDexHelper(network);
+
+    // Don't forget to update relevant tokens in constant-e2e.ts
+
+    const amountsForSell = [
+      0n,
+      1n * BI_POWS[18],
+      2n * BI_POWS[18],
+      3n * BI_POWS[18],
+      4n * BI_POWS[18],
+      5n * BI_POWS[18],
+      6n * BI_POWS[18],
+      7n * BI_POWS[18],
+      8n * BI_POWS[18],
+      9n * BI_POWS[18],
+      10n * BI_POWS[18],
+    ];
+
+    beforeAll(async () => {
+      blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      usualPP = new UsualPP(network, dexKey, dexHelper);
+      if (usualPP.initializePricing) {
+        await usualPP.initializePricing(blockNumber);
+      }
+    });
+
+    it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+      await testPricingOnNetwork(
+        usualPP,
+        network,
+        dexKey,
+        blockNumber,
+        'USD0++',
+        'USD0',
+        SwapSide.SELL,
+        amountsForSell,
+        '',
+      );
+    });
+
+    it('getTopPoolsForToken: USD0', async function () {
+      const tokenA = Tokens[network]['USD0'];
+      const dexHelper = new DummyDexHelper(network);
+      const usualPP = new UsualPP(network, dexKey, dexHelper);
+
+      const poolLiquidity = await usualPP.getTopPoolsForToken(
+        tokenA.address,
+        10,
+      );
+      console.log(
+        `${tokenA.symbol} Top Pools:`,
+        JSON.stringify(poolLiquidity, null, 2),
+      );
+
+      checkPoolsLiquidity(poolLiquidity, tokenA.address, dexKey);
+    });
+
+    it('getTopPoolsForToken: USD0++', async function () {
+      const tokenA = Tokens[network]['USD0++'];
+      const dexHelper = new DummyDexHelper(network);
+      const usualPP = new UsualPP(network, dexKey, dexHelper);
+
+      const poolLiquidity = await usualPP.getTopPoolsForToken(
+        tokenA.address,
+        10,
+      );
+      console.log(
+        `${tokenA.symbol} Top Pools:`,
+        JSON.stringify(poolLiquidity, null, 2),
+      );
+
+      checkPoolsLiquidity(poolLiquidity, tokenA.address, dexKey);
+    });
+  });
+});