viem 2.39.2 → 2.40.0

package/actions/public/fillTransaction.ts

@@ -0,0 +1,250 @@
+import type { Address } from 'abitype'
+import { parseAccount } from '../../accounts/utils/parseAccount.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { BaseError } from '../../errors/base.js'
+import { BaseFeeScalarError } from '../../errors/fee.js'
+import type { ErrorType } from '../../errors/utils.js'
+import type { Account, GetAccountParameter } from '../../types/account.js'
+import type {
+  Chain,
+  ChainFeesFnParameters,
+  DeriveChain,
+  GetChainParameter,
+} from '../../types/chain.js'
+import type { Hex } from '../../types/misc.js'
+import type { TransactionRequest } from '../../types/transaction.js'
+import type { UnionOmit } from '../../types/utils.js'
+import {
+  type GetTransactionErrorReturnType,
+  getTransactionError,
+} from '../../utils/errors/getTransactionError.js'
+import { extract } from '../../utils/formatters/extract.js'
+import {
+  type FormattedTransaction,
+  formatTransaction,
+} from '../../utils/formatters/transaction.js'
+import {
+  type FormattedTransactionRequest,
+  formatTransactionRequest,
+} from '../../utils/formatters/transactionRequest.js'
+import { getAction } from '../../utils/getAction.js'
+import type { NonceManager } from '../../utils/nonceManager.js'
+import { assertRequest } from '../../utils/transaction/assertRequest.js'
+import { getBlock } from './getBlock.js'
+import { getChainId as getChainId_ } from './getChainId.js'
+
+export type FillTransactionParameters<
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+  accountOverride extends Account | Address | undefined =
+    | Account
+    | Address
+    | undefined,
+  ///
+  _derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
+> = UnionOmit<FormattedTransactionRequest<_derivedChain>, 'from'> &
+  GetAccountParameter<account, accountOverride, false, true> &
+  GetChainParameter<chain, chainOverride> & {
+    /**
+     * Nonce manager to use for the transaction request.
+     */
+    nonceManager?: NonceManager | undefined
+  }
+
+export type FillTransactionReturnType<
+  chain extends Chain | undefined = Chain | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+  ///
+  _derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
+> = {
+  raw: Hex
+  transaction: FormattedTransaction<_derivedChain>
+}
+
+export type FillTransactionErrorType =
+  | GetTransactionErrorReturnType<ErrorType>
+  | ErrorType
+
+/**
+ * Fills a transaction request with the necessary fields to be signed over.
+ *
+ * - Docs: https://viem.sh/docs/actions/public/fillTransaction
+ *
+ * @param client - Client to use
+ * @param parameters - {@link FillTransactionParameters}
+ * @returns The filled transaction. {@link FillTransactionReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { fillTransaction } from 'viem/public'
+ *
+ * const client = createPublicClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const result = await fillTransaction(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: parseEther('1'),
+ * })
+ */
+export async function fillTransaction<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  chainOverride extends Chain | undefined = undefined,
+  accountOverride extends Account | Address | undefined = undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: FillTransactionParameters<
+    chain,
+    account,
+    chainOverride,
+    accountOverride
+  >,
+): Promise<FillTransactionReturnType<chain, chainOverride>> {
+  const {
+    account = client.account,
+    accessList,
+    authorizationList,
+    chain = client.chain,
+    blobVersionedHashes,
+    blobs,
+    data,
+    gas,
+    gasPrice,
+    maxFeePerBlobGas,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce: nonce_,
+    nonceManager,
+    to,
+    type,
+    value,
+    ...rest
+  } = parameters
+
+  const nonce = await (async () => {
+    if (!account) return nonce_
+    if (!nonceManager) return nonce_
+    const account_ = parseAccount(account)
+    const chainId = chain
+      ? chain.id
+      : await getAction(client, getChainId_, 'getChainId')({})
+    return await nonceManager.consume({
+      address: account_.address,
+      chainId,
+      client,
+    })
+  })()
+
+  assertRequest(parameters)
+
+  const chainFormat = chain?.formatters?.transactionRequest?.format
+  const format = chainFormat || formatTransactionRequest
+
+  const request = format(
+    {
+      // Pick out extra data that might exist on the chain's transaction request type.
+      ...extract(rest, { format: chainFormat }),
+      account: account ? parseAccount(account) : undefined,
+      accessList,
+      authorizationList,
+      blobs,
+      blobVersionedHashes,
+      data,
+      gas,
+      gasPrice,
+      maxFeePerBlobGas,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      nonce,
+      to,
+      type,
+      value,
+    } as TransactionRequest,
+    'fillTransaction',
+  )
+
+  try {
+    const response = await client.request({
+      method: 'eth_fillTransaction',
+      params: [request],
+    })
+    const format = chain?.formatters?.transaction?.format || formatTransaction
+
+    const transaction = format(response.tx)
+
+    // Remove unnecessary fields.
+    delete transaction.blockHash
+    delete transaction.blockNumber
+    delete transaction.r
+    delete transaction.s
+    delete transaction.transactionIndex
+    delete transaction.v
+    delete transaction.yParity
+
+    // Rewrite fields.
+    transaction.data = transaction.input
+
+    // Preference supplied fees (some nodes do not take these preferences).
+    if (transaction.gas) transaction.gas = parameters.gas ?? transaction.gas
+    if (transaction.gasPrice)
+      transaction.gasPrice = parameters.gasPrice ?? transaction.gasPrice
+    if (transaction.maxFeePerBlobGas)
+      transaction.maxFeePerBlobGas =
+        parameters.maxFeePerBlobGas ?? transaction.maxFeePerBlobGas
+    if (transaction.maxFeePerGas)
+      transaction.maxFeePerGas =
+        parameters.maxFeePerGas ?? transaction.maxFeePerGas
+    if (transaction.maxPriorityFeePerGas)
+      transaction.maxPriorityFeePerGas =
+        parameters.maxPriorityFeePerGas ?? transaction.maxPriorityFeePerGas
+    if (transaction.nonce)
+      transaction.nonce = parameters.nonce ?? transaction.nonce
+
+    // Build fee multiplier function.
+    const feeMultiplier = await (async () => {
+      if (typeof chain?.fees?.baseFeeMultiplier === 'function') {
+        const block = await getAction(client, getBlock, 'getBlock')({})
+        return chain.fees.baseFeeMultiplier({
+          block,
+          client,
+          request: parameters,
+        } as ChainFeesFnParameters)
+      }
+      return chain?.fees?.baseFeeMultiplier ?? 1.2
+    })()
+    if (feeMultiplier < 1) throw new BaseFeeScalarError()
+
+    const decimals = feeMultiplier.toString().split('.')[1]?.length ?? 0
+    const denominator = 10 ** decimals
+    const multiplyFee = (base: bigint) =>
+      (base * BigInt(Math.ceil(feeMultiplier * denominator))) /
+      BigInt(denominator)
+
+    // Apply fee multiplier.
+    if (transaction.maxFeePerGas && !parameters.maxFeePerGas)
+      transaction.maxFeePerGas = multiplyFee(transaction.maxFeePerGas)
+    if (transaction.gasPrice && !parameters.gasPrice)
+      transaction.gasPrice = multiplyFee(transaction.gasPrice)
+
+    return {
+      raw: response.raw,
+      transaction: {
+        from: request.from,
+        ...transaction,
+      },
+    }
+  } catch (err) {
+    throw getTransactionError(
+      err as BaseError,
+      {
+        ...parameters,
+        chain: client.chain,
+      } as never,
+    )
+  }
+}

package/actions/wallet/prepareTransactionRequest.ts

@@ -24,6 +24,7 @@ import {
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { AccountNotFoundErrorType } from '../../errors/account.js'
+import type { BaseError } from '../../errors/base.js'
 import {
   Eip1559FeesNotSupportedError,
   MaxFeePerGasTooLowError,
@@ -58,6 +59,7 @@ import { commitmentsToVersionedHashes } from '../../utils/blob/commitmentsToVers
 import { toBlobSidecars } from '../../utils/blob/toBlobSidecars.js'
 import type { FormattedTransactionRequest } from '../../utils/formatters/transactionRequest.js'
 import { getAction } from '../../utils/getAction.js'
+import { LruMap } from '../../utils/lru.js'
 import type { NonceManager } from '../../utils/nonceManager.js'
 import {
   type AssertRequestErrorType,
@@ -68,6 +70,10 @@ import {
   type GetTransactionType,
   getTransactionType,
 } from '../../utils/transaction/getTransactionType.js'
+import {
+  type FillTransactionParameters,
+  fillTransaction,
+} from '../public/fillTransaction.js'
 import { getChainId as getChainId_ } from '../public/getChainId.js'
 
 export const defaultParameters = [
@@ -82,6 +88,8 @@ export const defaultParameters = [
 /** @internal */
 export const eip1559NetworkCache = /*#__PURE__*/ new Map<string, boolean>()
 
+const supportsFillTransaction = /*#__PURE__*/ new LruMap<boolean>(128)
+
 export type PrepareTransactionRequestParameterType =
   | 'blobVersionedHashes'
   | 'chainId'
@@ -241,7 +249,7 @@ export async function prepareTransactionRequest<
   chainOverride extends Chain | undefined = undefined,
 >(
   client: Client<Transport, chain, account>,
-  args: PrepareTransactionRequestParameters<
+  args_: PrepareTransactionRequestParameters<
     chain,
     account,
     chainOverride,
@@ -257,6 +265,60 @@ export async function prepareTransactionRequest<
     request
   >
 > {
+  const attemptFill =
+    // Do not attempt if `eth_fillTransaction` is not supported.
+    supportsFillTransaction.get(client.uid) !== 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 fillResult = attemptFill
+    ? await getAction(
+        client,
+        fillTransaction,
+        'fillTransaction',
+      )(args_ as FillTransactionParameters)
+        .then((result) => {
+          const {
+            chainId,
+            from,
+            gas,
+            gasPrice,
+            nonce,
+            maxFeePerBlobGas,
+            maxFeePerGas,
+            maxPriorityFeePerGas,
+            type,
+          } = result.transaction
+          supportsFillTransaction.set(client.uid, true)
+          return {
+            ...args_,
+            chainId,
+            from,
+            gas,
+            gasPrice,
+            nonce,
+            maxFeePerBlobGas,
+            maxFeePerGas,
+            maxPriorityFeePerGas,
+            type,
+          }
+        })
+        .catch((e) => {
+          const error = e as BaseError & { cause: BaseError }
+          if (
+            error.cause.name === 'MethodNotFoundRpcError' ||
+            error.cause.name === 'MethodNotSupportedRpcError'
+          )
+            supportsFillTransaction.set(client.uid, false)
+          return args_
+        })
+    : args_
+
   const {
     account: account_ = client.account,
     blobs,
@@ -267,10 +329,14 @@ export async function prepareTransactionRequest<
     nonceManager,
     parameters = defaultParameters,
     type,
-  } = args
+  } = fillResult
+
   const account = account_ ? parseAccount(account_) : account_
 
-  const request = { ...args, ...(account ? { from: account?.address } : {}) }
+  const request = {
+    ...fillResult,
+    ...(account ? { from: account?.address } : {}),
+  }
 
   let block: Block | undefined
   async function getBlock(): Promise<Block> {
@@ -287,7 +353,7 @@ export async function prepareTransactionRequest<
   async function getChainId(): Promise<number> {
     if (chainId) return chainId
     if (chain) return chain.id
-    if (typeof args.chainId !== 'undefined') return args.chainId
+    if (typeof request.chainId !== 'undefined') return request.chainId
     const chainId_ = await getAction(client, getChainId_, 'getChainId')({})
     chainId = chainId_
     return chainId
@@ -379,9 +445,9 @@ export async function prepareTransactionRequest<
           })
 
         if (
-          typeof args.maxPriorityFeePerGas === 'undefined' &&
-          args.maxFeePerGas &&
-          args.maxFeePerGas < maxPriorityFeePerGas
+          typeof request.maxPriorityFeePerGas === 'undefined' &&
+          request.maxFeePerGas &&
+          request.maxFeePerGas < maxPriorityFeePerGas
         )
           throw new MaxFeePerGasTooLowError({
             maxPriorityFeePerGas,
@@ -393,12 +459,12 @@ export async function prepareTransactionRequest<
     } else {
       // Legacy fees
       if (
-        typeof args.maxFeePerGas !== 'undefined' ||
-        typeof args.maxPriorityFeePerGas !== 'undefined'
+        typeof request.maxFeePerGas !== 'undefined' ||
+        typeof request.maxPriorityFeePerGas !== 'undefined'
       )
         throw new Eip1559FeesNotSupportedError()
 
-      if (typeof args.gasPrice === 'undefined') {
+      if (typeof request.gasPrice === 'undefined') {
         const block = await getBlock()
         const { gasPrice: gasPrice_ } = await internal_estimateFeesPerGas(
           client,

package/chains/definitions/etherlinkShadownetTestnet.ts

@@ -0,0 +1,21 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const etherlinkShadownetTestnet = /*#__PURE__*/ defineChain({
+  id: 127823,
+  name: 'Etherlink Shadownet Testnet',
+  nativeCurrency: {
+    decimals: 18,
+    name: 'tez',
+    symbol: 'XTZ',
+  },
+  rpcUrls: {
+    default: { http: ['https://node.shadownet.etherlink.com'] },
+  },
+  blockExplorers: {
+    default: {
+      name: 'Etherlink Shadownet Testnet Explorer',
+      url: 'https://shadownet.explorer.etherlink.com',
+    },
+  },
+  testnet: true,
+})

package/chains/definitions/monad.ts

@@ -0,0 +1,36 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const monad = /*#__PURE__*/ defineChain({
+  id: 143,
+  name: 'Monad',
+  blockTime: 400,
+  nativeCurrency: {
+    name: 'Monad',
+    symbol: 'MON',
+    decimals: 18,
+  },
+  rpcUrls: {
+    default: {
+      http: ['https://rpc.monad.xyz', 'https://rpc1.monad.xyz'],
+      webSocket: ['wss://rpc.monad.xyz', 'wss://rpc1.monad.xyz'],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: 'MonadVision',
+      url: 'https://monadvision.com',
+    },
+    monadscan: {
+      name: 'Monadscan',
+      url: 'https://monadscan.com',
+      apiUrl: 'https://api.monadscan.com/api',
+    },
+  },
+  testnet: false,
+  contracts: {
+    multicall3: {
+      address: '0xcA11bde05977b3631167028862bE2a173976CA11',
+      blockCreated: 9248132,
+    },
+  },
+})

package/chains/index.ts

@@ -180,6 +180,7 @@ export { eos } from './definitions/eos.js'
 export { eosTestnet } from './definitions/eosTestnet.js'
 export { eteria } from './definitions/eteria.js'
 export { etherlink } from './definitions/etherlink.js'
+export { etherlinkShadownetTestnet } from './definitions/etherlinkShadownetTestnet.js'
 export { etherlinkTestnet } from './definitions/etherlinkTestnet.js'
 export { ethernity } from './definitions/ethernity.js'
 export { etp } from './definitions/etp.js'
@@ -392,6 +393,7 @@ export { mintSepoliaTestnet } from './definitions/mintSepoliaTestnet.js'
 export { mitosisTestnet } from './definitions/mitosisTestnet.js'
 export { mode } from './definitions/mode.js'
 export { modeTestnet } from './definitions/modeTestnet.js'
+export { monad } from './definitions/monad.js'
 export { monadTestnet } from './definitions/monadTestnet.js'
 export { moonbaseAlpha } from './definitions/moonbaseAlpha.js'
 export { moonbeam } from './definitions/moonbeam.js'

package/clients/decorators/public.ts

@@ -73,6 +73,11 @@ import {
   type EstimateMaxPriorityFeePerGasReturnType,
   estimateMaxPriorityFeePerGas,
 } from '../../actions/public/estimateMaxPriorityFeePerGas.js'
+import {
+  type FillTransactionParameters,
+  type FillTransactionReturnType,
+  fillTransaction,
+} from '../../actions/public/fillTransaction.js'
 import {
   type GetBalanceParameters,
   type GetBalanceReturnType,
@@ -543,6 +548,40 @@ export type PublicActions<
   estimateGas: (
     args: EstimateGasParameters<chain>,
   ) => Promise<EstimateGasReturnType>
+  /**
+   * Fills a transaction request with the necessary fields to be signed over.
+   *
+   * - Docs: https://viem.sh/docs/actions/public/fillTransaction
+   *
+   * @param client - Client to use
+   * @param parameters - {@link FillTransactionParameters}
+   * @returns The filled transaction. {@link FillTransactionReturnType}
+   *
+   * @example
+   * import { createPublicClient, http } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createPublicClient({
+   *   chain: mainnet,
+   *   transport: http(),
+   * })
+   * const result = await client.fillTransaction({
+   *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *   value: parseEther('1'),
+   * })
+   */
+  fillTransaction: <
+    chainOverride extends Chain | undefined = undefined,
+    accountOverride extends Account | Address | undefined = undefined,
+  >(
+    args: FillTransactionParameters<
+      chain,
+      account,
+      chainOverride,
+      accountOverride
+    >,
+  ) => Promise<FillTransactionReturnType<chain, chainOverride>>
   /**
    * Returns the balance of an address in wei.
    *
@@ -2039,6 +2078,7 @@ export function publicActions<
     getProof: (args) => getProof(client, args),
     estimateMaxPriorityFeePerGas: (args) =>
       estimateMaxPriorityFeePerGas(client, args),
+    fillTransaction: (args) => fillTransaction(client, args),
     getStorageAt: (args) => getStorageAt(client, args),
     getTransaction: (args) => getTransaction(client, args),
     getTransactionConfirmations: (args) =>

package/clients/decorators/wallet.ts

@@ -1,6 +1,11 @@
 import type { Abi, Address, TypedData } from 'abitype'
 
 import type { Account } from '../../accounts/types.js'
+import {
+  type FillTransactionParameters,
+  type FillTransactionReturnType,
+  fillTransaction,
+} from '../../actions/public/fillTransaction.js'
 import {
   type GetChainIdReturnType,
   getChainId,
@@ -195,6 +200,40 @@ export type WalletActions<
   >(
     args: DeployContractParameters<abi, chain, account, chainOverride>,
   ) => Promise<DeployContractReturnType>
+  /**
+   * Fills a transaction request with the necessary fields to be signed over.
+   *
+   * - Docs: https://viem.sh/docs/actions/public/fillTransaction
+   *
+   * @param client - Client to use
+   * @param parameters - {@link FillTransactionParameters}
+   * @returns The filled transaction. {@link FillTransactionReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const result = await client.fillTransaction({
+   *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *   value: parseEther('1'),
+   * })
+   */
+  fillTransaction: <
+    chainOverride extends Chain | undefined = undefined,
+    accountOverride extends Account | Address | undefined = undefined,
+  >(
+    args: FillTransactionParameters<
+      chain,
+      account,
+      chainOverride,
+      accountOverride
+    >,
+  ) => Promise<FillTransactionReturnType<chain, chainOverride>>
   /**
    * Returns a list of account addresses owned by the wallet or client.
    *
@@ -1146,6 +1185,7 @@ export function walletActions<
   return {
     addChain: (args) => addChain(client, args),
     deployContract: (args) => deployContract(client, args),
+    fillTransaction: (args) => fillTransaction(client, args),
     getAddresses: () => getAddresses(client),
     getCallsStatus: (args) => getCallsStatus(client, args),
     getCapabilities: (args) => getCapabilities(client, args),

package/errors/request.ts

@@ -48,6 +48,7 @@ export type WebSocketRequestErrorType = WebSocketRequestError & {
   name: 'WebSocketRequestError'
 }
 export class WebSocketRequestError extends BaseError {
+  url: string
   constructor({
     body,
     cause,
@@ -68,6 +69,7 @@ export class WebSocketRequestError extends BaseError {
       ].filter(Boolean) as string[],
       name: 'WebSocketRequestError',
     })
+    this.url = url
   }
 }
 
@@ -77,7 +79,7 @@ export type RpcRequestErrorType = RpcRequestError & {
 export class RpcRequestError extends BaseError {
   code: number
   data?: unknown
-
+  url: string
   constructor({
     body,
     error,
@@ -95,6 +97,7 @@ export class RpcRequestError extends BaseError {
     })
     this.code = error.code
     this.data = error.data
+    this.url = url
   }
 }
 
@@ -102,6 +105,7 @@ export type SocketClosedErrorType = SocketClosedError & {
   name: 'SocketClosedError'
 }
 export class SocketClosedError extends BaseError {
+  url: string | undefined
   constructor({
     url,
   }: {
@@ -111,6 +115,7 @@ export class SocketClosedError extends BaseError {
       metaMessages: [url && `URL: ${getUrl(url)}`].filter(Boolean) as string[],
       name: 'SocketClosedError',
     })
+    this.url = url
   }
 }
 
@@ -118,6 +123,7 @@ export type TimeoutErrorType = TimeoutError & {
   name: 'TimeoutError'
 }
 export class TimeoutError extends BaseError {
+  url: string
   constructor({
     body,
     url,
@@ -130,5 +136,6 @@ export class TimeoutError extends BaseError {
       metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
       name: 'TimeoutError',
     })
+    this.url = url
   }
 }

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.39.2'
+export const version = '2.40.0'

package/index.ts

@@ -135,6 +135,11 @@ export type {
   EstimateMaxPriorityFeePerGasParameters,
   EstimateMaxPriorityFeePerGasReturnType,
 } from './actions/public/estimateMaxPriorityFeePerGas.js'
+export type {
+  FillTransactionErrorType,
+  FillTransactionParameters,
+  FillTransactionReturnType,
+} from './actions/public/fillTransaction.js'
 export type {
   GetBalanceErrorType,
   GetBalanceParameters,

package/package.json

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