viem 2.21.58 → 2.21.60

package/account-abstraction/actions/bundler/prepareUserOperation.ts

@@ -12,8 +12,8 @@ import type { Client } from '../../../clients/createClient.js'
 import type { Transport } from '../../../clients/transports/createTransport.js'
 import { AccountNotFoundError } from '../../../errors/account.js'
 import type { ErrorType } from '../../../errors/utils.js'
+import type { Call, Calls } from '../../../types/calls.js'
 import type { Chain } from '../../../types/chain.js'
-import type { ContractFunctionParameters } from '../../../types/contract.js'
 import type { Hex } from '../../../types/misc.js'
 import type { StateOverride } from '../../../types/stateOverride.js'
 import type {
@@ -42,8 +42,6 @@ import type {
 } from '../../types/entryPointVersion.js'
 import type {
   UserOperation,
-  UserOperationCall,
-  UserOperationCalls,
   UserOperationRequest,
 } from '../../types/userOperation.js'
 import {
@@ -154,7 +152,7 @@ export type PrepareUserOperationRequest<
     EntryPointVersion = DeriveEntryPointVersion<_derivedAccount>,
 > = Assign<
   UserOperationRequest<_derivedVersion>,
-  OneOf<{ calls: UserOperationCalls<Narrow<calls>> } | { callData: Hex }> & {
+  OneOf<{ calls: Calls<Narrow<calls>> } | { callData: Hex }> & {
     parameters?: readonly PrepareUserOperationParameterType[] | undefined
     paymaster?:
       | Address
@@ -367,16 +365,14 @@ export async function prepareUserOperation<
       if (parameters.calls)
         return account.encodeCalls(
           parameters.calls.map((call_) => {
-            const call = call_ as
-              | UserOperationCall
-              | (ContractFunctionParameters & { to: Address; value: bigint })
-            if ('abi' in call)
+            const call = call_ as Call
+            if (call.abi)
               return {
                 data: encodeFunctionData(call),
                 to: call.to,
                 value: call.value,
-              } as UserOperationCall
-            return call as UserOperationCall
+              } as Call
+            return call as Call
           }),
         )
       return parameters.callData

package/account-abstraction/actions/bundler/sendUserOperation.ts

@@ -5,6 +5,7 @@ import type { Transport } from '../../../clients/transports/createTransport.js'
 import { AccountNotFoundError } from '../../../errors/account.js'
 import type { BaseError } from '../../../errors/base.js'
 import type { ErrorType } from '../../../errors/utils.js'
+import type { Calls } from '../../../types/calls.js'
 import type { Chain } from '../../../types/chain.js'
 import type { Hex } from '../../../types/misc.js'
 import type { Assign, MaybeRequired, OneOf } from '../../../types/utils.js'
@@ -22,7 +23,6 @@ import type {
 } from '../../types/entryPointVersion.js'
 import type {
   UserOperation,
-  UserOperationCalls,
   UserOperationRequest,
 } from '../../types/userOperation.js'
 import { getUserOperationError } from '../../utils/errors/getUserOperationError.js'
@@ -53,9 +53,7 @@ export type SendUserOperationParameters<
     | Assign<
         // Accept a partially-formed User Operation (UserOperationRequest) to be filled.
         UserOperationRequest<_derivedVersion>,
-        OneOf<
-          { calls: UserOperationCalls<Narrow<calls>> } | { callData: Hex }
-        > & {
+        OneOf<{ calls: Calls<Narrow<calls>> } | { callData: Hex }> & {
           paymaster?:
             | Address
             | true

package/account-abstraction/index.ts

@@ -202,8 +202,6 @@ export type {
   UserOperationReceipt,
   UserOperationRequest,
   PackedUserOperation,
-  UserOperationCall,
-  UserOperationCalls,
 } from './types/userOperation.js'
 
 export {

package/account-abstraction/types/userOperation.ts

@@ -1,10 +1,8 @@
-import type { AbiStateMutability, Address } from 'abitype'
-import type { ContractFunctionParameters } from '../../types/contract.js'
+import type { Address } from 'abitype'
 import type { Log } from '../../types/log.js'
 import type { Hash, Hex } from '../../types/misc.js'
-import type { GetMulticallContractParameters } from '../../types/multicall.js'
 import type { TransactionReceipt } from '../../types/transaction.js'
-import type { OneOf, Prettify, UnionPartialBy } from '../../types/utils.js'
+import type { OneOf, UnionPartialBy } from '../../types/utils.js'
 import type { EntryPointVersion } from './entryPointVersion.js'
 
 /** @link https://eips.ethereum.org/EIPS/eip-4337#-eth_estimateuseroperationgas */
@@ -192,71 +190,3 @@ export type UserOperationReceipt<
   /** Hash of the user operation. */
   userOpHash: Hash
 }
-
-export type UserOperationCall = {
-  to: Hex
-  data?: Hex | undefined
-  value?: bigint | undefined
-}
-
-export type UserOperationCalls<
-  calls extends readonly unknown[],
-  ///
-  result extends readonly any[] = [],
-> = calls extends readonly [] // no calls, return empty
-  ? readonly []
-  : calls extends readonly [infer call] // one call left before returning `result`
-    ? readonly [
-        ...result,
-        Prettify<
-          OneOf<
-            | (Omit<
-                GetMulticallContractParameters<call, AbiStateMutability>,
-                'address'
-              > & {
-                to: Address
-                value?: bigint | undefined
-              })
-            | UserOperationCall
-          >
-        >,
-      ]
-    : calls extends readonly [infer call, ...infer rest] // grab first call and recurse through `rest`
-      ? UserOperationCalls<
-          [...rest],
-          [
-            ...result,
-            Prettify<
-              OneOf<
-                | (Omit<
-                    GetMulticallContractParameters<call, AbiStateMutability>,
-                    'address'
-                  > & {
-                    to: Address
-                    value?: bigint | undefined
-                  })
-                | UserOperationCall
-              >
-            >,
-          ]
-        >
-      : readonly unknown[] extends calls
-        ? calls
-        : // If `calls` is *some* array but we couldn't assign `unknown[]` to it, then it must hold some known/homogenous type!
-          // use this to infer the param types in the case of Array.map() argument
-          calls extends readonly (infer call extends OneOf<
-              | (Omit<ContractFunctionParameters, 'address'> & {
-                  to: Address
-                  value?: bigint | undefined
-                })
-              | UserOperationCall
-            >)[]
-          ? readonly Prettify<call>[]
-          : // Fallback
-            readonly OneOf<
-              | (Omit<ContractFunctionParameters, 'address'> & {
-                  to: Address
-                  value?: bigint | undefined
-                })
-              | UserOperationCall
-            >[]

package/account-abstraction/utils/errors/getUserOperationError.ts

@@ -1,4 +1,4 @@
-import type { Address } from 'abitype'
+import type { Abi, Address } from 'abitype'
 import { BaseError } from '../../../errors/base.js'
 import {
   ContractFunctionExecutionError,
@@ -6,9 +6,8 @@ import {
   ContractFunctionZeroDataError,
 } from '../../../errors/contract.js'
 import type { ErrorType } from '../../../errors/utils.js'
-import type { ContractFunctionParameters } from '../../../types/contract.js'
+import type { Call } from '../../../types/calls.js'
 import type { Hex } from '../../../types/misc.js'
-import type { OneOf } from '../../../types/utils.js'
 import { decodeErrorResult } from '../../../utils/abi/decodeErrorResult.js'
 import type { GetContractErrorReturnType } from '../../../utils/errors/getContractError.js'
 import { ExecutionRevertedError } from '../../errors/bundler.js'
@@ -16,22 +15,12 @@ import {
   UserOperationExecutionError,
   type UserOperationExecutionErrorType,
 } from '../../errors/userOperation.js'
-import type {
-  UserOperation,
-  UserOperationCall,
-} from '../../types/userOperation.js'
+import type { UserOperation } from '../../types/userOperation.js'
 import {
   type GetBundlerErrorParameters,
   getBundlerError,
 } from './getBundlerError.js'
 
-type Call = OneOf<
-  | UserOperationCall
-  | (ContractFunctionParameters & {
-      to: Address
-    })
->
-
 type GetNodeErrorReturnType = ErrorType
 
 export type GetUserOperationErrorParameters = UserOperation & {
@@ -106,7 +95,7 @@ function getContractError(parameters: {
   const { abi, functionName, args, to } = (() => {
     const contractCalls = calls?.filter((call) =>
       Boolean(call.abi),
-    ) as readonly (ContractFunctionParameters & { to: Address })[]
+    ) as readonly Call[]
 
     if (contractCalls.length === 1) return contractCalls[0]
 
@@ -133,7 +122,12 @@ function getContractError(parameters: {
       args: undefined,
       to: undefined,
     }
-  })()
+  })() as {
+    abi: Abi
+    functionName: string
+    args: unknown[]
+    to: Address
+  }
 
   const cause = (() => {
     if (revertData === '0x')

package/actions/index.ts

@@ -46,6 +46,12 @@ export {
   type CallReturnType,
   call,
 } from './public/call.js'
+export {
+  type CreateAccessListErrorType,
+  type CreateAccessListParameters,
+  type CreateAccessListReturnType,
+  createAccessList,
+} from './public/createAccessList.js'
 export {
   type CreateBlockFilterErrorType,
   type CreateBlockFilterReturnType,

package/actions/public/createAccessList.ts

@@ -0,0 +1,159 @@
+import type { Address } from 'abitype'
+
+import type { Account } from '../../accounts/types.js'
+import {
+  type ParseAccountErrorType,
+  parseAccount,
+} from '../../accounts/utils/parseAccount.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 { BlockTag } from '../../types/block.js'
+import type { Chain } from '../../types/chain.js'
+import type { RpcTransactionRequest } from '../../types/rpc.js'
+import type { AccessList, TransactionRequest } from '../../types/transaction.js'
+import type { ExactPartial, UnionOmit } from '../../types/utils.js'
+import type { RequestErrorType } from '../../utils/buildRequest.js'
+import {
+  type NumberToHexErrorType,
+  numberToHex,
+} from '../../utils/encoding/toHex.js'
+import {
+  type GetCallErrorReturnType,
+  getCallError,
+} from '../../utils/errors/getCallError.js'
+import { extract } from '../../utils/formatters/extract.js'
+import {
+  type FormatTransactionRequestErrorType,
+  type FormattedTransactionRequest,
+  formatTransactionRequest,
+} from '../../utils/formatters/transactionRequest.js'
+import { assertRequest } from '../../utils/transaction/assertRequest.js'
+import type {
+  AssertRequestErrorType,
+  AssertRequestParameters,
+} from '../../utils/transaction/assertRequest.js'
+
+export type CreateAccessListParameters<
+  chain extends Chain | undefined = Chain | undefined,
+> = UnionOmit<
+  FormattedTransactionRequest<chain>,
+  'from' | 'nonce' | 'accessList'
+> & {
+  /** Account attached to the call (msg.sender). */
+  account?: Account | Address | undefined
+} & (
+    | {
+        /** The balance of the account at a block number. */
+        blockNumber?: bigint | undefined
+        blockTag?: undefined
+      }
+    | {
+        blockNumber?: undefined
+        /**
+         * The balance of the account at a block tag.
+         * @default 'latest'
+         */
+        blockTag?: BlockTag | undefined
+      }
+  )
+
+export type CreateAccessListReturnType = {
+  accessList: AccessList
+  gasUsed: bigint
+}
+
+export type CreateAccessListErrorType = GetCallErrorReturnType<
+  | ParseAccountErrorType
+  | AssertRequestErrorType
+  | NumberToHexErrorType
+  | FormatTransactionRequestErrorType
+  | RequestErrorType
+>
+
+/**
+ * Creates an EIP-2930 access list.
+ *
+ * - Docs: https://viem.sh/docs/actions/public/createAccessList
+ * - JSON-RPC Methods: `eth_createAccessList`
+ *
+ * @param client - Client to use
+ * @param parameters - {@link CreateAccessListParameters}
+ * @returns The access list. {@link CreateAccessListReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { createAccessList } from 'viem/public'
+ *
+ * const client = createPublicClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const data = await createAccessList(client, {
+ *   account: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+ *   data: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ * })
+ */
+export async function createAccessList<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
+  args: CreateAccessListParameters<chain>,
+): Promise<CreateAccessListReturnType> {
+  const {
+    account: account_ = client.account,
+    blockNumber,
+    blockTag = 'latest',
+    blobs,
+    data,
+    gas,
+    gasPrice,
+    maxFeePerBlobGas,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    to,
+    value,
+    ...rest
+  } = args
+  const account = account_ ? parseAccount(account_) : undefined
+
+  try {
+    assertRequest(args as AssertRequestParameters)
+
+    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : undefined
+    const block = blockNumberHex || blockTag
+
+    const chainFormat = client.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 }),
+      from: account?.address,
+      blobs,
+      data,
+      gas,
+      gasPrice,
+      maxFeePerBlobGas,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      to,
+      value,
+    } as TransactionRequest) as TransactionRequest
+
+    const response = await client.request({
+      method: 'eth_createAccessList',
+      params: [request as ExactPartial<RpcTransactionRequest>, block],
+    })
+    return {
+      accessList: response.accessList,
+      gasUsed: BigInt(response.gasUsed),
+    }
+  } catch (err) {
+    throw getCallError(err as ErrorType, {
+      ...args,
+      account,
+      chain: client.chain,
+    })
+  }
+}

package/clients/decorators/public.ts

@@ -30,6 +30,11 @@ import {
   type CallReturnType,
   call,
 } from '../../actions/public/call.js'
+import {
+  type CreateAccessListParameters,
+  type CreateAccessListReturnType,
+  createAccessList,
+} from '../../actions/public/createAccessList.js'
 import {
   type CreateBlockFilterReturnType,
   createBlockFilter,
@@ -285,6 +290,32 @@ export type PublicActions<
    * })
    */
   call: (parameters: CallParameters<chain>) => Promise<CallReturnType>
+  /**
+   * Creates an EIP-2930 access list that you can include in a transaction.
+   *
+   * - Docs: https://viem.sh/docs/actions/public/createAccessList
+   * - JSON-RPC Methods: `eth_createAccessList`
+   *
+   * @param args - {@link CreateAccessListParameters}
+   * @returns The call data. {@link CreateAccessListReturnType}
+   *
+   * @example
+   * import { createPublicClient, http } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createPublicClient({
+   *   chain: mainnet,
+   *   transport: http(),
+   * })
+   *
+   * const data = await client.createAccessList({
+   *   data: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+   *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   * })
+   */
+  createAccessList: (
+    parameters: CreateAccessListParameters<chain>,
+  ) => Promise<CreateAccessListReturnType>
   /**
    * Creates a Filter to listen for new block hashes that can be used with [`getFilterChanges`](https://viem.sh/docs/actions/public/getFilterChanges).
    *
@@ -1833,6 +1864,7 @@ export function publicActions<
 ): PublicActions<transport, chain, account> {
   return {
     call: (args) => call(client, args),
+    createAccessList: (args) => createAccessList(client, args),
     createBlockFilter: () => createBlockFilter(client),
     createContractEventFilter: (args) =>
       createContractEventFilter(client, args),

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.21.58'
+export const version = '2.21.60'

package/experimental/erc7821/actions/execute.ts

@@ -0,0 +1,232 @@
+import type { Abi, Address, Narrow } from 'abitype'
+import * as AbiError from 'ox/AbiError'
+import * as AbiParameters from 'ox/AbiParameters'
+
+import {
+  type SendTransactionErrorType,
+  sendTransaction,
+} from '../../../actions/wallet/sendTransaction.js'
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import type { BaseError } from '../../../errors/base.js'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Account, GetAccountParameter } from '../../../types/account.js'
+import type { Call, Calls } from '../../../types/calls.js'
+import type {
+  Chain,
+  DeriveChain,
+  GetChainParameter,
+} from '../../../types/chain.js'
+import type { Hex } from '../../../types/misc.js'
+import type { UnionEvaluate, UnionPick } from '../../../types/utils.js'
+import {
+  type DecodeErrorResultErrorType,
+  decodeErrorResult,
+} from '../../../utils/abi/decodeErrorResult.js'
+import {
+  type EncodeFunctionDataErrorType,
+  encodeFunctionData,
+} from '../../../utils/abi/encodeFunctionData.js'
+import {
+  type GetContractErrorReturnType,
+  getContractError,
+} from '../../../utils/errors/getContractError.js'
+import type { FormattedTransactionRequest } from '../../../utils/formatters/transactionRequest.js'
+import { abi, executionMode } from '../constants.js'
+import {
+  ExecuteUnsupportedError,
+  FunctionSelectorNotRecognizedError,
+} from '../errors.js'
+import { supportsExecutionMode } from './supportsExecutionMode.js'
+
+export type ExecuteParameters<
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+  calls extends readonly unknown[] = readonly unknown[],
+  _derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
+> = UnionEvaluate<
+  UnionPick<
+    FormattedTransactionRequest<_derivedChain>,
+    | 'authorizationList'
+    | 'gas'
+    | 'gasPrice'
+    | 'maxFeePerGas'
+    | 'maxPriorityFeePerGas'
+  >
+> &
+  GetAccountParameter<account, Account | Address, true, true> &
+  GetChainParameter<chain, chainOverride> & {
+    /** Address that will execute the calls. */
+    address: Address
+    /** Calls to execute. */
+    calls: Calls<Narrow<calls>>
+    /** Additional data to include for execution. */
+    opData?: Hex | undefined
+  }
+
+export type ExecuteReturnType = Hex
+
+export type ExecuteErrorType =
+  | DecodeErrorResultErrorType
+  | GetContractErrorReturnType
+  | EncodeFunctionDataErrorType
+  | SendTransactionErrorType
+  | ErrorType
+
+/**
+ * Executes call(s) using the `execute` function on an [ERC-7821-compatible contract](https://eips.ethereum.org/EIPS/eip-7821).
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { execute } from 'viem/experimental/erc7821'
+ *
+ * const account = privateKeyToAccount('0x...')
+ *
+ * const client = createClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ *
+ * const hash = await execute(client, {
+ *   account,
+ *   calls: [{
+ *     {
+ *       data: '0xdeadbeef',
+ *       to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *     },
+ *     {
+ *       to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *       value: 69420n,
+ *     },
+ *   }],
+ *   to: account.address,
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Account Hoisting
+ * import { createClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { execute } from 'viem/experimental/erc7821'
+ *
+ * const account = privateKeyToAccount('0x...')
+ *
+ * const client = createClient({
+ *   account,
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ *
+ * const hash = await execute(client, {
+ *   calls: [{
+ *     {
+ *       data: '0xdeadbeef',
+ *       to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *     },
+ *     {
+ *       to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *       value: 69420n,
+ *     },
+ *   }],
+ *   to: account.address,
+ * })
+ * ```
+ *
+ * @param client - Client to use.
+ * @param parameters - {@link ExecuteParameters}
+ * @returns Transaction hash. {@link ExecuteReturnType}
+ */
+export async function execute<
+  const calls extends readonly unknown[],
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  chainOverride extends Chain | undefined = undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: ExecuteParameters<chain, account, chainOverride, calls>,
+): Promise<ExecuteReturnType> {
+  const { address, authorizationList, opData } = parameters
+
+  const calls = parameters.calls.map((call_) => {
+    const call = call_ as Call
+    return {
+      data: call.abi ? encodeFunctionData(call) : (call.data ?? '0x'),
+      value: call.value ?? 0n,
+      target: call.to,
+    }
+  })
+  const mode = opData ? executionMode.opData : executionMode.default
+
+  const encodedCalls = AbiParameters.encode(
+    AbiParameters.from([
+      'struct Call { address target; uint256 value; bytes data; }',
+      'Call[] calls',
+      ...(opData ? ['bytes opData'] : []),
+    ]),
+    [calls, ...(opData ? [opData] : [])] as any,
+  )
+
+  const supported = await supportsExecutionMode(client, {
+    address: authorizationList?.[0]?.contractAddress ?? address,
+    opData,
+  })
+  if (!supported) throw new ExecuteUnsupportedError()
+
+  try {
+    return await sendTransaction(client, {
+      ...parameters,
+      to: address,
+      data: encodeFunctionData({
+        abi,
+        functionName: 'execute',
+        args: [mode, encodedCalls],
+      }),
+    } as any)
+  } catch (e) {
+    const error = (e as BaseError).walk((e) => 'data' in (e as Error)) as
+      | (BaseError & { data?: Hex | undefined })
+      | undefined
+
+    if (!error?.data) throw e
+    if (
+      error.data ===
+      AbiError.getSelector(AbiError.from('error FnSelectorNotRecognized()'))
+    )
+      throw new FunctionSelectorNotRecognizedError()
+
+    const matched = parameters.calls.find((call_) => {
+      const call = call_ as Call
+      if (!call.abi) return false
+      try {
+        return Boolean(
+          decodeErrorResult({
+            abi: call.abi,
+            data: error.data!,
+          }),
+        )
+      } catch {
+        return false
+      }
+    }) as {
+      abi: Abi
+      functionName: string
+      args: unknown[]
+      to: Address
+    } | null
+    if (!matched) throw e
+
+    throw getContractError(error as BaseError, {
+      abi: matched.abi,
+      address: matched.to,
+      args: matched.args,
+      docsPath: '/experimental/erc7821/execute',
+      functionName: matched.functionName,
+    })
+  }
+}