@across-protocol/sdk 3.2.13 → 3.2.14

package/src/coingecko/Coingecko.ts

@@ -29,6 +29,11 @@ type PriceCache = {
   };
 };
 
+type CGTokenPrice = {
+  [currency: string]: number;
+  last_updated_at: number;
+};
+
 // Singleton Coingecko class.
 export class Coingecko {
   private static instance: Coingecko | undefined;
@@ -118,38 +123,53 @@ export class Coingecko {
   getContractDetails(contract_address: string, platform_id = "ethereum") {
     return this.call(`coins/${platform_id}/contract/${contract_address.toLowerCase()}`);
   }
+
   async getCurrentPriceByContract(
-    contract_address: string,
+    contractAddress: string,
     currency = "usd",
     platform_id = "ethereum"
   ): Promise<[string, number]> {
     const priceCache: { [addr: string]: CoinGeckoPrice } = this.getPriceCache(currency, platform_id);
-    const now: number = msToS(Date.now());
-    let tokenPrice: CoinGeckoPrice | undefined = priceCache[contract_address];
+    let tokenPrice = this.getCachedAddressPrice(contractAddress, currency, platform_id);
+    if (tokenPrice === undefined) {
+      await this.getContractPrices([contractAddress], currency, platform_id);
+      tokenPrice = priceCache[contractAddress];
+    }
 
-    if (tokenPrice === undefined || tokenPrice.timestamp + this.maxPriceAge <= now) {
-      if (this.maxPriceAge > 0) {
+    assert(tokenPrice !== undefined);
+    return [tokenPrice.timestamp.toString(), tokenPrice.price];
+  }
+
+  async getCurrentPriceById(
+    contractAddress: string,
+    currency = "usd",
+    platform_id = "ethereum"
+  ): Promise<[string, number]> {
+    const priceCache: { [addr: string]: CoinGeckoPrice } = this.getPriceCache(currency, platform_id);
+    let tokenPrice = this.getCachedAddressPrice(contractAddress, currency, platform_id);
+    if (tokenPrice === undefined) {
+      const coingeckoId = getCoingeckoTokenIdByAddress(contractAddress);
+      // Build the path for the Coingecko API request
+      const result = await this.call(
+        `simple/price?ids=${coingeckoId}&vs_currencies=${currency}&include_last_updated_at=true`
+      );
+      const cgPrice = result?.[coingeckoId];
+      if (cgPrice === undefined || !cgPrice?.[currency]) {
+        const errMsg = `No price found for ${coingeckoId}`;
         this.logger.debug({
-          at: "Coingecko#getCurrentPriceByContract",
-          message: `Cache miss on ${platform_id}/${currency} for ${contract_address}`,
-          maxPriceAge: this.maxPriceAge,
-          tokenPrice: tokenPrice,
+          at: "Coingecko#getCurrentPriceById",
+          message: errMsg,
         });
+        throw new Error(errMsg);
+      } else {
+        this.updatePriceCache(cgPrice, contractAddress, currency, platform_id);
       }
-
-      await this.getContractPrices([contract_address], currency, platform_id);
-      tokenPrice = priceCache[contract_address];
-    } else {
-      this.logger.debug({
-        at: "Coingecko#getCurrentPriceByContract",
-        message: `Cache hit on token ${contract_address} (age ${now - tokenPrice.timestamp} S).`,
-        price: tokenPrice,
-      });
     }
-
+    tokenPrice = priceCache[contractAddress];
     assert(tokenPrice !== undefined);
     return [tokenPrice.timestamp.toString(), tokenPrice.price];
   }
+
   // Return an array of spot prices for an array of collateral addresses in one async call. Note we might in future
   // This was adapted from packages/merkle-distributor/kpi-options-helpers/calculate-uma-tvl.ts
   async getContractPrices(
@@ -176,10 +196,6 @@ export class Coingecko {
     });
 
     // annoying, but have to type this to iterate over entries
-    type CGTokenPrice = {
-      [currency: string]: number;
-      last_updated_at: number;
-    };
     type Result = {
       [address: string]: CGTokenPrice;
     };
@@ -195,7 +211,7 @@ export class Coingecko {
     } catch (err) {
       const errMsg = `Failed to retrieve ${platform_id}/${currency} prices (${err})`;
       this.logger.debug({
-        at: "Coingecko#getCurrentPriceByContract",
+        at: "Coingecko#getContractPrices",
         message: errMsg,
         tokens: contract_addresses,
       });
@@ -204,38 +220,17 @@ export class Coingecko {
 
     // Note: contract_addresses is a reliable reference for the price lookup.
     // priceCache might have been updated subsequently by concurrent price requests.
-    const updated: string[] = [];
     contract_addresses.forEach((addr) => {
       const cgPrice: CGTokenPrice | undefined = result[addr.toLowerCase()];
-
       if (cgPrice === undefined) {
         this.logger.debug({
           at: "Coingecko#getContractPrices",
           message: `Token ${addr} not included in CoinGecko response.`,
         });
-      } else if (cgPrice.last_updated_at > priceCache[addr].timestamp) {
-        priceCache[addr] = {
-          address: addr,
-          price: cgPrice[currency],
-          timestamp: cgPrice.last_updated_at,
-        };
-        updated.push(addr);
-      } else if (cgPrice.last_updated_at === priceCache[addr].timestamp) {
-        this.logger.debug({
-          at: "Coingecko#getContractPrices",
-          message: `No new price available for token ${addr}.`,
-          token: cgPrice,
-        });
+      } else {
+        this.updatePriceCache(cgPrice, addr, currency, platform_id);
       }
     });
-
-    if (updated.length > 0) {
-      this.logger.debug({
-        at: "Coingecko#updatePriceCache",
-        message: `Updated ${platform_id}/${currency} token price cache.`,
-        tokens: updated,
-      });
-    }
     return addresses.map((addr: string) => priceCache[addr]);
   }
 
@@ -275,6 +270,58 @@ export class Coingecko {
     return this.prices[platform_id][currency];
   }
 
+  protected getCachedAddressPrice(
+    contractAddress: string,
+    currency: string,
+    platform_id: string
+  ): CoinGeckoPrice | undefined {
+    const priceCache = this.getPriceCache(currency, platform_id);
+    const now: number = msToS(Date.now());
+    const tokenPrice: CoinGeckoPrice | undefined = priceCache[contractAddress];
+    if (tokenPrice === undefined || tokenPrice.timestamp + this.maxPriceAge <= now) {
+      if (this.maxPriceAge > 0) {
+        this.logger.debug({
+          at: "Coingecko#getCachedAddressPrice",
+          message: `Cache miss on ${platform_id}/${currency} for ${contractAddress}`,
+          maxPriceAge: this.maxPriceAge,
+          tokenPrice: tokenPrice,
+        });
+      }
+      return undefined;
+    } else {
+      this.logger.debug({
+        at: "Coingecko#getCachedAddressPrice",
+        message: `Cache hit on token ${contractAddress} (age ${now - tokenPrice.timestamp} S).`,
+        price: tokenPrice,
+      });
+      return tokenPrice;
+    }
+  }
+
+  protected updatePriceCache(cgPrice: CGTokenPrice, contractAddress: string, currency: string, platform_id: string) {
+    const priceCache = this.getPriceCache(currency, platform_id);
+    if (priceCache[contractAddress] === undefined) {
+      priceCache[contractAddress] = { address: contractAddress, price: 0, timestamp: 0 };
+    }
+    if (cgPrice.last_updated_at > priceCache[contractAddress].timestamp) {
+      priceCache[contractAddress] = {
+        address: contractAddress,
+        price: cgPrice[currency],
+        timestamp: cgPrice.last_updated_at,
+      };
+      this.logger.debug({
+        at: "Coingecko#updatePriceCache",
+        message: `Updated ${platform_id}/${currency}/${contractAddress} token price cache.`,
+      });
+    } else {
+      this.logger.debug({
+        at: "Coingecko#updatePriceCache",
+        message: `No new price available for token ${contractAddress}.`,
+        token: cgPrice,
+      });
+    }
+  }
+
   private async _callBasic(path: string, timeout?: number) {
     const url = `${this.host}/${path}`;
 

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

@@ -0,0 +1,13 @@
+import { PublicClient } from "viem";
+import { InternalGasPriceEstimate } from "../types";
+
+const MAX_PRIORITY_FEE_PER_GAS = BigInt(1);
+
+// Arbitrum Nitro implements EIP-1559 pricing, but the priority fee is always refunded to the caller.
+// Swap it for 1 Wei to avoid inaccurate transaction cost estimates.
+// Reference: https://developer.arbitrum.io/faqs/gas-faqs#q-priority
+export async function eip1559(provider: PublicClient, _chainId: number): Promise<InternalGasPriceEstimate> {
+  const { maxFeePerGas: _maxFeePerGas, maxPriorityFeePerGas } = await provider.estimateFeesPerGas();
+  const maxFeePerGas = BigInt(_maxFeePerGas) - maxPriorityFeePerGas + MAX_PRIORITY_FEE_PER_GAS;
+  return { maxFeePerGas, maxPriorityFeePerGas: MAX_PRIORITY_FEE_PER_GAS };
+}

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

@@ -0,0 +1,19 @@
+import { PublicClient } from "viem";
+import { InternalGasPriceEstimate } from "../types";
+
+export function eip1559(provider: PublicClient, _chainId: number): Promise<InternalGasPriceEstimate> {
+  return provider.estimateFeesPerGas();
+}
+
+export async function legacy(
+  provider: PublicClient,
+  _chainId: number,
+  _test?: number
+): Promise<InternalGasPriceEstimate> {
+  const gasPrice = await provider.getGasPrice();
+
+  return {
+    maxFeePerGas: gasPrice,
+    maxPriorityFeePerGas: BigInt(0),
+  };
+}

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

@@ -0,0 +1,86 @@
+import { PublicClient } from "viem";
+import { BaseHTTPAdapter, BaseHTTPAdapterArgs } from "../../priceClient/adapters/baseAdapter";
+import { isDefined } from "../../utils";
+import { CHAIN_IDs } from "../../constants";
+import { InternalGasPriceEstimate } from "../types";
+import { gasPriceError } from "../util";
+import { eip1559 } from "./ethereum-viem";
+
+type Polygon1559GasPrice = {
+  maxPriorityFee: number | string;
+  maxFee: number | string;
+};
+
+type GasStationV2Response = {
+  safeLow: Polygon1559GasPrice;
+  standard: Polygon1559GasPrice;
+  fast: Polygon1559GasPrice;
+  estimatedBaseFee: number | string;
+  blockTime: number | string;
+  blockNumber: number | string;
+};
+
+type GasStationArgs = BaseHTTPAdapterArgs & {
+  chainId?: number;
+  host?: string;
+};
+
+const { POLYGON } = CHAIN_IDs;
+
+const GWEI = BigInt(1_000_000_000);
+class PolygonGasStation extends BaseHTTPAdapter {
+  readonly chainId: number;
+
+  constructor({ chainId = POLYGON, host, timeout = 1500, retries = 1 }: GasStationArgs = {}) {
+    host = host ?? chainId === POLYGON ? "gasstation.polygon.technology" : "gasstation-testnet.polygon.technology";
+
+    super("Polygon Gas Station", host, { timeout, retries });
+    this.chainId = chainId;
+  }
+
+  async getFeeData(strategy: "safeLow" | "standard" | "fast" = "fast"): Promise<InternalGasPriceEstimate> {
+    const gas = await this.query("v2", {});
+
+    const gasPrice = (gas as GasStationV2Response)?.[strategy];
+    if (!this.isPolygon1559GasPrice(gasPrice)) {
+      // @todo: generalise gasPriceError() to accept a reason/cause?
+      gasPriceError("getFeeData()", this.chainId, gasPrice);
+    }
+
+    const maxPriorityFeePerGas = BigInt(gasPrice.maxPriorityFee) * GWEI;
+    const maxFeePerGas = BigInt(gasPrice.maxFee) * GWEI;
+
+    return { maxPriorityFeePerGas, maxFeePerGas };
+  }
+
+  protected isPolygon1559GasPrice(gasPrice: unknown): gasPrice is Polygon1559GasPrice {
+    if (!isDefined(gasPrice)) {
+      return false;
+    }
+    const _gasPrice = gasPrice as Polygon1559GasPrice;
+    return [_gasPrice.maxPriorityFee, _gasPrice.maxFee].every((field) => ["number", "string"].includes(typeof field));
+  }
+}
+
+export async function gasStation(provider: PublicClient, chainId: number): Promise<InternalGasPriceEstimate> {
+  const gasStation = new PolygonGasStation({ chainId, timeout: 2000, retries: 0 });
+  let maxPriorityFeePerGas: bigint;
+  let maxFeePerGas: bigint;
+  try {
+    ({ maxPriorityFeePerGas, maxFeePerGas } = await gasStation.getFeeData());
+  } catch (err) {
+    // Fall back to the RPC provider. May be less accurate.
+    ({ maxPriorityFeePerGas, maxFeePerGas } = await eip1559(provider, chainId));
+
+    // Per the GasStation docs, the minimum priority fee on Polygon is 30 Gwei.
+    // https://docs.polygon.technology/tools/gas/polygon-gas-station/#interpretation
+    const minPriorityFee = BigInt(30) * GWEI;
+    if (minPriorityFee > maxPriorityFeePerGas) {
+      const priorityDelta = minPriorityFee - maxPriorityFeePerGas;
+      maxPriorityFeePerGas = minPriorityFee;
+      maxFeePerGas = maxFeePerGas + priorityDelta;
+    }
+  }
+
+  return { maxPriorityFeePerGas, maxFeePerGas };
+}

package/src/gasPriceOracle/oracle.ts

@@ -1,11 +1,15 @@
+import { Transport } from "viem";
 import { providers } from "ethers";
 import { CHAIN_IDs } from "../constants";
-import { chainIsOPStack } from "../utils";
-import { GasPriceEstimate, GasPriceFeed } from "./types";
+import { BigNumber, chainIsOPStack } from "../utils";
+import { GasPriceEstimate } from "./types";
+import { getPublicClient } from "./util";
 import * as arbitrum from "./adapters/arbitrum";
 import * as ethereum from "./adapters/ethereum";
 import * as linea from "./adapters/linea";
 import * as polygon from "./adapters/polygon";
+import * as arbitrumViem from "./adapters/arbitrum-viem";
+import * as polygonViem from "./adapters/polygon-viem";
 
 /**
  * Provide an estimate for the current gas price for a particular chain.
@@ -17,17 +21,39 @@ import * as polygon from "./adapters/polygon";
 export async function getGasPriceEstimate(
   provider: providers.Provider,
   chainId?: number,
+  transport?: Transport,
   legacyFallback = true
 ): Promise<GasPriceEstimate> {
   if (chainId === undefined) {
     ({ chainId } = await provider.getNetwork());
   }
 
-  const gasPriceFeeds: { [chainId: number]: GasPriceFeed } = {
+  const useViem = process.env[`NEW_GAS_PRICE_ORACLE_${chainId}`] === "true";
+  return useViem
+    ? getViemGasPriceEstimate(chainId, transport)
+    : getEthersGasPriceEstimate(provider, chainId, legacyFallback);
+}
+
+/**
+ * Provide an estimate for the current gas price for a particular chain.
+ * @param chainId The chain ID to query for gas prices.
+ * @param provider A valid ethers provider.
+ * @param legacyFallback In the case of an unrecognised chain, fall back to type 0 gas estimation.
+ * @returns Am object of type GasPriceEstimate.
+ */
+async function getEthersGasPriceEstimate(
+  provider: providers.Provider,
+  chainId?: number,
+  legacyFallback = true
+): Promise<GasPriceEstimate> {
+  if (chainId === undefined) {
+    ({ chainId } = await provider.getNetwork());
+  }
+
+  const gasPriceFeeds = {
     [CHAIN_IDs.ALEPH_ZERO]: arbitrum.eip1559,
     [CHAIN_IDs.ARBITRUM]: arbitrum.eip1559,
     [CHAIN_IDs.BASE]: ethereum.eip1559,
-    [CHAIN_IDs.BOBA]: ethereum.legacy,
     [CHAIN_IDs.LINEA]: linea.eip1559, // @todo: Support linea_estimateGas in adapter.
     [CHAIN_IDs.MAINNET]: ethereum.eip1559,
     [CHAIN_IDs.MODE]: ethereum.eip1559,
@@ -35,7 +61,7 @@ export async function getGasPriceEstimate(
     [CHAIN_IDs.POLYGON]: polygon.gasStation,
     [CHAIN_IDs.ZK_SYNC]: ethereum.legacy,
     [CHAIN_IDs.SCROLL]: ethereum.legacy,
-  };
+  } as const;
 
   let gasPriceFeed = gasPriceFeeds[chainId];
   if (gasPriceFeed === undefined) {
@@ -47,3 +73,41 @@ export async function getGasPriceEstimate(
 
   return gasPriceFeed(provider, chainId);
 }
+
+/**
+ * Provide an estimate for the current gas price for a particular chain.
+ * @param providerOrChainId A valid ethers provider or a chain ID.
+ * @param transport An optional transport object for custom gas price retrieval.
+ * @returns Am object of type GasPriceEstimate.
+ */
+export async function getViemGasPriceEstimate(
+  providerOrChainId: providers.Provider | number,
+  transport?: Transport
+): Promise<GasPriceEstimate> {
+  const chainId =
+    typeof providerOrChainId === "number" ? providerOrChainId : (await providerOrChainId.getNetwork()).chainId;
+  const viemProvider = getPublicClient(chainId, transport);
+
+  const gasPriceFeeds = {
+    [CHAIN_IDs.ALEPH_ZERO]: arbitrumViem.eip1559,
+    [CHAIN_IDs.ARBITRUM]: arbitrumViem.eip1559,
+    [CHAIN_IDs.POLYGON]: polygonViem.gasStation,
+  } as const;
+
+  let maxFeePerGas: bigint;
+  let maxPriorityFeePerGas: bigint;
+  if (gasPriceFeeds[chainId]) {
+    ({ maxFeePerGas, maxPriorityFeePerGas } = await gasPriceFeeds[chainId](viemProvider, chainId));
+  } else {
+    let gasPrice: bigint | undefined;
+    ({ maxFeePerGas, maxPriorityFeePerGas, gasPrice } = await viemProvider.estimateFeesPerGas());
+
+    maxFeePerGas ??= gasPrice!;
+    maxPriorityFeePerGas ??= BigInt(0);
+  }
+
+  return {
+    maxFeePerGas: BigNumber.from(maxFeePerGas.toString()),
+    maxPriorityFeePerGas: BigNumber.from(maxPriorityFeePerGas.toString()),
+  };
+}

package/src/gasPriceOracle/types.ts

@@ -1,11 +1,13 @@
-import { providers } from "ethers";
+import { type Chain, type Transport, PublicClient, FeeValuesEIP1559 } from "viem";
 import { BigNumber } from "../utils";
 
+export type InternalGasPriceEstimate = FeeValuesEIP1559;
+
 export type GasPriceEstimate = {
   maxFeePerGas: BigNumber;
   maxPriorityFeePerGas: BigNumber;
 };
 
 export interface GasPriceFeed {
-  (provider: providers.Provider, chainId: number): Promise<GasPriceEstimate>;
+  (provider: PublicClient<Transport, Chain>, chainId: number): Promise<InternalGasPriceEstimate>;
 }

package/src/gasPriceOracle/util.ts

@@ -1,6 +1,15 @@
-import { providers } from "ethers";
-import { BigNumber } from "../utils";
+import assert from "assert";
+import { type Chain, type PublicClient, createPublicClient, http, Transport } from "viem";
+import * as chains from "viem/chains";
 
-export function gasPriceError(method: string, chainId: number, data: providers.FeeData | BigNumber): void {
+export function gasPriceError(method: string, chainId: number, data: unknown): void {
   throw new Error(`Malformed ${method} response on chain ID ${chainId} (${JSON.stringify(data)})`);
 }
+
+export function getPublicClient(chainId: number, transport?: Transport): PublicClient<Transport, Chain> {
+  transport ??= http(); // @todo: Inherit URL from provider.
+  const chain: Chain | undefined = Object.values(chains).find((chain) => chain.id === chainId);
+  assert(chain);
+
+  return createPublicClient({ chain, transport });
+}

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

@@ -14,6 +14,7 @@ import {
   toBNWei,
 } from "../../utils";
 import { Logger, QueryInterface } from "../relayFeeCalculator";
+import { Transport } from "viem";
 
 type Provider = providers.Provider;
 type OptimismProvider = L2Provider<Provider>;
@@ -61,17 +62,25 @@ export class QueryBase implements QueryInterface {
    * 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 gasPrice Optional gas price to use for the simulation.
-   * @param gasUnits Optional gas units to use for the simulation.
+   * @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.omitMarkup Optional flag to omit the gas markup.
+   * @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: Deposit,
     relayer = DEFAULT_SIMULATED_RELAYER_ADDRESS,
-    gasPrice = this.fixedGasPrice,
-    gasUnits?: BigNumberish,
-    omitMarkup?: boolean
+    options: Partial<{
+      gasPrice: BigNumberish;
+      gasUnits: BigNumberish;
+      omitMarkup: boolean;
+      transport: Transport;
+    }> = {}
   ): Promise<TransactionCostEstimate> {
+    const { gasPrice = this.fixedGasPrice, gasUnits, omitMarkup, transport } = options;
+
     const gasMarkup = omitMarkup ? 0 : this.gasMarkup;
     assert(
       gasMarkup > -1 && gasMarkup <= 4,
@@ -84,8 +93,11 @@ export class QueryBase implements QueryInterface {
       tx,
       relayer,
       this.provider,
-      gasPrice,
-      gasUnits
+      {
+        gasPrice,
+        gasUnits,
+        transport,
+      }
     );
 
     return {

package/src/relayFeeCalculator/relayFeeCalculator.ts

@@ -17,14 +17,14 @@ import {
   toBN,
   toBNWei,
 } from "../utils";
+import { Transport } from "viem";
 
 // This needs to be implemented for every chain and passed into RelayFeeCalculator
 export interface QueryInterface {
   getGasCosts: (
     deposit: Deposit,
     relayer: string,
-    gasPrice?: BigNumberish,
-    gasLimit?: BigNumberish
+    options?: Partial<{ gasPrice: BigNumberish; gasUnits: BigNumberish; omitMarkup: boolean; transport: Transport }>
   ) => Promise<TransactionCostEstimate>;
   getTokenPrice: (tokenSymbol: string) => Promise<number>;
   getTokenDecimals: (tokenSymbol: string) => number;
@@ -230,7 +230,8 @@ export class RelayFeeCalculator {
     _tokenPrice?: number,
     tokenMapping = TOKEN_SYMBOLS_MAP,
     gasPrice?: BigNumberish,
-    gasLimit?: BigNumberish
+    gasLimit?: BigNumberish,
+    transport?: Transport
   ): Promise<BigNumber> {
     if (toBN(amountToRelay).eq(bnZero)) return MAX_BIG_INT;
 
@@ -245,16 +246,18 @@ export class RelayFeeCalculator {
     const simulatedAmount = simulateZeroFill ? safeOutputAmount : toBN(amountToRelay);
     deposit = { ...deposit, outputAmount: simulatedAmount };
 
-    const getGasCosts = this.queries.getGasCosts(deposit, relayerAddress, gasPrice, gasLimit).catch((error) => {
-      this.logger.error({
-        at: "sdk/gasFeePercent",
-        message: "Error while fetching gas costs",
-        error,
-        simulateZeroFill,
-        deposit,
+    const getGasCosts = this.queries
+      .getGasCosts(deposit, relayerAddress, { gasPrice, gasUnits: gasLimit, transport })
+      .catch((error) => {
+        this.logger.error({
+          at: "sdk/gasFeePercent",
+          message: "Error while fetching gas costs",
+          error,
+          simulateZeroFill,
+          deposit,
+        });
+        throw error;
       });
-      throw error;
-    });
     const [{ tokenGasCost }, tokenPrice] = await Promise.all([
       getGasCosts,
       _tokenPrice ??

package/src/utils/common.ts

@@ -8,6 +8,7 @@ import { TypedMessage } from "../interfaces/TypedData";
 import { BigNumber, BigNumberish, BN, formatUnits, parseUnits, toBN } from "./BigNumberUtils";
 import { ConvertDecimals } from "./FormattingUtils";
 import { chainIsOPStack } from "./NetworkUtils";
+import { Transport } from "viem";
 
 export type Decimalish = string | number | Decimal;
 export const AddressZero = ethers.constants.AddressZero;
@@ -239,17 +240,24 @@ export type TransactionCostEstimate = {
  * @param unsignedTx The unsigned transaction that this function will estimate.
  * @param senderAddress The address that the transaction will be submitted from.
  * @param provider A valid ethers provider - will be used to reason the gas price.
- * @param gasPrice A manually provided gas price - if set, this function will not resolve the current gas price.
- * @param gasUnits A manually provided gas units - if set, this function will not estimate the gas units.
+ * @param options
+ * @param options.gasPrice A manually provided gas price - if set, this function will not resolve the current gas price.
+ * @param options.gasUnits A manually provided gas units - if set, this function will not estimate the gas units.
+ * @param options.transport A custom transport object for custom gas price retrieval.
  * @returns Estimated cost in units of gas and the underlying gas token (gasPrice * estimatedGasUnits).
  */
 export async function estimateTotalGasRequiredByUnsignedTransaction(
   unsignedTx: PopulatedTransaction,
   senderAddress: string,
   provider: providers.Provider | L2Provider<providers.Provider>,
-  gasPrice?: BigNumberish,
-  gasUnits?: BigNumberish
+  options: Partial<{
+    gasPrice: BigNumberish;
+    gasUnits: BigNumberish;
+    transport: Transport;
+  }> = {}
 ): Promise<TransactionCostEstimate> {
+  const { gasPrice: _gasPrice, gasUnits, transport } = options || {};
+
   const { chainId } = await provider.getNetwork();
   const voidSigner = new VoidSigner(senderAddress, provider);
 
@@ -268,13 +276,14 @@ export async function estimateTotalGasRequiredByUnsignedTransaction(
     // `provider.estimateTotalGasCost` to improve performance.
     const [l1GasCost, l2GasPrice] = await Promise.all([
       provider.estimateL1GasCost(populatedTransaction),
-      gasPrice || provider.getGasPrice(),
+      _gasPrice || provider.getGasPrice(),
     ]);
     const l2GasCost = nativeGasCost.mul(l2GasPrice);
     tokenGasCost = l1GasCost.add(l2GasCost);
   } else {
+    let gasPrice = _gasPrice;
     if (!gasPrice) {
-      const gasPriceEstimate = await getGasPriceEstimate(provider, chainId);
+      const gasPriceEstimate = await getGasPriceEstimate(provider, chainId, transport);
       gasPrice = gasPriceEstimate.maxFeePerGas;
     }
     tokenGasCost = nativeGasCost.mul(gasPrice);