@paraswap/dex-lib 3.11.5-cables.0 → 3.11.5-fluid-dex-changes.0

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

@@ -41,7 +41,6 @@ function testForNetwork(
         // ContractMethod.multiSwap,
         // ContractMethod.megaSwap,
         ContractMethod.swapExactAmountIn,
-        ContractMethod.swapExactAmountInOnBalancerV2,
       ],
     ],
     [
@@ -51,7 +50,6 @@ function testForNetwork(
         // ContractMethod.buy,
         // DirectMethodsV6.directBuy,
         ContractMethod.swapExactAmountOut,
-        ContractMethod.swapExactAmountOutOnBalancerV2,
       ],
     ],
   ]);
@@ -130,82 +128,6 @@ 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,7 +266,6 @@ export class BalancerV2EventPool extends StatefulEventSubscriber<PoolStateMap> {
   buySupportedPoolTypes: Set<BalancerPoolTypes> = new Set([
     BalancerPoolTypes.Weighted,
     BalancerPoolTypes.GyroE,
-    BalancerPoolTypes.ComposableStable,
   ]);
 
   eventSupportedPoolTypes: BalancerPoolTypes[] = [
@@ -869,7 +868,6 @@ 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/bebop/bebop.ts

@@ -723,7 +723,7 @@ export class Bebop extends SimpleExchange implements IDex<BebopData> {
         }
       }
 
-      if (side === SwapSide.SELL) {
+      if (side == SwapSide.SELL) {
         const requiredAmount = BigInt(optimalSwapExchange.destAmount);
         const quoteAmount = BigInt(
           response.buyTokens[utils.getAddress(destToken.address)].amount,

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

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

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

@@ -3,7 +3,6 @@ import dotenv from 'dotenv';
 dotenv.config();
 
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
-
 import { testE2E } from '../../../tests/utils-e2e';
 import {
   Tokens,
@@ -12,6 +11,9 @@ 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
@@ -70,6 +72,7 @@ function testForNetwork(
 
   const sideToContractMethods = new Map([
     [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
   ]);
 
   describe(`${network}`, () => {
@@ -137,8 +140,8 @@ describe('FluidDex E2E', () => {
       const tokenASymbol: string = 'USDC';
       const tokenBSymbol: string = 'USDT';
 
-      const tokenAAmount: string = '1000000';
-      const tokenBAmount: string = '100000000';
+      const tokenAAmount: string = '10000';
+      const tokenBAmount: string = '1000000';
 
       testForNetwork(
         network,
@@ -151,3 +154,148 @@ 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,9 +38,7 @@ describe('FluidDex EventPool Mainnet', function () {
     const eventsToTest: Record<Address, EventMappings> = {
       '0x52aa899454998be5b000ad077a46bbe360f4e497': {
         LogOperate: [
-          21091850, 21091882, 21091897, 21091915, 21092008, 21092022, 21092039,
-          21092142, 21092176, 21092187, 21092230, 21092286, 21092289, 21092295,
-          21092319, 21092352, 21092360, 21092368, 21092378, 21092383,
+          21190399, 21190405, 21190420, 21190452, 21190454, 21190465, 21190506,
         ],
       },
     };
@@ -86,7 +84,7 @@ describe('FluidDex EventPool Mainnet', function () {
 
     const eventsToTest: Record<Address, EventMappings> = {
       '0x91716C4EDA1Fb55e84Bf8b4c7085f84285c19085': {
-        LogDexDeployed: [21105297, 21105362, 21105366, 21105370],
+        LogDexDeployed: [21199929],
       },
     };
 

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

@@ -39,14 +39,13 @@ 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,
-      funcName == 'estimateSwapIn' ? 0 : 2n * amount,
+      0,
     ]),
   }));
 }
@@ -71,7 +70,7 @@ async function checkOnChainPricing(
   dexHelper: DummyDexHelper,
   srcToken: string,
 ) {
-  const resolverAddress = '0xE8a07a32489BD9d5a00f01A55749Cf5cB854Fd13';
+  const resolverAddress = '0x45f4ad57e300da55c33dea579a40fcee000d7b94';
 
   const readerIface = new Interface(ResolverABI);
 
@@ -110,7 +109,16 @@ async function checkOnChainPricing(
     decodeReaderResult(readerResult, readerIface, funcName),
   );
 
-  expect(prices).toEqual(expectedPrices);
+  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);
 }
 
 async function testPricingOnNetwork(
@@ -197,7 +205,7 @@ describe('FluidDex', function () {
       const tokenASymbol = 'wstETH';
       const tokenBSymbol = 'ETH';
 
-      const amountsForSell = [
+      const amountsForSwap = [
         0n,
         1n * BI_POWS[18],
         2n * BI_POWS[18],
@@ -220,12 +228,27 @@ describe('FluidDex', function () {
           tokenASymbol,
           tokenBSymbol,
           SwapSide.SELL,
-          amountsForSell,
+          amountsForSwap,
           '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,
@@ -235,18 +258,33 @@ describe('FluidDex', function () {
           tokenBSymbol,
           tokenASymbol,
           SwapSide.SELL,
-          amountsForSell,
+          amountsForSwap,
           '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 amountsForSell = [
+      const amountsForSwap = [
         0n,
         10n * BI_POWS[6],
         20n * BI_POWS[6],
@@ -258,7 +296,7 @@ describe('FluidDex', function () {
         80n * BI_POWS[6],
         90n * BI_POWS[6],
         100n * BI_POWS[6],
-        1000000n * BI_POWS[6],
+        1000n * BI_POWS[6],
       ];
 
       it('USDC -> USDT getPoolIdentifiers and getPricesVolume SELL', async function () {
@@ -270,12 +308,27 @@ describe('FluidDex', function () {
           tokenASymbol,
           tokenBSymbol,
           SwapSide.SELL,
-          amountsForSell,
+          amountsForSwap,
           '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,
@@ -285,11 +338,26 @@ describe('FluidDex', function () {
           tokenBSymbol,
           tokenASymbol,
           SwapSide.SELL,
-          amountsForSell,
+          amountsForSwap,
           '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,6 +140,7 @@ export class FluidDexLiquidityProxy extends StatefulEventSubscriber<FluidDexLiqu
         feeHex,
         collateralReservesHex,
         debtReservesHex,
+        dexLimitsHex,
       ] = poolReserve;
 
       const fee = Number(feeHex.toString());
@@ -160,6 +161,37 @@ 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,
@@ -167,6 +199,7 @@ export class FluidDexLiquidityProxy extends StatefulEventSubscriber<FluidDexLiqu
         fee,
         collateralReserves,
         debtReserves,
+        dexLimits,
       };
     });