@across-protocol/sdk 4.1.63 → 4.2.0

package/src/arch/svm/eventsClient.ts

@@ -0,0 +1,342 @@
+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 {
+  address,
+  Address,
+  Commitment,
+  getProgramDerivedAddress,
+  GetSignaturesForAddressApi,
+  GetTransactionApi,
+  Signature,
+} from "@solana/kit";
+import { bs58, chainIsSvm, getMessageHash } from "../../utils";
+import { EventName, EventWithData, SVMProvider } from "./types";
+import { decodeEvent, isDevnet } from "./utils";
+import { DepositWithTime, FillWithTime } from "../../interfaces";
+import { unwrapEventData } from "./";
+import assert from "assert";
+import {
+  FundsDepositedEventObject,
+  FilledRelayEventObject,
+} from "@across-protocol/contracts/dist/typechain/contracts/SpokePool";
+
+// 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'.
+type ExtractJsonOverload<T> = T extends (signature: infer _S, config: infer C) => infer R
+  ? C extends { encoding?: "json" }
+    ? R
+    : never
+  : never;
+
+type GetTransactionReturnType = ExtractJsonOverload<GetTransactionApi["getTransaction"]>;
+type GetSignaturesForAddressConfig = Parameters<GetSignaturesForAddressApi["getSignaturesForAddress"]>[1];
+type GetSignaturesForAddressTransaction = ReturnType<GetSignaturesForAddressApi["getSignaturesForAddress"]>[number];
+type GetSignaturesForAddressApiResponse = readonly GetSignaturesForAddressTransaction[];
+
+export type DepositEventFromSignature = Omit<DepositWithTime, "fromLiteChain" | "toLiteChain">;
+export type FillEventFromSignature = FillWithTime;
+
+export class SvmCpiEventsClient {
+  private rpc: SVMProvider;
+  private programAddress: Address;
+  private programEventAuthority: Address;
+  private idl: Idl;
+
+  /**
+   * Protected constructor. Use the async create() method to instantiate.
+   */
+  protected constructor(rpc: SVMProvider, address: Address, eventAuthority: Address, idl: Idl) {
+    this.rpc = rpc;
+    this.programAddress = address;
+    this.programEventAuthority = eventAuthority;
+    this.idl = idl;
+  }
+
+  /**
+   * Factory method to asynchronously create an instance of 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");
+    return this.createFor(rpc, programId, SvmSpokeIdl);
+  }
+
+  public static async createFor(rpc: SVMProvider, programId: string, idl: Idl): Promise<SvmCpiEventsClient> {
+    const programAddress = address(programId);
+    const [eventAuthority] = await getProgramDerivedAddress({
+      programAddress,
+      seeds: ["__event_authority"],
+    });
+    return new SvmCpiEventsClient(rpc, programAddress, eventAuthority, idl);
+  }
+
+  /**
+   * Queries events for the SvmSpoke program 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 queryEvents(
+    eventName: EventName,
+    fromSlot?: bigint,
+    toSlot?: bigint,
+    options: GetSignaturesForAddressConfig = { limit: 1000, commitment: "confirmed" }
+  ): Promise<EventWithData[]> {
+    const events = await this.queryAllEvents(fromSlot, toSlot, options);
+    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[];
+  }
+
+  /**
+   * Queries all events for a specific program.
+   *
+   * @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" },
+    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(addressToQuery!, currentOptions)
+        .send();
+      // Signatures are sorted by slot in descending order.
+      allSignatures.push(...signatures);
+
+      // Update options for the next batch. Set "before" to the last fetched signature.
+      if (signatures.length > 0) {
+        currentOptions = { ...currentOptions, before: signatures[signatures.length - 1].signature };
+      }
+
+      if (fromSlot && allSignatures.length > 0 && allSignatures[allSignatures.length - 1].slot < fromSlot) {
+        hasMoreSignatures = false;
+      }
+
+      hasMoreSignatures = Boolean(
+        hasMoreSignatures && currentOptions.limit && signatures.length === currentOptions.limit
+      );
+    }
+
+    const filteredSignatures = allSignatures.filter((signatureTransaction) => {
+      if (fromSlot && signatureTransaction.slot < fromSlot) return false;
+      if (toSlot && signatureTransaction.slot > toSlot) return false;
+      return true;
+    });
+
+    // Fetch events for all signatures in parallel.
+    const eventsWithSlots = await Promise.all(
+      filteredSignatures.map(async (signatureTransaction) => {
+        const events = await this.readEventsFromSignature(signatureTransaction.signature, options.commitment);
+        return events.map((event) => ({
+          ...event,
+          confirmationStatus: signatureTransaction.confirmationStatus,
+          blockTime: signatureTransaction.blockTime,
+          signature: signatureTransaction.signature,
+          slot: signatureTransaction.slot,
+        }));
+      })
+    );
+    return eventsWithSlots.flat();
+  }
+
+  /**
+   * Reads events from a transaction signature.
+   *
+   * @param txSignature - The transaction signature.
+   * @param commitment - Commitment level.
+   * @returns A promise that resolves to an array of events.
+   */
+  private async readEventsFromSignature(txSignature: Signature, commitment: Commitment = "confirmed") {
+    const txResult = await this.rpc
+      .getTransaction(txSignature, { commitment, maxSupportedTransactionVersion: 0 })
+      .send();
+
+    if (txResult === null) return [];
+    return this.processEventFromTx(txResult);
+  }
+
+  /**
+   * Processes events from a transaction.
+   *
+   * @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: unknown; name: string }[] {
+    if (!txResult) return [];
+    const events: { program: Address; data: unknown; name: string }[] = [];
+
+    const accountKeys = txResult.transaction.message.accountKeys;
+    const messageAccountKeys = [...accountKeys];
+    // Writable accounts come first, then readonly.
+    // See https://docs.anza.xyz/proposals/versioned-transactions#new-transaction-format
+    messageAccountKeys.push(...(txResult?.meta?.loadedAddresses?.writable ?? []));
+    messageAccountKeys.push(...(txResult?.meta?.loadedAddresses?.readonly ?? []));
+
+    for (const ixBlock of txResult.meta?.innerInstructions ?? []) {
+      for (const ix of ixBlock.instructions) {
+        const ixProgramId = messageAccountKeys[ix.programIdIndex];
+        const singleIxAccount = ix.accounts.length === 1 ? messageAccountKeys[ix.accounts[0]] : undefined;
+        if (
+          ixProgramId !== undefined &&
+          singleIxAccount !== undefined &&
+          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(this.idl, eventData);
+          events.push({ program: this.programAddress, name, data });
+        }
+      }
+    }
+
+    return events;
+  }
+
+  /**
+   * Finds all FundsDeposited events for a given transaction signature.
+   *
+   * @param originChainId - The chain ID where the deposit originated.
+   * @param txSignature - The transaction signature to search for events.
+   * @param commitment - Optional commitment level for the transaction query.
+   * @returns A promise that resolves to an array of deposit events for the transaction, or undefined if none found.
+   */
+  public async getDepositEventsFromSignature(
+    originChainId: number,
+    txSignature: Signature,
+    commitment: Commitment = "confirmed"
+  ): Promise<DepositEventFromSignature[] | undefined> {
+    assert(chainIsSvm(originChainId), `Origin chain ${originChainId} is not an SVM chain`);
+
+    const [events, txDetails] = await Promise.all([
+      this.readEventsFromSignature(txSignature, commitment),
+      this.rpc
+        .getTransaction(txSignature, {
+          commitment,
+          maxSupportedTransactionVersion: 0,
+        })
+        .send(),
+    ]);
+
+    // Filter for FundsDeposited events only
+    const depositEvents = events?.filter((event) => event?.name === "FundsDeposited");
+
+    if (!txDetails || !depositEvents?.length) {
+      return;
+    }
+
+    return events.map((event) => {
+      const unwrappedEventArgs = unwrapEventData(event as Record<string, unknown>, ["depositId"]) as Record<
+        "data",
+        FundsDepositedEventObject
+      >;
+
+      return {
+        ...unwrappedEventArgs.data,
+        depositTimestamp: Number(txDetails.blockTime),
+        originChainId,
+        messageHash: getMessageHash(unwrappedEventArgs.data.message),
+        blockNumber: Number(txDetails.slot),
+        txnIndex: 0,
+        txnRef: txSignature,
+        logIndex: 0,
+        destinationChainId: unwrappedEventArgs.data.destinationChainId.toNumber(),
+      } satisfies DepositEventFromSignature;
+    });
+  }
+
+  /**
+   * Finds all FilledRelay events for a given transaction signature.
+   *
+   * @param destinationChainId - The destination chain ID (must be an SVM chain).
+   * @param txSignature - The transaction signature to search for events.
+   * @returns A promise that resolves to an array of fill events for the transaction, or undefined if none found.
+   */
+  public async getFillEventsFromSignature(
+    destinationChainId: number,
+    txSignature: Signature,
+    commitment: Commitment = "confirmed"
+  ): Promise<FillEventFromSignature[] | undefined> {
+    assert(chainIsSvm(destinationChainId), `Destination chain ${destinationChainId} is not an SVM chain`);
+
+    // Find all events from the transaction signature and get transaction details
+    const [events, txDetails] = await Promise.all([
+      this.readEventsFromSignature(txSignature, commitment),
+      this.rpc
+        .getTransaction(txSignature, {
+          commitment,
+          maxSupportedTransactionVersion: 0,
+        })
+        .send(),
+    ]);
+
+    // Filter for FilledRelay events only
+    const fillEvents = events?.filter((event) => event?.name === "FilledRelay");
+
+    if (!txDetails || !fillEvents?.length) {
+      return;
+    }
+
+    return fillEvents.map((event) => {
+      const unwrappedEventData = unwrapEventData(event as Record<string, unknown>) as Record<
+        "data",
+        FilledRelayEventObject
+      >;
+      return {
+        ...unwrappedEventData.data,
+        fillTimestamp: Number(txDetails.blockTime),
+        blockNumber: Number(txDetails.slot),
+        txnRef: txSignature,
+        txnIndex: 0,
+        logIndex: 0,
+        destinationChainId,
+        repaymentChainId: unwrappedEventData.data.repaymentChainId.toNumber(),
+        originChainId: unwrappedEventData.data.originChainId.toNumber(),
+      } satisfies FillEventFromSignature;
+    });
+  }
+
+  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,233 @@
+import bs58 from "bs58";
+import { ethers } from "ethers";
+import { BN, BorshEventCoder, Idl } from "@coral-xyz/anchor";
+import {
+  Address,
+  address,
+  getAddressEncoder,
+  getProgramDerivedAddress,
+  getU64Encoder,
+  isAddress,
+  type TransactionSigner,
+} from "@solana/kit";
+import { SvmSpokeClient } from "@across-protocol/contracts";
+import { FillType, RelayData } from "../../interfaces";
+import { BigNumber, SvmAddress, getRelayDataHash, isUint8Array } from "../../utils";
+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;
+};
+
+/**
+ * Returns a random SVM address.
+ */
+export function getRandomSvmAddress() {
+  const bytes = ethers.utils.randomBytes(32);
+  const base58Address = bs58.encode(bytes);
+  return address(base58Address);
+}

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;