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

package/src/arch/svm/SpokeUtils.ts

@@ -1,38 +1,41 @@
-import {
-  SvmAddress,
-  getTokenInfo,
-  BigNumber,
-  isDefined,
-  isUnsafeDepositId,
-  toAddressType,
-  toBN,
-  getMessageHash,
-  keccak256,
-  chainIsSvm,
-  chunk,
-} from "../../utils";
 import { SvmSpokeClient } from "@across-protocol/contracts";
-import { getStatePda, SvmCpiEventsClient, getFillStatusPda, unwrapEventData, getEventAuthority } from "./";
-import { Deposit, FillStatus, FillWithBlock, RelayData } from "../../interfaces";
+import { decodeFillStatusAccount, fetchState } from "@across-protocol/contracts/dist/src/svm/clients/SvmSpoke";
+import { hashNonEmptyMessage } from "@across-protocol/contracts/dist/src/svm/web3-v1";
 import {
-  TOKEN_PROGRAM_ADDRESS,
   ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+  TOKEN_PROGRAM_ADDRESS,
   getApproveCheckedInstruction,
 } from "@solana-program/token";
 import {
   Address,
-  some,
   address,
-  getProgramDerivedAddress,
-  fetchEncodedAccounts,
   fetchEncodedAccount,
+  fetchEncodedAccounts,
+  getAddressEncoder,
+  getProgramDerivedAddress,
+  getU32Encoder,
+  getU64Encoder,
+  some,
   type TransactionSigner,
 } from "@solana/kit";
 import assert from "assert";
+import { arrayify, hexZeroPad, hexlify } from "ethers/lib/utils";
 import { Logger } from "winston";
-import { fetchState, decodeFillStatusAccount } from "@across-protocol/contracts/dist/src/svm/clients/SvmSpoke";
-import { SVMEventNames, SVMProvider } from "./types";
 import { CHAIN_IDs } from "../../constants";
+import { Deposit, FillStatus, FillWithBlock, RelayData } from "../../interfaces";
+import {
+  BigNumber,
+  SvmAddress,
+  chainIsSvm,
+  chunk,
+  getTokenInfo,
+  isDefined,
+  isUnsafeDepositId,
+  keccak256,
+  toAddressType,
+} from "../../utils";
+import { SvmCpiEventsClient, getEventAuthority, getFillStatusPda, getStatePda, unwrapEventData } from "./";
+import { SVMEventNames, SVMProvider } from "./types";
 
 /**
  * @param spokePool SpokePool Contract instance.
@@ -412,29 +415,26 @@ export async function getAssociatedTokenAddress(
 }
 
 export function getRelayDataHash(relayData: RelayData, destinationChainId: number): string {
-  const toBuffer = (hex: string, byteLength: number, littleEndian: boolean = true) => {
-    const buffer = Buffer.from(hex.slice(2), "hex");
-    if (buffer.length < byteLength) {
-      const zeroPad = Buffer.alloc(byteLength);
-      buffer.copy(zeroPad, byteLength - buffer.length);
-      return littleEndian ? zeroPad.reverse() : zeroPad;
-    }
-    return littleEndian ? buffer.slice(0, byteLength).reverse() : buffer.slice(0, byteLength);
-  };
+  const addressEncoder = getAddressEncoder();
+  const uint64Encoder = getU64Encoder();
+  const uint32Encoder = getU32Encoder();
+
+  assert(relayData.message.startsWith("0x"), "Message must be a hex string");
+
   const contentToHash = Buffer.concat([
-    toBuffer(relayData.depositor, 32, false),
-    toBuffer(relayData.recipient, 32, false),
-    toBuffer(relayData.exclusiveRelayer, 32, false),
-    toBuffer(relayData.inputToken, 32, false),
-    toBuffer(relayData.outputToken, 32, false),
-    toBuffer(relayData.inputAmount.toHexString(), 8),
-    toBuffer(relayData.outputAmount.toHexString(), 8),
-    toBuffer(toBN(relayData.originChainId).toHexString(), 8),
-    toBuffer(relayData.depositId.toHexString(), 32, false),
-    toBuffer(toBN(relayData.fillDeadline).toHexString(), 4),
-    toBuffer(toBN(relayData.exclusivityDeadline).toHexString(), 4),
-    toBuffer(getMessageHash(relayData.message), 32, false),
-    toBuffer(toBN(destinationChainId).toHexString(), 8),
+    Uint8Array.from(addressEncoder.encode(SvmAddress.from(relayData.depositor, "base16").toV2Address())),
+    Uint8Array.from(addressEncoder.encode(SvmAddress.from(relayData.recipient, "base16").toV2Address())),
+    Uint8Array.from(addressEncoder.encode(SvmAddress.from(relayData.exclusiveRelayer, "base16").toV2Address())),
+    Uint8Array.from(addressEncoder.encode(SvmAddress.from(relayData.inputToken, "base16").toV2Address())),
+    Uint8Array.from(addressEncoder.encode(SvmAddress.from(relayData.outputToken, "base16").toV2Address())),
+    Uint8Array.from(uint64Encoder.encode(BigInt(relayData.inputAmount.toString()))),
+    Uint8Array.from(uint64Encoder.encode(BigInt(relayData.outputAmount.toString()))),
+    Uint8Array.from(uint64Encoder.encode(BigInt(relayData.originChainId.toString()))),
+    arrayify(hexZeroPad(hexlify(relayData.depositId), 32)),
+    Uint8Array.from(uint32Encoder.encode(relayData.fillDeadline)),
+    Uint8Array.from(uint32Encoder.encode(relayData.exclusivityDeadline)),
+    hashNonEmptyMessage(Buffer.from(arrayify(relayData.message))),
+    Uint8Array.from(uint64Encoder.encode(BigInt(destinationChainId))),
   ]);
   return keccak256(contentToHash);
 }

package/src/arch/svm/constants.ts

@@ -1 +1,2 @@
+export { SYSTEM_PROGRAM_ADDRESS as SVM_DEFAULT_ADDRESS } from "@solana-program/system";
 export const SVM_SPOKE_SEED = BigInt(0);

package/src/arch/svm/eventsClient.ts

@@ -2,9 +2,16 @@ 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 { bs58, chainIsSvm, getMessageHash } from "../../utils";
 import { EventName, EventWithData, SVMProvider } from "./types";
 import { decodeEvent, isDevnet } from "./utils";
+import { DepositWithTime, FillWithTime } from "../../interfaces";
+import { unwrapEventData } from "./";
+import assert from "assert";
+import {
+  FundsDepositedEventObject,
+  FilledRelayEventObject,
+} from "@across-protocol/contracts/dist/typechain/contracts/SpokePool";
 
 // 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,6 +26,9 @@ type GetSignaturesForAddressConfig = Parameters<GetSignaturesForAddressApi["getS
 type GetSignaturesForAddressTransaction = ReturnType<GetSignaturesForAddressApi["getSignaturesForAddress"]>[number];
 type GetSignaturesForAddressApiResponse = readonly GetSignaturesForAddressTransaction[];
 
+export type DepositEventFromSignature = Omit<DepositWithTime, "fromLiteChain" | "toLiteChain">;
+export type FillEventFromSignature = FillWithTime;
+
 export class SvmCpiEventsClient {
   private rpc: SVMProvider;
   private programAddress: Address;
@@ -211,6 +221,109 @@ export class SvmCpiEventsClient {
     return events;
   }
 
+  /**
+   * Finds all FundsDeposited events for a given transaction signature.
+   *
+   * @param originChainId - The chain ID where the deposit originated.
+   * @param txSignature - The transaction signature to search for events.
+   * @param commitment - Optional commitment level for the transaction query.
+   * @returns A promise that resolves to an array of deposit events for the transaction, or undefined if none found.
+   */
+  public async getDepositEventsFromSignature(
+    originChainId: number,
+    txSignature: Signature,
+    commitment: Commitment = "confirmed"
+  ): Promise<DepositEventFromSignature[] | undefined> {
+    assert(chainIsSvm(originChainId), `Origin chain ${originChainId} is not an SVM chain`);
+
+    const [events, txDetails] = await Promise.all([
+      this.readEventsFromSignature(txSignature, commitment),
+      this.rpc
+        .getTransaction(txSignature, {
+          commitment,
+          maxSupportedTransactionVersion: 0,
+        })
+        .send(),
+    ]);
+
+    // Filter for FundsDeposited events only
+    const depositEvents = events?.filter((event) => event?.name === "FundsDeposited");
+
+    if (!txDetails || !depositEvents?.length) {
+      return;
+    }
+
+    return events.map((event) => {
+      const unwrappedEventArgs = unwrapEventData(event as Record<string, unknown>, ["depositId"]) as Record<
+        "data",
+        FundsDepositedEventObject
+      >;
+
+      return {
+        ...unwrappedEventArgs.data,
+        depositTimestamp: Number(txDetails.blockTime),
+        originChainId,
+        messageHash: getMessageHash(unwrappedEventArgs.data.message),
+        blockNumber: Number(txDetails.slot),
+        txnIndex: 0,
+        txnRef: txSignature,
+        logIndex: 0,
+        destinationChainId: unwrappedEventArgs.data.destinationChainId.toNumber(),
+      } satisfies DepositEventFromSignature;
+    });
+  }
+
+  /**
+   * Finds all FilledRelay events for a given transaction signature.
+   *
+   * @param destinationChainId - The destination chain ID (must be an SVM chain).
+   * @param txSignature - The transaction signature to search for events.
+   * @returns A promise that resolves to an array of fill events for the transaction, or undefined if none found.
+   */
+  public async getFillEventsFromSignature(
+    destinationChainId: number,
+    txSignature: Signature,
+    commitment: Commitment = "confirmed"
+  ): Promise<FillEventFromSignature[] | undefined> {
+    assert(chainIsSvm(destinationChainId), `Destination chain ${destinationChainId} is not an SVM chain`);
+
+    // Find all events from the transaction signature and get transaction details
+    const [events, txDetails] = await Promise.all([
+      this.readEventsFromSignature(txSignature, commitment),
+      this.rpc
+        .getTransaction(txSignature, {
+          commitment,
+          maxSupportedTransactionVersion: 0,
+        })
+        .send(),
+    ]);
+
+    // Filter for FilledRelay events only
+    const fillEvents = events?.filter((event) => event?.name === "FilledRelay");
+
+    if (!txDetails || !fillEvents?.length) {
+      return;
+    }
+
+    return fillEvents.map((event) => {
+      const unwrappedEventData = unwrapEventData(event as Record<string, unknown>) as Record<
+        "data",
+        FilledRelayEventObject
+      >;
+      return {
+        ...unwrappedEventData.data,
+        fillTimestamp: Number(txDetails.blockTime),
+        blockNumber: Number(txDetails.slot),
+        txnRef: txSignature,
+        txnIndex: 0,
+        logIndex: 0,
+        destinationChainId,
+        repaymentChainId: unwrappedEventData.data.repaymentChainId.toNumber(),
+        originChainId: unwrappedEventData.data.originChainId.toNumber(),
+      } satisfies FillEventFromSignature;
+    });
+  }
+
   public getProgramAddress(): Address {
     return this.programAddress;
   }

package/src/arch/svm/utils.ts

@@ -1,16 +1,16 @@
+import { SvmSpokeClient } from "@across-protocol/contracts";
 import { BN, BorshEventCoder, Idl } from "@coral-xyz/anchor";
 import {
+  Address,
   address,
+  getAddressEncoder,
   getProgramDerivedAddress,
   getU64Encoder,
-  getAddressEncoder,
-  Address,
   isAddress,
   type TransactionSigner,
 } from "@solana/kit";
-import { BigNumber, getRelayDataHash, isUint8Array, SvmAddress } from "../../utils";
-import { SvmSpokeClient } from "@across-protocol/contracts";
 import { FillType, RelayData } from "../../interfaces";
+import { BigNumber, SvmAddress, getRelayDataHash, isUint8Array } from "../../utils";
 import { EventName, SVMEventNames, SVMProvider } from "./types";
 
 /**

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/interfaces/SpokePool.ts

@@ -37,6 +37,10 @@ export interface DepositWithBlock extends Deposit, SortableEvent {
   quoteBlockNumber: number;
 }
 
+export interface DepositWithTime extends Deposit, SortableEvent {
+  depositTimestamp: number;
+}
+
 export enum FillStatus {
   Unfilled = 0,
   RequestedSlowFill,
@@ -66,6 +70,9 @@ export interface Fill extends Omit<RelayData, "message"> {
 }
 
 export interface FillWithBlock extends Fill, SortableEvent {}
+export interface FillWithTime extends Fill, SortableEvent {
+  fillTimestamp: number;
+}
 
 export interface EnabledDepositRoute {
   originToken: string;

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;
   }
 
   /**

package/src/relayFeeCalculator/relayFeeCalculator.ts

@@ -1,5 +1,9 @@
 import assert from "assert";
-import { DEFAULT_SIMULATED_RELAYER_ADDRESS, TOKEN_SYMBOLS_MAP } from "../constants";
+import {
+  DEFAULT_SIMULATED_RELAYER_ADDRESS,
+  DEFAULT_SIMULATED_RELAYER_ADDRESS_SVM,
+  TOKEN_SYMBOLS_MAP,
+} from "../constants";
 import { Deposit } from "../interfaces";
 import {
   BigNumber,
@@ -18,6 +22,7 @@ import {
   toBNWei,
   isZeroAddress,
   compareAddressesSimple,
+  chainIsSvm,
 } from "../utils";
 import { Transport } from "viem";
 
@@ -36,6 +41,7 @@ export interface QueryInterface {
     }>
   ) => Promise<TransactionCostEstimate>;
   getTokenPrice: (tokenSymbol: string) => Promise<number>;
+  getNativeGasCost: (deposit: Omit<Deposit, "messageHash">, relayer: string) => Promise<BigNumber>;
 }
 
 export const expectedCapitalCostsKeys = ["lowerBound", "upperBound", "cutoff", "decimals"];
@@ -105,6 +111,12 @@ export const DEFAULT_LOGGER: Logger = {
   error: (...args) => console.error(args),
 };
 
+export function getDefaultSimulatedRelayerAddress(chainId?: number) {
+  return isDefined(chainId) && chainIsSvm(chainId)
+    ? DEFAULT_SIMULATED_RELAYER_ADDRESS_SVM
+    : DEFAULT_SIMULATED_RELAYER_ADDRESS;
+}
+
 // Small amount to simulate filling with. Should be low enough to guarantee a successful fill.
 const safeOutputAmount = toBN(100);
 
@@ -241,7 +253,7 @@ export class RelayFeeCalculator {
     deposit: Deposit,
     amountToRelay: BigNumberish,
     simulateZeroFill = false,
-    relayerAddress = DEFAULT_SIMULATED_RELAYER_ADDRESS,
+    relayerAddress = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
     _tokenPrice?: number,
     tokenMapping = TOKEN_SYMBOLS_MAP,
     gasPrice?: BigNumberish,
@@ -480,7 +492,7 @@ export class RelayFeeCalculator {
     deposit: Deposit,
     amountToRelay?: BigNumberish,
     simulateZeroFill = false,
-    relayerAddress = DEFAULT_SIMULATED_RELAYER_ADDRESS,
+    relayerAddress = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
     _tokenPrice?: number,
     gasPrice?: BigNumberish,
     gasUnits?: BigNumberish,

package/src/utils/SpokeUtils.ts

@@ -1,4 +1,4 @@
-import { encodeAbiParameters, keccak256 } from "viem";
+import { encodeAbiParameters, Hex, keccak256 } from "viem";
 import { MAX_SAFE_DEPOSIT_ID, ZERO_ADDRESS, ZERO_BYTES } from "../constants";
 import { Deposit, RelayData } from "../interfaces";
 import { toBytes32 } from "./AddressUtils";
@@ -91,5 +91,5 @@ export function isZeroAddress(address: string): boolean {
 }
 
 export function getMessageHash(message: string): string {
-  return isMessageEmpty(message) ? ZERO_BYTES : keccak256(message as "0x{string}");
+  return isMessageEmpty(message) ? ZERO_BYTES : keccak256(message as Hex);
 }