@across-protocol/sdk 4.1.19 → 4.1.21

package/src/clients/SpokePoolClient.ts

@@ -21,6 +21,7 @@ import {
   isValidEvmAddress,
   isZeroAddress,
   toAddress,
+  validateFillForDeposit,
 } from "../utils";
 import {
   duplicateEvent,
@@ -29,7 +30,6 @@ import {
   spreadEvent,
   spreadEventWithBlockNumber,
 } from "../utils/EventUtils";
-import { validateFillForDeposit } from "../utils/FlowUtils";
 import { ZERO_ADDRESS } from "../constants";
 import {
   Deposit,
@@ -84,6 +84,7 @@ export class SpokePoolClient extends BaseAbstractClient {
   protected relayerRefundExecutions: RelayerRefundExecutionWithBlock[] = [];
   protected queryableEventNames: string[] = [];
   protected configStoreClient: AcrossConfigStoreClient | undefined;
+  protected invalidFills: Set<string> = new Set();
   public earliestDepositIdQueried = MAX_BIG_INT;
   public latestDepositIdQueried = bnZero;
   public firstDepositIdForSpokePool = MAX_BIG_INT;
@@ -380,7 +381,7 @@ export class SpokePoolClient extends BaseAbstractClient {
   public getValidUnfilledAmountForDeposit(deposit: Deposit): {
     unfilledAmount: BigNumber;
     fillCount: number;
-    invalidFills: Fill[];
+    invalidFills: FillWithBlock[];
   } {
     const { outputAmount } = deposit;
     const fillsForDeposit = this.depositHashesToFills[this.getDepositHash(deposit)];
@@ -390,7 +391,10 @@ export class SpokePoolClient extends BaseAbstractClient {
     }
 
     const { validFills, invalidFills, unrepayableFills } = fillsForDeposit.reduce(
-      (groupedFills: { validFills: Fill[]; invalidFills: Fill[]; unrepayableFills: Fill[] }, fill: Fill) => {
+      (
+        groupedFills: { validFills: FillWithBlock[]; invalidFills: FillWithBlock[]; unrepayableFills: FillWithBlock[] },
+        fill: FillWithBlock
+      ) => {
         if (validateFillForDeposit(fill, deposit).valid) {
           const repaymentChainId = getRepaymentChainId(fill, deposit);
           // In order to keep this function sync, we can't call verifyFillRepayment so we'll log any fills that
@@ -423,7 +427,15 @@ export class SpokePoolClient extends BaseAbstractClient {
     );
 
     // Log any invalid deposits with same deposit id but different params.
-    const invalidFillsForDeposit = invalidFills.filter((x) => x.depositId.eq(deposit.depositId));
+    const invalidFillsForDeposit = invalidFills.filter((x) => {
+      const txnUid = `${x.transactionHash}:${x.logIndex}`;
+      // if txnUid doesn't exist in the invalidFills set, add it now, but log the corresponding fill.
+      const newInvalidFill = x.depositId.eq(deposit.depositId) && !this.invalidFills.has(txnUid);
+      if (newInvalidFill) {
+        this.invalidFills.add(txnUid);
+      }
+      return newInvalidFill;
+    });
     if (invalidFillsForDeposit.length > 0) {
       this.logger.warn({
         at: "SpokePoolClient",
@@ -606,19 +618,6 @@ export class SpokePoolClient extends BaseAbstractClient {
     const { events: queryResults, currentTime, searchEndBlock } = update;
 
     if (eventsToQuery.includes("TokensBridged")) {
-      // Temporarily query old spoke pool events as well to ease migration:
-      const legacySpokePoolAbi = [
-        "event TokensBridged(uint256 amountToReturn,uint256 indexed chainId,uint32 indexed leafId,address indexed l2TokenAddress,address caller)",
-      ];
-      const prevSpoke = new Contract(this.spokePool.address, legacySpokePoolAbi, this.spokePool.provider);
-      const legacyQueryResults = await paginatedEventQuery(
-        prevSpoke,
-        prevSpoke.filters.TokensBridged(),
-        (await this.updateSearchConfig(this.spokePool.provider)) as EventSearchConfig
-      );
-      for (const event of legacyQueryResults) {
-        this.tokensBridged.push(spreadEventWithBlockNumber(event) as TokensBridged);
-      }
       for (const event of queryResults[eventsToQuery.indexOf("TokensBridged")]) {
         this.tokensBridged.push(spreadEventWithBlockNumber(event) as TokensBridged);
       }

package/src/index.ts

@@ -14,3 +14,4 @@ export * as clients from "./clients";
 export * as typechain from "./typechain";
 export * as caching from "./caching";
 export * as providers from "./providers";
+export * as svm from "./svm";

package/src/lpFeeCalculator/lpFeeCalculator.ts

@@ -14,6 +14,8 @@ export interface RateModel {
   R2: BigNumberish; // R_0+R_1+R_2 is the interest rate charged at 100% utilization
 }
 
+const ONE_HUNDRED_PERCENT = toBN(10).pow(18);
+
 // converts an APY rate to a one week rate. Uses the Decimal library to take a fractional exponent
 function convertApyToWeeklyFee(apy: BN): BN {
   // R_week = (1 + apy)^(1/52) - 1
@@ -99,7 +101,10 @@ export class LPFeeCalculator {
     const apy = this.calculateApyFromUtilization(toBN(utilizationBeforeDeposit), toBN(utilizationAfterDeposit));
 
     // ACROSS UMIP requires that the realized fee percent is floor rounded as decimal to 6 decimals.
-    return truncateDecimals ? truncate18DecimalBN(convertApyToWeeklyFee(apy), 6) : convertApyToWeeklyFee(apy);
+    return min(
+      ONE_HUNDRED_PERCENT,
+      truncateDecimals ? truncate18DecimalBN(convertApyToWeeklyFee(apy), 6) : convertApyToWeeklyFee(apy)
+    );
   }
   /**
    * Calculate the realized yearly LP Fee APY Percent for a given rate model, utilization before and after the deposit.

package/src/providers/cachedProvider.ts

@@ -42,49 +42,49 @@ export class CacheProvider extends RateLimitedProvider {
   override async send(method: string, params: Array<unknown>): Promise<unknown> {
     let cacheType = this.redisClient ? await this.cacheType(method, params) : CacheType.NONE;
 
-    if (cacheType !== CacheType.NONE) {
-      const redisKey = this.buildRedisKey(method, params);
+    if (cacheType === CacheType.NONE) {
+      return await super.send(method, params);
+    }
 
-      // Attempt to pull the result from the cache.
-      const redisResult = await this.redisClient?.get<string>(redisKey);
+    const redisKey = this.buildRedisKey(method, params);
 
-      // If cache has the result, parse the json and return it.
-      if (redisResult) {
-        return JSON.parse(redisResult);
-      }
+    // Attempt to pull the result from the cache.
+    const redisResult = await this.redisClient?.get<string>(redisKey);
 
-      // Cache does not have the result. Query it directly and cache.
-      const result = await super.send(method, params);
+    // If cache has the result, parse the json and return it.
+    if (redisResult) {
+      return JSON.parse(redisResult);
+    }
 
-      if (cacheType === CacheType.DECIDE_TTL_POST_SEND) {
-        const blockNumber = this.getBlockNumberFromRpcResponse(method, result);
-        cacheType = await this.cacheTypeForBlock(blockNumber);
-        if (cacheType === CacheType.NONE) {
-          return result;
-        }
-      }
+    // Cache does not have the result. Query it directly and cache.
+    const result = await super.send(method, params);
 
-      // Note: use swtich to ensure all enum cases are handled.
-      switch (cacheType) {
-        case CacheType.WITH_TTL:
-          {
-            // Apply a random margin to spread expiry over a larger time window.
-            const ttl = this.baseTTL + Math.ceil(random(-ttl_modifier, ttl_modifier, true) * this.baseTTL);
-            await this.redisClient?.set(redisKey, JSON.stringify(result), ttl);
-          }
-          break;
-        case CacheType.NO_TTL:
-          await this.redisClient?.set(redisKey, JSON.stringify(result), Number.POSITIVE_INFINITY);
-          break;
-        default:
-          throw new Error(`Unexpected Cache type: ${cacheType}`);
+    if (cacheType === CacheType.DECIDE_TTL_POST_SEND) {
+      const blockNumber = this.getBlockNumberFromRpcResponse(method, result);
+      cacheType = await this.cacheTypeForBlock(blockNumber);
+      if (cacheType === CacheType.NONE) {
+        return result;
       }
+    }
 
-      // Return the cached result.
-      return result;
+    // Note: use swtich to ensure all enum cases are handled.
+    switch (cacheType) {
+      case CacheType.WITH_TTL:
+        {
+          // Apply a random margin to spread expiry over a larger time window.
+          const ttl = this.baseTTL + Math.ceil(random(-ttl_modifier, ttl_modifier, true) * this.baseTTL);
+          await this.redisClient?.set(redisKey, JSON.stringify(result), ttl);
+        }
+        break;
+      case CacheType.NO_TTL:
+        await this.redisClient?.set(redisKey, JSON.stringify(result), Number.POSITIVE_INFINITY);
+        break;
+      default:
+        throw new Error(`Unexpected Cache type: ${cacheType}`);
     }
 
-    return await super.send(method, params);
+    // Return the cached result.
+    return result;
   }
 
   private buildRedisKey(method: string, params: Array<unknown>) {

package/src/providers/solana/baseRpcFactories.ts

@@ -1,4 +1,4 @@
-import { ClusterUrl, createSolanaRpcFromTransport, RpcTransport } from "@solana/web3.js";
+import { ClusterUrl, createSolanaRpcFromTransport, RpcTransport } from "@solana/kit";
 
 // This is abstract base class for creating Solana RPC clients and transports.
 export abstract class SolanaBaseRpcFactory {

package/src/providers/solana/cachedRpcFactory.ts

@@ -0,0 +1,124 @@
+import { RpcTransport, GetTransactionApi, RpcFromTransport, SolanaRpcApiFromTransport } from "@solana/kit";
+import { is, object, optional, string, tuple } from "superstruct";
+import { CachingMechanismInterface } from "../../interfaces";
+import { SolanaClusterRpcFactory } from "./baseRpcFactories";
+import { RateLimitedSolanaRpcFactory } from "./rateLimitedRpcFactory";
+import { CacheType } from "../utils";
+import { jsonReplacerWithBigInts, jsonReviverWithBigInts } from "../../utils";
+
+export class CachedSolanaRpcFactory extends SolanaClusterRpcFactory {
+  public readonly getTransactionCachePrefix: string;
+
+  // Holds the underlying transport that the cached transport wraps.
+  protected rateLimitedTransport: RpcTransport;
+
+  // RPC client based on the rate limited transport, used internally to check confirmation status.
+  protected rateLimitedRpcClient: RpcFromTransport<SolanaRpcApiFromTransport<RpcTransport>, RpcTransport>;
+
+  constructor(
+    providerCacheNamespace: string,
+    readonly redisClient?: CachingMechanismInterface,
+    ...rateLimitedConstructorParams: ConstructorParameters<typeof RateLimitedSolanaRpcFactory>
+  ) {
+    // SolanaClusterRpcFactory shares the last two constructor parameters with RateLimitedSolanaRpcFactory.
+    const superParams = rateLimitedConstructorParams.slice(-2) as [
+      ConstructorParameters<typeof SolanaClusterRpcFactory>[0], // clusterUrl: ClusterUrl
+      ConstructorParameters<typeof SolanaClusterRpcFactory>[1], // chainId: number
+    ];
+    super(...superParams);
+
+    // Create the rate limited transport and RPC client.
+    const rateLimitedRpcFactory = new RateLimitedSolanaRpcFactory(...rateLimitedConstructorParams);
+    this.rateLimitedTransport = rateLimitedRpcFactory.createTransport();
+    this.rateLimitedRpcClient = rateLimitedRpcFactory.createRpcClient();
+
+    // Pre-compute as much of the redis key as possible.
+    const cachePrefix = `${providerCacheNamespace},${new URL(this.clusterUrl).hostname},${this.chainId}`;
+    this.getTransactionCachePrefix = `${cachePrefix}:getTransaction,`;
+  }
+
+  public createTransport(): RpcTransport {
+    return async <TResponse>(...args: Parameters<RpcTransport>): Promise<TResponse> => {
+      const { method, params } = args[0].payload as { method: string; params?: unknown[] };
+      const cacheType = this.redisClient ? this.cacheType(method) : CacheType.NONE;
+
+      if (cacheType === CacheType.NONE) {
+        return this.rateLimitedTransport<TResponse>(...args);
+      }
+
+      const redisKey = this.buildRedisKey(method, params);
+
+      // Attempt to pull the result from the cache.
+      const redisResult = await this.redisClient?.get<string>(redisKey);
+
+      // If cache has the result, parse the json and return it.
+      if (redisResult) {
+        return JSON.parse(redisResult, jsonReviverWithBigInts);
+      }
+
+      // Cache does not have the result. Query it directly and cache it if finalized.
+      return this.requestAndCacheFinalized<TResponse>(...args);
+    };
+  }
+
+  private async requestAndCacheFinalized<TResponse>(...args: Parameters<RpcTransport>): Promise<TResponse> {
+    const { method, params } = args[0].payload as { method: string; params?: unknown[] };
+
+    // Only handles getTransaction right now.
+    if (method !== "getTransaction") return this.rateLimitedTransport<TResponse>(...args);
+
+    // Do not throw if params are not valid, just skip caching and pass through to the underlying transport.
+    if (!this.isGetTransactionParams(params)) return this.rateLimitedTransport<TResponse>(...args);
+
+    // Check the confirmation status first to avoid caching non-finalized transactions.
+    const getSignatureStatusesResponse = await this.rateLimitedRpcClient
+      .getSignatureStatuses([params[0]], {
+        searchTransactionHistory: true,
+      })
+      .send();
+
+    const getTransactionResponse = await this.rateLimitedTransport<TResponse>(...args);
+
+    // Cache the transaction only if it is finalized.
+    if (getSignatureStatusesResponse.value[0]?.confirmationStatus === "finalized") {
+      const redisKey = this.buildRedisKey(method, params);
+      await this.redisClient?.set(
+        redisKey,
+        JSON.stringify(getTransactionResponse, jsonReplacerWithBigInts),
+        Number.POSITIVE_INFINITY
+      );
+    }
+
+    return getTransactionResponse;
+  }
+
+  private buildRedisKey(method: string, params?: unknown[]) {
+    // Only handles getTransaction right now.
+    switch (method) {
+      case "getTransaction":
+        return this.getTransactionCachePrefix + JSON.stringify(params, jsonReplacerWithBigInts);
+      default:
+        throw new Error(`CachedSolanaRpcFactory::buildRedisKey: invalid JSON-RPC method ${method}`);
+    }
+  }
+
+  private cacheType(method: string): CacheType {
+    // Today, we only cache getTransaction.
+    if (method === "getTransaction") {
+      // We only store finalized transactions in the cache, hence TTL is not required.
+      return CacheType.NO_TTL;
+    } else {
+      return CacheType.NONE;
+    }
+  }
+
+  private isGetTransactionParams(params: unknown): params is Parameters<GetTransactionApi["getTransaction"]> {
+    return is(
+      params,
+      tuple([
+        string(), // Signature (Base58 string)
+        optional(object()), // We use only the tx signature to get its commitment, but pass through the options as is.
+      ])
+    );
+  }
+}

package/src/providers/solana/defaultRpcFactory.ts

@@ -1,4 +1,4 @@
-import { createDefaultRpcTransport, RpcTransport } from "@solana/web3.js";
+import { createDefaultRpcTransport, RpcTransport } from "@solana/kit";
 import { SolanaClusterRpcFactory } from "./baseRpcFactories";
 
 // Exposes default RPC transport for Solana in the SolanaClusterRpcFactory class.

package/src/providers/solana/index.ts

@@ -1,4 +1,5 @@
 export * from "./baseRpcFactories";
+export * from "./cachedRpcFactory";
 export * from "./defaultRpcFactory";
 export * from "./rateLimitedRpcFactory";
 export * from "./utils";

package/src/providers/solana/rateLimitedRpcFactory.ts

@@ -1,4 +1,4 @@
-import { RpcResponse, RpcTransport } from "@solana/web3.js";
+import { RpcResponse, RpcTransport } from "@solana/kit";
 import { QueueObject, queue } from "async";
 import winston, { Logger } from "winston";
 import { SolanaClusterRpcFactory } from "./baseRpcFactories";
@@ -13,7 +13,7 @@ export class RateLimitedSolanaRpcFactory extends SolanaClusterRpcFactory {
   private queue: QueueObject<SolanaRateLimitTask>;
 
   // Holds the underlying transport that the rate limiter wraps.
-  private readonly defaultTransport: RpcTransport;
+  protected defaultTransport: RpcTransport;
 
   // Takes the same arguments as the SolanaDefaultRpcFactory, but it has an additional parameters to control
   // concurrency and logging at the beginning of the list.

package/src/svm/eventsClient.ts

@@ -0,0 +1,205 @@
+import { getDeployedAddress, SvmSpokeIdl } from "@across-protocol/contracts";
+import { getSolanaChainId } from "@across-protocol/contracts/dist/src/svm/web3-v1";
+import { BorshEventCoder, utils } from "@coral-xyz/anchor";
+import web3, {
+  Address,
+  Commitment,
+  GetSignaturesForAddressApi,
+  GetTransactionApi,
+  RpcTransport,
+  Signature,
+} from "@solana/kit";
+import { EventData, EventName, EventWithData } from "./types";
+import { getEventName, parseEventData } from "./utils/events";
+import { isDevnet } from "./utils/helpers";
+
+// 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 class SvmSpokeEventsClient {
+  private rpc: web3.Rpc<web3.SolanaRpcApiFromTransport<RpcTransport>>;
+  private svmSpokeAddress: Address;
+  private svmSpokeEventAuthority: Address;
+
+  /**
+   * Private constructor. Use the async create() method to instantiate.
+   */
+  private constructor(
+    rpc: web3.Rpc<web3.SolanaRpcApiFromTransport<RpcTransport>>,
+    svmSpokeAddress: Address,
+    eventAuthority: Address
+  ) {
+    this.rpc = rpc;
+    this.svmSpokeAddress = svmSpokeAddress;
+    this.svmSpokeEventAuthority = eventAuthority;
+  }
+
+  /**
+   * Factory method to asynchronously create an instance of SvmSpokeEventsClient.
+   */
+  public static async create(
+    rpc: web3.Rpc<web3.SolanaRpcApiFromTransport<RpcTransport>>
+  ): Promise<SvmSpokeEventsClient> {
+    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,
+      seeds: ["__event_authority"],
+    });
+    return new SvmSpokeEventsClient(rpc, svmSpokeAddress, svmSpokeEventAuthority);
+  }
+
+  /**
+   * 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<T extends EventData>(
+    eventName: EventName,
+    fromSlot?: bigint,
+    toSlot?: bigint,
+    options: GetSignaturesForAddressConfig = { limit: 1000, commitment: "confirmed" }
+  ): Promise<EventWithData<T>[]> {
+    const events = await this.queryAllEvents(fromSlot, toSlot, options);
+    return events.filter((event) => event.name === eventName) as EventWithData<T>[];
+  }
+
+  /**
+   * Queries all events for a specific program.
+   *
+   * @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 all events with additional metadata.
+   */
+  private async queryAllEvents(
+    fromSlot?: bigint,
+    toSlot?: bigint,
+    options: GetSignaturesForAddressConfig = { limit: 1000, commitment: "confirmed" }
+  ): Promise<EventWithData<EventData>[]> {
+    const allSignatures: GetSignaturesForAddressTransaction[] = [];
+    let hasMoreSignatures = true;
+    let currentOptions = options;
+
+    while (hasMoreSignatures) {
+      const signatures: GetSignaturesForAddressApiResponse = await this.rpc
+        .getSignaturesForAddress(this.svmSpokeAddress, 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: EventData; name: EventName }[] {
+    if (!txResult) return [];
+    const events: { program: Address; data: EventData; name: EventName }[] = [];
+
+    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.svmSpokeAddress === ixProgramId &&
+          this.svmSpokeEventAuthority === singleIxAccount
+        ) {
+          const ixData = utils.bytes.bs58.decode(ix.data);
+          // Skip the first 8 bytes (assumed header) and encode the rest.
+          const eventData = utils.bytes.base64.encode(Buffer.from(new Uint8Array(ixData).slice(8)));
+          const event = new BorshEventCoder(SvmSpokeIdl).decode(eventData);
+          if (!event?.name) throw new Error("Event name is undefined");
+          const name = getEventName(event.name);
+          events.push({
+            program: this.svmSpokeAddress,
+            data: parseEventData(event?.data),
+            name,
+          });
+        }
+      }
+    }
+
+    return events;
+  }
+}

package/src/svm/index.ts

@@ -0,0 +1 @@
+export * from "./eventsClient";

package/src/svm/types.ts

@@ -0,0 +1,47 @@
+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",
+  FundsDeposited = "FundsDeposited",
+  EnabledDepositRoute = "EnabledDepositRoute",
+  RelayedRootBundle = "RelayedRootBundle",
+  ExecutedRelayerRefundRoot = "ExecutedRelayerRefundRoot",
+  BridgedToHubPool = "BridgedToHubPool",
+  PausedDeposits = "PausedDeposits",
+  PausedFills = "PausedFills",
+  SetXDomainAdmin = "SetXDomainAdmin",
+  EmergencyDeletedRootBundle = "EmergencyDeletedRootBundle",
+  RequestedSlowFill = "RequestedSlowFill",
+  ClaimedRelayerRefund = "ClaimedRelayerRefund",
+  TokensBridged = "TokensBridged",
+  TransferredOwnership = "TransferredOwnership",
+}
+
+export type EventName = keyof typeof SVMEventNames;
+
+export type EventWithData<T extends EventData> = {
+  confirmationStatus: string | null;
+  blockTime: UnixTimestamp | null;
+  signature: Signature;
+  slot: bigint;
+  name: EventName;
+  data: T;
+  program: Address;
+};

package/src/svm/utils/events.ts

@@ -0,0 +1,46 @@
+import { BN } from "@coral-xyz/anchor";
+import web3 from "@solana/kit";
+import { EventName, SVMEventNames } from "../types";
+
+/**
+ * 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 web3.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;
+}
+
+/**
+ * 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}`);
+}

package/src/svm/utils/helpers.ts

@@ -0,0 +1,9 @@
+import web3, { RpcTransport } from "@solana/kit";
+
+/**
+ * Helper to determine if the current RPC network is devnet.
+ */
+export async function isDevnet(rpc: web3.Rpc<web3.SolanaRpcApiFromTransport<RpcTransport>>): Promise<boolean> {
+  const genesisHash = await rpc.getGenesisHash().send();
+  return genesisHash === "EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG";
+}