@across-protocol/sdk 4.4.0-alpha.9 → 4.4.1

package/src/clients/BundleDataClient/utils/DataworkerUtils.ts

@@ -194,7 +194,7 @@ export async function _buildPoolRebalanceRoot(
  * @param clients Clients required to construct a new pool rebalance root.
  * @maxL1TokenCountOverride Optional parameter to cap the number of tokens in a single pool rebalance leaf.
  */
-export function _buildHistoricalPoolRebalanceRoot(
+export async function _buildHistoricalPoolRebalanceRoot(
   latestMainnetBlock: number,
   mainnetBundleEndBlock: number,
   bundleV3Deposits: BundleDepositsV3,
@@ -207,7 +207,7 @@ export function _buildHistoricalPoolRebalanceRoot(
     configStoreClient: AcrossConfigStoreClient;
   },
   maxL1TokenCountOverride?: number
-): PoolRebalanceRoot {
+): Promise<PoolRebalanceRoot> {
   const { runningBalances, realizedLpFees, chainWithRefundsOnly } = _getMarginalRunningBalances(
     mainnetBundleEndBlock,
     bundleV3Deposits,
@@ -217,7 +217,7 @@ export function _buildHistoricalPoolRebalanceRoot(
     expiredDepositsToRefundV3,
     clients
   );
-  addLastRunningBalance(latestMainnetBlock, runningBalances, clients.hubPoolClient);
+  await addLastRunningBalance(latestMainnetBlock, runningBalances, clients.hubPoolClient);
   const leaves: PoolRebalanceLeaf[] = constructPoolRebalanceLeaves(
     mainnetBundleEndBlock,
     runningBalances,
@@ -286,7 +286,7 @@ export async function _buildOptimisticPoolRebalanceRoot(
     true
   );
   // Build the pool rebalance root for the pending root bundle.
-  const { leaves, tree } = _buildHistoricalPoolRebalanceRoot(
+  const { leaves, tree } = await _buildHistoricalPoolRebalanceRoot(
     latestMainnetBlock,
     blockRangesForChains[0][1],
     pendingRootBundleData.bundleDepositsV3,
@@ -302,9 +302,8 @@ export async function _buildOptimisticPoolRebalanceRoot(
 
   // Only add marginal pending running balances if there is already an entry in `runningBalances`. If there is no entry in `runningBalances`, then
   // The running balance for this entry was unchanged since the last root bundle.
-  Object.keys(runningBalances).forEach((_repaymentChainId) => {
-    Object.keys(runningBalances[Number(_repaymentChainId)]).forEach((_l1TokenAddress) => {
-      const repaymentChainId = Number(_repaymentChainId);
+  for (const repaymentChainId of Object.keys(runningBalances).map(Number)) {
+    for (const _l1TokenAddress of Object.keys(runningBalances[repaymentChainId])) {
       const l1TokenAddress = EvmAddress.from(_l1TokenAddress);
       const pendingPoolRebalanceLeaf = leaves.find(
         (leaf) => leaf.chainId === repaymentChainId && leaf.l1Tokens.some((l1Token) => l1Token.eq(l1TokenAddress))
@@ -322,7 +321,7 @@ export async function _buildOptimisticPoolRebalanceRoot(
       } else {
         // Otherwise, add the last running balance for this token.
         const { runningBalance: lastExecutedBundleRunningBalance } =
-          clients.hubPoolClient.getRunningBalanceBeforeBlockForChain(
+          await clients.hubPoolClient.getRunningBalanceBeforeBlockForChain(
             latestMainnetBlock,
             repaymentChainId,
             l1TokenAddress
@@ -331,8 +330,8 @@ export async function _buildOptimisticPoolRebalanceRoot(
           updateRunningBalance(runningBalances, repaymentChainId, _l1TokenAddress, lastExecutedBundleRunningBalance);
         }
       }
-    });
-  });
+    }
+  }
   const poolRebalanceLeaves: PoolRebalanceLeaf[] = constructPoolRebalanceLeaves(
     mainnetBundleEndBlock,
     runningBalances,

package/src/clients/BundleDataClient/utils/PoolRebalanceUtils.ts

@@ -2,7 +2,7 @@ import { MerkleTree } from "@across-protocol/contracts/dist/utils/MerkleTree";
 import { RunningBalances, PoolRebalanceLeaf, Clients, SpokePoolTargetBalance } from "../../../interfaces";
 import { isSVMSpokePoolClient, SpokePoolClient } from "../../SpokePoolClient";
 import { BigNumber, bnZero, chainIsEvm, chainIsSvm, compareAddresses, EvmAddress, isDefined } from "../../../utils";
-import { getLatestFinalizedSlotWithBlock } from "../../../arch/svm";
+import { getNearestSlotTime } from "../../../arch/svm";
 import { HubPoolClient } from "../../HubPoolClient";
 import { V3DepositWithBlock } from "./shims";
 import { AcrossConfigStoreClient } from "../../AcrossConfigStoreClient";
@@ -36,16 +36,21 @@ export async function getWidestPossibleExpectedBlockRange(
     Math.max(spokeClients[chainId].latestHeightSearched - endBlockBuffers[idx], 0);
 
   // Across bundles are bounded by slots on Solana. The UMIP requires that the bundle end slot is backed by a block.
-  const resolveSVMEndBlock = (chainId: number, idx: number): Promise<number> => {
+  const resolveSVMEndBlock = async (chainId: number, idx: number): Promise<number> => {
     const spokePoolClient = spokeClients[chainId];
     assert(isSVMSpokePoolClient(spokePoolClient));
 
-    const maxSlot = resolveEndBlock(chainId, idx); // Respect any configured buffer for Solana.
-    return getLatestFinalizedSlotWithBlock(
-      spokePoolClient.svmEventsClient.getRpc(),
-      spokePoolClient.logger,
-      BigInt(maxSlot)
-    );
+    const provider = spokePoolClient.svmEventsClient.getRpc();
+    const { logger } = spokePoolClient;
+    const maxSlot = BigInt(resolveEndBlock(chainId, idx)); // Respect any configured buffer for Solana.
+
+    let slot: bigint;
+    let opts: { slot: bigint } | { commitment: "finalized" } = { commitment: "finalized" };
+    do {
+      ({ slot } = await getNearestSlotTime(provider, opts, logger));
+      opts = { slot: maxSlot };
+    } while (slot > maxSlot);
+    return Number(slot);
   };
 
   const latestPossibleBundleEndBlockNumbers = await Promise.all(
@@ -179,23 +184,23 @@ export function updateRunningBalance(
   }
 }
 
-export function addLastRunningBalance(
+export async function addLastRunningBalance(
   latestMainnetBlock: number,
   runningBalances: RunningBalances,
   hubPoolClient: HubPoolClient
-): void {
-  Object.keys(runningBalances).forEach((repaymentChainId) => {
-    Object.keys(runningBalances[Number(repaymentChainId)]).forEach((l1TokenAddress) => {
-      const { runningBalance } = hubPoolClient.getRunningBalanceBeforeBlockForChain(
+): Promise<void> {
+  for (const repaymentChainId of Object.keys(runningBalances).map(Number)) {
+    for (const l1TokenAddress of Object.keys(runningBalances[repaymentChainId])) {
+      const { runningBalance } = await hubPoolClient.getRunningBalanceBeforeBlockForChain(
         latestMainnetBlock,
-        Number(repaymentChainId),
+        repaymentChainId,
         EvmAddress.from(l1TokenAddress)
       );
       if (!runningBalance.eq(bnZero)) {
-        updateRunningBalance(runningBalances, Number(repaymentChainId), l1TokenAddress, runningBalance);
+        updateRunningBalance(runningBalances, repaymentChainId, l1TokenAddress, runningBalance);
       }
-    });
-  });
+    }
+  }
 }
 
 export function updateRunningBalanceForDeposit(

package/src/clients/BundleDataClient/utils/SuperstructUtils.ts

@@ -14,8 +14,12 @@ import {
   union,
   type,
 } from "superstruct";
-import { CHAIN_IDs, UNDEFINED_MESSAGE_HASH } from "../../../constants";
-import { BigNumber, EvmAddress, RawAddress, SvmAddress, toAddressType, toBytes32 } from "../../../utils";
+import { utils as ethersUtils } from "ethers";
+import { isAddress as isValidEvmAddress } from "viem";
+import { isAddress as isValidSvmAddress } from "@solana/kit";
+import { TronWeb } from "tronweb";
+import { UNDEFINED_MESSAGE_HASH } from "../../../constants";
+import { BigNumber, bs58, EvmAddress, RawAddress, SvmAddress, TvmAddress, toBytes32 } from "../../../utils";
 
 const PositiveIntegerStringSS = pattern(string(), /\d+/);
 const Web3AddressSS = pattern(string(), /^0x[a-fA-F0-9]{64}$/);
@@ -31,16 +35,26 @@ const BigNumberType = coerce(instance(BigNumber), union([string(), number()]), (
   }
 });
 
-// Accept any concrete implementation of `Address` (Evm, Svm, or Raw) but avoid using the
-// abstract `Address` class directly to keep TypeScript happy.
-const AddressInstanceSS = union([instance(EvmAddress), instance(SvmAddress), instance(RawAddress)]);
-
-const AddressType = coerce(AddressInstanceSS, string(), (value) => {
-  // Addresses are posted to arweave in their native format (base16 for EVM, base58 for SVM). The chainId for
-  // for the event data is not directly available, so infer it based on the shape of the address. RawAddress
-  // will be instantiated if the address format does not match the expected family.
-  const chainId = value.startsWith("0x") ? CHAIN_IDs.MAINNET : CHAIN_IDs.SOLANA;
-  return toAddressType(value, chainId);
+const AddressInstanceSS = union([
+  instance(EvmAddress),
+  instance(SvmAddress),
+  instance(TvmAddress),
+  instance(RawAddress),
+]);
+
+export const AddressType = coerce(AddressInstanceSS, string(), (value) => {
+  // Each family is matched by its native-format validator plus a length gate where it
+  // disambiguates. Unknown shapes fall to `RawAddress`, forcing future families into explicit
+  // branches rather than being absorbed silently.
+  try {
+    // strict: false preserves the prior byte-level acceptance of all-upper / non-checksummed hex.
+    if (value.length === 42 && isValidEvmAddress(value, { strict: false })) return EvmAddress.from(value);
+    if (value.length === 34 && TronWeb.isAddress(value)) return TvmAddress.from(value);
+    if (isValidSvmAddress(value)) return SvmAddress.from(value);
+  } catch {
+    // Validator accepted but `from()` rejected (e.g. SVM 12-zero EVM-masquerade) → RawAddress.
+  }
+  return new RawAddress(value.startsWith("0x") ? ethersUtils.arrayify(value) : bs58.decode(value));
 });
 
 const Web3AddressType = coerce(Web3AddressSS, string(), (value) => {

package/src/clients/HubPoolClient.ts

@@ -40,7 +40,6 @@ import {
   shouldCache,
   sortEventsDescending,
   spreadEventWithBlockNumber,
-  toBN,
   getTokenInfo,
   getUsdcSymbol,
   chainIsSvm,
@@ -133,6 +132,26 @@ export class HubPoolClient extends BaseAbstractClient {
     };
   }
 
+  // Decode a RootBundleExecuted log and normalize it into ExecutedRootBundle. runningBalances may carry
+  // incentive balances in the second half — keep only the first nTokens entries, matching the on-chain layout.
+  private decodeExecutedRootBundle(event: Log): ExecutedRootBundle {
+    const spread = spreadEventWithBlockNumber(event) as Omit<ExecutedRootBundle, "l1Tokens"> & {
+      l1Tokens: string[];
+    };
+    const nTokens = spread.l1Tokens.length;
+    if (![nTokens, nTokens * 2].includes(spread.runningBalances.length)) {
+      throw new Error(
+        `Invalid runningBalances length: ${spread.runningBalances.length}.` +
+          ` Expected ${nTokens} or ${nTokens * 2} for chain ${this.chainId} transaction ${spread.txnRef}`
+      );
+    }
+    return {
+      ...spread,
+      runningBalances: spread.runningBalances.slice(0, nTokens),
+      l1Tokens: spread.l1Tokens.map((token) => EvmAddress.from(token)),
+    };
+  }
+
   hasPendingProposal(): boolean {
     return this.pendingRootBundle !== undefined;
   }
@@ -803,8 +822,36 @@ export class HubPoolClient extends BaseAbstractClient {
     });
   }
 
-  getRunningBalanceBeforeBlockForChain(block: number, chain: number, l1Token: EvmAddress): TokenRunningBalance {
-    const executedRootBundle = this.getLatestExecutedRootBundleContainingL1Token(block, chain, l1Token);
+  async getRunningBalanceBeforeBlockForChain(
+    block: number,
+    chain: number,
+    l1Token: EvmAddress
+  ): Promise<TokenRunningBalance> {
+    let executedRootBundle = this.getLatestExecutedRootBundleContainingL1Token(block, chain, l1Token);
+
+    // `executedRootBundles` only spans the configured event lookback. If there's no balance update for this
+    // (chain, l1Token) within it, query the preceding history on the fly before assuming a zero running
+    // balance -- otherwise a balance carried by a token idle longer than the lookback is silently dropped,
+    // under-pulling spoke liquidity.
+    if (!isDefined(executedRootBundle)) {
+      const to = this.eventSearchConfig.from - 1; // the range preceding the already-loaded lookback window
+      if (to >= this.deploymentBlock) {
+        const events = await paginatedEventQuery(this.hubPool, this.hubPool.filters.RootBundleExecuted(), {
+          from: this.deploymentBlock,
+          to,
+          maxLookBack: this.eventSearchConfig.maxLookBack,
+        });
+        const historical = events
+          .filter((event) => !this.configOverride.ignoredHubExecutedBundles.includes(event.blockNumber))
+          .map((event) => this.decodeExecutedRootBundle(event));
+        executedRootBundle = sortEventsDescending(historical).find(
+          (executedLeaf) =>
+            executedLeaf.blockNumber <= block &&
+            executedLeaf.chainId === chain &&
+            executedLeaf.l1Tokens.some((token) => token.eq(l1Token))
+        );
+      }
+    }
 
     return this.getRunningBalanceForToken(l1Token, executedRootBundle);
   }
@@ -813,7 +860,7 @@ export class HubPoolClient extends BaseAbstractClient {
     l1Token: EvmAddress,
     executedRootBundle: ExecutedRootBundle | undefined
   ): TokenRunningBalance {
-    let runningBalance = toBN(0);
+    let runningBalance = bnZero;
     if (executedRootBundle) {
       const indexOfL1Token = executedRootBundle.l1Tokens.findIndex((tokenInBundle) => tokenInBundle.eq(l1Token));
       if (indexOfL1Token !== -1) {
@@ -1067,26 +1114,7 @@ export class HubPoolClient extends BaseAbstractClient {
         if (this.configOverride.ignoredHubExecutedBundles.includes(event.blockNumber)) {
           continue;
         }
-
-        // Set running balances and incentive balances for this bundle.
-        const executedRootBundle = spreadEventWithBlockNumber(event) as Omit<ExecutedRootBundle, "l1Tokens"> & {
-          l1Tokens: string[];
-        };
-        const { l1Tokens, runningBalances } = executedRootBundle;
-        const nTokens = l1Tokens.length;
-
-        // Safeguard
-        if (![nTokens, nTokens * 2].includes(runningBalances.length)) {
-          throw new Error(
-            `Invalid runningBalances length: ${runningBalances.length}.` +
-              ` Expected ${nTokens} or ${nTokens * 2} for chain ${this.chainId} transaction ${event.transactionHash}`
-          );
-        }
-        executedRootBundle.runningBalances = runningBalances.slice(0, nTokens);
-        this.executedRootBundles.push({
-          ...executedRootBundle,
-          l1Tokens: l1Tokens.map((l1Token) => EvmAddress.from(l1Token)),
-        });
+        this.executedRootBundles.push(this.decodeExecutedRootBundle(event));
       }
     }
 

package/src/clients/SpokePoolClient/EVMSpokePoolClient.ts

@@ -20,7 +20,6 @@ import {
   getNetworkName,
   InvalidFill,
   MakeOptional,
-  toBN,
   EvmAddress,
   unpackDepositEvent,
   chainIsTvm,
@@ -59,8 +58,13 @@ export class EVMSpokePoolClient extends SpokePoolClient {
   }
 
   public override relayFillStatus(relayData: RelayData, atHeight?: number): Promise<FillStatus> {
-    const fillStatusHandler = this.tvm ? relayFillStatusTvm : relayFillStatus;
-    return fillStatusHandler(this.spokePool, relayData, atHeight, this.chainId);
+    if (this.tvm) {
+      return relayFillStatusTvm(this.spokePool, relayData, atHeight, this.chainId, {
+        from: this.deploymentBlock,
+        maxLookBack: this.eventSearchConfig.maxLookBack,
+      });
+    }
+    return relayFillStatus(this.spokePool, relayData, atHeight, this.chainId);
   }
 
   public override fillStatusArray(relayData: RelayData[], atHeight?: number): Promise<(FillStatus | undefined)[]> {
@@ -68,8 +72,16 @@ export class EVMSpokePoolClient extends SpokePoolClient {
   }
 
   public override getMaxFillDeadlineInRange(startBlock: number, endBlock: number): Promise<number> {
-    const maxFillDeadlineInRangeHandler = this.tvm ? getMaxFillDeadlineTvm : getMaxFillDeadline;
-    return maxFillDeadlineInRangeHandler(this.spokePool, startBlock, endBlock);
+    // Clamp startBlock to the SpokePool's deployment block; reading state at
+    // an earlier block reverts because the contract did not yet exist.
+    const effectiveStartBlock = Math.max(startBlock, this.deploymentBlock);
+
+    if (this.tvm) {
+      return getMaxFillDeadlineTvm(this.spokePool, effectiveStartBlock, endBlock, {
+        maxLookBack: this.eventSearchConfig.maxLookBack,
+      });
+    }
+    return getMaxFillDeadline(this.spokePool, effectiveStartBlock, endBlock);
   }
 
   private _availableEventsOnSpoke(eventNames: string[] = knownEventNames): { [eventName: string]: EventFilter } {
@@ -86,38 +98,17 @@ export class EVMSpokePoolClient extends SpokePoolClient {
 
   /**
    * Retrieve the on-chain time at a specific block.
-   * EVM reads SpokePool.getCurrentTime() via multicall with a historical blockTag.
+   * Reads the block timestamp, which is well-supported for historical queries on both EVM and TVM.
    * @param blockNumber The block number to query.
    * @returns The on-chain time as a number.
    */
   protected async _getCurrentTime(blockNumber: number): Promise<number> {
-    if (this.tvm) {
-      const block = await this.spokePool.provider.getBlock(blockNumber);
-      const currentTime = block.timestamp;
-      if (currentTime < this.currentTime) {
-        throw new Error(`EVMSpokePoolClient::_getCurrentTimeTvm: currentTime: ${currentTime} < ${this.currentTime}`);
-      }
-      return currentTime;
-    }
-    const { spokePool } = this;
-    const multicallFunctions = ["getCurrentTime"];
-    const multicallOutput = await spokePool.callStatic.multicall(
-      multicallFunctions.map((f) => spokePool.interface.encodeFunctionData(f)),
-      { blockTag: blockNumber }
-    );
-
-    const [currentTime] = multicallFunctions.map(
-      (fn, idx) => spokePool.interface.decodeFunctionResult(fn, multicallOutput[idx])[0]
-    );
-
-    if (!BigNumber.isBigNumber(currentTime) || currentTime.lt(this.currentTime)) {
-      const errMsg = BigNumber.isBigNumber(currentTime)
-        ? `currentTime: ${currentTime} < ${toBN(this.currentTime)}`
-        : `currentTime is not a BigNumber: ${JSON.stringify(currentTime)}`;
-      throw new Error(`EVMSpokePoolClient::update: ${errMsg}`);
+    const block = await this.spokePool.provider.getBlock(blockNumber);
+    const currentTime = block.timestamp;
+    if (currentTime < this.currentTime) {
+      throw new Error(`EVMSpokePoolClient::_getCurrentTime: currentTime: ${currentTime} < ${this.currentTime}`);
     }
-
-    return currentTime.toNumber();
+    return currentTime;
   }
 
   protected override async _update(eventsToQuery: string[]): Promise<SpokePoolUpdate> {
@@ -234,8 +225,12 @@ export class EVMSpokePoolClient extends SpokePoolClient {
    * TVM overrides this with an event-based lookup.
    */
   protected _findDepositBlock(depositId: BigNumber, lowBlock: number, highBlock?: number): Promise<number | undefined> {
-    const findDepositBlockHandler = this.tvm ? findDepositBlockTvm : findDepositBlock;
-    return findDepositBlockHandler(this.spokePool, depositId, lowBlock, highBlock);
+    if (this.tvm) {
+      return findDepositBlockTvm(this.spokePool, depositId, lowBlock, highBlock, {
+        maxLookBack: this.eventSearchConfig.maxLookBack,
+      });
+    }
+    return findDepositBlock(this.spokePool, depositId, lowBlock, highBlock);
   }
 
   protected async queryDepositEvents(

package/src/clients/SpokePoolClient/SVMSpokePoolClient.ts

@@ -155,11 +155,11 @@ export class SVMSpokePoolClient extends SpokePoolClient {
         );
         return events.map(
           (event): SortableEvent => ({
+            ...unwrapEventData(event.data),
             txnRef: event.signature,
             blockNumber: Number(event.slot),
             txnIndex: 0,
             logIndex: 0,
-            ...(unwrapEventData(event.data) as Record<string, unknown>),
           })
         );
       }),

package/src/clients/SpokePoolClient/SpokePoolClient.ts

@@ -501,7 +501,7 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
    * @see _update
    */
   public async update(eventsToQuery = this._queryableEventNames()): Promise<void> {
-    const duplicateEvents: SortableEvent[] = [];
+    const duplicateEvents: { incoming: SortableEvent; existing: SortableEvent }[] = [];
     if (this.hubPoolClient !== null && !this.hubPoolClient.isUpdated) {
       throw new Error("HubPoolClient not updated");
     }
@@ -552,8 +552,9 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
         if (this.depositHashes[getRelayEventKey(deposit)] !== undefined) {
           // Sanity check that this event is not a duplicate, even though the relay data hash is a duplicate.
           const allDeposits = this._getDuplicateDeposits(deposit).concat(this.depositHashes[getRelayEventKey(deposit)]);
-          if (allDeposits.some((e) => duplicateEvent(deposit, e))) {
-            duplicateEvents.push(event);
+          const existing = allDeposits.find((e) => duplicateEvent(deposit, e));
+          if (existing !== undefined) {
+            duplicateEvents.push({ incoming: deposit, existing });
             continue;
           }
           assign(this.duplicateDepositHashes, [getRelayEventKey(deposit)], [deposit]);
@@ -650,8 +651,9 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
         const depositHash = getRelayEventKey(slowFillRequest);
 
         // Sanity check that this event is not a duplicate.
-        if (this.slowFillRequests[depositHash] !== undefined) {
-          duplicateEvents.push(slowFillRequest);
+        const existing = this.slowFillRequests[depositHash];
+        if (existing !== undefined) {
+          duplicateEvents.push({ incoming: slowFillRequest, existing });
           continue;
         }
 
@@ -680,9 +682,9 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
       // test that the types are complete. A broader change in strategy for safely unpacking events will be introduced.
       for (const fill of fillEvents) {
         // Sanity check that this event is not a duplicate.
-        const duplicateFill = this.fills[fill.originChainId]?.find((f) => duplicateEvent(fill, f));
-        if (duplicateFill) {
-          duplicateEvents.push(fill);
+        const existing = this.fills[fill.originChainId]?.find((f) => duplicateEvent(fill, f));
+        if (existing !== undefined) {
+          duplicateEvents.push({ incoming: fill, existing });
           continue;
         }
 
@@ -756,10 +758,7 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     }
 
     if (duplicateEvents.length > 0) {
-      this.log("debug", "Duplicate events listed", {
-        duplicateEvents,
-      });
-      this.log("error", "Duplicate events detected, check debug logs");
+      this.log("debug", "Duplicate events detected.", { duplicateEvents });
     }
 
     // Next iteration should start off from where this one ended.

package/src/clients/mocks/MockConfigStoreClient.ts

@@ -2,21 +2,15 @@ import assert from "assert";
 import winston from "winston";
 import { Contract, ethers } from "ethers";
 import { Log } from "../../interfaces";
-import {
-  getCurrentTime,
-  EventSearchConfig,
-  MakeOptional,
-  isDefined,
-  utf8ToHex,
-  spreadEventWithBlockNumber,
-} from "../../utils";
+import { getCurrentTime, EventSearchConfig, MakeOptional, utf8ToHex, spreadEventWithBlockNumber } from "../../utils";
 import {
   AcrossConfigStoreClient,
   ConfigStoreUpdate,
   DEFAULT_CONFIG_STORE_VERSION,
   GLOBAL_CONFIG_STORE_KEYS,
 } from "../AcrossConfigStoreClient";
-import { EventManager, EventOverrides, getEventManager } from "./MockEvents";
+import { CHAIN_IDs } from "../../constants";
+import { EventManager, EventOverrides } from "./MockEvents";
 
 export class MockConfigStoreClient extends AcrossConfigStoreClient {
   public configStoreVersion = DEFAULT_CONFIG_STORE_VERSION;
@@ -35,17 +29,21 @@ export class MockConfigStoreClient extends AcrossConfigStoreClient {
     configStore: Contract,
     eventSearchConfig: MakeOptional<EventSearchConfig, "to"> = { from: 0, maxLookBack: 0 },
     configStoreVersion: number,
-    chainId = 1,
+    chainId = CHAIN_IDs.MAINNET,
     mockUpdate = false,
-    availableChainIdsOverride?: number[]
+    availableChainIdsOverride?: number[],
+    opts: { eventManager?: EventManager } = {}
   ) {
     super(logger, configStore, eventSearchConfig, configStoreVersion);
     this.chainId = chainId;
-    this.eventManager = mockUpdate ? getEventManager(chainId, this.eventSignatures) : null;
-    if (isDefined(this.eventManager) && this.eventManager) {
+    if (mockUpdate) {
+      this.eventManager = opts.eventManager ?? new EventManager();
+      this.eventManager.addEventSignatures(this.eventSignatures);
       this.updateGlobalConfig(GLOBAL_CONFIG_STORE_KEYS.CHAIN_ID_INDICES, JSON.stringify(availableChainIdsOverride), {
         blockNumber: this.eventManager.blockNumber,
       });
+    } else {
+      this.eventManager = null;
     }
   }
 

package/src/clients/mocks/MockEvents.ts

@@ -20,8 +20,6 @@ type EthersEventTemplate = {
   transactionIndex?: number;
 };
 
-const eventManagers: { [chainId: number]: EventManager } = {};
-
 export class EventManager {
   private logIndexes: Record<string, number> = {};
   public events: Log[] = [];
@@ -49,6 +47,14 @@ export class EventManager {
     return events;
   }
 
+  // Reset internal state. Useful when a long-lived EventManager instance is
+  // reused across test contexts that begin at different block numbers.
+  reset(blockNumber = 0): void {
+    this.blockNumber = blockNumber;
+    this.logIndexes = {};
+    this.events = [];
+  }
+
   generateEvent(inputs: EthersEventTemplate): Log {
     const { address, event, topics, data, args } = inputs;
     let { blockNumber, transactionIndex } = inputs;
@@ -82,25 +88,3 @@ export class EventManager {
     return generatedEvent;
   }
 }
-
-/**
- * @description Retrieve an instance of the EventManager for a specific chain, or instantiate a new one.
- * @param chainId Chain ID to retrieve EventManager for.
- * @param eventSignatures Event Signatures to append to EventManager instance.
- * @param Initial blockNumber to use if a new EventManager is instantiated.
- * @returns EventManager instance for chain ID.
- */
-export function getEventManager(
-  chainId: number,
-  eventSignatures?: Record<string, string>,
-  blockNumber?: number
-): EventManager {
-  if (!isDefined(eventManagers[chainId])) {
-    eventManagers[chainId] = new EventManager(blockNumber);
-  }
-  const eventManager = eventManagers[chainId];
-  if (isDefined(eventSignatures)) {
-    eventManager.addEventSignatures(eventSignatures);
-  }
-  return eventManager;
-}

package/src/clients/mocks/MockHubPoolClient.ts

@@ -4,8 +4,8 @@ import { BigNumber, randomAddress, assign, bnZero, toAddressType, EvmAddress, Ad
 import { Log, PendingRootBundle, RealizedLpFee, L1TokenInfo } from "../../interfaces";
 import { AcrossConfigStoreClient as ConfigStoreClient } from "../AcrossConfigStoreClient";
 import { HubPoolClient, HubPoolUpdate, LpFeeRequest } from "../HubPoolClient";
-import { EventManager, EventOverrides, getEventManager } from "./MockEvents";
-import { ZERO_ADDRESS } from "../../constants";
+import { EventManager, EventOverrides } from "./MockEvents";
+import { CHAIN_IDs, ZERO_ADDRESS } from "../../constants";
 
 const emptyRootBundle: PendingRootBundle = {
   poolRebalanceRoot: "",
@@ -34,10 +34,12 @@ export class MockHubPoolClient extends HubPoolClient {
     hubPool: Contract,
     configStoreClient: ConfigStoreClient,
     deploymentBlock = 0,
-    chainId = 1
+    chainId = CHAIN_IDs.MAINNET,
+    opts: { eventManager?: EventManager } = {}
   ) {
     super(logger, hubPool, configStoreClient, deploymentBlock, chainId);
-    this.eventManager = getEventManager(chainId, this.eventSignatures, deploymentBlock);
+    this.eventManager = opts.eventManager ?? new EventManager(deploymentBlock);
+    this.eventManager.addEventSignatures(this.eventSignatures);
   }
 
   setDefaultRealizedLpFeePct(fee: BigNumber): void {

package/src/clients/mocks/MockSpokePoolClient.ts

@@ -33,7 +33,7 @@ import {
 } from "../../utils";
 import { EVMSpokePoolClient, SpokePoolUpdate } from "../SpokePoolClient";
 import { HubPoolClient } from "../HubPoolClient";
-import { EventManager, EventOverrides, getEventManager } from "./MockEvents";
+import { EventManager, EventOverrides } from "./MockEvents";
 import { AcrossConfigStoreClient } from "../AcrossConfigStoreClient";
 
 // This class replaces internal SpokePoolClient functionality, enabling
@@ -50,11 +50,12 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
     spokePool: Contract,
     chainId: number,
     deploymentBlock: number,
-    opts: { hubPoolClient: HubPoolClient | null } = { hubPoolClient: null }
+    opts: { hubPoolClient?: HubPoolClient | null; eventManager?: EventManager } = {}
   ) {
-    super(logger, spokePool, opts.hubPoolClient, chainId, deploymentBlock);
+    super(logger, spokePool, opts.hubPoolClient ?? null, chainId, deploymentBlock);
     this.latestHeightSearched = deploymentBlock;
-    this.eventManager = getEventManager(chainId, this.eventSignatures, deploymentBlock);
+    this.eventManager = opts.eventManager ?? new EventManager(deploymentBlock);
+    this.eventManager.addEventSignatures(this.eventSignatures);
   }
 
   setConfigStoreClient(configStore?: AcrossConfigStoreClient): void {

package/src/clients/mocks/MockSvmCpiEventsClient.ts

@@ -5,7 +5,7 @@ import { hexlify, arrayify, hexZeroPad } from "ethers/lib/utils";
 import { random } from "lodash";
 import { Address, UnixTimestamp, signature } from "@solana/kit";
 import { Idl } from "@coral-xyz/anchor";
-import { SvmSpokeClient } from "../../svm";
+import { SvmSpokeClient } from "@across-protocol/contracts";
 import { CHAIN_IDs } from "@across-protocol/constants";
 
 import { MockSolanaRpcFactory } from "../../providers/mocks";

package/src/clients/mocks/MockSvmSpokePoolClient.ts

@@ -1,5 +1,5 @@
 import winston from "winston";
-import { SvmSpokeClient } from "../../svm";
+import { SvmSpokeClient } from "@across-protocol/contracts";
 import { Address } from "@solana/kit";
 import { DepositWithBlock, RelayerRefundExecution, SortableEvent, SlowFillLeaf, Log } from "../../interfaces";
 import {
@@ -75,11 +75,11 @@ export class MockSvmSpokePoolClient extends SVMSpokePoolClient {
     const eventsWithBlockNumber = events.map((eventList) =>
       eventList.map((event) => {
         return {
+          ...unwrapEventData(event.data),
           txnRef: event.signature,
           blockNumber: Number(event.slot),
           txnIndex: 0,
           logIndex: 0,
-          ...(unwrapEventData(event.data) as Record<string, unknown>),
         };
       })
     );