@across-protocol/sdk 4.1.63 → 4.2.1

package/src/clients/mocks/MockSvmCpiEventsClient.ts

@@ -0,0 +1,226 @@
+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

@@ -0,0 +1,119 @@
+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/clients/mocks/index.ts

@@ -1,3 +1,5 @@
 export * from "./MockConfigStoreClient";
 export * from "./MockHubPoolClient";
 export * from "./MockSpokePoolClient";
+export * from "./MockSvmCpiEventsClient";
+export * from "./MockSvmSpokePoolClient";

package/src/coingecko/Coingecko.ts

@@ -70,13 +70,14 @@ export class Coingecko {
   private platformIdMap = new Map<number, string>(); // chainId => platform_id (137 => "polygon-pos")
   private tokenIdMap: Record<string, Record<string, string>> = {}; // coinGeckoId => { platform_id : "tokenAddress":}
 
-  public static get(logger: Logger, apiKey?: string) {
+  public static get(logger: Logger, apiKey?: string, customPlatformIdMap?: Record<number, string>) {
     if (!this.instance)
       this.instance = new Coingecko(
         "https://api.coingecko.com/api/v3",
         "https://pro-api.coingecko.com/api/v3",
         logger,
-        apiKey
+        apiKey,
+        customPlatformIdMap
       );
     return this.instance;
   }
@@ -98,7 +99,8 @@ export class Coingecko {
     private readonly host: string,
     private readonly proHost: string,
     private readonly logger: Logger,
-    private readonly apiKey?: string
+    private readonly apiKey?: string,
+    private readonly customPlatformIdMap?: Record<number, string>
   ) {
     this.prices = {};
   }
@@ -115,6 +117,13 @@ export class Coingecko {
       platforms.filter((chain) => Boolean(chain.chain_identifier)).map((chain) => [chain.chain_identifier, chain.id])
     );
 
+    // Extend the platformIdMap with any custom platform ids
+    if (this.customPlatformIdMap) {
+      Object.entries(this.customPlatformIdMap).forEach(([chainId, platformId]) => {
+        this.platformIdMap.set(Number(chainId), platformId);
+      });
+    }
+
     id = this.platformIdMap.get(chainId);
     if (!id) {
       this.logger.error({

package/src/constants.ts

@@ -54,6 +54,7 @@ export const DEFAULT_CACHING_TTL = 60 * 60 * 24 * 7 * 2; // 2 Weeks
 export const DEFAULT_CACHING_SAFE_LAG = 60 * 60; // 1 hour
 
 export const DEFAULT_SIMULATED_RELAYER_ADDRESS = "0x07aE8551Be970cB1cCa11Dd7a11F47Ae82e70E67";
+export const DEFAULT_SIMULATED_RELAYER_ADDRESS_SVM = "FmMK62wrtWVb5SVoTZftSCGw3nEDA79hDbZNTRnC1R6t";
 export const DEFAULT_SIMULATED_RELAYER_ADDRESS_TEST = "0x9A8f92a830A5cB89a3816e3D267CB7791c16b04D"; // Görli, ...
 
 export const DEFAULT_ARWEAVE_STORAGE_ADDRESS = "Z6hjBM8FHu90lYWB8o5jR1dfX92FlV2WBaND9xgp8Lg";

package/src/gasPriceOracle/adapters/arbitrum.ts

@@ -1,6 +1,6 @@
 import { providers } from "ethers";
 import { bnOne } from "../../utils";
-import { GasPriceEstimate } from "../types";
+import { EvmGasPriceEstimate } from "../types";
 import * as ethereum from "./ethereum";
 import { GasPriceEstimateOptions } from "../oracle";
 
@@ -16,7 +16,10 @@ import { GasPriceEstimateOptions } from "../oracle";
  * function.
  * @returns GasPriceEstimate
  */
-export async function eip1559(provider: providers.Provider, opts: GasPriceEstimateOptions): Promise<GasPriceEstimate> {
+export async function eip1559(
+  provider: providers.Provider,
+  opts: GasPriceEstimateOptions
+): Promise<EvmGasPriceEstimate> {
   const { maxFeePerGas: _maxFeePerGas, maxPriorityFeePerGas } = await ethereum.eip1559(provider, opts);
 
   // eip1559() sets maxFeePerGas = lastBaseFeePerGas + maxPriorityFeePerGas, so back out priority fee.

package/src/gasPriceOracle/adapters/ethereum.ts

@@ -1,7 +1,7 @@
 import assert from "assert";
 import { providers } from "ethers";
 import { BigNumber, bnZero, fixedPointAdjustment, getNetworkName, parseUnits } from "../../utils";
-import { GasPriceEstimate } from "../types";
+import { EvmGasPriceEstimate } from "../types";
 import { gasPriceError } from "../util";
 import { GasPriceEstimateOptions } from "../oracle";
 
@@ -13,7 +13,7 @@ import { GasPriceEstimateOptions } from "../oracle";
  * @param priorityFeeMultiplier Amount to multiply priority fee or unused for legacy gas pricing.
  * @returns Promise of gas price estimate object.
  */
-export function eip1559(provider: providers.Provider, opts: GasPriceEstimateOptions): Promise<GasPriceEstimate> {
+export function eip1559(provider: providers.Provider, opts: GasPriceEstimateOptions): Promise<EvmGasPriceEstimate> {
   return eip1559Raw(provider, opts.chainId, opts.baseFeeMultiplier, opts.priorityFeeMultiplier);
 }
 
@@ -29,7 +29,7 @@ export async function eip1559Raw(
   chainId: number,
   baseFeeMultiplier: BigNumber,
   priorityFeeMultiplier: BigNumber
-): Promise<GasPriceEstimate> {
+): Promise<EvmGasPriceEstimate> {
   const [{ baseFeePerGas }, _maxPriorityFeePerGas] = await Promise.all([
     provider.getBlock("pending"),
     (provider as providers.JsonRpcProvider).send("eth_maxPriorityFeePerGas", []),
@@ -54,7 +54,10 @@ export async function eip1559Raw(
  * @dev Its recommended to use the eip1559Raw method over this one where possible as it will be more accurate.
  * @returns GasPriceEstimate
  */
-export async function legacy(provider: providers.Provider, opts: GasPriceEstimateOptions): Promise<GasPriceEstimate> {
+export async function legacy(
+  provider: providers.Provider,
+  opts: GasPriceEstimateOptions
+): Promise<EvmGasPriceEstimate> {
   const { chainId, baseFeeMultiplier } = opts;
   const gasPrice = await provider.getGasPrice();
 

package/src/gasPriceOracle/adapters/linea-viem.ts

@@ -1,3 +1,4 @@
+import { PopulatedTransaction } from "ethers";
 import { Address, Hex, PublicClient } from "viem";
 import { estimateGas } from "viem/linea";
 import { DEFAULT_SIMULATED_RELAYER_ADDRESS as account } from "../../constants";
@@ -26,7 +27,8 @@ export async function eip1559(
   provider: PublicClient,
   opts: GasPriceEstimateOptions
 ): Promise<InternalGasPriceEstimate> {
-  const { unsignedTx, priorityFeeMultiplier } = opts;
+  const { unsignedTx: _unsignedTx, priorityFeeMultiplier } = opts;
+  const unsignedTx = _unsignedTx as PopulatedTransaction; // Cast the opaque unsignedTx type to an ethers PopulatedTransaction.
   const { baseFeePerGas, priorityFeePerGas: _priorityFeePerGas } = await estimateGas(provider, {
     account: (unsignedTx?.from as Address) ?? account,
     to: (unsignedTx?.to as Address) ?? account,

package/src/gasPriceOracle/adapters/polygon.ts

@@ -2,7 +2,7 @@ import { providers } from "ethers";
 import { BaseHTTPAdapter, BaseHTTPAdapterArgs } from "../../priceClient/adapters/baseAdapter";
 import { BigNumber, bnZero, fixedPointAdjustment, isDefined, parseUnits } from "../../utils";
 import { CHAIN_IDs } from "../../constants";
-import { GasPriceEstimate } from "../types";
+import { EvmGasPriceEstimate } from "../types";
 import { gasPriceError } from "../util";
 import { eip1559 } from "./ethereum";
 import { GasPriceEstimateOptions } from "../oracle";
@@ -38,7 +38,7 @@ export class PolygonGasStation extends BaseHTTPAdapter {
     this.chainId = chainId;
   }
 
-  async getFeeData(strategy: "safeLow" | "standard" | "fast" = "fast"): Promise<GasPriceEstimate> {
+  async getFeeData(strategy: "safeLow" | "standard" | "fast" = "fast"): Promise<EvmGasPriceEstimate> {
     const gas = await this.query("v2", {});
 
     const gasPrice = (gas as GasStationV2Response)?.[strategy];
@@ -69,7 +69,7 @@ export class PolygonGasStation extends BaseHTTPAdapter {
 }
 
 class MockRevertingPolygonGasStation extends PolygonGasStation {
-  getFeeData(): Promise<GasPriceEstimate> {
+  getFeeData(): Promise<EvmGasPriceEstimate> {
     throw new Error();
   }
 }
@@ -78,7 +78,7 @@ export const MockPolygonGasStationBaseFee = () => parseUnits("12", 9);
 export const MockPolygonGasStationPriorityFee = () => parseUnits("1", 9);
 
 class MockPolygonGasStation extends PolygonGasStation {
-  getFeeData(): Promise<GasPriceEstimate> {
+  getFeeData(): Promise<EvmGasPriceEstimate> {
     return Promise.resolve({
       maxPriorityFeePerGas: MockPolygonGasStationPriorityFee(),
       maxFeePerGas: MockPolygonGasStationBaseFee().add(MockPolygonGasStationPriorityFee()),
@@ -90,12 +90,12 @@ class MockPolygonGasStation extends PolygonGasStation {
  * @notice Returns the gas price suggested by the Polygon GasStation API or reconstructs it using
  * the eip1559() method as a fallback.
  * @param provider Ethers Provider.
- * @returns GasPriceEstimate
+ * @returns EvmGasPriceEstimate
  */
 export async function gasStation(
   provider: providers.Provider,
   opts: GasPriceEstimateOptions
-): Promise<GasPriceEstimate> {
+): Promise<EvmGasPriceEstimate> {
   const { chainId, baseFeeMultiplier, priorityFeeMultiplier } = opts;
   let gasStation: PolygonGasStation;
   if (process.env.TEST_POLYGON_GAS_STATION === "true") {

package/src/gasPriceOracle/adapters/solana.ts

@@ -0,0 +1,47 @@
+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(Math.max(nonzeroPrioritizationFees.length, 1))
+  );
+  if (microLamportsPerComputeUnit.lt(flooredPriorityFeePerGas)) {
+    microLamportsPerComputeUnit = flooredPriorityFeePerGas;
+  }
+  return {
+    baseFee: toBN(baseFeeResponse!.value!),
+    microLamportsPerComputeUnit,
+  };
+}

package/src/gasPriceOracle/index.ts

@@ -1,2 +1,2 @@
 export { getGasPriceEstimate } from "./oracle";
-export { GasPriceEstimate } from "./types";
+export { GasPriceEstimate, EvmGasPriceEstimate, SvmGasPriceEstimate } from "./types";

package/src/gasPriceOracle/oracle.ts

@@ -1,14 +1,16 @@
 import assert from "assert";
 import { Transport } from "viem";
-import { PopulatedTransaction, providers } from "ethers";
+import { 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).
@@ -19,8 +21,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.
-  unsignedTx?: PopulatedTransaction;
+  // 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;
   // transport Viem Transport object to use for querying gas fees used for testing.
   transport?: Transport;
 }
@@ -39,7 +41,7 @@ const VIEM_CHAINS = [CHAIN_IDs.LINEA];
  * @returns An  object of type GasPriceEstimate.
  */
 export async function getGasPriceEstimate(
-  provider: providers.Provider,
+  provider: providers.Provider | SolanaProvider,
   opts: Partial<GasPriceEstimateOptions> = {}
 ): Promise<GasPriceEstimate> {
   const baseFeeMultiplier = opts.baseFeeMultiplier ?? toBNWei("1");
@@ -53,6 +55,20 @@ 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,12 +2,18 @@ import { type Chain, type Transport, PublicClient, FeeValuesEIP1559 } from "viem
 import { BigNumber } from "../utils";
 
 export type InternalGasPriceEstimate = FeeValuesEIP1559;
+export type GasPriceEstimate = EvmGasPriceEstimate | SvmGasPriceEstimate;
 
-export type GasPriceEstimate = {
+export type EvmGasPriceEstimate = {
   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,4 +16,3 @@ 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";