@paraswap/dex-lib 3.8.13-arusd-fxusd.2 → 3.8.13-infusion

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

@@ -1,14 +0,0 @@
-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

@@ -1,96 +0,0 @@
-/* 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: '1000000000000000000',
-      },
-      {
-        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

@@ -1,101 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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

@@ -1,80 +0,0 @@
-import _ from 'lodash';
-import { 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 { bigIntify, catchParseLogError } from '../../utils';
-import { getOnChainState } from './utils';
-
-export class fxProtocolRusdEvent extends StatefulEventSubscriber<FxProtocolPoolState> {
-  decoder = (log: Log) => this.marketInterface.parseLog(log);
-
-  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> {
-    const event = this.decoder(log);
-    try {
-      const _state: FxProtocolPoolState = _.cloneDeep(state);
-      if (event.name === 'UpdateRedeemFeeRatioFToken') {
-        _state.redeemFee = bigIntify(event.args.defaultFeeRatio);
-        return _state;
-      } else if (event.name === 'AnswerUpdated') {
-        _state.weETHPrice = bigIntify(event.args.current);
-        return _state;
-      }
-      return null;
-    } catch (e) {
-      catchParseLogError(e, this.logger);
-      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;
-  }
-
-  getPrice(blockNumber: number, amount: bigint, isRedeem: boolean): bigint {
-    const state = this.getState(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 * nav * (BI_POWS[18] - redeemFee)) /
-          BI_POWS[18] /
-          baseTokenPrice,
-      );
-    } else {
-      return BigInt((baseTokenPrice * amount) / nav);
-    }
-  }
-}

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

@@ -1,303 +0,0 @@
-import {
-  Token,
-  Address,
-  ExchangePrices,
-  PoolPrices,
-  AdapterExchangeParam,
-  Logger,
-  NumberAsString,
-  DexExchangeParam,
-  PoolLiquidity,
-} from '../../types';
-import { SwapSide, Network } from '../../constants';
-import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
-import { getDexKeysWithNetwork } from '../../utils';
-import { IDex } from '../idex';
-import { IDexHelper } from '../../dex-helper/idex-helper';
-import { DexParams, FxProtocolData } from './types';
-import { SimpleExchange } from '../simple-exchange';
-import { FxProtocolConfig } from './config';
-import { Interface, JsonFragment } from '@ethersproject/abi';
-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 { extractReturnAmountPosition } from '../../executor/utils';
-import { fxProtocolRusdEvent } from './fx-protocol-rusd-event';
-import { BI_POWS } from '../../bigint-constants';
-
-export class FxProtocolRusd
-  extends SimpleExchange
-  implements IDex<FxProtocolData>
-{
-  protected config: DexParams;
-
-  readonly hasConstantPriceLargeAmounts = true;
-
-  readonly needWrapNative = false;
-
-  readonly isFeeOnTransferSupported = false;
-
-  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
-    getDexKeysWithNetwork(FxProtocolConfig);
-
-  fxUSDIface: Interface;
-  rUSDMarketIface: Interface;
-  weETHOracleIface: Interface;
-  fxProtocolRusdPool: fxProtocolRusdEvent;
-  logger: Logger;
-
-  constructor(
-    readonly network: Network,
-    readonly dexKey: string,
-    readonly dexHelper: IDexHelper,
-  ) {
-    super(dexHelper, dexKey);
-    const config = FxProtocolConfig[dexKey][network];
-    this.fxUSDIface = new Interface(FxUSD_ABI as JsonFragment[]);
-    this.rUSDMarketIface = new Interface(FxMarket_ABI as JsonFragment[]);
-    this.weETHOracleIface = new Interface(EthWeETHOralce_ABI as JsonFragment[]);
-    this.config = {
-      rUSDAddress: config.rUSDAddress.toLowerCase(),
-      weETHAddress: config.weETHAddress.toLowerCase(),
-      rUSDWeETHMarketAddress: config.rUSDWeETHMarketAddress.toLowerCase(),
-      weETHOracleAddress: config.weETHOracleAddress.toLowerCase(),
-    };
-    this.logger = dexHelper.getLogger(dexKey);
-    this.fxProtocolRusdPool = new fxProtocolRusdEvent(
-      this.dexKey,
-      dexHelper,
-      this.config.rUSDWeETHMarketAddress,
-      this.rUSDMarketIface,
-      this.config.weETHOracleAddress,
-      this.weETHOracleIface,
-      this.logger,
-    );
-  }
-
-  async initializePricing(blockNumber: number) {
-    const data: { returnData: any[] } =
-      await this.dexHelper.multiContract.methods
-        .aggregate([
-          {
-            target: this.config.rUSDWeETHMarketAddress,
-            callData: this.rUSDMarketIface.encodeFunctionData(
-              'fTokenRedeemFeeRatio',
-              [],
-            ),
-          },
-          {
-            target: this.config.weETHOracleAddress,
-            callData: this.weETHOracleIface.encodeFunctionData(
-              'latestAnswer',
-              [],
-            ),
-          },
-        ])
-        .call({}, blockNumber);
-
-    const redeemFee = BigInt(
-      this.rUSDMarketIface.decodeFunctionResult(
-        'fTokenRedeemFeeRatio',
-        data.returnData[0],
-      )[0],
-    );
-    const weETHPrice = BigInt(
-      this.weETHOracleIface.decodeFunctionResult(
-        'latestAnswer',
-        data.returnData[1],
-      )[0],
-    );
-    await Promise.all([
-      this.fxProtocolRusdPool.initialize(blockNumber, {
-        state: {
-          nav: 1000000000000000000n,
-          redeemFee,
-          weETHPrice,
-        },
-      }),
-    ]);
-  }
-
-  getConfig() {
-    return this.config;
-  }
-
-  is_weETH(token: string) {
-    return token.toLowerCase() === this.config.weETHAddress.toLowerCase();
-  }
-
-  is_rUSD(token: string) {
-    return token.toLowerCase() === this.config.rUSDAddress.toLowerCase();
-  }
-
-  is_rUSD_swap_token(srcToken: string, destToken: string) {
-    return (
-      (this.is_weETH(srcToken) && this.is_rUSD(destToken)) ||
-      (this.is_rUSD(srcToken) && this.is_weETH(destToken))
-    );
-  }
-  // Returns the list of contract adapters (name and index)
-  // for a buy/sell. Return null if there are no adapters.
-  getAdapters() {
-    return null;
-  }
-
-  async getPoolIdentifiers(
-    srcToken: Token,
-    destToken: Token,
-    side: SwapSide,
-    blockNumber: number,
-  ): Promise<string[]> {
-    if (!this.is_rUSD_swap_token(srcToken.address, destToken.address)) {
-      return [];
-    }
-    return [`${this.dexKey}_${this.config.rUSDAddress}`];
-  }
-
-  async getPricesVolume(
-    srcToken: Token,
-    destToken: Token,
-    amounts: bigint[],
-    side: SwapSide,
-    blockNumber: number,
-    limitPools?: string[],
-  ): Promise<null | ExchangePrices<FxProtocolData>> {
-    if (side == SwapSide.BUY) {
-      // note: BUY is not supported
-      return null;
-    }
-
-    const isRUSDSwapToken = this.is_rUSD_swap_token(
-      srcToken.address,
-      destToken.address,
-    );
-    if (!isRUSDSwapToken) {
-      return null;
-    }
-    const pool = this.fxProtocolRusdPool;
-    if (!pool.getState(blockNumber)) return null;
-
-    const is_redeem = this.is_weETH(destToken.address);
-    const unitIn = BI_POWS[18];
-    const unitOut = pool.getPrice(blockNumber, unitIn, is_redeem);
-    const amountsOut = amounts.map(_amountIn =>
-      pool.getPrice(blockNumber, _amountIn, is_redeem),
-    );
-
-    return [
-      {
-        unit: unitOut,
-        prices: amountsOut,
-        data: {},
-        poolAddresses: [this.config.rUSDAddress],
-        exchange: this.dexKey,
-        gasCost: 1000000,
-      },
-    ];
-  }
-
-  // Returns estimated gas cost of calldata for this DEX in multiSwap
-  getCalldataGasCost(
-    poolPrices: PoolPrices<FxProtocolData>,
-  ): number | number[] {
-    return CALLDATA_GAS_COST.DEX_NO_PAYLOAD;
-  }
-
-  // Encode params required by the exchange adapter
-  // V5: Used for multiSwap, buy & megaSwap
-  // V6: Not used, can be left blank
-  // Hint: abiCoder.encodeParameter() could be useful
-  getAdapterParam(
-    srcToken: string,
-    destToken: string,
-    srcAmount: string,
-    destAmount: string,
-    data: FxProtocolData,
-    side: SwapSide,
-  ): AdapterExchangeParam {
-    const payload = '0x';
-
-    return {
-      targetExchange: this.config.rUSDAddress,
-      payload,
-      networkFee: '0',
-    };
-  }
-
-  async getDexParam(
-    srcToken: Address,
-    destToken: Address,
-    srcAmount: NumberAsString,
-    destAmount: NumberAsString,
-    recipient: Address,
-    data: FxProtocolData,
-    side: SwapSide,
-  ): Promise<DexExchangeParam> {
-    const is_rUSD_src = this.is_rUSD(srcToken);
-    const is_weETH_src = this.is_weETH(srcToken);
-    const is_rUSD_dest = this.is_rUSD(destToken);
-    const is_weETH_dest = this.is_weETH(destToken);
-
-    if (is_weETH_src && is_rUSD_dest) {
-      const exchangeData = this.fxUSDIface.encodeFunctionData('mint', [
-        this.config.weETHAddress,
-        srcAmount,
-        this.dexHelper.config.data.executorsAddresses?.Executor01,
-        '0',
-      ]);
-      return {
-        needWrapNative: false,
-        dexFuncHasRecipient: false,
-        exchangeData,
-        targetExchange: this.config.rUSDAddress,
-        returnAmountPos: extractReturnAmountPosition(
-          this.fxUSDIface,
-          'mint',
-          '_amountOut',
-        ),
-      };
-    }
-    if (is_rUSD_src && is_weETH_dest) {
-      const exchangeData = this.fxUSDIface.encodeFunctionData('redeem', [
-        this.config.weETHAddress,
-        srcAmount,
-        this.dexHelper.config.data.executorsAddresses?.Executor01,
-        '0',
-      ]);
-      return {
-        needWrapNative: false,
-        dexFuncHasRecipient: false,
-        exchangeData,
-        targetExchange: this.config.rUSDAddress,
-        returnAmountPos: extractReturnAmountPosition(
-          this.fxUSDIface,
-          'redeem',
-          '_amountOut',
-        ),
-      };
-    }
-    throw new Error('LOGIC ERROR');
-  }
-
-  // Returns list of top pools based on liquidity. Max
-  // limit number pools should be returned.
-  async getTopPoolsForToken(
-    tokenAddress: Address,
-    limit: number,
-  ): Promise<PoolLiquidity[]> {
-    return [
-      {
-        exchange: this.dexKey,
-        address: this.config.rUSDAddress,
-        connectorTokens: [
-          {
-            decimals: 18,
-            address: this.config.rUSDAddress,
-          },
-        ],
-        liquidityUSD: 1000000000, // Just returning a big number so this DEX will be preferred
-      },
-    ];
-  }
-}