@across-protocol/sdk 4.1.63 → 4.2.0

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,12 +17,12 @@ 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 } from "../../gasPriceOracle/oracle";
+import { getGasPriceEstimate, EvmGasPriceEstimate } from "../../gasPriceOracle";
 type Provider = providers.Provider;
 type OptimismProvider = L2Provider<Provider>;
-type SymbolMappingType = Record<
+export type SymbolMappingType = Record<
   string,
   {
     addresses: Record<number, string>;
@@ -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;
@@ -213,7 +213,9 @@ export class QueryBase implements QueryInterface {
         ? Promise.resolve({ maxFeePerGas: _gasPrice })
         : getGasPriceEstimate(provider, { chainId, baseFeeMultiplier, priorityFeeMultiplier, transport, unsignedTx }),
     ] as const;
-    const [nativeGasCost, { maxFeePerGas: gasPrice }] = await Promise.all(queries);
+    const [nativeGasCost, _gasPriceEstimate] = await Promise.all(queries);
+    // It should be safe to cast to an EvmGasPriceEstimate here since QueryBase is only used for EVM chains.
+    const gasPrice = (_gasPriceEstimate as EvmGasPriceEstimate).maxFeePerGas;
     assert(nativeGasCost.gt(bnZero), "Gas cost should not be 0");
     let tokenGasCost: BigNumber;
 

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

@@ -3,11 +3,13 @@ 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 { chainIsOPStack, isDefined } from "../../utils";
+import { CUSTOM_GAS_TOKENS } from "../../constants";
+import { chainIsOPStack, isDefined, chainIsSvm, SvmAddress } from "../../utils";
 import { QueryBase } from "./baseQuery";
-import { DEFAULT_LOGGER, Logger } from "../relayFeeCalculator";
+import { SVMProvider as svmProvider } from "../../arch/svm";
+import { DEFAULT_LOGGER, getDefaultSimulatedRelayerAddress, Logger } from "../relayFeeCalculator";
 import { CustomGasTokenQueries } from "./customGasToken";
+import { SvmQuery } from "./svmQuery";
 
 /**
  * Some chains have a fixed gas price that is applied to the gas estimates. We should override
@@ -20,21 +22,21 @@ const fixedGasPrice = {
 export class QueryBase__factory {
   static create(
     chainId: number,
-    provider: providers.Provider,
+    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"
-  ): QueryBase {
+  ): QueryBase | SvmQuery {
     assert(isDefined(spokePoolAddress));
 
     const customGasTokenSymbol = CUSTOM_GAS_TOKENS[chainId];
     if (customGasTokenSymbol) {
       return new CustomGasTokenQueries({
         queryBaseArgs: [
-          provider,
+          provider as providers.Provider,
           symbolMapping,
           spokePoolAddress,
           simulatedRelayerAddress,
@@ -46,9 +48,23 @@ export class QueryBase__factory {
         customGasTokenSymbol,
       });
     }
+    if (chainIsSvm(chainId)) {
+      return new SvmQuery(
+        provider as svmProvider,
+        symbolMapping,
+        SvmAddress.from(spokePoolAddress),
+        SvmAddress.from(simulatedRelayerAddress),
+        logger,
+        coingeckoProApiKey,
+        fixedGasPrice[chainId],
+        coingeckoBaseCurrency
+      );
+    }
 
     // For OPStack chains, we need to wrap the provider in an L2Provider
-    provider = chainIsOPStack(chainId) ? asL2Provider(provider) : provider;
+    provider = chainIsOPStack(chainId)
+      ? asL2Provider(provider as providers.Provider)
+      : (provider as providers.Provider);
 
     return new QueryBase(
       provider,

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

@@ -1,3 +1,4 @@
 export * from "./baseQuery";
 export * from "./factory";
 export * from "./customGasToken";
+export * from "./svmQuery";

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

@@ -0,0 +1,225 @@
+import { pipe } from "@solana/functional";
+import { Coingecko } from "../../coingecko";
+import { SymbolMappingType } from "./";
+import { CHAIN_IDs } from "../../constants";
+import { Deposit } from "../../interfaces";
+import { getGasPriceEstimate, SvmGasPriceEstimate } from "../../gasPriceOracle";
+import {
+  BigNumberish,
+  TransactionCostEstimate,
+  BigNumber,
+  SvmAddress,
+  toBN,
+  isDefined,
+  toAddressType,
+} from "../../utils";
+import { getDefaultSimulatedRelayerAddress, Logger, QueryInterface } from "../relayFeeCalculator";
+import {
+  fillRelayInstruction,
+  createApproveInstruction,
+  createTokenAccountsInstruction,
+  SVMProvider,
+  SolanaVoidSigner,
+  getAssociatedTokenAddress,
+} from "../../arch/svm";
+import {
+  createTransactionMessage,
+  setTransactionMessageFeePayer,
+  setTransactionMessageLifetimeUsingBlockhash,
+  appendTransactionMessageInstructions,
+  getComputeUnitEstimateForTransactionMessageFactory,
+  fetchEncodedAccount,
+  IInstruction,
+} from "@solana/kit";
+import { TOKEN_PROGRAM_ADDRESS, getMintSize, getInitializeMintInstruction, fetchMint } from "@solana-program/token";
+import { getCreateAccountInstruction } from "@solana-program/system";
+
+/**
+ * A special QueryBase implementation for SVM used for querying gas costs, token prices, and decimals of various tokens
+ * on Solana.
+ */
+export class SvmQuery implements QueryInterface {
+  protected computeUnitEstimator;
+
+  /**
+   * Instantiates a SvmQuery instance
+   * @param provider A valid solana/kit rpc client.
+   * @param symbolMapping A mapping to valid ERC20 tokens and their respective characteristics
+   * @param spokePoolAddress The valid address of the Spoke Pool deployment
+   * @param simulatedRelayerAddress The address that these queries will reference as the sender. Note: This address must be approved for USDC
+   * @param logger A logging utility to report logs
+   * @param coingeckoProApiKey An optional CoinGecko API key that links to a PRO account
+   * @param fixedGasPrice Overrides the gas price with a fixed value. Note: primarily used for the Boba blockchain
+   * @param coingeckoBaseCurrency The basis currency that CoinGecko will use to resolve pricing
+   */
+  constructor(
+    readonly provider: SVMProvider,
+    readonly symbolMapping: SymbolMappingType,
+    readonly spokePoolAddress: SvmAddress,
+    readonly simulatedRelayerAddress: SvmAddress,
+    readonly logger: Logger,
+    readonly coingeckoProApiKey?: string,
+    readonly fixedGasPrice?: BigNumberish,
+    readonly coingeckoBaseCurrency: string = "eth"
+  ) {
+    this.computeUnitEstimator = getComputeUnitEstimateForTransactionMessageFactory({
+      rpc: provider,
+    });
+  }
+
+  /**
+   * Retrieves the current gas costs of performing a fillRelay contract at the referenced SpokePool.
+   * @param deposit V3 deposit instance.
+   * @param relayerAddress Relayer address to simulate with.
+   * @param options
+   * @param options.gasPrice Optional gas price to use for the simulation.
+   * @param options.gasUnits Optional gas units to use for the simulation.
+   * @param options.transport Optional transport object for custom gas price retrieval.
+   * @returns The gas estimate for this function call (multiplied with the optional buffer).
+   */
+  async getGasCosts(
+    deposit: Omit<Deposit, "messageHash">,
+    _relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
+    options: Partial<{
+      gasPrice: BigNumberish;
+      gasUnits: BigNumberish;
+      baseFeeMultiplier: BigNumber;
+      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(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;
+    const [associatedTokenAccountExists, mintInfo] = await Promise.all([
+      (await fetchEncodedAccount(this.provider, associatedToken)).exists,
+      fetchMint(this.provider, mint.toV2Address()),
+    ]);
+    if (!associatedTokenAccountExists) {
+      const space = BigInt(getMintSize());
+      const rent = await this.provider.getMinimumBalanceForRentExemption(space).send();
+      const createAccountIx = getCreateAccountInstruction({
+        payer: simulatedSigner,
+        newAccount: SolanaVoidSigner(mint.toBase58()),
+        lamports: rent,
+        space,
+        programAddress: TOKEN_PROGRAM_ADDRESS,
+      });
+
+      const initializeMintIx = getInitializeMintInstruction({
+        mint: mint.toV2Address(),
+        decimals: mintInfo.data.decimals,
+        mintAuthority: owner.toV2Address(),
+      });
+      recipientCreateTokenAccountInstructions = [createAccountIx, initializeMintIx];
+    }
+
+    const [createTokenAccountsIx, approveIx, fillIx] = await Promise.all([
+      createTokenAccountsInstruction(mint, simulatedSigner),
+      createApproveInstruction(
+        mint,
+        deposit.outputAmount,
+        this.simulatedRelayerAddress,
+        this.spokePoolAddress,
+        mintInfo.data.decimals
+      ),
+      fillRelayInstruction(this.spokePoolAddress, deposit, simulatedSigner, associatedToken),
+    ]);
+
+    // Get the most recent confirmed blockhash.
+    const recentBlockhash = await this.provider.getLatestBlockhash().send();
+    const fillRelayTx = pipe(
+      createTransactionMessage({ version: 0 }),
+      (tx) => setTransactionMessageFeePayer(relayer.toV2Address(), tx),
+      (tx) => setTransactionMessageLifetimeUsingBlockhash(recentBlockhash.value, tx),
+      (tx) =>
+        isDefined(recipientCreateTokenAccountInstructions)
+          ? appendTransactionMessageInstructions(recipientCreateTokenAccountInstructions, tx)
+          : tx,
+      (tx) => appendTransactionMessageInstructions([createTokenAccountsIx, approveIx, fillIx], tx)
+    );
+    return fillRelayTx;
+  }
+
+  /**
+   * Retrieves the current price of a token
+   * @param tokenSymbol A valid [CoinGecko-ID](https://api.coingecko.com/api/v3/coins/list)
+   * @returns The resolved token price within the specified coingeckoBaseCurrency
+   */
+  async getTokenPrice(tokenSymbol: string): Promise<number> {
+    if (!this.symbolMapping[tokenSymbol]) throw new Error(`${tokenSymbol} does not exist in mapping`);
+    const coingeckoInstance = Coingecko.get(this.logger, this.coingeckoProApiKey);
+    const [, price] = await coingeckoInstance.getCurrentPriceByContract(
+      this.symbolMapping[tokenSymbol].addresses[CHAIN_IDs.MAINNET],
+      this.coingeckoBaseCurrency
+    );
+    return price;
+  }
+
+  /**
+   * Resolves the number of decimal places a token can have
+   * @param tokenSymbol A valid Across-Enabled Token ID
+   * @returns The number of decimals of precision for the corresponding tokenSymbol
+   */
+  getTokenDecimals(tokenSymbol: string): number {
+    if (!this.symbolMapping[tokenSymbol]) throw new Error(`${tokenSymbol} does not exist in mapping`);
+    return this.symbolMapping[tokenSymbol].decimals;
+  }
+}

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/AddressUtils.ts

@@ -1,5 +1,6 @@
 import { providers, utils } from "ethers";
 import bs58 from "bs58";
+import { Address as V2Address } from "@solana/kit";
 import { BigNumber, chainIsEvm } from "./";
 
 /**
@@ -77,9 +78,9 @@ export function isValidEvmAddress(address: string): boolean {
  * @returns a child `Address` type most fitting for the chain ID.
  * @todo: Change this to `toAddress` once we remove the other `toAddress` function.
  */
-export function toAddressType(address: string, chainId: number): Address | EvmAddress | SvmAddress {
+export function toAddressType(address: string): Address | EvmAddress | SvmAddress {
   try {
-    if (chainIsEvm(chainId)) {
+    if (utils.isHexString(address)) {
       return EvmAddress.from(address);
     }
     return SvmAddress.from(address);
@@ -146,6 +147,11 @@ export class Address {
     return this.toBytes32();
   }
 
+  // Converts the address to a Buffer type.
+  toBuffer(): Buffer {
+    return Buffer.from(this.rawAddress);
+  }
+
   // Implements `Hexable` for `Address`. Needed for encoding purposes. This class is treated by default as a bytes32 primitive type, but can change for subclasses.
   toHexString(): string {
     return this.toBytes32();
@@ -185,6 +191,16 @@ export class Address {
     return utils.stripZeros(this.rawAddress).length === 0;
   }
 
+  // Forces `rawAddress` to become an SvmAddress type. This will only throw if `rawAddress.length > 32`.
+  forceSvmAddress(): SvmAddress {
+    return SvmAddress.from(this.toBase58());
+  }
+
+  // Forces `rawAddress` to become an EvmAddress type. This will throw if `rawAddress.length > 20`.
+  forceEvmAddress(): EvmAddress {
+    return EvmAddress.from(this.toEvmAddress());
+  }
+
   // Checks if the other address is equivalent to this address.
   eq(other: Address): boolean {
     return this.toString() === other.toString();
@@ -223,8 +239,20 @@ export class EvmAddress extends Address {
   }
 
   // Constructs a new EvmAddress type.
-  static from(hexString: string): EvmAddress {
-    return new this(utils.arrayify(hexString));
+  static from(address: string, encoding: "base16" | "base58" = "base16"): EvmAddress {
+    if (encoding === "base16") {
+      return new this(utils.arrayify(address));
+    }
+
+    const decodedAddress = bs58.decode(address);
+    const padding = decodedAddress.subarray(0, 12);
+    const evmAddress = decodedAddress.subarray(12);
+
+    if (padding.length !== 12 || utils.stripZeros(padding).length !== 0 || evmAddress.length !== 20) {
+      throw new Error(`Not a valid base58-encoded EVM address: ${address}`);
+    }
+
+    return new this(evmAddress);
   }
 }
 
@@ -241,12 +269,27 @@ export class SvmAddress extends Address {
     return this.toBase58();
   }
 
+  // Small utility to convert an SvmAddress to a Solana Kit branded type.
+  toV2Address(): V2Address<string> {
+    return this.toBase58() as V2Address<string>;
+  }
+
+  // Forces an SvmAddress to an EVM address string by truncating the leading 12 bytes.
   override toEvmAddress(): string {
     return toAddress(`0x${this.toBytes32().slice(-40)}`);
   }
 
   // Constructs a new SvmAddress type.
-  static from(bs58Address: string): SvmAddress {
-    return new this(bs58.decode(bs58Address));
+  static from(address: string, encoding: "base58" | "base16" = "base58"): SvmAddress {
+    if (encoding === "base58") {
+      return new this(bs58.decode(address));
+    }
+
+    const decodedAddress = utils.arrayify(address);
+    if (decodedAddress.length !== 32) {
+      throw new Error(`Not a valid base16-encoded SVM address: ${address}`);
+    }
+
+    return new this(decodedAddress);
   }
 }

package/src/utils/ArrayUtils.ts

@@ -168,3 +168,15 @@ export function includesAsync<T>(
 export function isArrayOf<T>(array: unknown, predicate: (value: unknown) => value is T): array is T[] {
   return Array.isArray(array) && array.every(predicate);
 }
+
+/**
+ * Checks if a value is a Uint8Array.
+ * @param value The value to check.
+ * @returns True if the value is a Uint8Array, false otherwise.
+ */
+export function isUint8Array(value: unknown): value is Uint8Array {
+  return (
+    Array.isArray(value) &&
+    value.every((item) => typeof item === "number" && Number.isInteger(item) && item >= 0 && item < 256)
+  );
+}

package/src/utils/BlockFinder.ts

@@ -0,0 +1,26 @@
+export type BlockFinderOpts = {
+  highBlock?: number;
+  highBlockOffset?: number;
+  blockRange?: number;
+};
+
+export type BlockTimeAverage = {
+  average: number;
+  blockRange: number;
+  timestamp: number;
+};
+
+export interface Block {
+  hash: string;
+  number: number;
+  timestamp: number;
+}
+
+export type BlockFinderHints = {
+  lowBlock?: number;
+  highBlock?: number;
+};
+
+export abstract class BlockFinder<TBlock extends Block> {
+  abstract getBlockForTimestamp(timestamp: number | string, hints: BlockFinderHints): Promise<TBlock>;
+}