@across-protocol/sdk 3.1.36 → 3.2.0

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();

package/src/clients/mocks/MockSpokePoolClient.ts

@@ -1,13 +1,12 @@
 import assert from "assert";
-import { Contract, Event, providers } from "ethers";
+import { Contract } from "ethers";
 import { random } from "lodash";
 import winston from "winston";
 import { ZERO_ADDRESS } from "../../constants";
 import {
+  Log,
   DepositWithBlock,
   FillType,
-  V3FundsDepositedEvent,
-  RealizedLpFee,
   RelayerRefundExecutionWithBlock,
   SlowFillRequestWithBlock,
   Fill,
@@ -15,25 +14,20 @@ import {
   SlowFillLeaf,
   SpeedUp,
 } from "../../interfaces";
-import { BigNumber, bnZero, toBN, toBNWei, forEachAsync, getCurrentTime, randomAddress } from "../../utils";
+import { toBN, toBNWei, getCurrentTime, randomAddress } from "../../utils";
 import { SpokePoolClient, SpokePoolUpdate } from "../SpokePoolClient";
 import { HubPoolClient } from "../HubPoolClient";
 import { EventManager, EventOverrides, getEventManager } from "./MockEvents";
 import { AcrossConfigStoreClient } from "../AcrossConfigStoreClient";
 
-type Block = providers.Block;
-
-// This class replaces internal SpokePoolClient functionality, enabling the
-// user to bypass on-chain queries and inject ethers Event objects directly.
+// This class replaces internal SpokePoolClient functionality, enabling
+// the user to bypass on-chain queries and inject Log objects directly.
 export class MockSpokePoolClient extends SpokePoolClient {
   public eventManager: EventManager;
-  private realizedLpFeePct: BigNumber = bnZero;
-  private realizedLpFeePctOverride = false;
   private destinationTokenForChainOverride: Record<number, string> = {};
   // Allow tester to set the numberOfDeposits() returned by SpokePool at a block height.
   public depositIdAtBlock: number[] = [];
   public numberOfDeposits = 0;
-  public blocks: Record<number, Block> = {};
 
   constructor(
     logger: winston.Logger,
@@ -47,36 +41,10 @@ export class MockSpokePoolClient extends SpokePoolClient {
     this.eventManager = getEventManager(chainId, this.eventSignatures, deploymentBlock);
   }
 
-  setDefaultRealizedLpFeePct(fee: BigNumber): void {
-    this.realizedLpFeePct = fee;
-    this.realizedLpFeePctOverride = true;
-  }
-
   setConfigStoreClient(configStore?: AcrossConfigStoreClient): void {
     this.configStoreClient = configStore;
   }
 
-  clearDefaultRealizedLpFeePct(): void {
-    this.realizedLpFeePctOverride = false;
-  }
-
-  async computeRealizedLpFeePct(depositEvent: V3FundsDepositedEvent) {
-    const { realizedLpFeePct, realizedLpFeePctOverride } = this;
-    const { blockNumber: quoteBlock } = depositEvent;
-    return realizedLpFeePctOverride
-      ? { realizedLpFeePct, quoteBlock }
-      : await super.computeRealizedLpFeePct(depositEvent);
-  }
-
-  async batchComputeRealizedLpFeePct(depositEvents: V3FundsDepositedEvent[]): Promise<RealizedLpFee[]> {
-    const { realizedLpFeePct, realizedLpFeePctOverride } = this;
-    return realizedLpFeePctOverride
-      ? depositEvents.map(({ blockNumber: quoteBlock }) => {
-          return { realizedLpFeePct, quoteBlock };
-        })
-      : await super.batchComputeRealizedLpFeePct(depositEvents);
-  }
-
   setDestinationTokenForChain(chainId: number, token: string): void {
     this.destinationTokenForChainOverride[chainId] = token;
   }
@@ -107,33 +75,32 @@ export class MockSpokePoolClient extends SpokePoolClient {
     return Promise.resolve(this.depositIdAtBlock[blockTag]);
   }
 
-  async _update(eventsToQuery: string[]): Promise<SpokePoolUpdate> {
+  _update(eventsToQuery: string[]): Promise<SpokePoolUpdate> {
     // Generate new "on chain" responses.
     const latestBlockSearched = this.eventManager.blockNumber;
     const currentTime = getCurrentTime();
 
-    const blocks: { [blockNumber: number]: Block } = {};
-
     // 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[][] = eventsToQuery.map(() => []);
-    await forEachAsync(this.eventManager.getEvents().flat(), async (event) => {
-      const idx = eventsToQuery.indexOf(event.event as string);
-      if (idx !== -1) {
-        events[idx].push(event);
-        blocks[event.blockNumber] = await event.getBlock();
-      }
-    });
-    this.blocks = blocks;
+    const events: Log[][] = eventsToQuery.map(() => []);
+    this.eventManager
+      .getEvents()
+      .flat()
+      .forEach((event) => {
+        const idx = eventsToQuery.indexOf(event.event);
+        if (idx !== -1) {
+          events[idx].push(event);
+        }
+      });
 
     // Update latestDepositIdQueried.
     const idx = eventsToQuery.indexOf("V3FundsDeposited");
     const latestDepositId = (events[idx] ?? []).reduce(
-      (depositId, event) => Math.max(depositId, event.args?.["depositId"] ?? 0),
+      (depositId, event) => Math.max(depositId, (event.args["depositId"] ?? 0) as number),
       this.latestDepositIdQueried
     );
 
-    return {
+    return Promise.resolve({
       success: true,
       firstDepositId: 0,
       latestDepositId,
@@ -141,7 +108,7 @@ export class MockSpokePoolClient extends SpokePoolClient {
       oldestTime: 0,
       events,
       searchEndBlock: this.eventSearchConfig.toBlock || latestBlockSearched,
-    };
+    });
   }
 
   // Event signatures. Not strictly required, but they make generated events more recognisable.
@@ -151,7 +118,7 @@ export class MockSpokePoolClient extends SpokePoolClient {
     FundsDeposited: "uint256,uint256,uint256,int64,uint32,uint32,address,address,address,bytes",
   };
 
-  depositV3(deposit: DepositWithBlock): Event {
+  depositV3(deposit: DepositWithBlock): Log {
     const event = "V3FundsDeposited";
 
     const { blockNumber, transactionIndex } = deposit;
@@ -197,7 +164,7 @@ export class MockSpokePoolClient extends SpokePoolClient {
     });
   }
 
-  fillV3Relay(fill: FillWithBlock): Event {
+  fillV3Relay(fill: FillWithBlock): Log {
     const event = "FilledV3Relay";
 
     const { blockNumber, transactionIndex } = fill;
@@ -247,7 +214,7 @@ export class MockSpokePoolClient extends SpokePoolClient {
     });
   }
 
-  speedUpV3Deposit(speedUp: SpeedUp): Event {
+  speedUpV3Deposit(speedUp: SpeedUp): Log {
     const event = "RequestedSpeedUpV3Deposit";
     const topics = [speedUp.depositId, speedUp.depositor];
     const args = { ...speedUp };
@@ -260,7 +227,7 @@ export class MockSpokePoolClient extends SpokePoolClient {
     });
   }
 
-  requestV3SlowFill(request: SlowFillRequestWithBlock): Event {
+  requestV3SlowFill(request: SlowFillRequestWithBlock): Log {
     const event = "RequestedV3SlowFill";
 
     const { originChainId, depositId } = request;
@@ -279,7 +246,7 @@ export class MockSpokePoolClient extends SpokePoolClient {
 
   // This is a simple wrapper around fillV3Relay().
   // rootBundleId and proof are discarded here - we have no interest in verifying that.
-  executeV3SlowRelayLeaf(leaf: SlowFillLeaf): Event {
+  executeV3SlowRelayLeaf(leaf: SlowFillLeaf): Log {
     const fill: Fill = {
       ...leaf.relayData,
       destinationChainId: this.chainId,
@@ -296,7 +263,7 @@ export class MockSpokePoolClient extends SpokePoolClient {
     return this.fillV3Relay(fill as FillWithBlock);
   }
 
-  executeRelayerRefundLeaf(refund: RelayerRefundExecutionWithBlock): Event {
+  executeRelayerRefundLeaf(refund: RelayerRefundExecutionWithBlock): Log {
     const event = "ExecutedRelayerRefundRoot";
 
     const chainId = refund.chainId ?? this.chainId;
@@ -328,7 +295,7 @@ export class MockSpokePoolClient extends SpokePoolClient {
     destinationChainId: number,
     enabled: boolean,
     overrides: EventOverrides = {}
-  ): Event {
+  ): Log {
     const event = "EnabledDepositRoute";
 
     const topics = [originToken, destinationChainId];

package/src/contracts/utils.ts

@@ -1,5 +1,6 @@
 import assert from "assert";
-import { Event } from "ethers";
+// eslint-disable-next-line no-restricted-imports
+import { Event } from "@ethersproject/contracts";
 import { BigNumber, BigNumberish, isDefined } from "../utils";
 
 /**

package/src/interfaces/Common.ts

@@ -1,5 +1,12 @@
+import { Log as _Log } from "@ethersproject/abstract-provider";
 import { BigNumber } from "../utils";
 
+export type Log = _Log & {
+  event: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  args: { [key: string]: any };
+};
+
 export interface SortableEvent {
   blockNumber: number;
   transactionIndex: number;

package/src/utils/EventUtils.ts

@@ -1,17 +1,18 @@
 import { Result } from "@ethersproject/abi";
-import { delay } from "./common";
-import { SortableEvent } from "../interfaces";
+// eslint-disable-next-line no-restricted-imports
 import { Contract, Event, EventFilter } from "ethers";
+import { Log, SortableEvent } from "../interfaces";
+import { delay } from "./common";
 
 const maxRetries = 3;
 const retrySleepTime = 10;
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function spreadEvent(args: Result = {} as Result): any {
+export function spreadEvent(args: Result | Record<string, unknown>): { [key: string]: any } {
   const keys = Object.keys(args).filter((key: string) => isNaN(+key)); // Extract non-numeric keys.
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const returnedObject: any = {};
+  const returnedObject: { [key: string]: unknown } = {};
   keys.forEach((key: string) => {
     switch (typeof args[key]) {
       case "boolean": // fallthrough
@@ -67,15 +68,18 @@ export interface EventSearchConfig {
   maxBlockLookBack?: number;
 }
 
+export const eventToLog = (event: Event): Log => ({ ...event, event: event.event!, args: spreadEvent(event.args!) });
+
 export async function paginatedEventQuery(
   contract: Contract,
   filter: EventFilter,
   searchConfig: EventSearchConfig,
   retryCount = 0
-): Promise<Event[]> {
+): Promise<Log[]> {
   // If the max block look back is set to 0 then we dont need to do any pagination and can query over the whole range.
   if (searchConfig.maxBlockLookBack === 0) {
-    return await contract.queryFilter(filter, searchConfig.fromBlock, searchConfig.toBlock);
+    const events = await contract.queryFilter(filter, searchConfig.fromBlock, searchConfig.toBlock);
+    return events.map(eventToLog);
   }
 
   // Compute the number of queries needed. If there is no maxBlockLookBack set then we can execute the whole query in
@@ -93,6 +97,7 @@ export async function paginatedEventQuery(
         .flat()
         // Filter events by block number because ranges can include blocks that are outside the range specified for caching reasons.
         .filter((event) => event.blockNumber >= searchConfig.fromBlock && event.blockNumber <= searchConfig.toBlock)
+        .map(eventToLog)
     );
   } catch (error) {
     if (retryCount < maxRetries) {
@@ -163,7 +168,7 @@ export function getPaginatedBlockRanges({
   return ranges;
 }
 
-export function spreadEventWithBlockNumber(event: Event): SortableEvent {
+export function spreadEventWithBlockNumber(event: Log): SortableEvent {
   return {
     ...spreadEvent(event.args),
     blockNumber: event.blockNumber,