@paraswap/dex-lib 3.11.5-fluid-dex-changes.1 → 3.11.5

package/src/dex/algebra/algebra.ts

@@ -61,8 +61,8 @@ type PoolPairsInfo = {
 
 const PoolsRegistryHashKey = `${CACHE_PREFIX}_poolsRegistry`;
 
-// const ALGEBRA_CLEAN_NOT_EXISTING_POOL_TTL_MS = 3 * 24 * 60 * 60 * 1000; // 3 days
-// const ALGEBRA_CLEAN_NOT_EXISTING_POOL_INTERVAL_MS = 24 * 60 * 60 * 1000; // Once in a day
+const ALGEBRA_CLEAN_NOT_EXISTING_POOL_TTL_MS = 3 * 24 * 60 * 60 * 1000; // 3 days
+const ALGEBRA_CLEAN_NOT_EXISTING_POOL_INTERVAL_MS = 24 * 60 * 60 * 1000; // Once in a day
 const ALGEBRA_EFFICIENCY_FACTOR = 3;
 const ALGEBRA_TICK_GAS_COST = 24_000; // Ceiled
 const ALGEBRA_TICK_BASE_OVERHEAD = 75_000;
@@ -168,23 +168,24 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
     // Init listening to new pools creation
     await this.factory.initialize(blockNumber);
 
-    //// COMMENTING DEPRECATED LOGIC: as we now  invalidate pools on creation this is not needed anymore
-    // if (!this.dexHelper.config.isSlave) {
-    //   const cleanExpiredNotExistingPoolsKeys = async () => {
-    //     const maxTimestamp =
-    //       Date.now() - ALGEBRA_CLEAN_NOT_EXISTING_POOL_TTL_MS;
-    //     await this.dexHelper.cache.zremrangebyscore(
-    //       this.notExistingPoolSetKey,
-    //       0,
-    //       maxTimestamp,
-    //     );
-    //   };
-
-    //   this.intervalTask = setInterval(
-    //     cleanExpiredNotExistingPoolsKeys.bind(this),
-    //     ALGEBRA_CLEAN_NOT_EXISTING_POOL_INTERVAL_MS,
-    //   );
-    // }
+    if (!this.dexHelper.config.isSlave) {
+      const cleanExpiredNotExistingPoolsKeys = async () => {
+        const maxTimestamp =
+          Date.now() - ALGEBRA_CLEAN_NOT_EXISTING_POOL_TTL_MS;
+        await this.dexHelper.cache.zremrangebyscore(
+          this.notExistingPoolSetKey,
+          0,
+          maxTimestamp,
+        );
+      };
+
+      void cleanExpiredNotExistingPoolsKeys();
+
+      this.intervalTask = setInterval(
+        cleanExpiredNotExistingPoolsKeys.bind(this),
+        ALGEBRA_CLEAN_NOT_EXISTING_POOL_INTERVAL_MS,
+      );
+    }
   }
 
   /*

package/src/dex/algebra/config.ts

@@ -27,8 +27,7 @@ export const AlgebraConfig: DexConfigMap<DexParams> = {
       chunksCount: 3,
       initRetryFrequency: 30,
       algebraStateMulticall: '0xa6bc273A238867dD74F2bBbD5fBbA3c941C939B9',
-      subgraphURL:
-        'https://api.studio.thegraph.com/query/44554/quickswap-v3-02/0.0.7',
+      subgraphURL: '3L5Y5brtgvzDoAFGaPs63xz27KdviCdzRuY12spLSBGU',
       uniswapMulticall: '0x61530d6E1c7A47BBB3e48e8b8EdF7569DcFeE121',
       deployer: '0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270',
       version: 'v1.1',

package/src/dex/balancer-v2/balancer-v2-e2e.test.ts

@@ -41,6 +41,7 @@ function testForNetwork(
         // ContractMethod.multiSwap,
         // ContractMethod.megaSwap,
         ContractMethod.swapExactAmountIn,
+        ContractMethod.swapExactAmountInOnBalancerV2,
       ],
     ],
     [
@@ -50,6 +51,7 @@ function testForNetwork(
         // ContractMethod.buy,
         // DirectMethodsV6.directBuy,
         ContractMethod.swapExactAmountOut,
+        ContractMethod.swapExactAmountOutOnBalancerV2,
       ],
     ],
   ]);
@@ -128,6 +130,82 @@ describe('BalancerV2 E2E', () => {
       network,
     );
 
+    describe.only('GHO -> USDT', () => {
+      const pairs: { name: string; sellAmount: string; buyAmount: string }[][] =
+        [
+          [
+            {
+              name: 'GHO',
+              sellAmount: '1000000000000000000000',
+              buyAmount: '1000000000',
+            },
+            {
+              name: 'USDT',
+              sellAmount: '1000000000',
+              buyAmount: '1000000000000000000000',
+            },
+          ],
+        ];
+
+      const sideToContractMethods = new Map([
+        [
+          SwapSide.SELL,
+          [
+            ContractMethod.swapExactAmountIn,
+            ContractMethod.swapExactAmountInOnBalancerV2,
+          ],
+        ],
+        [
+          SwapSide.BUY,
+          [
+            ContractMethod.swapExactAmountOut,
+            ContractMethod.swapExactAmountOutOnBalancerV2,
+          ],
+        ],
+      ]);
+
+      sideToContractMethods.forEach((contractMethods, side) =>
+        describe(`${side}`, () => {
+          contractMethods.forEach((contractMethod: string) => {
+            pairs.forEach(pair => {
+              describe(`${contractMethod}`, () => {
+                it(`${pair[0].name} -> ${pair[1].name}`, async () => {
+                  await testE2E(
+                    tokens[pair[0].name],
+                    tokens[pair[1].name],
+                    holders[pair[0].name],
+                    side === SwapSide.SELL
+                      ? pair[0].sellAmount
+                      : pair[0].buyAmount,
+                    side,
+                    dexKey,
+                    contractMethod as any,
+                    network,
+                    provider,
+                  );
+                });
+                it(`${pair[1].name} -> ${pair[0].name}`, async () => {
+                  await testE2E(
+                    tokens[pair[1].name],
+                    tokens[pair[0].name],
+                    holders[pair[1].name],
+                    side === SwapSide.SELL
+                      ? pair[1].sellAmount
+                      : pair[1].buyAmount,
+                    side,
+                    dexKey,
+                    contractMethod as any,
+                    network,
+                    provider,
+                  );
+                });
+              });
+            });
+          });
+        }),
+      );
+    });
+
     describe('Weighted Pool', () => {
       const sideToContractMethods = new Map([
         [

package/src/dex/balancer-v2/balancer-v2.ts

@@ -266,6 +266,7 @@ export class BalancerV2EventPool extends StatefulEventSubscriber<PoolStateMap> {
   buySupportedPoolTypes: Set<BalancerPoolTypes> = new Set([
     BalancerPoolTypes.Weighted,
     BalancerPoolTypes.GyroE,
+    BalancerPoolTypes.ComposableStable,
   ]);
 
   eventSupportedPoolTypes: BalancerPoolTypes[] = [
@@ -868,6 +869,7 @@ export class BalancerV2
         this.logger.error(`getState returned null`);
       }
       const eventPoolStates = { ...(eventPoolStatesRO || {}) };
+
       for (const addr of this.eventDisabledPools) delete eventPoolStates[addr];
 
       // Fetch previously cached non-event pool states

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

@@ -7,7 +7,7 @@ export const FluidDexConfig: DexConfigMap<DexParams> = {
     [Network.MAINNET]: {
       commonAddresses: {
         liquidityProxy: '0x52aa899454998be5b000ad077a46bbe360f4e497',
-        resolver: '0x45f4ad57e300da55c33dea579a40fcee000d7b94',
+        resolver: '0xE8a07a32489BD9d5a00f01A55749Cf5cB854Fd13',
         dexFactory: '0x91716C4EDA1Fb55e84Bf8b4c7085f84285c19085',
       },
     },

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

@@ -3,6 +3,7 @@ import dotenv from 'dotenv';
 dotenv.config();
 
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
+
 import { testE2E } from '../../../tests/utils-e2e';
 import {
   Tokens,
@@ -11,9 +12,6 @@ import {
 } from '../../../tests/constants-e2e';
 import { Network, ContractMethod, SwapSide } from '../../constants';
 import { generateConfig } from '../../config';
-import { CollateralReserves, DebtReserves, DexLimits } from './types';
-import { DummyDexHelper } from '../../dex-helper/index';
-import { FluidDex } from './fluid-dex';
 
 /*
   README
@@ -72,7 +70,6 @@ function testForNetwork(
 
   const sideToContractMethods = new Map([
     [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
-    [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
   ]);
 
   describe(`${network}`, () => {
@@ -140,8 +137,8 @@ describe('FluidDex E2E', () => {
       const tokenASymbol: string = 'USDC';
       const tokenBSymbol: string = 'USDT';
 
-      const tokenAAmount: string = '10000';
-      const tokenBAmount: string = '1000000';
+      const tokenAAmount: string = '1000000';
+      const tokenBAmount: string = '100000000';
 
       testForNetwork(
         network,
@@ -154,148 +151,3 @@ describe('FluidDex E2E', () => {
     });
   });
 });
-
-function NewColReservesOne(): CollateralReserves {
-  return {
-    token0RealReserves: BigInt(20000000006000000),
-    token1RealReserves: BigInt(20000000000500000),
-    token0ImaginaryReserves: BigInt(389736659726997981),
-    token1ImaginaryReserves: BigInt(389736659619871949),
-  };
-}
-
-function NewDebtReservesOne(): DebtReserves {
-  return {
-    token0Debt: BigInt(1e18),
-    token1Debt: BigInt(1e18),
-    token0RealReserves: BigInt(9486832995556050),
-    token1RealReserves: BigInt(9486832993079885),
-    token0ImaginaryReserves: BigInt(184868330099560759),
-    token1ImaginaryReserves: BigInt(184868330048879109),
-  };
-}
-
-const limitsTight: DexLimits = {
-  withdrawableToken0: {
-    available: 456740438880263n,
-    expandsTo: 711907234052361388866n,
-    expandsDuration: 600n,
-  },
-  withdrawableToken1: {
-    available: 825179383432029n,
-    expandsTo: 711907234052361388866n,
-    expandsDuration: 600n,
-  },
-  borrowableToken0: {
-    available: 941825058374170n,
-    expandsTo: 711907234052361388866n,
-    expandsDuration: 600n,
-  },
-  borrowableToken1: {
-    available: 941825058374170n,
-    expandsTo: 711907234052361388866n,
-    expandsDuration: 600n,
-  },
-};
-
-const limitsWide: DexLimits = {
-  withdrawableToken0: {
-    available: BigInt(34242332879776515083099999),
-    expandsTo: BigInt(34242332879776515083099999),
-    expandsDuration: BigInt(0),
-  },
-  withdrawableToken1: {
-    available: BigInt(34242332879776515083099999),
-    expandsTo: BigInt(34242332879776515083099999),
-    expandsDuration: BigInt(22),
-  },
-  borrowableToken0: {
-    available: BigInt(34242332879776515083099999),
-    expandsTo: BigInt(34242332879776515083099999),
-    expandsDuration: BigInt(0),
-  },
-  borrowableToken1: {
-    available: BigInt(34242332879776515083099999),
-    expandsTo: BigInt(34242332879776515083099999),
-    expandsDuration: BigInt(308),
-  },
-};
-
-const ErrInsufficientBorrowable = new Error('insufficient borrowable');
-const ErrInsufficientMaxPrice = new Error('insufficient max price');
-const ErrInsufficientReserve = new Error('insufficient reserve');
-
-describe('TestPoolSimulator_SwapInLimits', () => {
-  const network = Network.MAINNET;
-  const dexHelper = new DummyDexHelper(network);
-  const dexKey = 'FluidDex';
-  const fluidDex = new FluidDex(network, dexKey, dexHelper);
-
-  it('when limits hit', () => {
-    let outAmt;
-    try {
-      outAmt = fluidDex.swapInAdjusted(
-        true,
-        BigInt(1e15),
-        NewColReservesOne(),
-        NewDebtReservesOne(),
-        18,
-        limitsTight,
-        Math.floor(Date.now() / 1000) - 10,
-      );
-      expect(outAmt).toEqual(0n);
-    } catch (err: any) {
-      expect(err.message).toEqual(ErrInsufficientBorrowable.message);
-    }
-  });
-
-  it('when expanded', () => {
-    const outAmt = fluidDex.swapInAdjusted(
-      true,
-      BigInt(1e15),
-      NewColReservesOne(),
-      NewDebtReservesOne(),
-      18,
-      limitsTight,
-      Math.floor(Date.now() / 1000) - 6000,
-    );
-    console.log('outAmt: ', outAmt);
-    expect(outAmt?.toString()).toEqual('998262697204710');
-  });
-
-  it('when price diff hit', () => {
-    let outAmt;
-    try {
-      outAmt = fluidDex.swapInAdjusted(
-        true,
-        BigInt(3e16),
-        NewColReservesOne(),
-        NewDebtReservesOne(),
-        18,
-        limitsWide,
-        Math.floor(Date.now() / 1000) - 10,
-      );
-      expect(outAmt).toEqual(0n);
-    } catch (err: any) {
-      expect(err.message).toEqual(ErrInsufficientMaxPrice.message);
-    }
-  });
-
-  it('when reserves limit is hit', () => {
-    let outAmt;
-    try {
-      outAmt = fluidDex.swapInAdjusted(
-        true,
-        BigInt(5e16),
-        NewColReservesOne(),
-        NewDebtReservesOne(),
-        18,
-        limitsWide,
-        Math.floor(Date.now() / 1000) - 10,
-      );
-      expect(outAmt).toEqual(0n);
-    } catch (err: any) {
-      expect(err.message).toEqual(ErrInsufficientReserve.message);
-    }
-  });
-});

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

@@ -38,7 +38,9 @@ describe('FluidDex EventPool Mainnet', function () {
     const eventsToTest: Record<Address, EventMappings> = {
       '0x52aa899454998be5b000ad077a46bbe360f4e497': {
         LogOperate: [
-          21190399, 21190405, 21190420, 21190452, 21190454, 21190465, 21190506,
+          21091850, 21091882, 21091897, 21091915, 21092008, 21092022, 21092039,
+          21092142, 21092176, 21092187, 21092230, 21092286, 21092289, 21092295,
+          21092319, 21092352, 21092360, 21092368, 21092378, 21092383,
         ],
       },
     };
@@ -84,7 +86,7 @@ describe('FluidDex EventPool Mainnet', function () {
 
     const eventsToTest: Record<Address, EventMappings> = {
       '0x91716C4EDA1Fb55e84Bf8b4c7085f84285c19085': {
-        LogDexDeployed: [21199929],
+        LogDexDeployed: [21105297, 21105362, 21105366, 21105370],
       },
     };
 

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

@@ -39,13 +39,14 @@ function getReaderCalldata(
   const pool = pools.find(
     item => item.address.toLowerCase() === poolAddress.toLowerCase(),
   );
+
   return amounts.map(amount => ({
     target: exchangeAddress,
     callData: readerIface.encodeFunctionData(funcName, [
       poolAddress,
       pool!.token0.toLowerCase() === srcToken.toLowerCase() ? true : false,
       amount,
-      0,
+      funcName == 'estimateSwapIn' ? 0 : 2n * amount,
     ]),
   }));
 }
@@ -70,7 +71,7 @@ async function checkOnChainPricing(
   dexHelper: DummyDexHelper,
   srcToken: string,
 ) {
-  const resolverAddress = '0x45f4ad57e300da55c33dea579a40fcee000d7b94';
+  const resolverAddress = '0xE8a07a32489BD9d5a00f01A55749Cf5cB854Fd13';
 
   const readerIface = new Interface(ResolverABI);
 
@@ -109,16 +110,7 @@ async function checkOnChainPricing(
     decodeReaderResult(readerResult, readerIface, funcName),
   );
 
-  expect(
-    prices.every((price, index) => {
-      const expectedPrice = expectedPrices[index];
-      if (expectedPrice === 0n) {
-        return price === 0n;
-      }
-      const percentDiff = ((price - expectedPrice) * 100n) / expectedPrice;
-      return percentDiff <= 0.01 && percentDiff >= -0.01;
-    }),
-  ).toBe(true);
+  expect(prices).toEqual(expectedPrices);
 }
 
 async function testPricingOnNetwork(
@@ -205,7 +197,7 @@ describe('FluidDex', function () {
       const tokenASymbol = 'wstETH';
       const tokenBSymbol = 'ETH';
 
-      const amountsForSwap = [
+      const amountsForSell = [
         0n,
         1n * BI_POWS[18],
         2n * BI_POWS[18],
@@ -228,27 +220,12 @@ describe('FluidDex', function () {
           tokenASymbol,
           tokenBSymbol,
           SwapSide.SELL,
-          amountsForSwap,
+          amountsForSell,
           'estimateSwapIn',
           dexHelper,
         );
       });
 
-      it('wstETH -> ETH, getPoolIdentifiers and getPricesVolume BUY', async function () {
-        await testPricingOnNetwork(
-          fluidDex,
-          network,
-          dexKey,
-          blockNumber,
-          tokenASymbol,
-          tokenBSymbol,
-          SwapSide.BUY,
-          amountsForSwap,
-          'estimateSwapOut',
-          dexHelper,
-        );
-      });
-
       it('ETH -> wstETH, getPoolIdentifiers and getPricesVolume SELL', async function () {
         await testPricingOnNetwork(
           fluidDex,
@@ -258,33 +235,18 @@ describe('FluidDex', function () {
           tokenBSymbol,
           tokenASymbol,
           SwapSide.SELL,
-          amountsForSwap,
+          amountsForSell,
           'estimateSwapIn',
           dexHelper,
         );
       });
-
-      it('ETH -> wstETH, getPoolIdentifiers and getPricesVolume BUY', async function () {
-        await testPricingOnNetwork(
-          fluidDex,
-          network,
-          dexKey,
-          blockNumber,
-          tokenBSymbol,
-          tokenASymbol,
-          SwapSide.BUY,
-          amountsForSwap,
-          'estimateSwapOut',
-          dexHelper,
-        );
-      });
     });
 
     describe('USDC -> USDT', () => {
       const tokenASymbol = 'USDC';
       const tokenBSymbol = 'USDT';
 
-      const amountsForSwap = [
+      const amountsForSell = [
         0n,
         10n * BI_POWS[6],
         20n * BI_POWS[6],
@@ -296,7 +258,7 @@ describe('FluidDex', function () {
         80n * BI_POWS[6],
         90n * BI_POWS[6],
         100n * BI_POWS[6],
-        1000n * BI_POWS[6],
+        1000000n * BI_POWS[6],
       ];
 
       it('USDC -> USDT getPoolIdentifiers and getPricesVolume SELL', async function () {
@@ -308,27 +270,12 @@ describe('FluidDex', function () {
           tokenASymbol,
           tokenBSymbol,
           SwapSide.SELL,
-          amountsForSwap,
+          amountsForSell,
           'estimateSwapIn',
           dexHelper,
         );
       });
 
-      it('USDC -> USDT getPoolIdentifiers and getPricesVolume BUY', async function () {
-        await testPricingOnNetwork(
-          fluidDex,
-          network,
-          dexKey,
-          blockNumber,
-          tokenASymbol,
-          tokenBSymbol,
-          SwapSide.BUY,
-          amountsForSwap,
-          'estimateSwapOut',
-          dexHelper,
-        );
-      });
-
       it('USDT -> USDC getPoolIdentifiers and getPricesVolume SELL', async function () {
         await testPricingOnNetwork(
           fluidDex,
@@ -338,26 +285,11 @@ describe('FluidDex', function () {
           tokenBSymbol,
           tokenASymbol,
           SwapSide.SELL,
-          amountsForSwap,
+          amountsForSell,
           'estimateSwapIn',
           dexHelper,
         );
       });
-
-      it('USDT -> USDC getPoolIdentifiers and getPricesVolume BUY', async function () {
-        await testPricingOnNetwork(
-          fluidDex,
-          network,
-          dexKey,
-          blockNumber,
-          tokenBSymbol,
-          tokenASymbol,
-          SwapSide.BUY,
-          amountsForSwap,
-          'estimateSwapOut',
-          dexHelper,
-        );
-      });
     });
   });
 });

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

@@ -140,7 +140,6 @@ export class FluidDexLiquidityProxy extends StatefulEventSubscriber<FluidDexLiqu
         feeHex,
         collateralReservesHex,
         debtReservesHex,
-        dexLimitsHex,
       ] = poolReserve;
 
       const fee = Number(feeHex.toString());
@@ -161,37 +160,6 @@ export class FluidDexLiquidityProxy extends StatefulEventSubscriber<FluidDexLiqu
         token1ImaginaryReserves: bigIntify(debtReservesHex[5]),
       };
 
-      const withdrawableToken0 = {
-        available: bigIntify(dexLimitsHex[0][0]),
-        expandsTo: bigIntify(dexLimitsHex[0][1]),
-        expandsDuration: bigIntify(dexLimitsHex[0][2]),
-      };
-
-      const withdrawableToken1 = {
-        available: bigIntify(dexLimitsHex[1][0]),
-        expandsTo: bigIntify(dexLimitsHex[1][1]),
-        expandsDuration: bigIntify(dexLimitsHex[1][2]),
-      };
-
-      const borrowableToken0 = {
-        available: bigIntify(dexLimitsHex[2][0]),
-        expandsTo: bigIntify(dexLimitsHex[2][1]),
-        expandsDuration: bigIntify(dexLimitsHex[2][2]),
-      };
-
-      const borrowableToken1 = {
-        available: bigIntify(dexLimitsHex[3][0]),
-        expandsTo: bigIntify(dexLimitsHex[3][1]),
-        expandsDuration: bigIntify(dexLimitsHex[3][2]),
-      };
-
-      const dexLimits = {
-        withdrawableToken0,
-        withdrawableToken1,
-        borrowableToken0,
-        borrowableToken1,
-      };
-
       return {
         pool,
         token0,
@@ -199,7 +167,6 @@ export class FluidDexLiquidityProxy extends StatefulEventSubscriber<FluidDexLiqu
         fee,
         collateralReserves,
         debtReserves,
-        dexLimits,
       };
     });