@paraswap/dex-lib 3.11.8-stader.3 → 3.11.8

package/src/dex/stader/config.ts

@@ -1,13 +0,0 @@
-import { DexParams } from './types';
-import { DexConfigMap } from '../../types';
-import { Network, SwapSide } from '../../constants';
-
-export const StaderConfig: DexConfigMap<DexParams> = {
-  Stader: {
-    [Network.MAINNET]: {
-      ETHx: '0xA35b1B31Ce002FBF2058D22F30f95D405200A15b',
-      SSPM: '0xcf5EA1b38380f6aF39068375516Daf40Ed70D299',
-      StaderOracle: '0xF64bAe65f6f2a5277571143A24FaaFDFC0C2a737',
-    },
-  },
-};

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

@@ -1,74 +0,0 @@
-import dotenv from 'dotenv';
-dotenv.config();
-
-import { testE2E } from '../../../tests/utils-e2e';
-import { Tokens, Holders } from '../../../tests/constants-e2e';
-import { ContractMethod, Network, SwapSide } from '../../constants';
-import { StaticJsonRpcProvider } from '@ethersproject/providers';
-import { generateConfig } from '../../config';
-
-describe('ETHx', () => {
-  const network = Network.MAINNET;
-  const tokens = Tokens[network];
-  const holders = Holders[network];
-  const provider = new StaticJsonRpcProvider(
-    generateConfig(network).privateHttpProvider,
-    network,
-  );
-  const dexKey = 'Stader';
-
-  const sideToContractMethods = new Map([
-    [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
-  ]);
-
-  const pairs: { name: string; sellAmount: string; buyAmount: string }[][] = [
-    [
-      {
-        name: 'ETH',
-        sellAmount: '1000000000000000000',
-        buyAmount: '1000000000000000000',
-      },
-      {
-        name: 'ETHx',
-        sellAmount: '1000000000000000000',
-        buyAmount: '1000000000000000000',
-      },
-    ],
-    [
-      {
-        name: 'WETH',
-        sellAmount: '1000000000000000000',
-        buyAmount: '1000000000000000000',
-      },
-      {
-        name: 'ETHx',
-        sellAmount: '1000000000000000000',
-        buyAmount: '1000000000000000000',
-      },
-    ],
-  ];
-
-  sideToContractMethods.forEach((contractMethods, side) =>
-    describe(`${side}`, () => {
-      contractMethods.forEach((contractMethod: ContractMethod) => {
-        pairs.forEach(pair => {
-          describe(`${contractMethod}`, () => {
-            it(`${pair[0].name} -> ${pair[1].name}`, async () => {
-              await testE2E(
-                tokens[pair[0].name],
-                tokens[pair[1].name],
-                holders[pair[0].name],
-                side === SwapSide.SELL ? pair[0].sellAmount : pair[0].buyAmount,
-                side,
-                dexKey,
-                contractMethod,
-                network,
-                provider,
-              );
-            });
-          });
-        });
-      });
-    }),
-  );
-});

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

@@ -1,64 +0,0 @@
-/* eslint-disable no-console */
-import dotenv from 'dotenv';
-dotenv.config();
-
-import { ETHxEventPool } from './stader-pool';
-import { Network } from '../../constants';
-import { DummyDexHelper } from '../../dex-helper/index';
-import { testEventSubscriber } from '../../../tests/utils-events';
-import { ETHxPoolState } from './types';
-import { Interface, JsonFragment } from '@ethersproject/abi';
-import { StaderConfig } from './config';
-import StadeOracleAbi from '../../abi/StaderOracle.json';
-
-jest.setTimeout(50 * 1000);
-
-async function fetchETHxPoolState(
-  staderPools: ETHxEventPool,
-  blockNumber: number,
-): Promise<ETHxPoolState> {
-  return staderPools.generateState(blockNumber);
-}
-
-describe('Stader EventPool Mainnet', function () {
-  const dexKey = 'Stader';
-  const network = Network.MAINNET;
-  const dexHelper = new DummyDexHelper(network);
-  const logger = dexHelper.getLogger(dexKey);
-  let staderPool: ETHxEventPool;
-
-  const blockNumbers: { [eventName: string]: number[] } = {
-    ExchangeRateUpdated: [
-      21341230, 21334070, 21326910, 21319802, 21312600, 21305433, 21291465,
-      21276861,
-    ],
-  };
-
-  beforeEach(async () => {
-    staderPool = new ETHxEventPool(
-      dexKey,
-      dexHelper,
-      StaderConfig[dexKey][network].StaderOracle.toLowerCase(),
-      new Interface(StadeOracleAbi as JsonFragment[]),
-      logger,
-    );
-  });
-
-  Object.keys(blockNumbers).forEach((event: string) => {
-    blockNumbers[event].forEach((blockNumber: number) => {
-      it(`State after ${blockNumber}`, async function () {
-        await testEventSubscriber(
-          staderPool,
-          staderPool.addressesSubscribed,
-          (_blockNumber: number) =>
-            fetchETHxPoolState(staderPool, _blockNumber),
-          blockNumber,
-          `${dexKey}_${StaderConfig[dexKey][
-            network
-          ].StaderOracle.toLowerCase()}`,
-          dexHelper.provider,
-        );
-      });
-    });
-  });
-});

package/src/dex/stader/stader-integration.test.ts

@@ -1,210 +0,0 @@
-/* eslint-disable no-console */
-import dotenv from 'dotenv';
-dotenv.config();
-
-import { DummyDexHelper } from '../../dex-helper/index';
-import { Network, SwapSide } from '../../constants';
-import { BI_POWS } from '../../bigint-constants';
-import { Stader } from './stader';
-import { checkPoolPrices, checkPoolsLiquidity } from '../../../tests/utils';
-import { Tokens } from '../../../tests/constants-e2e';
-import { Interface, Result } from '@ethersproject/abi';
-import SSPMABI from '../../abi/SSPM.json';
-
-function getReaderCalldata(
-  exchangeAddress: string,
-  readerIface: Interface,
-  poolAddress: string,
-  amounts: bigint[],
-  funcName: string,
-) {
-  return amounts.map(amount => ({
-    target: exchangeAddress,
-    callData: readerIface.encodeFunctionData(funcName, [amount]),
-  }));
-}
-
-function decodeReaderResult(
-  results: Result,
-  readerIface: Interface,
-  funcName: string,
-) {
-  return results.map(result => {
-    return BigInt(result);
-  });
-}
-
-async function checkOnChainPricing(
-  stader: Stader,
-  funcName: string,
-  poolAddress: string,
-  blockNumber: number,
-  prices: bigint[],
-  amounts: bigint[],
-  dexHelper: DummyDexHelper,
-  srcToken: string,
-) {
-  const readerIface = new Interface(SSPMABI);
-  const SSPMAddress = stader.SSPM_Address;
-
-  const readerCallData = getReaderCalldata(
-    SSPMAddress,
-    readerIface,
-    poolAddress,
-    amounts.slice(1),
-    funcName,
-  );
-
-  const readerResult = (
-    await dexHelper.multiContract.methods
-      .aggregate(readerCallData)
-      .call({}, blockNumber)
-  ).returnData;
-
-  const expectedPrices = [0n].concat(
-    decodeReaderResult(readerResult, readerIface, funcName),
-  );
-
-  expect(prices).toEqual(expectedPrices);
-}
-
-describe('Stader', function () {
-  const dexKey = 'Stader';
-  let blockNumber: number;
-  let stader: Stader;
-
-  describe('Mainnet', () => {
-    const network = Network.MAINNET;
-    const dexHelper = new DummyDexHelper(network);
-
-    const tokens = Tokens[network];
-
-    beforeAll(async () => {
-      blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
-      stader = new Stader(network, dexKey, dexHelper);
-      if (stader.initializePricing) {
-        await stader.initializePricing(blockNumber);
-      }
-    });
-
-    it('getPoolIdentifiers and getPricesVolume ETH -> ETHx SELL', async () => {
-      const srcTokenSymbol = 'ETH';
-      const destTokenSymbol = 'ETHx';
-
-      const amountsForSell = [
-        0n,
-        1n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        2n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        3n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        4n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        5n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        6n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        7n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        8n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        9n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        10n * BI_POWS[tokens[srcTokenSymbol].decimals],
-      ];
-
-      const pools = await stader.getPoolIdentifiers(
-        tokens[srcTokenSymbol],
-        tokens[destTokenSymbol],
-        SwapSide.SELL,
-        blockNumber,
-      );
-      console.log(
-        `${srcTokenSymbol} <> ${destTokenSymbol} Pool Identifiers: `,
-        pools,
-      );
-
-      expect(pools.length).toBeGreaterThan(0);
-
-      const poolPrices = await stader.getPricesVolume(
-        tokens[srcTokenSymbol],
-        tokens[destTokenSymbol],
-        amountsForSell,
-        SwapSide.SELL,
-        blockNumber,
-        pools,
-      );
-      console.log(
-        `${srcTokenSymbol} <> ${destTokenSymbol} Pool Prices: `,
-        poolPrices,
-      );
-
-      expect(poolPrices).not.toBeNull();
-      checkPoolPrices(poolPrices!, amountsForSell, SwapSide.SELL, dexKey);
-
-      // Check if onchain pricing equals to calculated ones
-      await checkOnChainPricing(
-        stader,
-        'previewDeposit',
-        poolPrices![0].poolAddresses![0],
-        blockNumber,
-        poolPrices![0].prices,
-        amountsForSell,
-        dexHelper,
-        tokens[srcTokenSymbol].address,
-      );
-    });
-
-    it('getPoolIdentifiers and getPricesVolume WETH -> ETHx SELL', async () => {
-      const srcTokenSymbol = 'WETH';
-      const destTokenSymbol = 'ETHx';
-
-      const amountsForSell = [
-        0n,
-        1n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        2n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        3n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        4n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        5n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        6n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        7n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        8n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        9n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        10n * BI_POWS[tokens[srcTokenSymbol].decimals],
-      ];
-
-      const pools = await stader.getPoolIdentifiers(
-        tokens[srcTokenSymbol],
-        tokens[destTokenSymbol],
-        SwapSide.SELL,
-        blockNumber,
-      );
-      console.log(
-        `${srcTokenSymbol} <> ${destTokenSymbol} Pool Identifiers: `,
-        pools,
-      );
-
-      expect(pools.length).toBeGreaterThan(0);
-
-      const poolPrices = await stader.getPricesVolume(
-        tokens[srcTokenSymbol],
-        tokens[destTokenSymbol],
-        amountsForSell,
-        SwapSide.SELL,
-        blockNumber,
-        pools,
-      );
-      console.log(
-        `${srcTokenSymbol} <> ${destTokenSymbol} Pool Prices: `,
-        poolPrices,
-      );
-
-      expect(poolPrices).not.toBeNull();
-      checkPoolPrices(poolPrices!, amountsForSell, SwapSide.SELL, dexKey);
-
-      // Check if onchain pricing equals to calculated ones
-      await checkOnChainPricing(
-        stader,
-        'previewDeposit',
-        poolPrices![0].poolAddresses![0],
-        blockNumber,
-        poolPrices![0].prices,
-        amountsForSell,
-        dexHelper,
-        tokens[srcTokenSymbol].address,
-      );
-    });
-  });
-});

package/src/dex/stader/stader-pool.ts

@@ -1,68 +0,0 @@
-import { Interface } from '@ethersproject/abi';
-import { IDexHelper } from '../../dex-helper/idex-helper';
-import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
-import { Address, Log, Logger } from '../../types';
-import { DeepReadonly } from 'ts-essentials';
-import { catchParseLogError } from '../../utils';
-import { ETHxPoolState } from './types';
-import { getOnChainStateETHx } from './utils';
-import { BI_POWS } from '../../bigint-constants';
-
-export class ETHxEventPool extends StatefulEventSubscriber<ETHxPoolState> {
-  decoder = (log: Log) => this.poolInterface.parseLog(log);
-  DECIMALS = 1000000000000000000n;
-  addressesSubscribed: string[];
-
-  constructor(
-    parentName: string,
-    protected dexHelper: IDexHelper,
-    private poolAddress: Address,
-    private poolInterface: Interface,
-    logger: Logger,
-  ) {
-    super(parentName, 'ETHx', dexHelper, logger);
-    this.addressesSubscribed = [poolAddress];
-  }
-
-  protected processLog(
-    state: DeepReadonly<ETHxPoolState>,
-    log: Readonly<Log>,
-  ): DeepReadonly<ETHxPoolState> | null {
-    try {
-      const event = this.decoder(log);
-      if (event.name === 'ExchangeRateUpdated') {
-        const totalEth = BigInt(event.args.totalEth);
-        const ethxSupply = BigInt(event.args.ethxSupply);
-        return {
-          totalETHBalance: totalEth,
-          totalETHXSupply: ethxSupply,
-        };
-      }
-    } catch (e) {
-      catchParseLogError(e, this.logger);
-    }
-
-    return null;
-  }
-
-  async generateState(
-    blockNumber: number,
-  ): Promise<DeepReadonly<ETHxPoolState>> {
-    const state = await getOnChainStateETHx(
-      this.dexHelper.multiContract,
-      this.poolAddress,
-      this.poolInterface,
-      blockNumber,
-    );
-
-    return state;
-  }
-
-  getPrice(blockNumber: number, ethAmount: bigint): bigint {
-    const state = this.getState(blockNumber);
-    if (!state) throw new Error('Cannot compute price');
-    const { totalETHBalance, totalETHXSupply } = state;
-
-    return (ethAmount * totalETHXSupply) / totalETHBalance;
-  }
-}

package/src/dex/stader/stader.ts

@@ -1,208 +0,0 @@
-import { Interface, JsonFragment } from '@ethersproject/abi';
-import { NumberAsString, SwapSide } from '@paraswap/core';
-import {
-  AdapterExchangeParam,
-  Address,
-  DexExchangeParam,
-  ExchangePrices,
-  Logger,
-  PoolLiquidity,
-  PoolPrices,
-  Token,
-  TransferFeeParams,
-} from '../../types';
-import { IDexTxBuilder } from '../idex';
-import SSPMAbi from '../../abi/SSPM.json';
-import StadeOracleAbi from '../../abi/StaderOracle.json';
-import { ETHER_ADDRESS, Network, NULL_ADDRESS } from '../../constants';
-import { IDexHelper } from '../../dex-helper';
-import { SimpleExchange } from '../simple-exchange';
-import { BI_POWS } from '../../bigint-constants';
-import { AsyncOrSync } from 'ts-essentials';
-import { ETHxEventPool } from './stader-pool';
-import { StaderData, SSPMFunctions } from './types';
-import { StaderConfig } from './config';
-import { WethFunctions } from '../weth/types';
-import ERC20ABI from '../../abi/erc20.json';
-import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
-import _ from 'lodash';
-import { extractReturnAmountPosition } from '../../executor/utils';
-import { getDexKeysWithNetwork, isETHAddress } from '../../utils';
-
-export class Stader
-  extends SimpleExchange
-  implements IDexTxBuilder<StaderData, any>
-{
-  static dexKeys = ['Stader'];
-  ETHxAddress: string;
-  SSPM_Address: string;
-  SSPMInterface: Interface;
-  StaderOracleAddress: string;
-  StaderOracleInterface: Interface;
-  erc20Interface: Interface;
-  needWrapNative = false;
-  ethxPool: ETHxEventPool;
-  logger: Logger;
-  hasConstantPriceLargeAmounts: boolean = true;
-
-  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
-    getDexKeysWithNetwork(_.pick(StaderConfig, ['Stader']));
-
-  constructor(
-    protected network: Network,
-    dexKey: string,
-    dexHelper: IDexHelper,
-    protected config = StaderConfig[dexKey][network],
-  ) {
-    super(dexHelper, 'Stader');
-    this.network = dexHelper.config.data.network;
-    this.ETHxAddress = this.config.ETHx.toLowerCase();
-    this.SSPM_Address = this.config.SSPM.toLowerCase();
-    this.SSPMInterface = new Interface(SSPMAbi as JsonFragment[]);
-    this.StaderOracleAddress = this.config.StaderOracle.toLowerCase();
-    this.StaderOracleInterface = new Interface(
-      StadeOracleAbi as JsonFragment[],
-    );
-    this.erc20Interface = new Interface(ERC20ABI);
-    this.logger = dexHelper.getLogger(this.dexKey);
-    this.ethxPool = new ETHxEventPool(
-      this.dexKey,
-      dexHelper,
-      this.StaderOracleAddress,
-      this.StaderOracleInterface,
-      this.logger,
-    );
-  }
-
-  getAdapterParam(
-    srcToken: Address,
-    destToken: Address,
-    srcAmount: NumberAsString,
-    destAmount: NumberAsString,
-    data: StaderData,
-    side: SwapSide,
-  ): AdapterExchangeParam {
-    return {
-      targetExchange: NULL_ADDRESS,
-      payload: '0x',
-      networkFee: '0',
-    };
-  }
-
-  async initializePricing(blockNumber: number) {
-    await this.ethxPool.initialize(blockNumber);
-  }
-
-  async getPricesVolume(
-    srcToken: Token,
-    destToken: Token,
-    amountsIn: bigint[],
-    side: SwapSide,
-    blockNumber: number,
-    limitPools?: string[] | undefined,
-    transferFees?: TransferFeeParams | undefined,
-    isFirstSwap?: boolean | undefined,
-  ): Promise<ExchangePrices<StaderData> | null> {
-    if (side === SwapSide.BUY) return null;
-    if (!this.isEligibleSwap(srcToken, destToken)) return null;
-
-    const pool = this.ethxPool;
-    if (!pool.getState(blockNumber)) return null;
-
-    const unitIn = BI_POWS[18];
-    const unitOut = pool.getPrice(blockNumber, unitIn);
-    const amountsOut = amountsIn.map(amountIn =>
-      pool.getPrice(blockNumber, amountIn),
-    );
-
-    return [
-      {
-        prices: amountsOut,
-        unit: unitOut,
-        data: {},
-        exchange: this.dexKey,
-        poolIdentifier: `${ETHER_ADDRESS}_${destToken.address}`.toLowerCase(),
-        gasCost: 120_000,
-        poolAddresses: [destToken.address],
-      },
-    ];
-  }
-
-  isEligibleSwap(srcToken: Token | string, destToken: Token | string): boolean {
-    const srcTokenAddress = (
-      typeof srcToken === 'string' ? srcToken : srcToken.address
-    ).toLowerCase();
-    const destTokenAddress = (
-      typeof destToken === 'string' ? destToken : destToken.address
-    ).toLowerCase();
-
-    return (
-      (isETHAddress(srcTokenAddress) || this.isWETH(srcTokenAddress)) &&
-      destTokenAddress === this.ETHxAddress
-    );
-  }
-
-  getDexParam(
-    srcToken: Address,
-    _destToken: Address,
-    srcAmount: NumberAsString,
-    _destAmount: NumberAsString,
-    _recipient: Address,
-    _data: StaderData,
-    _side: SwapSide,
-  ): DexExchangeParam {
-    if (_side === SwapSide.BUY) throw new Error(`Buy not supported`);
-
-    const swapData = this.SSPMInterface.encodeFunctionData(
-      SSPMFunctions.deposit,
-      [_recipient],
-    );
-
-    return {
-      needWrapNative: this.needWrapNative,
-      dexFuncHasRecipient: true,
-      exchangeData: swapData,
-      targetExchange: this.config.SSPM.toLowerCase(),
-      preSwapUnwrapCalldata: this.isWETH(srcToken)
-        ? this.erc20Interface.encodeFunctionData(WethFunctions.withdraw, [
-            srcAmount,
-          ])
-        : undefined,
-      returnAmountPos:
-        _side === SwapSide.SELL
-          ? extractReturnAmountPosition(
-              this.SSPMInterface,
-              SSPMFunctions.deposit,
-            )
-          : undefined,
-    };
-  }
-
-  async getPoolIdentifiers(
-    srcToken: Token,
-    destToken: Token,
-    side: SwapSide,
-    blockNumber: number,
-  ): Promise<string[]> {
-    if (side === SwapSide.BUY) return [];
-
-    if (!this.isEligibleSwap(srcToken, destToken)) return [];
-
-    return [`${ETHER_ADDRESS}_${destToken.address}`.toLowerCase()];
-  }
-
-  getCalldataGasCost(poolPrices: PoolPrices<StaderData>): number | number[] {
-    return CALLDATA_GAS_COST.DEX_OVERHEAD + CALLDATA_GAS_COST.LENGTH_SMALL;
-  }
-
-  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
-    return null;
-  }
-
-  getTopPoolsForToken(
-    tokenAddress: string,
-    limit: number,
-  ): AsyncOrSync<PoolLiquidity[]> {
-    return [];
-  }
-}

package/src/dex/stader/types.ts

@@ -1,16 +0,0 @@
-export type ETHxPoolState = {
-  totalETHBalance: bigint;
-  totalETHXSupply: bigint;
-};
-
-export type StaderData = {};
-
-export type DexParams = {
-  ETHx: string;
-  SSPM: string;
-  StaderOracle: string;
-};
-
-export enum SSPMFunctions {
-  deposit = 'deposit',
-}

package/src/dex/stader/utils.ts

@@ -1,34 +0,0 @@
-import { Contract } from 'web3-eth-contract';
-import { ETHxPoolState } from './types';
-import { Interface, AbiCoder } from '@ethersproject/abi';
-import { BI_POWS } from '../../bigint-constants';
-
-export async function getOnChainStateETHx(
-  multiContract: Contract,
-  poolAddress: string,
-  poolInterface: Interface,
-  blockNumber: number | 'latest',
-): Promise<ETHxPoolState> {
-  const coder = new AbiCoder();
-  const data: { returnData: any[] } = await multiContract.methods
-    .aggregate([
-      {
-        target: poolAddress,
-        callData: poolInterface.encodeFunctionData('getExchangeRate', []),
-      },
-    ])
-    .call({}, blockNumber);
-
-  const decodedData = coder.decode(
-    ['uint256', 'uint256', 'uint256'],
-    data.returnData[0],
-  );
-
-  const totalETHBalance = BigInt(decodedData[1].toString());
-  const totalETHXSupply = BigInt(decodedData[2].toString());
-
-  return {
-    totalETHBalance,
-    totalETHXSupply,
-  };
-}