@across-protocol/sdk 3.1.35 → 3.2.0

package/src/clients/AcrossConfigStoreClient/AcrossConfigStoreClient.ts

@@ -1,6 +1,6 @@
 import { utils, across } from "@uma/sdk";
 import assert from "assert";
-import { Contract, Event } from "ethers";
+import { Contract } from "ethers";
 import winston from "winston";
 import { isError } from "../../typeguards";
 import {
@@ -14,7 +14,6 @@ import {
   paginatedEventQuery,
   sortEventsAscendingInPlace,
   sortEventsDescending,
-  spreadEvent,
   spreadEventWithBlockNumber,
   toBN,
   utf8ToHex,
@@ -25,8 +24,10 @@ import {
   DisabledChainsUpdate,
   GlobalConfigUpdate,
   LiteChainsIdListUpdate,
+  Log,
   ParsedTokenConfig,
   RouteRateModelUpdate,
+  SortableEvent,
   SpokePoolTargetBalance,
   SpokeTargetBalanceUpdate,
   TokenConfig,
@@ -41,8 +42,8 @@ type ConfigStoreUpdateSuccess = {
   chainId: number;
   searchEndBlock: number;
   events: {
-    updatedTokenConfigEvents: Event[];
-    updatedGlobalConfigEvents: Event[];
+    updatedTokenConfigEvents: Log[];
+    updatedGlobalConfigEvents: Log[];
     globalConfigUpdateTimes: number[];
   };
 };
@@ -430,12 +431,10 @@ export class AcrossConfigStoreClient extends BaseAbstractClient {
 
     // Save new Global config updates.
     for (let i = 0; i < updatedGlobalConfigEvents.length; i++) {
-      const event = updatedGlobalConfigEvents[i];
-      const args = {
-        blockNumber: event.blockNumber,
-        transactionIndex: event.transactionIndex,
-        logIndex: event.logIndex,
-        ...spreadEvent(event.args),
+      const args = spreadEventWithBlockNumber(updatedGlobalConfigEvents[i]) as SortableEvent & {
+        key: string;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        value: any;
       };
 
       if (args.key === utf8ToHex(GLOBAL_CONFIG_STORE_KEYS.MAX_RELAYER_REPAYMENT_LEAF_SIZE)) {

package/src/clients/HubPoolClient.ts

@@ -1,5 +1,5 @@
 import assert from "assert";
-import { Contract, Event, EventFilter } from "ethers";
+import { Contract, EventFilter } from "ethers";
 import _ from "lodash";
 import winston from "winston";
 import { DEFAULT_CACHING_SAFE_LAG, DEFAULT_CACHING_TTL } from "../constants";
@@ -13,6 +13,7 @@ import {
   DisputedRootBundle,
   ExecutedRootBundle,
   L1Token,
+  Log,
   LpToken,
   PendingRootBundle,
   ProposedRootBundle,
@@ -38,7 +39,6 @@ import {
   paginatedEventQuery,
   shouldCache,
   sortEventsDescending,
-  spreadEvent,
   spreadEventWithBlockNumber,
   toBN,
   getTokenInfo,
@@ -52,7 +52,7 @@ type HubPoolUpdateSuccess = {
   success: true;
   currentTime: number;
   pendingRootBundleProposal: PendingRootBundle;
-  events: Record<string, Event[]>;
+  events: Record<string, Log[]>;
   searchEndBlock: number;
 };
 type HubPoolUpdateFailure = {
@@ -291,11 +291,33 @@ export class HubPoolClient extends BaseAbstractClient {
     return getL1TokenInfo(tokenAddress, chain);
   }
 
-  getBlockNumber(timestamp: number): Promise<number | undefined> {
+  /**
+   * Resolve a given timestamp to a block number on the HubPool chain.
+   * @param timestamp A single timestamp to be resolved to a block number on the HubPool chain.
+   * @returns The block number corresponding to the supplied timestamp.
+   */
+  getBlockNumber(timestamp: number): Promise<number> {
     const hints = { lowBlock: this.deploymentBlock };
     return getCachedBlockForTimestamp(this.chainId, timestamp, this.blockFinder, this.cachingMechanism, hints);
   }
 
+  /**
+   * For an array of timestamps, resolve each unique timestamp to a block number on the HubPool chain.
+   * @dev Inputs are filtered for uniqueness and sorted to improve BlockFinder efficiency.
+   * @dev Querying block numbers sequentially also improves BlockFinder efficiency.
+   * @param timestamps Array of timestamps to be resolved to a block number on the HubPool chain.
+   * @returns A mapping of quoteTimestamp -> HubPool block number.
+   */
+  async getBlockNumbers(timestamps: number[]): Promise<{ [quoteTimestamp: number]: number }> {
+    const sortedTimestamps = dedupArray(timestamps).sort((x, y) => x - y);
+    const blockNumbers: { [quoteTimestamp: number]: number } = {};
+    for (const timestamp of sortedTimestamps) {
+      blockNumbers[timestamp] = await this.getBlockNumber(timestamp);
+    }
+
+    return blockNumbers;
+  }
+
   async getCurrentPoolUtilization(l1Token: string): Promise<BigNumber> {
     const blockNumber = this.latestBlockSearched ?? (await this.hubPool.provider.getBlockNumber());
     return await this.getUtilization(l1Token, blockNumber, bnZero, getCurrentTime(), 0);
@@ -400,15 +422,6 @@ export class HubPoolClient extends BaseAbstractClient {
       }
     };
 
-    // Helper to resolve a quoteTimestamp to a HubPool block number.
-    const resolveTimestampsToBlocks = async (quoteTimestamp: number): Promise<[number, number]> => {
-      const quoteBlock = await this.getBlockNumber(quoteTimestamp);
-      if (!isDefined(quoteBlock)) {
-        throw new Error(`Could not find block for timestamp ${quoteTimestamp}`);
-      }
-      return [quoteTimestamp, quoteBlock];
-    };
-
     // Helper to resolve existing HubPool token utilisation for an array of unique block numbers.
     // Produces a mapping of blockNumber -> utilization for a specific token.
     const resolveUtilization = async (hubPoolToken: string): Promise<Record<number, BigNumber>> => {
@@ -462,14 +475,12 @@ export class HubPoolClient extends BaseAbstractClient {
      */
     const timeToCache = this.configOverride.timeToCache ?? DEFAULT_CACHING_SAFE_LAG;
 
-    // Identify the unique hubPoolToken & quoteTimestamp mappings. This is used to optimise subsequent HubPool queries.
-    deposits.forEach((deposit) => resolveUniqueQuoteTimestamps(deposit));
-
     // Filter all deposits for unique quoteTimestamps, to be resolved to a blockNumber in parallel.
     const quoteTimestamps = dedupArray(deposits.map(({ quoteTimestamp }) => quoteTimestamp));
-    quoteBlocks = Object.fromEntries(
-      await mapAsync(quoteTimestamps, (quoteTimestamp) => resolveTimestampsToBlocks(quoteTimestamp))
-    );
+    quoteBlocks = await this.getBlockNumbers(quoteTimestamps);
+
+    // Identify the unique hubPoolToken & quoteTimestamp mappings. This is used to optimise subsequent HubPool queries.
+    deposits.forEach((deposit) => resolveUniqueQuoteTimestamps(deposit));
 
     // For each token / quoteBlock pair, resolve the utilisation for each quoted block.
     // This can be reused for each deposit with the same HubPool token and quoteTimestamp pair.
@@ -890,11 +901,10 @@ export class HubPoolClient extends BaseAbstractClient {
     // only run iff a new token has been enabled. Will only append iff the info is not there already.
     // Filter out any duplicate addresses. This might happen due to enabling, disabling and re-enabling a token.
     if (eventsToQuery.includes("L1TokenEnabledForLiquidityProvision")) {
-      const uniqueL1Tokens = [
-        ...Array.from(
-          new Set(events["L1TokenEnabledForLiquidityProvision"].map((event) => spreadEvent(event.args).l1Token))
-        ),
-      ];
+      const uniqueL1Tokens = dedupArray(
+        events["L1TokenEnabledForLiquidityProvision"].map((event) => String(event.args["l1Token"]))
+      );
+
       const [tokenInfo, lpTokenInfo] = await Promise.all([
         Promise.all(uniqueL1Tokens.map((l1Token: string) => fetchTokenInfo(l1Token, this.hubPool.provider))),
         Promise.all(

package/src/clients/SpokePoolClient.ts

@@ -1,4 +1,4 @@
-import { Contract, Event, EventFilter } from "ethers";
+import { Contract, EventFilter } from "ethers";
 import winston from "winston";
 import {
   AnyObject,
@@ -20,7 +20,6 @@ import {
   spreadEventWithBlockNumber,
 } from "../utils/EventUtils";
 import { validateFillForDeposit } from "../utils/FlowUtils";
-
 import { ZERO_ADDRESS } from "../constants";
 import {
   Deposit,
@@ -28,15 +27,13 @@ import {
   Fill,
   FillStatus,
   FillWithBlock,
-  FilledV3RelayEvent,
-  RealizedLpFee,
+  Log,
   RelayData,
   RelayerRefundExecutionWithBlock,
   RootBundleRelayWithBlock,
   SlowFillRequestWithBlock,
   SpeedUpWithBlock,
   TokensBridged,
-  V3FundsDepositedEvent,
 } from "../interfaces";
 import { SpokePool } from "../typechain";
 import { getNetworkName } from "../utils/NetworkUtils";
@@ -51,7 +48,7 @@ type SpokePoolUpdateSuccess = {
   oldestTime: number;
   firstDepositId: number;
   latestDepositId: number;
-  events: Event[][];
+  events: Log[][];
   searchEndBlock: number;
 };
 type SpokePoolUpdateFailure = {
@@ -511,7 +508,7 @@ export class SpokePoolClient extends BaseAbstractClient {
     }
 
     // Sort all events to ensure they are stored in a consistent order.
-    events.forEach((events: Event[]) => sortEventsAscendingInPlace(events));
+    events.forEach((events: Log[]) => sortEventsAscendingInPlace(events));
 
     return {
       success: true,
@@ -550,24 +547,34 @@ export class SpokePoolClient extends BaseAbstractClient {
     }
 
     if (eventsToQuery.includes("V3FundsDeposited")) {
-      const depositEvents = [
-        ...((queryResults[eventsToQuery.indexOf("V3FundsDeposited")] ?? []) as V3FundsDepositedEvent[]),
-      ];
+      const depositEvents = queryResults[eventsToQuery.indexOf("V3FundsDeposited")] ?? [];
       if (depositEvents.length > 0) {
         this.log("debug", `Using ${depositEvents.length} newly queried deposit events for chain ${this.chainId}`, {
           earliestEvent: depositEvents[0].blockNumber,
         });
       }
 
-      const dataForQuoteTime = await this.batchComputeRealizedLpFeePct(depositEvents);
-      for (const [index, event] of Array.from(depositEvents.entries())) {
-        const rawDeposit = spreadEventWithBlockNumber(event);
+      // For each deposit, resolve its quoteTimestamp to a block number on the HubPool.
+      // Don't bother filtering for uniqueness; the HubPoolClient handles this efficienctly.
+      const quoteBlockNumbers = await this.getBlockNumbers(
+        depositEvents.map(({ args }) => Number(args["quoteTimestamp"]))
+      );
+      for (const event of depositEvents) {
+        const quoteBlockNumber = quoteBlockNumbers[Number(event.args["quoteTimestamp"])];
 
         // Derive and append the common properties that are not part of the onchain event.
-        const { quoteBlock: quoteBlockNumber } = dataForQuoteTime[index];
-        const deposit = { ...(rawDeposit as DepositWithBlock), originChainId: this.chainId, quoteBlockNumber };
+        const deposit = {
+          ...spreadEventWithBlockNumber(event),
+          quoteBlockNumber,
+          originChainId: this.chainId,
+          // The following properties are placeholders to be updated immediately.
+          fromLiteChain: true,
+          toLiteChain: true,
+        } as DepositWithBlock;
+
         deposit.fromLiteChain = this.isOriginLiteChain(deposit);
         deposit.toLiteChain = this.isDestinationLiteChain(deposit);
+
         if (deposit.outputToken === ZERO_ADDRESS) {
           deposit.outputToken = this.getDestinationTokenForDeposit(deposit);
         }
@@ -586,16 +593,12 @@ export class SpokePoolClient extends BaseAbstractClient {
       }
     }
 
-    // TODO: When validating fills with deposits for the purposes of UBA flows, do we need to consider
-    // speed ups as well? For example, do we need to also consider that the speed up is before the fill
-    // timestamp to be applied for the fill? My brain hurts.
     // Update deposits with speed up requests from depositor.
     if (eventsToQuery.includes("RequestedSpeedUpV3Deposit")) {
-      const speedUpEvents = [...(queryResults[eventsToQuery.indexOf("RequestedSpeedUpV3Deposit")] ?? [])];
+      const speedUpEvents = queryResults[eventsToQuery.indexOf("RequestedSpeedUpV3Deposit")] ?? [];
 
       for (const event of speedUpEvents) {
-        const rawEvent = spreadEventWithBlockNumber(event);
-        const speedUp = { ...rawEvent, originChainId: this.chainId } as SpeedUpWithBlock;
+        const speedUp = { ...spreadEventWithBlockNumber(event), originChainId: this.chainId } as SpeedUpWithBlock;
         assign(this.speedUps, [speedUp.depositor, speedUp.depositId], [speedUp]);
 
         // Find deposit hash matching this speed up event and update the deposit data associated with the hash,
@@ -614,10 +617,11 @@ export class SpokePoolClient extends BaseAbstractClient {
     if (eventsToQuery.includes("RequestedV3SlowFill")) {
       const slowFillRequests = queryResults[eventsToQuery.indexOf("RequestedV3SlowFill")];
       for (const event of slowFillRequests) {
-        const slowFillRequest: SlowFillRequestWithBlock = {
-          ...(spreadEventWithBlockNumber(event) as SlowFillRequestWithBlock),
+        const slowFillRequest = {
+          ...spreadEventWithBlockNumber(event),
           destinationChainId: this.chainId,
-        };
+        } as SlowFillRequestWithBlock;
+
         const relayDataHash = getRelayDataHash(slowFillRequest, this.chainId);
         if (this.slowFillRequests[relayDataHash] !== undefined) {
           continue;
@@ -627,7 +631,7 @@ export class SpokePoolClient extends BaseAbstractClient {
     }
 
     if (eventsToQuery.includes("FilledV3Relay")) {
-      const fillEvents = [...((queryResults[eventsToQuery.indexOf("FilledV3Relay")] ?? []) as FilledV3RelayEvent[])];
+      const fillEvents = queryResults[eventsToQuery.indexOf("FilledV3Relay")] ?? [];
 
       if (fillEvents.length > 0) {
         this.log("debug", `Using ${fillEvents.length} newly queried fill events for chain ${this.chainId}`, {
@@ -639,9 +643,9 @@ export class SpokePoolClient extends BaseAbstractClient {
       // test that the types are complete. A broader change in strategy for safely unpacking events will be introduced.
       for (const event of fillEvents) {
         const fill = {
-          ...(spreadEventWithBlockNumber(event) as FillWithBlock),
+          ...spreadEventWithBlockNumber(event),
           destinationChainId: this.chainId,
-        };
+        } as FillWithBlock;
 
         assign(this.fills, [fill.originChainId], [fill]);
         assign(this.depositHashesToFills, [this.getDepositHash(fill)], [fill]);
@@ -719,46 +723,24 @@ export class SpokePoolClient extends BaseAbstractClient {
   }
 
   /**
-   * Computes the realized LP fee percentage for a given deposit.
-   * @param depositEvent The deposit event to compute the realized LP fee percentage for.
-   * @returns The realized LP fee percentage.
+   * Resolve a given timestamp to a block number on the HubPool chain via the HubPoolClient.
+   * @param timestamp A single timestamp to be resolved via the HubPoolClient.
+   * @returns The block number on the HubPool chain corresponding to the supplied timestamp.
    */
-  protected async computeRealizedLpFeePct(depositEvent: V3FundsDepositedEvent): Promise<RealizedLpFee> {
-    const [lpFee] = await this.batchComputeRealizedLpFeePct([depositEvent]);
-    return lpFee;
+  protected getBlockNumber(timestamp: number): Promise<number> {
+    return this.hubPoolClient?.getBlockNumber(timestamp) ?? Promise.resolve(MAX_BIG_INT.toNumber());
   }
 
   /**
-   * Computes the realized LP fee percentage for a batch of deposits.
-   * @dev Computing in batch opens up for efficiencies, e.g. in quoteTimestamp -> blockNumber resolution.
-   * @param depositEvents The array of deposit events to compute the realized LP fee percentage for.
-   * @returns The array of realized LP fee percentages and associated HubPool block numbers.
+   * For an array of timestamps, resolve each timestamp to a block number on the HubPool chain via the HubPoolClient.
+   * @param timestamps Array of timestamps to be resolved to a block number via the HubPoolClient.
+   * @returns A mapping of quoteTimestamp -> HubPool block number.
    */
-  protected async batchComputeRealizedLpFeePct(depositEvents: V3FundsDepositedEvent[]): Promise<RealizedLpFee[]> {
-    // If no hub pool client, we're using this for testing. Set quote block very high so that if it's ever
-    // used to look up a configuration for a block, it will always match with the latest configuration.
-    if (this.hubPoolClient === null) {
-      const realizedLpFeePct = bnZero;
-      const quoteBlock = MAX_BIG_INT.toNumber();
-      return depositEvents.map(() => {
-        return { realizedLpFeePct, quoteBlock };
-      });
-    }
-
-    const deposits = depositEvents.map(({ args }) => {
-      // For v3 deposits, leave payment chain ID undefined so we don't compute lp fee since we don't have the
-      // payment chain ID until we match this deposit with a fill.
-      const { inputToken, inputAmount, quoteTimestamp } = args;
-      return {
-        inputToken,
-        inputAmount,
-        originChainId: this.chainId,
-        paymentChainId: undefined,
-        quoteTimestamp,
-      };
-    });
-
-    return deposits.length > 0 ? await this.hubPoolClient.batchComputeRealizedLpFeePct(deposits) : [];
+  protected getBlockNumbers(timestamps: number[]): Promise<{ [quoteTimestamp: number]: number }> {
+    return (
+      this.hubPoolClient?.getBlockNumbers(timestamps) ??
+      Promise.resolve(Object.fromEntries(timestamps.map((timestamp) => [timestamp, MAX_BIG_INT.toNumber()])))
+    );
   }
 
   /**
@@ -829,7 +811,7 @@ export class SpokePoolClient extends BaseAbstractClient {
     );
     const tStop = Date.now();
 
-    const event = (query as V3FundsDepositedEvent[]).find((deposit) => deposit.args.depositId === depositId);
+    const event = query.find(({ args }) => args["depositId"] === depositId);
     if (event === undefined) {
       const srcChain = getNetworkName(this.chainId);
       const dstChain = getNetworkName(destinationChainId);
@@ -838,19 +820,18 @@ export class SpokePoolClient extends BaseAbstractClient {
           ` between ${srcChain} blocks [${searchBounds.low}, ${searchBounds.high}]`
       );
     }
-    const partialDeposit = spreadEventWithBlockNumber(event) as DepositWithBlock;
-    const { quoteBlock: quoteBlockNumber } = await this.computeRealizedLpFeePct(event);
 
-    // Append destination token and realized lp fee to deposit.
-    const deposit: DepositWithBlock = {
-      ...partialDeposit,
+    const deposit = {
+      ...spreadEventWithBlockNumber(event),
       originChainId: this.chainId,
-      quoteBlockNumber,
-      outputToken:
-        partialDeposit.outputToken === ZERO_ADDRESS
-          ? this.getDestinationTokenForDeposit({ ...partialDeposit, originChainId: this.chainId })
-          : partialDeposit.outputToken,
-    };
+      quoteBlockNumber: await this.getBlockNumber(Number(event.args["quoteTimestamp"])),
+      fromLiteChain: true, // To be updated immediately afterwards.
+      toLiteChain: true, // To be updated immediately afterwards.
+    } as DepositWithBlock;
+
+    if (deposit.outputToken === ZERO_ADDRESS) {
+      deposit.outputToken = this.getDestinationTokenForDeposit(deposit);
+    }
     deposit.fromLiteChain = this.isOriginLiteChain(deposit);
     deposit.toLiteChain = this.isDestinationLiteChain(deposit);
 

package/src/clients/mocks/MockConfigStoreClient.ts

@@ -1,7 +1,8 @@
 import assert from "assert";
 import winston from "winston";
-import { Contract, Event, ethers } from "ethers";
-import { EventSearchConfig, MakeOptional, isDefined, utf8ToHex } from "../../utils";
+import { Contract, ethers } from "ethers";
+import { Log } from "../../interfaces";
+import { getCurrentTime, EventSearchConfig, MakeOptional, isDefined, utf8ToHex } from "../../utils";
 import {
   AcrossConfigStoreClient,
   ConfigStoreUpdate,
@@ -60,7 +61,7 @@ export class MockConfigStoreClient extends AcrossConfigStoreClient {
     this.configStoreVersion = version;
   }
 
-  async _update(): Promise<ConfigStoreUpdate> {
+  _update(): Promise<ConfigStoreUpdate> {
     // Backwards compatibility for pre-existing MockConfigStoreClient users.
     if (this.eventManager === null) {
       return super._update();
@@ -72,7 +73,7 @@ export class MockConfigStoreClient extends AcrossConfigStoreClient {
     // Ensure an array for every requested event exists, in the requested order.
     // All requested event types must be populated in the array (even if empty).
     const globalConfigUpdateTimes: number[] = [];
-    const _events: Event[][] = eventNames.map(() => []);
+    const _events: Log[][] = eventNames.map(() => []);
     for (const event of this.eventManager.getEvents().flat()) {
       const idx = eventNames.indexOf(event.event as string);
       if (idx !== -1) {
@@ -80,15 +81,14 @@ export class MockConfigStoreClient extends AcrossConfigStoreClient {
       }
 
       if (event.event === "UpdatedGlobalConfig") {
-        const block = await event.getBlock();
-        globalConfigUpdateTimes.push(block.timestamp);
+        globalConfigUpdateTimes.push(getCurrentTime());
       }
     }
 
     // Transform 2d-events array into a record.
     const events = Object.fromEntries(eventNames.map((eventName, idx) => [eventName, _events[idx]]));
 
-    return {
+    return Promise.resolve({
       success: true,
       chainId: this.chainId as number,
       searchEndBlock: this.eventSearchConfig.toBlock || latestBlockSearched,
@@ -97,14 +97,14 @@ export class MockConfigStoreClient extends AcrossConfigStoreClient {
         globalConfigUpdateTimes,
         updatedTokenConfigEvents: events["UpdatedTokenConfig"],
       },
-    };
+    });
   }
 
-  updateGlobalConfig(key: string, value: string, overrides: EventOverrides = {}): Event {
+  updateGlobalConfig(key: string, value: string, overrides: EventOverrides = {}): Log {
     return this.generateConfig("UpdatedGlobalConfig", utf8ToHex(key), value, overrides);
   }
 
-  updateTokenConfig(key: string, value: string, overrides: EventOverrides = {}): Event {
+  updateTokenConfig(key: string, value: string, overrides: EventOverrides = {}): Log {
     // Verify that the key is a valid address
     if (ethers.utils.isAddress(key) === false) {
       throw new Error(`Invalid address: ${key}`);
@@ -112,7 +112,7 @@ export class MockConfigStoreClient extends AcrossConfigStoreClient {
     return this.generateConfig("UpdatedTokenConfig", key, value, overrides);
   }
 
-  private generateConfig(event: string, key: string, value: string, overrides: EventOverrides = {}): Event {
+  private generateConfig(event: string, key: string, value: string, overrides: EventOverrides = {}): Log {
     assert(this.eventManager !== null);
 
     const topics = [key, value];

package/src/clients/mocks/MockEvents.ts

@@ -1,17 +1,14 @@
 import assert from "assert";
-import { utils as ethersUtils, Event, providers } from "ethers";
+import { utils as ethersUtils } from "ethers";
 import { random } from "lodash";
-import { isDefined, randomAddress, toBN } from "../../utils";
+import { Log } from "../../interfaces";
+import { isDefined } from "../../utils";
 
 const { id, keccak256, toUtf8Bytes } = ethersUtils;
 export type EventOverrides = {
   blockNumber?: number;
 };
 
-type Block = providers.Block;
-type TransactionResponse = providers.TransactionResponse;
-type TransactionReceipt = providers.TransactionReceipt;
-
 type EthersEventTemplate = {
   address: string;
   event: string;
@@ -25,22 +22,9 @@ type EthersEventTemplate = {
 
 const eventManagers: { [chainId: number]: EventManager } = {};
 
-// May need to populate getTransaction and getTransactionReceipt if calling code starts using it.
-// https://docs.ethers.org/v5/api/providers/provider/#Provider-getTransaction
-const getTransaction = (): Promise<TransactionResponse> => {
-  throw new Error("getTransaction() not supported");
-};
-// https://docs.ethers.org/v5/api/providers/provider/#Provider-getTransactionReceipt
-const getTransactionReceipt = (): Promise<TransactionReceipt> => {
-  throw new Error("getTransactionReceipt() not supported");
-};
-const removeListener = (): void => {
-  throw new Error("removeListener not supported");
-};
-
 export class EventManager {
   private logIndexes: Record<string, number> = {};
-  public events: Event[] = [];
+  public events: Log[] = [];
   public readonly minBlockRange = 10;
   public readonly eventSignatures: Record<string, string> = {};
 
@@ -55,78 +39,44 @@ export class EventManager {
     });
   }
 
-  addEvent(event: Event): void {
+  addEvent(event: Log): void {
     this.events.push(event);
   }
 
-  getEvents(): Event[] {
+  getEvents(): Log[] {
     const events = this.events;
     this.events = [];
     return events;
   }
 
-  generateEvent(inputs: EthersEventTemplate): Event {
-    const { address, event, topics: _topics, data, args } = inputs;
-    const eventSignature = `${event}(${this.eventSignatures[event]})`;
-    const topics = [keccak256(toUtf8Bytes(eventSignature))].concat(_topics);
-
+  generateEvent(inputs: EthersEventTemplate): Log {
+    const { address, event, topics, data, args } = inputs;
     let { blockNumber, transactionIndex } = inputs;
+    const eventSignature = `${event}(${this.eventSignatures[event]})`;
 
     // Increment the block number by at least 1, by default. The caller may override
     // to force the same block number to be used, but never a previous block number.
     blockNumber ??= random(this.blockNumber + 1, this.blockNumber + this.minBlockRange, false);
     assert(blockNumber >= this.blockNumber, `${blockNumber} < ${this.blockNumber}`);
     this.blockNumber = blockNumber;
-
     transactionIndex ??= random(1, 32, false);
-    const transactionHash = id(`Across-${event}-${blockNumber}-${transactionIndex}-${random(1, 100_000)}`);
 
     const _logIndex = `${blockNumber}-${transactionIndex}`;
     this.logIndexes[_logIndex] ??= 0;
-    const logIndex = this.logIndexes[_logIndex]++;
-
-    const decodeError = new Error(`${event} decoding error`);
-    const parentHash = id(`Across-blockHash-${random(1, 100_000)}`);
-    const blockHash = id(`Across-blockHash-${parentHash}-${random(1, 100_000)}`);
-
-    // getBlock() may later be used to retrieve (for example) the block timestamp.
-    // @todo: If multiple events coincide on the same block number, this callback should return the same Block object.
-    const getBlock = (): Promise<Block> => {
-      return Promise.resolve({
-        hash: blockHash,
-        parentHash,
-        number: blockNumber as number,
-        timestamp: Math.floor(Date.now() / 1000),
-        nonce: "",
-        difficulty: random(1, 1000, false),
-        _difficulty: toBN(random(1, 1000, false)),
-        gasLimit: toBN(random(1_000_000, 10_000_000, false)),
-        gasUsed: toBN(random(1, 1000, false)),
-        miner: randomAddress(),
-        extraData: `Block containing test transaction ${transactionHash}.`,
-        transactions: [transactionHash],
-      });
-    };
 
     const generatedEvent = {
+      event,
       blockNumber,
       transactionIndex,
-      logIndex,
-      transactionHash,
+      logIndex: this.logIndexes[_logIndex]++,
+      transactionHash: id(`Across-${event}-${blockNumber}-${transactionIndex}-${random(1, 100_000)}`),
       removed: false,
       address,
       data: data ?? id(`Across-random-txndata-${random(1, 100_000)}`),
-      topics,
+      topics: [keccak256(toUtf8Bytes(eventSignature)), ...topics],
       args,
-      blockHash,
-      event,
-      eventSignature,
-      decodeError,
-      getBlock,
-      getTransaction,
-      getTransactionReceipt,
-      removeListener,
-    } as Event;
+      blockHash: id(`Across-blockHash-${random(1, 100_000)}`),
+    };
 
     this.addEvent(generatedEvent);
     return generatedEvent;

package/src/clients/mocks/MockHubPoolClient.ts

@@ -1,7 +1,7 @@
 import winston from "winston";
-import { Contract, Event } from "ethers";
+import { Contract } from "ethers";
 import { BigNumber, randomAddress, assign, bnZero } from "../../utils";
-import { L1Token, PendingRootBundle, RealizedLpFee } from "../../interfaces";
+import { L1Token, Log, PendingRootBundle, RealizedLpFee } from "../../interfaces";
 import { AcrossConfigStoreClient as ConfigStoreClient } from "../AcrossConfigStoreClient";
 import { HubPoolClient, HubPoolUpdate, LpFeeRequest } from "../HubPoolClient";
 import { EventManager, EventOverrides, getEventManager } from "./MockEvents";
@@ -127,7 +127,7 @@ export class MockHubPoolClient extends HubPoolClient {
 
     // Ensure an array for every requested event exists, in the requested order.
     // All requested event types must be populated in the array (even if empty).
-    const _events: Event[][] = eventNames.map(() => []);
+    const _events: Log[][] = eventNames.map(() => []);
     this.eventManager
       .getEvents()
       .flat()
@@ -163,7 +163,7 @@ export class MockHubPoolClient extends HubPoolClient {
     l1Token: string,
     destinationToken: string,
     overrides: EventOverrides = {}
-  ): Event {
+  ): Log {
     const event = "SetPoolRebalanceRoute";
 
     const topics = [destinationChainId, l1Token, destinationToken];
@@ -191,7 +191,7 @@ export class MockHubPoolClient extends HubPoolClient {
     slowRelayRoot?: string,
     proposer?: string,
     overrides: EventOverrides = {}
-  ): Event {
+  ): Log {
     const event = "ProposeRootBundle";
 
     poolRebalanceRoot ??= "XX";
@@ -229,7 +229,7 @@ export class MockHubPoolClient extends HubPoolClient {
     runningBalances: BigNumber[],
     caller?: string,
     overrides: EventOverrides = {}
-  ): Event {
+  ): Log {
     const event = "RootBundleExecuted";
 
     caller ??= randomAddress();