@paraswap/dex-lib 3.7.2 → 3.7.3

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

package/src/dex/angle-transmuter/redstone.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 ProxyABI from '../../abi/Redstone.json';
+import { ChainLinkState } from '../../lib/chainlink';
+
+export class RedstoneSubscriber<State> extends PartialEventSubscriber<
+  State,
+  ChainLinkState
+> {
+  static readonly proxyInterface = new Interface(ProxyABI);
+  // static readonly ANSWER_UPDATED_TOPIC =
+  //     RedstoneSubscriber.proxyInterface.getEventTopic('');
+
+  constructor(
+    private proxy: Address,
+    private aggregator: Address,
+    lens: Lens<DeepReadonly<State>, DeepReadonly<ChainLinkState>>,
+    logger: Logger,
+  ) {
+    super([aggregator], lens, logger);
+  }
+
+  static getReadAggregatorMultiCallInput(proxy: Address): MultiCallInput {
+    return {
+      target: proxy,
+      callData: RedstoneSubscriber.proxyInterface.encodeFunctionData(
+        'getPriceFeedAdapter',
+      ),
+    };
+  }
+
+  static readAggregator(multicallOutput: MultiCallOutput): Address {
+    return RedstoneSubscriber.proxyInterface.decodeFunctionResult(
+      'getPriceFeedAdapter',
+      multicallOutput,
+    )[0];
+  }
+
+  static getReadDecimal(proxy: Address): MultiCallInput {
+    return {
+      target: proxy,
+      callData:
+        RedstoneSubscriber.proxyInterface.encodeFunctionData('decimals'),
+    };
+  }
+
+  static readDecimals(multicallOutput: MultiCallOutput): Address {
+    return RedstoneSubscriber.proxyInterface.decodeFunctionResult(
+      'decimals',
+      multicallOutput,
+    )[0];
+  }
+
+  public processLog(
+    state: DeepReadonly<ChainLinkState>,
+    log: Readonly<Log>,
+    blockHeader: Readonly<BlockHeader>,
+  ): DeepReadonly<ChainLinkState> | null {
+    // No events with updated info, this is placeholder
+    return {
+      answer: BigInt('1000000'),
+      timestamp: BigInt('1000000'),
+    };
+  }
+
+  public getGenerateStateMultiCallInputs(): MultiCallInput[] {
+    return [
+      {
+        target: this.proxy,
+        callData:
+          RedstoneSubscriber.proxyInterface.encodeFunctionData(
+            'latestRoundData',
+          ),
+      },
+    ];
+  }
+
+  public generateState(
+    multicallOutputs: MultiCallOutput[],
+    blockNumber?: number | 'latest',
+  ): DeepReadonly<ChainLinkState> {
+    const decoded = RedstoneSubscriber.proxyInterface.decodeFunctionResult(
+      'latestRoundData',
+      multicallOutputs[0],
+    );
+    return {
+      answer: BigInt(decoded.answer.toString()),
+      timestamp: BigInt(decoded.updatedAt.toString()),
+    };
+  }
+
+  public getLatestRoundData(state: DeepReadonly<State>): bigint {
+    return this.lens.get()(state).answer;
+  }
+}