@paraswap/dex-lib 3.10.0 → 3.10.2

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

@@ -0,0 +1,20 @@
+import { DexParams } from './types';
+import { DexConfigMap } from '../../types';
+import { Network } from '../../constants';
+
+export const FluidDexConfig: DexConfigMap<DexParams> = {
+  FluidDex: {
+    [Network.MAINNET]: {
+      commonAddresses: {
+        liquidityProxy: '0x52aa899454998be5b000ad077a46bbe360f4e497',
+        resolver: '0xE8a07a32489BD9d5a00f01A55749Cf5cB854Fd13',
+        dexFactory: '0x91716C4EDA1Fb55e84Bf8b4c7085f84285c19085',
+      },
+    },
+  },
+};
+
+// Uniswap takes total gas of 125k = 21k base gas & 104k swap (this is when user has token balance)
+// Fluid takes total gas of 175k = 21k base gas & 154k swap (this is when user has token balance),
+// with ETH swaps costing less (because no WETH conversion)
+export const FLUID_DEX_GAS_COST = 154_000;

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

@@ -0,0 +1,153 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+
+import { testE2E } from '../../../tests/utils-e2e';
+import {
+  Tokens,
+  Holders,
+  NativeTokenSymbols,
+} from '../../../tests/constants-e2e';
+import { Network, ContractMethod, SwapSide } from '../../constants';
+import { generateConfig } from '../../config';
+
+/*
+  README
+  ======
+
+  This test script should add e2e tests for FluidDex. The tests
+  should cover as many cases as possible. Most of the DEXes follow
+  the following test structure:
+    - DexName
+      - ForkName + Network
+        - ContractMethod
+          - ETH -> Token swap
+          - Token -> ETH swap
+          - Token -> Token swap
+
+  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,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+  const nativeTokenSymbol = NativeTokenSymbols[network];
+
+  const sideToContractMethods = new Map([
+    [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+  ]);
+
+  describe(`${network}`, () => {
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: string) => {
+          describe(`${contractMethod}`, () => {
+            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
+                tokenBAmount,
+                SwapSide.SELL,
+                dexKey,
+                contractMethod as ContractMethod,
+                network,
+                provider,
+              );
+            });
+            it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
+              await testE2E(
+                tokens[tokenBSymbol],
+                tokens[tokenASymbol],
+                holders[tokenBSymbol],
+                tokenBAmount,
+                SwapSide.SELL,
+                dexKey,
+                contractMethod as ContractMethod,
+                network,
+                provider,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
+describe('FluidDex E2E', () => {
+  const dexKey = 'FluidDex';
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+
+    describe('ETH -> wstETH', () => {
+      const tokenASymbol: string = 'wstETH';
+      const tokenBSymbol: string = 'ETH';
+
+      const tokenAAmount: string = '100000000000000';
+      const tokenBAmount: string = '100000000000000';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+      );
+    });
+
+    describe('USDC -> USDT', () => {
+      const tokenASymbol: string = 'USDC';
+      const tokenBSymbol: string = 'USDT';
+
+      const tokenAAmount: string = '1000000';
+      const tokenBAmount: string = '100000000';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+      );
+    });
+  });
+});

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

@@ -0,0 +1,293 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { FluidDexEventPool } from './fluid-dex-pool';
+import { FluidDexFactory } from './fluid-dex-factory';
+import { FluidDex } from './fluid-dex';
+import { Network } from '../../constants';
+import { Address } from '../../types';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { testEventSubscriber } from '../../../tests/utils-events';
+import { CommonAddresses, FluidDexPoolState, Pool } from './types';
+import { FluidDexConfig } from './config';
+import { DeepReadonly } from 'ts-essentials';
+import { TenderlySimulation } from '../../../tests/tenderly-simulation';
+
+/*
+  README
+  ======
+
+  This test script adds unit tests for FluidDex event based
+  system. This is done by fetching the state on-chain before the
+  event block, manually pushing the block logs to the event-subscriber,
+  comparing the local state with on-chain state.
+
+  Most of the logic for testing is abstracted by `testEventSubscriber`.
+  You need to do two things to make the tests work:
+
+  1. Fetch the block numbers where certain events were released. You
+  can modify the `./scripts/fetch-event-blocknumber.ts` to get the
+  block numbers for different events. Make sure to get sufficient
+  number of blockNumbers to cover all possible cases for the event
+  mutations.
+
+  2. Complete the implementation for fetchPoolState function. The
+  function should fetch the on-chain state of the event subscriber
+  using just the blocknumber.
+
+  The template tests only include the test for a single event
+  subscriber. There can be cases where multiple event subscribers
+  exist for a single DEX. In such cases additional tests should be
+  added.
+
+  You can run this individual test script by running:
+  `npx jest src/dex/<dex-name>/<dex-name>-events.test.ts`
+
+  (This comment should be removed from the final implementation)
+*/
+
+jest.setTimeout(50 * 1000);
+
+async function fetchPoolState(
+  fluidDexPool: FluidDexEventPool,
+  blockNumber: number,
+): Promise<FluidDexPoolState> {
+  return await fluidDexPool.generateState(blockNumber);
+}
+
+async function fetchTotalPools(
+  factory: FluidDexFactory,
+  blockNumber: number,
+): Promise<DeepReadonly<Pool[]>> {
+  return await factory.generateState(blockNumber);
+}
+
+async function delay(seconds: number): Promise<void> {
+  for (let i = seconds; i > 0; i--) {
+    process.stdout.write(`\r${i} second${i !== 1 ? 's' : ''} left`);
+    await new Promise(resolve => setTimeout(resolve, 1000));
+  }
+  process.stdout.write("\rTime's up!    \n");
+}
+
+function stringifyCircular(obj: any, space?: number): string {
+  const seen = new WeakSet();
+  return JSON.stringify(
+    obj,
+    (key, value) => {
+      if (typeof value === 'object' && value !== null) {
+        if (seen.has(value)) {
+          return '[Circular]';
+        }
+        seen.add(value);
+      }
+      return value;
+    },
+    space,
+  );
+}
+
+function replacer(key: string, value: any) {
+  if (typeof value === 'bigint') {
+    return value.toString();
+  }
+  return value;
+}
+
+// eventName -> blockNumbers
+type EventMappings = Record<string, number[]>;
+
+describe('FluidDex EventPool Mainnet', function () {
+  const dexKey = 'FluidDex';
+  const network = Network.MAINNET;
+  const dexHelper = new DummyDexHelper(network);
+  const logger = dexHelper.getLogger(dexKey);
+  const fluidDexCommonAddressStruct: CommonAddresses =
+    FluidDexConfig[dexKey][network].commonAddresses;
+  const liquidityProxy: Address = '0x52aa899454998be5b000ad077a46bbe360f4e497';
+  const dexFactory: Address = '0x91716C4EDA1Fb55e84Bf8b4c7085f84285c19085';
+
+  const poolFetchEventsToTest: Record<Address, EventMappings> = {
+    [dexFactory]: {
+      DexDeployed: [21063272],
+    },
+  };
+
+  // poolAddress -> EventMappings
+  const poolUpdateEventsToTest: Record<Address, EventMappings> = {
+    [dexFactory]: {
+      LogOperate: [21063272],
+    },
+  };
+
+  let fluidDexEventPool: FluidDexEventPool;
+  let factory: FluidDexFactory;
+
+  Object.entries(poolUpdateEventsToTest).forEach(
+    ([poolAddress, events]: [string, EventMappings]) => {
+      describe(`Events for ${poolAddress}`, () => {
+        Object.entries(events).forEach(
+          ([eventName, blockNumbers]: [string, number[]]) => {
+            describe(`${eventName}`, () => {
+              blockNumbers.forEach((blockNumber: number) => {
+                it(`State after ${blockNumber}`, async function () {
+                  const fluidDex = new FluidDex(network, dexKey, dexHelper);
+
+                  await fluidDex.initializePricing(blockNumber);
+                  console.log('hello');
+
+                  const ts: TenderlySimulation = new TenderlySimulation(
+                    network,
+                  );
+
+                  await ts.setup();
+
+                  const forkId = ts.forkId;
+                  dexHelper.replaceProviderWithRPC(
+                    `https://rpc.tenderly.co/fork/${forkId}`,
+                  );
+
+                  console.log(forkId);
+
+                  const pools = fluidDex.factory.getState(blockNumber);
+                  let pool: string | undefined;
+
+                  if (pools) {
+                    for (let i = 0; i < pools.length; i++) {
+                      if (
+                        pools[i].token0.toLowerCase() ===
+                          '0x7f39c581f595b53c5cb19bd0b3f8da6c935e2ca0' &&
+                        pools[i].token1.toLowerCase() ===
+                          '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'
+                      ) {
+                        pool = pools[i].address.toLowerCase();
+                        break;
+                      }
+                    }
+                  } else {
+                    console.error('Pools data is null or undefined');
+                  }
+
+                  fluidDexEventPool = fluidDex.eventPools[`FluidDex_${pool}`];
+                  console.log(
+                    `this is the dex key that i fetched from writing the for loop FluidDex_${pool}`,
+                  );
+
+                  console.log(
+                    'eth balance before : ' +
+                      (await dexHelper.provider.getBalance(
+                        '0x3c22ec75ea5d745c78fc84762f7f1e6d82a2c5bf',
+                      )),
+                  );
+
+                  console.log(
+                    'state 1 block before : ' +
+                      JSON.stringify(
+                        await fluidDexEventPool.generateState(
+                          await dexHelper.provider.getBlockNumber(),
+                        ),
+                        replacer,
+                        2,
+                      ),
+                  );
+
+                  const allowanceTxn = await ts.simulate({
+                    from: '0x3c22ec75ea5d745c78fc84762f7f1e6d82a2c5bf',
+                    to: '0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0', // undefined in case of contract deployment
+                    value: '0',
+                    data: '0x095ea7b30000000000000000000000006a000f20005980200259b80c51020030400010680000000000000000000000000000000000000000000000056bc75e2d63100000',
+                  });
+
+                  console.log(
+                    'allowance txn (isSuccess?) : ' + allowanceTxn.success,
+                  );
+
+                  const swapTxn = await ts.simulate({
+                    from: '0x3c22ec75ea5d745c78fc84762f7f1e6d82a2c5bf',
+                    to: '0x6a000f20005980200259b80c5102003040001068', // undefined in case of contract deployment
+                    value: '0',
+                    data: '0xe3ead59e000000000000000000000000000010036c0190e009a000d0fc3541100a07380a0000000000000000000000007f39c581f595b53c5cb19bd0b3f8da6c935e2ca0000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee00000000000000000000000000000000000000000000000000005af3107a400000000000000000000000000000000000000000000000000000006a6b745e1dd000000000000000000000000000000000000000000000000000006b7ea416a9c0a47d24fdc9fd475bb1cc320a468c050100000000000000000000000001405b6c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000180000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000001807f39c581f595b53c5cb19bd0b3f8da6c935e2ca00000006000000044ff00000000000000000000000000000000000000000000000000000000000000095ea7b30000000000000000000000000b1a513ee24972daef112bc777a5610d4325c9e7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0b1a513ee24972daef112bc777a5610d4325c9e7000000a00024000000000007000000000000000000000000000000000000000000000000000000002668dfaa000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000005af3107a400000000000000000000000000000000000000000000000000000000000000000010000000000000000000000006a000f20005980200259b80c5102003040001068',
+                  });
+
+                  console.log('swap txn (isSuccess?) : ' + swapTxn.success);
+
+                  console.log(
+                    'eth balance after : ' +
+                      (await dexHelper.provider.getBalance(
+                        '0x3c22ec75ea5d745c78fc84762f7f1e6d82a2c5bf',
+                      )),
+                  );
+
+                  // console.log(JSON.stringify(swapTxn));
+
+                  const txnBlockNumber = swapTxn.transaction.block_number;
+
+                  console.log(txnBlockNumber);
+                  console.log(await dexHelper.provider.getBlockNumber());
+
+                  await delay(30);
+
+                  console.log(
+                    'state 1 block before : ' +
+                      JSON.stringify(
+                        await fluidDexEventPool.generateState(
+                          txnBlockNumber - 2,
+                        ),
+                        replacer,
+                        2,
+                      ),
+                  );
+                  console.log(
+                    'state 1 block after : ' +
+                      JSON.stringify(
+                        await fluidDexEventPool.generateState(
+                          await dexHelper.provider.getBlockNumber(),
+                        ),
+                        replacer,
+                        2,
+                      ),
+                  );
+                });
+              });
+            });
+          },
+        );
+      });
+    },
+  );
+
+  Object.entries(poolFetchEventsToTest).forEach(
+    ([poolAddress, events]: [string, EventMappings]) => {
+      describe(`Events for ${poolAddress}`, () => {
+        Object.entries(events).forEach(
+          ([eventName, blockNumbers]: [string, number[]]) => {
+            describe(`${eventName}`, () => {
+              blockNumbers.forEach((blockNumber: number) => {
+                it(`State after ${blockNumber}`, async function () {
+                  factory = new FluidDexFactory(
+                    'FluidDex',
+                    fluidDexCommonAddressStruct,
+                    network,
+                    dexHelper,
+                    logger,
+                  );
+
+                  await testEventSubscriber(
+                    factory,
+                    factory.addressesSubscribed,
+                    (_blockNumber: number) =>
+                      fetchTotalPools(factory, _blockNumber),
+                    blockNumber,
+                    `${dexKey}_${poolAddress}`,
+                    dexHelper.provider,
+                  );
+                });
+              });
+            });
+          },
+        );
+      });
+    },
+  );
+});

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

@@ -0,0 +1,143 @@
+import { Interface } from '@ethersproject/abi';
+import { BytesLike } from 'ethers/lib/utils';
+import { DeepReadonly } from 'ts-essentials';
+import { Log, Logger } from '../../types';
+import { 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 DexFactoryABI from '../../abi/fluid-dex/dexFactory.abi.json';
+import { CommonAddresses, Pool } from './types';
+import { MultiResult } from '../../lib/multi-wrapper';
+import { Address } from '../../types';
+import { generalDecoder } from '../../lib/decoders';
+import { Contract } from 'ethers';
+
+export class FluidDexFactory extends StatefulEventSubscriber<Pool[]> {
+  handlers: {
+    [event: string]: (
+      event: any,
+      state: DeepReadonly<Pool[]>,
+      log: Readonly<Log>,
+    ) => Promise<DeepReadonly<Pool[]> | null>;
+  } = {};
+
+  logDecoder: (log: Log) => any;
+
+  addressesSubscribed: Address[];
+  protected dexFactoryIface = new Interface(DexFactoryABI);
+  protected resolverIface = new Interface(ResolverABI);
+
+  constructor(
+    readonly parentName: string,
+    readonly commonAddresses: CommonAddresses,
+    protected network: number,
+    protected dexHelper: IDexHelper,
+    logger: Logger,
+  ) {
+    super(parentName, 'getAllPools', dexHelper, logger);
+
+    this.logDecoder = (log: Log) => this.dexFactoryIface.parseLog(log);
+    this.addressesSubscribed = [commonAddresses.dexFactory];
+
+    // Add handlers
+    this.handlers['DexDeployed'] = this.handleDexDeployed.bind(this);
+  }
+
+  /**
+   * Handle a trade rate change on the pool.
+   */
+  async handleDexDeployed(
+    event: any,
+    state: DeepReadonly<Pool[]>,
+    log: Readonly<Log>,
+  ): Promise<DeepReadonly<Pool[]> | null> {
+    const blockNumber_ = await this.dexHelper.provider.getBlockNumber();
+    return this.getStateOrGenerate(blockNumber_, false);
+  }
+
+  decodePool = (result: MultiResult<BytesLike> | BytesLike): Pool => {
+    return generalDecoder(
+      result,
+      ['tuple(address pool, address token0, address token1, uint256 fee)'],
+      undefined,
+      decoded => {
+        return {
+          address: decoded[0].toLowerCase(),
+          token0: decoded[1].toLowerCase(),
+          token1: decoded[2].toLowerCase(),
+        };
+      },
+    );
+  };
+
+  /**
+   * 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<Pool[]>,
+    log: Readonly<Log>,
+  ): Promise<DeepReadonly<Pool[]> | null> {
+    try {
+      let event;
+      try {
+        event = this.logDecoder(log);
+      } catch (e) {
+        return null;
+      }
+      if (event.name in this.handlers) {
+        return await this.handlers[event.name](event, state, log);
+      }
+    } catch (e) {
+      catchParseLogError(e, this.logger);
+    }
+
+    return null;
+  }
+
+  async getStateOrGenerate(
+    blockNumber: number,
+    readonly: boolean = false,
+  ): Promise<DeepReadonly<Pool[]>> {
+    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<Pool[]>> {
+    const resolverContract = new Contract(
+      this.commonAddresses.resolver,
+      ResolverABI,
+      this.dexHelper.provider,
+    );
+    const rawResult = await resolverContract.callStatic.getAllPools({
+      blockTag: blockNumber,
+    });
+
+    const pools: Pool[] = rawResult.map((result: any) => ({
+      address: result[0],
+      token0: result[1],
+      token1: result[2],
+    }));
+
+    return pools;
+  }
+}