@paraswap/dex-lib 3.8.14 → 3.8.16-oswap

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;
+  }
+}

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

@@ -0,0 +1,282 @@
+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';
+import { getOnChainState } from './utils';
+
+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 poolState = await getOnChainState(
+      this.dexHelper.multiContract,
+      this.config.rUSDWeETHMarketAddress,
+      this.rUSDMarketIface,
+      this.config.weETHOracleAddress,
+      this.weETHOracleIface,
+      blockNumber,
+    );
+
+    await this.fxProtocolRusdPool.initialize(blockNumber, {
+      state: poolState,
+    });
+  }
+
+  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>> {
+    // note: BUY is not supported
+    if (side === SwapSide.BUY) return null;
+
+    const isRUSDSwapToken = this.is_rUSD_swap_token(
+      srcToken.address,
+      destToken.address,
+    );
+    if (!isRUSDSwapToken) {
+      return null;
+    }
+    const pool = this.fxProtocolRusdPool;
+    const is_redeem = this.is_weETH(destToken.address);
+    const unitIn = BI_POWS[18];
+    const unitOut = await pool.getPrice(blockNumber, unitIn, is_redeem);
+    const amountsOut = await Promise.all(
+      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,
+        recipient,
+        '0',
+      ]);
+      return {
+        needWrapNative: false,
+        dexFuncHasRecipient: true,
+        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,
+        recipient,
+        '0',
+      ]);
+      return {
+        needWrapNative: false,
+        dexFuncHasRecipient: true,
+        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[]> {
+    if (!this.is_rUSD(tokenAddress) && !this.is_weETH(tokenAddress)) return [];
+
+    return [
+      {
+        exchange: this.dexKey,
+        address: this.config.rUSDAddress,
+        connectorTokens: this.is_weETH(tokenAddress)
+          ? [
+              {
+                decimals: 18,
+                address: this.config.rUSDAddress,
+              },
+            ]
+          : [
+              {
+                decimals: 18,
+                address: this.config.weETHAddress,
+              },
+            ],
+        liquidityUSD: 1000000000, // Just returning a big number so this DEX will be preferred
+      },
+    ];
+  }
+}

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

@@ -0,0 +1,16 @@
+import { Address } from '../../types';
+
+export type FxProtocolPoolState = {
+  nav: string;
+  redeemFee: string;
+  weETHPrice: string;
+};
+
+export type FxProtocolData = {};
+
+export type DexParams = {
+  rUSDAddress: Address;
+  weETHAddress: Address;
+  rUSDWeETHMarketAddress: Address;
+  weETHOracleAddress: Address;
+};

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

@@ -0,0 +1,47 @@
+import { Contract } from 'web3-eth-contract';
+import { FxProtocolPoolState } from './types';
+import { Interface } from '@ethersproject/abi';
+
+export async function getOnChainState(
+  multiContract: Contract,
+  marketAddress: string,
+  marketInterface: Interface,
+  ethWeETHOracleAddress: string,
+  ethWeETHOracleIface: Interface,
+  blockNumber: number | 'latest',
+): Promise<FxProtocolPoolState> {
+  const data: { returnData: any[] } = await multiContract.methods
+    .aggregate([
+      {
+        target: marketAddress,
+        callData: marketInterface.encodeFunctionData(
+          'fTokenRedeemFeeRatio',
+          [],
+        ),
+      },
+      {
+        target: ethWeETHOracleAddress,
+        callData: ethWeETHOracleIface.encodeFunctionData('latestAnswer', []),
+      },
+    ])
+    .call({}, blockNumber);
+
+  const redeemFee = BigInt(
+    marketInterface.decodeFunctionResult(
+      'fTokenRedeemFeeRatio',
+      data.returnData[0],
+    )[0],
+  ).toString();
+  const weETHPrice = BigInt(
+    ethWeETHOracleIface.decodeFunctionResult(
+      'latestAnswer',
+      data.returnData[1],
+    )[0],
+  ).toString();
+
+  return {
+    nav: '1000000000000000000',
+    redeemFee,
+    weETHPrice,
+  };
+}