@paraswap/dex-lib 3.8.13 → 3.8.15

package/src/dex/concentrator-arusd/utils.ts

@@ -0,0 +1,36 @@
+import { Contract } from 'web3-eth-contract';
+import { ConcentratorArusdState, ConcentratorArusdNavState } from './types';
+import { Interface, AbiCoder } from '@ethersproject/abi';
+
+const coder = new AbiCoder();
+
+export async function getOnChainState(
+  multiContract: Contract,
+  poolAddress: string,
+  poolInterface: Interface,
+  blockNumber: number | 'latest',
+): Promise<ConcentratorArusdState> {
+  const data: { returnData: any[] } = await multiContract.methods
+    .aggregate([
+      {
+        target: poolAddress,
+        callData: poolInterface.encodeFunctionData('totalSupply', []),
+      },
+      {
+        target: poolAddress,
+        callData: poolInterface.encodeFunctionData('getTotalAssets', []),
+      },
+    ])
+    .call({}, blockNumber);
+
+  const totalSupply = BigInt(
+    poolInterface.decodeFunctionResult('totalSupply', data.returnData[0])[0],
+  ).toString();
+  const totalAssets = BigInt(
+    poolInterface.decodeFunctionResult('getTotalAssets', data.returnData[1])[0],
+  ).toString();
+  return {
+    totalSupply,
+    totalAssets,
+  };
+}

package/src/dex/fx-protocol-rusd/config.ts

@@ -0,0 +1,14 @@
+import { DexParams } from './types';
+import { DexConfigMap, AdapterMappings } from '../../types';
+import { Network, SwapSide } from '../../constants';
+
+export const FxProtocolConfig: DexConfigMap<DexParams> = {
+  FxProtocolRusd: {
+    [Network.MAINNET]: {
+      rUSDAddress: '0x65D72AA8DA931F047169112fcf34f52DbaAE7D18',
+      weETHAddress: '0xCd5fE23C85820F7B72D0926FC9b05b43E359b7ee',
+      rUSDWeETHMarketAddress: '0x267c6a96db7422faa60aa7198ffeeec4169cd65f',
+      weETHOracleAddress: '0xddb6f90ffb4d3257dd666b69178e5b3c5bf41136',
+    },
+  },
+};

package/src/dex/fx-protocol-rusd/fx-protocol-e2e.test.ts

@@ -0,0 +1,96 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import {
+  Tokens,
+  Holders,
+  NativeTokenSymbols,
+} from '../../../tests/constants-e2e';
+import { Network, ContractMethod, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+
+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 sideToContractMethods = new Map([
+    [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    // [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
+  ]);
+
+  describe(`${network}`, () => {
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          describe(`${contractMethod}`, () => {
+            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
+describe('FxProtocolRusd E2E', () => {
+  const dexKey = 'FxProtocolRusd';
+  const network = Network.MAINNET;
+  const pairs: { name: string; amount: string; skipBuy?: boolean }[][] = [
+    [
+      {
+        name: 'weETH',
+        amount: '1000000000000000000',
+      },
+      {
+        name: 'rUSD',
+        amount: '1000000000000000000',
+      },
+    ],
+    [
+      {
+        name: 'rUSD',
+        amount: '100000000000000',
+      },
+      {
+        name: 'weETH',
+        amount: '1000000000000000000',
+      },
+    ],
+  ];
+
+  pairs.forEach(pair => {
+    testForNetwork(
+      network,
+      dexKey,
+      pair[0].name,
+      pair[1].name,
+      pair[0].amount,
+      pair[1].amount,
+    );
+  });
+});

package/src/dex/fx-protocol-rusd/fx-protocol-events.test.ts

@@ -0,0 +1,101 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { FxProtocolRusdEvent } from './fx-protocol-rusd-event';
+import { FxProtocolConfig } from './config';
+import { Network } from '../../constants';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { testEventSubscriber } from '../../../tests/utils-events';
+import FxUSD_ABI from '../../abi/fx-protocol/FxUSD.json';
+import FxMarket_ABI from '../../abi/fx-protocol/FxMarket.json';
+import EthWeETHOralce_ABI from '../../abi/fx-protocol/weETHOralce.json';
+
+import _ from 'lodash';
+import { FxProtocolPoolState } from './types';
+import { Interface } from 'ethers/lib/utils';
+import { JsonFragment } from '@ethersproject/abi';
+
+/*
+  README
+  ======
+
+  This test script adds unit tests for fxProtocol 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);
+const dexKey = 'FxProtocolRusd';
+const network = Network.MAINNET;
+
+async function fetchPoolState(
+  fxProtocolPool: FxProtocolRusdEvent,
+  blockNumber: number,
+): Promise<FxProtocolPoolState> {
+  return fxProtocolPool.generateState(blockNumber);
+}
+
+describe('FxProtocolRusd Event', function () {
+  const blockNumbers: { [eventName: string]: number[] } = {
+    UpdateRedeemFeeRatioFToken: [19460858, 19465918, 19460857],
+    AnswerUpdated: [20482537, 20481328, 20480824, 20480670, 20480669],
+  };
+
+  describe('FxProtocolRusdPool', function () {
+    Object.keys(blockNumbers).forEach((event: string) => {
+      blockNumbers[event].forEach((blockNumber: number) => {
+        it(`Should return the correct state after the ${blockNumber}:${event}`, async function () {
+          const dexHelper = new DummyDexHelper(network);
+          const logger = dexHelper.getLogger(dexKey);
+          const config = FxProtocolConfig[dexKey][network];
+
+          const fxProtocolPool = new FxProtocolRusdEvent(
+            dexKey,
+            dexHelper,
+            config.rUSDWeETHMarketAddress,
+            new Interface(FxMarket_ABI as JsonFragment[]),
+            config.weETHOracleAddress,
+            new Interface(EthWeETHOralce_ABI as JsonFragment[]),
+            logger,
+          );
+
+          await fxProtocolPool.initialize(blockNumber);
+
+          await testEventSubscriber(
+            fxProtocolPool,
+            fxProtocolPool.addressesSubscribed,
+            (_blockNumber: number) =>
+              fetchPoolState(fxProtocolPool, _blockNumber),
+            blockNumber,
+            `${dexKey}_${fxProtocolPool}`,
+            dexHelper.provider,
+          );
+        });
+      });
+    });
+  });
+});

package/src/dex/fx-protocol-rusd/fx-protocol-integration.test.ts

@@ -0,0 +1,104 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { DummyDexHelper } from '../../dex-helper/index';
+import { Network, SwapSide } from '../../constants';
+import { checkPoolPrices, checkPoolsLiquidity } from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+import { BI_POWS } from '../../bigint-constants';
+import { FxProtocolRusd } from './fx-protocol-rusd';
+
+const network = Network.MAINNET;
+
+const rUSDSymbol = 'rUSD';
+const rUSDToken = Tokens[network][rUSDSymbol];
+
+const weETHSymbol = 'weETH';
+const weETHToken = Tokens[network][weETHSymbol];
+
+const amounts = [0n, BI_POWS[18], 2000000000000000000n];
+
+const dexKey = 'FxProtocolRusd';
+const dexHelper = new DummyDexHelper(network);
+let blocknumber: number;
+let fxProtocolRusd: FxProtocolRusd;
+
+describe('FxProtocolRusd', function () {
+  beforeAll(async () => {
+    blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+    fxProtocolRusd = new FxProtocolRusd(network, dexKey, dexHelper);
+    if (fxProtocolRusd.initializePricing) {
+      await fxProtocolRusd.initializePricing(blocknumber);
+    }
+  });
+
+  it('getPoolIdentifiers and getPricesVolume weETH -> rUSD SELL', async function () {
+    const pools = await fxProtocolRusd.getPoolIdentifiers(
+      weETHToken,
+      rUSDToken,
+      SwapSide.SELL,
+      blocknumber,
+    );
+    console.log(`${weETHSymbol} <> ${rUSDSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await fxProtocolRusd.getPricesVolume(
+      weETHToken,
+      rUSDToken,
+      amounts,
+      SwapSide.SELL,
+      blocknumber,
+      pools,
+    );
+    console.log(`${weETHSymbol} <> ${rUSDSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume rUSD -> weETH SELL', async function () {
+    const pools = await fxProtocolRusd.getPoolIdentifiers(
+      rUSDToken,
+      weETHToken,
+      SwapSide.SELL,
+      blocknumber,
+    );
+    console.log(`${rUSDSymbol} <> ${weETHSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await fxProtocolRusd.getPricesVolume(
+      rUSDToken,
+      weETHToken,
+      amounts,
+      SwapSide.SELL,
+      blocknumber,
+      pools,
+    );
+    console.log(`${rUSDSymbol} <> ${weETHSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+  });
+
+  it('weETH getTopPoolsForToken', async function () {
+    const poolLiquidity = await fxProtocolRusd.getTopPoolsForToken(
+      weETHToken.address,
+      10,
+    );
+    console.log(`${weETHSymbol} Top Pools:`, poolLiquidity);
+
+    checkPoolsLiquidity(poolLiquidity, weETHToken.address, dexKey);
+  });
+
+  it('rUSD getTopPoolsForToken', async function () {
+    const poolLiquidity = await fxProtocolRusd.getTopPoolsForToken(
+      rUSDToken.address,
+      10,
+    );
+    console.log(`${rUSDSymbol} Top Pools:`, poolLiquidity);
+
+    checkPoolsLiquidity(poolLiquidity, rUSDToken.address, dexKey);
+  });
+});

package/src/dex/fx-protocol-rusd/fx-protocol-rusd-event.ts

@@ -0,0 +1,112 @@
+import _ from 'lodash';
+import { defaultAbiCoder, Interface } from '@ethersproject/abi';
+import { IDexHelper } from '../../dex-helper';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import { Address, Log, Logger } from '../../types';
+import { AsyncOrSync, DeepReadonly } from 'ts-essentials';
+import { FxProtocolPoolState } from './types';
+import { BI_POWS } from '../../bigint-constants';
+import { getOnChainState } from './utils';
+
+const ANSWER_UPDATED_TOPICHASH = `0x0559884fd3a460db3073b7fc896cc77986f16e378210ded43186175bf646fc5f`;
+const UPDATE_REDEEM_FEE_TOPICHASH = `0xb3d49e95905d108ea668ffe62a85ee16bdc4ff9f122a7137964327ea8e0585ff`;
+
+export class FxProtocolRusdEvent extends StatefulEventSubscriber<FxProtocolPoolState> {
+  constructor(
+    parentName: string,
+    protected dexHelper: IDexHelper,
+    private marketAddress: Address,
+    private marketInterface: Interface,
+    private weETHOracleAddress: Address,
+    private weETHOracleIface: Interface,
+    logger: Logger,
+  ) {
+    super(parentName, 'fxProtocolRusd', dexHelper, logger);
+    this.addressesSubscribed = [marketAddress, weETHOracleAddress];
+  }
+
+  protected processLog(
+    state: DeepReadonly<FxProtocolPoolState>,
+    log: Readonly<Log>,
+  ): AsyncOrSync<DeepReadonly<FxProtocolPoolState> | null> {
+    if (log.topics[0] === UPDATE_REDEEM_FEE_TOPICHASH) {
+      const [defaultFeeRatio] = defaultAbiCoder.decode(
+        ['uint256', 'int256'],
+        log.data,
+      );
+
+      return {
+        ...state,
+        redeemFee: BigInt(defaultFeeRatio).toString(),
+      };
+    }
+
+    if (log.topics[0] === ANSWER_UPDATED_TOPICHASH) {
+      return {
+        ...state,
+        weETHPrice: BigInt(log.topics[1]).toString(),
+      };
+    }
+
+    return null;
+  }
+
+  async generateState(
+    blockNumber: number | 'latest' = 'latest',
+  ): Promise<DeepReadonly<FxProtocolPoolState>> {
+    const state = await getOnChainState(
+      this.dexHelper.multiContract,
+      this.marketAddress,
+      this.marketInterface,
+      this.weETHOracleAddress,
+      this.weETHOracleIface,
+      blockNumber,
+    );
+    return state;
+  }
+
+  async getPrice(
+    blockNumber: number,
+    amount: bigint,
+    isRedeem: boolean,
+  ): Promise<bigint> {
+    const state = await this.getOrGenerateState(blockNumber);
+    if (!state) throw new Error('Cannot compute price');
+
+    const { nav, redeemFee, weETHPrice } = state;
+    const baseTokenPrice = BigInt(weETHPrice) * BI_POWS[10];
+
+    if (isRedeem) {
+      return BigInt(
+        (amount * BigInt(nav) * (BI_POWS[18] - BigInt(redeemFee))) /
+          BI_POWS[18] /
+          baseTokenPrice,
+      );
+    } else {
+      return BigInt((baseTokenPrice * amount) / BigInt(nav));
+    }
+  }
+
+  async getOrGenerateState(
+    blockNumber: number,
+  ): Promise<DeepReadonly<FxProtocolPoolState> | null> {
+    const state = this.getState(blockNumber);
+    if (state) {
+      return state;
+    }
+
+    this.logger.debug(
+      `No state found for ${this.addressesSubscribed[0]}, generating new one`,
+    );
+    const newState = await this.generateState(blockNumber);
+
+    if (!newState) {
+      this.logger.debug(
+        `Could not regenerate state for ${this.addressesSubscribed[0]}`,
+      );
+      return null;
+    }
+    this.setState(newState, blockNumber);
+    return newState;
+  }
+}