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

package/src/clients/SpokePoolClient/SVMSpokePoolClient.ts

@@ -1,268 +0,0 @@
-import { Address, Rpc, RpcTransport, SolanaRpcApiFromTransport } from "@solana/kit";
-import winston from "winston";
-import {
-  SVMEventNames,
-  unwrapEventData,
-  getFillDeadline,
-  getTimestampForSlot,
-  getStatePda,
-  SvmCpiEventsClient,
-  findDeposit,
-  relayFillStatus,
-  fillStatusArray,
-} from "../../arch/svm";
-import { FillStatus, RelayData, SortableEvent } from "../../interfaces";
-import {
-  BigNumber,
-  DepositSearchResult,
-  EventSearchConfig,
-  InvalidFill,
-  isZeroAddress,
-  MakeOptional,
-  sortEventsAscendingInPlace,
-} from "../../utils";
-import { isUpdateFailureReason } from "../BaseAbstractClient";
-import { HubPoolClient } from "../HubPoolClient";
-import { knownEventNames, SpokePoolClient, SpokePoolUpdate } from "./SpokePoolClient";
-
-/**
- * SvmSpokePoolClient is a client for the SVM SpokePool program. It extends the base SpokePoolClient
- * and implements the abstract methods required for interacting with an SVM Spoke Pool.
- */
-export class SvmSpokePoolClient extends SpokePoolClient {
-  /**
-   * Protected constructor. Use the async create() method to instantiate.
-   */
-  protected constructor(
-    logger: winston.Logger,
-    hubPoolClient: HubPoolClient | null,
-    chainId: number,
-    deploymentSlot: bigint, // Using slot instead of block number for SVM
-    eventSearchConfig: MakeOptional<EventSearchConfig, "to">,
-    public svmEventsClient: SvmCpiEventsClient,
-    protected programId: Address,
-    protected statePda: Address
-  ) {
-    // Convert deploymentSlot to number for base class, might need refinement
-    super(logger, hubPoolClient, chainId, Number(deploymentSlot), eventSearchConfig);
-  }
-
-  /**
-   * Factory method to asynchronously create an instance of SvmSpokePoolClient.
-   */
-  public static async create(
-    logger: winston.Logger,
-    hubPoolClient: HubPoolClient | null,
-    chainId: number,
-    deploymentSlot: bigint,
-    eventSearchConfig: MakeOptional<EventSearchConfig, "to"> = { from: 0, maxLookBack: 0 }, // Provide default
-    rpc: Rpc<SolanaRpcApiFromTransport<RpcTransport>>
-  ): Promise<SvmSpokePoolClient> {
-    const svmEventsClient = await SvmCpiEventsClient.create(rpc);
-    const programId = svmEventsClient.getProgramAddress();
-    const statePda = await getStatePda(programId);
-    return new SvmSpokePoolClient(
-      logger,
-      hubPoolClient,
-      chainId,
-      deploymentSlot,
-      eventSearchConfig,
-      svmEventsClient,
-      programId,
-      statePda
-    );
-  }
-
-  /**
-   * Factory method to asynchronously create an instance of SvmSpokePoolClient with an existing event client.
-   */
-  public static async createWithExistingEventClient(
-    logger: winston.Logger,
-    hubPoolClient: HubPoolClient | null,
-    chainId: number,
-    deploymentSlot: bigint,
-    eventSearchConfig: MakeOptional<EventSearchConfig, "to"> = { from: 0, maxLookBack: 0 }, // Provide default
-    eventClient: SvmCpiEventsClient
-  ) {
-    const programId = eventClient.getProgramAddress();
-    const statePda = await getStatePda(programId);
-    return new SvmSpokePoolClient(
-      logger,
-      hubPoolClient,
-      chainId,
-      deploymentSlot,
-      eventSearchConfig,
-      eventClient,
-      programId,
-      statePda
-    );
-  }
-
-  public _queryableEventNames(): string[] {
-    // We want to take the internal event names relevant to
-    // the SVM SpokePoolClient and filter them against the
-    // knownEventNames list that we reference in practice
-    const internalEventNames = Object.values(SVMEventNames);
-    return internalEventNames.filter((e) => knownEventNames.includes(e));
-  }
-
-  /**
-   * Performs an update to refresh the state of this client by querying SVM events.
-   */
-  protected async _update(eventsToQuery: string[]): Promise<SpokePoolUpdate> {
-    const searchConfig = await this.updateSearchConfig(this.svmEventsClient.getRpc());
-    if (isUpdateFailureReason(searchConfig)) {
-      const reason = searchConfig;
-      return { success: false, reason };
-    }
-
-    const deploymentSlot = BigInt(this.deploymentBlock);
-
-    const eventSearchConfigs = eventsToQuery.map((eventName) => {
-      if (!this._queryableEventNames().includes(eventName)) {
-        throw new Error(`SpokePoolClient: Cannot query unrecognised SpokePool event name: ${eventName}`);
-      }
-
-      const _searchConfig = { ...searchConfig }; // shallow copy
-
-      // By default, an event's query range is controlled by the `eventSearchConfig` passed in during instantiation.
-      // However, certain events have special overriding requirements to their search ranges:
-      // - EnabledDepositRoute: The full history is always required, so override the requested fromBlock.
-      if (eventName === "EnabledDepositRoute" && !this.isUpdated) {
-        _searchConfig.from = Number(deploymentSlot);
-      }
-
-      return _searchConfig as EventSearchConfig;
-    });
-
-    const spokePoolAddress = this.svmEventsClient.getProgramAddress();
-
-    this.log("debug", `Updating SpokePool client for chain ${this.chainId}`, {
-      eventsToQuery,
-      searchConfig,
-      spokePool: spokePoolAddress,
-    });
-
-    const timerStart = Date.now();
-
-    const [currentTime, ...eventsQueried] = await Promise.all([
-      this.svmEventsClient.getRpc().getBlockTime(BigInt(searchConfig.to)).send(),
-      ...eventsToQuery.map(async (eventName, idx) => {
-        const config = eventSearchConfigs[idx];
-        const events = await this.svmEventsClient.queryEvents(
-          eventName as SVMEventNames,
-          BigInt(config.from),
-          BigInt(config.to),
-          {
-            limit: config.maxLookBack,
-          }
-        );
-        return events.map(
-          (event): SortableEvent => ({
-            txnRef: event.signature,
-            blockNumber: Number(event.slot),
-            txnIndex: 0,
-            logIndex: 0,
-            ...(unwrapEventData(event.data) as Record<string, unknown>),
-          })
-        );
-      }),
-    ]);
-    this.log("debug", `Time to query new events from RPC for ${this.chainId}: ${Date.now() - timerStart} ms`);
-    if (currentTime < this.currentTime) {
-      const errMsg = `currentTime: ${currentTime} < ${this.currentTime}`;
-      throw new Error(`SvmSpokePoolClient::update: ${errMsg}`);
-    }
-
-    // Sort all events to ensure they are stored in a consistent order.
-    eventsQueried.forEach((events) => sortEventsAscendingInPlace(events));
-
-    return {
-      success: true,
-      currentTime: Number(currentTime), // uint32
-      searchEndBlock: searchConfig.to,
-      events: eventsQueried,
-    };
-  }
-
-  /**
-   * Retrieves the fill deadline buffer fetched from the State PDA.
-   * @note This function assumes that fill deadline buffer is a constant value in svm environments.
-   */
-  public override getMaxFillDeadlineInRange(_startSlot: number, _endSlot: number): Promise<number> {
-    return getFillDeadline(this.svmEventsClient.getRpc(), this.statePda);
-  }
-
-  /**
-   * Retrieves the timestamp for a given SVM slot number.
-   */
-  public override getTimestampForBlock(slot: number): Promise<number> {
-    return getTimestampForSlot(this.svmEventsClient.getRpc(), slot);
-  }
-
-  /**
-   * Retrieves the timestamp for a given SVM slot number.
-   * @note This function uses the same underlying function as getTimestampForBlock.
-   *       It is kept for consistency with the EVM SpokePoolClient.
-   */
-  public getTimeAt(slot: number): Promise<number> {
-    return getTimestampForSlot(this.svmEventsClient.getRpc(), slot);
-  }
-
-  /**
-   * Finds a deposit based on its deposit ID on the SVM chain.
-   */
-  public async findDeposit(depositId: BigNumber): Promise<DepositSearchResult> {
-    const deposit = await findDeposit(this.svmEventsClient, depositId);
-    if (!deposit) {
-      return {
-        found: false,
-        code: InvalidFill.DepositIdNotFound,
-        reason: `Deposit with ID ${depositId} not found`,
-      };
-    }
-    // Because we have additional context about this deposit, we can enrich it
-    // with additional information.
-    return {
-      found: true,
-      deposit: {
-        ...deposit,
-        quoteBlockNumber: await this.getBlockNumber(Number(deposit.quoteTimestamp)),
-        originChainId: this.chainId,
-        fromLiteChain: this.isOriginLiteChain(deposit),
-        toLiteChain: this.isDestinationLiteChain(deposit),
-        outputToken: isZeroAddress(deposit.outputToken)
-          ? this.getDestinationTokenForDeposit(deposit)
-          : deposit.outputToken,
-      },
-    };
-  }
-
-  /**
-   * Retrieves the fill status for a given relay data from the SVM chain.
-   */
-  public override relayFillStatus(
-    relayData: RelayData,
-    atHeight?: number,
-    destinationChainId?: number
-  ): Promise<FillStatus> {
-    destinationChainId ??= this.chainId;
-    return relayFillStatus(this.programId, relayData, destinationChainId, this.svmEventsClient, atHeight);
-  }
-
-  /**
-   * Retrieves the fill status for an array of given relay data.
-   * @param relayData The array relay data to retrieve the fill status for.
-   * @param atHeight The slot at which to query the fill status.
-   * @returns The fill status for each of the given relay data.
-   */
-  public fillStatusArray(
-    relayData: RelayData[],
-    atHeight?: number,
-    destinationChainId?: number
-  ): Promise<(FillStatus | undefined)[]> {
-    // @note: deploymentBlock actually refers to the deployment slot. Also, blockTag should be a slot number.
-    destinationChainId ??= this.chainId;
-    return fillStatusArray(this.programId, relayData, destinationChainId, this.svmEventsClient, atHeight, this.logger);
-  }
-}

package/src/clients/mocks/MockSvmCpiEventsClient.ts

@@ -1,226 +0,0 @@
-import assert from "assert";
-import { createHash } from "crypto";
-import { hexlify, arrayify, hexZeroPad } from "ethers/lib/utils";
-import { random } from "lodash";
-import { Address, UnixTimestamp, signature } from "@solana/kit";
-import { Idl } from "@coral-xyz/anchor";
-import { SvmSpokeClient } from "@across-protocol/contracts";
-import { CHAIN_IDs } from "@across-protocol/constants";
-
-import { MockSolanaRpcFactory } from "../../providers/mocks";
-import {
-  SVM_DEFAULT_ADDRESS,
-  EventName,
-  EventWithData,
-  SvmCpiEventsClient,
-  SVMEventNames,
-  SVMProvider,
-  getRandomSvmAddress,
-} from "../../arch/svm";
-import { bnZero, bnOne, bs58, getCurrentTime, randomAddress, EvmAddress } from "../../utils";
-import { FillType } from "../../interfaces";
-
-export class MockSvmCpiEventsClient extends SvmCpiEventsClient {
-  private events: Record<EventName, EventWithData[]> = {} as Record<EventName, EventWithData[]>;
-  private slotHeight: bigint = BigInt(0);
-  public chainId: number;
-  public minBlockRange = 10;
-  public numberOfDeposits = bnZero;
-
-  constructor(programId = SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS, chainId = CHAIN_IDs.SOLANA) {
-    super(null as unknown as SVMProvider, programId as Address, null as unknown as Address, null as unknown as Idl);
-    this.chainId = chainId;
-  }
-
-  public setSlotHeight(slotHeight: bigint) {
-    this.slotHeight = slotHeight;
-  }
-
-  public setEvents(events: EventWithData[]) {
-    for (const event of events) {
-      this.events[event.name as EventName] ??= [];
-      this.events[event.name as EventName].push(event);
-    }
-    const maxSlot = Math.max(...events.map((event) => Number(event.slot)));
-    this.setSlotHeight(BigInt(maxSlot) + BigInt(1));
-  }
-
-  public clearEvents(name?: EventName) {
-    if (name) {
-      this.events[name] = [];
-    } else {
-      this.events = {} as Record<EventName, EventWithData[]>;
-    }
-  }
-
-  public override queryEvents(eventName: EventName, fromSlot?: bigint, toSlot?: bigint): Promise<EventWithData[]> {
-    return Promise.resolve(
-      this.events[eventName]?.filter(
-        (event) => (!fromSlot || event.slot >= fromSlot) && (!toSlot || event.slot <= toSlot)
-      ) ?? []
-    );
-  }
-
-  public override getRpc(): SVMProvider {
-    const client = new MockSolanaRpcFactory("https://test.com", 1234567890);
-    client.setResult("getSlot", [], this.slotHeight);
-    return client.createRpcClient();
-  }
-
-  public deposit(deposit: SvmSpokeClient.FundsDeposited & Partial<EventWithData>): EventWithData {
-    const { slot } = deposit;
-    let { depositId, destinationChainId, inputAmount, outputAmount } = deposit;
-    depositId ??= arrayify(hexZeroPad(hexlify(random(1, 100_000, false)), 32));
-    this.numberOfDeposits = this.numberOfDeposits.add(bnOne);
-
-    destinationChainId ??= BigInt(random(1, 42161, false));
-    const depositor = deposit.depositor ?? getRandomSvmAddress();
-    const recipient = deposit.recipient ?? EvmAddress.from(randomAddress()).toBase58();
-    const inputToken = deposit.inputToken ?? getRandomSvmAddress();
-    const outputToken = deposit.outputToken ?? EvmAddress.from(randomAddress()).toBase58();
-    inputAmount ??= BigInt(random(1, 1000, false));
-    outputAmount ??= (inputAmount * BigInt(95)) / BigInt(100);
-    const message = deposit.message ?? new Uint8Array(32);
-    const quoteTimestamp = deposit.quoteTimestamp ?? getCurrentTime();
-
-    const args = {
-      depositId,
-      destinationChainId,
-      depositor,
-      recipient,
-      inputToken,
-      inputAmount,
-      outputToken,
-      outputAmount,
-      quoteTimestamp,
-      fillDeadline: deposit.fillDeadline ?? quoteTimestamp + 3600,
-      exclusiveRelayer: deposit.exclusiveRelayer ?? SVM_DEFAULT_ADDRESS,
-      exclusivityDeadline: deposit.exclusivityDeadline ?? quoteTimestamp + 600,
-      message,
-    };
-
-    return this.generateEvent({
-      event: SVMEventNames.FundsDeposited,
-      address: this.getProgramAddress(),
-      args,
-      slot,
-    });
-  }
-
-  public fillRelay(fill: SvmSpokeClient.FilledRelay & Partial<EventWithData>): EventWithData {
-    const { slot } = fill;
-    let { depositId, inputAmount, outputAmount, fillDeadline } = fill;
-    depositId ??= arrayify(hexZeroPad(hexlify(random(1, 100_000, false)), 32));
-    inputAmount ??= BigInt(random(1, 1000, false));
-    outputAmount ??= (inputAmount * BigInt(95)) / BigInt(100);
-    fillDeadline ??= getCurrentTime() + 60;
-
-    const depositor = fill.depositor ?? EvmAddress.from(randomAddress()).toBase58();
-    const recipient = fill.recipient ?? getRandomSvmAddress();
-    const inputToken = fill.inputToken ?? EvmAddress.from(randomAddress()).toBase58();
-    const outputToken = fill.outputToken ?? getRandomSvmAddress();
-    const messageHash = fill.messageHash ?? new Uint8Array(32);
-
-    const relayExecutionInfo = {
-      updatedRecipient: fill.relayExecutionInfo?.updatedRecipient ?? recipient,
-      updatedOutputAmount: fill.relayExecutionInfo?.updatedOutputAmount ?? outputAmount,
-      fillType: fill.relayExecutionInfo?.fillType ?? FillType.FastFill,
-      updatedMessageHash: fill.relayExecutionInfo?.updatedMessageHash ?? messageHash,
-    };
-
-    const args = {
-      depositId,
-      originChainId: fill.originChainId ?? BigInt(random(1, 42161, false)),
-      depositor,
-      recipient,
-      inputToken,
-      inputAmount,
-      outputToken,
-      outputAmount,
-      fillDeadline,
-      exclusiveRelayer: fill.exclusiveRelayer ?? SVM_DEFAULT_ADDRESS,
-      exclusivityDeadline: fill.exclusivityDeadline ?? fillDeadline,
-      relayer: fill.relayer ?? getRandomSvmAddress(),
-      messageHash,
-      relayExecutionInfo,
-    };
-
-    return this.generateEvent({
-      event: SVMEventNames.FilledRelay,
-      address: this.getProgramAddress(),
-      args,
-      slot,
-    });
-  }
-
-  public requestSlowFill(slowFillRequest: SvmSpokeClient.RequestedSlowFill & Partial<EventWithData>): EventWithData {
-    const { slot } = slowFillRequest;
-    let { depositId, originChainId } = slowFillRequest;
-    depositId ??= Uint8Array.from([random(1, 100_000, false)]);
-    originChainId ??= BigInt(random(1, 42161, false));
-    const depositor = slowFillRequest.depositor ?? EvmAddress.from(randomAddress()).toBase58();
-    const recipient = slowFillRequest.recipient ?? getRandomSvmAddress();
-    const inputToken = slowFillRequest.inputToken ?? EvmAddress.from(randomAddress()).toBase58();
-    const outputToken = slowFillRequest.outputToken ?? getRandomSvmAddress();
-
-    const args = {
-      ...slowFillRequest,
-      depositId,
-      originChainId,
-      depositor,
-      recipient,
-      inputToken,
-      outputToken,
-      inputAmount: slowFillRequest.inputAmount ?? BigInt(random(1, 1000, false)),
-      outputAmount: slowFillRequest.outputAmount ?? slowFillRequest.inputAmount ?? BigInt(random(1, 1000, false)),
-      exclusiveRelayer: slowFillRequest.exclusiveRelayer ?? SVM_DEFAULT_ADDRESS,
-    };
-
-    return this.generateEvent({
-      event: SVMEventNames.RequestedSlowFill,
-      address: this.getProgramAddress(),
-      args,
-      slot,
-    });
-  }
-
-  protected generateEvent(inputs: {
-    address: Address;
-    event: EventName;
-    args: Record<string, unknown>;
-    slot?: bigint;
-  }) {
-    const { address, event, args } = inputs;
-    let { slot } = inputs;
-
-    const randomSlotWithinRange = () =>
-      random(Number(this.slotHeight) + 1, Number(this.slotHeight) + this.minBlockRange, false);
-
-    // Increment the slot number by at least 1, by default. The caller may override
-    // to force the same slot number to be used, but never a previous slot number.
-    slot ??= BigInt(randomSlotWithinRange());
-    assert(slot >= this.slotHeight, `${slot} < ${this.slotHeight}`);
-    this.slotHeight = slot;
-
-    const generatedEvent = {
-      name: event,
-      slot,
-      signature: signature(
-        bs58.encode(
-          Uint8Array.from(
-            createHash("sha512")
-              .update(`Across-${event}-${slot}-${random(1, 100_000)}`)
-              .digest()
-          )
-        )
-      ),
-      program: address,
-      data: args,
-      confirmationStatus: "finalized",
-      blockTime: BigInt(new Date().getTime()) as UnixTimestamp,
-    };
-
-    this.setEvents([generatedEvent]);
-    return generatedEvent;
-  }
-}

package/src/clients/mocks/MockSvmSpokePoolClient.ts

@@ -1,119 +0,0 @@
-import winston from "winston";
-import { SvmSpokeClient } from "@across-protocol/contracts";
-import { Address } from "@solana/kit";
-import { DepositWithBlock, RelayerRefundExecution, SortableEvent, SlowFillLeaf, Log } from "../../interfaces";
-import { getCurrentTime, bnZero, MakeOptional, EventSearchConfig } from "../../utils";
-import { SpokePoolUpdate, SvmSpokePoolClient } from "../SpokePoolClient";
-import { HubPoolClient } from "../HubPoolClient";
-import { EventOverrides } from "./MockEvents";
-import { AcrossConfigStoreClient } from "../AcrossConfigStoreClient";
-import { MockSvmCpiEventsClient } from "./MockSvmCpiEventsClient";
-import { EventWithData, SvmCpiEventsClient, SVMEventNames, unwrapEventData } from "../../arch/svm";
-
-// This class replaces internal SpokePoolClient functionality, enabling
-// the user to bypass on-chain queries and inject events directly.
-export class MockSvmSpokePoolClient extends SvmSpokePoolClient {
-  public mockEventsClient: MockSvmCpiEventsClient;
-  private destinationTokenForChainOverride: Record<number, string> = {};
-
-  constructor(
-    logger: winston.Logger,
-    chainId: number,
-    programId = SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS,
-    deploymentBlock: number = 1,
-    eventSearchConfig: MakeOptional<EventSearchConfig, "to"> = { from: 0, maxLookBack: 0 },
-    opts: { hubPoolClient: HubPoolClient | null } = { hubPoolClient: null }
-  ) {
-    super(
-      logger,
-      opts.hubPoolClient,
-      chainId,
-      BigInt(deploymentBlock),
-      eventSearchConfig,
-      null as unknown as SvmCpiEventsClient,
-      programId,
-      null as unknown as Address
-    );
-    this.mockEventsClient = new MockSvmCpiEventsClient();
-    this.latestHeightSearched = deploymentBlock;
-  }
-
-  setConfigStoreClient(configStore?: AcrossConfigStoreClient): void {
-    this.configStoreClient = configStore;
-  }
-
-  setDestinationTokenForChain(chainId: number, token: string): void {
-    this.destinationTokenForChainOverride[chainId] = token;
-  }
-
-  getDestinationTokenForDeposit(deposit: DepositWithBlock): string {
-    return this.destinationTokenForChainOverride[deposit.originChainId] ?? super.getDestinationTokenForDeposit(deposit);
-  }
-
-  setLatestBlockNumber(blockNumber: number): void {
-    this.latestHeightSearched = blockNumber;
-  }
-
-  async _update(eventsToQuery: string[]): Promise<SpokePoolUpdate> {
-    const from = this.eventSearchConfig.from ?? this.deploymentBlock;
-    const to = this.eventSearchConfig.to ? BigInt(this.eventSearchConfig.to) : undefined;
-
-    // Get events from the mock event client.
-    const events: EventWithData[][] = await Promise.all(
-      eventsToQuery.map((eventName) => this.mockEventsClient.queryEvents(eventName as SVMEventNames, BigInt(from), to))
-    );
-
-    const eventsWithBlockNumber = events.map((eventList) =>
-      eventList.map((event) => {
-        return {
-          txnRef: event.signature,
-          blockNumber: Number(event.slot),
-          txnIndex: 0,
-          logIndex: 0,
-          ...(unwrapEventData(event.data) as Record<string, unknown>),
-        };
-      })
-    );
-
-    return Promise.resolve({
-      success: true,
-      firstDepositId: bnZero,
-      currentTime: getCurrentTime(),
-      events: eventsWithBlockNumber,
-      searchEndBlock: this.eventSearchConfig.to || this.latestHeightSearched,
-    });
-  }
-
-  deposit(deposit: SvmSpokeClient.FundsDeposited & Partial<EventWithData>): EventWithData {
-    return this.mockEventsClient.deposit(deposit);
-  }
-
-  fillRelay(fill: SvmSpokeClient.FilledRelay & Partial<EventWithData>): EventWithData {
-    return this.mockEventsClient.fillRelay(fill);
-  }
-
-  requestSlowFill(request: SvmSpokeClient.RequestedSlowFill & Partial<EventWithData>): EventWithData {
-    return this.mockEventsClient.requestSlowFill(request);
-  }
-
-  setTokensBridged(_tokensBridged: SvmSpokeClient.TokensBridged & Partial<EventWithData>): EventWithData {
-    throw new Error("MockSvmSpokePoolClient#setTokensBridged not implemented");
-  }
-
-  executeSlowRelayLeaf(_leaf: Omit<SlowFillLeaf, "messageHash">): Log {
-    throw new Error("MockSvmSpokePoolClient#executeV3SlowRelayLeaf not implemented");
-  }
-
-  executeRelayerRefundLeaf(_refund: RelayerRefundExecution & Partial<SortableEvent>): Log {
-    throw new Error("MockSvmSpokePoolClient#executeRelayerRefundLeaf not implemented");
-  }
-
-  setEnableRoute(
-    _originToken: string,
-    _destinationChainId: number,
-    _enabled: boolean,
-    _overrides: EventOverrides = {}
-  ): Log {
-    throw new Error("MockSvmSpokePoolClient#setEnableRoute not implemented");
-  }
-}

package/src/gasPriceOracle/adapters/solana.ts

@@ -1,45 +0,0 @@
-import { SVMProvider } from "../../arch/svm";
-import { toBN, dedupArray, parseUnits } from "../../utils";
-import { GasPriceEstimate } from "../types";
-import { GasPriceEstimateOptions } from "../oracle";
-import { CompilableTransactionMessage, TransactionMessageBytesBase64, compileTransaction } from "@solana/kit";
-
-/**
- * @notice Returns result of getFeeForMessage and getRecentPrioritizationFees RPC calls.
- * @returns GasPriceEstimate
- */
-export async function messageFee(provider: SVMProvider, opts: GasPriceEstimateOptions): Promise<GasPriceEstimate> {
-  const { unsignedTx: _unsignedTx } = opts;
-
-  // Cast the opaque unsignedTx type to a solana-kit CompilableTransactionMessage.
-  const unsignedTx = _unsignedTx as CompilableTransactionMessage;
-  const compiledTransaction = compileTransaction(unsignedTx);
-
-  // Get this base fee. This should result in LAMPORTS_PER_SIGNATURE * nSignatures.
-  const encodedTransactionMessage = Buffer.from(compiledTransaction.messageBytes).toString(
-    "base64"
-  ) as TransactionMessageBytesBase64;
-  const baseFeeResponse = await provider.getFeeForMessage(encodedTransactionMessage).send();
-
-  // Get the priority fee by calling `getRecentPrioritzationFees` on all the addresses in the transaction's instruction array.
-  const instructionAddresses = dedupArray(unsignedTx.instructions.map((instruction) => instruction.programAddress));
-  const recentPriorityFees = await provider.getRecentPrioritizationFees(instructionAddresses).send();
-
-  // Take the most recent 25 slots and find the average of the nonzero priority fees.
-  const nonzeroPrioritizationFees = recentPriorityFees
-    .slice(125)
-    .map((value) => value.prioritizationFee)
-    .filter((fee) => fee > 0);
-  const totalPrioritizationFees = nonzeroPrioritizationFees.reduce((acc, fee) => acc + fee, BigInt(0));
-
-  // Optionally impose a minimum priority fee, denoted in microLamports/computeUnit.
-  const flooredPriorityFeePerGas = parseUnits(process.env[`MIN_PRIORITY_FEE_PER_GAS_${opts.chainId}`] || "0", 6);
-  let microLamportsPerComputeUnit = toBN(totalPrioritizationFees / BigInt(nonzeroPrioritizationFees.length));
-  if (microLamportsPerComputeUnit.lt(flooredPriorityFeePerGas)) {
-    microLamportsPerComputeUnit = flooredPriorityFeePerGas;
-  }
-  return {
-    baseFee: toBN(baseFeeResponse!.value!),
-    microLamportsPerComputeUnit,
-  };
-}

package/src/providers/mocks/MockCachedSolanaRpcFactory.ts

@@ -1,15 +0,0 @@
-import { CachedSolanaRpcFactory } from "..";
-import { MockRateLimitedSolanaRpcFactory } from "./MockRateLimitedSolanaRpcFactory";
-
-// Creates mocked cached Solana RPC factory by using the mocked Solana RPC factory.
-export class MockCachedSolanaRpcFactory extends CachedSolanaRpcFactory {
-  constructor(
-    mockRateLimitedSolanaRpcFactory: MockRateLimitedSolanaRpcFactory,
-    ...cachedConstructorParams: ConstructorParameters<typeof CachedSolanaRpcFactory>
-  ) {
-    super(...cachedConstructorParams);
-
-    this.rateLimitedTransport = mockRateLimitedSolanaRpcFactory.createTransport();
-    this.rateLimitedRpcClient = mockRateLimitedSolanaRpcFactory.createRpcClient();
-  }
-}

package/src/providers/mocks/MockRateLimitedSolanaRpcFactory.ts

@@ -1,14 +0,0 @@
-import { RateLimitedSolanaRpcFactory } from "..";
-import { MockSolanaRpcFactory } from "./MockSolanaRpcFactory";
-
-// Creates mocked rate limited Solana RPC factory by using the mocked Solana RPC factory.
-export class MockRateLimitedSolanaRpcFactory extends RateLimitedSolanaRpcFactory {
-  constructor(
-    mockSolanaRpcFactory: MockSolanaRpcFactory,
-    ...rateLimitedConstructorParams: ConstructorParameters<typeof RateLimitedSolanaRpcFactory>
-  ) {
-    super(...rateLimitedConstructorParams);
-
-    this.defaultTransport = mockSolanaRpcFactory.createTransport();
-  }
-}