viem 2.40.4 → 2.41.1

package/actions/wallet/prepareTransactionRequest.ts

@@ -266,18 +266,33 @@ export async function prepareTransactionRequest<
     request
   >
 > {
+  let request = args as PrepareTransactionRequestParameters
   const {
     account: account_ = client.account,
-    chain,
+    chain = client.chain,
     nonceManager,
     parameters = defaultParameters,
-  } = args
+  } = request
+
+  const prepareTransactionRequest = (() => {
+    if (typeof chain?.prepareTransactionRequest === 'function')
+      return {
+        fn: chain.prepareTransactionRequest,
+        runAt: ['beforeFillTransaction'],
+      }
+    if (Array.isArray(chain?.prepareTransactionRequest))
+      return {
+        fn: chain.prepareTransactionRequest[0],
+        runAt: chain.prepareTransactionRequest[1].runAt,
+      }
+    return undefined
+  })()
 
   let chainId: number | undefined
   async function getChainId(): Promise<number> {
     if (chainId) return chainId
+    if (typeof request.chainId !== 'undefined') return request.chainId
     if (chain) return chain.id
-    if (typeof args.chainId !== 'undefined') return args.chainId
     const chainId_ = await getAction(client, getChainId_, 'getChainId')({})
     chainId = chainId_
     return chainId
@@ -285,7 +300,7 @@ export async function prepareTransactionRequest<
 
   const account = account_ ? parseAccount(account_) : account_
 
-  let nonce = args.nonce
+  let nonce = request.nonce
   if (
     parameters.includes('nonce') &&
     typeof nonce === 'undefined' &&
@@ -300,23 +315,56 @@ export async function prepareTransactionRequest<
     })
   }
 
-  const attemptFill =
+  if (
+    prepareTransactionRequest?.fn &&
+    prepareTransactionRequest.runAt?.includes('beforeFillTransaction')
+  )
+    request = await prepareTransactionRequest.fn(request, {
+      phase: 'beforeFillTransaction',
+    })
+
+  const attemptFill = (() => {
+    // Do not attempt if blobs are provided.
+    if (
+      (parameters.includes('blobVersionedHashes') ||
+        parameters.includes('sidecars')) &&
+      request.kzg &&
+      request.blobs
+    )
+      return false
+
     // Do not attempt if `eth_fillTransaction` is not supported.
-    supportsFillTransaction.get(client.uid) !== false &&
+    if (supportsFillTransaction.get(client.uid) === false) return false
+
     // Should attempt `eth_fillTransaction` if "fees" or "gas" are required to be populated,
     // otherwise, can just use the other individual calls.
-    ['fees', 'gas'].some((parameter) =>
-      args.parameters?.includes(
-        parameter as PrepareTransactionRequestParameterType,
-      ),
+    const shouldAttempt = ['fees', 'gas'].some((parameter) =>
+      parameters.includes(parameter as PrepareTransactionRequestParameterType),
     )
+    if (!shouldAttempt) return false
+
+    // Check if `eth_fillTransaction` needs to be called.
+    if (parameters.includes('chainId') && typeof request.chainId !== 'number')
+      return true
+    if (parameters.includes('nonce') && typeof nonce !== 'number') return true
+    if (
+      parameters.includes('fees') &&
+      typeof request.gasPrice !== 'bigint' &&
+      (typeof request.maxFeePerGas !== 'bigint' ||
+        typeof (request as any).maxPriorityFeePerGas !== 'bigint')
+    )
+      return true
+    if (parameters.includes('gas') && typeof request.gas !== 'bigint')
+      return true
+    return false
+  })()
 
   const fillResult = attemptFill
     ? await getAction(
         client,
         fillTransaction,
         'fillTransaction',
-      )({ ...args, nonce } as FillTransactionParameters)
+      )({ ...request, nonce } as FillTransactionParameters)
         .then((result) => {
           const {
             chainId,
@@ -332,7 +380,7 @@ export async function prepareTransactionRequest<
           } = result.transaction
           supportsFillTransaction.set(client.uid, true)
           return {
-            ...args,
+            ...request,
             ...(from ? { from } : {}),
             ...(type ? { type } : {}),
             ...(typeof chainId !== 'undefined' ? { chainId } : {}),
@@ -353,7 +401,7 @@ export async function prepareTransactionRequest<
         })
         .catch((e) => {
           const error = e as BaseError & { cause: BaseError }
-          const unsupported = error.walk((e) => {
+          const unsupported = error.walk?.((e) => {
             const error = e as BaseError
             return (
               error.name === 'MethodNotFoundRpcError' ||
@@ -361,18 +409,27 @@ export async function prepareTransactionRequest<
             )
           })
           if (unsupported) supportsFillTransaction.set(client.uid, false)
-          return args
+          return request
         })
-    : args
+    : request
 
-  const { blobs, gas, kzg, type } = fillResult
   nonce ??= fillResult.nonce
 
-  const request = {
-    ...fillResult,
+  request = {
+    ...(fillResult as any),
     ...(account ? { from: account?.address } : {}),
     ...(nonce ? { nonce } : {}),
   }
+  const { blobs, gas, kzg, type } = request
+
+  if (
+    prepareTransactionRequest?.fn &&
+    prepareTransactionRequest.runAt?.includes('beforeFillParameters')
+  ) {
+    request = await prepareTransactionRequest.fn(request, {
+      phase: 'beforeFillParameters',
+    })
+  }
 
   let block: Block | undefined
   async function getBlock(): Promise<Block> {
@@ -512,6 +569,14 @@ export async function prepareTransactionRequest<
       prepare: account?.type === 'local' ? [] : ['blobVersionedHashes'],
     } as EstimateGasParameters)
 
+  if (
+    prepareTransactionRequest?.fn &&
+    prepareTransactionRequest.runAt?.includes('afterFillParameters')
+  )
+    request = await prepareTransactionRequest.fn(request, {
+      phase: 'afterFillParameters',
+    })
+
   assertRequest(request as AssertRequestParameters)
 
   delete request.parameters

package/errors/version.ts

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

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/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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.40.4",
+  "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
 }