improve: allow SVM events client to take in non-spoke IDLs (#982)

Signed-off-by: bennett <[email protected]>

Author: bmzig

src/arch/svm/eventsClient.ts

@@ -1,3 +1,4 @@
+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, {
@@ -9,7 +10,7 @@ import web3, {
   Signature,
 } from "@solana/kit";
 import { bs58 } from "../../utils";
-import { EventData, EventName, EventWithData } from "./types";
+import { EventWithData } from "./types";
 import { decodeEvent, isDevnet } from "./utils";
 import { getSlotForBlock } from "./SpokeUtils";
 
@@ -26,39 +27,48 @@ type GetSignaturesForAddressConfig = Parameters<GetSignaturesForAddressApi["getS
 type GetSignaturesForAddressTransaction = ReturnType<GetSignaturesForAddressApi["getSignaturesForAddress"]>[number];
 type GetSignaturesForAddressApiResponse = readonly GetSignaturesForAddressTransaction[];
 
-export class SvmSpokeEventsClient {
+export class SvmCpiEventsClient {
   private rpc: web3.Rpc<web3.SolanaRpcApiFromTransport<RpcTransport>>;
-  private svmSpokeAddress: Address;
-  private svmSpokeEventAuthority: Address;
+  private programAddress: Address;
+  private programEventAuthority: Address;
+  private idl: Idl;
 
   /**
    * Private constructor. Use the async create() method to instantiate.
    */
   private constructor(
     rpc: web3.Rpc<web3.SolanaRpcApiFromTransport<RpcTransport>>,
-    svmSpokeAddress: Address,
-    eventAuthority: Address
+    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: web3.Rpc<web3.SolanaRpcApiFromTransport<RpcTransport>>): 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: web3.Rpc<web3.SolanaRpcApiFromTransport<RpcTransport>>,
+    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 +80,14 @@ 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>(
-    eventName: EventName,
+  public async queryEvents(
+    eventName: string,
     fromBlock?: bigint,
     toBlock?: bigint,
     options: GetSignaturesForAddressConfig = { limit: 1000, commitment: "confirmed" }
-  ): Promise<EventWithData<T>[]> {
+  ): Promise<EventWithData[]> {
     const events = await this.queryAllEvents(fromBlock, toBlock, options);
-    return events.filter((event) => event.name === eventName) as EventWithData<T>[];
+    return events.filter((event) => event.name === eventName) as EventWithData[];
   }
 
   /**
@@ -92,7 +102,7 @@ export class SvmSpokeEventsClient {
     fromBlock?: bigint,
     toBlock?: bigint,
     options: GetSignaturesForAddressConfig = { limit: 1000, commitment: "confirmed" }
-  ): Promise<EventWithData<EventData>[]> {
+  ): Promise<EventWithData[]> {
     const allSignatures: GetSignaturesForAddressTransaction[] = [];
     let hasMoreSignatures = true;
     let currentOptions = options;
@@ -112,7 +122,7 @@ export class SvmSpokeEventsClient {
 
     while (hasMoreSignatures) {
       const signatures: GetSignaturesForAddressApiResponse = await this.rpc
-        .getSignaturesForAddress(this.svmSpokeAddress, currentOptions)
+        .getSignaturesForAddress(this.programAddress, currentOptions)
         .send();
       // Signatures are sorted by slot in descending order.
       allSignatures.push(...signatures);
@@ -175,11 +185,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];
@@ -195,22 +203,22 @@ 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 getSvmSpokeAddress(): Address {
-    return this.svmSpokeAddress;
+  public getProgramAddress(): Address {
+    return this.programAddress;
   }
 }

src/arch/svm/types.ts

@@ -1,21 +1,4 @@
 import { Signature, Address, UnixTimestamp } from "@solana/kit";
-import { SvmSpokeClient } from "@across-protocol/contracts";
-
-export type EventData =
-  | SvmSpokeClient.BridgedToHubPool
-  | SvmSpokeClient.TokensBridged
-  | SvmSpokeClient.ExecutedRelayerRefundRoot
-  | SvmSpokeClient.RelayedRootBundle
-  | SvmSpokeClient.PausedDeposits
-  | SvmSpokeClient.PausedFills
-  | SvmSpokeClient.SetXDomainAdmin
-  | SvmSpokeClient.EnabledDepositRoute
-  | SvmSpokeClient.FilledRelay
-  | SvmSpokeClient.FundsDeposited
-  | SvmSpokeClient.EmergencyDeletedRootBundle
-  | SvmSpokeClient.RequestedSlowFill
-  | SvmSpokeClient.ClaimedRelayerRefund
-  | SvmSpokeClient.TransferredOwnership;
 
 export enum SVMEventNames {
   FilledRelay = "FilledRelay",
@@ -36,12 +19,12 @@ 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;
 };

src/arch/svm/utils.ts

@@ -1,7 +1,6 @@
 import { BN, BorshEventCoder, Idl } from "@coral-xyz/anchor";
 import web3, { address, getProgramDerivedAddress, getU64Encoder, Address, RpcTransport } from "@solana/kit";
-
-import { EventName, EventData, SVMEventNames } from "./types";
+import { EventName, SVMEventNames } from "./types";
 
 /**
  * Helper to determine if the current RPC network is devnet.
@@ -42,11 +41,11 @@ export function parseEventData(eventData: any): any {
 /**
  * Decodes a raw event according to a supplied IDL.
  */
-export function decodeEvent(idl: Idl, rawEvent: string): { data: EventData; name: EventName } {
+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: getEventName(event.name),
+    name: event.name,
     data: parseEventData(event.data),
   };
 }

src/clients/SpokePoolClient/SVMSpokePoolClient.ts

@@ -2,13 +2,7 @@ import winston from "winston";
 import { Address, Rpc, SolanaRpcApiFromTransport, RpcTransport } from "@solana/kit";
 
 import { BigNumber, DepositSearchResult, EventSearchConfig, MakeOptional } from "../../utils";
-import {
-  SvmSpokeEventsClient,
-  SVMEventNames,
-  getFillDeadline,
-  getTimestampForBlock,
-  getStatePda,
-} from "../../arch/svm";
+import { SvmCpiEventsClient, SVMEventNames, getFillDeadline, getTimestampForBlock, getStatePda } from "../../arch/svm";
 import { HubPoolClient } from "../HubPoolClient";
 import { knownEventNames, SpokePoolClient, SpokePoolUpdate } from "./SpokePoolClient";
 import { RelayData, FillStatus } from "../../interfaces";
@@ -27,9 +21,9 @@ export class SvmSpokePoolClient extends SpokePoolClient {
     chainId: number,
     deploymentSlot: bigint, // Using slot instead of block number for SVM
     eventSearchConfig: MakeOptional<EventSearchConfig, "toBlock">,
+    protected svmEventsClient: SvmCpiEventsClient,
     protected programId: Address,
     protected statePda: Address,
-    protected svmEventsClient: SvmSpokeEventsClient,
     protected rpc: Rpc<SolanaRpcApiFromTransport<RpcTransport>>
   ) {
     // Convert deploymentSlot to number for base class, might need refinement
@@ -47,18 +41,18 @@ export class SvmSpokePoolClient extends SpokePoolClient {
     eventSearchConfig: MakeOptional<EventSearchConfig, "toBlock"> = { fromBlock: 0, maxBlockLookBack: 0 }, // Provide default
     rpc: Rpc<SolanaRpcApiFromTransport<RpcTransport>>
   ): Promise<SvmSpokePoolClient> {
-    const svmEventsClient = await SvmSpokeEventsClient.create(rpc);
-    const programId = svmEventsClient.getSvmSpokeAddress();
+    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,
-      svmEventsClient,
       rpc
     );
   }