@paraswap/dex-lib 3.11.9 → 3.11.10-stader.0

package/src/dex/index.ts

@@ -94,6 +94,7 @@ import { LitePsm } from './lite-psm/lite-psm';
 import { UsualBond } from './usual-bond/usual-bond';
 import { StkGHO } from './stkgho/stkgho';
 import { SkyConverter } from './sky-converter/sky-converter';
+import { Stader } from './stader/stader';
 
 const LegacyDexes = [
   CurveV2,
@@ -113,6 +114,7 @@ const LegacyDexes = [
 ];
 
 const Dexes = [
+  Stader,
   Bebop,
   Dexalot,
   CurveV1,

package/src/dex/stader/config.ts

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

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

@@ -0,0 +1,64 @@
+/* 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

@@ -0,0 +1,240 @@
+/* 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,
+      );
+    });
+
+    it('ETH getTopPoolsForToken', async function () {
+      const poolLiquidity = await stader.getTopPoolsForToken(
+        tokens['ETH'].address,
+        10,
+      );
+      console.log(`ETH Top Pools:`, poolLiquidity);
+
+      checkPoolsLiquidity(poolLiquidity, tokens['ETH'].address, dexKey);
+    });
+
+    it('WETH getTopPoolsForToken', async function () {
+      const poolLiquidity = await stader.getTopPoolsForToken(
+        tokens['WETH'].address,
+        10,
+      );
+      console.log(`WETH Top Pools:`, poolLiquidity);
+
+      checkPoolsLiquidity(poolLiquidity, tokens['WETH'].address, dexKey);
+    });
+
+    it('ETHx getTopPoolsForToken', async function () {
+      const poolLiquidity = await stader.getTopPoolsForToken(
+        tokens['ETHx'].address,
+        10,
+      );
+      console.log(`ETHx Top Pools:`, poolLiquidity);
+
+      checkPoolsLiquidity(poolLiquidity, tokens['ETHx'].address, dexKey);
+    });
+  });
+});

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

@@ -0,0 +1,68 @@
+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;
+  }
+}