@paraswap/dex-lib 4.1.6 → 4.1.7-mwrappedm.0

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

@@ -4,13 +4,46 @@ dotenv.config();
 
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import { testE2E } from '../../../tests/utils-e2e';
-import { Tokens, Holders } from '../../../tests/constants-e2e';
+import {
+  Tokens,
+  Holders,
+  NativeTokenSymbols,
+} 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
+  ======
+
+  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
+  tokenB with any two highly liquid tokens on FluidDex for the tests
+  to work. If the tokens that you would like to use are not defined in
+  Tokens or Holders map, you can update the './tests/constants-e2e'
+
+  Other than the standard cases that are already added by the template
+  it is highly recommended to add test cases which could be specific
+  to testing FluidDex (Eg. Tests based on poolType, special tokens,
+  etc).
+
+  You can run this individual test script by running:
+  `npx jest src/dex/<dex-name>/<dex-name>-e2e.test.ts`
+
+  e2e tests use the Tenderly fork api. Please add the following to your
+  .env file:
+  TENDERLY_TOKEN=Find this under Account>Settings>Authorization.
+  TENDERLY_ACCOUNT_ID=Your Tenderly account name.
+  TENDERLY_PROJECT=Name of a Tenderly project you have created in your
+  dashboard.
+
+  (This comment should be removed from the final implementation)
+*/
+
 function testForNetwork(
   network: Network,
   dexKey: string,
@@ -23,14 +56,9 @@ function testForNetwork(
     generateConfig(network).privateHttpProvider,
     network,
   );
-
   const tokens = Tokens[network];
   const holders = Holders[network];
 
-  // Create FluidDex instance to check reserves
-  const dexHelper = new DummyDexHelper(network);
-  const fluidDex = new FluidDex(network, dexKey, dexHelper);
-
   const sideToContractMethods = new Map([
     [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
     [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
@@ -41,11 +69,11 @@ function testForNetwork(
       describe(`${side}`, () => {
         contractMethods.forEach((contractMethod: string) => {
           describe(`${contractMethod}`, () => {
-            it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
+            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
               await testE2E(
-                tokens[tokenBSymbol],
                 tokens[tokenASymbol],
-                holders[tokenBSymbol],
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
                 tokenBAmount,
                 side,
                 dexKey,
@@ -54,13 +82,12 @@ function testForNetwork(
                 provider,
               );
             });
-
-            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+            it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
               await testE2E(
-                tokens[tokenASymbol],
                 tokens[tokenBSymbol],
-                holders[tokenASymbol],
-                tokenAAmount,
+                tokens[tokenASymbol],
+                holders[tokenBSymbol],
+                tokenBAmount,
                 side,
                 dexKey,
                 contractMethod as ContractMethod,
@@ -81,11 +108,30 @@ describe('FluidDex E2E', () => {
   describe('Mainnet', () => {
     const network = Network.MAINNET;
 
-    describe('limit:FLUID -> ETH', () => {
-      const tokenASymbol: string = 'FLUID';
-      const tokenBSymbol: string = 'ETH';
-      const tokenAAmount: string = '16009704732281037900';
-      const tokenBAmount: string = '7992306873300550562400';
+    // 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';
+
+      const tokenAAmount: string = '100000000000000';
+      const tokenBAmount: string = '100000000000000';
 
       testForNetwork(
         network,
@@ -102,7 +148,7 @@ describe('FluidDex E2E', () => {
       const tokenBSymbol: string = 'ETH';
 
       const tokenAAmount: string = '100000000000000';
-      const tokenBAmount: string = '3500000000000000000';
+      const tokenBAmount: string = '100000000000000';
 
       testForNetwork(
         network,
@@ -191,9 +237,6 @@ function NewDebtReservesOne(): DebtReserves {
   };
 }
 
-const centerPriceTight: bigint = 3401944443797854601871360n;
-const centerPriceWide: bigint = 1190081051944310368000000000n;
-
 const limitsTight: DexLimits = {
   withdrawableToken0: {
     available: 456740438880263n,
@@ -240,6 +283,10 @@ const limitsWide: DexLimits = {
   },
 };
 
+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);
@@ -248,18 +295,21 @@ describe('TestPoolSimulator_SwapInLimits', () => {
 
   it('when limits hit', () => {
     let outAmt;
-    outAmt = fluidDex.swapInAdjusted(
-      true,
-      BigInt(1e15),
-      NewColReservesOne(),
-      NewDebtReservesOne(),
-      100n,
-      18,
-      limitsTight,
-      BigInt(centerPriceTight),
-      Math.floor(Date.now() / 1000) - 10,
-    );
-    expect(outAmt).toEqual(0n);
+    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', () => {
@@ -271,41 +321,47 @@ describe('TestPoolSimulator_SwapInLimits', () => {
       100n,
       18,
       limitsTight,
-      BigInt(centerPriceTight),
       Math.floor(Date.now() / 1000) - 6000,
     );
-    expect(outAmt?.toString()).toEqual('998163044346107');
+    console.log('outAmt: ', outAmt);
+    expect(outAmt?.toString()).toEqual('998262697204710');
   });
 
   it('when price diff hit', () => {
     let outAmt;
-    outAmt = fluidDex.swapInAdjusted(
-      true,
-      BigInt(3e16),
-      NewColReservesOne(),
-      NewDebtReservesOne(),
-      100n,
-      18,
-      limitsWide,
-      BigInt(centerPriceWide),
-      Math.floor(Date.now() / 1000) - 10,
-    );
-    expect(outAmt).toEqual(0n);
+    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;
-    outAmt = fluidDex.swapInAdjusted(
-      true,
-      BigInt(5e16),
-      NewColReservesOne(),
-      NewDebtReservesOne(),
-      100n,
-      18,
-      limitsWide,
-      BigInt(centerPriceWide),
-      Math.floor(Date.now() / 1000) - 10,
-    );
-    expect(outAmt).toEqual(0n);
+    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-liquidity-proxy.ts

@@ -137,14 +137,12 @@ export class FluidDexLiquidityProxy extends StatefulEventSubscriber<FluidDexLiqu
         token0,
         token1,
         feeHex,
-        centerPriceHex,
         collateralReservesHex,
         debtReservesHex,
         dexLimitsHex,
       ] = poolReserve;
 
       const fee = Number(feeHex.toString());
-      const centerPrice = Number(centerPriceHex.toString());
 
       const collateralReserves = {
         token0RealReserves: bigIntify(collateralReservesHex[0]),
@@ -198,7 +196,6 @@ export class FluidDexLiquidityProxy extends StatefulEventSubscriber<FluidDexLiqu
         token0,
         token1,
         fee,
-        centerPrice,
         collateralReserves,
         debtReserves,
         dexLimits,

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

@@ -48,6 +48,11 @@ 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;
@@ -110,7 +115,9 @@ 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);
+    this.pools = (await this.fetchFluidDexPools(blockNumber)).filter(
+      pool => !this.restrictedIds.includes(pool.id),
+    );
     this.eventPools = await Promise.all(
       this.pools.map(async pool => {
         const eventPool = new FluidDexEventPool(
@@ -133,7 +140,9 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
   }
 
   protected onPoolCreatedUpdatePools(poolsFromFactory: readonly Pool[]) {
-    this.pools = this.generateFluidDexPoolsFromPoolsFactory(poolsFromFactory);
+    this.pools = this.generateFluidDexPoolsFromPoolsFactory(
+      poolsFromFactory,
+    ).filter(pool => !this.restrictedIds.includes(pool.id));
     this.logger.info(`${this.dexKey}: pools list was updated ...`);
   }
 
@@ -173,6 +182,9 @@ 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) ||
@@ -248,7 +260,6 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
                 destToken.decimals,
                 BigInt(currentPoolReserves.fee),
                 currentPoolReserves.dexLimits,
-                BigInt(currentPoolReserves.centerPrice),
                 Math.floor(Date.now() / 1000),
               );
             } else {
@@ -261,7 +272,6 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
                 destToken.decimals,
                 BigInt(currentPoolReserves.fee),
                 currentPoolReserves.dexLimits,
-                BigInt(currentPoolReserves.centerPrice),
                 Math.floor(Date.now() / 1000),
               );
             }
@@ -370,19 +380,9 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
       }
     } else {
       if (pool!.token0.toLowerCase() !== srcToken.toLowerCase()) {
-        args = [
-          false,
-          (BigInt(destAmount) * 1000001n) / 1000000n, // 0.0001% increase target out amount when calling Fluid Dex as it is not 100% exact. Guarantees meeting reaching exact out amount condition
-          BigInt(srcAmount),
-          recipient,
-        ];
+        args = [false, BigInt(destAmount), BigInt(srcAmount), recipient];
       } else {
-        args = [
-          true,
-          (BigInt(destAmount) * 1000001n) / 1000000n, // 0.0001% increase target out amount when calling Fluid Dex as it is not 100% exact. Guarantees meeting reaching exact out amount condition
-          BigInt(srcAmount),
-          recipient,
-        ];
+        args = [true, BigInt(destAmount), BigInt(srcAmount), recipient];
       }
     }
     const swapData = this.fluidDexPoolIface.encodeFunctionData(method, args);
@@ -415,7 +415,6 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
     outDecimals: number,
     fee: bigint,
     currentLimits: DexLimits,
-    centerPrice: bigint,
     syncTime: number,
   ): bigint {
     if (amountIn === 0n) {
@@ -439,7 +438,6 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
       fee,
       outDecimals,
       currentLimits,
-      centerPrice,
       syncTime,
     );
     return (amountOut * BigInt(10 ** outDecimals)) / BigInt(10 ** 12);
@@ -461,7 +459,6 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
     fee: bigint,
     outDecimals: number,
     currentLimits: DexLimits,
-    centerPrice: bigint,
     syncTime: number,
   ): bigint {
     const {
@@ -606,40 +603,6 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
       return 0n;
     }
 
-    if (amountInCollateral > 0) {
-      let reservesRatioValid = swap0To1
-        ? this.verifyToken1Reserves(
-            colReserveIn + amountInCollateral,
-            colReserveOut - amountOutCollateral,
-            centerPrice,
-          )
-        : this.verifyToken0Reserves(
-            colReserveOut - amountOutCollateral,
-            colReserveIn + amountInCollateral,
-            centerPrice,
-          );
-      if (!reservesRatioValid) {
-        return 0n;
-      }
-    }
-
-    if (amountInDebt > 0) {
-      let reservesRatioValid = swap0To1
-        ? this.verifyToken1Reserves(
-            debtReserveIn + amountInDebt,
-            debtReserveOut - amountOutDebt,
-            centerPrice,
-          )
-        : this.verifyToken0Reserves(
-            debtReserveOut - amountOutDebt,
-            debtReserveIn + amountInDebt,
-            centerPrice,
-          );
-      if (!reservesRatioValid) {
-        return 0n;
-      }
-    }
-
     // For price calculations, we'll use a precision factor for bigint division
     const PRECISION = 1000000000000000000000000000n; // 1e27
 
@@ -679,6 +642,40 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
       return 0n;
     }
 
+    if (amountInCollateral > 0) {
+      let reservesRatioValid = swap0To1
+        ? this.verifyToken1Reserves(
+            colReserveIn + amountInCollateral,
+            colReserveOut - amountOutCollateral,
+            oldPrice,
+          )
+        : this.verifyToken0Reserves(
+            colReserveOut - amountOutCollateral,
+            colReserveIn + amountInCollateral,
+            oldPrice,
+          );
+      if (!reservesRatioValid) {
+        return 0n;
+      }
+    }
+
+    if (amountInDebt > 0) {
+      let reservesRatioValid = swap0To1
+        ? this.verifyToken1Reserves(
+            debtReserveIn + amountInDebt,
+            debtReserveOut - amountOutDebt,
+            oldPrice,
+          )
+        : this.verifyToken0Reserves(
+            debtReserveOut - amountOutDebt,
+            debtReserveIn + amountInDebt,
+            oldPrice,
+          );
+      if (!reservesRatioValid) {
+        return 0n;
+      }
+    }
+
     const totalAmountOut = amountOutCollateral + amountOutDebt;
 
     return totalAmountOut;
@@ -882,7 +879,6 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
     outDecimals: number,
     fee: bigint,
     currentLimits: DexLimits,
-    centerPrice: bigint,
     syncTime: number,
   ): bigint {
     const amountOutAdjusted =
@@ -896,11 +892,14 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
       fee,
       outDecimals,
       currentLimits,
-      centerPrice,
       syncTime,
     );
 
+    if (amountIn === 2n ** 256n - 1n) {
+      return amountIn;
+    }
     const ans = (amountIn * BigInt(10 ** inDecimals)) / BigInt(10 ** 12);
+
     return ans;
   }
 
@@ -920,7 +919,6 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
     fee: bigint,
     outDecimals: number,
     currentLimits: DexLimits,
-    centerPrice: bigint,
     syncTime: number,
   ): bigint {
     if (amountOut === 0n) {
@@ -1038,10 +1036,10 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
       );
       amountInDebt = this.applyFeeForBuy(amountInDebt, fee);
       if (amountOut > debtReserveOut) {
-        return 0n;
+        return 2n ** 256n - 1n;
       }
       if (amountOut > borrowable) {
-        return 0n;
+        return 2n ** 256n - 1n;
       }
     } else if (a >= amountOut) {
       // Entire trade routes through collateral pool
@@ -1053,10 +1051,10 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
       );
       amountInCollateral = this.applyFeeForBuy(amountInCollateral, fee);
       if (amountOut > colReserveOut) {
-        return 0n;
+        return 2n ** 256n - 1n;
       }
       if (amountOut > withdrawable) {
-        return 0n;
+        return 2n ** 256n - 1n;
       }
     } else {
       // Trade routes through both pools
@@ -1074,43 +1072,10 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
 
       amountInDebt = this.applyFeeForBuy(amountInDebt, fee);
       if (amountOutDebt > debtReserveOut || a > colReserveOut) {
-        return 0n;
+        return 2n ** 256n - 1n;
       }
       if (amountOutDebt > borrowable || a > withdrawable) {
-        return 0n;
-      }
-    }
-
-    if (amountInCollateral > 0) {
-      let reservesRatioValid = swap0to1
-        ? this.verifyToken1Reserves(
-            colReserveIn + amountInCollateral,
-            colReserveOut - amountOutCollateral,
-            centerPrice,
-          )
-        : this.verifyToken0Reserves(
-            colReserveOut - amountOutCollateral,
-            colReserveIn + amountInCollateral,
-            centerPrice,
-          );
-      if (!reservesRatioValid) {
-        return 0n;
-      }
-    }
-    if (amountInDebt > 0) {
-      let reservesRatioValid = swap0to1
-        ? this.verifyToken1Reserves(
-            debtReserveIn + amountInDebt,
-            debtReserveOut - amountOutDebt,
-            centerPrice,
-          )
-        : this.verifyToken0Reserves(
-            debtReserveOut - amountOutDebt,
-            debtReserveIn + amountInDebt,
-            centerPrice,
-          );
-      if (!reservesRatioValid) {
-        return 0n;
+        return 2n ** 256n - 1n;
       }
     }
 
@@ -1147,7 +1112,40 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
       (oldPrice / BigInt(100)) * MAX_PRICE_DIFF
     ) {
       // if price diff is > 5% then swap would revert.
-      return 0n;
+      return 2n ** 256n - 1n;
+    }
+
+    if (amountInCollateral > 0) {
+      let reservesRatioValid = swap0to1
+        ? this.verifyToken1Reserves(
+            colReserveIn + amountInCollateral,
+            colReserveOut - amountOutCollateral,
+            oldPrice,
+          )
+        : this.verifyToken0Reserves(
+            colReserveOut - amountOutCollateral,
+            colReserveIn + amountInCollateral,
+            oldPrice,
+          );
+      if (!reservesRatioValid) {
+        return 0n;
+      }
+    }
+    if (amountInDebt > 0) {
+      let reservesRatioValid = swap0to1
+        ? this.verifyToken1Reserves(
+            debtReserveIn + amountInDebt,
+            debtReserveOut - amountOutDebt,
+            oldPrice,
+          )
+        : this.verifyToken0Reserves(
+            debtReserveOut - amountOutDebt,
+            debtReserveIn + amountInDebt,
+            oldPrice,
+          );
+      if (!reservesRatioValid) {
+        return 0n;
+      }
     }
 
     const totalAmountIn = amountInCollateral + amountInDebt;

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

@@ -6,7 +6,6 @@ export type PoolReserve = {
   token0: string;
   token1: string;
   fee: number;
-  centerPrice: number;
   collateralReserves: CollateralReserves;
   debtReserves: DebtReserves;
   dexLimits: DexLimits;
@@ -17,7 +16,6 @@ export type PoolReserveResponse = [
   string,
   string,
   BigNumber,
-  BigNumber,
   BigNumber[],
   BigNumber[],
   DexLimitResponse,
@@ -70,7 +68,6 @@ export interface PoolWithReserves {
   token0: string;
   token1: string;
   fee: number;
-  centerPrice: number;
   collateralReserves: CollateralReserves;
   debtReserves: DebtReserves;
 }

package/src/dex/index.ts

@@ -102,6 +102,7 @@ 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';
+import { MWrappedM } from './m-token/m-wrapped-m';
 
 const LegacyDexes = [
   CurveV2,
@@ -198,6 +199,7 @@ const Dexes = [
   UsualMWrappedM,
   UsualMUsd0,
   UsualPP,
+  MWrappedM,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<

package/src/dex/m-token/config.ts

@@ -0,0 +1,18 @@
+import { DexConfigMap } from '../../types';
+import { DexParams } from './types';
+import { Network } from '../../constants';
+
+export const Config: DexConfigMap<DexParams> = {
+  MWrappedM: {
+    [Network.MAINNET]: {
+      MToken: {
+        address: '0x866A2BF4E572CbcF37D5071A7a58503Bfb36be1b',
+        decimals: 6,
+      },
+      WrappedM: {
+        address: '0x437cc33344a0B27A429f795ff6B469C72698B291',
+        decimals: 6,
+      },
+    },
+  },
+};