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

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
@@ -66,10 +68,10 @@ function testForNetwork(
   );
   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}`, () => {
@@ -83,7 +85,7 @@ function testForNetwork(
                 tokens[tokenBSymbol],
                 holders[tokenASymbol],
                 tokenBAmount,
-                SwapSide.SELL,
+                side,
                 dexKey,
                 contractMethod as ContractMethod,
                 network,
@@ -96,7 +98,7 @@ function testForNetwork(
                 tokens[tokenASymbol],
                 holders[tokenBSymbol],
                 tokenBAmount,
-                SwapSide.SELL,
+                side,
                 dexKey,
                 contractMethod as ContractMethod,
                 network,
@@ -137,8 +139,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 +153,152 @@ 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(),
+        100n,
+        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(),
+      100n,
+      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(),
+        100n,
+        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(),
+        100n,
+        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

@@ -40,13 +40,19 @@ function getReaderCalldata(
     item => item.address.toLowerCase() === poolAddress.toLowerCase(),
   );
 
+  console.log('amounts: ', amounts);
+  console.log(
+    'pool!.token0.toLowerCase() === srcToken.toLowerCase() ? true : false,: ',
+    pool!.token0.toLowerCase() === srcToken.toLowerCase() ? true : false,
+  );
+
   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 +77,7 @@ async function checkOnChainPricing(
   dexHelper: DummyDexHelper,
   srcToken: string,
 ) {
-  const resolverAddress = '0xE8a07a32489BD9d5a00f01A55749Cf5cB854Fd13';
+  const resolverAddress = '0x45f4ad57e300da55c33dea579a40fcee000d7b94';
 
   const readerIface = new Interface(ResolverABI);
 
@@ -110,7 +116,21 @@ async function checkOnChainPricing(
     decodeReaderResult(readerResult, readerIface, funcName),
   );
 
+  console.log('EXPECTED PRICES: ', expectedPrices);
+  console.log('ACTUAL PRICES: ', prices);
+
   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 +217,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 +240,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 +270,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 +308,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 +320,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 +350,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,
       };
     });