viem 2.0.0-beta.1 → 2.0.0-beta.3

package/chains/opStack/actions/estimateL1Gas.ts

@@ -0,0 +1,138 @@
+import type { Address } from 'abitype'
+
+import { getChainId } from '../../../actions/public/getChainId.js'
+import {
+  type ReadContractErrorType,
+  readContract,
+} from '../../../actions/public/readContract.js'
+import {
+  type PrepareTransactionRequestErrorType,
+  type PrepareTransactionRequestParameters,
+  prepareTransactionRequest,
+} from '../../../actions/wallet/prepareTransactionRequest.js'
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import { maxInt256 } from '../../../constants/number.js'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Account, GetAccountParameter } from '../../../types/account.js'
+import { type Chain, type GetChain } from '../../../types/chain.js'
+import type { Signature } from '../../../types/misc.js'
+import type { TransactionRequestEIP1559 } from '../../../types/transaction.js'
+import type { RequestErrorType } from '../../../utils/buildRequest.js'
+import { getChainContractAddress } from '../../../utils/chain/getChainContractAddress.js'
+import { type HexToNumberErrorType } from '../../../utils/encoding/fromHex.js'
+import { numberToHex } from '../../../utils/encoding/toHex.js'
+import {
+  type AssertRequestErrorType,
+  assertRequest,
+} from '../../../utils/transaction/assertRequest.js'
+import {
+  type SerializeTransactionErrorType,
+  serializeTransaction,
+} from '../../../utils/transaction/serializeTransaction.js'
+import { gasPriceOracleAbi } from '../abis.js'
+import { contracts } from '../contracts.js'
+
+export type EstimateL1GasParameters<
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends Account | undefined = Account | undefined,
+  TChainOverride extends Chain | undefined = Chain | undefined,
+> = Omit<TransactionRequestEIP1559, 'from'> &
+  GetAccountParameter<TAccount> &
+  GetChain<TChain, TChainOverride> & {
+    /** Gas price oracle address. */
+    gasPriceOracleAddress?: Address
+  }
+
+export type EstimateL1GasReturnType = bigint
+
+export type EstimateL1GasErrorType =
+  | RequestErrorType
+  | PrepareTransactionRequestErrorType
+  | AssertRequestErrorType
+  | SerializeTransactionErrorType
+  | HexToNumberErrorType
+  | ReadContractErrorType
+  | ErrorType
+
+const stubSignature = {
+  r: numberToHex(maxInt256),
+  s: numberToHex(maxInt256),
+  v: 28n,
+} as const satisfies Signature
+
+/**
+ * Estimates the L1 data gas required to execute an L2 transaction.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link EstimateL1GasParameters}
+ * @returns The gas estimate. {@link EstimateL1GasReturnType}
+ *
+ * @example
+ * import { createPublicClient, http, parseEther } from 'viem'
+ * import { optimism } from 'viem/chains'
+ * import { estimateL1Gas } from 'viem/chains/optimism'
+ *
+ * const client = createPublicClient({
+ *   chain: optimism,
+ *   transport: http(),
+ * })
+ * const l1Gas = await estimateL1Gas(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: parseEther('1'),
+ * })
+ */
+export async function estimateL1Gas<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+  TChainOverride extends Chain | undefined = undefined,
+>(
+  client: Client<Transport, TChain, TAccount>,
+  args: EstimateL1GasParameters<TChain, TAccount, TChainOverride>,
+): Promise<EstimateL1GasReturnType> {
+  const {
+    chain = client.chain,
+    gasPriceOracleAddress: gasPriceOracleAddress_,
+  } = args
+
+  const gasPriceOracleAddress = (() => {
+    if (gasPriceOracleAddress_) return gasPriceOracleAddress_
+    if (chain)
+      return getChainContractAddress({
+        chain,
+        contract: 'gasPriceOracle',
+      })
+    return contracts.gasPriceOracle.address
+  })()
+
+  // Populate transaction with required fields to accurately estimate gas.
+  const [request, chainId] = await Promise.all([
+    prepareTransactionRequest(
+      client,
+      args as PrepareTransactionRequestParameters,
+    ),
+    (async () => {
+      if (chain) return chain.id
+      return getChainId(client)
+    })(),
+  ])
+
+  assertRequest(request)
+
+  const transaction = serializeTransaction(
+    {
+      ...request,
+      chainId,
+      type: 'eip1559',
+    },
+    stubSignature,
+  )
+
+  return readContract(client, {
+    abi: gasPriceOracleAbi,
+    address: gasPriceOracleAddress,
+    functionName: 'getL1GasUsed',
+    args: [transaction],
+  })
+}

package/chains/opStack/actions/estimateTotalFee.ts

@@ -0,0 +1,86 @@
+import {
+  type EstimateGasErrorType,
+  type EstimateGasParameters,
+  estimateGas,
+} from '../../../actions/public/estimateGas.js'
+import {
+  type GetGasPriceErrorType,
+  getGasPrice,
+} from '../../../actions/public/getGasPrice.js'
+import {
+  type PrepareTransactionRequestErrorType,
+  type PrepareTransactionRequestParameters,
+  prepareTransactionRequest,
+} from '../../../actions/wallet/prepareTransactionRequest.js'
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Account } from '../../../types/account.js'
+import { type Chain } from '../../../types/chain.js'
+import type { RequestErrorType } from '../../../utils/buildRequest.js'
+import {
+  type EstimateL1FeeErrorType,
+  type EstimateL1FeeParameters,
+  estimateL1Fee,
+} from './estimateL1Fee.js'
+
+export type EstimateTotalFeeParameters<
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends Account | undefined = Account | undefined,
+  TChainOverride extends Chain | undefined = Chain | undefined,
+> = EstimateL1FeeParameters<TChain, TAccount, TChainOverride>
+
+export type EstimateTotalFeeReturnType = bigint
+
+export type EstimateTotalFeeErrorType =
+  | RequestErrorType
+  | PrepareTransactionRequestErrorType
+  | EstimateL1FeeErrorType
+  | EstimateGasErrorType
+  | GetGasPriceErrorType
+  | ErrorType
+
+/**
+ * Estimates the L1 data fee + L2 fee to execute an L2 transaction.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link EstimateTotalFeeParameters}
+ * @returns The fee (in wei). {@link EstimateTotalFeeReturnType}
+ *
+ * @example
+ * import { createPublicClient, http, parseEther } from 'viem'
+ * import { optimism } from 'viem/chains'
+ * import { estimateTotalFee } from 'viem/chains/optimism'
+ *
+ * const client = createPublicClient({
+ *   chain: optimism,
+ *   transport: http(),
+ * })
+ * const totalGas = await estimateTotalFee(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: parseEther('1'),
+ * })
+ */
+export async function estimateTotalFee<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+  TChainOverride extends Chain | undefined = undefined,
+>(
+  client: Client<Transport, TChain, TAccount>,
+  args: EstimateTotalFeeParameters<TChain, TAccount, TChainOverride>,
+): Promise<EstimateTotalFeeReturnType> {
+  // Populate transaction with required fields to accurately estimate gas.
+  const request = await prepareTransactionRequest(
+    client,
+    args as PrepareTransactionRequestParameters,
+  )
+
+  const [l1Fee, l2Gas, l2GasPrice] = await Promise.all([
+    estimateL1Fee(client, request as EstimateL1FeeParameters),
+    estimateGas(client, request as EstimateGasParameters),
+    getGasPrice(client),
+  ])
+
+  return l1Fee + l2Gas * l2GasPrice
+}

package/chains/opStack/actions/estimateTotalGas.ts

@@ -0,0 +1,80 @@
+import {
+  type EstimateGasErrorType,
+  type EstimateGasParameters,
+  estimateGas,
+} from '../../../actions/public/estimateGas.js'
+import {
+  type PrepareTransactionRequestErrorType,
+  type PrepareTransactionRequestParameters,
+  prepareTransactionRequest,
+} from '../../../actions/wallet/prepareTransactionRequest.js'
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Account } from '../../../types/account.js'
+import { type Chain } from '../../../types/chain.js'
+import type { RequestErrorType } from '../../../utils/buildRequest.js'
+import {
+  type EstimateL1GasErrorType,
+  type EstimateL1GasParameters,
+  estimateL1Gas,
+} from './estimateL1Gas.js'
+
+export type EstimateTotalGasParameters<
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends Account | undefined = Account | undefined,
+  TChainOverride extends Chain | undefined = Chain | undefined,
+> = EstimateL1GasParameters<TChain, TAccount, TChainOverride>
+
+export type EstimateTotalGasReturnType = bigint
+
+export type EstimateTotalGasErrorType =
+  | RequestErrorType
+  | PrepareTransactionRequestErrorType
+  | EstimateL1GasErrorType
+  | EstimateGasErrorType
+  | ErrorType
+
+/**
+ * Estimates the amount of L1 data gas + L2 gas required to execute an L2 transaction.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link EstimateTotalGasParameters}
+ * @returns The gas estimate. {@link EstimateTotalGasReturnType}
+ *
+ * @example
+ * import { createPublicClient, http, parseEther } from 'viem'
+ * import { optimism } from 'viem/chains'
+ * import { estimateTotalGas } from 'viem/chains/optimism'
+ *
+ * const client = createPublicClient({
+ *   chain: optimism,
+ *   transport: http(),
+ * })
+ * const totalGas = await estimateTotalGas(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: parseEther('1'),
+ * })
+ */
+export async function estimateTotalGas<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+  TChainOverride extends Chain | undefined = undefined,
+>(
+  client: Client<Transport, TChain, TAccount>,
+  args: EstimateTotalGasParameters<TChain, TAccount, TChainOverride>,
+): Promise<EstimateTotalGasReturnType> {
+  // Populate transaction with required fields to accurately estimate gas.
+  const request = await prepareTransactionRequest(
+    client,
+    args as PrepareTransactionRequestParameters,
+  )
+
+  const [l1Gas, l2Gas] = await Promise.all([
+    estimateL1Gas(client, request as EstimateL1GasParameters),
+    estimateGas(client, request as EstimateGasParameters),
+  ])
+
+  return l1Gas + l2Gas
+}

package/chains/opStack/chainConfig.ts

@@ -0,0 +1,7 @@
+import { contracts } from './contracts.js'
+import { formatters } from './formatters.js'
+
+export const chainConfig = {
+  contracts,
+  formatters,
+} as const

package/chains/opStack/contracts.ts

@@ -0,0 +1,14 @@
+import type { Chain } from '../../types/chain.js'
+
+export const contracts = {
+  gasPriceOracle: { address: '0x420000000000000000000000000000000000000F' },
+  l1Block: { address: '0x4200000000000000000000000000000000000015' },
+  l2CrossDomainMessenger: {
+    address: '0x4200000000000000000000000000000000000007',
+  },
+  l2Erc721Bridge: { address: '0x4200000000000000000000000000000000000014' },
+  l2StandardBridge: { address: '0x4200000000000000000000000000000000000010' },
+  l2ToL1MessagePasser: {
+    address: '0x4200000000000000000000000000000000000016',
+  },
+} as const satisfies Chain['contracts']

package/chains/opStack/decorators/public.ts

@@ -0,0 +1,337 @@
+import type { Abi } from 'abitype'
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import type { Account } from '../../../types/account.js'
+import type { Chain } from '../../../types/chain.js'
+import type {
+  ContractFunctionArgs,
+  ContractFunctionName,
+} from '../../../types/contract.js'
+import {
+  type EstimateContractL1FeeParameters,
+  type EstimateContractL1FeeReturnType,
+  estimateContractL1Fee,
+} from '../actions/estimateContractL1Fee.js'
+import {
+  type EstimateContractL1GasParameters,
+  type EstimateContractL1GasReturnType,
+  estimateContractL1Gas,
+} from '../actions/estimateContractL1Gas.js'
+import {
+  type EstimateContractTotalFeeParameters,
+  type EstimateContractTotalFeeReturnType,
+  estimateContractTotalFee,
+} from '../actions/estimateContractTotalFee.js'
+import {
+  type EstimateContractTotalGasParameters,
+  type EstimateContractTotalGasReturnType,
+  estimateContractTotalGas,
+} from '../actions/estimateContractTotalGas.js'
+import {
+  type EstimateL1FeeParameters,
+  type EstimateL1FeeReturnType,
+  estimateL1Fee,
+} from '../actions/estimateL1Fee.js'
+import {
+  type EstimateL1GasParameters,
+  type EstimateL1GasReturnType,
+  estimateL1Gas,
+} from '../actions/estimateL1Gas.js'
+import {
+  type EstimateTotalFeeParameters,
+  type EstimateTotalFeeReturnType,
+  estimateTotalFee,
+} from '../actions/estimateTotalFee.js'
+import {
+  type EstimateTotalGasParameters,
+  type EstimateTotalGasReturnType,
+  estimateTotalGas,
+} from '../actions/estimateTotalGas.js'
+
+export type OpStackPublicActions<
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+> = {
+  /**
+   * Estimates the L1 data fee required to execute an L2 contract write.
+   *
+   * @param client - Client to use
+   * @param parameters - {@link EstimateContractL1FeeParameters}
+   * @returns The gas estimate (in wei). {@link EstimateContractL1FeeReturnType}
+   *
+   * @example
+   * import { createPublicClient, http, parseAbi } from 'viem'
+   * import { optimism } from 'viem/chains'
+   * import { opStackPublicActions } from 'viem/op-stack'
+   *
+   * const client = createPublicClient({
+   *   chain: optimism,
+   *   transport: http(),
+   * }).extend(opStackPublicActions())
+   *
+   * const l1Fee = await client.estimateContractL1Fee({
+   *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+   *   abi: parseAbi(['function mint() public']),
+   *   functionName: 'mint',
+   *   account: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+   * })
+   */
+  estimateContractL1Fee: <
+    const abi extends Abi | readonly unknown[],
+    functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+    args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+    chainOverride extends Chain | undefined = undefined,
+  >(
+    parameters: EstimateContractL1FeeParameters<
+      abi,
+      functionName,
+      args,
+      chain,
+      account,
+      chainOverride
+    >,
+  ) => Promise<EstimateContractL1FeeReturnType>
+  /**
+   * Estimates the L1 data gas required to successfully execute a contract write function call.
+   *
+   * @param client - Client to use
+   * @param parameters - {@link EstimateContractL1GasParameters}
+   * @returns The gas estimate (in wei). {@link EstimateContractL1GasReturnType}
+   *
+   * @example
+   * import { createPublicClient, http, parseAbi } from 'viem'
+   * import { optimism } from 'viem/chains'
+   * import { opStackPublicActions } from 'viem/op-stack'
+   *
+   * const client = createPublicClient({
+   *   chain: optimism,
+   *   transport: http(),
+   * }).extend(opStackPublicActions())
+   *
+   * const l1Gas = await client.estimateContractL1Gas({
+   *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+   *   abi: parseAbi(['function mint() public']),
+   *   functionName: 'mint',
+   *   account: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+   * })
+   */
+  estimateContractL1Gas: <
+    const abi extends Abi | readonly unknown[],
+    functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+    args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+    chainOverride extends Chain | undefined = undefined,
+  >(
+    parameters: EstimateContractL1GasParameters<
+      abi,
+      functionName,
+      args,
+      chain,
+      account,
+      chainOverride
+    >,
+  ) => Promise<EstimateContractL1GasReturnType>
+  /**
+   * Estimates the L1 + L2 fee to execute an L2 contract write.
+   *
+   * @param client - Client to use
+   * @param parameters - {@link EstimateContractTotalFeeParameters}
+   * @returns The gas estimate (in wei). {@link EstimateContractTotalFeeReturnType}
+   *
+   * @example
+   * import { createPublicClient, http, parseAbi } from 'viem'
+   * import { optimism } from 'viem/chains'
+   * import { opStackPublicActions } from 'viem/op-stack'
+   *
+   * const client = createPublicClient({
+   *   chain: optimism,
+   *   transport: http(),
+   * }).extend(opStackPublicActions())
+   *
+   * const totalFee = await client.estimateContractTotalFee({
+   *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+   *   abi: parseAbi(['function mint() public']),
+   *   functionName: 'mint',
+   *   account: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+   * })
+   */
+  estimateContractTotalFee: <
+    const abi extends Abi | readonly unknown[],
+    functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+    args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+    chainOverride extends Chain | undefined = undefined,
+  >(
+    parameters: EstimateContractTotalFeeParameters<
+      abi,
+      functionName,
+      args,
+      chain,
+      account,
+      chainOverride
+    >,
+  ) => Promise<EstimateContractTotalFeeReturnType>
+  /**
+   * Estimates the L1 data gas + L2 gas required to successfully execute a contract write function call.
+   *
+   * @param client - Client to use
+   * @param parameters - {@link EstimateContractTotalGasParameters}
+   * @returns The gas estimate (in wei). {@link EstimateContractTotalGasReturnType}
+   *
+   * @example
+   * import { createPublicClient, http, parseAbi } from 'viem'
+   * import { optimism } from 'viem/chains'
+   * import { opStackPublicActions } from 'viem/op-stack'
+   *
+   * const client = createPublicClient({
+   *   chain: optimism,
+   *   transport: http(),
+   * }).extend(opStackPublicActions())
+   *
+   * const totalGas = await client.estimateContractTotalGas({
+   *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+   *   abi: parseAbi(['function mint() public']),
+   *   functionName: 'mint',
+   *   account: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+   * })
+   */
+  estimateContractTotalGas: <
+    const abi extends Abi | readonly unknown[],
+    functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+    args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+    chainOverride extends Chain | undefined = undefined,
+  >(
+    parameters: EstimateContractTotalGasParameters<
+      abi,
+      functionName,
+      args,
+      chain,
+      account,
+      chainOverride
+    >,
+  ) => Promise<EstimateContractTotalGasReturnType>
+  /**
+   * Estimates the L1 data fee required to execute an L2 transaction.
+   *
+   * @param client - Client to use
+   * @param parameters - {@link EstimateL1FeeParameters}
+   * @returns The fee (in wei). {@link EstimateL1FeeReturnType}
+   *
+   * @example
+   * import { createPublicClient, http, parseEther } from 'viem'
+   * import { optimism } from 'viem/chains'
+   * import { opStackPublicActions } from 'viem/op-stack'
+   *
+   * const client = createPublicClient({
+   *   chain: optimism,
+   *   transport: http(),
+   * }).extend(opStackPublicActions())
+   *
+   * const l1Fee = await client.estimateL1Fee({
+   *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *   value: parseEther('1'),
+   * })
+   */
+  estimateL1Fee: <chainOverride extends Chain | undefined = undefined>(
+    parameters: EstimateL1FeeParameters<chain, account, chainOverride>,
+  ) => Promise<EstimateL1FeeReturnType>
+  /**
+   * Estimates the amount of L1 data gas required to execute an L2 transaction.
+   *
+   * @param client - Client to use
+   * @param parameters - {@link EstimateL1GasParameters}
+   * @returns The gas estimate. {@link EstimateL1GasReturnType}
+   *
+   * @example
+   * import { createPublicClient, http, parseEther } from 'viem'
+   * import { optimism } from 'viem/chains'
+   * import { opStackPublicActions } from 'viem/op-stack'
+   *
+   * const client = createPublicClient({
+   *   chain: optimism,
+   *   transport: http(),
+   * }).extend(opStackPublicActions())
+   *
+   * const l1Gas = await client.estimateL1Gas({
+   *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *   value: parseEther('1'),
+   * })
+   */
+  estimateL1Gas: <chainOverride extends Chain | undefined = undefined>(
+    parameters: EstimateL1GasParameters<chain, account, chainOverride>,
+  ) => Promise<EstimateL1GasReturnType>
+  /**
+   * Estimates the L1 data fee + L2 fee to execute an L2 transaction.
+   *
+   * @param client - Client to use
+   * @param parameters - {@link EstimateTotalFeeParameters}
+   * @returns The gas estimate. {@link EstimateTotalFeeReturnType}
+   *
+   * @example
+   * import { createPublicClient, http, parseEther } from 'viem'
+   * import { optimism } from 'viem/chains'
+   * import { opStackPublicActions } from 'viem/op-stack'
+   *
+   * const client = createPublicClient({
+   *   chain: optimism,
+   *   transport: http(),
+   * }).extend(opStackPublicActions())
+   *
+   * const totalFee = await client.estimateTotalFee({
+   *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *   value: parseEther('1'),
+   * })
+   */
+  estimateTotalFee: <chainOverride extends Chain | undefined = undefined>(
+    parameters: EstimateTotalFeeParameters<chain, account, chainOverride>,
+  ) => Promise<EstimateTotalFeeReturnType>
+  /**
+   * Estimates the total amount of combined L1 data gas + L2 gas required to execute an L2 transaction.
+   *
+   * @param client - Client to use
+   * @param parameters - {@link EstimateTotalGasParameters}
+   * @returns The gas estimate. {@link EstimateTotalGasReturnType}
+   *
+   * @example
+   * import { createPublicClient, http, parseEther } from 'viem'
+   * import { optimism } from 'viem/chains'
+   * import { opStackPublicActions } from 'viem/op-stack'
+   *
+   * const client = createPublicClient({
+   *   chain: optimism,
+   *   transport: http(),
+   * }).extend(opStackPublicActions())
+   *
+   * const totalGas = await client.estimateTotalGas({
+   *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *   value: parseEther('1'),
+   * })
+   */
+  estimateTotalGas: <chainOverride extends Chain | undefined = undefined>(
+    parameters: EstimateTotalGasParameters<chain, account, chainOverride>,
+  ) => Promise<EstimateTotalGasReturnType>
+}
+
+export function opStackPublicActions() {
+  return <
+    TChain extends Chain | undefined = Chain | undefined,
+    TAccount extends Account | undefined = Account | undefined,
+  >(
+    client: Client<Transport, TChain, TAccount>,
+  ): OpStackPublicActions<TChain, TAccount> => {
+    return {
+      estimateContractL1Fee: (args) => estimateContractL1Fee(client, args),
+      estimateContractL1Gas: (args) => estimateContractL1Gas(client, args),
+      estimateContractTotalFee: (args) =>
+        estimateContractTotalFee(client, args),
+      estimateContractTotalGas: (args) =>
+        estimateContractTotalGas(client, args),
+      estimateL1Fee: (args) => estimateL1Fee(client, args),
+      estimateL1Gas: (args) => estimateL1Gas(client, args),
+      estimateTotalFee: (args) => estimateTotalFee(client, args),
+      estimateTotalGas: (args) => estimateTotalGas(client, args),
+    }
+  }
+}