viem 2.40.3 → 2.40.4

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.40.4'

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/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/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.40.4",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",