@paraswap/dex-lib 3.6.3 → 3.6.4-transmuter.2

package/src/dex/angle-transmuter/constants.ts

@@ -0,0 +1,138 @@
+import { ethers } from 'ethers';
+import { bigIntify } from '../../utils';
+import { ChainlinkConfig, MorphoConfig, PoolConfig, PythConfig } from './types';
+
+export const CBETH = '0xBe9895146f7AF43049ca1c1AE358B0541Ea49704';
+export const RETH = '0xae78736Cd615f374D3085123A210448E74Fc6393';
+export const STETH = '0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84';
+export const SFRXETH = '0xac3E018457B222d93114458476f3E3416Abbe38F';
+
+export const configEUR: PoolConfig = {
+  stablecoin: {
+    address: '0x1a7e4e63778B4f12a199C062f3eFdD288afCBce8',
+    decimals: 18,
+  },
+  transmuter: '0x00253582b2a3FE112feEC532221d9708c64cEFAb',
+  collaterals: [
+    '0x3f95AA88dDbB7D9D484aa3D482bf0a80009c52c9',
+    '0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c',
+    '0x2F123cF3F37CE3328CC9B5b8415f9EC5109b45e7',
+  ],
+  oracles: {
+    chainlink: {},
+    backed: {
+      '0x83Ec02059F686E747392A22ddfED7833bA0d7cE3': {
+        proxy: '0x83Ec02059F686E747392A22ddfED7833bA0d7cE3',
+        aggregator: '0x83Ec02059F686E747392A22ddfED7833bA0d7cE3',
+        decimals: 8,
+      },
+      '0x475855DAe09af1e3f2d380d766b9E630926ad3CE': {
+        proxy: '0x475855DAe09af1e3f2d380d766b9E630926ad3CE',
+        aggregator: '0x475855DAe09af1e3f2d380d766b9E630926ad3CE',
+        decimals: 8,
+      },
+    },
+    redstone: {
+      '0x6E27A25999B3C665E44D903B2139F5a4Be2B6C26': {
+        proxy: '0x6E27A25999B3C665E44D903B2139F5a4Be2B6C26',
+        aggregator: '0x5BeEFeFE23aecccC77d164AB8E9Ff74e056588f1',
+        decimals: 8,
+      },
+    },
+    morpho: {},
+    pyth: {
+      proxy: '0x4305FB66699C3B2702D4d05CF36551390A4c69C6',
+      ids: [
+        '0x76fa85158bf14ede77087fe3ae472f66213f6ea2f5b411cb2de472794990fa5c',
+        '0xa995d00bb36a63cef7fd2c287dc105fc8f3d93779f062f09551b0af3e81ec30b',
+      ],
+    },
+  },
+};
+
+export const configUSD: PoolConfig = {
+  stablecoin: {
+    address: '0x0000206329b97DB379d5E1Bf586BbDB969C63274',
+    decimals: 18,
+  },
+  transmuter: '0x222222fD79264BBE280b4986F6FEfBC3524d0137',
+  collaterals: [
+    '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+    '0xCA30c93B02514f86d5C86a6e375E3A330B435Fb5',
+    '0xBEEF01735c132Ada46AA9aA4c54623cAA92A64CB',
+  ],
+  oracles: {
+    backed: {} as ChainlinkConfig,
+    chainlink: {
+      '0x8fFfFfd4AfB6115b954Bd326cbe7B4BA576818f6': {
+        proxy: '0x8fFfFfd4AfB6115b954Bd326cbe7B4BA576818f6',
+        aggregator: '0x789190466E21a8b78b8027866CBBDc151542A26C',
+        decimals: 8,
+      },
+      '0x32d1463EB53b73C095625719Afa544D5426354cB': {
+        proxy: '0x32d1463EB53b73C095625719Afa544D5426354cB',
+        aggregator: '0x5EE6Ee50c1cB3E8Da20eE83D57818184387433e8',
+        decimals: 8,
+      },
+    },
+    redstone: {} as ChainlinkConfig,
+    morpho: {
+      '0x025106374196586E8BC91eE8818dD7B0Efd2B78B': {
+        baseVault: '0xBEEF01735c132Ada46AA9aA4c54623cAA92A64CB',
+        baseVaultConversion: bigIntify('1000000000000000000'),
+        quoteVault: ethers.constants.AddressZero,
+        quoteVaultConversion: bigIntify('1'),
+        baseFeed1: '0x8fFfFfd4AfB6115b954Bd326cbe7B4BA576818f6',
+        baseFeed2: ethers.constants.AddressZero,
+        quoteFeed1: ethers.constants.AddressZero,
+        quoteFeed2: ethers.constants.AddressZero,
+        scaleFactor: bigIntify('1000000000000000000'),
+      },
+    },
+    pyth: {} as PythConfig,
+  },
+};
+
+export const configUSDBase: PoolConfig = {
+  stablecoin: {
+    address: '0x0000206329b97DB379d5E1Bf586BbDB969C63274',
+    decimals: 18,
+  },
+  transmuter: '0x222222880e079445Df703c0604706E71a538Fd4f',
+  collaterals: ['0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'],
+  oracles: {
+    backed: {} as ChainlinkConfig,
+    chainlink: {
+      '0x7e860098F58bBFC8648a4311b374B1D669a2bc6B': {
+        proxy: '0x7e860098F58bBFC8648a4311b374B1D669a2bc6B',
+        aggregator: '0x0Ee7145e1370653533e2F2E824424bE2AA95A4Aa',
+        decimals: 8,
+      },
+    },
+    redstone: {} as ChainlinkConfig,
+    morpho: {} as MorphoConfig,
+    pyth: {} as PythConfig,
+  },
+};
+
+export const configUSDArbitrum: PoolConfig = {
+  stablecoin: {
+    address: '0x0000206329b97DB379d5E1Bf586BbDB969C63274',
+    decimals: 18,
+  },
+  transmuter: '0xD253b62108d1831aEd298Fc2434A5A8e4E418053',
+  collaterals: ['0xaf88d065e77c8cC2239327C5EDb3A432268e5831'],
+  oracles: {
+    backed: {} as ChainlinkConfig,
+    chainlink: {
+      '0x50834F3163758fcC1Df9973b6e91f0F0F0434aD3': {
+        proxy: '0x50834F3163758fcC1Df9973b6e91f0F0F0434aD3',
+        aggregator: '0x2946220288DbBF77dF0030fCecc2a8348CbBE32C',
+        decimals: 8,
+      },
+    },
+    redstone: {} as ChainlinkConfig,
+    morpho: {} as MorphoConfig,
+    pyth: {} as PythConfig,
+  },
+};

package/src/dex/angle-transmuter/morphoOracle.ts

@@ -0,0 +1,335 @@
+import { Interface } from '@ethersproject/abi';
+import type { DeepReadonly } from 'ts-essentials';
+import type {
+  BlockHeader,
+  Log,
+  Logger,
+  MultiCallInput,
+  MultiCallOutput,
+} from '../../types';
+import { bigIntify, catchParseLogError } from '../../utils';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import type { IDexHelper } from '../../dex-helper/idex-helper';
+import type { MorphoOracleState } from './types';
+import MorphoOracleABI from '../../abi/angle-transmuter/MorphoOracle.json';
+import ERC20ABI from '../../abi/erc20.json';
+
+export class MorphoOracleEventPool extends StatefulEventSubscriber<MorphoOracleState> {
+  handlers: {
+    [event: string]: (
+      event: any,
+      state: DeepReadonly<MorphoOracleState>,
+      log: Readonly<Log>,
+      blockHeader: Readonly<BlockHeader>,
+    ) => DeepReadonly<MorphoOracleState> | null;
+  } = {};
+
+  static morphoOracleIface = new Interface(MorphoOracleABI);
+  static erc20Iface = new Interface(ERC20ABI);
+
+  logDecoder: (log: Log) => any;
+
+  addressesSubscribed: string[];
+
+  constructor(
+    readonly parentName: string,
+    protected network: number,
+    protected dexHelper: IDexHelper,
+    public morphoOracle: string,
+    logger: Logger,
+  ) {
+    super(parentName, 'Morpho_Oracle', dexHelper, logger);
+
+    this.logDecoder = (log: Log) =>
+      MorphoOracleEventPool.morphoOracleIface.parseLog(log);
+    this.addressesSubscribed = [morphoOracle];
+  }
+
+  /**
+   * The function is called every time any of the subscribed
+   * addresses release log. The function accepts the current
+   * state, updates the state according to the log, and returns
+   * the updated state.
+   * @param state - Current state of event subscriber
+   * @param log - Log released by one of the subscribed addresses
+   * @returns Updates state of the event subscriber after the log
+   */
+  protected processLog(
+    state: DeepReadonly<MorphoOracleState>,
+    log: Readonly<Log>,
+    blockHeader: Readonly<BlockHeader>,
+  ): DeepReadonly<MorphoOracleState> | null {
+    try {
+      const event = this.logDecoder(log);
+      if (event.name in this.handlers) {
+        return this.handlers[event.name](event, state, log, blockHeader);
+      }
+    } catch (e) {
+      catchParseLogError(e, this.logger);
+    }
+
+    return null;
+  }
+
+  /**
+   * The function generates state using on-chain calls. This
+   * function is called to regenerate state if the event based
+   * system fails to fetch events and the local state is no
+   * more correct.
+   * @param blockNumber - Blocknumber for which the state should
+   * should be generated
+   * @returns state of the event subscriber at blocknumber
+   */
+  public async generateState(
+    blockNumber: number,
+  ): Promise<DeepReadonly<MorphoOracleState>> {
+    const poolState = {} as MorphoOracleState;
+
+    const multicall = [
+      {
+        target: this.morphoOracle,
+        callData:
+          MorphoOracleEventPool.morphoOracleIface.encodeFunctionData(
+            'BASE_VAULT',
+          ),
+      },
+      {
+        target: this.morphoOracle,
+        callData: MorphoOracleEventPool.morphoOracleIface.encodeFunctionData(
+          'BASE_VAULT_CONVERSION_SAMPLE',
+        ),
+      },
+      {
+        target: this.morphoOracle,
+        callData:
+          MorphoOracleEventPool.morphoOracleIface.encodeFunctionData(
+            'QUOTE_VAULT',
+          ),
+      },
+      {
+        target: this.morphoOracle,
+        callData: MorphoOracleEventPool.morphoOracleIface.encodeFunctionData(
+          'QUOTE_VAULT_CONVERSION_SAMPLE',
+        ),
+      },
+      {
+        target: this.morphoOracle,
+        callData:
+          MorphoOracleEventPool.morphoOracleIface.encodeFunctionData(
+            'BASE_FEED_1',
+          ),
+      },
+      {
+        target: this.morphoOracle,
+        callData:
+          MorphoOracleEventPool.morphoOracleIface.encodeFunctionData(
+            'BASE_FEED_2',
+          ),
+      },
+      {
+        target: this.morphoOracle,
+        callData:
+          MorphoOracleEventPool.morphoOracleIface.encodeFunctionData(
+            'QUOTE_FEED_1',
+          ),
+      },
+      {
+        target: this.morphoOracle,
+        callData:
+          MorphoOracleEventPool.morphoOracleIface.encodeFunctionData(
+            'QUOTE_FEED_1',
+          ),
+      },
+      {
+        target: this.morphoOracle,
+        callData:
+          MorphoOracleEventPool.morphoOracleIface.encodeFunctionData(
+            'SCALE_FACTOR',
+          ),
+      },
+    ];
+
+    // on chain call
+    const returnData = (
+      await this.dexHelper.multiContract.methods
+        .aggregate(multicall)
+        .call({}, blockNumber)
+    ).returnData;
+
+    // Decode
+    poolState.baseVault =
+      MorphoOracleEventPool.morphoOracleIface.decodeFunctionResult(
+        'BASE_VAULT',
+        returnData[0],
+      )[0] as string;
+    poolState.baseVaultConversion = bigIntify(
+      MorphoOracleEventPool.morphoOracleIface.decodeFunctionResult(
+        'BASE_VAULT_CONVERSION_SAMPLE',
+        returnData[1],
+      )[0],
+    );
+    poolState.quoteVault =
+      MorphoOracleEventPool.morphoOracleIface.decodeFunctionResult(
+        'QUOTE_VAULT',
+        returnData[2],
+      )[0] as string;
+    poolState.quoteVaultConversion = bigIntify(
+      MorphoOracleEventPool.morphoOracleIface.decodeFunctionResult(
+        'QUOTE_VAULT_CONVERSION_SAMPLE',
+        returnData[3],
+      )[0],
+    );
+    poolState.baseFeed1 =
+      MorphoOracleEventPool.morphoOracleIface.decodeFunctionResult(
+        'BASE_FEED_1',
+        returnData[4],
+      )[0] as string;
+    poolState.baseFeed2 =
+      MorphoOracleEventPool.morphoOracleIface.decodeFunctionResult(
+        'BASE_FEED_2',
+        returnData[5],
+      )[0] as string;
+    poolState.quoteFeed1 =
+      MorphoOracleEventPool.morphoOracleIface.decodeFunctionResult(
+        'QUOTE_FEED_1',
+        returnData[6],
+      )[0] as string;
+    poolState.quoteFeed2 =
+      MorphoOracleEventPool.morphoOracleIface.decodeFunctionResult(
+        'QUOTE_FEED_2',
+        returnData[7],
+      )[0] as string;
+    poolState.scaleFactor = bigIntify(
+      MorphoOracleEventPool.morphoOracleIface.decodeFunctionResult(
+        'SCALE_FACTOR',
+        returnData[8],
+      )[0],
+    );
+
+    return poolState;
+  }
+
+  static getGenerateInfoMultiCallInput(morphoOracle: string): MultiCallInput[] {
+    return [
+      {
+        target: morphoOracle,
+        callData:
+          MorphoOracleEventPool.morphoOracleIface.encodeFunctionData(
+            'BASE_VAULT',
+          ),
+      },
+      {
+        target: morphoOracle,
+        callData: MorphoOracleEventPool.morphoOracleIface.encodeFunctionData(
+          'BASE_VAULT_CONVERSION_SAMPLE',
+        ),
+      },
+      {
+        target: morphoOracle,
+        callData:
+          MorphoOracleEventPool.morphoOracleIface.encodeFunctionData(
+            'QUOTE_VAULT',
+          ),
+      },
+      {
+        target: morphoOracle,
+        callData: MorphoOracleEventPool.morphoOracleIface.encodeFunctionData(
+          'QUOTE_VAULT_CONVERSION_SAMPLE',
+        ),
+      },
+      {
+        target: morphoOracle,
+        callData:
+          MorphoOracleEventPool.morphoOracleIface.encodeFunctionData(
+            'BASE_FEED_1',
+          ),
+      },
+      {
+        target: morphoOracle,
+        callData:
+          MorphoOracleEventPool.morphoOracleIface.encodeFunctionData(
+            'BASE_FEED_2',
+          ),
+      },
+      {
+        target: morphoOracle,
+        callData:
+          MorphoOracleEventPool.morphoOracleIface.encodeFunctionData(
+            'QUOTE_FEED_1',
+          ),
+      },
+      {
+        target: morphoOracle,
+        callData:
+          MorphoOracleEventPool.morphoOracleIface.encodeFunctionData(
+            'QUOTE_FEED_1',
+          ),
+      },
+      {
+        target: morphoOracle,
+        callData:
+          MorphoOracleEventPool.morphoOracleIface.encodeFunctionData(
+            'SCALE_FACTOR',
+          ),
+      },
+    ];
+  }
+
+  static generateInfo(
+    multicallOutputs: MultiCallOutput[],
+  ): DeepReadonly<MorphoOracleState> {
+    const poolState = {} as MorphoOracleState;
+
+    // Decode
+    poolState.baseVault =
+      MorphoOracleEventPool.morphoOracleIface.decodeFunctionResult(
+        'BASE_VAULT',
+        multicallOutputs[0],
+      )[0] as string;
+    poolState.baseVaultConversion = bigIntify(
+      MorphoOracleEventPool.morphoOracleIface.decodeFunctionResult(
+        'BASE_VAULT_CONVERSION_SAMPLE',
+        multicallOutputs[1],
+      )[0],
+    );
+    poolState.quoteVault =
+      MorphoOracleEventPool.morphoOracleIface.decodeFunctionResult(
+        'QUOTE_VAULT',
+        multicallOutputs[2],
+      )[0] as string;
+    poolState.quoteVaultConversion = bigIntify(
+      MorphoOracleEventPool.morphoOracleIface.decodeFunctionResult(
+        'QUOTE_VAULT_CONVERSION_SAMPLE',
+        multicallOutputs[3],
+      )[0],
+    );
+    poolState.baseFeed1 =
+      MorphoOracleEventPool.morphoOracleIface.decodeFunctionResult(
+        'BASE_FEED_1',
+        multicallOutputs[4],
+      )[0] as string;
+    poolState.baseFeed2 =
+      MorphoOracleEventPool.morphoOracleIface.decodeFunctionResult(
+        'BASE_FEED_2',
+        multicallOutputs[5],
+      )[0] as string;
+    poolState.quoteFeed1 =
+      MorphoOracleEventPool.morphoOracleIface.decodeFunctionResult(
+        'QUOTE_FEED_1',
+        multicallOutputs[6],
+      )[0] as string;
+    poolState.quoteFeed2 =
+      MorphoOracleEventPool.morphoOracleIface.decodeFunctionResult(
+        'QUOTE_FEED_2',
+        multicallOutputs[7],
+      )[0] as string;
+    poolState.scaleFactor = bigIntify(
+      MorphoOracleEventPool.morphoOracleIface.decodeFunctionResult(
+        'SCALE_FACTOR',
+        multicallOutputs[8],
+      )[0],
+    );
+
+    return poolState;
+  }
+}

package/src/dex/angle-transmuter/morphoVault.ts

@@ -0,0 +1,134 @@
+import { Interface } from '@ethersproject/abi';
+import type { DeepReadonly } from 'ts-essentials';
+import type {
+  BlockHeader,
+  Log,
+  Logger,
+  MultiCallInput,
+  MultiCallOutput,
+} from '../../types';
+import { bigIntify } from '../../utils';
+import type { MorphoVaultState } from './types';
+import MorphoVaultABI from '../../abi/angle-transmuter/MorphoVault.json';
+import { PartialEventSubscriber } from '../../composed-event-subscriber';
+import { Lens } from '../../lens';
+import _ from 'lodash';
+import { ethers } from 'ethers';
+
+export class MorphoVaultSubscriber<State> extends PartialEventSubscriber<
+  State,
+  MorphoVaultState
+> {
+  static interface = new Interface(MorphoVaultABI);
+
+  constructor(
+    public morphoVault: string,
+    lens: Lens<DeepReadonly<State>, DeepReadonly<MorphoVaultState>>,
+    logger: Logger,
+  ) {
+    super([morphoVault], lens, logger);
+  }
+
+  public processLog(
+    state: DeepReadonly<MorphoVaultState>,
+    log: Readonly<Log>,
+    blockHeader: Readonly<BlockHeader>,
+  ): DeepReadonly<MorphoVaultState> | null {
+    try {
+      const parsed = MorphoVaultSubscriber.interface.parseLog(log);
+      const _state: MorphoVaultState = _.cloneDeep(state) as MorphoVaultState;
+      switch (parsed.name) {
+        case 'UpdateLastTotalAssets':
+          return this.handleUpdateLastTotalAssets(parsed, _state);
+        case 'AccrueInterest':
+          return this.handleAccrueFee(parsed, _state);
+        case 'Deposit':
+          return this.handleDeposit(parsed, _state);
+        case 'Withdraw':
+          return this.handleWithdraw(parsed, _state);
+        default:
+          return null;
+      }
+    } catch (e) {
+      this.logger.error('Failed to parse log', e);
+      return null;
+    }
+  }
+
+  public getGenerateStateMultiCallInputs(): MultiCallInput[] {
+    return [
+      {
+        target: this.morphoVault,
+        callData:
+          MorphoVaultSubscriber.interface.encodeFunctionData('totalAssets'),
+      },
+      {
+        target: this.morphoVault,
+        callData:
+          MorphoVaultSubscriber.interface.encodeFunctionData('totalSupply'),
+      },
+    ];
+  }
+
+  public generateState(
+    multicallOutputs: MultiCallOutput[],
+    blockNumber?: number | 'latest',
+  ): DeepReadonly<MorphoVaultState> {
+    const morphoVaultState = {} as MorphoVaultState;
+
+    // Decode
+    morphoVaultState.totalAssets = bigIntify(
+      MorphoVaultSubscriber.interface.decodeFunctionResult(
+        'totalAssets',
+        multicallOutputs[0],
+      )[0],
+    );
+    morphoVaultState.totalSupply = bigIntify(
+      MorphoVaultSubscriber.interface.decodeFunctionResult(
+        'totalSupply',
+        multicallOutputs[1],
+      )[0],
+    );
+    return morphoVaultState;
+  }
+
+  getRate(amount: bigint, state: MorphoVaultState): bigint {
+    return amount === 0n || state.totalSupply === 0n
+      ? amount
+      : (amount * state.totalSupply) / state.totalAssets;
+  }
+
+  handleUpdateLastTotalAssets(
+    event: ethers.utils.LogDescription,
+    state: MorphoVaultState,
+  ): DeepReadonly<MorphoVaultState> | null {
+    state.totalAssets = bigIntify(event.args.updatedTotalAssets);
+    return state;
+  }
+
+  handleAccrueFee(
+    event: ethers.utils.LogDescription,
+    state: MorphoVaultState,
+  ): DeepReadonly<MorphoVaultState> | null {
+    state.totalSupply += bigIntify(event.args.feeShares);
+    return state;
+  }
+
+  handleDeposit(
+    event: ethers.utils.LogDescription,
+    state: MorphoVaultState,
+  ): DeepReadonly<MorphoVaultState> | null {
+    const shares = bigIntify(event.args.shares);
+    state.totalSupply += shares;
+    return state;
+  }
+
+  handleWithdraw(
+    event: ethers.utils.LogDescription,
+    state: MorphoVaultState,
+  ): DeepReadonly<MorphoVaultState> | null {
+    const shares = bigIntify(event.args.shares);
+    state.totalSupply -= shares;
+    return state;
+  }
+}

package/src/dex/angle-transmuter/pyth.ts

@@ -0,0 +1,105 @@
+import { DeepReadonly } from 'ts-essentials';
+import { PartialEventSubscriber } from '../../composed-event-subscriber';
+import {
+  Address,
+  BlockHeader,
+  Log,
+  Logger,
+  MultiCallInput,
+  MultiCallOutput,
+} from '../../types';
+import { Lens } from '../../lens';
+import { Interface } from '@ethersproject/abi';
+import PythABI from '../../abi/angle-transmuter/Pyth.json';
+import _ from 'lodash';
+import { formatUnits, parseUnits } from 'ethers/lib/utils';
+import { BigNumber } from 'ethers';
+import { PythState } from './types';
+
+export class PythSubscriber<State> extends PartialEventSubscriber<
+  State,
+  PythState
+> {
+  static readonly proxyInterface = new Interface(PythABI);
+  static readonly ANSWER_UPDATED_TOPIC =
+    PythSubscriber.proxyInterface.getEventTopic('PriceFeedUpdate');
+
+  constructor(
+    private proxy: Address,
+    private oracleIds: string[],
+    lens: Lens<DeepReadonly<State>, DeepReadonly<PythState>>,
+    logger: Logger,
+  ) {
+    super([proxy], lens, logger);
+  }
+
+  public processLog(
+    state: DeepReadonly<PythState>,
+    log: Readonly<Log>,
+    blockHeader: Readonly<BlockHeader>,
+  ): DeepReadonly<PythState> | null {
+    if (log.topics[0] !== PythSubscriber.ANSWER_UPDATED_TOPIC) return null; // Ignore other events
+    const decoded = PythSubscriber.proxyInterface.decodeEventLog(
+      'PriceFeedUpdate',
+      log.data,
+      log.topics,
+    );
+    if (this.oracleIds.indexOf(decoded.id) === -1) return null;
+    const _state = _.cloneDeep(state) as PythState;
+    const expo = _state[decoded.id].expo;
+    _state[decoded.id] = {
+      answer: this._processPrice(decoded.price, expo),
+      expo: expo,
+      timestamp: Number(decoded.publishTime),
+    };
+    return _state;
+  }
+
+  public getGenerateStateMultiCallInputs(): MultiCallInput[] {
+    const oraclesMultiCalls = this.oracleIds.map(id => {
+      return {
+        target: this.proxy,
+        callData: PythSubscriber.proxyInterface.encodeFunctionData(
+          'getPriceUnsafe',
+          [id],
+        ),
+      };
+    });
+    return oraclesMultiCalls;
+  }
+
+  public generateState(
+    multicallOutputs: MultiCallOutput[],
+    blockNumber?: number | 'latest',
+  ): DeepReadonly<PythState> {
+    const decodedOracle = multicallOutputs.map(call => {
+      return PythSubscriber.proxyInterface.decodeFunctionResult(
+        'getPriceUnsafe',
+        call,
+      )[0];
+    });
+    const _state = {} as PythState;
+    this.oracleIds.map((id, index) => {
+      const expo = decodedOracle[index].expo;
+      _state[id] = {
+        answer: this._processPrice(decodedOracle[index].price, expo),
+        expo: expo,
+        timestamp: Number(decodedOracle[index].publishTime),
+      };
+    });
+    return _state;
+  }
+
+  public getLatestRoundData(
+    state: DeepReadonly<State>,
+    oracleId: string,
+  ): number {
+    return this.lens.get()(state)[oracleId].answer;
+  }
+
+  public _processPrice(price: BigNumber, expo: number): number {
+    const isNormalizerExpoNeg = expo < 0;
+    if (isNormalizerExpoNeg) return Number(formatUnits(price, -expo));
+    return Number(parseUnits(price.toString(), expo));
+  }
+}