@across-protocol/sdk 4.1.63-beta.3 → 4.1.64-alpha.0

package/src/gasPriceOracle/oracle.ts

@@ -1,16 +1,14 @@
 import assert from "assert";
 import { Transport } from "viem";
-import { providers } from "ethers";
+import { PopulatedTransaction, providers } from "ethers";
 import { CHAIN_IDs } from "../constants";
 import { BigNumber, chainIsOPStack, fixedPointAdjustment, toBNWei } from "../utils";
-import { SVMProvider as SolanaProvider } from "../arch/svm";
 import { GasPriceEstimate } from "./types";
 import { getPublicClient } from "./util";
 import * as arbitrum from "./adapters/arbitrum";
 import * as ethereum from "./adapters/ethereum";
 import * as polygon from "./adapters/polygon";
 import * as lineaViem from "./adapters/linea-viem";
-import * as solana from "./adapters/solana";
 
 export interface GasPriceEstimateOptions {
   // baseFeeMultiplier Multiplier applied to base fee for EIP1559 gas prices (or total fee for legacy).
@@ -21,8 +19,8 @@ export interface GasPriceEstimateOptions {
   legacyFallback: boolean;
   // chainId The chain ID to query for gas prices. If omitted can be inferred by provider.
   chainId: number;
-  // unsignedTx The unsigned transaction used for simulation by Linea's Viem provider to produce the priority gas fee, or alternatively, by Solana's provider to determine the base/priority fee.
-  unsignedTx?: unknown;
+  // unsignedTx The unsigned transaction used for simulation by Linea's Viem provider to produce the priority gas fee.
+  unsignedTx?: PopulatedTransaction;
   // transport Viem Transport object to use for querying gas fees used for testing.
   transport?: Transport;
 }
@@ -41,7 +39,7 @@ const VIEM_CHAINS = [CHAIN_IDs.LINEA];
  * @returns An  object of type GasPriceEstimate.
  */
 export async function getGasPriceEstimate(
-  provider: providers.Provider | SolanaProvider,
+  provider: providers.Provider,
   opts: Partial<GasPriceEstimateOptions> = {}
 ): Promise<GasPriceEstimate> {
   const baseFeeMultiplier = opts.baseFeeMultiplier ?? toBNWei("1");
@@ -55,20 +53,6 @@ export async function getGasPriceEstimate(
     `Require 1.0 < priority fee multiplier (${priorityFeeMultiplier}) <= 5.0 for a total gas multiplier within [+1.0, +5.0]`
   );
 
-  // Exit here if we need to estimate on Solana.
-  if (!(provider instanceof providers.Provider)) {
-    const optsWithDefaults: GasPriceEstimateOptions = {
-      ...GAS_PRICE_ESTIMATE_DEFAULTS,
-      baseFeeMultiplier,
-      priorityFeeMultiplier,
-      ...opts,
-      chainId: opts.chainId ?? CHAIN_IDs.SOLANA,
-    };
-    return solana.messageFee(provider, optsWithDefaults);
-  }
-
-  // Cast the provider to an ethers provider, which should be given to the oracle when querying an EVM network.
-  provider = provider as providers.Provider;
   const chainId = opts.chainId ?? (await provider.getNetwork()).chainId;
   const optsWithDefaults: GasPriceEstimateOptions = {
     ...GAS_PRICE_ESTIMATE_DEFAULTS,

package/src/gasPriceOracle/types.ts

@@ -2,18 +2,12 @@ import { type Chain, type Transport, PublicClient, FeeValuesEIP1559 } from "viem
 import { BigNumber } from "../utils";
 
 export type InternalGasPriceEstimate = FeeValuesEIP1559;
-export type GasPriceEstimate = EvmGasPriceEstimate | SvmGasPriceEstimate;
 
-export type EvmGasPriceEstimate = {
+export type GasPriceEstimate = {
   maxFeePerGas: BigNumber;
   maxPriorityFeePerGas: BigNumber;
 };
 
-export type SvmGasPriceEstimate = {
-  baseFee: BigNumber;
-  microLamportsPerComputeUnit: BigNumber;
-};
-
 export interface GasPriceFeed {
   (provider: PublicClient<Transport, Chain>, chainId: number): Promise<InternalGasPriceEstimate>;
 }

package/src/index.ts

@@ -16,3 +16,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/interfaces/SpokePool.ts

@@ -37,10 +37,6 @@ export interface DepositWithBlock extends Deposit, SortableEvent {
   quoteBlockNumber: number;
 }
 
-export interface DepositWithTime extends Deposit, SortableEvent {
-  depositTimestamp: number;
-}
-
 export enum FillStatus {
   Unfilled = 0,
   RequestedSlowFill,
@@ -70,17 +66,7 @@ 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;
-  destinationChainId: number;
-  enabled: boolean;
-}
 
-export interface EnabledDepositRouteWithBlock extends EnabledDepositRoute, SortableEvent {}
 export interface SpeedUp {
   depositor: string;
   depositorSignature: string;

package/src/providers/index.ts

@@ -5,5 +5,5 @@ export * from "./speedProvider";
 export * from "./constants";
 export * from "./types";
 export * from "./utils";
-export * from "./mocks";
+export * as mocks from "./mockProvider";
 export * from "./solana";

package/src/providers/{mocks/mockEthersProvider.ts → mockProvider.ts}

@@ -1,6 +1,6 @@
 import { BigNumber, providers } from "ethers";
 import { Block, BlockTag, FeeData, TransactionResponse } from "@ethersproject/abstract-provider";
-import { bnZero } from "../../utils/BigNumberUtils";
+import { bnZero } from "../utils/BigNumberUtils";
 
 /**
  * @notice Class used to test GasPriceOracle which makes ethers provider calls to the following implemented

package/src/relayFeeCalculator/chain-queries/baseQuery.ts

@@ -3,7 +3,7 @@ import { isL2Provider as isOptimismL2Provider } from "@eth-optimism/sdk/dist/l2-
 
 import { PopulatedTransaction, providers, VoidSigner } from "ethers";
 import { Coingecko } from "../../coingecko";
-import { CHAIN_IDs } from "../../constants";
+import { CHAIN_IDs, DEFAULT_SIMULATED_RELAYER_ADDRESS } from "../../constants";
 import { Deposit } from "../../interfaces";
 import { SpokePool, SpokePool__factory } from "../../typechain";
 import { populateV3Relay } from "../../arch/evm";
@@ -17,12 +17,12 @@ import {
   fixedPointAdjustment,
 } from "../../utils";
 import assert from "assert";
-import { Logger, QueryInterface, getDefaultSimulatedRelayerAddress } from "../relayFeeCalculator";
+import { Logger, QueryInterface } from "../relayFeeCalculator";
 import { Transport } from "viem";
-import { getGasPriceEstimate, EvmGasPriceEstimate } from "../../gasPriceOracle";
+import { getGasPriceEstimate } from "../../gasPriceOracle/oracle";
 type Provider = providers.Provider;
 type OptimismProvider = L2Provider<Provider>;
-export type SymbolMappingType = Record<
+type SymbolMappingType = Record<
   string,
   {
     addresses: Record<number, string>;
@@ -72,7 +72,7 @@ export class QueryBase implements QueryInterface {
    */
   async getGasCosts(
     deposit: Omit<Deposit, "messageHash">,
-    relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
+    relayer = DEFAULT_SIMULATED_RELAYER_ADDRESS,
     options: Partial<{
       gasPrice: BigNumberish;
       gasUnits: BigNumberish;
@@ -122,7 +122,7 @@ export class QueryBase implements QueryInterface {
    */
   getUnsignedTxFromDeposit(
     deposit: Omit<Deposit, "messageHash">,
-    relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId)
+    relayer = DEFAULT_SIMULATED_RELAYER_ADDRESS
   ): Promise<PopulatedTransaction> {
     return populateV3Relay(this.spokePool, deposit, relayer);
   }
@@ -135,7 +135,7 @@ export class QueryBase implements QueryInterface {
    */
   async getNativeGasCost(
     deposit: Omit<Deposit, "messageHash">,
-    relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId)
+    relayer = DEFAULT_SIMULATED_RELAYER_ADDRESS
   ): Promise<BigNumber> {
     const unsignedTx = await this.getUnsignedTxFromDeposit(deposit, relayer);
     const voidSigner = new VoidSigner(relayer, this.provider);
@@ -152,7 +152,7 @@ export class QueryBase implements QueryInterface {
    */
   async getOpStackL1DataFee(
     unsignedTx: PopulatedTransaction,
-    relayer = getDefaultSimulatedRelayerAddress(unsignedTx.chainId),
+    relayer = DEFAULT_SIMULATED_RELAYER_ADDRESS,
     options: Partial<{
       opStackL2GasUnits: BigNumberish;
       opStackL1DataFeeMultiplier: BigNumber;
@@ -213,9 +213,7 @@ export class QueryBase implements QueryInterface {
         ? Promise.resolve({ maxFeePerGas: _gasPrice })
         : getGasPriceEstimate(provider, { chainId, baseFeeMultiplier, priorityFeeMultiplier, transport, unsignedTx }),
     ] as const;
-    const [nativeGasCost, _gasPriceEstimate] = await Promise.all(queries);
-    // It should be safe to cast to an EvmGasPriceEstimate here since QueryBase is only used for EVM chains.
-    const gasPrice = (_gasPriceEstimate as EvmGasPriceEstimate).maxFeePerGas;
+    const [nativeGasCost, { maxFeePerGas: gasPrice }] = await Promise.all(queries);
     assert(nativeGasCost.gt(bnZero), "Gas cost should not be 0");
     let tokenGasCost: BigNumber;
 

package/src/relayFeeCalculator/chain-queries/factory.ts

@@ -3,13 +3,11 @@ import { CHAIN_IDs, TOKEN_SYMBOLS_MAP } from "@across-protocol/constants";
 import { getDeployedAddress } from "@across-protocol/contracts";
 import { asL2Provider } from "@eth-optimism/sdk";
 import { providers } from "ethers";
-import { CUSTOM_GAS_TOKENS } from "../../constants";
-import { chainIsOPStack, isDefined, chainIsSvm, SvmAddress } from "../../utils";
+import { DEFAULT_SIMULATED_RELAYER_ADDRESS, CUSTOM_GAS_TOKENS } from "../../constants";
+import { chainIsOPStack, isDefined } from "../../utils";
 import { QueryBase } from "./baseQuery";
-import { SVMProvider as svmProvider } from "../../arch/svm";
-import { DEFAULT_LOGGER, getDefaultSimulatedRelayerAddress, Logger } from "../relayFeeCalculator";
+import { DEFAULT_LOGGER, Logger } from "../relayFeeCalculator";
 import { CustomGasTokenQueries } from "./customGasToken";
-import { SvmQuery } from "./svmQuery";
 
 /**
  * Some chains have a fixed gas price that is applied to the gas estimates. We should override
@@ -22,21 +20,21 @@ const fixedGasPrice = {
 export class QueryBase__factory {
   static create(
     chainId: number,
-    provider: providers.Provider | svmProvider,
+    provider: providers.Provider,
     symbolMapping = TOKEN_SYMBOLS_MAP,
     spokePoolAddress = getDeployedAddress("SpokePool", chainId),
-    simulatedRelayerAddress = getDefaultSimulatedRelayerAddress(chainId),
+    simulatedRelayerAddress = DEFAULT_SIMULATED_RELAYER_ADDRESS,
     coingeckoProApiKey?: string,
     logger: Logger = DEFAULT_LOGGER,
     coingeckoBaseCurrency = "eth"
-  ): QueryBase | SvmQuery {
+  ): QueryBase {
     assert(isDefined(spokePoolAddress));
 
     const customGasTokenSymbol = CUSTOM_GAS_TOKENS[chainId];
     if (customGasTokenSymbol) {
       return new CustomGasTokenQueries({
         queryBaseArgs: [
-          provider as providers.Provider,
+          provider,
           symbolMapping,
           spokePoolAddress,
           simulatedRelayerAddress,
@@ -48,23 +46,9 @@ export class QueryBase__factory {
         customGasTokenSymbol,
       });
     }
-    if (chainIsSvm(chainId)) {
-      return new SvmQuery(
-        provider as svmProvider,
-        symbolMapping,
-        SvmAddress.from(spokePoolAddress),
-        SvmAddress.from(simulatedRelayerAddress),
-        logger,
-        coingeckoProApiKey,
-        fixedGasPrice[chainId],
-        coingeckoBaseCurrency
-      );
-    }
 
     // For OPStack chains, we need to wrap the provider in an L2Provider
-    provider = chainIsOPStack(chainId)
-      ? asL2Provider(provider as providers.Provider)
-      : (provider as providers.Provider);
+    provider = chainIsOPStack(chainId) ? asL2Provider(provider) : provider;
 
     return new QueryBase(
       provider,

package/src/relayFeeCalculator/chain-queries/index.ts

@@ -1,4 +1,3 @@
 export * from "./baseQuery";
 export * from "./factory";
 export * from "./customGasToken";
-export * from "./svmQuery";

package/src/relayFeeCalculator/relayFeeCalculator.ts

@@ -1,9 +1,5 @@
 import assert from "assert";
-import {
-  DEFAULT_SIMULATED_RELAYER_ADDRESS,
-  DEFAULT_SIMULATED_RELAYER_ADDRESS_SVM,
-  TOKEN_SYMBOLS_MAP,
-} from "../constants";
+import { DEFAULT_SIMULATED_RELAYER_ADDRESS, TOKEN_SYMBOLS_MAP } from "../constants";
 import { Deposit } from "../interfaces";
 import {
   BigNumber,
@@ -22,7 +18,6 @@ import {
   toBNWei,
   isZeroAddress,
   compareAddressesSimple,
-  chainIsSvm,
 } from "../utils";
 import { Transport } from "viem";
 
@@ -41,7 +36,6 @@ export interface QueryInterface {
     }>
   ) => Promise<TransactionCostEstimate>;
   getTokenPrice: (tokenSymbol: string) => Promise<number>;
-  getNativeGasCost: (deposit: Omit<Deposit, "messageHash">, relayer: string) => Promise<BigNumber>;
 }
 
 export const expectedCapitalCostsKeys = ["lowerBound", "upperBound", "cutoff", "decimals"];
@@ -111,12 +105,6 @@ export const DEFAULT_LOGGER: Logger = {
   error: (...args) => console.error(args),
 };
 
-export function getDefaultSimulatedRelayerAddress(chainId?: number) {
-  return isDefined(chainId) && chainIsSvm(chainId)
-    ? DEFAULT_SIMULATED_RELAYER_ADDRESS_SVM
-    : DEFAULT_SIMULATED_RELAYER_ADDRESS;
-}
-
 // Small amount to simulate filling with. Should be low enough to guarantee a successful fill.
 const safeOutputAmount = toBN(100);
 
@@ -253,7 +241,7 @@ export class RelayFeeCalculator {
     deposit: Deposit,
     amountToRelay: BigNumberish,
     simulateZeroFill = false,
-    relayerAddress = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
+    relayerAddress = DEFAULT_SIMULATED_RELAYER_ADDRESS,
     _tokenPrice?: number,
     tokenMapping = TOKEN_SYMBOLS_MAP,
     gasPrice?: BigNumberish,
@@ -314,7 +302,7 @@ export class RelayFeeCalculator {
           throw error;
         }),
     ]);
-    const gasFeesInToken = nativeToToken(tokenGasCost, tokenPrice, inputTokenInfo.decimals, this.nativeTokenDecimals);
+    const gasFeesInToken = nativeToToken(tokenGasCost, tokenPrice, outputTokenInfo.decimals, this.nativeTokenDecimals);
     return percent(gasFeesInToken, amountToRelay.toString());
   }
 
@@ -492,7 +480,7 @@ export class RelayFeeCalculator {
     deposit: Deposit,
     amountToRelay?: BigNumberish,
     simulateZeroFill = false,
-    relayerAddress = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
+    relayerAddress = DEFAULT_SIMULATED_RELAYER_ADDRESS,
     _tokenPrice?: number,
     gasPrice?: BigNumberish,
     gasUnits?: BigNumberish,

package/src/svm/eventsClient.ts

@@ -0,0 +1,199 @@
+import { getDeployedAddress, SvmSpokeIdl } from "@across-protocol/contracts";
+import { getSolanaChainId } from "@across-protocol/contracts/dist/src/svm/web3-v1";
+import web3, {
+  Address,
+  Commitment,
+  GetSignaturesForAddressApi,
+  GetTransactionApi,
+  RpcTransport,
+  Signature,
+} from "@solana/kit";
+import { bs58 } from "../utils";
+import { EventData, EventName, EventWithData } from "./types";
+import { decodeEvent } 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 = 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 });
+        }
+      }
+    }
+
+    return events;
+  }
+}

package/src/svm/index.ts

@@ -0,0 +1,3 @@
+export * from "./eventsClient";
+export * from "./types";
+export * as utils from "./utils";

package/src/{arch/svm → svm}/types.ts

@@ -1,15 +1,5 @@
+import { Signature, Address, UnixTimestamp } from "@solana/kit";
 import { SvmSpokeClient } from "@across-protocol/contracts";
-import {
-  Address,
-  Rpc,
-  RpcSubscriptions,
-  RpcTransport,
-  Signature,
-  SignatureNotificationsApi,
-  SlotNotificationsApi,
-  SolanaRpcApiFromTransport,
-  UnixTimestamp,
-} from "@solana/kit";
 
 export type EventData =
   | SvmSpokeClient.BridgedToHubPool
@@ -46,19 +36,12 @@ export enum SVMEventNames {
 
 export type EventName = keyof typeof SVMEventNames;
 
-export type EventWithData = {
+export type EventWithData<T extends EventData> = {
   confirmationStatus: string | null;
   blockTime: UnixTimestamp | null;
   signature: Signature;
   slot: bigint;
-  name: string;
-  data: unknown;
+  name: EventName;
+  data: T;
   program: Address;
 };
-
-// Typed aggregate of JSON‑RPC and subscription clients.
-export type RpcClient = {
-  rpc: Rpc<SolanaRpcApiFromTransport<RpcTransport>>;
-  rpcSubscriptions: RpcSubscriptions<SignatureNotificationsApi & SlotNotificationsApi>;
-};
-export type SVMProvider = Rpc<SolanaRpcApiFromTransport<RpcTransport>>;

package/src/svm/utils/events.ts

@@ -0,0 +1,58 @@
+import { BN, BorshEventCoder, Idl } from "@coral-xyz/anchor";
+import { address } from "@solana/kit";
+import { EventName, EventData, 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 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;
+}
+
+/**
+ * Decodes a raw event according to a supplied IDL.
+ */
+export function decodeEvent(idl: Idl, rawEvent: string): { data: EventData; name: EventName } {
+  const event = new BorshEventCoder(idl).decode(rawEvent);
+  if (!event) throw new Error(`Malformed rawEvent for IDL ${idl.address}: ${rawEvent}`);
+  return {
+    name: getEventName(event.name),
+    data: parseEventData(event.data),
+  };
+}
+
+/**
+ * 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";
+}

package/src/svm/utils/index.ts

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