chore: merge

Author: james-a-morris

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 { EventName, EventWithData } 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
@@ -25,39 +26,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);
   }
 
   /**
@@ -69,14 +79,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>(
+  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[];
   }
 
   /**
@@ -91,14 +101,14 @@ export class SvmSpokeEventsClient {
     fromSlot?: bigint,
     toSlot?: bigint,
     options: GetSignaturesForAddressConfig = { limit: 1000, commitment: "confirmed" }
-  ): Promise<EventWithData<EventData>[]> {
+  ): Promise<EventWithData[]> {
     const allSignatures: GetSignaturesForAddressTransaction[] = [];
     let hasMoreSignatures = true;
     let currentOptions = options;
 
     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);
@@ -161,11 +171,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];
@@ -181,22 +189,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

@@ -36,13 +36,13 @@ 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

@@ -2,7 +2,7 @@ import { BN, BorshEventCoder, Idl } from "@coral-xyz/anchor";
 import { BigNumber, isUint8Array, SvmAddress } from "../../utils";
 import web3, { address, isAddress, RpcTransport, getProgramDerivedAddress, getU64Encoder, Address } from "@solana/kit";
 
-import { EventName, EventData, SVMEventNames } from "./types";
+import { EventName, SVMEventNames } from "./types";
 import { FillType } from "../../interfaces";
 
 /**
@@ -44,11 +44,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,11 +2,11 @@ import { Address, Rpc, RpcTransport, SolanaRpcApiFromTransport } from "@solana/k
 import winston from "winston";
 import {
   SVMEventNames,
-  SvmSpokeEventsClient,
   unwrapEventData,
   getFillDeadline,
   getTimestampForSlot,
   getStatePda,
+  SvmCpiEventsClient,
 } from "../../arch/svm";
 import { FillStatus, RelayData, SortableEvent } from "../../interfaces";
 import {
@@ -34,9 +34,9 @@ export class SvmSpokePoolClient extends SpokePoolClient {
     chainId: number,
     deploymentSlot: bigint, // Using slot instead of block number for SVM
     eventSearchConfig: MakeOptional<EventSearchConfig, "to">,
+    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
@@ -54,18 +54,18 @@ export class SvmSpokePoolClient extends SpokePoolClient {
     eventSearchConfig: MakeOptional<EventSearchConfig, "to"> = { from: 0, maxLookBack: 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
     );
   }
@@ -107,7 +107,7 @@ export class SvmSpokePoolClient extends SpokePoolClient {
       return _searchConfig as EventSearchConfig;
     });
 
-    const spokePoolAddress = this.svmEventsClient.getSvmSpokeAddress();
+    const spokePoolAddress = this.svmEventsClient.getProgramAddress();
 
     this.log("debug", `Updating SpokePool client for chain ${this.chainId}`, {
       eventsToQuery,