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

package/src/{svm → arch/svm}/eventsClient.ts

@@ -1,17 +1,10 @@
+import { Idl } from "@coral-xyz/anchor";
 import { getDeployedAddress, SvmSpokeIdl } from "@across-protocol/contracts";
 import { getSolanaChainId } from "@across-protocol/contracts/dist/src/svm/web3-v1";
-import web3, {
-  Address,
-  Commitment,
-  GetSignaturesForAddressApi,
-  GetTransactionApi,
-  RpcTransport,
-  Signature,
-} from "@solana/kit";
-import { bs58 } from "../utils";
-import { EventData, EventName, EventWithData } from "./types";
-import { decodeEvent } from "./utils/events";
-import { isDevnet } from "./utils/helpers";
+import web3, { Address, Commitment, GetSignaturesForAddressApi, GetTransactionApi, Signature } from "@solana/kit";
+import { bs58 } from "../../utils";
+import { EventName, EventWithData, SVMProvider } from "./types";
+import { decodeEvent, isDevnet } from "./utils";
 
 // Utility type to extract the return type for the JSON encoding overload. We only care about the overload where the
 // configuration parameter (C) has the optional property 'encoding' set to 'json'.
@@ -26,39 +19,39 @@ type GetSignaturesForAddressConfig = Parameters<GetSignaturesForAddressApi["getS
 type GetSignaturesForAddressTransaction = ReturnType<GetSignaturesForAddressApi["getSignaturesForAddress"]>[number];
 type GetSignaturesForAddressApiResponse = readonly GetSignaturesForAddressTransaction[];
 
-export class SvmSpokeEventsClient {
-  private rpc: web3.Rpc<web3.SolanaRpcApiFromTransport<RpcTransport>>;
-  private svmSpokeAddress: Address;
-  private svmSpokeEventAuthority: Address;
+export class SvmCpiEventsClient {
+  private rpc: SVMProvider;
+  private programAddress: Address;
+  private programEventAuthority: Address;
+  private idl: Idl;
 
   /**
-   * Private constructor. Use the async create() method to instantiate.
+   * Protected constructor. Use the async create() method to instantiate.
    */
-  private constructor(
-    rpc: web3.Rpc<web3.SolanaRpcApiFromTransport<RpcTransport>>,
-    svmSpokeAddress: Address,
-    eventAuthority: Address
-  ) {
+  protected constructor(rpc: SVMProvider, address: Address, eventAuthority: Address, idl: Idl) {
     this.rpc = rpc;
-    this.svmSpokeAddress = svmSpokeAddress;
-    this.svmSpokeEventAuthority = eventAuthority;
+    this.programAddress = address;
+    this.programEventAuthority = eventAuthority;
+    this.idl = idl;
   }
 
   /**
    * Factory method to asynchronously create an instance of SvmSpokeEventsClient.
    */
-  public static async create(
-    rpc: web3.Rpc<web3.SolanaRpcApiFromTransport<RpcTransport>>
-  ): Promise<SvmSpokeEventsClient> {
+  public static async create(rpc: SVMProvider): Promise<SvmCpiEventsClient> {
     const isTestnet = await isDevnet(rpc);
     const programId = getDeployedAddress("SvmSpoke", getSolanaChainId(isTestnet ? "devnet" : "mainnet").toString());
     if (!programId) throw new Error("Program not found");
-    const svmSpokeAddress = web3.address(programId);
-    const [svmSpokeEventAuthority] = await web3.getProgramDerivedAddress({
-      programAddress: svmSpokeAddress,
+    return this.createFor(rpc, programId, SvmSpokeIdl);
+  }
+
+  public static async createFor(rpc: SVMProvider, programId: string, idl: Idl): Promise<SvmCpiEventsClient> {
+    const address = web3.address(programId);
+    const [eventAuthority] = await web3.getProgramDerivedAddress({
+      programAddress: address,
       seeds: ["__event_authority"],
     });
-    return new SvmSpokeEventsClient(rpc, svmSpokeAddress, svmSpokeEventAuthority);
+    return new SvmCpiEventsClient(rpc, address, eventAuthority, idl);
   }
 
   /**
@@ -70,14 +63,34 @@ export class SvmSpokeEventsClient {
    * @param options - Options for fetching signatures.
    * @returns A promise that resolves to an array of events matching the eventName.
    */
-  public async queryEvents<T extends EventData>(
+  public async queryEvents(
     eventName: EventName,
     fromSlot?: bigint,
     toSlot?: bigint,
     options: GetSignaturesForAddressConfig = { limit: 1000, commitment: "confirmed" }
-  ): Promise<EventWithData<T>[]> {
+  ): Promise<EventWithData[]> {
     const events = await this.queryAllEvents(fromSlot, toSlot, options);
-    return events.filter((event) => event.name === eventName) as EventWithData<T>[];
+    return events.filter((event) => event.name === eventName) as EventWithData[];
+  }
+
+  /**
+   * Queries events for the provided derived address at instantiation filtered by event name.
+   *
+   * @param eventName - The name of the event to filter by.
+   * @param fromSlot - Optional starting slot.
+   * @param toSlot - Optional ending slot.
+   * @param options - Options for fetching signatures.
+   * @returns A promise that resolves to an array of events matching the eventName.
+   */
+  public async queryDerivedAddressEvents(
+    eventName: string,
+    derivedAddress: Address,
+    fromSlot?: bigint,
+    toSlot?: bigint,
+    options: GetSignaturesForAddressConfig = { limit: 1000, commitment: "confirmed" }
+  ): Promise<EventWithData[]> {
+    const events = await this.queryAllEvents(fromSlot, toSlot, options, derivedAddress);
+    return events.filter((event) => event.name === eventName) as EventWithData[];
   }
 
   /**
@@ -86,20 +99,23 @@ export class SvmSpokeEventsClient {
    * @param fromSlot - Optional starting slot.
    * @param toSlot - Optional ending slot.
    * @param options - Options for fetching signatures.
+   * @param forDerivedAddress - Whether to query events for the program or the derived address.
    * @returns A promise that resolves to an array of all events with additional metadata.
    */
   private async queryAllEvents(
     fromSlot?: bigint,
     toSlot?: bigint,
-    options: GetSignaturesForAddressConfig = { limit: 1000, commitment: "confirmed" }
-  ): Promise<EventWithData<EventData>[]> {
+    options: GetSignaturesForAddressConfig = { limit: 1000, commitment: "confirmed" },
+    derivedAddress?: Address
+  ): Promise<EventWithData[]> {
+    const addressToQuery = derivedAddress || this.programAddress;
     const allSignatures: GetSignaturesForAddressTransaction[] = [];
     let hasMoreSignatures = true;
     let currentOptions = options;
 
     while (hasMoreSignatures) {
       const signatures: GetSignaturesForAddressApiResponse = await this.rpc
-        .getSignaturesForAddress(this.svmSpokeAddress, currentOptions)
+        .getSignaturesForAddress(addressToQuery!, currentOptions)
         .send();
       // Signatures are sorted by slot in descending order.
       allSignatures.push(...signatures);
@@ -162,11 +178,9 @@ export class SvmSpokeEventsClient {
    * @param txResult - The transaction result.
    * @returns A promise that resolves to an array of events with their data and name.
    */
-  private processEventFromTx(
-    txResult: GetTransactionReturnType
-  ): { program: Address; data: EventData; name: EventName }[] {
+  private processEventFromTx(txResult: GetTransactionReturnType): { program: Address; data: unknown; name: string }[] {
     if (!txResult) return [];
-    const events: { program: Address; data: EventData; name: EventName }[] = [];
+    const events: { program: Address; data: unknown; name: string }[] = [];
 
     const accountKeys = txResult.transaction.message.accountKeys;
     const messageAccountKeys = [...accountKeys];
@@ -182,18 +196,26 @@ export class SvmSpokeEventsClient {
         if (
           ixProgramId !== undefined &&
           singleIxAccount !== undefined &&
-          this.svmSpokeAddress === ixProgramId &&
-          this.svmSpokeEventAuthority === singleIxAccount
+          this.programAddress === ixProgramId &&
+          this.programEventAuthority === singleIxAccount
         ) {
           const ixData = bs58.decode(ix.data);
           // Skip the first 8 bytes (assumed header) and encode the rest.
           const eventData = Buffer.from(ixData.slice(8)).toString("base64");
-          const { name, data } = decodeEvent(SvmSpokeIdl, eventData);
-          events.push({ program: this.svmSpokeAddress, name, data });
+          const { name, data } = decodeEvent(this.idl, eventData);
+          events.push({ program: this.programAddress, name, data });
         }
       }
     }
 
     return events;
   }
+
+  public getProgramAddress(): Address {
+    return this.programAddress;
+  }
+
+  public getRpc(): SVMProvider {
+    return this.rpc;
+  }
 }

package/src/arch/svm/index.ts

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

package/src/{svm → arch/svm}/types.ts

@@ -1,5 +1,15 @@
-import { Signature, Address, UnixTimestamp } from "@solana/kit";
 import { SvmSpokeClient } from "@across-protocol/contracts";
+import {
+  Address,
+  Rpc,
+  RpcSubscriptions,
+  RpcTransport,
+  Signature,
+  SignatureNotificationsApi,
+  SlotNotificationsApi,
+  SolanaRpcApiFromTransport,
+  UnixTimestamp,
+} from "@solana/kit";
 
 export type EventData =
   | SvmSpokeClient.BridgedToHubPool
@@ -36,12 +46,19 @@ export enum SVMEventNames {
 
 export type EventName = keyof typeof SVMEventNames;
 
-export type EventWithData<T extends EventData> = {
+export type EventWithData = {
   confirmationStatus: string | null;
   blockTime: UnixTimestamp | null;
   signature: Signature;
   slot: bigint;
-  name: EventName;
-  data: T;
+  name: string;
+  data: unknown;
   program: Address;
 };
+
+// Typed aggregate of JSON‑RPC and subscription clients.
+export type RpcClient = {
+  rpc: Rpc<SolanaRpcApiFromTransport<RpcTransport>>;
+  rpcSubscriptions: RpcSubscriptions<SignatureNotificationsApi & SlotNotificationsApi>;
+};
+export type SVMProvider = Rpc<SolanaRpcApiFromTransport<RpcTransport>>;

package/src/arch/svm/utils.ts

@@ -0,0 +1,222 @@
+import { BN, BorshEventCoder, Idl } from "@coral-xyz/anchor";
+import {
+  address,
+  getProgramDerivedAddress,
+  getU64Encoder,
+  getAddressEncoder,
+  Address,
+  isAddress,
+  type TransactionSigner,
+} from "@solana/kit";
+import { BigNumber, getRelayDataHash, isUint8Array, SvmAddress } from "../../utils";
+import { SvmSpokeClient } from "@across-protocol/contracts";
+import { FillType, RelayData } from "../../interfaces";
+import { EventName, SVMEventNames, SVMProvider } from "./types";
+
+/**
+ * Basic void TransactionSigner type
+ */
+export const SolanaVoidSigner: (simulationAddress: string) => TransactionSigner<string> = (
+  simulationAddress: string
+) => {
+  return {
+    address: address(simulationAddress),
+    signAndSendTransactions: async () => {
+      return await Promise.resolve([]);
+    },
+  };
+};
+
+/**
+ * Helper to determine if the current RPC network is devnet.
+ */
+export async function isDevnet(rpc: SVMProvider): Promise<boolean> {
+  const genesisHash = await rpc.getGenesisHash().send();
+  return genesisHash === "EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG";
+}
+
+/**
+ * Parses event data from a transaction.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function parseEventData(eventData: any): any {
+  if (!eventData) return eventData;
+
+  if (Array.isArray(eventData)) {
+    return eventData.map(parseEventData);
+  }
+
+  if (typeof eventData === "object") {
+    if (eventData.constructor.name === "PublicKey") {
+      return address(eventData.toString());
+    }
+    if (BN.isBN(eventData)) {
+      return BigInt(eventData.toString());
+    }
+
+    // Convert each key from snake_case to camelCase and process the value recursively.
+    return Object.fromEntries(
+      Object.entries(eventData).map(([key, value]) => [snakeToCamel(key), parseEventData(value)])
+    );
+  }
+
+  return eventData;
+}
+
+/**
+ * Decodes a raw event according to a supplied IDL.
+ */
+export function decodeEvent(idl: Idl, rawEvent: string): { data: unknown; name: string } {
+  const event = new BorshEventCoder(idl).decode(rawEvent);
+  if (!event) throw new Error(`Malformed rawEvent for IDL ${idl.address}: ${rawEvent}`);
+  return {
+    name: event.name,
+    data: parseEventData(event.data),
+  };
+}
+
+/**
+ * Converts a snake_case string to camelCase.
+ */
+function snakeToCamel(s: string): string {
+  return s.replace(/(_\w)/g, (match) => match[1].toUpperCase());
+}
+
+/**
+ * Gets the event name from a raw name.
+ */
+export function getEventName(rawName: string): EventName {
+  if (Object.values(SVMEventNames).some((name) => rawName.includes(name))) return rawName as EventName;
+  throw new Error(`Unknown event name: ${rawName}`);
+}
+
+/**
+ * Unwraps any data structure and converts Address types to strings and Uint8Array to hex or BigInt.
+ * Recursively processes nested objects and arrays.
+ */
+export function unwrapEventData(
+  data: unknown,
+  uint8ArrayKeysAsBigInt: string[] = ["depositId"],
+  currentKey?: string
+): unknown {
+  // Handle null/undefined
+  if (data == null) {
+    return data;
+  }
+  // Handle BigInt
+  if (typeof data === "bigint") {
+    return BigNumber.from(data);
+  }
+  // Handle Uint8Array and byte arrays
+  if (data instanceof Uint8Array || isUint8Array(data)) {
+    const bytes = data instanceof Uint8Array ? data : new Uint8Array(data as number[]);
+    const hex = "0x" + Buffer.from(bytes).toString("hex");
+    if (currentKey && uint8ArrayKeysAsBigInt.includes(currentKey)) {
+      return BigNumber.from(hex);
+    }
+    return hex;
+  }
+  // Handle regular arrays (non-byte arrays)
+  if (Array.isArray(data)) {
+    return data.map((item) => unwrapEventData(item, uint8ArrayKeysAsBigInt));
+  }
+  // Handle strings (potential addresses)
+  if (typeof data === "string" && isAddress(data)) {
+    return SvmAddress.from(data).toBytes32();
+  }
+  // Handle objects
+  if (typeof data === "object") {
+    // Special case: if an object is in the context of the fillType key, then
+    // parse out the fillType from the object
+    if (currentKey === "fillType") {
+      const fillType = Object.keys(data)[0];
+      switch (fillType) {
+        case "FastFill":
+          return FillType.FastFill;
+        case "ReplacedSlowFill":
+          return FillType.ReplacedSlowFill;
+        case "SlowFill":
+          return FillType.SlowFill;
+        default:
+          throw new Error(`Unknown fill type: ${fillType}`);
+      }
+    }
+    // Special case: if an object is empty, return 0x
+    if (Object.keys(data).length === 0) {
+      return "0x";
+    }
+    return Object.fromEntries(
+      Object.entries(data as Record<string, unknown>).map(([key, value]) => [
+        key,
+        unwrapEventData(value, uint8ArrayKeysAsBigInt, key),
+      ])
+    );
+  }
+  // Return primitives as is
+  return data;
+}
+
+/**
+ * Returns the PDA for the State account.
+ * @param programId The SpokePool program ID.
+ * @returns The PDA for the State account.
+ */
+export async function getStatePda(programId: Address): Promise<Address> {
+  const intEncoder = getU64Encoder();
+  const seed = intEncoder.encode(0);
+  const [statePda] = await getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: ["state", seed],
+  });
+  return statePda;
+}
+
+/**
+ * Returns the fill status PDA for the given relay data.
+ * @param programId The SpokePool program ID.
+ * @param relayData The relay data to get the fill status PDA for.
+ * @param destinationChainId The destination chain ID.
+ * @returns The PDA for the fill status.
+ */
+export async function getFillStatusPda(
+  programId: Address,
+  relayData: RelayData,
+  destinationChainId: number
+): Promise<Address> {
+  const relayDataHash = getRelayDataHash(relayData, destinationChainId);
+  const uint8RelayDataHash = new Uint8Array(Buffer.from(relayDataHash.slice(2), "hex"));
+  const [fillStatusPda] = await getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: ["fills", uint8RelayDataHash],
+  });
+  return fillStatusPda;
+}
+
+/**
+ * Returns the PDA for a route account on SVM Spoke.
+ * @param originToken The origin token address.
+ * @param seed The seed for the route account.
+ * @param routeChainId The route chain ID.
+ * @returns The PDA for the route account.
+ */
+export async function getRoutePda(originToken: Address, seed: bigint, routeChainId: bigint): Promise<Address> {
+  const intEncoder = getU64Encoder();
+  const addressEncoder = getAddressEncoder();
+  const [pda] = await getProgramDerivedAddress({
+    programAddress: address(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS),
+    seeds: ["route", addressEncoder.encode(originToken), intEncoder.encode(seed), intEncoder.encode(routeChainId)],
+  });
+  return pda;
+}
+
+/**
+ * Returns the PDA for the Event Authority.
+ * @returns The PDA for the Event Authority.
+ */
+export const getEventAuthority = async () => {
+  const [eventAuthority] = await getProgramDerivedAddress({
+    programAddress: address(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS),
+    seeds: ["__event_authority"],
+  });
+  return eventAuthority;
+};

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, "toBlock"> = { fromBlock: 0, maxBlockLookBack: 0 },
+    eventSearchConfig: MakeOptional<EventSearchConfig, "to"> = { from: 0, maxLookBack: 0 },
     readonly configStoreVersion: number
   ) {
     super(eventSearchConfig);
-    this.firstBlockToSearch = eventSearchConfig.fromBlock;
-    this.latestBlockSearched = 0;
+    this.firstHeightToSearch = eventSearchConfig.from;
+    this.latestHeightSearched = 0;
   }
 
   getRateModelForBlockNumber(
@@ -355,7 +355,7 @@ export class AcrossConfigStoreClient extends BaseAbstractClient {
     return {
       success: true,
       chainId,
-      searchEndBlock: searchConfig.toBlock,
+      searchEndBlock: searchConfig.to,
       events: {
         updatedTokenConfigEvents: updatedTokenConfigSortableEvents,
         updatedGlobalConfigEvents: updatedGlobalConfigSortableEvents,
@@ -550,9 +550,9 @@ export class AcrossConfigStoreClient extends BaseAbstractClient {
     }
 
     this.hasLatestConfigStoreVersion = this.hasValidConfigStoreVersionForTimestamp();
-    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.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.chainId = this.chainId ?? chainId; // Update on the first run only.
     this.isUpdated = true;
 

package/src/clients/BaseAbstractClient.ts

@@ -1,6 +1,7 @@
 import { providers } from "ethers";
 import { CachingMechanismInterface } from "../interfaces";
 import { EventSearchConfig, isDefined, MakeOptional } from "../utils";
+import { SVMProvider } from "../arch/svm";
 
 export enum UpdateFailureReason {
   NotReady,
@@ -18,15 +19,15 @@ export function isUpdateFailureReason(x: EventSearchConfig | UpdateFailureReason
  */
 export abstract class BaseAbstractClient {
   protected _isUpdated: boolean;
-  public firstBlockToSearch = 0;
-  public latestBlockSearched = 0;
+  public firstHeightToSearch = 0;
+  public latestHeightSearched = 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, "toBlock"> = { fromBlock: 0, maxBlockLookBack: 0 },
+    readonly eventSearchConfig: MakeOptional<EventSearchConfig, "to"> = { from: 0, maxLookBack: 0 },
     protected cachingMechanism?: CachingMechanismInterface
   ) {
     this._isUpdated = false;
@@ -58,22 +59,28 @@ export abstract class BaseAbstractClient {
    * @provider Ethers RPC provider instance.
    * @returns An EventSearchConfig instance if valid, otherwise an UpdateFailureReason.
    */
-  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})`);
+  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})`);
       }
     } else {
-      toBlock = await provider.getBlockNumber();
-      if (toBlock < fromBlock) {
+      if (provider instanceof providers.Provider) {
+        to = await provider.getBlockNumber();
+      } else {
+        to = Number(await provider.getSlot({ commitment: "confirmed" }).send());
+      }
+      if (to < from) {
         return UpdateFailureReason.AlreadyUpdated;
       }
     }
 
-    const { maxBlockLookBack } = this.eventSearchConfig;
-    return { fromBlock, toBlock, maxBlockLookBack };
+    const { maxLookBack } = this.eventSearchConfig;
+    return { from, to, maxLookBack };
   }
 
   /**

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -20,7 +20,8 @@ import {
   DepositWithBlock,
 } from "../../interfaces";
 import { SpokePoolClient } from "..";
-import { findFillEvent } from "../../arch/evm";
+import { findFillEvent as findEvmFillEvent } from "../../arch/evm";
+import { findFillEvent as findSvmFillEvent } from "../../arch/svm";
 import {
   BigNumber,
   bnZero,
@@ -56,7 +57,7 @@ import {
   V3FillWithBlock,
   verifyFillRepayment,
 } from "./utils";
-import { isEVMSpokePoolClient } from "../SpokePoolClient";
+import { isEVMSpokePoolClient, isSvmSpokePoolClient } from "../SpokePoolClient";
 
 // max(uint256) - 1
 export const INFINITE_FILL_DEADLINE = bnUint32Max;
@@ -370,7 +371,7 @@ export class BundleDataClient {
     }
 
     const bundle = this.clients.hubPoolClient.getLatestFullyExecutedRootBundle(
-      this.clients.hubPoolClient.latestBlockSearched
+      this.clients.hubPoolClient.latestHeightSearched
     );
     if (bundle !== undefined) {
       refunds.push(await this.getPendingRefundsFromBundle(bundle));
@@ -383,7 +384,7 @@ export class BundleDataClient {
   async getPendingRefundsFromBundle(bundle: ProposedRootBundle): Promise<CombinedRefunds> {
     const nextBundleMainnetStartBlock = this.clients.hubPoolClient.getNextBundleStartBlockNumber(
       this.chainIdListForBundleEvaluationBlockNumbers,
-      this.clients.hubPoolClient.latestBlockSearched,
+      this.clients.hubPoolClient.latestHeightSearched,
       this.clients.hubPoolClient.chainId
     );
     const chainIds = this.clients.configStoreClient.getChainIdIndicesForBlock(nextBundleMainnetStartBlock);
@@ -517,7 +518,7 @@ export class BundleDataClient {
     const hubPoolClient = this.clients.hubPoolClient;
     const nextBundleMainnetStartBlock = hubPoolClient.getNextBundleStartBlockNumber(
       this.chainIdListForBundleEvaluationBlockNumbers,
-      hubPoolClient.latestBlockSearched,
+      hubPoolClient.latestHeightSearched,
       hubPoolClient.chainId
     );
     const chainIds = this.clients.configStoreClient.getChainIdIndicesForBlock(nextBundleMainnetStartBlock);
@@ -530,8 +531,8 @@ export class BundleDataClient {
       this.spokePoolClients,
       getEndBlockBuffers(chainIds, this.blockRangeEndBlockBuffer),
       this.clients,
-      this.clients.hubPoolClient.latestBlockSearched,
-      this.clients.configStoreClient.getEnabledChains(this.clients.hubPoolClient.latestBlockSearched)
+      this.clients.hubPoolClient.latestHeightSearched,
+      this.clients.configStoreClient.getEnabledChains(this.clients.hubPoolClient.latestHeightSearched)
     );
     // 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
@@ -799,7 +800,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].latestBlockSearched)
+        Math.min(queryBlock, spokePoolClients[deposit.destinationChainId].latestHeightSearched)
       );
     };
 
@@ -1616,16 +1617,24 @@ export class BundleDataClient {
     deposit: DepositWithBlock,
     spokePoolClient: SpokePoolClient
   ): Promise<FillWithBlock | undefined> {
-    if (!isEVMSpokePoolClient(spokePoolClient)) {
-      // FIXME: Handle non-EVM chains.
-      throw new Error("Destination chain is not an EVM chain.");
+    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");
     }
-    return await findFillEvent(
-      spokePoolClient.spokePool,
-      deposit,
-      spokePoolClient.deploymentBlock,
-      spokePoolClient.latestBlockSearched
-    );
   }
 
   async getBundleBlockTimestamps(
@@ -1652,13 +1661,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.latestBlockSearched);
+          const startBlockForChain = Math.min(_startBlockForChain, spokePoolClient.latestHeightSearched);
           // @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.latestBlockSearched);
+          const endBlockForChain = Math.min(_endBlockForChain + 1, spokePoolClient.latestHeightSearched);
           const [startTime, _endTime] = [
             await spokePoolClient.getTimestampForBlock(startBlockForChain),
             await spokePoolClient.getTimestampForBlock(endBlockForChain),