@paraswap/dex-lib 3.8.37 → 3.8.39-bebop

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

package/src/dex/spark/spark.ts

@@ -1,6 +1,11 @@
 import { SimpleExchange } from '../simple-exchange';
 import { Context, IDex } from '../idex';
-import { SparkParams, SparkData, SparkSDaiFunctions } from './types';
+import {
+  SparkParams,
+  SparkData,
+  SparkSDaiFunctions,
+  SparkSDaiPoolState,
+} from './types';
 import { Network, SwapSide } from '../../constants';
 import { getDexKeysWithNetwork } from '../../utils';
 import { Adapters, SDaiConfig } from './config';
@@ -21,7 +26,7 @@ import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
 import PotAbi from '../../abi/maker-psm/pot.json';
 import SavingsDaiAbi from '../../abi/sdai/SavingsDai.abi.json';
 import { Interface } from 'ethers/lib/utils';
-import { SparkSDaiEventPool } from './spark-sdai-pool';
+import { calcChi, RAY, SparkSDaiEventPool } from './spark-sdai-pool';
 import { BI_POWS } from '../../bigint-constants';
 import { SDAI_DEPOSIT_GAS_COST, SDAI_REDEEM_GAS_COST } from './constants';
 import { extractReturnAmountPosition } from '../../executor/utils';
@@ -42,25 +47,29 @@ export class Spark
   constructor(
     protected network: Network,
     dexKey: string,
-    protected dexHelper: IDexHelper,
+    readonly dexHelper: IDexHelper,
 
     readonly daiAddress: string = SDaiConfig[dexKey][network].daiAddress,
     readonly sdaiAddress: string = SDaiConfig[dexKey][network].sdaiAddress,
     readonly potAddress: string = SDaiConfig[dexKey][network].potAddress,
+    readonly abiInterface: Interface = SDaiConfig[dexKey][network]
+      .poolInterface,
 
     protected adapters = Adapters[network] || {},
     protected sdaiInterface = new Interface(SavingsDaiAbi),
-    protected potInterface = new Interface(PotAbi),
   ) {
     super(dexHelper, dexKey);
     this.logger = dexHelper.getLogger(dexKey);
     this.eventPool = new SparkSDaiEventPool(
       this.dexKey,
+      this.network,
       `${this.daiAddress}_${this.sdaiAddress}`,
       dexHelper,
       this.potAddress,
-      this.potInterface,
+      this.abiInterface,
       this.logger,
+      SDaiConfig[dexKey][network].savingsRate.topic,
+      SDaiConfig[dexKey][network].savingsRate.symbol,
     );
   }
 
@@ -107,41 +116,38 @@ export class Spark
     limitPools?: string[],
   ): Promise<null | ExchangePrices<SparkData>> {
     if (!this.isAppropriatePair(srcToken, destToken)) return null;
-    if (!this.eventPool.getState(blockNumber)) return null;
+    const state = this.eventPool.getState(blockNumber);
+    if (!state) return null;
+
+    const isSrcAsset = this.isDai(srcToken.address);
+
+    let calcFunction: Function;
 
     if (side === SwapSide.SELL) {
-      const calcSellFn = (blockNumber: number, amountIn: bigint) =>
-        this.isDai(srcToken.address)
-          ? this.eventPool.convertToSDai(amountIn, blockNumber)
-          : this.eventPool.convertToDai(amountIn, blockNumber);
-
-      return [
-        {
-          prices: amounts.map(amount => calcSellFn(blockNumber, amount)),
-          unit: calcSellFn(blockNumber, BI_POWS[18]),
-          gasCost: SDAI_DEPOSIT_GAS_COST,
-          exchange: this.dexKey,
-          data: { exchange: `${this.sdaiAddress}` },
-          poolAddresses: [`${this.sdaiAddress}`],
-        },
-      ];
+      if (isSrcAsset) {
+        calcFunction = this.previewDeposit.bind(this);
+      } else {
+        calcFunction = this.previewRedeem.bind(this);
+      }
     } else {
-      const calcBuyFn = (blockNumber: number, amountIn: bigint) =>
-        this.isDai(srcToken.address)
-          ? this.eventPool.convertToDai(amountIn, blockNumber)
-          : this.eventPool.convertToSDai(amountIn, blockNumber);
-
-      return [
-        {
-          prices: amounts.map(amount => calcBuyFn(blockNumber, amount)),
-          unit: calcBuyFn(blockNumber, BI_POWS[18]),
-          gasCost: SDAI_REDEEM_GAS_COST,
-          exchange: this.dexKey,
-          data: { exchange: `${this.sdaiAddress}` },
-          poolAddresses: [`${this.sdaiAddress}`],
-        },
-      ];
+      if (isSrcAsset) {
+        calcFunction = this.previewMint.bind(this);
+      } else {
+        calcFunction = this.previewWithdraw.bind(this);
+      }
     }
+
+    return [
+      {
+        // cannot produce 1:1 price without making an rpc call for block.timestamp and using it for price calculation in `calcChi` function
+        prices: amounts.map(amount => calcFunction(amount, state)),
+        unit: BI_POWS[18],
+        gasCost: SDAI_DEPOSIT_GAS_COST,
+        exchange: this.dexKey,
+        data: { exchange: `${this.sdaiAddress}` },
+        poolAddresses: [`${this.sdaiAddress}`],
+      },
+    ];
   }
 
   // Returns estimated gas cost of calldata for this DEX in multiSwap
@@ -286,4 +292,24 @@ export class Spark
       networkFee: '0',
     };
   }
+
+  previewRedeem(shares: bigint, state: SparkSDaiPoolState) {
+    return (shares * calcChi(state)) / RAY;
+  }
+
+  previewMint(shares: bigint, state: SparkSDaiPoolState) {
+    return this.divUp(shares * calcChi(state), RAY);
+  }
+
+  previewWithdraw(assets: bigint, state: SparkSDaiPoolState) {
+    return this.divUp(assets * RAY, calcChi(state));
+  }
+
+  previewDeposit(assets: bigint, state: SparkSDaiPoolState) {
+    return (assets * RAY) / calcChi(state);
+  }
+
+  divUp(x: bigint, y: bigint): bigint {
+    return x !== 0n ? (x - 1n) / y + 1n : 0n;
+  }
 }

package/src/dex/spark/types.ts

@@ -1,3 +1,4 @@
+import { Interface } from '@ethersproject/abi';
 import { Address } from '../../types';
 
 export type SparkData = { exchange: Address };
@@ -6,6 +7,11 @@ export type SparkParams = {
   sdaiAddress: Address;
   daiAddress: Address;
   potAddress: Address;
+  savingsRate: {
+    symbol: 'dsr' | 'ssr';
+    topic: string;
+  };
+  poolInterface: Interface;
 };
 
 export enum SparkSDaiFunctions {

package/src/dex/spark/utils.ts

@@ -4,34 +4,60 @@ import { Interface, AbiCoder } from '@ethersproject/abi';
 
 const coder = new AbiCoder();
 
-// - `dsr`: the Dai Savings Rate
+// - `dsr` || `ssr`: the Dai Savings Rate or USDS savings rate
 // - `chi`: the Rate Accumulator
 // - `rho`: time of last drip
 export async function getOnChainState(
   multiContract: Contract,
   potAddress: string,
   potInterface: Interface,
+  savingsRateSymbol: 'dsr' | 'ssr',
   blockNumber: number | 'latest',
 ): Promise<SparkSDaiPoolState> {
+  if (savingsRateSymbol === 'dsr') {
+    return getOnChainStateSDAI(
+      multiContract,
+      potAddress,
+      potInterface,
+      blockNumber,
+    );
+  }
+
+  return getOnChainStateUSDS(
+    multiContract,
+    potAddress,
+    potInterface,
+    blockNumber,
+  );
+}
+
+export async function getOnChainStateSDAI(
+  multiContract: Contract,
+  potAddress: string,
+  potInterface: Interface,
+  blockNumber: number | 'latest',
+): Promise<SparkSDaiPoolState> {
+  const calls = [
+    {
+      target: potAddress,
+      callData: potInterface.encodeFunctionData('dsr', []),
+    },
+    {
+      target: potAddress,
+      callData: potInterface.encodeFunctionData('chi', []),
+    },
+    {
+      target: potAddress,
+      callData: potInterface.encodeFunctionData('rho', []),
+    },
+    {
+      target: potAddress,
+      callData: potInterface.encodeFunctionData('live', []),
+    },
+  ];
+
   const data: { returnData: any[] } = await multiContract.methods
-    .aggregate([
-      {
-        target: potAddress,
-        callData: potInterface.encodeFunctionData('dsr', []),
-      },
-      {
-        target: potAddress,
-        callData: potInterface.encodeFunctionData('chi', []),
-      },
-      {
-        target: potAddress,
-        callData: potInterface.encodeFunctionData('rho', []),
-      },
-      {
-        target: potAddress,
-        callData: potInterface.encodeFunctionData('live', []),
-      },
-    ])
+    .aggregate(calls)
     .call({}, blockNumber);
 
   const [dsr, chi, rho, live] = data.returnData.map(item =>
@@ -45,3 +71,41 @@ export async function getOnChainState(
     rho,
   };
 }
+
+export async function getOnChainStateUSDS(
+  multiContract: Contract,
+  potAddress: string,
+  potInterface: Interface,
+  blockNumber: number | 'latest',
+): Promise<SparkSDaiPoolState> {
+  const calls = [
+    {
+      target: potAddress,
+      callData: potInterface.encodeFunctionData('ssr', []),
+    },
+    {
+      target: potAddress,
+      callData: potInterface.encodeFunctionData('chi', []),
+    },
+    {
+      target: potAddress,
+      callData: potInterface.encodeFunctionData('rho', []),
+    },
+  ];
+
+  const data: { returnData: any[] } = await multiContract.methods
+    .aggregate(calls)
+    .call({}, blockNumber);
+
+  const [dsr, chi, rho] = data.returnData.map(item =>
+    coder.decode(['uint256'], item)[0].toString(),
+  );
+
+  return {
+    // 'hack' - sUSDS doesn't have global shutdown and no notion of `live`, so it's always `live`
+    live: true,
+    dsr,
+    chi,
+    rho,
+  };
+}