viem 2.40.3 → 2.41.1

package/chains/definitions/reactiveTestnet.ts

@@ -0,0 +1,21 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const reactiveTestnet = /*#__PURE__*/ defineChain({
+  id: 5_318_007,
+  name: 'Reactive Lasna Testnet',
+  nativeCurrency: {
+    decimals: 18,
+    name: 'Lasna React',
+    symbol: 'lREACT',
+  },
+  rpcUrls: {
+    default: { http: ['https://lasna-rpc.rnk.dev'] },
+  },
+  blockExplorers: {
+    default: {
+      name: 'Reactscan',
+      url: 'https://lasna.reactscan.net',
+    },
+  },
+  testnet: true,
+})

package/chains/index.ts

@@ -479,6 +479,7 @@ export { qMainnet } from './definitions/qMainnet.js'
 export { qTestnet } from './definitions/qTestnet.js'
 export { quai } from './definitions/quai.js'
 export { quaiTestnet } from './definitions/quaiTestnet.js'
+export { reactiveTestnet } from './definitions/reactiveTestnet.js'
 export { real } from './definitions/real.js'
 export { redbellyMainnet } from './definitions/redbellyMainnet.js'
 export { redbellyTestnet } from './definitions/redbellyTestnet.js'

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.40.3'
+export const version = '2.41.1'

package/op-stack/abis.ts

@@ -76,6 +76,27 @@ export const gasPriceOracleAbi = [
   },
 ] as const
 
+/**
+ * ABI for the OP Stack [`L1Block` contract](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/L2/L1Block.sol).
+ * @see https://optimistic.etherscan.io/address/0x4200000000000000000000000000000000000015
+ */
+export const l1BlockAbi = [
+  {
+    inputs: [],
+    name: 'operatorFeeScalar',
+    outputs: [{ internalType: 'uint32', name: '', type: 'uint32' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'operatorFeeConstant',
+    outputs: [{ internalType: 'uint64', name: '', type: 'uint64' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+] as const
+
 export const l2OutputOracleAbi = [
   {
     inputs: [

package/op-stack/actions/depositTransaction.ts

@@ -20,11 +20,7 @@ import type { FormattedTransactionRequest } from '../../utils/formatters/transac
 import { portalAbi } from '../abis.js'
 import type { GetContractAddressParameter } from '../types/contract.js'
 import type { DepositRequest } from '../types/deposit.js'
-import {
-  type EstimateDepositTransactionGasErrorType,
-  type EstimateDepositTransactionGasParameters,
-  estimateDepositTransactionGas,
-} from './estimateDepositTransactionGas.js'
+import type { EstimateDepositTransactionGasErrorType } from './estimateDepositTransactionGas.js'
 
 export type DepositTransactionParameters<
   chain extends Chain | undefined = Chain | undefined,
@@ -147,14 +143,6 @@ export async function depositTransaction<
     return Object.values(targetChain!.contracts.portal)[0].address
   })()
 
-  const gas_ =
-    typeof gas !== 'number' && gas !== null
-      ? await estimateDepositTransactionGas(
-          client,
-          parameters as EstimateDepositTransactionGasParameters,
-        )
-      : undefined
-
   return writeContract(client, {
     account: account!,
     abi: portalAbi,
@@ -172,6 +160,6 @@ export async function depositTransaction<
     maxPriorityFeePerGas,
     nonce,
     value: mint,
-    gas: gas_,
+    gas: gas ?? undefined,
   } satisfies WriteContractParameters as any)
 }

package/op-stack/actions/estimateOperatorFee.ts

@@ -0,0 +1,119 @@
+import type { Address } from 'abitype'
+
+import {
+  type EstimateGasErrorType,
+  type EstimateGasParameters,
+  estimateGas,
+} from '../../actions/public/estimateGas.js'
+import {
+  type ReadContractErrorType,
+  readContract,
+} from '../../actions/public/readContract.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, GetAccountParameter } from '../../types/account.js'
+import type { Chain, GetChainParameter } from '../../types/chain.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 { l1BlockAbi } from '../abis.js'
+import { contracts } from '../contracts.js'
+
+export type EstimateOperatorFeeParameters<
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends Account | undefined = Account | undefined,
+  TChainOverride extends Chain | undefined = undefined,
+> = Omit<TransactionRequestEIP1559, 'from'> &
+  GetAccountParameter<TAccount> &
+  GetChainParameter<TChain, TChainOverride> & {
+    /** L1 block attributes contract address. */
+    l1BlockAddress?: Address | undefined
+  }
+
+export type EstimateOperatorFeeReturnType = bigint
+
+export type EstimateOperatorFeeErrorType =
+  | RequestErrorType
+  | EstimateGasErrorType
+  | HexToNumberErrorType
+  | ReadContractErrorType
+  | ErrorType
+
+/**
+ * Estimates the operator fee required to execute an L2 transaction.
+ *
+ * Operator fees are part of the Isthmus upgrade and allow OP Stack operators
+ * to recover costs related to Alt-DA, ZK proving, or custom gas tokens.
+ * Returns 0 for pre-Isthmus chains or when operator fee functions don't exist.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link EstimateOperatorFeeParameters}
+ * @returns The operator fee (in wei). {@link EstimateOperatorFeeReturnType}
+ *
+ * @example
+ * import { createPublicClient, http, parseEther } from 'viem'
+ * import { optimism } from 'viem/chains'
+ * import { estimateOperatorFee } from 'viem/chains/optimism'
+ *
+ * const client = createPublicClient({
+ *   chain: optimism,
+ *   transport: http(),
+ * })
+ * const operatorFee = await estimateOperatorFee(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: parseEther('1'),
+ * })
+ */
+export async function estimateOperatorFee<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+  TChainOverride extends Chain | undefined = undefined,
+>(
+  client: Client<Transport, TChain, TAccount>,
+  args: EstimateOperatorFeeParameters<TChain, TAccount, TChainOverride>,
+): Promise<EstimateOperatorFeeReturnType> {
+  const { chain = client.chain, l1BlockAddress: l1BlockAddress_ } = args
+
+  const l1BlockAddress = (() => {
+    if (l1BlockAddress_) return l1BlockAddress_
+    if (chain?.contracts?.l1Block)
+      return getChainContractAddress({
+        chain,
+        contract: 'l1Block',
+      })
+    return contracts.l1Block.address
+  })()
+
+  // Try to get operator fee parameters. If any of these calls fail,
+  // it means this is a pre-Isthmus chain and operator fees don't apply
+  try {
+    // Get operator fee parameters first to fail fast if not supported
+    const [operatorFeeScalar, operatorFeeConstant] = await Promise.all([
+      readContract(client, {
+        abi: l1BlockAbi,
+        address: l1BlockAddress,
+        functionName: 'operatorFeeScalar',
+      }),
+      readContract(client, {
+        abi: l1BlockAbi,
+        address: l1BlockAddress,
+        functionName: 'operatorFeeConstant',
+      }),
+    ])
+
+    // Estimate gas for the actual transaction
+    const gasUsed = await estimateGas(client, args as EstimateGasParameters)
+
+    // Calculate operator fee: saturatingAdd(saturatingMul(gasUsed, scalar) / 1e6, constant)
+    // Using saturating arithmetic to prevent overflow
+    const scaledFee = (gasUsed * BigInt(operatorFeeScalar)) / 1_000_000n
+    return scaledFee + BigInt(operatorFeeConstant)
+  } catch {
+    // If any call fails, this is likely a pre-Isthmus chain or the contract
+    // doesn't support these functions. Return 0 for operator fee.
+    return 0n
+  }
+}

package/op-stack/actions/estimateTotalFee.ts

@@ -23,12 +23,18 @@ import {
   type EstimateL1FeeParameters,
   estimateL1Fee,
 } from './estimateL1Fee.js'
+import {
+  type EstimateOperatorFeeErrorType,
+  type EstimateOperatorFeeParameters,
+  estimateOperatorFee,
+} from './estimateOperatorFee.js'
 
 export type EstimateTotalFeeParameters<
   chain extends Chain | undefined = Chain | undefined,
   account extends Account | undefined = Account | undefined,
   chainOverride extends Chain | undefined = Chain | undefined,
-> = EstimateL1FeeParameters<chain, account, chainOverride>
+> = EstimateL1FeeParameters<chain, account, chainOverride> &
+  EstimateOperatorFeeParameters<chain, account, chainOverride>
 
 export type EstimateTotalFeeReturnType = bigint
 
@@ -36,12 +42,13 @@ export type EstimateTotalFeeErrorType =
   | RequestErrorType
   | PrepareTransactionRequestErrorType
   | EstimateL1FeeErrorType
+  | EstimateOperatorFeeErrorType
   | EstimateGasErrorType
   | GetGasPriceErrorType
   | ErrorType
 
 /**
- * Estimates the L1 data fee + L2 fee to execute an L2 transaction.
+ * Estimates the L1 data fee + L2 fee + operator fee to execute an L2 transaction.
  *
  * @param client - Client to use
  * @param parameters - {@link EstimateTotalFeeParameters}
@@ -76,11 +83,12 @@ export async function estimateTotalFee<
     args as PrepareTransactionRequestParameters,
   )
 
-  const [l1Fee, l2Gas, l2GasPrice] = await Promise.all([
+  const [l1Fee, operatorFee, l2Gas, l2GasPrice] = await Promise.all([
     estimateL1Fee(client, request as EstimateL1FeeParameters),
+    estimateOperatorFee(client, request as EstimateOperatorFeeParameters),
     estimateGas(client, request as EstimateGasParameters),
     getGasPrice(client),
   ])
 
-  return l1Fee + l2Gas * l2GasPrice
+  return l1Fee + operatorFee + l2Gas * l2GasPrice
 }

package/op-stack/actions/estimateTotalGas.ts

@@ -3,11 +3,7 @@ import {
   type EstimateGasParameters,
   estimateGas,
 } from '../../actions/public/estimateGas.js'
-import {
-  type PrepareTransactionRequestErrorType,
-  type PrepareTransactionRequestParameters,
-  prepareTransactionRequest,
-} from '../../actions/wallet/prepareTransactionRequest.js'
+import type { PrepareTransactionRequestErrorType } 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'
@@ -65,15 +61,9 @@ export async function estimateTotalGas<
   client: Client<Transport, chain, account>,
   args: EstimateTotalGasParameters<chain, account, chainOverride>,
 ): 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),
+    estimateL1Gas(client, args as EstimateL1GasParameters),
+    estimateGas(client, args as EstimateGasParameters),
   ])
 
   return l1Gas + l2Gas

package/op-stack/actions/finalizeWithdrawal.ts

@@ -19,11 +19,7 @@ import type { FormattedTransactionRequest } from '../../utils/formatters/transac
 import { portal2Abi, portalAbi } from '../abis.js'
 import type { GetContractAddressParameter } from '../types/contract.js'
 import type { Withdrawal } from '../types/withdrawal.js'
-import {
-  type EstimateFinalizeWithdrawalGasErrorType,
-  type EstimateFinalizeWithdrawalGasParameters,
-  estimateFinalizeWithdrawalGas,
-} from './estimateFinalizeWithdrawalGas.js'
+import type { EstimateFinalizeWithdrawalGasErrorType } from './estimateFinalizeWithdrawalGas.js'
 
 export type FinalizeWithdrawalParameters<
   chain extends Chain | undefined = Chain | undefined,
@@ -114,14 +110,6 @@ export async function finalizeWithdrawal<
     return Object.values(targetChain!.contracts.portal)[0].address
   })()
 
-  const gas_ =
-    typeof gas !== 'number' && gas !== null
-      ? await estimateFinalizeWithdrawalGas(
-          client,
-          parameters as EstimateFinalizeWithdrawalGasParameters,
-        )
-      : undefined
-
   const [functionName, args, abi] = proofSubmitter
     ? [
         'finalizeWithdrawalTransactionExternalProof',
@@ -137,7 +125,7 @@ export async function finalizeWithdrawal<
     chain,
     functionName,
     args,
-    gas: gas_,
+    gas: gas ?? undefined,
     maxFeePerGas,
     maxPriorityFeePerGas,
     nonce,

package/op-stack/actions/initiateWithdrawal.ts

@@ -19,11 +19,7 @@ import type { FormattedTransactionRequest } from '../../utils/formatters/transac
 import { l2ToL1MessagePasserAbi } from '../abis.js'
 import { contracts } from '../contracts.js'
 import type { WithdrawalRequest } from '../types/withdrawal.js'
-import {
-  type EstimateInitiateWithdrawalGasErrorType,
-  type EstimateInitiateWithdrawalGasParameters,
-  estimateInitiateWithdrawalGas,
-} from './estimateInitiateWithdrawalGas.js'
+import type { EstimateInitiateWithdrawalGasErrorType } from './estimateInitiateWithdrawalGas.js'
 
 export type InitiateWithdrawalParameters<
   chain extends Chain | undefined = Chain | undefined,
@@ -129,14 +125,6 @@ export async function initiateWithdrawal<
     request: { data = '0x', gas: l1Gas, to, value },
   } = parameters
 
-  const gas_ =
-    typeof gas !== 'number' && gas !== null
-      ? await estimateInitiateWithdrawalGas(
-          client,
-          parameters as EstimateInitiateWithdrawalGasParameters,
-        )
-      : undefined
-
   return writeContract(client, {
     account: account!,
     abi: l2ToL1MessagePasserAbi,
@@ -144,7 +132,7 @@ export async function initiateWithdrawal<
     chain,
     functionName: 'initiateWithdrawal',
     args: [to, l1Gas, data],
-    gas: gas_,
+    gas: gas ?? undefined,
     maxFeePerGas,
     maxPriorityFeePerGas,
     nonce,

package/op-stack/actions/proveWithdrawal.ts

@@ -18,11 +18,7 @@ import type { UnionEvaluate, UnionOmit } from '../../types/utils.js'
 import type { FormattedTransactionRequest } from '../../utils/formatters/transactionRequest.js'
 import { portal2Abi } from '../abis.js'
 import type { GetContractAddressParameter } from '../types/contract.js'
-import {
-  type EstimateProveWithdrawalGasErrorType,
-  type EstimateProveWithdrawalGasParameters,
-  estimateProveWithdrawalGas,
-} from './estimateProveWithdrawalGas.js'
+import type { EstimateProveWithdrawalGasErrorType } from './estimateProveWithdrawalGas.js'
 
 export type ProveWithdrawalParameters<
   chain extends Chain | undefined = Chain | undefined,
@@ -131,14 +127,6 @@ export async function proveWithdrawal<
     return Object.values(targetChain!.contracts.portal)[0].address
   })()
 
-  const gas_ =
-    typeof gas !== 'bigint' && gas !== null
-      ? await estimateProveWithdrawalGas(
-          client,
-          parameters as EstimateProveWithdrawalGasParameters,
-        )
-      : (gas ?? undefined)
-
   return writeContract(client, {
     account: account!,
     abi: portal2Abi,
@@ -146,7 +134,7 @@ export async function proveWithdrawal<
     chain,
     functionName: 'proveWithdrawalTransaction',
     args: [withdrawal, l2OutputIndex, outputRootProof, withdrawalProof],
-    gas: gas_,
+    gas: gas ?? undefined,
     maxFeePerGas,
     maxPriorityFeePerGas,
     nonce,

package/op-stack/decorators/publicL2.ts

@@ -52,6 +52,11 @@ import {
   type EstimateL1GasReturnType,
   estimateL1Gas,
 } from '../actions/estimateL1Gas.js'
+import {
+  type EstimateOperatorFeeParameters,
+  type EstimateOperatorFeeReturnType,
+  estimateOperatorFee,
+} from '../actions/estimateOperatorFee.js'
 import {
   type EstimateTotalFeeParameters,
   type EstimateTotalFeeReturnType,
@@ -418,6 +423,34 @@ export type PublicActionsL2<
   estimateL1Gas: <chainOverride extends Chain | undefined = undefined>(
     parameters: EstimateL1GasParameters<chain, account, chainOverride>,
   ) => Promise<EstimateL1GasReturnType>
+  /**
+   * Estimates the operator fee required to execute an L2 transaction.
+   *
+   * Returns 0 for pre-Isthmus chains or when operator fee functions don't exist.
+   *
+   * @param client - Client to use
+   * @param parameters - {@link EstimateOperatorFeeParameters}
+   * @returns The operator fee (in wei). {@link EstimateOperatorFeeReturnType}
+   *
+   * @example
+   * import { createPublicClient, http, parseEther } from 'viem'
+   * import { optimism } from 'viem/chains'
+   * import { publicActionsL2 } from 'viem/op-stack'
+   *
+   * const client = createPublicClient({
+   *   chain: optimism,
+   *   transport: http(),
+   * }).extend(publicActionsL2())
+   *
+   * const operatorFee = await client.estimateOperatorFee({
+   *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *   value: parseEther('1'),
+   * })
+   */
+  estimateOperatorFee: <chainOverride extends Chain | undefined = undefined>(
+    parameters: EstimateOperatorFeeParameters<chain, account, chainOverride>,
+  ) => Promise<EstimateOperatorFeeReturnType>
   /**
    * Estimates the L1 data fee + L2 fee to execute an L2 transaction.
    *
@@ -509,6 +542,7 @@ export function publicActionsL2() {
       estimateL1Fee: (args) => estimateL1Fee(client, args),
       getL1BaseFee: (args) => getL1BaseFee(client, args),
       estimateL1Gas: (args) => estimateL1Gas(client, args),
+      estimateOperatorFee: (args) => estimateOperatorFee(client, args),
       estimateTotalFee: (args) => estimateTotalFee(client, args),
       estimateTotalGas: (args) => estimateTotalGas(client, args),
     }

package/op-stack/index.ts

@@ -59,6 +59,12 @@ export {
   type EstimateL1GasReturnType,
   estimateL1Gas,
 } from './actions/estimateL1Gas.js'
+export {
+  type EstimateOperatorFeeErrorType,
+  type EstimateOperatorFeeParameters,
+  type EstimateOperatorFeeReturnType,
+  estimateOperatorFee,
+} from './actions/estimateOperatorFee.js'
 export {
   type EstimateTotalFeeErrorType,
   type EstimateTotalFeeParameters,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.40.3",
+  "version": "2.41.1",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",

package/types/chain.ts

@@ -71,6 +71,15 @@ export type Chain<
 // Config
 /////////////////////////////////////////////////////////////////////
 
+type PrepareTransactionRequestPhase =
+  | 'beforeFillTransaction'
+  | 'beforeFillParameters'
+  | 'afterFillParameters'
+type PrepareTransactionRequestFn = (
+  args: PrepareTransactionRequestParameters,
+  options: { phase: PrepareTransactionRequestPhase },
+) => Promise<PrepareTransactionRequestParameters>
+
 export type ChainConfig<
   formatters extends ChainFormatters | undefined = ChainFormatters | undefined,
   custom extends Record<string, unknown> | undefined =
@@ -83,6 +92,23 @@ export type ChainConfig<
   fees?: ChainFees<formatters | undefined> | undefined
   /** Modifies how data is formatted and typed (e.g. blocks and transactions) */
   formatters?: formatters | undefined
+  /** Function to prepare a transaction request. Runs before the transaction is filled. */
+  prepareTransactionRequest?:
+    | PrepareTransactionRequestFn
+    | [
+        fn: PrepareTransactionRequestFn | undefined,
+        options: {
+          /**
+           * Phases to run the function at.
+           *
+           * - `beforeFillTransaction`: Before the transaction is attempted to be filled via `eth_fillTransaction`.
+           * - `beforeFillParameters`: Before missing parameters are filled.
+           * - `afterFillParameters`: After missing parameters are filled.
+           */
+          runAt: readonly PrepareTransactionRequestPhase[]
+        },
+      ]
+    | undefined
   /** Modifies how data is serialized (e.g. transactions). */
   serializers?: ChainSerializers<formatters> | undefined
 }