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

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/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/providers/index.ts

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

package/src/providers/mocks/MockCachedSolanaRpcFactory.ts

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

@@ -0,0 +1,14 @@
+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();
+  }
+}

package/src/providers/mocks/MockSolanaRpcFactory.ts

@@ -0,0 +1,55 @@
+import { RpcResponse, RpcTransport } from "@solana/kit";
+import { SolanaClusterRpcFactory } from "../solana";
+
+type CachedResponse = { result: unknown } | { error: unknown } | { throwError: string };
+
+// Exposes mocked RPC transport for Solana in the SolanaClusterRpcFactory class.
+export class MockSolanaRpcFactory extends SolanaClusterRpcFactory {
+  private responseTime: number = 10; // in milliseconds
+  private responses: Map<string, CachedResponse> = new Map();
+
+  constructor(...clusterConstructorParams: ConstructorParameters<typeof SolanaClusterRpcFactory>) {
+    super(...clusterConstructorParams);
+  }
+
+  public createTransport(): RpcTransport {
+    return <TResponse>(...args: Parameters<RpcTransport>): Promise<TResponse> => {
+      return this.createMockRpcTransport()<TResponse>(...args);
+    };
+  }
+
+  public setResult(method: string, params: unknown[], result: unknown) {
+    const requestKey = JSON.stringify({ method, params });
+    this.responses.set(requestKey, { result });
+  }
+
+  public setError(method: string, params: unknown[], error: unknown) {
+    const requestKey = JSON.stringify({ method, params });
+    this.responses.set(requestKey, { error });
+  }
+
+  public setThrow(method: string, params: unknown[], throwError: string) {
+    const requestKey = JSON.stringify({ method, params });
+    this.responses.set(requestKey, { throwError });
+  }
+
+  public setResponseTime(responseTime: number) {
+    this.responseTime = responseTime;
+  }
+
+  private createMockRpcTransport(): RpcTransport {
+    return async <TResponse>({ payload }: Parameters<RpcTransport>[0]): Promise<RpcResponse<TResponse>> => {
+      const { method, params } = payload as { method: string; params?: unknown[] };
+      const requestKey = JSON.stringify({ method, params });
+      let jsonRpcResponse = this.responses.get(requestKey);
+      if (jsonRpcResponse === undefined) {
+        const requestKeyWithoutParams = JSON.stringify({ method, params: [] });
+        jsonRpcResponse = this.responses.get(requestKeyWithoutParams);
+        if (jsonRpcResponse === undefined) jsonRpcResponse = { result: null };
+      }
+      await new Promise((resolve) => setTimeout(resolve, this.responseTime));
+      if ("throwError" in jsonRpcResponse) throw new Error(jsonRpcResponse.throwError);
+      return jsonRpcResponse as TResponse;
+    };
+  }
+}

package/src/providers/mocks/index.ts

@@ -0,0 +1,4 @@
+export * from "./mockEthersProvider";
+export * from "./MockCachedSolanaRpcFactory";
+export * from "./MockRateLimitedSolanaRpcFactory";
+export * from "./MockSolanaRpcFactory";

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

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

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

@@ -3,7 +3,7 @@ import { isL2Provider as isOptimismL2Provider } from "@eth-optimism/sdk/dist/l2-
 
 import { PopulatedTransaction, providers, VoidSigner } from "ethers";
 import { Coingecko } from "../../coingecko";
-import { CHAIN_IDs, DEFAULT_SIMULATED_RELAYER_ADDRESS } from "../../constants";
+import { CHAIN_IDs } from "../../constants";
 import { Deposit } from "../../interfaces";
 import { SpokePool, SpokePool__factory } from "../../typechain";
 import { populateV3Relay } from "../../arch/evm";
@@ -17,7 +17,7 @@ import {
   fixedPointAdjustment,
 } from "../../utils";
 import assert from "assert";
-import { Logger, QueryInterface } from "../relayFeeCalculator";
+import { Logger, QueryInterface, getDefaultSimulatedRelayerAddress } from "../relayFeeCalculator";
 import { Transport } from "viem";
 import { getGasPriceEstimate, EvmGasPriceEstimate } from "../../gasPriceOracle";
 type Provider = providers.Provider;
@@ -72,7 +72,7 @@ export class QueryBase implements QueryInterface {
    */
   async getGasCosts(
     deposit: Omit<Deposit, "messageHash">,
-    relayer = DEFAULT_SIMULATED_RELAYER_ADDRESS,
+    relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
     options: Partial<{
       gasPrice: BigNumberish;
       gasUnits: BigNumberish;
@@ -122,7 +122,7 @@ export class QueryBase implements QueryInterface {
    */
   getUnsignedTxFromDeposit(
     deposit: Omit<Deposit, "messageHash">,
-    relayer = DEFAULT_SIMULATED_RELAYER_ADDRESS
+    relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId)
   ): Promise<PopulatedTransaction> {
     return populateV3Relay(this.spokePool, deposit, relayer);
   }
@@ -135,7 +135,7 @@ export class QueryBase implements QueryInterface {
    */
   async getNativeGasCost(
     deposit: Omit<Deposit, "messageHash">,
-    relayer = DEFAULT_SIMULATED_RELAYER_ADDRESS
+    relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId)
   ): Promise<BigNumber> {
     const unsignedTx = await this.getUnsignedTxFromDeposit(deposit, relayer);
     const voidSigner = new VoidSigner(relayer, this.provider);
@@ -152,7 +152,7 @@ export class QueryBase implements QueryInterface {
    */
   async getOpStackL1DataFee(
     unsignedTx: PopulatedTransaction,
-    relayer = DEFAULT_SIMULATED_RELAYER_ADDRESS,
+    relayer = getDefaultSimulatedRelayerAddress(unsignedTx.chainId),
     options: Partial<{
       opStackL2GasUnits: BigNumberish;
       opStackL1DataFeeMultiplier: BigNumber;

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

@@ -3,11 +3,11 @@ import { CHAIN_IDs, TOKEN_SYMBOLS_MAP } from "@across-protocol/constants";
 import { getDeployedAddress } from "@across-protocol/contracts";
 import { asL2Provider } from "@eth-optimism/sdk";
 import { providers } from "ethers";
-import { DEFAULT_SIMULATED_RELAYER_ADDRESS, CUSTOM_GAS_TOKENS } from "../../constants";
+import { CUSTOM_GAS_TOKENS } from "../../constants";
 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 { DEFAULT_LOGGER, getDefaultSimulatedRelayerAddress, Logger } from "../relayFeeCalculator";
 import { CustomGasTokenQueries } from "./customGasToken";
 import { SvmQuery } from "./svmQuery";
 
@@ -25,7 +25,7 @@ export class QueryBase__factory {
     provider: providers.Provider | svmProvider,
     symbolMapping = TOKEN_SYMBOLS_MAP,
     spokePoolAddress = getDeployedAddress("SpokePool", chainId),
-    simulatedRelayerAddress = DEFAULT_SIMULATED_RELAYER_ADDRESS,
+    simulatedRelayerAddress = getDefaultSimulatedRelayerAddress(chainId),
     coingeckoProApiKey?: string,
     logger: Logger = DEFAULT_LOGGER,
     coingeckoBaseCurrency = "eth"

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

@@ -1,7 +1,7 @@
 import { pipe } from "@solana/functional";
 import { Coingecko } from "../../coingecko";
 import { SymbolMappingType } from "./";
-import { CHAIN_IDs, DEFAULT_SIMULATED_RELAYER_ADDRESS } from "../../constants";
+import { CHAIN_IDs } from "../../constants";
 import { Deposit } from "../../interfaces";
 import { getGasPriceEstimate, SvmGasPriceEstimate } from "../../gasPriceOracle";
 import {
@@ -13,7 +13,7 @@ import {
   isDefined,
   toAddressType,
 } from "../../utils";
-import { Logger, QueryInterface } from "../relayFeeCalculator";
+import { getDefaultSimulatedRelayerAddress, Logger, QueryInterface } from "../relayFeeCalculator";
 import {
   fillRelayInstruction,
   createApproveInstruction,
@@ -79,7 +79,7 @@ export class SvmQuery implements QueryInterface {
    */
   async getGasCosts(
     deposit: Omit<Deposit, "messageHash">,
-    _relayer = DEFAULT_SIMULATED_RELAYER_ADDRESS,
+    _relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
     options: Partial<{
       gasPrice: BigNumberish;
       gasUnits: BigNumberish;
@@ -87,11 +87,64 @@ export class SvmQuery implements QueryInterface {
       priorityFeeMultiplier: BigNumber;
     }> = {}
   ): Promise<TransactionCostEstimate> {
+    const relayer = _relayer ? toAddressType(_relayer).forceSvmAddress() : this.simulatedRelayerAddress;
+
+    const fillRelayTx = await this.getFillRelayTx(deposit, relayer.toBase58());
+
+    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,
+    };
+  }
+
+  /**
+   * @notice Return the gas cost of a simulated transaction
+   * @param fillRelayTx FillRelay transaction
+   * @param relayer SVM address of the relayer
+   * @returns Estimated gas cost in compute units
+   */
+  async getNativeGasCost(
+    deposit: Omit<Deposit, "messageHash">,
+    _relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId)
+  ): Promise<BigNumber> {
+    const fillRelayTx = await this.getFillRelayTx(deposit, _relayer);
+    const computeUnitsConsumed = toBN(await this.computeUnitEstimator(fillRelayTx));
+    return computeUnitsConsumed;
+  }
+
+  /**
+   * @notice Return the fillRelay transaction for a given deposit
+   * @param deposit
+   * @param relayer SVM address of the relayer
+   * @returns FillRelay transaction
+   */
+  async getFillRelayTx(
+    deposit: Omit<Deposit, "messageHash">,
+    _relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId)
+  ) {
+    const relayer = _relayer ? toAddressType(_relayer).forceSvmAddress() : this.simulatedRelayerAddress;
     // 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());
+    const simulatedSigner = SolanaVoidSigner(relayer.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;
@@ -134,7 +187,7 @@ export class SvmQuery implements QueryInterface {
     const recentBlockhash = await this.provider.getLatestBlockhash().send();
     const fillRelayTx = pipe(
       createTransactionMessage({ version: 0 }),
-      (tx) => setTransactionMessageFeePayer(this.simulatedRelayerAddress.toV2Address(), tx),
+      (tx) => setTransactionMessageFeePayer(relayer.toV2Address(), tx),
       (tx) => setTransactionMessageLifetimeUsingBlockhash(recentBlockhash.value, tx),
       (tx) =>
         isDefined(recipientCreateTokenAccountInstructions)
@@ -142,28 +195,7 @@ export class SvmQuery implements QueryInterface {
           : 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,
-    };
+    return fillRelayTx;
   }
 
   /**