@across-protocol/sdk 4.1.63-alpha.1 → 4.1.63-beta.1

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

@@ -19,10 +19,10 @@ import {
 import assert from "assert";
 import { Logger, QueryInterface } from "../relayFeeCalculator";
 import { Transport } from "viem";
-import { getGasPriceEstimate } from "../../gasPriceOracle/oracle";
+import { getGasPriceEstimate, EvmGasPriceEstimate } from "../../gasPriceOracle";
 type Provider = providers.Provider;
 type OptimismProvider = L2Provider<Provider>;
-type SymbolMappingType = Record<
+export type SymbolMappingType = Record<
   string,
   {
     addresses: Record<number, string>;
@@ -213,7 +213,9 @@ export class QueryBase implements QueryInterface {
         ? Promise.resolve({ maxFeePerGas: _gasPrice })
         : getGasPriceEstimate(provider, { chainId, baseFeeMultiplier, priorityFeeMultiplier, transport, unsignedTx }),
     ] as const;
-    const [nativeGasCost, { maxFeePerGas: gasPrice }] = await Promise.all(queries);
+    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;
     assert(nativeGasCost.gt(bnZero), "Gas cost should not be 0");
     let tokenGasCost: BigNumber;
 

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

@@ -4,10 +4,12 @@ import { getDeployedAddress } from "@across-protocol/contracts";
 import { asL2Provider } from "@eth-optimism/sdk";
 import { providers } from "ethers";
 import { DEFAULT_SIMULATED_RELAYER_ADDRESS, CUSTOM_GAS_TOKENS } from "../../constants";
-import { chainIsOPStack, isDefined } from "../../utils";
+import { chainIsOPStack, isDefined, chainIsSvm, SvmAddress } from "../../utils";
 import { QueryBase } from "./baseQuery";
+import { SVMProvider as svmProvider } from "../../arch/svm";
 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
@@ -20,21 +22,21 @@ const fixedGasPrice = {
 export class QueryBase__factory {
   static create(
     chainId: number,
-    provider: providers.Provider,
+    provider: providers.Provider | svmProvider,
     symbolMapping = TOKEN_SYMBOLS_MAP,
     spokePoolAddress = getDeployedAddress("SpokePool", chainId),
     simulatedRelayerAddress = DEFAULT_SIMULATED_RELAYER_ADDRESS,
     coingeckoProApiKey?: string,
     logger: Logger = DEFAULT_LOGGER,
     coingeckoBaseCurrency = "eth"
-  ): QueryBase {
+  ): QueryBase | SvmQuery {
     assert(isDefined(spokePoolAddress));
 
     const customGasTokenSymbol = CUSTOM_GAS_TOKENS[chainId];
     if (customGasTokenSymbol) {
       return new CustomGasTokenQueries({
         queryBaseArgs: [
-          provider,
+          provider as providers.Provider,
           symbolMapping,
           spokePoolAddress,
           simulatedRelayerAddress,
@@ -46,9 +48,23 @@ 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) : provider;
+    provider = chainIsOPStack(chainId)
+      ? asL2Provider(provider as providers.Provider)
+      : (provider as providers.Provider);
 
     return new QueryBase(
       provider,

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

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

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

@@ -0,0 +1,193 @@
+import { pipe } from "@solana/functional";
+import { Coingecko } from "../../coingecko";
+import { SymbolMappingType } from "./";
+import { CHAIN_IDs, DEFAULT_SIMULATED_RELAYER_ADDRESS } from "../../constants";
+import { Deposit } from "../../interfaces";
+import { getGasPriceEstimate, SvmGasPriceEstimate } from "../../gasPriceOracle";
+import {
+  BigNumberish,
+  TransactionCostEstimate,
+  BigNumber,
+  SvmAddress,
+  toBN,
+  isDefined,
+  toAddressType,
+} from "../../utils";
+import { Logger, QueryInterface } from "../relayFeeCalculator";
+import {
+  fillRelayInstruction,
+  createApproveInstruction,
+  createTokenAccountsInstruction,
+  SVMProvider,
+  SolanaVoidSigner,
+  getAssociatedTokenAddress,
+} from "../../arch/svm";
+import {
+  createTransactionMessage,
+  setTransactionMessageFeePayer,
+  setTransactionMessageLifetimeUsingBlockhash,
+  appendTransactionMessageInstructions,
+  getComputeUnitEstimateForTransactionMessageFactory,
+  fetchEncodedAccount,
+  IInstruction,
+} from "@solana/kit";
+import { TOKEN_PROGRAM_ADDRESS, getMintSize, getInitializeMintInstruction, fetchMint } from "@solana-program/token";
+import { getCreateAccountInstruction } from "@solana-program/system";
+
+/**
+ * A special QueryBase implementation for SVM used for querying gas costs, token prices, and decimals of various tokens
+ * on Solana.
+ */
+export class SvmQuery implements QueryInterface {
+  protected computeUnitEstimator;
+
+  /**
+   * Instantiates a SvmQuery instance
+   * @param provider A valid solana/kit rpc client.
+   * @param symbolMapping A mapping to valid ERC20 tokens and their respective characteristics
+   * @param spokePoolAddress The valid address of the Spoke Pool deployment
+   * @param simulatedRelayerAddress The address that these queries will reference as the sender. Note: This address must be approved for USDC
+   * @param logger A logging utility to report logs
+   * @param coingeckoProApiKey An optional CoinGecko API key that links to a PRO account
+   * @param fixedGasPrice Overrides the gas price with a fixed value. Note: primarily used for the Boba blockchain
+   * @param coingeckoBaseCurrency The basis currency that CoinGecko will use to resolve pricing
+   */
+  constructor(
+    readonly provider: SVMProvider,
+    readonly symbolMapping: SymbolMappingType,
+    readonly spokePoolAddress: SvmAddress,
+    readonly simulatedRelayerAddress: SvmAddress,
+    readonly logger: Logger,
+    readonly coingeckoProApiKey?: string,
+    readonly fixedGasPrice?: BigNumberish,
+    readonly coingeckoBaseCurrency: string = "eth"
+  ) {
+    this.computeUnitEstimator = getComputeUnitEstimateForTransactionMessageFactory({
+      rpc: provider,
+    });
+  }
+
+  /**
+   * Retrieves the current gas costs of performing a fillRelay contract at the referenced SpokePool.
+   * @param deposit V3 deposit instance.
+   * @param relayerAddress Relayer address to simulate with.
+   * @param options
+   * @param options.gasPrice Optional gas price to use for the simulation.
+   * @param options.gasUnits Optional gas units to use for the simulation.
+   * @param options.transport Optional transport object for custom gas price retrieval.
+   * @returns The gas estimate for this function call (multiplied with the optional buffer).
+   */
+  async getGasCosts(
+    deposit: Omit<Deposit, "messageHash">,
+    _relayer = DEFAULT_SIMULATED_RELAYER_ADDRESS,
+    options: Partial<{
+      gasPrice: BigNumberish;
+      gasUnits: BigNumberish;
+      baseFeeMultiplier: BigNumber;
+      priorityFeeMultiplier: BigNumber;
+    }> = {}
+  ): Promise<TransactionCostEstimate> {
+    // If the user did not have a token account created on destination, then we need to include this as a gas cost.
+    const mint = toAddressType(deposit.outputToken).forceSvmAddress();
+    const owner = toAddressType(deposit.recipient).forceSvmAddress();
+    const associatedToken = await getAssociatedTokenAddress(owner, mint);
+    const simulatedSigner = SolanaVoidSigner(this.simulatedRelayerAddress.toBase58());
+
+    // If the recipient has an associated token account on destination, then skip generating the instruction for creating a new token account.
+    let recipientCreateTokenAccountInstructions: IInstruction[] | undefined = undefined;
+    const [associatedTokenAccountExists, mintInfo] = await Promise.all([
+      (await fetchEncodedAccount(this.provider, associatedToken)).exists,
+      fetchMint(this.provider, mint.toV2Address()),
+    ]);
+    if (!associatedTokenAccountExists) {
+      const space = BigInt(getMintSize());
+      const rent = await this.provider.getMinimumBalanceForRentExemption(space).send();
+      const createAccountIx = getCreateAccountInstruction({
+        payer: simulatedSigner,
+        newAccount: SolanaVoidSigner(mint.toBase58()),
+        lamports: rent,
+        space,
+        programAddress: TOKEN_PROGRAM_ADDRESS,
+      });
+
+      const initializeMintIx = getInitializeMintInstruction({
+        mint: mint.toV2Address(),
+        decimals: mintInfo.data.decimals,
+        mintAuthority: owner.toV2Address(),
+      });
+      recipientCreateTokenAccountInstructions = [createAccountIx, initializeMintIx];
+    }
+
+    const [createTokenAccountsIx, approveIx, fillIx] = await Promise.all([
+      createTokenAccountsInstruction(mint, simulatedSigner),
+      createApproveInstruction(
+        mint,
+        deposit.outputAmount,
+        this.simulatedRelayerAddress,
+        this.spokePoolAddress,
+        mintInfo.data.decimals
+      ),
+      fillRelayInstruction(this.spokePoolAddress, deposit, simulatedSigner, associatedToken),
+    ]);
+
+    // Get the most recent confirmed blockhash.
+    const recentBlockhash = await this.provider.getLatestBlockhash().send();
+    const fillRelayTx = pipe(
+      createTransactionMessage({ version: 0 }),
+      (tx) => setTransactionMessageFeePayer(this.simulatedRelayerAddress.toV2Address(), tx),
+      (tx) => setTransactionMessageLifetimeUsingBlockhash(recentBlockhash.value, tx),
+      (tx) =>
+        isDefined(recipientCreateTokenAccountInstructions)
+          ? appendTransactionMessageInstructions(recipientCreateTokenAccountInstructions, tx)
+          : tx,
+      (tx) => appendTransactionMessageInstructions([createTokenAccountsIx, approveIx, fillIx], tx)
+    );
+
+    const [computeUnitsConsumed, _gasPriceEstimate] = await Promise.all([
+      toBN(await this.computeUnitEstimator(fillRelayTx)),
+      getGasPriceEstimate(this.provider, {
+        unsignedTx: fillRelayTx,
+        baseFeeMultiplier: options.baseFeeMultiplier,
+        priorityFeeMultiplier: options.priorityFeeMultiplier,
+      }),
+    ]);
+
+    // We can cast the gas price estimate to an SvmGasPriceEstimate here since the oracle should always
+    // query the Solana adapter.
+    const gasPriceEstimate = _gasPriceEstimate as SvmGasPriceEstimate;
+    const gasPrice = gasPriceEstimate.baseFee.add(
+      gasPriceEstimate.microLamportsPerComputeUnit.mul(computeUnitsConsumed).div(toBN(1_000_000)) // 1_000_000 microLamports/lamport.
+    );
+
+    return {
+      nativeGasCost: computeUnitsConsumed,
+      tokenGasCost: gasPrice,
+      gasPrice,
+    };
+  }
+
+  /**
+   * Retrieves the current price of a token
+   * @param tokenSymbol A valid [CoinGecko-ID](https://api.coingecko.com/api/v3/coins/list)
+   * @returns The resolved token price within the specified coingeckoBaseCurrency
+   */
+  async getTokenPrice(tokenSymbol: string): Promise<number> {
+    if (!this.symbolMapping[tokenSymbol]) throw new Error(`${tokenSymbol} does not exist in mapping`);
+    const coingeckoInstance = Coingecko.get(this.logger, this.coingeckoProApiKey);
+    const [, price] = await coingeckoInstance.getCurrentPriceByContract(
+      this.symbolMapping[tokenSymbol].addresses[CHAIN_IDs.MAINNET],
+      this.coingeckoBaseCurrency
+    );
+    return price;
+  }
+
+  /**
+   * Resolves the number of decimal places a token can have
+   * @param tokenSymbol A valid Across-Enabled Token ID
+   * @returns The number of decimals of precision for the corresponding tokenSymbol
+   */
+  getTokenDecimals(tokenSymbol: string): number {
+    if (!this.symbolMapping[tokenSymbol]) throw new Error(`${tokenSymbol} does not exist in mapping`);
+    return this.symbolMapping[tokenSymbol].decimals;
+  }
+}

package/src/utils/AddressUtils.ts

@@ -1,5 +1,6 @@
 import { providers, utils } from "ethers";
 import bs58 from "bs58";
+import { Address as V2Address } from "@solana/kit";
 import { BigNumber, chainIsEvm } from "./";
 
 /**
@@ -77,9 +78,9 @@ export function isValidEvmAddress(address: string): boolean {
  * @returns a child `Address` type most fitting for the chain ID.
  * @todo: Change this to `toAddress` once we remove the other `toAddress` function.
  */
-export function toAddressType(address: string, chainId: number): Address | EvmAddress | SvmAddress {
+export function toAddressType(address: string): Address | EvmAddress | SvmAddress {
   try {
-    if (chainIsEvm(chainId)) {
+    if (utils.isHexString(address)) {
       return EvmAddress.from(address);
     }
     return SvmAddress.from(address);
@@ -146,6 +147,11 @@ export class Address {
     return this.toBytes32();
   }
 
+  // Converts the address to a Buffer type.
+  toBuffer(): Buffer {
+    return Buffer.from(this.rawAddress);
+  }
+
   // Implements `Hexable` for `Address`. Needed for encoding purposes. This class is treated by default as a bytes32 primitive type, but can change for subclasses.
   toHexString(): string {
     return this.toBytes32();
@@ -185,6 +191,16 @@ export class Address {
     return utils.stripZeros(this.rawAddress).length === 0;
   }
 
+  // Forces `rawAddress` to become an SvmAddress type. This will only throw if `rawAddress.length > 32`.
+  forceSvmAddress(): SvmAddress {
+    return SvmAddress.from(this.toBase58());
+  }
+
+  // Forces `rawAddress` to become an EvmAddress type. This will throw if `rawAddress.length > 20`.
+  forceEvmAddress(): EvmAddress {
+    return EvmAddress.from(this.toEvmAddress());
+  }
+
   // Checks if the other address is equivalent to this address.
   eq(other: Address): boolean {
     return this.toString() === other.toString();
@@ -223,8 +239,20 @@ export class EvmAddress extends Address {
   }
 
   // Constructs a new EvmAddress type.
-  static from(hexString: string): EvmAddress {
-    return new this(utils.arrayify(hexString));
+  static from(address: string, encoding: "base16" | "base58" = "base16"): EvmAddress {
+    if (encoding === "base16") {
+      return new this(utils.arrayify(address));
+    }
+
+    const decodedAddress = bs58.decode(address);
+    const padding = decodedAddress.subarray(0, 12);
+    const evmAddress = decodedAddress.subarray(12);
+
+    if (padding.length !== 12 || utils.stripZeros(padding).length !== 0 || evmAddress.length !== 20) {
+      throw new Error(`Not a valid base58-encoded EVM address: ${address}`);
+    }
+
+    return new this(evmAddress);
   }
 }
 
@@ -241,12 +269,27 @@ export class SvmAddress extends Address {
     return this.toBase58();
   }
 
+  // Small utility to convert an SvmAddress to a Solana Kit branded type.
+  toV2Address(): V2Address<string> {
+    return this.toBase58() as V2Address<string>;
+  }
+
+  // Forces an SvmAddress to an EVM address string by truncating the leading 12 bytes.
   override toEvmAddress(): string {
     return toAddress(`0x${this.toBytes32().slice(-40)}`);
   }
 
   // Constructs a new SvmAddress type.
-  static from(bs58Address: string): SvmAddress {
-    return new this(bs58.decode(bs58Address));
+  static from(address: string, encoding: "base58" | "base16" = "base58"): SvmAddress {
+    if (encoding === "base58") {
+      return new this(bs58.decode(address));
+    }
+
+    const decodedAddress = utils.arrayify(address);
+    if (decodedAddress.length !== 32) {
+      throw new Error(`Not a valid base16-encoded SVM address: ${address}`);
+    }
+
+    return new this(decodedAddress);
   }
 }

package/src/utils/ArrayUtils.ts

@@ -168,3 +168,15 @@ export function includesAsync<T>(
 export function isArrayOf<T>(array: unknown, predicate: (value: unknown) => value is T): array is T[] {
   return Array.isArray(array) && array.every(predicate);
 }
+
+/**
+ * Checks if a value is a Uint8Array.
+ * @param value The value to check.
+ * @returns True if the value is a Uint8Array, false otherwise.
+ */
+export function isUint8Array(value: unknown): value is Uint8Array {
+  return (
+    Array.isArray(value) &&
+    value.every((item) => typeof item === "number" && Number.isInteger(item) && item >= 0 && item < 256)
+  );
+}

package/src/utils/EventUtils.ts

@@ -99,9 +99,9 @@ export function spreadEvent(args: Result | Record<string, unknown>): { [key: str
 }
 
 export interface EventSearchConfig {
-  fromBlock: number;
-  toBlock: number;
-  maxBlockLookBack?: number;
+  from: number;
+  to: number;
+  maxLookBack?: number;
 }
 
 export const eventToLog = (event: Event): Log => ({ ...event, event: event.event!, args: spreadEvent(event.args!) });
@@ -113,8 +113,8 @@ export async function paginatedEventQuery(
   retryCount = 0
 ): Promise<Log[]> {
   // If the max block look back is set to 0 then we dont need to do any pagination and can query over the whole range.
-  if (searchConfig.maxBlockLookBack === 0) {
-    const events = await contract.queryFilter(filter, searchConfig.fromBlock, searchConfig.toBlock);
+  if (searchConfig.maxLookBack === 0) {
+    const events = await contract.queryFilter(filter, searchConfig.from, searchConfig.to);
     return events.map(eventToLog);
   }
 
@@ -132,7 +132,7 @@ export async function paginatedEventQuery(
       )
         .flat()
         // Filter events by block number because ranges can include blocks that are outside the range specified for caching reasons.
-        .filter((event) => event.blockNumber >= searchConfig.fromBlock && event.blockNumber <= searchConfig.toBlock)
+        .filter((event) => event.blockNumber >= searchConfig.from && event.blockNumber <= searchConfig.to)
         .map(eventToLog)
     );
   } catch (error) {
@@ -159,11 +159,11 @@ export async function paginatedEventQuery(
  * input range, but can include blocks outside of the desired range, so results should be filtered. Results
  * are ordered from smallest to largest.
  */
-export function getPaginatedBlockRanges({
-  fromBlock,
-  toBlock,
-  maxBlockLookBack,
-}: EventSearchConfig): [number, number][] {
+export function getPaginatedBlockRanges({ from, to, maxLookBack }: EventSearchConfig): [number, number][] {
+  const fromBlock = from;
+  const toBlock = to;
+  const maxBlockLookBack = maxLookBack;
+
   // If the maxBlockLookBack is undefined, we can look back as far as we like. Just return the entire range.
   if (maxBlockLookBack === undefined) {
     return [[fromBlock, toBlock]];

package/src/utils/JSONUtils.ts

@@ -33,6 +33,8 @@ export function stringifyJSONWithNumericString(obj: unknown): string {
   return JSON.stringify(obj, (_key, value) => {
     if (typeof value === "object" && value !== null && value.type === "BigNumber") {
       return BigNumber.from(value).toString();
+    } else if (typeof value === "bigint" && value !== null) {
+      return value.toString();
     }
     return value;
   });

package/src/utils/SpokeUtils.ts

@@ -1,9 +1,11 @@
-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";
 import { BigNumber } from "./BigNumberUtils";
 import { isMessageEmpty } from "./DepositUtils";
+import { chainIsSvm } from "./NetworkUtils";
+import { svm } from "../arch";
 
 /**
  * Produce the RelayData for a Deposit.
@@ -63,7 +65,9 @@ export function getRelayDataHash(relayData: RelayData, destinationChainId: numbe
     outputToken: toBytes32(relayData.outputToken),
     exclusiveRelayer: toBytes32(relayData.exclusiveRelayer),
   };
-
+  if (chainIsSvm(destinationChainId)) {
+    return svm.getRelayDataHash(_relayData, destinationChainId);
+  }
   return keccak256(encodeAbiParameters(abi, [_relayData, destinationChainId]));
 }
 
@@ -87,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);
 }

package/dist/cjs/svm/eventsClient.d.ts

@@ -1,15 +0,0 @@
-import web3, { GetSignaturesForAddressApi, RpcTransport } from "@solana/kit";
-import { EventData, EventName, EventWithData } from "./types";
-type GetSignaturesForAddressConfig = Parameters<GetSignaturesForAddressApi["getSignaturesForAddress"]>[1];
-export declare class SvmSpokeEventsClient {
-    private rpc;
-    private svmSpokeAddress;
-    private svmSpokeEventAuthority;
-    private constructor();
-    static create(rpc: web3.Rpc<web3.SolanaRpcApiFromTransport<RpcTransport>>): Promise<SvmSpokeEventsClient>;
-    queryEvents<T extends EventData>(eventName: EventName, fromSlot?: bigint, toSlot?: bigint, options?: GetSignaturesForAddressConfig): Promise<EventWithData<T>[]>;
-    private queryAllEvents;
-    private readEventsFromSignature;
-    private processEventFromTx;
-}
-export {};

package/dist/cjs/svm/eventsClient.js

@@ -1,157 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SvmSpokeEventsClient = void 0;
-var tslib_1 = require("tslib");
-var contracts_1 = require("@across-protocol/contracts");
-var web3_v1_1 = require("@across-protocol/contracts/dist/src/svm/web3-v1");
-var kit_1 = tslib_1.__importDefault(require("@solana/kit"));
-var utils_1 = require("../utils");
-var events_1 = require("./utils/events");
-var helpers_1 = require("./utils/helpers");
-var SvmSpokeEventsClient = (function () {
-    function SvmSpokeEventsClient(rpc, svmSpokeAddress, eventAuthority) {
-        this.rpc = rpc;
-        this.svmSpokeAddress = svmSpokeAddress;
-        this.svmSpokeEventAuthority = eventAuthority;
-    }
-    SvmSpokeEventsClient.create = function (rpc) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var isTestnet, programId, svmSpokeAddress, svmSpokeEventAuthority;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4, (0, helpers_1.isDevnet)(rpc)];
-                    case 1:
-                        isTestnet = _a.sent();
-                        programId = (0, contracts_1.getDeployedAddress)("SvmSpoke", (0, web3_v1_1.getSolanaChainId)(isTestnet ? "devnet" : "mainnet").toString());
-                        if (!programId)
-                            throw new Error("Program not found");
-                        svmSpokeAddress = kit_1.default.address(programId);
-                        return [4, kit_1.default.getProgramDerivedAddress({
-                                programAddress: svmSpokeAddress,
-                                seeds: ["__event_authority"],
-                            })];
-                    case 2:
-                        svmSpokeEventAuthority = (_a.sent())[0];
-                        return [2, new SvmSpokeEventsClient(rpc, svmSpokeAddress, svmSpokeEventAuthority)];
-                }
-            });
-        });
-    };
-    SvmSpokeEventsClient.prototype.queryEvents = function (eventName, fromSlot, toSlot, options) {
-        if (options === void 0) { options = { limit: 1000, commitment: "confirmed" }; }
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var events;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4, this.queryAllEvents(fromSlot, toSlot, options)];
-                    case 1:
-                        events = _a.sent();
-                        return [2, events.filter(function (event) { return event.name === eventName; })];
-                }
-            });
-        });
-    };
-    SvmSpokeEventsClient.prototype.queryAllEvents = function (fromSlot, toSlot, options) {
-        if (options === void 0) { options = { limit: 1000, commitment: "confirmed" }; }
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var allSignatures, hasMoreSignatures, currentOptions, signatures, filteredSignatures, eventsWithSlots;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        allSignatures = [];
-                        hasMoreSignatures = true;
-                        currentOptions = options;
-                        _a.label = 1;
-                    case 1:
-                        if (!hasMoreSignatures) return [3, 3];
-                        return [4, this.rpc
-                                .getSignaturesForAddress(this.svmSpokeAddress, currentOptions)
-                                .send()];
-                    case 2:
-                        signatures = _a.sent();
-                        allSignatures.push.apply(allSignatures, signatures);
-                        if (signatures.length > 0) {
-                            currentOptions = tslib_1.__assign(tslib_1.__assign({}, 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);
-                        return [3, 1];
-                    case 3:
-                        filteredSignatures = allSignatures.filter(function (signatureTransaction) {
-                            if (fromSlot && signatureTransaction.slot < fromSlot)
-                                return false;
-                            if (toSlot && signatureTransaction.slot > toSlot)
-                                return false;
-                            return true;
-                        });
-                        return [4, Promise.all(filteredSignatures.map(function (signatureTransaction) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                var events;
-                                return tslib_1.__generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0: return [4, this.readEventsFromSignature(signatureTransaction.signature, options.commitment)];
-                                        case 1:
-                                            events = _a.sent();
-                                            return [2, events.map(function (event) { return (tslib_1.__assign(tslib_1.__assign({}, event), { confirmationStatus: signatureTransaction.confirmationStatus, blockTime: signatureTransaction.blockTime, signature: signatureTransaction.signature, slot: signatureTransaction.slot })); })];
-                                    }
-                                });
-                            }); }))];
-                    case 4:
-                        eventsWithSlots = _a.sent();
-                        return [2, eventsWithSlots.flat()];
-                }
-            });
-        });
-    };
-    SvmSpokeEventsClient.prototype.readEventsFromSignature = function (txSignature, commitment) {
-        if (commitment === void 0) { commitment = "confirmed"; }
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var txResult;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4, this.rpc
-                            .getTransaction(txSignature, { commitment: commitment, maxSupportedTransactionVersion: 0 })
-                            .send()];
-                    case 1:
-                        txResult = _a.sent();
-                        if (txResult === null)
-                            return [2, []];
-                        return [2, this.processEventFromTx(txResult)];
-                }
-            });
-        });
-    };
-    SvmSpokeEventsClient.prototype.processEventFromTx = function (txResult) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
-        if (!txResult)
-            return [];
-        var events = [];
-        var accountKeys = txResult.transaction.message.accountKeys;
-        var messageAccountKeys = tslib_1.__spreadArray([], accountKeys, true);
-        messageAccountKeys.push.apply(messageAccountKeys, ((_c = (_b = (_a = txResult === null || txResult === void 0 ? void 0 : txResult.meta) === null || _a === void 0 ? void 0 : _a.loadedAddresses) === null || _b === void 0 ? void 0 : _b.writable) !== null && _c !== void 0 ? _c : []));
-        messageAccountKeys.push.apply(messageAccountKeys, ((_f = (_e = (_d = txResult === null || txResult === void 0 ? void 0 : txResult.meta) === null || _d === void 0 ? void 0 : _d.loadedAddresses) === null || _e === void 0 ? void 0 : _e.readonly) !== null && _f !== void 0 ? _f : []));
-        for (var _i = 0, _j = (_h = (_g = txResult.meta) === null || _g === void 0 ? void 0 : _g.innerInstructions) !== null && _h !== void 0 ? _h : []; _i < _j.length; _i++) {
-            var ixBlock = _j[_i];
-            for (var _k = 0, _l = ixBlock.instructions; _k < _l.length; _k++) {
-                var ix = _l[_k];
-                var ixProgramId = messageAccountKeys[ix.programIdIndex];
-                var singleIxAccount = ix.accounts.length === 1 ? messageAccountKeys[ix.accounts[0]] : undefined;
-                if (ixProgramId !== undefined &&
-                    singleIxAccount !== undefined &&
-                    this.svmSpokeAddress === ixProgramId &&
-                    this.svmSpokeEventAuthority === singleIxAccount) {
-                    var ixData = utils_1.bs58.decode(ix.data);
-                    var eventData = Buffer.from(ixData.slice(8)).toString("base64");
-                    var _m = (0, events_1.decodeEvent)(contracts_1.SvmSpokeIdl, eventData), name_1 = _m.name, data = _m.data;
-                    events.push({ program: this.svmSpokeAddress, name: name_1, data: data });
-                }
-            }
-        }
-        return events;
-    };
-    return SvmSpokeEventsClient;
-}());
-exports.SvmSpokeEventsClient = SvmSpokeEventsClient;
-//# sourceMappingURL=eventsClient.js.map