@paraswap/dex-lib 3.8.36 → 3.8.38

package/src/dex/index.ts

@@ -88,6 +88,7 @@ import { ConcentratorArusd } from './concentrator-arusd/concentrator-arusd';
 import { FxProtocolRusd } from './fx-protocol-rusd/fx-protocol-rusd';
 import { AaveGsm } from './aave-gsm/aave-gsm';
 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';
 
@@ -173,6 +174,7 @@ const Dexes = [
   FxProtocolRusd,
   AaveGsm,
   LitePsm,
+  UsualBond,
   StkGHO,
   SkyConverter,
 ];

package/src/dex/spark/config.ts

@@ -2,6 +2,9 @@ import { SparkParams } from './types';
 import { DexConfigMap } from '../../types';
 import { Network } from '../../constants';
 import { SwapSide } from '@paraswap/core';
+import PotAbi from '../../abi/maker-psm/pot.json';
+import SavingsUSDSAbi from '../../abi/sdai/SavingsUSDS.abi.json';
+import { Interface } from '@ethersproject/abi';
 
 export const SDaiConfig: DexConfigMap<SparkParams> = {
   Spark: {
@@ -9,6 +12,27 @@ export const SDaiConfig: DexConfigMap<SparkParams> = {
       sdaiAddress: '0x83F20F44975D03b1b09e64809B757c47f942BEeA',
       daiAddress: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
       potAddress: '0x197E90f9FAD81970bA7976f33CbD77088E5D7cf7',
+      savingsRate: {
+        symbol: 'dsr',
+        // bytes32 repr of "dsr" string
+        topic:
+          '0x6473720000000000000000000000000000000000000000000000000000000000',
+      },
+      poolInterface: new Interface(PotAbi),
+    },
+  },
+  sUSDS: {
+    [Network.MAINNET]: {
+      sdaiAddress: '0xa3931d71877C0E7a3148CB7Eb4463524FEc27fbD', // sUSDS
+      daiAddress: '0xdC035D45d973E3EC169d2276DDab16f1e407384F', // USDS
+      potAddress: '0xa3931d71877C0E7a3148CB7Eb4463524FEc27fbD', // no separate pot, sUSDS is the pot
+      savingsRate: {
+        symbol: 'ssr',
+        // bytes32 repr of "ssr" string
+        topic:
+          '0x7373720000000000000000000000000000000000000000000000000000000000',
+      },
+      poolInterface: new Interface(SavingsUSDSAbi),
     },
   },
 };

package/src/dex/spark/scripts/validate-state.ts

@@ -72,6 +72,7 @@ async function isPoolStateEqualToReal(
     dexHelper.multiContract,
     potAddress,
     new Interface(PotAbi),
+    'dsr',
     blockNumber,
   );
 

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

@@ -23,23 +23,8 @@ function testForNetwork(
   const holders = Holders[network];
 
   const sideToContractMethods = new Map([
-    [
-      SwapSide.SELL,
-      [
-        ContractMethod.simpleSwap,
-        ContractMethod.multiSwap,
-        ContractMethod.megaSwap,
-        ContractMethod.swapExactAmountIn,
-      ],
-    ],
-    [
-      SwapSide.BUY,
-      [
-        ContractMethod.simpleBuy,
-        ContractMethod.buy,
-        ContractMethod.swapExactAmountOut,
-      ],
-    ],
+    [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
   ]);
 
   describe(`${network}`, () => {
@@ -80,10 +65,9 @@ function testForNetwork(
   });
 }
 
-describe('sDAI E2E', () => {
-  const dexKey = 'Spark';
-
-  describe('Mainnet', () => {
+describe('Spark E2E', () => {
+  describe('sDai', () => {
+    const dexKey = 'Spark';
     const network = Network.MAINNET;
 
     const tokenASymbol: string = 'DAI';
@@ -101,4 +85,24 @@ describe('sDAI E2E', () => {
       tokenBAmount,
     );
   });
+
+  describe('sUSDS', () => {
+    const dexKey = 'sUSDS';
+    const network = Network.MAINNET;
+
+    const tokenASymbol: string = 'USDS';
+    const tokenBSymbol: string = 'sUSDS';
+
+    const tokenAAmount: string = '1000000000000000000';
+    const tokenBAmount: string = '1000000000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+    );
+  });
 });

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

@@ -12,41 +12,7 @@ import PotAbi from '../../abi/maker-psm/pot.json';
 import { Interface } from '@ethersproject/abi';
 import _ from 'lodash';
 
-/*
-  README
-  ======
-
-  This test script adds unit tests for SDai 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 = 'Spark';
 const network = Network.MAINNET;
 
 async function fetchPoolState(
@@ -56,7 +22,8 @@ async function fetchPoolState(
   return sdaiPool.generateState(blockNumber);
 }
 
-describe('SDai Event', function () {
+describe('SDai', function () {
+  const dexKey = 'Spark';
   const blockNumbers: { [eventName: string]: number[] } = {
     drip: [19827559, 19827524, 19827163, 19827124, 19827000, 19826892],
     // TODO: no matching logs, you have to manually call "file"
@@ -69,33 +36,81 @@ describe('SDai Event', function () {
     potAddress: SDaiConfig[dexKey][network].potAddress,
   };
 
-  describe('SDaiPool', 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 sdaiPool = new SparkSDaiEventPool(
-            dexKey,
-            `dai-sdai-pool`,
-            dexHelper,
-            addresses.potAddress,
-            new Interface(PotAbi),
-            logger,
-          );
-
-          await sdaiPool.initialize(blockNumber);
-
-          await testEventSubscriber(
-            sdaiPool,
-            sdaiPool.addressesSubscribed,
-            (_blockNumber: number) => fetchPoolState(sdaiPool, _blockNumber),
-            blockNumber,
-            `${dexKey}_${sdaiPool}`,
-            dexHelper.provider,
-          );
-        });
+  const potIface = SDaiConfig[dexKey][network].poolInterface;
+
+  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 sdaiPool = new SparkSDaiEventPool(
+          dexKey,
+          network,
+          `dai-sdai-pool`,
+          dexHelper,
+          addresses.potAddress,
+          potIface,
+          logger,
+          '0x6473720000000000000000000000000000000000000000000000000000000000',
+          'dsr',
+        );
+
+        await sdaiPool.initialize(blockNumber);
+
+        await testEventSubscriber(
+          sdaiPool,
+          sdaiPool.addressesSubscribed,
+          (_blockNumber: number) => fetchPoolState(sdaiPool, _blockNumber),
+          blockNumber,
+          `${dexKey}_${sdaiPool}`,
+          dexHelper.provider,
+        );
+      });
+    });
+  });
+});
+
+describe('sUSDS', function () {
+  const dexKey = 'sUSDS';
+  const blockNumbers: { [eventName: string]: number[] } = {
+    drip: [20812786, 20812797, 20813343, 20813668, 20814065, 20814418],
+  };
+
+  const addresses: { [contract: string]: string } = {
+    potAddress: SDaiConfig[dexKey][network].potAddress,
+  };
+
+  const potIface = SDaiConfig[dexKey][network].poolInterface;
+
+  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 sUSDSPool = new SparkSDaiEventPool(
+          dexKey,
+          network,
+          `usds-susds-pool`,
+          dexHelper,
+          addresses.potAddress,
+          potIface,
+          logger,
+          '0x7373720000000000000000000000000000000000000000000000000000000000',
+          'ssr',
+        );
+
+        await sUSDSPool.initialize(blockNumber);
+
+        await testEventSubscriber(
+          sUSDSPool,
+          sUSDSPool.addressesSubscribed,
+          (_blockNumber: number) => fetchPoolState(sUSDSPool, _blockNumber),
+          blockNumber,
+          `${dexKey}_${sUSDSPool}`,
+          dexHelper.provider,
+        );
       });
     });
   });

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

@@ -7,23 +7,25 @@ import { checkPoolPrices, checkPoolsLiquidity } from '../../../tests/utils';
 import { Tokens } from '../../../tests/constants-e2e';
 import { BI_POWS } from '../../bigint-constants';
 import { Spark } from './spark';
+import { MultiCallParams } from '../../lib/multi-wrapper';
+import { uint256ToBigInt } from '../../lib/decoders';
 
 const network = Network.MAINNET;
 
-const SDaiSymbol = 'sDAI';
-const SDaiToken = Tokens[network][SDaiSymbol];
-
-const DaiSymbol = 'DAI';
-const DaiToken = Tokens[network][DaiSymbol];
-
 const amounts = [0n, BI_POWS[18], 2000000000000000000n];
 
-const dexKey = 'Spark';
 const dexHelper = new DummyDexHelper(network);
 let blocknumber: number;
 let spark: Spark;
 
 describe('Spark', function () {
+  const dexKey = 'Spark';
+  const SDaiSymbol = 'sDAI';
+  const SDaiToken = Tokens[network][SDaiSymbol];
+
+  const DaiSymbol = 'DAI';
+  const DaiToken = Tokens[network][DaiSymbol];
+
   beforeAll(async () => {
     blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
     spark = new Spark(network, dexKey, dexHelper);
@@ -149,3 +151,284 @@ describe('Spark', function () {
     checkPoolsLiquidity(poolLiquidity, SDaiToken.address, dexKey);
   });
 });
+
+describe('sUSDS', function () {
+  const dexKey = 'sUSDS';
+  const SDaiSymbol = 'sUSDS';
+  const SDaiToken = Tokens[network][SDaiSymbol];
+
+  const DaiSymbol = 'USDS';
+  const DaiToken = Tokens[network][DaiSymbol];
+
+  beforeAll(async () => {
+    blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+    spark = new Spark(network, dexKey, dexHelper);
+    if (spark.initializePricing) {
+      await spark.initializePricing(blocknumber);
+    }
+  });
+
+  it('getPoolIdentifiers and getPricesVolume USDS -> sUSDS SELL', async function () {
+    const pools = await spark.getPoolIdentifiers(
+      DaiToken,
+      SDaiToken,
+      SwapSide.SELL,
+      blocknumber,
+    );
+    console.log(`${DaiSymbol} <> ${SDaiSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await spark.getPricesVolume(
+      DaiToken,
+      SDaiToken,
+      amounts,
+      SwapSide.SELL,
+      blocknumber,
+      pools,
+    );
+    console.log(`${DaiSymbol} <> ${SDaiSymbol} Pool Prices: `, poolPrices);
+
+    const onChainPrices = await Promise.all(
+      amounts.map(async amount => {
+        const callData: MultiCallParams<bigint>[] = [
+          {
+            target: '0xa3931d71877C0E7a3148CB7Eb4463524FEc27fbD',
+            callData: spark.abiInterface.encodeFunctionData('previewDeposit', [
+              amount,
+            ]),
+            decodeFunction: uint256ToBigInt,
+          },
+        ];
+
+        const results = await spark.dexHelper.multiWrapper.aggregate<bigint>(
+          callData,
+          blocknumber,
+        );
+        return results[0];
+      }),
+    );
+
+    console.log('On-chain price:', onChainPrices);
+
+    const chiCalldata: MultiCallParams<bigint>[] = [
+      {
+        target: '0xa3931d71877C0E7a3148CB7Eb4463524FEc27fbD',
+        callData: spark.abiInterface.encodeFunctionData('chi', []),
+        decodeFunction: uint256ToBigInt,
+      },
+    ];
+
+    const results = await spark.dexHelper.multiWrapper.aggregate<bigint>(
+      chiCalldata,
+      blocknumber,
+    );
+    console.log(`ON_CHAIN_CHI at block=${blocknumber}`, results[0]);
+
+    expect(poolPrices).not.toBeNull();
+    expect(poolPrices?.[0].prices).toEqual(onChainPrices);
+    checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume sUSDS -> USDS SELL', async function () {
+    const pools = await spark.getPoolIdentifiers(
+      SDaiToken,
+      DaiToken,
+      SwapSide.SELL,
+      blocknumber,
+    );
+    console.log(`${SDaiSymbol} <> ${DaiSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await spark.getPricesVolume(
+      SDaiToken,
+      DaiToken,
+      amounts,
+      SwapSide.SELL,
+      blocknumber,
+      pools,
+    );
+    console.log(`${SDaiSymbol} <> ${DaiSymbol} Pool Prices: `, poolPrices);
+
+    const onChainPrices = await Promise.all(
+      amounts.map(async amount => {
+        const callData: MultiCallParams<bigint>[] = [
+          {
+            target: '0xa3931d71877C0E7a3148CB7Eb4463524FEc27fbD',
+            callData: spark.abiInterface.encodeFunctionData('previewRedeem', [
+              amount,
+            ]),
+            decodeFunction: uint256ToBigInt,
+          },
+        ];
+
+        const results = await spark.dexHelper.multiWrapper.aggregate<bigint>(
+          callData,
+          blocknumber,
+        );
+        return results[0];
+      }),
+    );
+
+    console.log('On-chain price:', onChainPrices);
+
+    const chiCalldata: MultiCallParams<bigint>[] = [
+      {
+        target: '0xa3931d71877C0E7a3148CB7Eb4463524FEc27fbD',
+        callData: spark.abiInterface.encodeFunctionData('chi', []),
+        decodeFunction: uint256ToBigInt,
+      },
+    ];
+
+    const results = await spark.dexHelper.multiWrapper.aggregate<bigint>(
+      chiCalldata,
+      blocknumber,
+    );
+    console.log('ON_CHAIN_CHI:', results[0]);
+
+    expect(poolPrices).not.toBeNull();
+    expect(poolPrices?.[0].prices).toEqual(onChainPrices);
+    checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume USDS -> sUSDS BUY', async function () {
+    const pools = await spark.getPoolIdentifiers(
+      DaiToken,
+      SDaiToken,
+      SwapSide.BUY,
+      blocknumber,
+    );
+    console.log(`${DaiSymbol} <> ${SDaiSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await spark.getPricesVolume(
+      DaiToken,
+      SDaiToken,
+      amounts,
+      SwapSide.BUY,
+      blocknumber,
+      pools,
+    );
+    console.log(`${DaiSymbol} <> ${SDaiSymbol} Pool Prices: `, poolPrices);
+
+    const onChainPrices = await Promise.all(
+      amounts.map(async amount => {
+        const callData: MultiCallParams<bigint>[] = [
+          {
+            target: '0xa3931d71877C0E7a3148CB7Eb4463524FEc27fbD',
+            callData: spark.abiInterface.encodeFunctionData('previewMint', [
+              amount,
+            ]),
+            decodeFunction: uint256ToBigInt,
+          },
+        ];
+
+        const results = await spark.dexHelper.multiWrapper.aggregate<bigint>(
+          callData,
+          blocknumber,
+        );
+        return results[0];
+      }),
+    );
+
+    console.log('On-chain price:', onChainPrices);
+
+    const chiCalldata: MultiCallParams<bigint>[] = [
+      {
+        target: '0xa3931d71877C0E7a3148CB7Eb4463524FEc27fbD',
+        callData: spark.abiInterface.encodeFunctionData('chi', []),
+        decodeFunction: uint256ToBigInt,
+      },
+    ];
+
+    const results = await spark.dexHelper.multiWrapper.aggregate<bigint>(
+      chiCalldata,
+      blocknumber,
+    );
+    console.log('ON_CHAIN_CHI:', results[0]);
+    expect(poolPrices).not.toBeNull();
+    expect(poolPrices?.[0].prices).toEqual(onChainPrices);
+    checkPoolPrices(poolPrices!, amounts, SwapSide.BUY, dexKey);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume sUSDS -> USDS BUY', async function () {
+    const pools = await spark.getPoolIdentifiers(
+      SDaiToken,
+      DaiToken,
+      SwapSide.BUY,
+      blocknumber,
+    );
+    console.log(`${SDaiSymbol} <> ${DaiSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await spark.getPricesVolume(
+      SDaiToken,
+      DaiToken,
+      amounts,
+      SwapSide.BUY,
+      blocknumber,
+      pools,
+    );
+    console.log(`${SDaiSymbol} <> ${DaiSymbol} Pool Prices: `, poolPrices);
+
+    const onChainPrices = await Promise.all(
+      amounts.map(async amount => {
+        const callData: MultiCallParams<bigint>[] = [
+          {
+            target: '0xa3931d71877C0E7a3148CB7Eb4463524FEc27fbD',
+            callData: spark.abiInterface.encodeFunctionData('previewWithdraw', [
+              amount,
+            ]),
+            decodeFunction: uint256ToBigInt,
+          },
+        ];
+
+        const results = await spark.dexHelper.multiWrapper.aggregate<bigint>(
+          callData,
+          blocknumber,
+        );
+        return results[0];
+      }),
+    );
+
+    console.log('On-chain price:', onChainPrices);
+
+    const chiCalldata: MultiCallParams<bigint>[] = [
+      {
+        target: '0xa3931d71877C0E7a3148CB7Eb4463524FEc27fbD',
+        callData: spark.abiInterface.encodeFunctionData('chi', []),
+        decodeFunction: uint256ToBigInt,
+      },
+    ];
+
+    const results = await spark.dexHelper.multiWrapper.aggregate<bigint>(
+      chiCalldata,
+      blocknumber,
+    );
+    console.log('ON_CHAIN_CHI:', results[0]);
+
+    expect(poolPrices).not.toBeNull();
+    expect(poolPrices?.[0].prices).toEqual(onChainPrices);
+    checkPoolPrices(poolPrices!, amounts, SwapSide.BUY, dexKey);
+  });
+
+  it('USDS getTopPoolsForToken', async function () {
+    const poolLiquidity = await spark.getTopPoolsForToken(DaiToken.address, 10);
+    console.log(`${DaiSymbol} Top Pools:`, poolLiquidity);
+
+    checkPoolsLiquidity(poolLiquidity, DaiToken.address, dexKey);
+  });
+
+  it('sUSDS getTopPoolsForToken', async function () {
+    const poolLiquidity = await spark.getTopPoolsForToken(
+      SDaiToken.address,
+      10,
+    );
+    console.log(`${SDaiSymbol} Top Pools:`, poolLiquidity);
+
+    checkPoolsLiquidity(poolLiquidity, SDaiToken.address, dexKey);
+  });
+});

package/src/dex/spark/spark-sdai-pool.ts

@@ -7,8 +7,10 @@ import type { AsyncOrSync, DeepReadonly } from 'ts-essentials';
 import type { Address, BlockHeader, Log, Logger } from '../../types';
 import type { SparkSDaiPoolState } from './types';
 import { getOnChainState } from './utils';
+import { SDaiConfig } from './config';
+import { Network } from '../../constants';
 
-const RAY = BI_POWS[27];
+export const RAY = BI_POWS[27];
 const ZERO = BigInt(0);
 const TWO = BigInt(2);
 const HALF = RAY / TWO;
@@ -17,10 +19,6 @@ const HALF = RAY / TWO;
 const FILE_TOPICHASH = `0x29ae811400000000000000000000000000000000000000000000000000000000`;
 // function drip()
 const DRIP_TOPICHASH = `0x9f678cca00000000000000000000000000000000000000000000000000000000`;
-// function cage()
-const CAGE_TOPICHASH = `0x6924500900000000000000000000000000000000000000000000000000000000`;
-// bytes32 repr of "dsr" string
-const DSR_TOPIC = `0x6473720000000000000000000000000000000000000000000000000000000000`;
 
 const rpow = (x: bigint, n: bigint): bigint => {
   if (!x && !n) return RAY;
@@ -38,7 +36,10 @@ const rpow = (x: bigint, n: bigint): bigint => {
   return z;
 };
 
-const calcChi = (state: SparkSDaiPoolState, currentTimestamp?: number) => {
+export const calcChi = (
+  state: SparkSDaiPoolState,
+  currentTimestamp?: number,
+) => {
   currentTimestamp ||= Math.floor(Date.now() / 1000);
   if (!state.live) return RAY;
 
@@ -54,11 +55,14 @@ const calcChi = (state: SparkSDaiPoolState, currentTimestamp?: number) => {
 export class SparkSDaiEventPool extends StatefulEventSubscriber<SparkSDaiPoolState> {
   constructor(
     parentName: string,
+    network: Network,
     poolName: string,
     protected dexHelper: IDexHelper,
     private potAddress: Address,
     private potInterface: Interface,
     logger: Logger,
+    private savingsRateTopic: string,
+    private savingsRateSymbol: 'ssr' | 'dsr',
   ) {
     super(parentName, poolName, dexHelper, logger);
     this.addressesSubscribed = [potAddress];
@@ -69,7 +73,10 @@ export class SparkSDaiEventPool extends StatefulEventSubscriber<SparkSDaiPoolSta
     log: Readonly<Log>,
     blockHeader: Readonly<BlockHeader>,
   ): AsyncOrSync<DeepReadonly<SparkSDaiPoolState> | null> {
-    if (log.topics[0] === FILE_TOPICHASH && log.topics[2] === DSR_TOPIC) {
+    if (
+      log.topics[0] === FILE_TOPICHASH &&
+      log.topics[2] === this.savingsRateTopic
+    ) {
       return {
         ...state,
         dsr: BigInt(log.topics[3]).toString(),
@@ -94,21 +101,17 @@ export class SparkSDaiEventPool extends StatefulEventSubscriber<SparkSDaiPoolSta
       this.dexHelper.multiContract,
       this.potAddress,
       this.potInterface,
+      this.savingsRateSymbol,
       blockNumber,
     );
   }
 
-  convertToSDai(daiAmount: bigint, blockNumber: number): bigint {
-    const state = this.getState(blockNumber);
-    if (!state) throw new Error(`SDai state at ${blockNumber} does not exists`);
-
-    return (daiAmount * RAY) / calcChi(state);
-  }
-
-  convertToDai(sdaiAmount: bigint, blockNumber: number): bigint {
-    const state = this.getState(blockNumber);
-    if (!state) throw new Error(`SDai state at ${blockNumber} does not exists`);
-
-    return (sdaiAmount * calcChi(state)) / RAY;
+  async getOrGenerateState(blockNumber: number): Promise<SparkSDaiPoolState> {
+    let state = this.getState(blockNumber);
+    if (!state) {
+      state = await this.generateState(blockNumber);
+      this.setState(state, blockNumber);
+    }
+    return state;
   }
 }