viem 2.21.57 → 2.21.59

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 & {
@@ -58,7 +47,7 @@ export function getUserOperationError<err extends ErrorType<string>>(
     if (calls && cause instanceof ExecutionRevertedError) {
       const revertData = getRevertData(cause)
       const contractCalls = calls?.filter(
-        (call: any) => call.abi || call.data,
+        (call: any) => call.abi,
       ) as readonly Call[]
       if (revertData && contractCalls.length > 0)
         return getContractError({ calls: contractCalls, revertData })
@@ -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/public/getEip712Domain.ts

@@ -22,7 +22,7 @@ export type GetEip712DomainParameters = {
 export type GetEip712DomainReturnType = {
   domain: RequiredBy<
     TypedDataDomain,
-    'chainId' | 'name' | 'verifyingContract' | 'version'
+    'chainId' | 'name' | 'verifyingContract' | 'salt' | 'version'
   >
   fields: Hex
   extensions: readonly bigint[]

package/chains/definitions/arthera.ts

@@ -0,0 +1,25 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const arthera = /*#__PURE__*/ defineChain({
+  id: 10242,
+  name: 'Arthera',
+  nativeCurrency: { name: 'Arthera', symbol: 'AA', decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: ['https://rpc.arthera.net'],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: 'Arthera EVM Explorer',
+      url: 'https://explorer.arthera.net',
+      apiUrl: 'https://explorer.arthera.net/api',
+    },
+  },
+  contracts: {
+    multicall3: {
+      address: '0xca11bde05977b3631167028862be2a173976ca11',
+      blockCreated: 4502791,
+    },
+  },
+})

package/chains/index.ts

@@ -22,6 +22,7 @@ export { arbitrumSepolia } from './definitions/arbitrumSepolia.js'
 export { areonNetwork } from './definitions/areonNetwork.js'
 export { areonNetworkTestnet } from './definitions/areonNetworkTestnet.js'
 export { artelaTestnet } from './definitions/artelaTestnet.js'
+export { arthera } from './definitions/arthera.js'
 export { assetChain } from './definitions/assetChain.js'
 export { assetChainTestnet } from './definitions/assetChainTestnet.js'
 export { astar } from './definitions/astar.js'
@@ -225,9 +226,9 @@ export { kcc } from './definitions/kcc.js'
 export { kinto } from './definitions/kinto.js'
 /** @deprecated Use `kaia` instead. */
 export { klaytn } from './definitions/klaytn.js'
-/** @deprecated Use `kairos` instead. */
 export { kaia } from './definitions/kaia.js'
 export { kairos } from './definitions/kairos.js'
+/** @deprecated Use `kairos` instead. */
 export { klaytnBaobab } from './definitions/klaytnBaobab.js'
 export { koi } from './definitions/koi.js'
 export { kroma } from './definitions/kroma.js'

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.21.57'
+export const version = '2.21.59'

package/experimental/erc7739/utils/hashTypedData.ts

@@ -16,7 +16,7 @@ export type HashTypedDataParameters<
 > = TypedDataDefinition<typedData, primaryType, primaryTypes> & {
   verifierDomain: RequiredBy<
     TypedDataDomain,
-    'chainId' | 'name' | 'verifyingContract' | 'version'
+    'chainId' | 'name' | 'verifyingContract' | 'salt' | 'version'
   >
 }
 

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,
+    })
+  }
+}

package/experimental/erc7821/actions/supportsExecutionMode.ts

@@ -0,0 +1,60 @@
+import type { Address } from '../../../accounts/index.js'
+import { 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 { Chain } from '../../../types/chain.js'
+import type { Hex } from '../../../types/misc.js'
+import { abi, executionMode } from '../constants.js'
+
+export type SupportsExecutionModeParameters = {
+  address: Address
+  opData?: Hex | undefined
+}
+
+export type SupportsExecutionModeReturnType = boolean
+
+export type SupportsExecutionModeErrorType = ErrorType
+
+/**
+ * Checks if the contract supports the ERC-7821 execution mode.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { supportsExecutionMode } from 'viem/experimental/erc7821'
+ *
+ * const client = createClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ *
+ * const supported = await supportsExecutionMode(client, {
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ * })
+ * ```
+ *
+ * @param client - Client to use.
+ * @param parameters - {@link SupportsExecutionModeParameters}
+ * @returns If the execution mode is supported. {@link SupportsExecutionModeReturnType}
+ */
+export async function supportsExecutionMode<
+  chain extends Chain | undefined = Chain | undefined,
+>(
+  client: Client<Transport, chain>,
+  parameters: SupportsExecutionModeParameters,
+): Promise<SupportsExecutionModeReturnType> {
+  const { address, opData } = parameters
+  const mode = opData ? executionMode.opData : executionMode.default
+  try {
+    return await readContract(client, {
+      abi,
+      address,
+      functionName: 'supportsExecutionMode',
+      args: [mode],
+    })
+  } catch {
+    return false
+  }
+}

package/experimental/erc7821/constants.ts

@@ -0,0 +1,62 @@
+export const abi = [
+  {
+    type: 'fallback',
+    stateMutability: 'payable',
+  },
+  {
+    type: 'receive',
+    stateMutability: 'payable',
+  },
+  {
+    type: 'function',
+    name: 'execute',
+    inputs: [
+      {
+        name: 'mode',
+        type: 'bytes32',
+        internalType: 'bytes32',
+      },
+      {
+        name: 'executionData',
+        type: 'bytes',
+        internalType: 'bytes',
+      },
+    ],
+    outputs: [],
+    stateMutability: 'payable',
+  },
+  {
+    type: 'function',
+    name: 'supportsExecutionMode',
+    inputs: [
+      {
+        name: 'mode',
+        type: 'bytes32',
+        internalType: 'bytes32',
+      },
+    ],
+    outputs: [
+      {
+        name: 'result',
+        type: 'bool',
+        internalType: 'bool',
+      },
+    ],
+    stateMutability: 'view',
+  },
+  {
+    type: 'error',
+    name: 'FnSelectorNotRecognized',
+    inputs: [],
+  },
+  {
+    type: 'error',
+    name: 'UnsupportedExecutionMode',
+    inputs: [],
+  },
+] as const
+
+export const executionMode = {
+  default: '0x0100000000000000000000000000000000000000000000000000000000000000',
+  opData: '0x0100000000007821000100000000000000000000000000000000000000000000',
+} as const

package/experimental/erc7821/decorators/erc7821.ts

@@ -0,0 +1,149 @@
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import type { Account } from '../../../types/account.js'
+import type { Chain } from '../../../types/chain.js'
+import {
+  type ExecuteParameters,
+  type ExecuteReturnType,
+  execute,
+} from '../actions/execute.js'
+import {
+  type SupportsExecutionModeParameters,
+  type SupportsExecutionModeReturnType,
+  supportsExecutionMode,
+} from '../actions/supportsExecutionMode.js'
+
+export type Erc7821Actions<
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+> = {
+  /**
+   * 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 { erc7821Actions } from 'viem/experimental'
+   *
+   * const account = privateKeyToAccount('0x...')
+   *
+   * const client = createClient({
+   *   chain: mainnet,
+   *   transport: http(),
+   * }).extend(erc7821Actions())
+   *
+   * const hash = await client.execute({
+   *   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 { erc7821Actions } from 'viem/experimental'
+   *
+   * const account = privateKeyToAccount('0x...')
+   *
+   * const client = createClient({
+   *   account,
+   *   chain: mainnet,
+   *   transport: http(),
+   * }).extend(erc7821Actions())
+   *
+   * const hash = await client.execute({
+   *   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}
+   */
+  execute: <
+    const calls extends readonly unknown[],
+    chainOverride extends Chain | undefined = undefined,
+  >(
+    parameters: ExecuteParameters<chain, account, chainOverride, calls>,
+  ) => Promise<ExecuteReturnType>
+  /**
+   * Checks if the contract supports the ERC-7821 execution mode.
+   *
+   * @example
+   * ```ts
+   * import { createClient, http } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   * import { erc7821Actions } from 'viem/experimental'
+   *
+   * const client = createClient({
+   *   chain: mainnet,
+   *   transport: http(),
+   * }).extend(erc7821Actions())
+   *
+   * const supported = await supportsExecutionMode(client, {
+   *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   * })
+   * ```
+   *
+   * @param client - Client to use.
+   * @param parameters - {@link SupportsExecutionModeParameters}
+   * @returns If the execution mode is supported. {@link SupportsExecutionModeReturnType}
+   */
+  supportsExecutionMode: (
+    parameters: SupportsExecutionModeParameters,
+  ) => Promise<SupportsExecutionModeReturnType>
+}
+
+/**
+ * A suite of Actions for [ERC-7821](https://eips.ethereum.org/EIPS/eip-7821).
+ *
+ * @example
+ * import { createClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { erc7821Actions } from 'viem/experimental'
+ *
+ * const client = createClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * }).extend(erc7821Actions())
+ */
+export function erc7821Actions() {
+  return <
+    transport extends Transport,
+    chain extends Chain | undefined = Chain | undefined,
+    account extends Account | undefined = Account | undefined,
+  >(
+    client: Client<transport, chain, account>,
+  ): Erc7821Actions<chain, account> => {
+    return {
+      execute: (parameters) => execute(client, parameters),
+      supportsExecutionMode: (parameters) =>
+        supportsExecutionMode(client, parameters),
+    }
+  }
+}

package/experimental/erc7821/errors.ts

@@ -0,0 +1,29 @@
+import { BaseError } from '../../errors/base.js'
+
+export type ExecuteUnsupportedErrorType = ExecuteUnsupportedError & {
+  name: 'ExecuteUnsupportedError'
+}
+export class ExecuteUnsupportedError extends BaseError {
+  constructor() {
+    super('ERC-7821 execution is not supported.', {
+      name: 'ExecuteUnsupportedError',
+    })
+  }
+}
+
+export type FunctionSelectorNotRecognizedErrorType =
+  FunctionSelectorNotRecognizedError & {
+    name: 'FunctionSelectorNotRecognizedError'
+  }
+export class FunctionSelectorNotRecognizedError extends BaseError {
+  constructor() {
+    super('Function is not recognized.', {
+      metaMessages: [
+        'This could be due to any of the following:',
+        '  - The contract does not have the function,',
+        '  - The address is not a contract.',
+      ],
+      name: 'FunctionSelectorNotRecognizedError',
+    })
+  }
+}