feat: improve event utils (#789)

Author: chrismaree

src/SvmUtils.ts

@@ -23,6 +23,7 @@ import {
   AddressLookupTableProgram,
   VersionedTransaction,
   TransactionMessage,
+  ConfirmedSignatureInfo,
 } from "@solana/web3.js";
 
 export function findProgramAddress(label: string, program: PublicKey, extraSeeds?: string[]) {
@@ -50,13 +51,14 @@ export async function readEvents<IDL extends Idl = Idl>(
   programs: Program<IDL>[],
   commitment: Finality = "confirmed"
 ) {
-  const txResult = await connection.getTransaction(txSignature, {
-    commitment,
-    maxSupportedTransactionVersion: 0,
-  });
+  const txResult = await connection.getTransaction(txSignature, { commitment, maxSupportedTransactionVersion: 0 });
 
   if (txResult === null) return [];
 
+  return processEventFromTx(txResult, programs);
+}
+
+function processEventFromTx(txResult: web3.VersionedTransactionResponse, programs: Program<any>[]) {
   const eventAuthorities: Map<string, PublicKey> = new Map();
   for (const program of programs) {
     eventAuthorities.set(
@@ -95,10 +97,32 @@ export async function readEvents<IDL extends Idl = Idl>(
       }
     }
   }
-
   return events;
 }
 
+// Helper function to wait for an event to be emitted. Should only be used in tests where txSignature is known to emit.
+export async function readEventsUntilFound<IDL extends Idl = Idl>(
+  connection: Connection,
+  txSignature: string,
+  programs: Program<IDL>[]
+) {
+  const startTime = Date.now();
+  let txResult = null;
+
+  while (Date.now() - startTime < 5000) {
+    // 5 seconds timeout to wait to find the event.
+    txResult = await connection.getTransaction(txSignature, {
+      commitment: "confirmed",
+      maxSupportedTransactionVersion: 0,
+    });
+    if (txResult !== null) return processEventFromTx(txResult, programs);
+
+    await new Promise((resolve) => setTimeout(resolve, 50)); // 50 ms delay between retries.
+  }
+
+  throw new Error("No event found within 5 seconds");
+}
+
 export function getEvent(events: any[], program: PublicKey, eventName: string) {
   for (const event of events) {
     if (event.name === eventName && program.toString() === event.program.toString()) {
@@ -108,19 +132,53 @@ export function getEvent(events: any[], program: PublicKey, eventName: string) {
   throw new Error("Event " + eventName + " not found");
 }
 
+export interface EventType {
+  program: PublicKey;
+  data: any;
+  name: string;
+  slot: number;
+  confirmationStatus: string;
+  blockTime: number;
+  signature: string;
+}
+
 export async function readProgramEvents(
   connection: Connection,
   program: Program<any>,
-  options?: SignaturesForAddressOptions,
-  finality: Finality = "confirmed"
-) {
-  const events = [];
-  const pastSignatures = await connection.getSignaturesForAddress(program.programId, options, finality);
+  finality: Finality = "confirmed",
+  options: SignaturesForAddressOptions = { limit: 1000 }
+): Promise<EventType[]> {
+  const allSignatures: ConfirmedSignatureInfo[] = [];
+
+  // Fetch all signatures in sequential batches
+  while (true) {
+    const signatures = await connection.getSignaturesForAddress(program.programId, options, finality);
+    allSignatures.push(...signatures);
+
+    // Update options for the next batch. Set before to the last fetched signature.
+    if (signatures.length > 0) {
+      options = { ...options, before: signatures[signatures.length - 1].signature };
+    }
 
-  for (const signature of pastSignatures) {
-    events.push(...(await readEvents(connection, signature.signature, [program], finality)));
+    if (options.limit && signatures.length < options.limit) break; // Exit early if the number of signatures < limit
   }
-  return events;
+
+  // Fetch events for all signatures in parallel
+  const eventsWithSlots = await Promise.all(
+    allSignatures.map(async (signature) => {
+      const events = await readEvents(connection, signature.signature, [program], finality);
+      return events.map((event) => ({
+        ...event,
+        confirmationStatus: signature.confirmationStatus || "Unknown",
+        blockTime: signature.blockTime || 0,
+        signature: signature.signature,
+        slot: signature.slot,
+        name: event.name || "Unknown",
+      }));
+    })
+  );
+
+  return eventsWithSlots.flat(); // Flatten the array of events & return.
 }
 
 export async function subscribeToCpiEventsForProgram(

test/svm/SvmSpoke.Bundle.ts

@@ -22,8 +22,7 @@ import {
   buildRelayerRefundMerkleTree,
   loadExecuteRelayerRefundLeafParams,
   randomBigInt,
-  readEvents,
-  readProgramEvents,
+  readEventsUntilFound,
   relayerRefundHashFn,
   RelayerRefundLeafSolana,
   RelayerRefundLeafType,
@@ -186,11 +185,8 @@ describe("svm_spoke.bundle", () => {
       .accounts(relayRootBundleAccounts)
       .rpc();
 
-    // Wait for event processing
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-
     // Check for the emitted event
-    const events = await readEvents(connection, tx, [program]);
+    let events = await readEventsUntilFound(connection, tx, [program]);
     const event = events.find((event) => event.name === "relayedRootBundle")?.data;
     assert.isTrue(event.rootBundleId.toString() === rootBundleId.toString(), "Root bundle ID should match");
     assert.isTrue(
@@ -255,17 +251,15 @@ describe("svm_spoke.bundle", () => {
     };
     const proofAsNumbers = proof.map((p) => Array.from(p));
     await loadExecuteRelayerRefundLeafParams(program, owner, stateAccountData.rootBundleId, leaf, proofAsNumbers);
-    await program.methods
+    const tx = await program.methods
       .executeRelayerRefundLeaf()
       .accounts(executeRelayerRefundLeafAccounts)
       .remainingAccounts(remainingAccounts)
       .rpc();
 
     // Verify the ExecutedRelayerRefundRoot event
-    await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait for event processing
-    let events = await readProgramEvents(connection, program);
+    let events = await readEventsUntilFound(connection, tx, [program]);
     let event = events.find((event) => event.name === "executedRelayerRefundRoot")?.data;
-
     // Remove the expectedValues object and use direct assertions
     assertSE(event.amountToReturn, relayerRefundLeaves[0].amountToReturn, "amountToReturn should match");
     assertSE(event.chainId, chainId, "chainId should match");
@@ -280,7 +274,6 @@ describe("svm_spoke.bundle", () => {
     assertSE(event.caller, owner, "caller should match");
 
     event = events.find((event) => event.name === "tokensBridged")?.data;
-
     assertSE(event.amountToReturn, relayerRefundLeaves[0].amountToReturn, "amountToReturn should match");
     assertSE(event.chainId, chainId, "chainId should match");
     assertSE(event.leafId, leaf.leafId, "leafId should match");
@@ -1486,17 +1479,14 @@ describe("svm_spoke.bundle", () => {
     it("No deferred refunds in all Token Accounts", async () => {
       const tx = await executeRelayerRefundLeaf({ deferredRefunds: false });
 
-      await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait for event processing
-      const events = await readEvents(connection, tx, [program]);
+      const events = await readEventsUntilFound(connection, tx, [program]);
       const event = events.find((event) => event.name === "executedRelayerRefundRoot")?.data;
       assert.isFalse(event.deferredRefunds, "deferredRefunds should be false");
     });
 
     it("Deferred refunds in all Claim Accounts", async () => {
       const tx = await executeRelayerRefundLeaf({ deferredRefunds: true });
-
-      await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait for event processing
-      const events = await readEvents(connection, tx, [program]);
+      const events = await readEventsUntilFound(connection, tx, [program]);
       const event = events.find((event) => event.name === "executedRelayerRefundRoot")?.data;
       assert.isTrue(event.deferredRefunds, "deferredRefunds should be true");
     });
@@ -1657,7 +1647,6 @@ describe("svm_spoke.bundle", () => {
         .rpc();
       assert.fail("Leaf verification should fail without leading 64 bytes");
     } catch (err: any) {
-      console.log("err", err);
       assert.include(err.toString(), "Invalid Merkle proof", "Expected merkle verification to fail");
     }
   });
@@ -1749,7 +1738,6 @@ describe("svm_spoke.bundle", () => {
         .rpc();
       assert.fail("Leaf verification should fail without leading 64 bytes");
     } catch (err: any) {
-      console.log("err", err);
       assert.include(err.toString(), "Invalid Merkle proof", "Expected merkle verification to fail");
     }
   });

test/svm/SvmSpoke.Deposit.ts

@@ -16,7 +16,7 @@ import {
 } from "@solana/spl-token";
 import { PublicKey, Keypair, Transaction, sendAndConfirmTransaction } from "@solana/web3.js";
 import { common, DepositDataValues } from "./SvmSpoke.common";
-import { readProgramEvents, intToU8Array32, u8Array32ToInt } from "./utils";
+import { readEventsUntilFound, intToU8Array32 } from "./utils";
 const { provider, connection, program, owner, seedBalance, initializeState, depositData } = common;
 const { createRoutePda, getVaultAta, assertSE, assert, getCurrentTime, depositQuoteTimeBuffer, fillDeadlineBuffer } =
   common;
@@ -121,7 +121,8 @@ describe("svm_spoke.deposit", () => {
       .accounts(calledDepositAccounts)
       .instruction();
     const depositTx = new Transaction().add(approveIx, depositIx);
-    await sendAndConfirmTransaction(connection, depositTx, [payer, depositor]);
+    const tx = await sendAndConfirmTransaction(connection, depositTx, [payer, depositor]);
+    return tx;
   };
 
   beforeEach(async () => {
@@ -183,10 +184,9 @@ describe("svm_spoke.deposit", () => {
 
     // Execute the first deposit_v3 call
     let depositDataValues = Object.values(depositData) as DepositDataValues;
-    await approvedDepositV3(depositDataValues);
-    await new Promise((resolve) => setTimeout(resolve, 500));
+    const tx = await approvedDepositV3(depositDataValues);
 
-    let events = await readProgramEvents(connection, program);
+    let events = await readEventsUntilFound(connection, tx, [program]);
     let event = events[0].data; // 0th event is the latest event
     const expectedValues1 = { ...depositData, depositId: intToU8Array32(1) }; // Verify the event props emitted match the depositData.
     for (let [key, value] of Object.entries(expectedValues1)) {
@@ -195,9 +195,8 @@ describe("svm_spoke.deposit", () => {
     }
 
     // Execute the second deposit_v3 call
-    await approvedDepositV3(depositDataValues);
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    events = await readProgramEvents(connection, program);
+    const tx2 = await approvedDepositV3(depositDataValues);
+    events = await readEventsUntilFound(connection, tx2, [program]);
     event = events[0].data; // 0th event is the latest event.
 
     const expectedValues2 = { ...expectedValues1, depositId: intToU8Array32(2) }; // Verify the event props emitted match the depositData.
@@ -364,8 +363,6 @@ describe("svm_spoke.deposit", () => {
 
     await program.methods.setEnableRoute(inputToken, fakeRouteChainId, true).accounts(fakeSetEnableRouteAccounts).rpc();
 
-    await new Promise((resolve) => setTimeout(resolve, 2000));
-
     const fakeDepositAccounts = {
       state: fakeState.state,
       route: fakeRoutePda,
@@ -382,11 +379,9 @@ describe("svm_spoke.deposit", () => {
       ...depositData,
       destinationChainId: fakeRouteChainId,
     }) as DepositDataValues;
-    await approvedDepositV3(depositDataValues, fakeDepositAccounts);
-
-    await new Promise((resolve) => setTimeout(resolve, 500));
+    const tx = await approvedDepositV3(depositDataValues, fakeDepositAccounts);
 
-    let events = await readProgramEvents(connection, program);
+    let events = await readEventsUntilFound(connection, tx, [program]);
     let event = events[0].data; // 0th event is the latest event.
     const expectedValues = {
       ...{ ...depositData, destinationChainId: fakeRouteChainId },
@@ -457,11 +452,9 @@ describe("svm_spoke.deposit", () => {
       .accounts(depositAccounts)
       .instruction();
     const depositTx = new Transaction().add(approveIx, depositIx);
-    await sendAndConfirmTransaction(connection, depositTx, [payer, depositor]);
+    const tx = await sendAndConfirmTransaction(connection, depositTx, [payer, depositor]);
 
-    await new Promise((resolve) => setTimeout(resolve, 500));
-
-    const events = await readProgramEvents(connection, program);
+    const events = await readEventsUntilFound(connection, tx, [program]);
     const event = events[0].data; // 0th event is the latest event.
 
     // Verify the event props emitted match the expected values
@@ -526,10 +519,9 @@ describe("svm_spoke.deposit", () => {
     depositData.exclusivityParameter = maxExclusivityOffsetSeconds;
 
     const depositDataValues = Object.values(depositData) as DepositDataValues;
-    await approvedDepositV3(depositDataValues);
+    const tx = await approvedDepositV3(depositDataValues);
 
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    const events = await readProgramEvents(connection, program);
+    const events = await readEventsUntilFound(connection, tx, [program]);
     const event = events[0].data; // 0th event is the latest event
     assertSE(
       event.exclusivityDeadline,
@@ -547,10 +539,9 @@ describe("svm_spoke.deposit", () => {
     depositData.exclusivityParameter = exclusivityDeadlineTimestamp;
 
     const depositDataValues = Object.values(depositData) as DepositDataValues;
-    await approvedDepositV3(depositDataValues);
+    const tx = await approvedDepositV3(depositDataValues);
 
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    const events = await readProgramEvents(connection, program);
+    const events = await readEventsUntilFound(connection, tx, [program]);
     const event = events[0].data; // 0th event is the latest event;
 
     assertSE(event.exclusivityDeadline, exclusivityDeadlineTimestamp, "exclusivityDeadline should be passed in time");
@@ -565,10 +556,9 @@ describe("svm_spoke.deposit", () => {
     depositData.exclusivityParameter = zeroExclusivity;
 
     const depositDataValues = Object.values(depositData) as DepositDataValues;
-    await approvedDepositV3(depositDataValues);
+    const tx = await approvedDepositV3(depositDataValues);
 
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    const events = await readProgramEvents(connection, program);
+    const events = await readEventsUntilFound(connection, tx, [program]);
     const event = events[0].data; // 0th event is the latest event;
 
     assertSE(event.exclusivityDeadline, zeroExclusivity, "Exclusivity deadline should always be 0");
@@ -629,13 +619,12 @@ describe("svm_spoke.deposit", () => {
       .instruction();
 
     const unsafeDepositTx = new Transaction().add(approveIx, unsafeDepositIx);
-    await sendAndConfirmTransaction(connection, unsafeDepositTx, [payer, depositor]);
+    const tx = await sendAndConfirmTransaction(connection, unsafeDepositTx, [payer, depositor]);
 
     // Wait for a short period to ensure the event is emitted
-    await new Promise((resolve) => setTimeout(resolve, 500));
 
     // Read and verify the event
-    const events = await readProgramEvents(connection, program);
+    const events = await readEventsUntilFound(connection, tx, [program]);
     const event = events[0].data; // Assuming the latest event is the one we want
 
     const expectedValues = { ...depositData, depositId: expectedDepositIdArray };

test/svm/SvmSpoke.Fill.AcrossPlus.ts

@@ -255,7 +255,7 @@ describe("svm_spoke.fill.across_plus", () => {
       await sendTransactionWithLookupTable(connection, [computeBudgetIx, approveIx, fillIx], relayer);
 
       // Verify relayer's balance after the fill
-      await new Promise((resolve) => setTimeout(resolve, 1000)); // Make sure token transfers get processed.
+      await new Promise((resolve) => setTimeout(resolve, 500)); // Make sure token transfers get processed.
       const fRelayerBal = (await getAccount(connection, relayerATA)).amount;
       assertSE(
         fRelayerBal,