@paraswap/dex-lib 4.0.4 → 4.0.5-fluid-dex-pool-discovery-issue.0

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

@@ -0,0 +1 @@
+export const MIN_SWAP_LIQUIDITY = 10n ** 4n;

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

@@ -118,6 +118,23 @@ describe('FluidDex E2E', () => {
   describe('Mainnet', () => {
     const network = Network.MAINNET;
 
+    describe('ETH -> INST', () => {
+      const tokenASymbol: string = 'ETH';
+      const tokenBSymbol: string = 'INST';
+
+      const tokenAAmount: string = '100000000000000';
+      const tokenBAmount: string = '100000000000000';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+      );
+    });
+
     describe('ETH -> wstETH', () => {
       const tokenASymbol: string = 'wstETH';
       const tokenBSymbol: string = 'ETH';

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

@@ -10,14 +10,16 @@ import { FluidDexLiquidityProxyState } from './types';
 import { FluidDexConfig } from './config';
 import { FluidDexLiquidityProxy } from './fluid-dex-liquidity-proxy';
 import { FluidDexFactory } from './fluid-dex-factory';
+import { FluidDexEventPool } from './fluid-dex-pool';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
 
 jest.setTimeout(50 * 1000);
 
-async function fetchLiquidityProxyState(
-  liquidityProxy: FluidDexLiquidityProxy,
+async function fetchState(
+  statefulEventSubscriber: StatefulEventSubscriber<any>,
   blockNumber: number,
-): Promise<FluidDexLiquidityProxyState> {
-  return liquidityProxy.generateState(blockNumber);
+): Promise<any> {
+  return statefulEventSubscriber.generateState(blockNumber);
 }
 
 // eventName -> blockNumbers
@@ -64,7 +66,7 @@ describe('FluidDex EventPool Mainnet', function () {
                       liquidityProxy,
                       liquidityProxy.addressesSubscribed,
                       (_blockNumber: number) =>
-                        fetchLiquidityProxyState(liquidityProxy, _blockNumber),
+                        fetchState(liquidityProxy, _blockNumber),
                       blockNumber,
                       `${dexKey}_${poolAddress}`,
                       dexHelper.provider,
@@ -126,4 +128,52 @@ describe('FluidDex EventPool Mainnet', function () {
       },
     );
   });
+
+  describe('Pool events', () => {
+    let dexPool: FluidDexEventPool;
+
+    const eventsToTest: Record<Address, EventMappings> = {
+      '0x8710039D5de6840EdE452A85672B32270a709aE2': {
+        LogPauseSwapAndArbitrage: [21337128],
+      },
+      '0x2886a01a0645390872a9eb99dae1283664b0c524': {
+        LogPauseSwapAndArbitrage: [21374547],
+      },
+    };
+
+    Object.entries(eventsToTest).forEach(
+      ([poolAddress, events]: [string, EventMappings]) => {
+        describe(`Events for ${poolAddress}`, () => {
+          beforeEach(() => {
+            dexPool = new FluidDexEventPool(
+              dexKey,
+              poolAddress,
+              network,
+              dexHelper,
+              logger,
+            );
+          });
+          Object.entries(events).forEach(
+            ([eventName, blockNumbers]: [string, number[]]) => {
+              describe(`${eventName}`, () => {
+                blockNumbers.forEach((blockNumber: number) => {
+                  it(`State after ${blockNumber}`, async function () {
+                    await testEventSubscriber(
+                      dexPool,
+                      dexPool.addressesSubscribed,
+                      (_blockNumber: number) =>
+                        fetchState(dexPool, _blockNumber),
+                      blockNumber,
+                      `${dexKey}_${poolAddress}`,
+                      dexHelper.provider,
+                    );
+                  });
+                });
+              });
+            },
+          );
+        });
+      },
+    );
+  });
 });

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

@@ -5,6 +5,7 @@ import { bigIntify, catchParseLogError } from '../../utils';
 import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
 import { IDexHelper } from '../../dex-helper/idex-helper';
 import ResolverABI from '../../abi/fluid-dex/resolver.abi.json';
+import FluidDexPoolABI from '../../abi/fluid-dex/fluid-dex.abi.json';
 import LiquidityABI from '../../abi/fluid-dex/liquidityUserModule.abi.json';
 import {
   CommonAddresses,
@@ -13,7 +14,7 @@ import {
   PoolReserveResponse,
 } from './types';
 import { Address } from '../../types';
-import { Contract } from 'ethers';
+import { Contract, ethers } from 'ethers';
 
 export class FluidDexLiquidityProxy extends StatefulEventSubscriber<FluidDexLiquidityProxyState> {
   handlers: {
@@ -28,7 +29,9 @@ export class FluidDexLiquidityProxy extends StatefulEventSubscriber<FluidDexLiqu
 
   addressesSubscribed: Address[];
 
-  protected liquidityIface = new Interface(LiquidityABI);
+  readonly liquidityIface = new Interface(LiquidityABI);
+
+  readonly poolIface = new Interface(FluidDexPoolABI);
 
   readonly resolverIface = new Interface(ResolverABI);
 
@@ -123,7 +126,6 @@ export class FluidDexLiquidityProxy extends StatefulEventSubscriber<FluidDexLiqu
       });
 
     const convertedResult = this.convertToFluidDexPoolState(rawResult);
-
     this.logger.info(`${this.parentName}: ${this.name}: generating state...`);
 
     return convertedResult;

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

@@ -0,0 +1,139 @@
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import { DeepReadonly } from 'ts-essentials';
+import { Address, Log, Logger } from '../../types';
+import { IDexHelper } from '../../dex-helper';
+import { Interface } from '@ethersproject/abi';
+import FluidDexPoolABI from '../../abi/fluid-dex/fluid-dex.abi.json';
+import { catchParseLogError } from '../../utils';
+import { ethers } from 'ethers';
+import { uint256ToBigInt } from '../../lib/decoders';
+import { DecodedStateMultiCallResultWithRelativeBitmaps } from '../uniswap-v3/types';
+
+const {
+  utils: { hexlify, hexZeroPad },
+} = ethers;
+
+type PoolState = {
+  isSwapAndArbitragePaused: boolean;
+};
+
+export class FluidDexEventPool extends StatefulEventSubscriber<PoolState> {
+  handlers: {
+    [event: string]: (
+      event: any,
+      state: DeepReadonly<PoolState>,
+      log: Readonly<Log>,
+    ) => DeepReadonly<PoolState> | null;
+  } = {};
+
+  logDecoder: (log: Log) => any;
+  addressesSubscribed: Address[];
+  protected poolIface = new Interface(FluidDexPoolABI);
+
+  constructor(
+    readonly parentName: string,
+    readonly poolAddress: string,
+    protected network: number,
+    protected dexHelper: IDexHelper,
+    logger: Logger,
+  ) {
+    super(parentName, 'pool', dexHelper, logger);
+
+    this.logDecoder = (log: Log) => this.poolIface.parseLog(log);
+    this.addressesSubscribed = [poolAddress];
+
+    // Add handlers
+    this.handlers['LogPauseSwapAndArbitrage'] =
+      this.handleLogPauseSwapAndArbitrage.bind(this);
+    this.handlers['LogUnpauseSwapAndArbitrage'] =
+      this.handleLogUnpauseSwapAndArbitrage.bind(this);
+  }
+
+  /**
+   * The function is called every time any of the subscribed
+   * addresses release log. The function accepts the current
+   * state, updates the state according to the log, and returns
+   * the updated state.
+   * @param state - Current state of event subscriber
+   * @param log - Log released by one of the subscribed addresses
+   * @returns Updates state of the event subscriber after the log
+   */
+  async processLog(
+    state: DeepReadonly<PoolState>,
+    log: Readonly<Log>,
+  ): Promise<DeepReadonly<PoolState> | null> {
+    try {
+      let event;
+      try {
+        event = this.logDecoder(log);
+      } catch (e) {
+        return null;
+      }
+
+      if (event.name in this.handlers) {
+        return this.handlers[event.name](event, state, log);
+      }
+    } catch (e) {
+      catchParseLogError(e, this.logger);
+    }
+
+    return null;
+  }
+
+  handleLogPauseSwapAndArbitrage(): PoolState {
+    return { isSwapAndArbitragePaused: true };
+  }
+
+  handleLogUnpauseSwapAndArbitrage(): PoolState {
+    return { isSwapAndArbitragePaused: false };
+  }
+
+  async getStateOrGenerate(
+    blockNumber: number,
+    readonly: boolean = false,
+  ): Promise<DeepReadonly<PoolState>> {
+    let state = this.getState(blockNumber);
+    if (!state) {
+      state = await this.generateState(blockNumber);
+      if (!readonly) this.setState(state, blockNumber);
+    }
+    return state;
+  }
+
+  /**
+   * The function generates state using on-chain calls. This
+   * function is called to regenerate state if the event based
+   * system fails to fetch events and the local state is no
+   * more correct.
+   * @param blockNumber - Blocknumber for which the state should
+   * should be generated
+   * @returns state of the event subscriber at blocknumber
+   */
+  async generateState(blockNumber: number): Promise<DeepReadonly<PoolState>> {
+    const multicallData = [
+      {
+        target: this.addressesSubscribed[0],
+        callData: this.poolIface.encodeFunctionData('readFromStorage', [
+          hexZeroPad(hexlify(1), 32),
+        ]),
+        decodeFunction: uint256ToBigInt,
+      },
+    ];
+
+    const storageResults = await this.dexHelper.multiWrapper.tryAggregate<
+      bigint | DecodedStateMultiCallResultWithRelativeBitmaps
+    >(
+      false,
+      multicallData,
+      blockNumber,
+      this.dexHelper.multiWrapper.defaultBatchSize,
+      false,
+    );
+
+    const isSwapAndArbitragePaused =
+      BigInt(storageResults[0].returnData.toString()) >> BigInt(255) ===
+      BigInt(1);
+
+    return { isSwapAndArbitragePaused };
+  }
+}

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

@@ -34,6 +34,8 @@ import { generalDecoder } from '../../lib/decoders';
 import { BigNumber } from 'ethers';
 import { sqrt } from './utils';
 import { FluidDexLiquidityProxy } from './fluid-dex-liquidity-proxy';
+import { FluidDexEventPool } from './fluid-dex-pool';
+import { MIN_SWAP_LIQUIDITY } from './constants';
 
 export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
   readonly hasConstantPriceLargeAmounts = false;
@@ -46,14 +48,14 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
 
   pools: FluidDexPool[] = [];
 
+  eventPools: FluidDexEventPool[] = [];
+
   readonly factory: FluidDexFactory;
 
   readonly liquidityProxy: FluidDexLiquidityProxy;
 
   readonly fluidDexPoolIface: Interface;
 
-  FEE_100_PERCENT = BigInt(1000000);
-
   constructor(
     readonly network: Network,
     readonly dexKey: string,
@@ -110,6 +112,20 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
     await this.factory.initialize(blockNumber);
     this.pools = await this.fetchFluidDexPools(blockNumber);
 
+    this.eventPools = await Promise.all(
+      this.pools.map(async pool => {
+        const eventPool = new FluidDexEventPool(
+          this.dexKey,
+          pool.address,
+          this.network,
+          this.dexHelper,
+          this.logger,
+        );
+        await eventPool.initialize(blockNumber);
+        return eventPool;
+      }),
+    );
+
     await this.liquidityProxy.initialize(blockNumber);
   }
 
@@ -147,29 +163,24 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
     side: SwapSide,
     blockNumber: number,
   ): Promise<string[]> {
-    const pool = this.getPoolByTokenPair(srcToken.address, destToken.address);
-    return pool ? [pool.id] : [];
+    const pools = this.getPoolsByTokenPair(srcToken.address, destToken.address);
+    return pools.map(pool => pool.id);
   }
 
-  getPoolByTokenPair(
-    srcToken: Address,
-    destToken: Address,
-  ): FluidDexPool | null {
+  getPoolsByTokenPair(srcToken: Address, destToken: Address): FluidDexPool[] {
     const srcAddress = srcToken.toLowerCase();
     const destAddress = destToken.toLowerCase();
 
     // A pair must have 2 different tokens.
-    if (srcAddress === destAddress) return null;
+    if (srcAddress === destAddress) return [];
 
-    for (const pool of this.pools) {
-      if (
+    const pools = this.pools.filter(
+      pool =>
         (srcAddress === pool.token0 && destAddress === pool.token1) ||
-        (srcAddress === pool.token1 && destAddress === pool.token0)
-      ) {
-        return pool;
-      }
-    }
-    return null;
+        (srcAddress === pool.token1 && destAddress === pool.token0),
+    );
+
+    return pools;
   }
 
   // Returns pool prices for amounts.
@@ -187,61 +198,99 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
     try {
       if (srcToken.address.toLowerCase() === destToken.address.toLowerCase())
         return null;
-      // Get the pool to use.
-      const pool = this.getPoolByTokenPair(srcToken.address, destToken.address);
-      if (!pool) return null;
+
+      // Get the pools to use.
+      const pools = this.getPoolsByTokenPair(
+        srcToken.address,
+        destToken.address,
+      );
+
+      if (!pools.length) return null;
+      const poolIds = pools.map(pool => pool.id);
       // Make sure the pool meets the optional limitPools filter.
-      if (limitPools && !limitPools.includes(pool.id)) return null;
+      if (
+        limitPools &&
+        !limitPools.every(limitPool => poolIds.includes(limitPool))
+      )
+        return null;
 
       const liquidityProxyState = await this.liquidityProxy.getStateOrGenerate(
         blockNumber,
       );
 
-      const currentPoolReserves = liquidityProxyState.poolsReserves.find(
-        poolReserve =>
-          poolReserve.pool.toLowerCase() === pool.address.toLowerCase(),
-      );
-      if (!currentPoolReserves) {
-        return null;
-      }
-      const prices = amounts.map(amount => {
-        if (side === SwapSide.SELL) {
-          return this.swapIn(
-            srcToken.address.toLowerCase() === pool.token0.toLowerCase(),
-            amount,
-            currentPoolReserves.collateralReserves,
-            currentPoolReserves.debtReserves,
-            srcToken.decimals,
-            destToken.decimals,
-            BigInt(currentPoolReserves.fee),
-            currentPoolReserves.dexLimits,
-            Math.floor(Date.now() / 1000),
+      const poolsPrices = await Promise.all(
+        pools.map(async pool => {
+          const currentPoolReserves = liquidityProxyState.poolsReserves.find(
+            poolReserve =>
+              poolReserve.pool.toLowerCase() === pool.address.toLowerCase(),
           );
-        } else {
-          return this.swapOut(
-            srcToken.address.toLowerCase() === pool.token0.toLowerCase(),
-            amount,
-            currentPoolReserves.collateralReserves,
-            currentPoolReserves.debtReserves,
-            srcToken.decimals,
-            destToken.decimals,
-            BigInt(currentPoolReserves.fee),
-            currentPoolReserves.dexLimits,
-            Math.floor(Date.now() / 1000),
+
+          const eventPool = this.eventPools.find(
+            eventPool =>
+              eventPool.poolAddress.toLowerCase() ===
+              pool.address.toLowerCase(),
           );
-        }
-      });
-      return [
-        {
-          prices: prices,
-          unit: getBigIntPow(destToken.decimals),
-          data: {},
-          exchange: this.dexKey,
-          poolIdentifier: pool.id,
-          gasCost: FLUID_DEX_GAS_COST,
-          poolAddresses: [pool.address],
-        },
-      ];
+
+          if (!eventPool) {
+            this.logger.warn(
+              `${this.dexKey}-${this.network}: Event pool ${pool.address} was not found...`,
+            );
+            return null;
+          }
+
+          const state = await eventPool.getStateOrGenerate(blockNumber);
+
+          if (!currentPoolReserves || state.isSwapAndArbitragePaused === true) {
+            return null;
+          }
+
+          const prices = amounts.map(amount => {
+            if (side === SwapSide.SELL) {
+              return this.swapIn(
+                srcToken.address.toLowerCase() === pool.token0.toLowerCase(),
+                amount,
+                currentPoolReserves.collateralReserves,
+                currentPoolReserves.debtReserves,
+                srcToken.decimals,
+                destToken.decimals,
+                BigInt(currentPoolReserves.fee),
+                currentPoolReserves.dexLimits,
+                Math.floor(Date.now() / 1000),
+              );
+            } else {
+              return this.swapOut(
+                srcToken.address.toLowerCase() === pool.token0.toLowerCase(),
+                amount,
+                currentPoolReserves.collateralReserves,
+                currentPoolReserves.debtReserves,
+                srcToken.decimals,
+                destToken.decimals,
+                BigInt(currentPoolReserves.fee),
+                currentPoolReserves.dexLimits,
+                Math.floor(Date.now() / 1000),
+              );
+            }
+          });
+
+          return {
+            prices: prices,
+            unit: getBigIntPow(destToken.decimals),
+            data: {
+              poolId: pool.id,
+            },
+            exchange: this.dexKey,
+            poolIdentifier: pool.id,
+            gasCost: FLUID_DEX_GAS_COST,
+            poolAddresses: [pool.address],
+          };
+        }),
+      );
+
+      const notNullResults = poolsPrices.filter(
+        res => res !== null,
+      ) as ExchangePrices<FluidDexData>;
+
+      return notNullResults;
     } catch (e) {
       this.logger.error(
         `Error_getPricesVolume ${srcToken.address || srcToken.symbol}, ${
@@ -272,10 +321,9 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
   ): AdapterExchangeParam {
     // Encode here the payload for adapter
     const payload = '';
-    const pool = this.getPoolByTokenPair(srcToken, destToken);
 
     return {
-      targetExchange: pool!.address,
+      targetExchange: '0x',
       payload,
       networkFee: '0',
     };
@@ -313,7 +361,11 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
       side === SwapSide.SELL ? 'amountOut_' : 'amountIn_',
     );
 
-    const pool = this.getPoolByTokenPair(srcToken, destToken);
+    const pool = this.pools.find(pool => pool.id === data.poolId);
+    if (!pool)
+      throw new Error(
+        `${this.dexKey}-${this.network}: Pool with id: ${data.poolId} was not found`,
+      );
 
     if (side === SwapSide.SELL) {
       if (pool!.token0.toLowerCase() !== srcToken.toLowerCase()) {
@@ -584,11 +636,84 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
     if (priceDiff > maxAllowedDiff) {
       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;
   }
 
+  /**
+   * Checks if token0 reserves are sufficient compared to token1 reserves.
+   * This helps prevent edge cases and ensures high precision in calculations.
+   * @param {number} token0Reserves - The reserves of token0.
+   * @param {number} token1Reserves - The reserves of token1.
+   * @param {number} price - The current price used for calculation.
+   * @returns {boolean} - Returns false if token0 reserves are too low, true otherwise.
+   */
+  protected verifyToken0Reserves(
+    token0Reserves: bigint,
+    token1Reserves: bigint,
+    price: bigint,
+  ): boolean {
+    return (
+      token0Reserves >=
+      (token1Reserves * 10n ** 27n) / (price * MIN_SWAP_LIQUIDITY)
+    );
+  }
+
+  /**
+   * Checks if token1 reserves are sufficient compared to token0 reserves.
+   * This helps prevent edge cases and ensures high precision in calculations.
+   * @param {number} token0Reserves - The reserves of token0.
+   * @param {number} token1Reserves - The reserves of token1.
+   * @param {number} price - The current price used for calculation.
+   * @returns {boolean} - Returns false if token1 reserves are too low, true otherwise.
+   */
+  protected verifyToken1Reserves(
+    token0Reserves: bigint,
+    token1Reserves: bigint,
+    price: bigint,
+  ): boolean {
+    return (
+      token1Reserves >=
+      (token0Reserves * price) / (10n ** 27n * MIN_SWAP_LIQUIDITY)
+    );
+  }
+
   /**
    * Calculates the currently available swappable amount for a token limit considering expansion since last syncTime.
    * @param syncTime - timestamp in seconds when the limits were synced
@@ -765,7 +890,7 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
       syncTime,
     );
 
-    if (amountIn == 2n ** 256n - 1n) {
+    if (amountIn === 2n ** 256n - 1n) {
       return amountIn;
     }
     const ans = (amountIn * BigInt(10 ** inDecimals)) / BigInt(10 ** 12);
@@ -985,6 +1110,39 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
       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;
 
     return totalAmountIn;

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

@@ -72,7 +72,9 @@ export interface PoolWithReserves {
   debtReserves: DebtReserves;
 }
 
-export type FluidDexData = {};
+export type FluidDexData = {
+  poolId: string;
+};
 
 // Each pool has a contract address and token pairs.
 export type FluidDexPool = {