@paraswap/dex-lib 2.42.28 → 2.42.29-wombat.3

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

@@ -1,152 +1,266 @@
 import { Interface } from '@ethersproject/abi';
-import { Address } from '@paraswap/core';
-import _ from 'lodash';
-
-import { MultiCallParams, MultiResult } from '../../lib/multi-wrapper';
-import { IDexHelper } from '../../dex-helper';
-import { StatefulRpcPoller } from '../../lib/stateful-rpc-poller/stateful-rpc-poller';
-import { StatePollingManager } from '../../lib/stateful-rpc-poller/state-polling-manager';
-import { ObjWithUpdateInfo } from '../../lib/stateful-rpc-poller/types';
-import { pollingManagerCbExtractor } from '../../lib/stateful-rpc-poller/utils';
+import { AsyncOrSync, DeepReadonly } from 'ts-essentials';
+import {
+  Address,
+  Log,
+  Logger,
+  MultiCallInput,
+  MultiCallOutput,
+} from '../../types';
+import { catchParseLogError } from '../../utils';
 import {
-  addressArrayDecode,
-  booleanDecode,
-  uint256ToBigInt,
-  uint8ToNumber,
-} from '../../lib/decoders';
-import PoolABI from '../../abi/wombat/pool.json';
+  InitializeStateOptions,
+  StatefulEventSubscriber,
+} from '../../stateful-event-subscriber';
+import { IDexHelper } from '../../dex-helper';
+import PoolV2ABI from '../../abi/wombat/pool-v2.json';
+import PoolV3ABI from '../../abi/wombat/pool-v3.json';
 import AssetABI from '../../abi/wombat/asset.json';
-import { uint120ToBigInt } from './utils';
-import { AssetState, MulticallResultOutputs, PoolState } from './types';
-
-export class WombatPool extends StatefulRpcPoller<
-  PoolState,
-  MulticallResultOutputs
-> {
-  static readonly poolInterface = new Interface(PoolABI);
+import { convertUint256ToInt256, toWad, WAD, wdiv, wmul } from './utils';
+import { BlockHeader } from 'web3-eth';
+import { AssetState, PoolState } from './types';
+
+const CLEAR_RPC_CALL_COUNT_INTERVAL = 1000 * 60 * 5; // 5 minutes
+
+export class WombatPool extends StatefulEventSubscriber<PoolState> {
+  static readonly poolV2Interface = new Interface(PoolV2ABI);
+  static readonly poolV3Interface = new Interface(PoolV3ABI);
   static readonly assetInterface = new Interface(AssetABI);
 
+  private rpcCallCount = 0;
+
+  private handlers: {
+    [event: string]: (
+      event: any,
+      state: DeepReadonly<PoolState>,
+      log: Readonly<Log>,
+    ) => AsyncOrSync<DeepReadonly<PoolState> | null>;
+  } = {};
+  private poolInterface: Interface = WombatPool.poolV2Interface;
+  private eventRefetched: string[];
+
+  blankState: PoolState = {
+    asset: {},
+    underlyingAddresses: [],
+    params: {
+      paused: false,
+      ampFactor: 0n,
+      haircutRate: 0n,
+      startCovRatio: 0n,
+      endCovRatio: 0n,
+    },
+  };
+
   constructor(
     dexKey: string,
-    poolIdentifier: string,
-    dexHelper: IDexHelper,
+    name: string,
+    protected network: number,
+    protected dexHelper: IDexHelper,
+    logger: Logger,
     protected poolAddress: Address,
-    protected asset2TokenMap: Map<Address, Address>,
   ) {
-    const callbacks = pollingManagerCbExtractor(
-      StatePollingManager.getInstance(dexHelper),
+    super(
+      `${dexKey}_${name}`,
+      `${dexKey}_${network}_${name}`,
+      dexHelper,
+      logger,
     );
 
-    super(dexKey, poolIdentifier, dexHelper, 0, 0, false, callbacks);
+    this.addressesSubscribed = [this.poolAddress];
+
+    // users-actions handlers
+    this.handlers['Swap'] = this.handleSwap.bind(this);
+    this.handlers['SwapV2'] = this.handleSwapV2.bind(this);
+
+    // admin-actions handlers
+    this.handlers['SetAmpFactor'] = this.handleSetAmpFactor.bind(this);
+    this.handlers['SetHaircutRate'] = this.handleSetHaircutRate.bind(this);
+    this.handlers['AssetAdded'] = this.handleAssetAdded.bind(this);
+    this.handlers['AssetRemoved'] = this.handleAssetRemoved.bind(this);
+    this.handlers['FillPool'] = this.handleFillPool.bind(this);
+    this.handlers['Paused'] = this.handlePaused.bind(this);
+    this.handlers['Unpaused'] = this.handleUnpaused.bind(this);
+    this.handlers['PausedAsset'] = this.handlePausedAsset.bind(this);
+    this.handlers['UnpausedAsset'] = this.handleUnpausedAsset.bind(this);
+
+    this.eventRefetched = ['Deposit', 'Withdraw'];
+
+    setInterval(() => {
+      this.rpcCallCount = 0;
+    }, CLEAR_RPC_CALL_COUNT_INTERVAL);
+  }
+
+  async initialize(
+    blockNumber: number,
+    options?: InitializeStateOptions<PoolState>,
+  ) {
+    const poolContract = new this.dexHelper.web3Provider.eth.Contract(
+      PoolV3ABI as any,
+      this.poolAddress,
+    );
+    try {
+      await poolContract.methods.withdrawalHaircutRate().call({}, blockNumber);
+      this.poolInterface = WombatPool.poolV3Interface;
+    } catch (e) {
+      this.logger.info(
+        `no public variable withdrawalHaircutRate in pool ${this.poolAddress}, this is v2 pool`,
+      );
+    }
+    await super.initialize(blockNumber, options);
+  }
+
+  protected async processBlockLogs(
+    state: DeepReadonly<PoolState>,
+    logs: Readonly<Log>[],
+    blockHeader: Readonly<BlockHeader>,
+  ): Promise<DeepReadonly<PoolState> | null> {
+    let nextState: DeepReadonly<PoolState> | null = null;
+    for (const log of logs) {
+      try {
+        const event = this.poolInterface.parseLog(log);
+        if (this.eventRefetched.includes(event.name)) {
+          // if the state is refetched, no need to deal with the left logs in the block
+          return await this.generateState(log.blockNumber);
+        }
+      } catch (e) {
+        catchParseLogError(e, this.logger);
+      }
+
+      const retState: DeepReadonly<PoolState> | null = await this.processLog(
+        nextState || state,
+        log,
+        blockHeader,
+      );
+
+      if (retState) {
+        nextState = retState;
+      }
+    }
+    return nextState;
   }
 
-  protected _getFetchStateMultiCalls(): MultiCallParams<MulticallResultOutputs>[] {
-    const params: MultiCallParams<MulticallResultOutputs>[] = [];
+  /**
+   * 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
+   * @param blockHeader
+   * @returns Updates state of the event subscriber after the log
+   */
+  protected async processLog(
+    state: DeepReadonly<PoolState>,
+    log: Readonly<Log>,
+    blockHeader: Readonly<BlockHeader>,
+  ): Promise<DeepReadonly<PoolState> | null> {
+    try {
+      const event = this.poolInterface.parseLog(log);
+      if (event.name in this.handlers) {
+        return await this.handlers[event.name](event, state, log);
+      }
+    } catch (e) {
+      catchParseLogError(e, this.logger);
+    }
 
-    params.push({
+    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
+   */
+  async generateState(blockNumber: number): Promise<DeepReadonly<PoolState>> {
+    this.rpcCallCount++;
+
+    if (this.rpcCallCount > 1) {
+      this.logger.warn(
+        `WombatPool generateState excessive RPC call. Name: ${
+          this.name
+        }; pool: ${this.poolAddress}. Called ${
+          this.rpcCallCount + 1
+        } times during ${CLEAR_RPC_CALL_COUNT_INTERVAL / 1000} s interval`,
+      );
+    }
+    let multiCallInputs: MultiCallInput[] = [];
+
+    // 1.A generate pool params requests
+    // paused
+    multiCallInputs.push({
       target: this.poolAddress,
-      callData: WombatPool.poolInterface.encodeFunctionData('paused'),
-      decodeFunction: booleanDecode,
+      callData: this.poolInterface.encodeFunctionData('paused'),
     });
-    params.push({
+    // ampFactor
+    multiCallInputs.push({
       target: this.poolAddress,
-      callData: WombatPool.poolInterface.encodeFunctionData('ampFactor'),
-      decodeFunction: uint256ToBigInt,
+      callData: this.poolInterface.encodeFunctionData('ampFactor'),
     });
-    params.push({
+    // haircutRate
+    multiCallInputs.push({
       target: this.poolAddress,
-      callData: WombatPool.poolInterface.encodeFunctionData('haircutRate'),
-      decodeFunction: uint256ToBigInt,
+      callData: this.poolInterface.encodeFunctionData('haircutRate'),
     });
-    params.push({
+    // startCovRatio
+    multiCallInputs.push({
       target: this.poolAddress,
-      callData: WombatPool.poolInterface.encodeFunctionData('startCovRatio'),
-      decodeFunction: uint256ToBigInt,
+      callData: this.poolInterface.encodeFunctionData('startCovRatio'),
     });
-    params.push({
+    // endCovRatio
+    multiCallInputs.push({
       target: this.poolAddress,
-      callData: WombatPool.poolInterface.encodeFunctionData('endCovRatio'),
-      decodeFunction: uint256ToBigInt,
+      callData: this.poolInterface.encodeFunctionData('endCovRatio'),
     });
-    params.push({
+    // tokens
+    multiCallInputs.push({
       target: this.poolAddress,
-      callData: WombatPool.poolInterface.encodeFunctionData('getTokens'),
-      decodeFunction: addressArrayDecode,
+      callData: this.poolInterface.encodeFunctionData('getTokens'),
     });
 
-    this.asset2TokenMap.forEach((token, asset) => {
-      params.push({
-        target: this.poolAddress,
-        callData: WombatPool.poolInterface.encodeFunctionData('isPaused', [
-          token,
-        ]),
-        decodeFunction: booleanDecode,
-      });
-      params.push({
-        target: asset,
-        callData: WombatPool.assetInterface.encodeFunctionData('cash'),
-        decodeFunction: uint120ToBigInt,
-      });
-      params.push({
-        target: asset,
-        callData: WombatPool.assetInterface.encodeFunctionData('liability'),
-        decodeFunction: uint120ToBigInt,
-      });
-      params.push({
-        target: asset,
-        callData: WombatPool.assetInterface.encodeFunctionData(
-          'underlyingTokenDecimals',
-        ),
-        decodeFunction: uint8ToNumber,
-      });
-      params.push({
-        target: asset,
-        callData:
-          WombatPool.assetInterface.encodeFunctionData('getRelativePrice'),
-        decodeFunction: uint256ToBigInt,
-      });
-    });
-
-    return params;
-  }
+    // 1.B. invoke multicall
+    let returnData: MultiCallOutput[] = [];
+    if (multiCallInputs.length) {
+      returnData = (
+        await this.dexHelper.multiContract.methods
+          .aggregate(multiCallInputs)
+          .call({}, blockNumber)
+      ).returnData;
+    }
 
-  protected _parseStateFromMultiResults(
-    multiOutputs: MulticallResultOutputs[],
-  ): PoolState {
-    const [
-      paused,
-      ampFactor,
-      haircutRate,
-      startCovRatio,
-      endCovRatio,
-      tokens,
-      ...remained
-    ] = multiOutputs as [
-      boolean,
-      bigint,
-      bigint,
-      bigint,
-      bigint,
-      Address[],
-      ...MulticallResultOutputs[],
-    ];
+    let i = 0;
+    // 1.C. decode pool params
+    const paused = Boolean(
+      this.poolInterface.decodeFunctionResult('paused', returnData[i++])[0],
+    );
+    const ampFactor = BigInt(
+      this.poolInterface.decodeFunctionResult('ampFactor', returnData[i++])[0],
+    );
+    const haircutRate = BigInt(
+      this.poolInterface.decodeFunctionResult(
+        'haircutRate',
+        returnData[i++],
+      )[0],
+    );
+    const startCovRatio = BigInt(
+      this.poolInterface.decodeFunctionResult(
+        'startCovRatio',
+        returnData[i++],
+      )[0],
+    );
+    const endCovRatio = BigInt(
+      this.poolInterface.decodeFunctionResult(
+        'endCovRatio',
+        returnData[i++],
+      )[0],
+    );
 
-    const assetTokenArray = Array.from(this.asset2TokenMap.entries());
-    const token2AssetStates = new Map<Address, AssetState>();
-    _.chunk(remained, 5).forEach((chunk, i) => {
-      const [paused, cash, liability, underlyingTokenDecimals, relativePrice] =
-        chunk as [boolean, bigint, bigint, number, bigint | undefined];
-
-      const [asset, token] = assetTokenArray[i];
-      token2AssetStates.set(token, {
-        address: asset,
-        paused,
-        cash,
-        liability,
-        underlyingTokenDecimals,
-        relativePrice,
-      });
-    });
+    const tokens = this.poolInterface
+      .decodeFunctionResult('getTokens', returnData[i++])[0]
+      .map((tokenAddress: Address) => tokenAddress.toLowerCase());
 
     const poolState: PoolState = {
       params: {
@@ -160,77 +274,420 @@ export class WombatPool extends StatefulRpcPoller<
       asset: {},
     };
 
+    // 2.A. generate requests for getting asset addresses
+    multiCallInputs = tokens.map((tokenAddress: Address) => ({
+      target: this.poolAddress,
+      callData: this.poolInterface.encodeFunctionData('addressOfAsset', [
+        tokenAddress,
+      ]),
+    }));
+
+    // 2.B. invoke multicall
+    returnData = (
+      await this.dexHelper.multiContract.methods
+        .aggregate(multiCallInputs)
+        .call({}, blockNumber)
+    ).returnData;
+
+    // 2.C. decode asset addresses
+    const assets: Address[] = returnData.map(data => {
+      return this.poolInterface.decodeFunctionResult('addressOfAsset', data)[0];
+    });
+
+    // 3. get asset states
+    const assetState = await this.getAssetState(
+      this.poolAddress,
+      assets.map(asset => asset.toLowerCase()),
+      tokens,
+      blockNumber,
+    );
     const isMainPool =
-      Array.from(token2AssetStates.values()).filter(
-        assetState => assetState.relativePrice === undefined,
-      ).length > 0;
-    for (const token of poolState.underlyingAddresses) {
-      if (!token2AssetStates.has(token)) {
-        // this happens when asset has been added to pool but is not added to BMW yet
-        continue;
-      }
-      poolState.asset[token] = token2AssetStates.get(token)!;
+      assetState.filter(asset => asset.relativePrice === undefined).length > 0;
+    for (let j = 0; j < tokens.length; j++) {
       if (isMainPool) {
-        poolState.asset[token].relativePrice = undefined;
+        assetState[j].relativePrice = undefined;
       }
+      poolState.asset[tokens[j]] = assetState[j];
     }
 
     return poolState;
   }
 
-  public async fetchLatestStateFromRpc(): Promise<ObjWithUpdateInfo<PoolState> | null> {
-    const multiCalls = this.getFetchStateWithBlockInfoMultiCalls();
-    try {
-      const lastUpdatedAtMs = Date.now();
-      const aggregatedResults = (await this.dexHelper.multiWrapper.tryAggregate<
-        number | MulticallResultOutputs
-      >(
-        false,
-        multiCalls as MultiCallParams<MulticallResultOutputs | number>[],
-        undefined,
-        undefined,
-        // multiCalls includes calls asset.isPaused, asset.getRelativePrice
-        // some of the contracts don't have these methods, so prevent logging errors
-        false,
-      )) as [MultiResult<number>, ...MultiResult<MulticallResultOutputs>[]];
-
-      return this.parseStateFromMultiResultsWithBlockInfo(
-        aggregatedResults,
-        lastUpdatedAtMs,
+  handleSwap(
+    event: any,
+    state: DeepReadonly<PoolState>,
+    log: Readonly<Log>,
+  ): AsyncOrSync<DeepReadonly<PoolState> | null> {
+    const fromTokenAddress = event.args.fromToken.toString().toLowerCase();
+    const fromAmount = BigInt(event.args.fromAmount.toString());
+    const toTokenAddress = event.args.toToken.toString().toLowerCase();
+    const toAmount = BigInt(event.args.toAmount.toString());
+
+    if (
+      !state.underlyingAddresses.includes(fromTokenAddress) ||
+      !state.underlyingAddresses.includes(toTokenAddress)
+    ) {
+      return null;
+    }
+
+    let idealToAmount;
+    const fromAmountInt256 = convertUint256ToInt256(fromAmount);
+    if (fromAmountInt256 > 0) {
+      idealToAmount = wdiv(toAmount, WAD - state.params.haircutRate);
+    } else {
+      this.logger.warn(
+        `pool ${this.poolAddress} swap from a negative amount ${fromAmountInt256} at block ${log.blockNumber} should not happen`,
       );
-    } catch (e) {
-      this._logMessageWithSuppression('ERROR_FETCHING_STATE_FROM_RPC', e);
+      const haircut = wmul(-fromAmount, state.params.haircutRate);
+      idealToAmount = toAmount + haircut;
     }
 
-    return null;
+    const fromAmountInWad = toWad(
+      fromAmount,
+      BigInt(state.asset[fromTokenAddress].underlyingTokenDecimals),
+    );
+    const toAmountInWad = toWad(
+      idealToAmount,
+      BigInt(state.asset[toTokenAddress].underlyingTokenDecimals),
+    );
+
+    return {
+      ...state,
+      asset: {
+        ...state.asset,
+        [fromTokenAddress]: {
+          ...state.asset[fromTokenAddress],
+          cash: state.asset[fromTokenAddress].cash + fromAmountInWad,
+        },
+        [toTokenAddress]: {
+          ...state.asset[toTokenAddress],
+          cash: state.asset[toTokenAddress].cash - toAmountInWad,
+        },
+      },
+    };
+  }
+
+  handleSwapV2(
+    event: any,
+    state: DeepReadonly<PoolState>,
+    _log: Readonly<Log>,
+  ): AsyncOrSync<DeepReadonly<PoolState> | null> {
+    const fromTokenAddress = event.args.fromToken.toString().toLowerCase();
+    const fromAmount = BigInt(event.args.fromAmount.toString());
+    const toTokenAddress = event.args.toToken.toString().toLowerCase();
+    const toAmount = BigInt(event.args.toAmount.toString());
+    const toTokenFee = BigInt(event.args.toTokenFee.toString());
+
+    if (
+      !state.underlyingAddresses.includes(fromTokenAddress) ||
+      !state.underlyingAddresses.includes(toTokenAddress)
+    ) {
+      return null;
+    }
+
+    const fromAmountInWad = toWad(
+      fromAmount,
+      BigInt(state.asset[fromTokenAddress].underlyingTokenDecimals),
+    );
+    const toAmountInWad = toWad(
+      toAmount + toTokenFee,
+      BigInt(state.asset[toTokenAddress].underlyingTokenDecimals),
+    );
+
+    return {
+      ...state,
+      asset: {
+        ...state.asset,
+        [fromTokenAddress]: {
+          ...state.asset[fromTokenAddress],
+          cash: state.asset[fromTokenAddress].cash + fromAmountInWad,
+        },
+        [toTokenAddress]: {
+          ...state.asset[toTokenAddress],
+          cash: state.asset[toTokenAddress].cash - toAmountInWad,
+        },
+      },
+    };
   }
 
-  public parseStateFromMultiResultsWithBlockInfo(
-    multiOutputs: [
-      MultiResult<number>,
-      ...MultiResult<MulticallResultOutputs>[],
-    ],
-    lastUpdatedAtMs: number,
-  ): ObjWithUpdateInfo<PoolState> {
-    const [blockNumber, ...outputsForAbstract] = multiOutputs.map((m, i) => {
-      return m.returnData;
-    }) as [number, ...MulticallResultOutputs[]];
+  handleSetAmpFactor(
+    event: any,
+    state: DeepReadonly<PoolState>,
+    _log: Readonly<Log>,
+  ): AsyncOrSync<DeepReadonly<PoolState> | null> {
+    const ampFactor = BigInt(event.args.value.toString());
 
     return {
-      value: this._parseStateFromMultiResults(outputsForAbstract),
-      blockNumber,
-      lastUpdatedAtMs,
+      ...state,
+      params: {
+        ...state.params,
+        ampFactor,
+      },
     };
   }
 
-  public addAssets(asset2TokenMap: Map<Address, Address>) {
-    for (const [asset, token] of asset2TokenMap) {
-      if (this.asset2TokenMap.has(asset)) {
-        continue;
+  handleSetHaircutRate(
+    event: any,
+    state: DeepReadonly<PoolState>,
+    _log: Readonly<Log>,
+  ): AsyncOrSync<DeepReadonly<PoolState> | null> {
+    const haircutRate = BigInt(event.args.value.toString());
+
+    return {
+      ...state,
+      params: {
+        ...state.params,
+        haircutRate,
+      },
+    };
+  }
+
+  async handleAssetAdded(
+    event: any,
+    state: DeepReadonly<PoolState>,
+    log: Readonly<Log>,
+  ): Promise<DeepReadonly<PoolState> | null> {
+    const token: Address = event.args.token.toString().toLowerCase();
+    const asset: Address = event.args.asset.toString().toLowerCase();
+    if (state.underlyingAddresses.includes(token)) {
+      return null;
+    }
+
+    const assetState = await this.getAssetState(
+      this.poolAddress,
+      [asset],
+      [token],
+      log.blockNumber,
+    );
+    const poolState = {
+      ...state,
+      underlyingAddresses: [...state.underlyingAddresses, token],
+      asset: {
+        ...state.asset,
+        [token]: assetState[0],
+      },
+    };
+
+    const isMainPool =
+      Object.values(poolState.asset).filter(
+        asset => asset.relativePrice === undefined,
+      ).length > 0;
+    if (isMainPool) {
+      for (const underlyingAddress of poolState.underlyingAddresses) {
+        poolState.asset[underlyingAddress] = {
+          ...poolState.asset[underlyingAddress],
+          relativePrice: undefined,
+        };
       }
+    }
+    return poolState;
+  }
 
-      this.asset2TokenMap.set(asset, token);
-      this._cachedMultiCallData = undefined;
+  async handleAssetRemoved(
+    event: any,
+    state: DeepReadonly<PoolState>,
+    _log: Readonly<Log>,
+  ): Promise<DeepReadonly<PoolState> | null> {
+    const token = event.args.token.toString().toLowerCase();
+    if (!state.underlyingAddresses.includes(token)) {
+      return null;
     }
+
+    return {
+      ...state,
+      underlyingAddresses: state.underlyingAddresses.filter(
+        underlyingAddress => underlyingAddress !== token,
+      ),
+      asset: {
+        ...state.asset,
+        [token]: undefined,
+      },
+    };
+  }
+
+  async handleFillPool(
+    event: any,
+    state: DeepReadonly<PoolState>,
+    _log: Readonly<Log>,
+  ): Promise<DeepReadonly<PoolState> | null> {
+    const token = event.args.token.toString().toLowerCase();
+    const amount = BigInt(event.args.amount.toString());
+    if (!state.underlyingAddresses.includes(token)) {
+      return null;
+    }
+
+    return {
+      ...state,
+      asset: {
+        ...state.asset,
+        [token]: {
+          ...state.asset[token],
+          cash: state.asset[token].cash + amount,
+        },
+      },
+    };
+  }
+
+  async handlePaused(
+    event: any,
+    state: DeepReadonly<PoolState>,
+    _log: Readonly<Log>,
+  ): Promise<DeepReadonly<PoolState> | null> {
+    return {
+      ...state,
+      params: {
+        ...state.params,
+        paused: true,
+      },
+    };
+  }
+
+  async handleUnpaused(
+    event: any,
+    state: DeepReadonly<PoolState>,
+    _log: Readonly<Log>,
+  ): Promise<DeepReadonly<PoolState> | null> {
+    return {
+      ...state,
+      params: {
+        ...state.params,
+        paused: false,
+      },
+    };
+  }
+
+  async handlePausedAsset(
+    event: any,
+    state: DeepReadonly<PoolState>,
+    _log: Readonly<Log>,
+  ): Promise<DeepReadonly<PoolState> | null> {
+    const token = event.args.token.toString();
+    if (!state.underlyingAddresses.includes(token)) {
+      return null;
+    }
+
+    return {
+      ...state,
+      asset: {
+        ...state.asset,
+        [token]: {
+          ...state.asset[token],
+          paused: true,
+        },
+      },
+    };
+  }
+
+  async handleUnpausedAsset(
+    event: any,
+    state: DeepReadonly<PoolState>,
+    _log: Readonly<Log>,
+  ): Promise<DeepReadonly<PoolState> | null> {
+    const token = event.args.token.toString();
+    if (!state.underlyingAddresses.includes(token)) {
+      return null;
+    }
+
+    return {
+      ...state,
+      asset: {
+        ...state.asset,
+        [token]: {
+          ...state.asset[token],
+          paused: true,
+        },
+      },
+    };
+  }
+
+  private async getAssetState(
+    pool: Address,
+    assets: Address[],
+    tokens: Address[],
+    blockNumber: number,
+  ): Promise<AssetState[]> {
+    const assetStates: AssetState[] = [];
+    const multiCallInputs: MultiCallInput[] = [];
+
+    const methods = [
+      'cash',
+      'liability',
+      'underlyingTokenDecimals',
+      'getRelativePrice',
+    ];
+
+    for (let i = 0; i < assets.length; i++) {
+      const asset = assets[i];
+      const token = tokens[i];
+
+      multiCallInputs.push({
+        target: pool,
+        callData: this.poolInterface.encodeFunctionData('isPaused', [token]),
+      });
+
+      for (const method of methods) {
+        multiCallInputs.push({
+          target: asset,
+          callData: WombatPool.assetInterface.encodeFunctionData(method),
+        });
+      }
+    }
+
+    const returnData = await this.dexHelper.multiContract.methods
+      .tryAggregate(false, multiCallInputs)
+      .call({}, blockNumber);
+
+    for (
+      let i = 0;
+      i < assets.length * (methods.length + 1);
+      i += methods.length + 1
+    ) {
+      const paused = returnData[i].success
+        ? Boolean(
+            this.poolInterface.decodeFunctionResult(
+              'isPaused',
+              returnData[i].returnData,
+            )[0],
+          )
+        : false;
+      const cash = BigInt(
+        WombatPool.assetInterface.decodeFunctionResult(
+          methods[0],
+          returnData[i + 1].returnData,
+        )[0],
+      );
+      const liability = BigInt(
+        WombatPool.assetInterface.decodeFunctionResult(
+          methods[1],
+          returnData[i + 2].returnData,
+        )[0],
+      );
+      const underlyingTokenDecimals =
+        WombatPool.assetInterface.decodeFunctionResult(
+          methods[2],
+          returnData[i + 3].returnData,
+        )[0];
+
+      let relativePrice: bigint | undefined;
+      if (returnData[i + 4].success) {
+        relativePrice = BigInt(
+          WombatPool.assetInterface.decodeFunctionResult(
+            methods[3],
+            returnData[i + 4].returnData,
+          )[0],
+        );
+      }
+
+      assetStates.push({
+        address: assets[i / (methods.length + 1)],
+        paused,
+        cash,
+        liability,
+        underlyingTokenDecimals,
+        relativePrice,
+      });
+    }
+
+    return assetStates;
   }
 }