@across-protocol/sdk 4.1.63-beta.0 → 4.1.63

package/dist/types/utils/TokenUtils.d.ts

@@ -113,6 +113,15 @@ export declare const resolveContractFromSymbol: (symbol: string, chainId: string
         };
         coingeckoId: string;
     };
+    ezETH: {
+        name: string;
+        symbol: string;
+        decimals: number;
+        addresses: {
+            [x: number]: string;
+        };
+        coingeckoId: string;
+    };
     GHO: {
         name: string;
         symbol: string;
@@ -519,6 +528,15 @@ export declare function getTokenInfo(l2TokenAddress: string, chainId: number, to
         };
         coingeckoId: string;
     };
+    ezETH: {
+        name: string;
+        symbol: string;
+        decimals: number;
+        addresses: {
+            [x: number]: string;
+        };
+        coingeckoId: string;
+    };
     GHO: {
         name: string;
         symbol: string;

package/dist/types/utils/TokenUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TokenUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/TokenUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAC5D,OAAO,EAAY,SAAS,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAM7C,KAAK,gBAAgB,GAAG,SAAS,CAAC,QAAQ,GAAG,MAAM,CAAC;AAEpD,wBAAsB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,CAI1G;AAED,eAAO,MAAM,mBAAmB,mBACd,MAAM;;aAMvB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAY7E;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,WAC5B,MAAM,WACL,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEd,MAAM,GAAG,SAIX,CAAC;AAEF,wBAAgB,4BAA4B,CAAC,eAAe,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAM7F;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,gBAAgB,EAClC,QAAQ,GAAE,QAAmB,GAC5B,OAAO,CAAC,SAAS,CAAC,CAGpB;AAED,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAI1D;AAED,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAIzD;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoB,GAAG,OAAO,CAkB/G;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOlF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAUjF"}
+{"version":3,"file":"TokenUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/TokenUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAC5D,OAAO,EAAY,SAAS,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAM7C,KAAK,gBAAgB,GAAG,SAAS,CAAC,QAAQ,GAAG,MAAM,CAAC;AAEpD,wBAAsB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,CAI1G;AAED,eAAO,MAAM,mBAAmB,mBACd,MAAM;;aAMvB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAY7E;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,WAC5B,MAAM,WACL,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEd,MAAM,GAAG,SAIX,CAAC;AAEF,wBAAgB,4BAA4B,CAAC,eAAe,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAM7F;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,gBAAgB,EAClC,QAAQ,GAAE,QAAmB,GAC5B,OAAO,CAAC,SAAS,CAAC,CAGpB;AAED,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAI1D;AAED,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAIzD;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoB,GAAG,OAAO,CAkB/G;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOlF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAUjF"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@across-protocol/sdk",
   "author": "UMA Team",
-  "version": "4.1.63-beta.0",
+  "version": "4.1.63",
   "license": "AGPL-3.0",
   "homepage": "https://docs.across.to/reference/sdk",
   "files": [
@@ -104,17 +104,14 @@
   },
   "dependencies": {
     "@across-protocol/across-token": "^1.0.0",
-    "@across-protocol/constants": "^3.1.64",
+    "@across-protocol/constants": "^3.1.66",
     "@across-protocol/contracts": "^4.0.9",
     "@coral-xyz/anchor": "^0.30.1",
     "@eth-optimism/sdk": "^3.3.1",
     "@ethersproject/bignumber": "^5.7.0",
     "@pinata/sdk": "^2.1.0",
     "@solana/kit": "^2.1.0",
-    "@solana-program/system": "^0.7.0",
-    "@solana-program/token-2022": "^0.4.0",
     "@solana/web3.js": "^1.31.0",
-    "@solana-program/system": "^0.7.0",
     "@types/mocha": "^10.0.1",
     "@uma/sdk": "^0.34.10",
     "arweave": "^1.14.4",

package/src/arch/evm/SpokeUtils.ts

@@ -160,7 +160,7 @@ export async function findDepositBlock(
 export async function relayFillStatus(
   spokePool: Contract,
   relayData: RelayData,
-  blockTag: BlockTag = "latest",
+  blockTag?: number | "latest",
   destinationChainId?: number
 ): Promise<FillStatus> {
   destinationChainId ??= await spokePool.chainId();
@@ -290,20 +290,20 @@ export async function findFillEvent(
   if (!blockNumber) return undefined;
 
   // We can hardcode this to 0 to instruct paginatedEventQuery to make a single request for the same block number.
-  const maxLookBack = 0;
-  const [from, to] = [blockNumber, blockNumber];
+  const maxBlockLookBack = 0;
+  const [fromBlock, toBlock] = [blockNumber, blockNumber];
 
   const query = (
     await Promise.all([
       paginatedEventQuery(
         spokePool,
         spokePool.filters.FilledRelay(null, null, null, null, null, relayData.originChainId, relayData.depositId),
-        { from, to, maxLookBack }
+        { fromBlock, toBlock, maxBlockLookBack }
       ),
       paginatedEventQuery(
         spokePool,
         spokePool.filters.FilledV3Relay(null, null, null, null, null, relayData.originChainId, relayData.depositId),
-        { from, to, maxLookBack }
+        { fromBlock, toBlock, maxBlockLookBack }
       ),
     ])
   ).flat();

package/src/arch/svm/index.ts

@@ -1,5 +1 @@
-export * from "./eventsClient";
-export * from "./SpokeUtils";
-export * from "./types";
-export * from "./utils";
-export * from "./constants";
+export const platform = "svm"; // Placeholder for actual exports.

package/src/clients/AcrossConfigStoreClient/AcrossConfigStoreClient.ts

@@ -98,12 +98,12 @@ export class AcrossConfigStoreClient extends BaseAbstractClient {
   constructor(
     readonly logger: winston.Logger,
     readonly configStore: Contract,
-    eventSearchConfig: MakeOptional<EventSearchConfig, "to"> = { from: 0, maxLookBack: 0 },
+    eventSearchConfig: MakeOptional<EventSearchConfig, "toBlock"> = { fromBlock: 0, maxBlockLookBack: 0 },
     readonly configStoreVersion: number
   ) {
     super(eventSearchConfig);
-    this.firstHeightToSearch = eventSearchConfig.from;
-    this.latestHeightSearched = 0;
+    this.firstBlockToSearch = eventSearchConfig.fromBlock;
+    this.latestBlockSearched = 0;
   }
 
   getRateModelForBlockNumber(
@@ -355,7 +355,7 @@ export class AcrossConfigStoreClient extends BaseAbstractClient {
     return {
       success: true,
       chainId,
-      searchEndBlock: searchConfig.to,
+      searchEndBlock: searchConfig.toBlock,
       events: {
         updatedTokenConfigEvents: updatedTokenConfigSortableEvents,
         updatedGlobalConfigEvents: updatedGlobalConfigSortableEvents,
@@ -550,9 +550,9 @@ export class AcrossConfigStoreClient extends BaseAbstractClient {
     }
 
     this.hasLatestConfigStoreVersion = this.hasValidConfigStoreVersionForTimestamp();
-    this.latestHeightSearched = result.searchEndBlock;
-    this.firstHeightToSearch = result.searchEndBlock + 1; // Next iteration should start off from where this one ended.
-    this.eventSearchConfig.to = undefined; // Caller can re-set on subsequent updates if necessary
+    this.latestBlockSearched = result.searchEndBlock;
+    this.firstBlockToSearch = result.searchEndBlock + 1; // Next iteration should start off from where this one ended.
+    this.eventSearchConfig.toBlock = undefined; // Caller can re-set on subsequent updates if necessary
     this.chainId = this.chainId ?? chainId; // Update on the first run only.
     this.isUpdated = true;
 

package/src/clients/BaseAbstractClient.ts

@@ -1,7 +1,6 @@
 import { providers } from "ethers";
 import { CachingMechanismInterface } from "../interfaces";
 import { EventSearchConfig, isDefined, MakeOptional } from "../utils";
-import { SVMProvider } from "../arch/svm";
 
 export enum UpdateFailureReason {
   NotReady,
@@ -19,15 +18,15 @@ export function isUpdateFailureReason(x: EventSearchConfig | UpdateFailureReason
  */
 export abstract class BaseAbstractClient {
   protected _isUpdated: boolean;
-  public firstHeightToSearch = 0;
-  public latestHeightSearched = 0;
+  public firstBlockToSearch = 0;
+  public latestBlockSearched = 0;
 
   /**
    * Creates a new client.
    * @param cachingMechanism The caching mechanism to use for this client. If not provided, the client will not rely on an external cache.
    */
   constructor(
-    readonly eventSearchConfig: MakeOptional<EventSearchConfig, "to"> = { from: 0, maxLookBack: 0 },
+    readonly eventSearchConfig: MakeOptional<EventSearchConfig, "toBlock"> = { fromBlock: 0, maxBlockLookBack: 0 },
     protected cachingMechanism?: CachingMechanismInterface
   ) {
     this._isUpdated = false;
@@ -59,28 +58,22 @@ export abstract class BaseAbstractClient {
    * @provider Ethers RPC provider instance.
    * @returns An EventSearchConfig instance if valid, otherwise an UpdateFailureReason.
    */
-  public async updateSearchConfig(
-    provider: providers.Provider | SVMProvider
-  ): Promise<EventSearchConfig | UpdateFailureReason> {
-    const from = this.firstHeightToSearch;
-    let { to } = this.eventSearchConfig;
-    if (isDefined(to)) {
-      if (from > to) {
-        throw new Error(`Invalid event search config from (${from}) > to (${to})`);
+  public async updateSearchConfig(provider: providers.Provider): Promise<EventSearchConfig | UpdateFailureReason> {
+    const fromBlock = this.firstBlockToSearch;
+    let { toBlock } = this.eventSearchConfig;
+    if (isDefined(toBlock)) {
+      if (fromBlock > toBlock) {
+        throw new Error(`Invalid event search config fromBlock (${fromBlock}) > toBlock (${toBlock})`);
       }
     } else {
-      if (provider instanceof providers.Provider) {
-        to = await provider.getBlockNumber();
-      } else {
-        to = Number(await provider.getSlot({ commitment: "confirmed" }).send());
-      }
-      if (to < from) {
+      toBlock = await provider.getBlockNumber();
+      if (toBlock < fromBlock) {
         return UpdateFailureReason.AlreadyUpdated;
       }
     }
 
-    const { maxLookBack } = this.eventSearchConfig;
-    return { from, to, maxLookBack };
+    const { maxBlockLookBack } = this.eventSearchConfig;
+    return { fromBlock, toBlock, maxBlockLookBack };
   }
 
   /**

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -20,8 +20,7 @@ import {
   DepositWithBlock,
 } from "../../interfaces";
 import { SpokePoolClient } from "..";
-import { findFillEvent as findEvmFillEvent } from "../../arch/evm";
-import { findFillEvent as findSvmFillEvent } from "../../arch/svm";
+import { findFillEvent } from "../../arch/evm";
 import {
   BigNumber,
   bnZero,
@@ -57,7 +56,7 @@ import {
   V3FillWithBlock,
   verifyFillRepayment,
 } from "./utils";
-import { isEVMSpokePoolClient, isSvmSpokePoolClient } from "../SpokePoolClient";
+import { isEVMSpokePoolClient } from "../SpokePoolClient";
 
 // max(uint256) - 1
 export const INFINITE_FILL_DEADLINE = bnUint32Max;
@@ -371,7 +370,7 @@ export class BundleDataClient {
     }
 
     const bundle = this.clients.hubPoolClient.getLatestFullyExecutedRootBundle(
-      this.clients.hubPoolClient.latestHeightSearched
+      this.clients.hubPoolClient.latestBlockSearched
     );
     if (bundle !== undefined) {
       refunds.push(await this.getPendingRefundsFromBundle(bundle));
@@ -384,7 +383,7 @@ export class BundleDataClient {
   async getPendingRefundsFromBundle(bundle: ProposedRootBundle): Promise<CombinedRefunds> {
     const nextBundleMainnetStartBlock = this.clients.hubPoolClient.getNextBundleStartBlockNumber(
       this.chainIdListForBundleEvaluationBlockNumbers,
-      this.clients.hubPoolClient.latestHeightSearched,
+      this.clients.hubPoolClient.latestBlockSearched,
       this.clients.hubPoolClient.chainId
     );
     const chainIds = this.clients.configStoreClient.getChainIdIndicesForBlock(nextBundleMainnetStartBlock);
@@ -518,7 +517,7 @@ export class BundleDataClient {
     const hubPoolClient = this.clients.hubPoolClient;
     const nextBundleMainnetStartBlock = hubPoolClient.getNextBundleStartBlockNumber(
       this.chainIdListForBundleEvaluationBlockNumbers,
-      hubPoolClient.latestHeightSearched,
+      hubPoolClient.latestBlockSearched,
       hubPoolClient.chainId
     );
     const chainIds = this.clients.configStoreClient.getChainIdIndicesForBlock(nextBundleMainnetStartBlock);
@@ -531,8 +530,8 @@ export class BundleDataClient {
       this.spokePoolClients,
       getEndBlockBuffers(chainIds, this.blockRangeEndBlockBuffer),
       this.clients,
-      this.clients.hubPoolClient.latestHeightSearched,
-      this.clients.configStoreClient.getEnabledChains(this.clients.hubPoolClient.latestHeightSearched)
+      this.clients.hubPoolClient.latestBlockSearched,
+      this.clients.configStoreClient.getEnabledChains(this.clients.hubPoolClient.latestBlockSearched)
     );
     // Return block ranges for blocks after _pendingBlockRanges and up to widestBlockRanges.
     // If a chain is disabled or doesn't have a spoke pool client, return a range of 0
@@ -800,7 +799,7 @@ export class BundleDataClient {
         // hasn't queried. This is because this function will usually be called
         // in production with block ranges that were validated by
         // DataworkerUtils.blockRangesAreInvalidForSpokeClients.
-        Math.min(queryBlock, spokePoolClients[deposit.destinationChainId].latestHeightSearched)
+        Math.min(queryBlock, spokePoolClients[deposit.destinationChainId].latestBlockSearched)
       );
     };
 
@@ -1617,24 +1616,16 @@ export class BundleDataClient {
     deposit: DepositWithBlock,
     spokePoolClient: SpokePoolClient
   ): Promise<FillWithBlock | undefined> {
-    if (isSvmSpokePoolClient(spokePoolClient)) {
-      return await findSvmFillEvent(
-        deposit,
-        spokePoolClient.chainId,
-        spokePoolClient.svmEventsClient,
-        spokePoolClient.deploymentBlock,
-        spokePoolClient.latestHeightSearched
-      );
-    } else if (isEVMSpokePoolClient(spokePoolClient)) {
-      return await findEvmFillEvent(
-        spokePoolClient.spokePool,
-        deposit,
-        spokePoolClient.deploymentBlock,
-        spokePoolClient.latestHeightSearched
-      );
-    } else {
-      throw new Error("Unsupported spoke pool client type");
+    if (!isEVMSpokePoolClient(spokePoolClient)) {
+      // FIXME: Handle non-EVM chains.
+      throw new Error("Destination chain is not an EVM chain.");
     }
+    return await findFillEvent(
+      spokePoolClient.spokePool,
+      deposit,
+      spokePoolClient.deploymentBlock,
+      spokePoolClient.latestBlockSearched
+    );
   }
 
   async getBundleBlockTimestamps(
@@ -1661,13 +1652,13 @@ export class BundleDataClient {
           // contain blocks where the spoke pool client hasn't queried. This is because this function
           // will usually be called in production with block ranges that were validated by
           // DataworkerUtils.blockRangesAreInvalidForSpokeClients.
-          const startBlockForChain = Math.min(_startBlockForChain, spokePoolClient.latestHeightSearched);
+          const startBlockForChain = Math.min(_startBlockForChain, spokePoolClient.latestBlockSearched);
           // @dev Add 1 to the bundle end block. The thinking here is that there can be a gap between
           // block timestamps in subsequent blocks. The bundle data client assumes that fill deadlines expire
           // in exactly one bundle, therefore we must make sure that the bundle block timestamp for one bundle's
           // end block is exactly equal to the bundle block timestamp for the next bundle's start block. This way
           // there are no gaps in block timestamps between bundles.
-          const endBlockForChain = Math.min(_endBlockForChain + 1, spokePoolClient.latestHeightSearched);
+          const endBlockForChain = Math.min(_endBlockForChain + 1, spokePoolClient.latestBlockSearched);
           const [startTime, _endTime] = [
             await spokePoolClient.getTimestampForBlock(startBlockForChain),
             await spokePoolClient.getTimestampForBlock(endBlockForChain),

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

@@ -32,7 +32,7 @@ export function getWidestPossibleExpectedBlockRange(
   // filled during the challenge period.
   const latestPossibleBundleEndBlockNumbers = chainIdListForBundleEvaluationBlockNumbers.map(
     (chainId: number, index) =>
-      spokeClients[chainId] && Math.max(spokeClients[chainId].latestHeightSearched - endBlockBuffers[index], 0)
+      spokeClients[chainId] && Math.max(spokeClients[chainId].latestBlockSearched - endBlockBuffers[index], 0)
   );
   return chainIdListForBundleEvaluationBlockNumbers.map((chainId: number, index) => {
     const lastEndBlockForChain = clients.hubPoolClient.getLatestBundleEndBlockForChain(

package/src/clients/HubPoolClient.ts

@@ -105,7 +105,7 @@ export class HubPoolClient extends BaseAbstractClient {
     public configStoreClient: ConfigStoreClient,
     public deploymentBlock = 0,
     readonly chainId: number = 1,
-    eventSearchConfig: MakeOptional<EventSearchConfig, "to"> = { from: 0, maxLookBack: 0 },
+    eventSearchConfig: MakeOptional<EventSearchConfig, "toBlock"> = { fromBlock: 0, maxBlockLookBack: 0 },
     protected readonly configOverride: {
       ignoredHubExecutedBundles: number[];
       ignoredHubProposedBundles: number[];
@@ -117,8 +117,8 @@ export class HubPoolClient extends BaseAbstractClient {
     cachingMechanism?: CachingMechanismInterface
   ) {
     super(eventSearchConfig, cachingMechanism);
-    this.latestHeightSearched = Math.min(deploymentBlock - 1, 0);
-    this.firstHeightToSearch = eventSearchConfig.from;
+    this.latestBlockSearched = Math.min(deploymentBlock - 1, 0);
+    this.firstBlockToSearch = eventSearchConfig.fromBlock;
 
     const provider = this.hubPool.provider;
     this.blockFinder = new BlockFinder(provider);
@@ -254,7 +254,7 @@ export class HubPoolClient extends BaseAbstractClient {
     return l2Token !== undefined;
   }
 
-  l2TokenHasPoolRebalanceRoute(l2Token: string, l2ChainId: number, hubPoolBlock = this.latestHeightSearched): boolean {
+  l2TokenHasPoolRebalanceRoute(l2Token: string, l2ChainId: number, hubPoolBlock = this.latestBlockSearched): boolean {
     return Object.values(this.l1TokensToDestinationTokensWithBlock).some((destinationTokenMapping) => {
       return Object.entries(destinationTokenMapping).some(([_l2ChainId, setPoolRebalanceRouteEvents]) => {
         return setPoolRebalanceRouteEvents.some((e) => {
@@ -312,7 +312,7 @@ export class HubPoolClient extends BaseAbstractClient {
   }
 
   async getCurrentPoolUtilization(l1Token: string): Promise<BigNumber> {
-    const blockNumber = this.latestHeightSearched ?? (await this.hubPool.provider.getBlockNumber());
+    const blockNumber = this.latestBlockSearched ?? (await this.hubPool.provider.getBlockNumber());
     return await this.getUtilization(l1Token, blockNumber, bnZero, getCurrentTime(), 0);
   }
 
@@ -523,7 +523,7 @@ export class HubPoolClient extends BaseAbstractClient {
     chainIdA: number,
     tokenB: string,
     chainIdB: number,
-    hubPoolBlock = this.latestHeightSearched
+    hubPoolBlock = this.latestBlockSearched
   ): boolean {
     if (
       !this.l2TokenHasPoolRebalanceRoute(tokenA, chainIdA, hubPoolBlock) ||
@@ -719,7 +719,7 @@ export class HubPoolClient extends BaseAbstractClient {
     if (n === 0) {
       throw new Error("n cannot be 0");
     }
-    if (!this.latestHeightSearched) {
+    if (!this.latestBlockSearched) {
       throw new Error("HubPoolClient::getNthFullyExecutedRootBundle client not updated");
     }
 
@@ -728,7 +728,7 @@ export class HubPoolClient extends BaseAbstractClient {
     // If n is negative, then return the Nth latest executed bundle, otherwise return the Nth earliest
     // executed bundle.
     if (n < 0) {
-      let nextLatestMainnetBlock = startBlock ?? this.latestHeightSearched;
+      let nextLatestMainnetBlock = startBlock ?? this.latestBlockSearched;
       for (let i = 0; i < Math.abs(n); i++) {
         bundleToReturn = this.getLatestFullyExecutedRootBundle(nextLatestMainnetBlock);
         const bundleBlockNumber = bundleToReturn ? bundleToReturn.blockNumber : 0;
@@ -740,12 +740,12 @@ export class HubPoolClient extends BaseAbstractClient {
     } else {
       let nextStartBlock = startBlock ?? 0;
       for (let i = 0; i < n; i++) {
-        bundleToReturn = this.getEarliestFullyExecutedRootBundle(this.latestHeightSearched, nextStartBlock);
+        bundleToReturn = this.getEarliestFullyExecutedRootBundle(this.latestBlockSearched, nextStartBlock);
         const bundleBlockNumber = bundleToReturn ? bundleToReturn.blockNumber : 0;
 
         // Add 1 so that next `getEarliestFullyExecutedRootBundle` call filters out the root bundle we just found
         // because its block number is < nextStartBlock.
-        nextStartBlock = Math.min(bundleBlockNumber + 1, this.latestHeightSearched);
+        nextStartBlock = Math.min(bundleBlockNumber + 1, this.latestBlockSearched);
       }
     }
 
@@ -831,7 +831,7 @@ export class HubPoolClient extends BaseAbstractClient {
       // instantiation. However, certain events generally must be queried back to HubPool genesis.
       const overrideEvents = ["CrossChainContractsSet", "L1TokenEnabledForLiquidityProvision", "SetPoolRebalanceRoute"];
       if (overrideEvents.includes(eventName) && !this.isUpdated) {
-        _searchConfig.from = this.deploymentBlock;
+        _searchConfig.fromBlock = this.deploymentBlock;
       }
 
       return {
@@ -853,7 +853,7 @@ export class HubPoolClient extends BaseAbstractClient {
     const [multicallOutput, ...events] = await Promise.all([
       hubPool.callStatic.multicall(
         multicallFunctions.map((f) => hubPool.interface.encodeFunctionData(f)),
-        { blockTag: searchConfig.to }
+        { blockTag: searchConfig.toBlock }
       ),
       ...eventSearchConfigs.map((config) => paginatedEventQuery(hubPool, config.filter, config.searchConfig)),
     ]);
@@ -874,7 +874,7 @@ export class HubPoolClient extends BaseAbstractClient {
       success: true,
       currentTime,
       pendingRootBundleProposal,
-      searchEndBlock: searchConfig.to,
+      searchEndBlock: searchConfig.toBlock,
       events: _events,
     };
   }
@@ -1087,9 +1087,9 @@ export class HubPoolClient extends BaseAbstractClient {
     }
 
     this.currentTime = currentTime;
-    this.latestHeightSearched = searchEndBlock;
-    this.firstHeightToSearch = update.searchEndBlock + 1; // Next iteration should start off from where this one ended.
-    this.eventSearchConfig.to = undefined; // Caller can re-set on subsequent updates if necessary.
+    this.latestBlockSearched = searchEndBlock;
+    this.firstBlockToSearch = update.searchEndBlock + 1; // Next iteration should start off from where this one ended.
+    this.eventSearchConfig.toBlock = undefined; // Caller can re-set on subsequent updates if necessary.
 
     this.isUpdated = true;
     this.logger.debug({ at: "HubPoolClient::update", message: "HubPool client updated!", searchEndBlock });

package/src/clients/SpokePoolClient/EVMSpokePoolClient.ts

@@ -39,17 +39,20 @@ export class EVMSpokePoolClient extends SpokePoolClient {
     hubPoolClient: HubPoolClient | null,
     chainId: number,
     deploymentBlock: number,
-    eventSearchConfig: MakeOptional<EventSearchConfig, "to"> = { from: 0, maxLookBack: 0 }
+    eventSearchConfig: MakeOptional<EventSearchConfig, "toBlock"> = { fromBlock: 0, maxBlockLookBack: 0 }
   ) {
     super(logger, hubPoolClient, chainId, deploymentBlock, eventSearchConfig);
   }
 
-  public override relayFillStatus(relayData: RelayData, atHeight?: number): Promise<FillStatus> {
-    return relayFillStatus(this.spokePool, relayData, atHeight, this.chainId);
+  public override relayFillStatus(relayData: RelayData, blockTag?: number | "latest"): Promise<FillStatus> {
+    return relayFillStatus(this.spokePool, relayData, blockTag, this.chainId);
   }
 
-  public override fillStatusArray(relayData: RelayData[], atHeight?: number): Promise<(FillStatus | undefined)[]> {
-    return fillStatusArray(this.spokePool, relayData, atHeight);
+  public override fillStatusArray(
+    relayData: RelayData[],
+    blockTag?: number | "latest"
+  ): Promise<(FillStatus | undefined)[]> {
+    return fillStatusArray(this.spokePool, relayData, blockTag);
   }
 
   public override getMaxFillDeadlineInRange(startBlock: number, endBlock: number): Promise<number> {
@@ -86,7 +89,7 @@ export class EVMSpokePoolClient extends SpokePoolClient {
       // However, certain events have special overriding requirements to their search ranges:
       // - EnabledDepositRoute: The full history is always required, so override the requested fromBlock.
       if (eventName === "EnabledDepositRoute" && !this.isUpdated) {
-        _searchConfig.from = this.deploymentBlock;
+        _searchConfig.fromBlock = this.deploymentBlock;
       }
 
       return {
@@ -107,7 +110,7 @@ export class EVMSpokePoolClient extends SpokePoolClient {
     const [multicallOutput, ...events] = await Promise.all([
       spokePool.callStatic.multicall(
         multicallFunctions.map((f) => spokePool.interface.encodeFunctionData(f)),
-        { blockTag: searchConfig.to }
+        { blockTag: searchConfig.toBlock }
       ),
       ...eventSearchConfigs.map((config) => paginatedEventQuery(this.spokePool, config.filter, config.searchConfig)),
     ]);
@@ -121,22 +124,17 @@ export class EVMSpokePoolClient extends SpokePoolClient {
       const errMsg = BigNumber.isBigNumber(currentTime)
         ? `currentTime: ${currentTime} < ${toBN(this.currentTime)}`
         : `currentTime is not a BigNumber: ${JSON.stringify(currentTime)}`;
-      throw new Error(`EVMSpokePoolClient::update: ${errMsg}`);
+      throw new Error(`SpokePoolClient::update: ${errMsg}`);
     }
 
     // Sort all events to ensure they are stored in a consistent order.
     events.forEach((events) => sortEventsAscendingInPlace(events.map(logToSortableEvent)));
 
-    // Map events to SortableEvent
-    const eventsWithBlockNumber = events.map((eventList) =>
-      eventList.map((event) => spreadEventWithBlockNumber(event))
-    );
-
     return {
       success: true,
       currentTime: currentTime.toNumber(), // uint32
-      searchEndBlock: searchConfig.to,
-      events: eventsWithBlockNumber,
+      searchEndBlock: searchConfig.toBlock,
+      events,
     };
   }
 
@@ -151,31 +149,31 @@ export class EVMSpokePoolClient extends SpokePoolClient {
     }
 
     // No deposit found; revert to searching for it.
-    const upperBound = this.latestHeightSearched || undefined; // Don't permit block 0 as the high block.
-    const from = await findDepositBlock(this.spokePool, depositId, this.deploymentBlock, upperBound);
+    const upperBound = this.latestBlockSearched || undefined; // Don't permit block 0 as the high block.
+    const fromBlock = await findDepositBlock(this.spokePool, depositId, this.deploymentBlock, upperBound);
     const chain = getNetworkName(this.chainId);
-    if (!from) {
+    if (!fromBlock) {
       const reason =
         `Unable to find ${chain} depositId ${depositId}` +
         ` within blocks [${this.deploymentBlock}, ${upperBound ?? "latest"}].`;
       return { found: false, code: InvalidFill.DepositIdNotFound, reason };
     }
 
-    const to = from;
+    const toBlock = fromBlock;
     const tStart = Date.now();
     // Check both V3FundsDeposited and FundsDeposited events to look for a specified depositId.
-    const { maxLookBack } = this.eventSearchConfig;
+    const { maxBlockLookBack } = this.eventSearchConfig;
     const query = (
       await Promise.all([
         paginatedEventQuery(
           this.spokePool,
           this.spokePool.filters.V3FundsDeposited(null, null, null, null, null, depositId),
-          { from, to, maxLookBack }
+          { fromBlock, toBlock, maxBlockLookBack }
         ),
         paginatedEventQuery(
           this.spokePool,
           this.spokePool.filters.FundsDeposited(null, null, null, null, null, depositId),
-          { from, to, maxLookBack }
+          { fromBlock, toBlock, maxBlockLookBack }
         ),
       ])
     ).flat();
@@ -186,7 +184,7 @@ export class EVMSpokePoolClient extends SpokePoolClient {
       return {
         found: false,
         code: InvalidFill.DepositIdNotFound,
-        reason: `${chain} depositId ${depositId} not found at block ${from}.`,
+        reason: `${chain} depositId ${depositId} not found at block ${fromBlock}.`,
       };
     }