feat(svm-eventsClient): add methods to find deposit and fills from signature (#1033)

Signed-off-by: Gerhard Steenkamp <gerhard@umaproject.org>

Author: gsteenkamp89

src/arch/svm/eventsClient.ts

@@ -2,9 +2,16 @@ 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, Signature } from "@solana/kit";
-import { bs58 } from "../../utils";
+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'.
@@ -19,6 +26,9 @@ type GetSignaturesForAddressConfig = Parameters<GetSignaturesForAddressApi["getS
 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;
@@ -211,6 +221,109 @@ export class SvmCpiEventsClient {
     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;
   }

src/interfaces/SpokePool.ts

@@ -37,6 +37,10 @@ export interface DepositWithBlock extends Deposit, SortableEvent {
   quoteBlockNumber: number;
 }
 
+export interface DepositWithTime extends Deposit, SortableEvent {
+  depositTimestamp: number;
+}
+
 export enum FillStatus {
   Unfilled = 0,
   RequestedSlowFill,
@@ -66,6 +70,9 @@ export interface Fill extends Omit<RelayData, "message"> {
 }
 
 export interface FillWithBlock extends Fill, SortableEvent {}
+export interface FillWithTime extends Fill, SortableEvent {
+  fillTimestamp: number;
+}
 
 export interface EnabledDepositRoute {
   originToken: string;

src/utils/SpokeUtils.ts

@@ -1,4 +1,4 @@
-import { encodeAbiParameters, keccak256 } from "viem";
+import { encodeAbiParameters, Hex, keccak256 } from "viem";
 import { MAX_SAFE_DEPOSIT_ID, ZERO_ADDRESS, ZERO_BYTES } from "../constants";
 import { Deposit, RelayData } from "../interfaces";
 import { toBytes32 } from "./AddressUtils";
@@ -91,5 +91,5 @@ export function isZeroAddress(address: string): boolean {
 }
 
 export function getMessageHash(message: string): string {
-  return isMessageEmpty(message) ? ZERO_BYTES : keccak256(message as "0x{string}");
+  return isMessageEmpty(message) ? ZERO_BYTES : keccak256(message as Hex);
 }

test/Solana.SvmCpiEventsClient.Integration.test.ts

@@ -1,8 +1,8 @@
 import { SvmSpokeClient } from "@across-protocol/contracts";
-import { getSolanaChainId, intToU8Array32 } from "@across-protocol/contracts/dist/src/svm/web3-v1";
+import { getSolanaChainId, intToU8Array32, u8Array32ToInt } from "@across-protocol/contracts/dist/src/svm/web3-v1";
 import { SYSTEM_PROGRAM_ADDRESS } from "@solana-program/system";
 import { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, TOKEN_2022_PROGRAM_ADDRESS } from "@solana-program/token-2022";
-import { Address, KeyPairSigner } from "@solana/kit";
+import { address, Address, KeyPairSigner } from "@solana/kit";
 import { expect } from "chai";
 import { BigNumber } from "ethers";
 import { arrayify, hexlify } from "ethers/lib/utils";
@@ -29,6 +29,12 @@ import {
   requestSlowFill,
 } from "./utils/svm/utils";
 import { validatorSetup, validatorTeardown } from "./utils/svm/validator.setup";
+import { CHAIN_IDs } from "@across-protocol/constants";
+
+// Define an extended interface for our Solana client with chainId
+interface ExtendedSolanaClient extends ReturnType<typeof createDefaultSolanaClient> {
+  chainId: number;
+}
 
 const formatRelayData = (relayData: SvmSpokeClient.RelayDataArgs): RelayData => {
   return {
@@ -52,7 +58,9 @@ const getRandomInt = (min: number = 0, max: number = 1000000) => {
 };
 
 describe("SvmCpiEventsClient (integration)", () => {
-  const solanaClient = createDefaultSolanaClient();
+  const solanaClient = createDefaultSolanaClient() as ExtendedSolanaClient;
+  // Add chainId property for tests
+  solanaClient.chainId = 7777; // Use a test value for Solana testnet
   let client: SvmCpiEventsClient;
 
   let signer: KeyPairSigner;
@@ -328,4 +336,49 @@ describe("SvmCpiEventsClient (integration)", () => {
     expect(data.fillDeadline).to.equal(relayData.fillDeadline);
     expect(data.exclusivityDeadline).to.equal(relayData.exclusivityDeadline);
   });
+
+  it("gets deposit events from transaction signature", async () => {
+    // deposit from solana
+    solanaClient.chainId = CHAIN_IDs.SOLANA;
+    const payerAta = await mintTokens(signer, solanaClient, address(mint.address), tokenAmount);
+    const { depositInput, signature } = await sendCreateDeposit(payerAta, tokenAmount, tokenAmount);
+
+    const depositEvents = await client.getDepositEventsFromSignature(solanaClient.chainId, signature);
+
+    expect(depositEvents).to.have.lengthOf(1);
+    const depositEvent = depositEvents![0];
+    expect(SvmAddress.from(depositEvent.depositor, "base16").toBase58()).to.equal(depositInput.depositor.toString());
+    expect(SvmAddress.from(depositEvent.recipient, "base16").toBase58()).to.equal(depositInput.recipient.toString());
+    expect(SvmAddress.from(depositEvent.inputToken, "base16").toBase58()).to.equal(depositInput.inputToken.toString());
+    expect(SvmAddress.from(depositEvent.outputToken, "base16").toBase58()).to.equal(
+      depositInput.outputToken.toString()
+    );
+    expect(depositEvent.inputAmount.toString()).to.equal(depositInput.inputAmount.toString());
+    expect(depositEvent.outputAmount.toString()).to.equal(depositInput.outputAmount.toString());
+    expect(depositEvent.destinationChainId).to.equal(depositInput.destinationChainId);
+  });
+
+  it("gets fill events from transaction signature", async () => {
+    solanaClient.chainId = CHAIN_IDs.SOLANA;
+
+    await mintTokens(signer, solanaClient, address(mint.address), tokenAmount);
+
+    const { relayData, signature } = await sendCreateFill();
+
+    const fillEvents = await client.getFillEventsFromSignature(solanaClient.chainId, signature);
+
+    expect(fillEvents).to.have.lengthOf(1);
+    const fillEvent = fillEvents![0];
+
+    expect(SvmAddress.from(fillEvent.depositor, "base16").toBase58()).to.equal(relayData.depositor.toString());
+    expect(SvmAddress.from(fillEvent.recipient, "base16").toBase58()).to.equal(relayData.recipient.toString());
+    expect(SvmAddress.from(fillEvent.inputToken, "base16").toBase58()).to.equal(relayData.inputToken.toString());
+    expect(SvmAddress.from(fillEvent.outputToken, "base16").toBase58()).to.equal(relayData.outputToken.toString());
+    expect(fillEvent.inputAmount.toString()).to.equal(BigInt(relayData.inputAmount).toString());
+    expect(fillEvent.outputAmount.toString()).to.equal(BigInt(relayData.outputAmount).toString());
+    expect(fillEvent.originChainId).to.equal(Number(relayData.originChainId));
+    expect(fillEvent.depositId).to.equal(u8Array32ToInt(relayData.depositId));
+    expect(fillEvent.fillDeadline).to.equal(Number(relayData.fillDeadline));
+    expect(fillEvent.exclusivityDeadline).to.equal(Number(relayData.exclusivityDeadline));
+  });
 });