@across-protocol/sdk 4.1.63 → 4.2.1

package/src/clients/SpokePoolClient/SVMSpokePoolClient.ts

@@ -0,0 +1,268 @@
+import { Address, Rpc, RpcTransport, SolanaRpcApiFromTransport } from "@solana/kit";
+import winston from "winston";
+import {
+  SVMEventNames,
+  unwrapEventData,
+  getFillDeadline,
+  getTimestampForSlot,
+  getStatePda,
+  SvmCpiEventsClient,
+  findDeposit,
+  relayFillStatus,
+  fillStatusArray,
+} from "../../arch/svm";
+import { FillStatus, RelayData, SortableEvent } from "../../interfaces";
+import {
+  BigNumber,
+  DepositSearchResult,
+  EventSearchConfig,
+  InvalidFill,
+  isZeroAddress,
+  MakeOptional,
+  sortEventsAscendingInPlace,
+} from "../../utils";
+import { isUpdateFailureReason } from "../BaseAbstractClient";
+import { HubPoolClient } from "../HubPoolClient";
+import { knownEventNames, SpokePoolClient, SpokePoolUpdate } from "./SpokePoolClient";
+
+/**
+ * SvmSpokePoolClient is a client for the SVM SpokePool program. It extends the base SpokePoolClient
+ * and implements the abstract methods required for interacting with an SVM Spoke Pool.
+ */
+export class SvmSpokePoolClient extends SpokePoolClient {
+  /**
+   * Protected constructor. Use the async create() method to instantiate.
+   */
+  protected constructor(
+    logger: winston.Logger,
+    hubPoolClient: HubPoolClient | null,
+    chainId: number,
+    deploymentSlot: bigint, // Using slot instead of block number for SVM
+    eventSearchConfig: MakeOptional<EventSearchConfig, "to">,
+    public svmEventsClient: SvmCpiEventsClient,
+    protected programId: Address,
+    protected statePda: Address
+  ) {
+    // Convert deploymentSlot to number for base class, might need refinement
+    super(logger, hubPoolClient, chainId, Number(deploymentSlot), eventSearchConfig);
+  }
+
+  /**
+   * Factory method to asynchronously create an instance of SvmSpokePoolClient.
+   */
+  public static async create(
+    logger: winston.Logger,
+    hubPoolClient: HubPoolClient | null,
+    chainId: number,
+    deploymentSlot: bigint,
+    eventSearchConfig: MakeOptional<EventSearchConfig, "to"> = { from: 0, maxLookBack: 0 }, // Provide default
+    rpc: Rpc<SolanaRpcApiFromTransport<RpcTransport>>
+  ): Promise<SvmSpokePoolClient> {
+    const svmEventsClient = await SvmCpiEventsClient.create(rpc);
+    const programId = svmEventsClient.getProgramAddress();
+    const statePda = await getStatePda(programId);
+    return new SvmSpokePoolClient(
+      logger,
+      hubPoolClient,
+      chainId,
+      deploymentSlot,
+      eventSearchConfig,
+      svmEventsClient,
+      programId,
+      statePda
+    );
+  }
+
+  /**
+   * Factory method to asynchronously create an instance of SvmSpokePoolClient with an existing event client.
+   */
+  public static async createWithExistingEventClient(
+    logger: winston.Logger,
+    hubPoolClient: HubPoolClient | null,
+    chainId: number,
+    deploymentSlot: bigint,
+    eventSearchConfig: MakeOptional<EventSearchConfig, "to"> = { from: 0, maxLookBack: 0 }, // Provide default
+    eventClient: SvmCpiEventsClient
+  ) {
+    const programId = eventClient.getProgramAddress();
+    const statePda = await getStatePda(programId);
+    return new SvmSpokePoolClient(
+      logger,
+      hubPoolClient,
+      chainId,
+      deploymentSlot,
+      eventSearchConfig,
+      eventClient,
+      programId,
+      statePda
+    );
+  }
+
+  public _queryableEventNames(): string[] {
+    // We want to take the internal event names relevant to
+    // the SVM SpokePoolClient and filter them against the
+    // knownEventNames list that we reference in practice
+    const internalEventNames = Object.values(SVMEventNames);
+    return internalEventNames.filter((e) => knownEventNames.includes(e));
+  }
+
+  /**
+   * Performs an update to refresh the state of this client by querying SVM events.
+   */
+  protected async _update(eventsToQuery: string[]): Promise<SpokePoolUpdate> {
+    const searchConfig = await this.updateSearchConfig(this.svmEventsClient.getRpc());
+    if (isUpdateFailureReason(searchConfig)) {
+      const reason = searchConfig;
+      return { success: false, reason };
+    }
+
+    const deploymentSlot = BigInt(this.deploymentBlock);
+
+    const eventSearchConfigs = eventsToQuery.map((eventName) => {
+      if (!this._queryableEventNames().includes(eventName)) {
+        throw new Error(`SpokePoolClient: Cannot query unrecognised SpokePool event name: ${eventName}`);
+      }
+
+      const _searchConfig = { ...searchConfig }; // shallow copy
+
+      // By default, an event's query range is controlled by the `eventSearchConfig` passed in during instantiation.
+      // 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 = Number(deploymentSlot);
+      }
+
+      return _searchConfig as EventSearchConfig;
+    });
+
+    const spokePoolAddress = this.svmEventsClient.getProgramAddress();
+
+    this.log("debug", `Updating SpokePool client for chain ${this.chainId}`, {
+      eventsToQuery,
+      searchConfig,
+      spokePool: spokePoolAddress,
+    });
+
+    const timerStart = Date.now();
+
+    const [currentTime, ...eventsQueried] = await Promise.all([
+      this.svmEventsClient.getRpc().getBlockTime(BigInt(searchConfig.to)).send(),
+      ...eventsToQuery.map(async (eventName, idx) => {
+        const config = eventSearchConfigs[idx];
+        const events = await this.svmEventsClient.queryEvents(
+          eventName as SVMEventNames,
+          BigInt(config.from),
+          BigInt(config.to),
+          {
+            limit: config.maxLookBack,
+          }
+        );
+        return events.map(
+          (event): SortableEvent => ({
+            txnRef: event.signature,
+            blockNumber: Number(event.slot),
+            txnIndex: 0,
+            logIndex: 0,
+            ...(unwrapEventData(event.data) as Record<string, unknown>),
+          })
+        );
+      }),
+    ]);
+    this.log("debug", `Time to query new events from RPC for ${this.chainId}: ${Date.now() - timerStart} ms`);
+    if (currentTime < this.currentTime) {
+      const errMsg = `currentTime: ${currentTime} < ${this.currentTime}`;
+      throw new Error(`SvmSpokePoolClient::update: ${errMsg}`);
+    }
+
+    // Sort all events to ensure they are stored in a consistent order.
+    eventsQueried.forEach((events) => sortEventsAscendingInPlace(events));
+
+    return {
+      success: true,
+      currentTime: Number(currentTime), // uint32
+      searchEndBlock: searchConfig.to,
+      events: eventsQueried,
+    };
+  }
+
+  /**
+   * Retrieves the fill deadline buffer fetched from the State PDA.
+   * @note This function assumes that fill deadline buffer is a constant value in svm environments.
+   */
+  public override getMaxFillDeadlineInRange(_startSlot: number, _endSlot: number): Promise<number> {
+    return getFillDeadline(this.svmEventsClient.getRpc(), this.statePda);
+  }
+
+  /**
+   * Retrieves the timestamp for a given SVM slot number.
+   */
+  public override getTimestampForBlock(slot: number): Promise<number> {
+    return getTimestampForSlot(this.svmEventsClient.getRpc(), slot);
+  }
+
+  /**
+   * Retrieves the timestamp for a given SVM slot number.
+   * @note This function uses the same underlying function as getTimestampForBlock.
+   *       It is kept for consistency with the EVM SpokePoolClient.
+   */
+  public getTimeAt(slot: number): Promise<number> {
+    return getTimestampForSlot(this.svmEventsClient.getRpc(), slot);
+  }
+
+  /**
+   * Finds a deposit based on its deposit ID on the SVM chain.
+   */
+  public async findDeposit(depositId: BigNumber): Promise<DepositSearchResult> {
+    const deposit = await findDeposit(this.svmEventsClient, depositId);
+    if (!deposit) {
+      return {
+        found: false,
+        code: InvalidFill.DepositIdNotFound,
+        reason: `Deposit with ID ${depositId} not found`,
+      };
+    }
+    // Because we have additional context about this deposit, we can enrich it
+    // with additional information.
+    return {
+      found: true,
+      deposit: {
+        ...deposit,
+        quoteBlockNumber: await this.getBlockNumber(Number(deposit.quoteTimestamp)),
+        originChainId: this.chainId,
+        fromLiteChain: this.isOriginLiteChain(deposit),
+        toLiteChain: this.isDestinationLiteChain(deposit),
+        outputToken: isZeroAddress(deposit.outputToken)
+          ? this.getDestinationTokenForDeposit(deposit)
+          : deposit.outputToken,
+      },
+    };
+  }
+
+  /**
+   * Retrieves the fill status for a given relay data from the SVM chain.
+   */
+  public override relayFillStatus(
+    relayData: RelayData,
+    atHeight?: number,
+    destinationChainId?: number
+  ): Promise<FillStatus> {
+    destinationChainId ??= this.chainId;
+    return relayFillStatus(this.programId, relayData, destinationChainId, this.svmEventsClient, atHeight);
+  }
+
+  /**
+   * Retrieves the fill status for an array of given relay data.
+   * @param relayData The array relay data to retrieve the fill status for.
+   * @param atHeight The slot at which to query the fill status.
+   * @returns The fill status for each of the given relay data.
+   */
+  public fillStatusArray(
+    relayData: RelayData[],
+    atHeight?: number,
+    destinationChainId?: number
+  ): Promise<(FillStatus | undefined)[]> {
+    // @note: deploymentBlock actually refers to the deployment slot. Also, blockTag should be a slot number.
+    destinationChainId ??= this.chainId;
+    return fillStatusArray(this.programId, relayData, destinationChainId, this.svmEventsClient, atHeight, this.logger);
+  }
+}

package/src/clients/SpokePoolClient/SpokePoolClient.ts

@@ -18,25 +18,22 @@ import {
   toAddress,
   validateFillForDeposit,
   chainIsEvm,
+  chainIsProd,
 } from "../../utils";
-import {
-  duplicateEvent,
-  sortEventsAscendingInPlace,
-  spreadEvent,
-  spreadEventWithBlockNumber,
-} from "../../utils/EventUtils";
+import { duplicateEvent, sortEventsAscendingInPlace } from "../../utils/EventUtils";
 import { ZERO_ADDRESS } from "../../constants";
 import {
   Deposit,
   DepositWithBlock,
+  EnabledDepositRouteWithBlock,
   Fill,
   FillStatus,
   FillWithBlock,
-  Log,
   RelayData,
   RelayerRefundExecutionWithBlock,
   RootBundleRelayWithBlock,
   SlowFillRequestWithBlock,
+  SortableEvent,
   SpeedUpWithBlock,
   TokensBridged,
 } from "../../interfaces";
@@ -48,7 +45,7 @@ import { HubPoolClient } from "../HubPoolClient";
 export type SpokePoolUpdateSuccess = {
   success: true;
   currentTime: number;
-  events: Log[][];
+  events: SortableEvent[][];
   searchEndBlock: number;
 };
 export type SpokePoolUpdateFailure = {
@@ -105,11 +102,11 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     readonly hubPoolClient: HubPoolClient | null,
     readonly chainId: number,
     public deploymentBlock: number,
-    eventSearchConfig: MakeOptional<EventSearchConfig, "toBlock"> = { fromBlock: 0, maxBlockLookBack: 0 }
+    eventSearchConfig: MakeOptional<EventSearchConfig, "to"> = { from: 0, maxLookBack: 0 }
   ) {
     super(eventSearchConfig);
-    this.firstBlockToSearch = eventSearchConfig.fromBlock;
-    this.latestBlockSearched = 0;
+    this.firstHeightToSearch = eventSearchConfig.from;
+    this.latestHeightSearched = 0;
     this.configStoreClient = hubPoolClient?.configStoreClient;
   }
 
@@ -353,7 +350,7 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     fillCount: number;
     invalidFills: FillWithBlock[];
   } {
-    const { outputAmount } = deposit;
+    const { outputAmount, originChainId } = deposit;
     const fillsForDeposit = this.depositHashesToFills[this.getDepositHash(deposit)];
     // If no fills then the full amount is remaining.
     if (fillsForDeposit === undefined || fillsForDeposit.length === 0) {
@@ -373,7 +370,7 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
           const { chainToSendRefundTo: repaymentChainId } = getRefundInformationFromFill(
             fillRepaymentData,
             this.hubPoolClient!,
-            this.hubPoolClient!.latestBlockSearched
+            this.hubPoolClient!.latestHeightSearched
           );
           // In order to keep this function sync, we can't call verifyFillRepayment so we'll log any fills where
           // the filler-specified repayment chain and repayment address is not a valid repayment upon
@@ -409,8 +406,10 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
       }
       return newInvalidFill;
     });
+    // Log invalid and unrepayable fills as warns if we are on a production network.
+    const logLevel = chainIsProd(originChainId) ? "warn" : "debug";
     if (invalidFillsForDeposit.length > 0) {
-      this.logger.warn({
+      this.logger[logLevel]({
         at: "SpokePoolClient",
         chainId: this.chainId,
         message: "Invalid fills found matching deposit ID",
@@ -421,7 +420,7 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     }
     const unrepayableFillsForDeposit = unrepayableFills.filter((x) => x.depositId.eq(deposit.depositId));
     if (unrepayableFillsForDeposit.length > 0) {
-      this.logger.warn({
+      this.logger[logLevel]({
         at: "SpokePoolClient",
         chainId: this.chainId,
         message: "Unrepayable fills found where we need to switch repayment address and or chain",
@@ -486,7 +485,7 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
    * @see _update
    */
   public async update(eventsToQuery = this._queryableEventNames()): Promise<void> {
-    const duplicateEvents: Log[] = [];
+    const duplicateEvents: SortableEvent[] = [];
     if (this.hubPoolClient !== null && !this.hubPoolClient.isUpdated) {
       throw new Error("HubPoolClient not updated");
     }
@@ -498,14 +497,14 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     const { events: queryResults, currentTime, searchEndBlock } = update;
 
     if (eventsToQuery.includes("TokensBridged")) {
-      for (const event of queryResults[eventsToQuery.indexOf("TokensBridged")]) {
-        this.tokensBridged.push(spreadEventWithBlockNumber(event) as TokensBridged);
+      for (const event of queryResults[eventsToQuery.indexOf("TokensBridged")] as TokensBridged[]) {
+        this.tokensBridged.push(event);
       }
     }
 
     // Performs the indexing of a deposit-like spoke pool event.
     const queryDepositEvents = async (eventName: string) => {
-      const depositEvents = queryResults[eventsToQuery.indexOf(eventName)] ?? [];
+      const depositEvents = (queryResults[eventsToQuery.indexOf(eventName)] ?? []) as DepositWithBlock[];
       if (depositEvents.length > 0) {
         this.log(
           "debug",
@@ -518,22 +517,20 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
 
       // 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"]))
-      );
+      const quoteBlockNumbers = await this.getBlockNumbers(depositEvents.map((e) => e.quoteTimestamp));
       for (const event of depositEvents) {
-        const quoteBlockNumber = quoteBlockNumbers[Number(event.args["quoteTimestamp"])];
+        const quoteBlockNumber = quoteBlockNumbers[Number(event.quoteTimestamp)];
 
         // Derive and append the common properties that are not part of the onchain event.
         const deposit = {
-          ...spreadEventWithBlockNumber(event),
-          messageHash: getMessageHash(event.args.message),
+          ...event,
+          messageHash: getMessageHash(event.message),
           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);
@@ -564,10 +561,10 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
 
     // Performs indexing of a "speed up deposit"-like event.
     const querySpeedUpDepositEvents = (eventName: string) => {
-      const speedUpEvents = queryResults[eventsToQuery.indexOf(eventName)] ?? [];
+      const speedUpEvents = (queryResults[eventsToQuery.indexOf(eventName)] ?? []) as SpeedUpWithBlock[];
 
       for (const event of speedUpEvents) {
-        const speedUp = { ...spreadEventWithBlockNumber(event), originChainId: this.chainId } as SpeedUpWithBlock;
+        const speedUp = { ...event, originChainId: this.chainId };
         assign(this.speedUps, [speedUp.depositor, speedUp.depositId.toString()], [speedUp]);
 
         // Find deposit hash matching this speed up event and update the deposit data associated with the hash,
@@ -592,12 +589,12 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
 
     // Performs indexing of "requested slow fill"-like events.
     const queryRequestedSlowFillEvents = (eventName: string) => {
-      const slowFillRequests = queryResults[eventsToQuery.indexOf(eventName)];
+      const slowFillRequests = (queryResults[eventsToQuery.indexOf(eventName)] ?? []) as SlowFillRequestWithBlock[];
       for (const event of slowFillRequests) {
         const slowFillRequest = {
-          ...spreadEventWithBlockNumber(event),
+          ...event,
           destinationChainId: this.chainId,
-        } as SlowFillRequestWithBlock;
+        };
 
         if (eventName === "RequestedV3SlowFill") {
           slowFillRequest.messageHash = getMessageHash(slowFillRequest.message);
@@ -623,7 +620,7 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
 
     // Performs indexing of filled relay-like events.
     const queryFilledRelayEvents = (eventName: string) => {
-      const fillEvents = queryResults[eventsToQuery.indexOf(eventName)] ?? [];
+      const fillEvents = (queryResults[eventsToQuery.indexOf(eventName)] ?? []) as FillWithBlock[];
 
       if (fillEvents.length > 0) {
         this.log("debug", `Using ${fillEvents.length} newly queried ${eventName} events for chain ${this.chainId}`, {
@@ -635,13 +632,13 @@ 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 event of fillEvents) {
         const fill = {
-          ...spreadEventWithBlockNumber(event),
+          ...event,
           destinationChainId: this.chainId,
-        } as FillWithBlock;
+        };
 
         if (eventName === "FilledV3Relay") {
-          fill.messageHash = getMessageHash(event.args.message);
-          fill.relayExecutionInfo.updatedMessageHash = getMessageHash(event.args.relayExecutionInfo.updatedMessage);
+          fill.messageHash = getMessageHash((event as unknown as { message: string }).message);
+          fill.relayExecutionInfo.updatedMessageHash = getMessageHash(event.relayExecutionInfo.updatedMessage!);
         }
 
         // Sanity check that this event is not a duplicate.
@@ -664,30 +661,27 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     });
 
     if (eventsToQuery.includes("EnabledDepositRoute")) {
-      const enableDepositsEvents = queryResults[eventsToQuery.indexOf("EnabledDepositRoute")];
+      const enableDepositsEvents = (queryResults[eventsToQuery.indexOf("EnabledDepositRoute")] ??
+        []) as EnabledDepositRouteWithBlock[];
 
       for (const event of enableDepositsEvents) {
-        const enableDeposit = spreadEvent(event.args);
-        assign(
-          this.depositRoutes,
-          [enableDeposit.originToken, enableDeposit.destinationChainId],
-          enableDeposit.enabled
-        );
+        assign(this.depositRoutes, [event.originToken, event.destinationChainId], event.enabled);
       }
     }
 
     if (eventsToQuery.includes("RelayedRootBundle")) {
-      const relayedRootBundleEvents = queryResults[eventsToQuery.indexOf("RelayedRootBundle")];
+      const relayedRootBundleEvents = (queryResults[eventsToQuery.indexOf("RelayedRootBundle")] ??
+        []) as RootBundleRelayWithBlock[];
       for (const event of relayedRootBundleEvents) {
-        this.rootBundleRelays.push(spreadEventWithBlockNumber(event) as RootBundleRelayWithBlock);
+        this.rootBundleRelays.push(event);
       }
     }
 
     if (eventsToQuery.includes("ExecutedRelayerRefundRoot")) {
-      const refundEvents = queryResults[eventsToQuery.indexOf("ExecutedRelayerRefundRoot")];
+      const refundEvents = (queryResults[eventsToQuery.indexOf("ExecutedRelayerRefundRoot")] ??
+        []) as RelayerRefundExecutionWithBlock[];
       for (const event of refundEvents) {
-        const executedRefund = spreadEventWithBlockNumber(event) as RelayerRefundExecutionWithBlock;
-        this.relayerRefundExecutions.push(executedRefund);
+        this.relayerRefundExecutions.push(event);
       }
     }
 
@@ -700,12 +694,12 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
 
     // Next iteration should start off from where this one ended.
     this.currentTime = currentTime;
-    this.latestBlockSearched = searchEndBlock;
-    this.firstBlockToSearch = searchEndBlock + 1;
-    this.eventSearchConfig.toBlock = undefined; // Caller can re-set on subsequent updates if necessary
+    this.latestHeightSearched = searchEndBlock;
+    this.firstHeightToSearch = searchEndBlock + 1;
+    this.eventSearchConfig.to = undefined; // Caller can re-set on subsequent updates if necessary
     this.isUpdated = true;
     this.log("debug", `SpokePool client for chain ${this.chainId} updated!`, {
-      nextFirstBlockToSearch: this.firstBlockToSearch,
+      nextFirstHeightToSearch: this.firstHeightToSearch,
     });
   }
 
@@ -848,19 +842,16 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
   /**
    * Retrieves the fill status for a given relay data.
    * @param relayData The relay data to retrieve the fill status for.
-   * @param blockTag The block at which to query the fill status.
+   * @param atHeight The height at which to query the fill status.
    * @returns The fill status for the given relay data.
    */
-  public abstract relayFillStatus(relayData: RelayData, blockTag?: number | "latest"): Promise<FillStatus>;
+  public abstract relayFillStatus(relayData: RelayData, atHeight?: number): Promise<FillStatus>;
 
   /**
    * Retrieves the fill status for an array of given relay data.
    * @param relayData The array relay data to retrieve the fill status for.
-   * @param blockTag The block at which to query the fill status.
+   * @param atHeight The height at which to query the fill status.
    * @returns The fill status for each of the given relay data.
    */
-  public abstract fillStatusArray(
-    relayData: RelayData[],
-    blockTag?: number | "latest"
-  ): Promise<(FillStatus | undefined)[]>;
+  public abstract fillStatusArray(relayData: RelayData[], atHeight?: number): Promise<(FillStatus | undefined)[]>;
 }

package/src/clients/SpokePoolClient/index.ts

@@ -1,8 +1,10 @@
 import { EVMSpokePoolClient } from "./EVMSpokePoolClient";
+import { SvmSpokePoolClient } from "./SVMSpokePoolClient";
 import { SpokePoolClient } from "./SpokePoolClient";
 
 export { EVMSpokePoolClient } from "./EVMSpokePoolClient";
 export { SpokePoolClient, SpokePoolUpdate } from "./SpokePoolClient";
+export { SvmSpokePoolClient } from "./SVMSpokePoolClient";
 
 /**
  * Checks if a SpokePoolClient is an EVMSpokePoolClient.
@@ -12,3 +14,12 @@ export { SpokePoolClient, SpokePoolUpdate } from "./SpokePoolClient";
 export function isEVMSpokePoolClient(spokePoolClient: SpokePoolClient): spokePoolClient is EVMSpokePoolClient {
   return spokePoolClient instanceof EVMSpokePoolClient;
 }
+
+/**
+ * Checks if a SpokePoolClient is an SVMSpokePoolClient.
+ * @param spokePoolClient The SpokePoolClient to check.
+ * @returns True if the SpokePoolClient is an SVMSpokePoolClient, false otherwise.
+ */
+export function isSvmSpokePoolClient(spokePoolClient: SpokePoolClient): spokePoolClient is SvmSpokePoolClient {
+  return spokePoolClient instanceof SvmSpokePoolClient;
+}

package/src/clients/index.ts

@@ -6,6 +6,6 @@ export {
 } from "./AcrossConfigStoreClient";
 export { UpdateFailureReason } from "./BaseAbstractClient";
 export { HubPoolClient, LpFeeRequest } from "./HubPoolClient";
-export { SpokePoolClient, SpokePoolUpdate, EVMSpokePoolClient } from "./SpokePoolClient";
+export { SpokePoolClient, SpokePoolUpdate, EVMSpokePoolClient, SvmSpokePoolClient } from "./SpokePoolClient";
 export * as BundleDataClient from "./BundleDataClient";
 export * as mocks from "./mocks";

package/src/clients/mocks/MockConfigStoreClient.ts

@@ -33,7 +33,7 @@ export class MockConfigStoreClient extends AcrossConfigStoreClient {
   constructor(
     logger: winston.Logger,
     configStore: Contract,
-    eventSearchConfig: MakeOptional<EventSearchConfig, "toBlock"> = { fromBlock: 0, maxBlockLookBack: 0 },
+    eventSearchConfig: MakeOptional<EventSearchConfig, "to"> = { from: 0, maxLookBack: 0 },
     configStoreVersion: number,
     chainId = 1,
     mockUpdate = false,
@@ -97,7 +97,7 @@ export class MockConfigStoreClient extends AcrossConfigStoreClient {
     return Promise.resolve({
       success: true,
       chainId: this.chainId as number,
-      searchEndBlock: this.eventSearchConfig.toBlock || latestBlockSearched,
+      searchEndBlock: this.eventSearchConfig.to || latestBlockSearched,
       events: {
         updatedGlobalConfigEvents: events["UpdatedGlobalConfig"].map(spreadEventWithBlockNumber),
         globalConfigUpdateTimes,

package/src/clients/mocks/MockHubPoolClient.ts

@@ -79,7 +79,7 @@ export class MockHubPoolClient extends HubPoolClient {
   }
 
   setLatestBlockNumber(blockNumber: number) {
-    this.latestBlockSearched = blockNumber;
+    this.latestHeightSearched = blockNumber;
   }
 
   addL1Token(l1Token: L1Token) {
@@ -158,7 +158,7 @@ export class MockHubPoolClient extends HubPoolClient {
       latestBlockSearched,
       pendingRootBundleProposal: this.rootBundleProposal,
       events,
-      searchEndBlock: this.eventSearchConfig.toBlock || latestBlockSearched,
+      searchEndBlock: this.eventSearchConfig.to || latestBlockSearched,
     });
   }
 

package/src/clients/mocks/MockSpokePoolClient.ts

@@ -27,6 +27,7 @@ import {
   bnOne,
   toAddress,
   toBytes32,
+  spreadEventWithBlockNumber,
 } from "../../utils";
 import { EVMSpokePoolClient, SpokePoolUpdate } from "../SpokePoolClient";
 import { HubPoolClient } from "../HubPoolClient";
@@ -50,7 +51,7 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
     opts: { hubPoolClient: HubPoolClient | null } = { hubPoolClient: null }
   ) {
     super(logger, spokePool, opts.hubPoolClient, chainId, deploymentBlock);
-    this.latestBlockSearched = deploymentBlock;
+    this.latestHeightSearched = deploymentBlock;
     this.eventManager = getEventManager(chainId, this.eventSignatures, deploymentBlock);
   }
 
@@ -67,7 +68,7 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
   }
 
   setLatestBlockNumber(blockNumber: number): void {
-    this.latestBlockSearched = blockNumber;
+    this.latestHeightSearched = blockNumber;
   }
 
   setDepositIds(_depositIds: BigNumber[]): void {
@@ -106,12 +107,16 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
         }
       });
 
+    const eventsWithBlockNumber = events.map((eventList) =>
+      eventList.map((event) => spreadEventWithBlockNumber(event))
+    );
+
     return Promise.resolve({
       success: true,
       firstDepositId: bnZero,
       currentTime,
-      events,
-      searchEndBlock: this.eventSearchConfig.toBlock || latestBlockSearched,
+      events: eventsWithBlockNumber,
+      searchEndBlock: this.eventSearchConfig.to || latestBlockSearched,
     });
   }