@across-protocol/sdk 4.1.63-beta.0 → 4.1.63

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

@@ -4,12 +4,10 @@ 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, chainIsSvm, SvmAddress } from "../../utils";
+import { chainIsOPStack, isDefined } 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
@@ -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 = 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/{arch/svm → svm}/eventsClient.ts

@@ -1,10 +1,17 @@
-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 { EventName, EventWithData, SVMProvider } from "./types";
-import { decodeEvent, isDevnet } from "./utils";
+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'.
@@ -19,39 +26,39 @@ type GetSignaturesForAddressConfig = Parameters<GetSignaturesForAddressApi["getS
 type GetSignaturesForAddressTransaction = ReturnType<GetSignaturesForAddressApi["getSignaturesForAddress"]>[number];
 type GetSignaturesForAddressApiResponse = readonly GetSignaturesForAddressTransaction[];
 
-export class SvmCpiEventsClient {
-  private rpc: SVMProvider;
-  private programAddress: Address;
-  private programEventAuthority: Address;
-  private idl: Idl;
+export class SvmSpokeEventsClient {
+  private rpc: web3.Rpc<web3.SolanaRpcApiFromTransport<RpcTransport>>;
+  private svmSpokeAddress: Address;
+  private svmSpokeEventAuthority: Address;
 
   /**
-   * Protected constructor. Use the async create() method to instantiate.
+   * Private constructor. Use the async create() method to instantiate.
    */
-  protected constructor(rpc: SVMProvider, address: Address, eventAuthority: Address, idl: Idl) {
+  private constructor(
+    rpc: web3.Rpc<web3.SolanaRpcApiFromTransport<RpcTransport>>,
+    svmSpokeAddress: Address,
+    eventAuthority: Address
+  ) {
     this.rpc = rpc;
-    this.programAddress = address;
-    this.programEventAuthority = eventAuthority;
-    this.idl = idl;
+    this.svmSpokeAddress = svmSpokeAddress;
+    this.svmSpokeEventAuthority = eventAuthority;
   }
 
   /**
    * Factory method to asynchronously create an instance of SvmSpokeEventsClient.
    */
-  public static async create(rpc: SVMProvider): Promise<SvmCpiEventsClient> {
+  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");
-    return this.createFor(rpc, programId, SvmSpokeIdl);
-  }
-
-  public static async createFor(rpc: SVMProvider, programId: string, idl: Idl): Promise<SvmCpiEventsClient> {
-    const address = web3.address(programId);
-    const [eventAuthority] = await web3.getProgramDerivedAddress({
-      programAddress: address,
+    const svmSpokeAddress = web3.address(programId);
+    const [svmSpokeEventAuthority] = await web3.getProgramDerivedAddress({
+      programAddress: svmSpokeAddress,
       seeds: ["__event_authority"],
     });
-    return new SvmCpiEventsClient(rpc, address, eventAuthority, idl);
+    return new SvmSpokeEventsClient(rpc, svmSpokeAddress, svmSpokeEventAuthority);
   }
 
   /**
@@ -63,34 +70,14 @@ export class SvmCpiEventsClient {
    * @param options - Options for fetching signatures.
    * @returns A promise that resolves to an array of events matching the eventName.
    */
-  public async queryEvents(
+  public async queryEvents<T extends EventData>(
     eventName: EventName,
     fromSlot?: bigint,
     toSlot?: bigint,
     options: GetSignaturesForAddressConfig = { limit: 1000, commitment: "confirmed" }
-  ): Promise<EventWithData[]> {
+  ): Promise<EventWithData<T>[]> {
     const events = await this.queryAllEvents(fromSlot, toSlot, options);
-    return events.filter((event) => event.name === eventName) as EventWithData[];
-  }
-
-  /**
-   * Queries events for the provided derived address at instantiation 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 queryDerivedAddressEvents(
-    eventName: string,
-    derivedAddress: Address,
-    fromSlot?: bigint,
-    toSlot?: bigint,
-    options: GetSignaturesForAddressConfig = { limit: 1000, commitment: "confirmed" }
-  ): Promise<EventWithData[]> {
-    const events = await this.queryAllEvents(fromSlot, toSlot, options, derivedAddress);
-    return events.filter((event) => event.name === eventName) as EventWithData[];
+    return events.filter((event) => event.name === eventName) as EventWithData<T>[];
   }
 
   /**
@@ -99,23 +86,20 @@ export class SvmCpiEventsClient {
    * @param fromSlot - Optional starting slot.
    * @param toSlot - Optional ending slot.
    * @param options - Options for fetching signatures.
-   * @param forDerivedAddress - Whether to query events for the program or the derived address.
    * @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" },
-    derivedAddress?: Address
-  ): Promise<EventWithData[]> {
-    const addressToQuery = derivedAddress || this.programAddress;
+    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(addressToQuery!, currentOptions)
+        .getSignaturesForAddress(this.svmSpokeAddress, currentOptions)
         .send();
       // Signatures are sorted by slot in descending order.
       allSignatures.push(...signatures);
@@ -178,9 +162,11 @@ export class SvmCpiEventsClient {
    * @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: unknown; name: string }[] {
+  private processEventFromTx(
+    txResult: GetTransactionReturnType
+  ): { program: Address; data: EventData; name: EventName }[] {
     if (!txResult) return [];
-    const events: { program: Address; data: unknown; name: string }[] = [];
+    const events: { program: Address; data: EventData; name: EventName }[] = [];
 
     const accountKeys = txResult.transaction.message.accountKeys;
     const messageAccountKeys = [...accountKeys];
@@ -196,26 +182,18 @@ export class SvmCpiEventsClient {
         if (
           ixProgramId !== undefined &&
           singleIxAccount !== undefined &&
-          this.programAddress === ixProgramId &&
-          this.programEventAuthority === singleIxAccount
+          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(this.idl, eventData);
-          events.push({ program: this.programAddress, name, data });
+          const { name, data } = decodeEvent(SvmSpokeIdl, eventData);
+          events.push({ program: this.svmSpokeAddress, name, data });
         }
       }
     }
 
     return events;
   }
-
-  public getProgramAddress(): Address {
-    return this.programAddress;
-  }
-
-  public getRpc(): SVMProvider {
-    return this.rpc;
-  }
 }

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";

package/src/utils/AddressUtils.ts

@@ -1,6 +1,5 @@
 import { providers, utils } from "ethers";
 import bs58 from "bs58";
-import { Address as V2Address } from "@solana/kit";
 import { BigNumber, chainIsEvm } from "./";
 
 /**
@@ -78,9 +77,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): Address | EvmAddress | SvmAddress {
+export function toAddressType(address: string, chainId: number): Address | EvmAddress | SvmAddress {
   try {
-    if (utils.isHexString(address)) {
+    if (chainIsEvm(chainId)) {
       return EvmAddress.from(address);
     }
     return SvmAddress.from(address);
@@ -147,11 +146,6 @@ 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();
@@ -191,16 +185,6 @@ 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();
@@ -239,20 +223,8 @@ export class EvmAddress extends Address {
   }
 
   // Constructs a new EvmAddress type.
-  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);
+  static from(hexString: string): EvmAddress {
+    return new this(utils.arrayify(hexString));
   }
 }
 
@@ -269,27 +241,12 @@ 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(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);
+  static from(bs58Address: string): SvmAddress {
+    return new this(bs58.decode(bs58Address));
   }
 }

package/src/utils/ArrayUtils.ts

@@ -168,15 +168,3 @@ 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 {
-  from: number;
-  to: number;
-  maxLookBack?: number;
+  fromBlock: number;
+  toBlock: number;
+  maxBlockLookBack?: 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.maxLookBack === 0) {
-    const events = await contract.queryFilter(filter, searchConfig.from, searchConfig.to);
+  if (searchConfig.maxBlockLookBack === 0) {
+    const events = await contract.queryFilter(filter, searchConfig.fromBlock, searchConfig.toBlock);
     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.from && event.blockNumber <= searchConfig.to)
+        .filter((event) => event.blockNumber >= searchConfig.fromBlock && event.blockNumber <= searchConfig.toBlock)
         .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({ from, to, maxLookBack }: EventSearchConfig): [number, number][] {
-  const fromBlock = from;
-  const toBlock = to;
-  const maxBlockLookBack = maxLookBack;
-
+export function getPaginatedBlockRanges({
+  fromBlock,
+  toBlock,
+  maxBlockLookBack,
+}: EventSearchConfig): [number, number][] {
   // 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,8 +33,6 @@ 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

@@ -4,8 +4,6 @@ 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.
@@ -65,9 +63,7 @@ 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]));
 }
 

package/dist/cjs/arch/svm/SpokeUtils.d.ts

@@ -1,20 +0,0 @@
-import { SvmAddress, BigNumber } from "../../utils";
-import { SvmSpokeClient } from "@across-protocol/contracts";
-import { SvmCpiEventsClient } from "./";
-import { Deposit, FillStatus, FillWithBlock, RelayData } from "../../interfaces";
-import { Address, type TransactionSigner } from "@solana/kit";
-import { Logger } from "winston";
-import { SVMProvider } from "./types";
-export declare function populateV3Relay(_spokePool: unknown, _deposit: Omit<Deposit, "messageHash">, _relayer: string, _repaymentChainId?: number): Promise<unknown>;
-export declare function getTimestampForSlot(provider: SVMProvider, slotNumber: number): Promise<number>;
-export declare function getFillDeadline(provider: SVMProvider, statePda: Address): Promise<number>;
-export declare function getDepositIdAtBlock(_contract: unknown, _blockTag: number): Promise<BigNumber>;
-export declare function findDepositBlock(_spokePool: unknown, depositId: BigNumber, _lowBlock: number, _highBlock?: number): Promise<number | undefined>;
-export declare function relayFillStatus(programId: Address, relayData: RelayData, destinationChainId: number, svmEventsClient: SvmCpiEventsClient, atHeight?: number): Promise<FillStatus>;
-export declare function fillStatusArray(programId: Address, relayData: RelayData[], destinationChainId: number, svmEventsClient: SvmCpiEventsClient, atHeight?: number, logger?: Logger): Promise<(FillStatus | undefined)[]>;
-export declare function findFillEvent(relayData: RelayData, destinationChainId: number, svmEventsClient: SvmCpiEventsClient, fromSlot: number, toSlot?: number): Promise<FillWithBlock | undefined>;
-export declare function fillRelayInstruction(spokePool: SvmAddress, deposit: Omit<Deposit, "messageHash">, relayer: TransactionSigner<string>, recipientTokenAccount: Address<string>, repaymentChainId?: number): Promise<SvmSpokeClient.FillRelayInstruction<Address<"JAZWcGrpSWNPTBj8QtJ9UyQqhJCDhG9GJkDeMf5NQBiq">, string, string, string, string, string, string, string, string, string, string, string, string, []>>;
-export declare function createTokenAccountsInstruction(mint: SvmAddress, relayer: TransactionSigner<string>): SvmSpokeClient.CreateTokenAccountsInstruction;
-export declare function createApproveInstruction(mint: SvmAddress, amount: BigNumber, relayer: SvmAddress, spokePool: SvmAddress, mintDecimals?: number): Promise<import("@solana-program/token").ApproveCheckedInstruction<Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">, string, string, string, string, []>>;
-export declare function getAssociatedTokenAddress(owner: SvmAddress, mint: SvmAddress, tokenProgramId?: Address<string>): Promise<Address<string>>;
-export declare function getRelayDataHash(relayData: RelayData, destinationChainId: number): string;