@paraswap/dex-lib 3.8.13 → 3.8.15

package/src/dex/concentrator-arusd/concentrator-arusd-e2e.test.ts

@@ -0,0 +1,92 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import { Tokens, Holders } 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]],
+  ]);
+
+  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('ConcentratorArusd E2E', () => {
+  const dexKey = 'ConcentratorArusd';
+  const network = Network.MAINNET;
+
+  const pairs: { name: string; amount: string; skipBuy?: boolean }[][] = [
+    [
+      {
+        name: 'rUSD',
+        amount: '1000000000000000',
+      },
+      {
+        name: 'arUSD',
+        amount: '1000000000000000000',
+      },
+    ],
+    [
+      {
+        name: 'arUSD',
+        amount: '1000000000000000000',
+      },
+      {
+        name: 'rUSD',
+        amount: '1000000000000000000',
+      },
+    ],
+  ];
+
+  pairs.forEach(pair => {
+    testForNetwork(
+      network,
+      dexKey,
+      pair[0].name,
+      pair[1].name,
+      pair[0].amount,
+      pair[1].amount,
+    );
+  });
+});

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

@@ -0,0 +1,100 @@
+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 { ConcentratorArusdState } from './types';
+import { BI_POWS } from '../../bigint-constants';
+import { getOnChainState } from './utils';
+
+export class ConcentratorArusdEvent extends StatefulEventSubscriber<ConcentratorArusdState> {
+  decoder = (log: Log) => this.poolInterface.parseLog(log);
+
+  constructor(
+    parentName: string,
+    protected dexHelper: IDexHelper,
+    private poolAddress: Address,
+    private poolInterface: Interface,
+    logger: Logger,
+  ) {
+    super(parentName, 'ConcentratorArusd', dexHelper, logger);
+    this.addressesSubscribed = [poolAddress];
+  }
+
+  protected processLog(
+    state: DeepReadonly<ConcentratorArusdState>,
+    log: Readonly<Log>,
+  ): AsyncOrSync<DeepReadonly<ConcentratorArusdState> | null> {
+    const event = this.decoder(log);
+    const _state: ConcentratorArusdState = _.cloneDeep(state);
+    if (event.name === 'Deposit') {
+      _state.totalSupply = (
+        BigInt(_state.totalSupply) + BigInt(event.args.amountSyOut)
+      ).toString();
+      _state.totalAssets = (
+        BigInt(_state.totalAssets) + BigInt(event.args.amountDeposited)
+      ).toString();
+      return _state;
+    } else if (event.name === 'Redeem') {
+      _state.totalSupply = (
+        BigInt(_state.totalSupply) - BigInt(event.args.amountSyToRedeem)
+      ).toString();
+      _state.totalAssets = (
+        BigInt(_state.totalAssets) - BigInt(event.args.amountTokenOut)
+      ).toString();
+      return _state;
+    }
+    return null;
+  }
+
+  async generateState(
+    blockNumber: number | 'latest' = 'latest',
+  ): Promise<DeepReadonly<ConcentratorArusdState>> {
+    const state = await getOnChainState(
+      this.dexHelper.multiContract,
+      this.poolAddress,
+      this.poolInterface,
+      blockNumber,
+    );
+    return state;
+  }
+
+  async getPrice(
+    blockNumber: number,
+    ethAmount: bigint,
+    is_deposit: boolean,
+  ): Promise<bigint> {
+    const state = await this.getOrGenerateState(blockNumber);
+    if (!state) throw new Error('Cannot compute price');
+    const { totalSupply, totalAssets } = state;
+    const nav = (BigInt(totalAssets) * BI_POWS[18]) / BigInt(totalSupply);
+    if (is_deposit) {
+      return BigInt((ethAmount * BI_POWS[18]) / nav);
+    }
+    return BigInt((nav * ethAmount) / BI_POWS[18]);
+  }
+
+  async getOrGenerateState(
+    blockNumber: number,
+  ): Promise<DeepReadonly<ConcentratorArusdState> | 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/concentrator-arusd/concentrator-arusd-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 { ConcentratorArusd } from './concentrator-arusd';
+
+const network = Network.MAINNET;
+
+const rUSDSymbol = 'rUSD';
+const rUSDToken = Tokens[network][rUSDSymbol];
+
+const arUSDSymbol = 'arUSD';
+const arUSDTokne = Tokens[network][arUSDSymbol];
+
+const amounts = [0n, BI_POWS[18], 2000000000000000000n];
+
+const dexKey = 'ConcentratorArusd';
+const dexHelper = new DummyDexHelper(network);
+let blocknumber: number;
+let concentratorArusd: ConcentratorArusd;
+
+describe('ConcentratorArusd', function () {
+  beforeAll(async () => {
+    blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+    concentratorArusd = new ConcentratorArusd(network, dexKey, dexHelper);
+    if (concentratorArusd.initializePricing) {
+      await concentratorArusd.initializePricing(blocknumber);
+    }
+  });
+
+  it('getPoolIdentifiers and getPricesVolume arUSD -> rUSD SELL', async function () {
+    const pools = await concentratorArusd.getPoolIdentifiers(
+      arUSDTokne,
+      rUSDToken,
+      SwapSide.SELL,
+      blocknumber,
+    );
+    console.log(`${arUSDTokne} <> ${rUSDSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await concentratorArusd.getPricesVolume(
+      arUSDTokne,
+      rUSDToken,
+      amounts,
+      SwapSide.SELL,
+      blocknumber,
+      pools,
+    );
+    console.log(`${arUSDSymbol} <> ${rUSDSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume rUSD -> arUSD SELL', async function () {
+    const pools = await concentratorArusd.getPoolIdentifiers(
+      rUSDToken,
+      arUSDTokne,
+      SwapSide.SELL,
+      blocknumber,
+    );
+    console.log(`${rUSDSymbol} <> ${arUSDSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await concentratorArusd.getPricesVolume(
+      rUSDToken,
+      arUSDTokne,
+      amounts,
+      SwapSide.SELL,
+      blocknumber,
+      pools,
+    );
+    console.log(`${rUSDSymbol} <> ${arUSDSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+  });
+
+  it('arUSD getTopPoolsForToken', async function () {
+    const poolLiquidity = await concentratorArusd.getTopPoolsForToken(
+      arUSDTokne.address,
+      10,
+    );
+    console.log(`${arUSDSymbol} Top Pools:`, poolLiquidity);
+
+    checkPoolsLiquidity(poolLiquidity, arUSDTokne.address, dexKey);
+  });
+
+  it('rUSD getTopPoolsForToken', async function () {
+    const poolLiquidity = await concentratorArusd.getTopPoolsForToken(
+      rUSDToken.address,
+      10,
+    );
+    console.log(`${rUSDSymbol} Top Pools:`, poolLiquidity);
+
+    checkPoolsLiquidity(poolLiquidity, rUSDToken.address, dexKey);
+  });
+});

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

@@ -0,0 +1,269 @@
+import {
+  Token,
+  Address,
+  ExchangePrices,
+  PoolPrices,
+  AdapterExchangeParam,
+  PoolLiquidity,
+  Logger,
+  NumberAsString,
+  DexExchangeParam,
+} from '../../types';
+import { SwapSide, Network } from '../../constants';
+import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
+import { getDexKeysWithNetwork } from '../../utils';
+import { Context, IDex } from '../../dex/idex';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { ConcentratorArusdData, DexParams } from './types';
+import { SimpleExchange } from '../simple-exchange';
+import { ConcentratorArusdConfig } from './config';
+import { Interface } from '@ethersproject/abi';
+import ArUSD_ABI from '../../abi/concentrator/arUSD.json';
+import ArUSD5115_ABI from '../../abi/concentrator/arUSD5115.json';
+import { extractReturnAmountPosition } from '../../executor/utils';
+import { BI_POWS } from '../../bigint-constants';
+import { ConcentratorArusdEvent } from './concentrator-arusd-event';
+import { getOnChainState } from './utils';
+
+export class ConcentratorArusd
+  extends SimpleExchange
+  implements IDex<ConcentratorArusdData>
+{
+  static readonly arUSDIface = new Interface(ArUSD_ABI);
+
+  protected config: DexParams;
+
+  readonly hasConstantPriceLargeAmounts = true;
+  readonly needWrapNative = true;
+
+  readonly isFeeOnTransferSupported = false;
+
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(ConcentratorArusdConfig);
+
+  arUSD5115Iface: Interface;
+  concentratorArusdEvent: ConcentratorArusdEvent;
+  logger: Logger;
+
+  constructor(
+    readonly network: Network,
+    readonly dexKey: string,
+    readonly dexHelper: IDexHelper,
+    protected adapters = {},
+  ) {
+    super(dexHelper, dexKey);
+    const config = ConcentratorArusdConfig[dexKey][network];
+    this.config = {
+      rUSDAddress: config.rUSDAddress.toLowerCase(),
+      arUSDAddress: config.arUSDAddress.toLowerCase(),
+      arUSD5115Address: config.arUSD5115Address.toLowerCase(),
+    };
+    this.arUSD5115Iface = new Interface(ArUSD5115_ABI);
+    this.logger = dexHelper.getLogger(dexKey);
+    this.concentratorArusdEvent = new ConcentratorArusdEvent(
+      this.dexKey,
+      dexHelper,
+      this.config.arUSD5115Address,
+      this.arUSD5115Iface,
+      this.logger,
+    );
+  }
+
+  async initializePricing(blockNumber: number) {
+    const poolState = await getOnChainState(
+      this.dexHelper.multiContract,
+      this.config.arUSD5115Address,
+      this.arUSD5115Iface,
+      blockNumber,
+    );
+
+    await this.concentratorArusdEvent.initialize(blockNumber, {
+      state: poolState,
+    });
+  }
+
+  is_arUSD(token: string) {
+    return token.toLowerCase() === this.config.arUSDAddress;
+  }
+
+  is_rUSD(token: string) {
+    return token.toLowerCase() === this.config.rUSDAddress;
+  }
+
+  is_arUSD_swap_token(srcToken: string, destToken: string) {
+    if (this.is_rUSD(srcToken) && this.is_arUSD(destToken)) {
+      return true;
+    }
+    if (this.is_arUSD(srcToken) && this.is_rUSD(destToken)) {
+      return true;
+    }
+    return false;
+  }
+
+  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
+    return null;
+  }
+
+  async getPoolIdentifiers(
+    srcToken: Token,
+    destToken: Token,
+    side: SwapSide,
+    blockNumber: number,
+  ): Promise<string[]> {
+    if (!this.is_arUSD_swap_token(srcToken.address, destToken.address)) {
+      return [];
+    }
+    return [`${this.dexKey}_${this.config.arUSDAddress}`];
+  }
+
+  async getPricesVolume(
+    srcToken: Token,
+    destToken: Token,
+    amounts: bigint[],
+    side: SwapSide,
+    blockNumber: number,
+    limitPools?: string[],
+  ): Promise<null | ExchangePrices<ConcentratorArusdData>> {
+    // note: BUY is not supported
+    if (side === SwapSide.BUY) return null;
+
+    const isArUSDSwapToken = this.is_arUSD_swap_token(
+      srcToken.address,
+      destToken.address,
+    );
+    if (!isArUSDSwapToken) {
+      return null;
+    }
+    const is_deposit = !!this.is_rUSD(srcToken.address);
+    const pool = this.concentratorArusdEvent;
+    const unitIn = BI_POWS[18];
+    const unitOut = await pool.getPrice(blockNumber, unitIn, is_deposit);
+    const amountsOut = await Promise.all(
+      amounts.map(async amountIn => {
+        const _newPrice = await pool.getPrice(
+          blockNumber,
+          amountIn,
+          is_deposit,
+        );
+        return _newPrice;
+      }),
+    );
+    return [
+      {
+        unit: unitOut,
+        prices: amountsOut,
+        data: {},
+        poolAddresses: [this.config.arUSDAddress],
+        exchange: this.dexKey,
+        gasCost: 1000000,
+      },
+    ];
+  }
+
+  // Returns estimated gas cost of calldata for this DEX in multiSwap
+  getCalldataGasCost(
+    poolPrices: PoolPrices<ConcentratorArusdData>,
+  ): number | number[] {
+    return CALLDATA_GAS_COST.DEX_NO_PAYLOAD;
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: ConcentratorArusdData,
+    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: ConcentratorArusdData,
+    side: SwapSide,
+    context: Context,
+    executorAddress: Address,
+  ): Promise<DexExchangeParam> {
+    const is_rUSD_src = this.is_rUSD(srcToken);
+    const is_arUSD_src = this.is_arUSD(srcToken);
+    const is_rUSD_dest = this.is_rUSD(destToken);
+    const is_arUSD_dest = this.is_arUSD(destToken);
+
+    if (is_rUSD_src && is_arUSD_dest) {
+      const exchangeData = ConcentratorArusd.arUSDIface.encodeFunctionData(
+        'deposit',
+        [srcAmount, recipient],
+      );
+      return {
+        needWrapNative: false,
+        dexFuncHasRecipient: true,
+        exchangeData,
+        targetExchange: this.config.arUSDAddress,
+        returnAmountPos: extractReturnAmountPosition(
+          ConcentratorArusd.arUSDIface,
+          'deposit',
+          'shares',
+        ),
+      };
+    }
+    if (is_arUSD_src && is_rUSD_dest) {
+      const exchangeData = ConcentratorArusd.arUSDIface.encodeFunctionData(
+        'redeem',
+        [srcAmount, recipient, executorAddress],
+      );
+      return {
+        needWrapNative: false,
+        dexFuncHasRecipient: true,
+        exchangeData,
+        targetExchange: this.config.arUSDAddress,
+        returnAmountPos: extractReturnAmountPosition(
+          ConcentratorArusd.arUSDIface,
+          'redeem',
+          'assets',
+        ),
+      };
+    }
+    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_arUSD(tokenAddress)) return [];
+
+    return [
+      {
+        exchange: this.dexKey,
+        address: this.config.arUSDAddress,
+        connectorTokens: this.is_rUSD(tokenAddress)
+          ? [
+              {
+                decimals: 18,
+                address: this.config.arUSDAddress,
+              },
+            ]
+          : [
+              {
+                decimals: 18,
+                address: this.config.rUSDAddress,
+              },
+            ],
+        liquidityUSD: 1000000000, // Just returning a big number so this DEX will be preferred
+      },
+    ];
+  }
+}

package/src/dex/concentrator-arusd/concetrator-arusd-events.test.ts

@@ -0,0 +1,97 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { ConcentratorArusdEvent } from './concentrator-arusd-event';
+import { ConcentratorArusdConfig } from './config';
+import { Network } from '../../constants';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { testEventSubscriber } from '../../../tests/utils-events';
+import ArUSD5115_ABI from '../../abi/concentrator/arUSD5115.json';
+
+import _ from 'lodash';
+import { ConcentratorArusdState } from './types';
+import { Interface } from 'ethers/lib/utils';
+import { JsonFragment } from '@ethersproject/abi';
+
+/*
+  README
+  ======
+
+  This test script adds unit tests for arUSD 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 = 'ConcentratorArusd';
+const network = Network.MAINNET;
+
+async function fetchPoolState(
+  concentratorArusdPool: ConcentratorArusdEvent,
+  blockNumber: number,
+): Promise<ConcentratorArusdState> {
+  return concentratorArusdPool.generateState(blockNumber);
+}
+
+describe('concentratorArusd Event', function () {
+  const blockNumbers: { [eventName: string]: number[] } = {
+    Deposit: [20474218, 20474012, 20472829, 20472449],
+    Redeem: [20461979, 20461979, 20461765, 20461765],
+  };
+
+  describe('concentratorArusdPool', 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 = ConcentratorArusdConfig[dexKey][network];
+
+          const concentratorArusdPool = new ConcentratorArusdEvent(
+            dexKey,
+            dexHelper,
+            config.arUSD5115Address,
+            new Interface(ArUSD5115_ABI as JsonFragment[]),
+            logger,
+          );
+
+          await concentratorArusdPool.initialize(blockNumber);
+
+          await testEventSubscriber(
+            concentratorArusdPool,
+            concentratorArusdPool.addressesSubscribed,
+            (_blockNumber: number) =>
+              fetchPoolState(concentratorArusdPool, _blockNumber),
+            blockNumber,
+            `${dexKey}_${concentratorArusdPool}`,
+            dexHelper.provider,
+          );
+        });
+      });
+    });
+  });
+});

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

@@ -0,0 +1,13 @@
+import { DexParams } from './types';
+import { DexConfigMap, AdapterMappings } from '../../types';
+import { Network, SwapSide } from '../../constants';
+
+export const ConcentratorArusdConfig: DexConfigMap<DexParams> = {
+  ConcentratorArusd: {
+    [Network.MAINNET]: {
+      rUSDAddress: '0x65D72AA8DA931F047169112fcf34f52DbaAE7D18',
+      arUSDAddress: '0x07D1718fF05a8C53C8F05aDAEd57C0d672945f9a',
+      arUSD5115Address: '0x549716F858aefF9CB845d4C78c67A7599B0Df240',
+    },
+  },
+};

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

@@ -0,0 +1,16 @@
+import { Address } from '../../types';
+
+export type ConcentratorArusdState = {
+  totalSupply: string;
+  totalAssets: string;
+};
+export type ConcentratorArusdNavState = {
+  nav: string;
+};
+export type ConcentratorArusdData = {};
+
+export type DexParams = {
+  arUSDAddress: Address;
+  rUSDAddress: Address;
+  arUSD5115Address: Address;
+};