viem 2.35.0 → 2.36.0-jxom-erc8010-20250826223301

package/actions/public/multicall.ts

@@ -3,9 +3,11 @@ import type { AbiStateMutability, Address, Narrow } from 'abitype'
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import { multicall3Abi } from '../../constants/abis.js'
+import { multicall3Bytecode } from '../../constants/contracts.js'
 import { AbiDecodingZeroDataError } from '../../errors/abi.js'
 import { BaseError } from '../../errors/base.js'
 import { RawContractError } from '../../errors/contract.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
 import type { ContractFunctionParameters } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
@@ -13,6 +15,7 @@ import type {
   MulticallContracts,
   MulticallResults,
 } from '../../types/multicall.js'
+import type { OneOf } from '../../types/utils.js'
 import {
   type DecodeFunctionResultErrorType,
   decodeFunctionResult,
@@ -29,8 +32,6 @@ import {
   type GetContractErrorReturnType,
   getContractError,
 } from '../../utils/errors/getContractError.js'
-
-import type { ErrorType } from '../../errors/utils.js'
 import { getAction } from '../../utils/getAction.js'
 import type { CallParameters } from './call.js'
 import { type ReadContractErrorType, readContract } from './readContract.js'
@@ -42,16 +43,31 @@ export type MulticallParameters<
     optional?: boolean
     properties?: Record<string, any>
   } = {},
-> = Pick<CallParameters, 'blockNumber' | 'blockTag' | 'stateOverride'> & {
+> = Pick<
+  CallParameters,
+  'authorizationList' | 'blockNumber' | 'blockTag' | 'stateOverride'
+> & {
+  /** The account to use for the multicall. */
   account?: Address | undefined
+  /** Whether to allow failures. */
   allowFailure?: allowFailure | boolean | undefined
+  /** The size of each batch of calls. */
   batchSize?: number | undefined
+  /** The contracts to call. */
   contracts: MulticallContracts<
     Narrow<contracts>,
     { mutability: AbiStateMutability } & options
   >
-  multicallAddress?: Address | undefined
-}
+} & OneOf<
+    | {
+        /** The address of the multicall3 contract to use. */
+        multicallAddress?: Address | undefined
+      }
+    | {
+        /** Enable deployless multicall. */
+        deployless?: boolean | undefined
+      }
+  >
 
 export type MulticallReturnType<
   contracts extends readonly unknown[] = readonly ContractFunctionParameters[],
@@ -122,34 +138,33 @@ export async function multicall<
 ): Promise<MulticallReturnType<contracts, allowFailure>> {
   const {
     account,
+    authorizationList,
     allowFailure = true,
-    batchSize: batchSize_,
     blockNumber,
     blockTag,
-    multicallAddress: multicallAddress_,
     stateOverride,
   } = parameters
   const contracts = parameters.contracts as ContractFunctionParameters[]
 
-  const batchSize =
-    batchSize_ ??
-    ((typeof client.batch?.multicall === 'object' &&
-      client.batch.multicall.batchSize) ||
-      1_024)
-
-  let multicallAddress = multicallAddress_
-  if (!multicallAddress) {
-    if (!client.chain)
-      throw new Error(
-        'client chain not configured. multicallAddress is required.',
-      )
+  const {
+    batchSize = parameters.batchSize ?? 1024,
+    deployless = parameters.deployless ?? false,
+  } = typeof client.batch?.multicall === 'object' ? client.batch.multicall : {}
 
-    multicallAddress = getChainContractAddress({
-      blockNumber,
-      chain: client.chain,
-      contract: 'multicall3',
-    })
-  }
+  const multicallAddress = (() => {
+    if (parameters.multicallAddress) return parameters.multicallAddress
+    if (deployless) return null
+    if (client.chain) {
+      return getChainContractAddress({
+        blockNumber,
+        chain: client.chain,
+        contract: 'multicall3',
+      })
+    }
+    throw new Error(
+      'client chain not configured. multicallAddress is required.',
+    )
+  })()
 
   type Aggregate3Calls = {
     allowFailure: boolean
@@ -216,10 +231,13 @@ export async function multicall<
         readContract,
         'readContract',
       )({
+        ...(multicallAddress === null
+          ? { code: multicall3Bytecode }
+          : { address: multicallAddress }),
         abi: multicall3Abi,
         account,
-        address: multicallAddress!,
         args: [calls],
+        authorizationList,
         blockNumber,
         blockTag,
         functionName: 'aggregate3',

package/actions/public/readContract.ts

@@ -43,6 +43,7 @@ export type ReadContractParameters<
   Pick<
     CallParameters,
     | 'account'
+    | 'authorizationList'
     | 'blockNumber'
     | 'blockTag'
     | 'factory'

package/actions/public/simulateBlocks.ts

@@ -261,7 +261,7 @@ export async function simulateBlocks<
         const error = (() => {
           if (status === 'success') return undefined
 
-          let error = undefined
+          let error: Error | undefined
           if (call.error?.data === '0x') error = new AbiDecodingZeroDataError()
           else if (call.error) error = new RawContractError(call.error)
 

package/actions/public/simulateContract.ts

@@ -18,6 +18,7 @@ import type {
   ExtractAbiFunctionForArgs,
 } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
+import type { TransactionRequest } from '../../types/transaction.js'
 import type {
   IsNarrowable,
   NoInfer,
@@ -37,10 +38,8 @@ import {
   type GetContractErrorReturnType,
   getContractError,
 } from '../../utils/errors/getContractError.js'
-import type { WriteContractParameters } from '../wallet/writeContract.js'
-
-import type { TransactionRequest } from '../../types/transaction.js'
 import { getAction } from '../../utils/getAction.js'
+import type { WriteContractParameters } from '../wallet/writeContract.js'
 import { type CallErrorType, type CallParameters, call } from './call.js'
 
 export type GetMutabilityAwareValue<

package/actions/public/verifyHash.ts

@@ -1,10 +1,22 @@
 import type { Address } from 'abitype'
+import * as SignatureErc6492 from 'ox/erc6492/SignatureErc6492'
+import * as SignatureErc8010 from 'ox/erc8010/SignatureErc8010'
 
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
-import { universalSignatureValidatorAbi } from '../../constants/abis.js'
-import { universalSignatureValidatorByteCode } from '../../constants/contracts.js'
-import { CallExecutionError } from '../../errors/contract.js'
+import {
+  erc1271Abi,
+  erc6492SignatureValidatorAbi,
+  multicall3Abi,
+} from '../../constants/abis.js'
+import {
+  erc6492SignatureValidatorByteCode,
+  multicall3Bytecode,
+} from '../../constants/contracts.js'
+import {
+  CallExecutionError,
+  ContractFunctionExecutionError,
+} from '../../errors/contract.js'
 import type { InvalidHexBooleanError } from '../../errors/encoding.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
@@ -17,14 +29,18 @@ import {
 import { getAddress } from '../../utils/address/getAddress.js'
 import { isAddressEqual } from '../../utils/address/isAddressEqual.js'
 import { type IsHexErrorType, isHex } from '../../utils/data/isHex.js'
-import { type ToHexErrorType, bytesToHex } from '../../utils/encoding/toHex.js'
+import {
+  bytesToHex,
+  numberToHex,
+  type ToHexErrorType,
+} from '../../utils/encoding/toHex.js'
 import { getAction } from '../../utils/getAction.js'
-import { encodeFunctionData, hexToBool } from '../../utils/index.js'
-import { isErc6492Signature } from '../../utils/signature/isErc6492Signature.js'
+import { concatHex, encodeFunctionData, hexToBool } from '../../utils/index.js'
 import { recoverAddress } from '../../utils/signature/recoverAddress.js'
-import { serializeErc6492Signature } from '../../utils/signature/serializeErc6492Signature.js'
 import { serializeSignature } from '../../utils/signature/serializeSignature.js'
 import { type CallErrorType, type CallParameters, call } from './call.js'
+import { getCode } from './getCode.js'
+import { readContract } from './readContract.js'
 
 export type VerifyHashParameters = Pick<
   CallParameters,
@@ -32,10 +48,13 @@ export type VerifyHashParameters = Pick<
 > & {
   /** The address that signed the original message. */
   address: Address
+  /** The address of the ERC-6492 signature verifier contract. */
+  erc6492VerifierAddress?: Address | undefined
   /** The hash to be verified. */
   hash: Hex
   /** The signature that was generated by signing the message with the address's private key. */
   signature: Hex | ByteArray | Signature
+  /** @deprecated use `erc6492VerifierAddress` instead. */
   universalSignatureVerifierAddress?: Address | undefined
 } & OneOf<{ factory: Address; factoryData: Hex } | {}>
 
@@ -62,62 +81,31 @@ export async function verifyHash<chain extends Chain | undefined>(
 ): Promise<VerifyHashReturnType> {
   const {
     address,
-    factory,
-    factoryData,
     hash,
-    signature,
-    universalSignatureVerifierAddress = client.chain?.contracts
-      ?.universalSignatureVerifier?.address,
-    ...rest
+    erc6492VerifierAddress:
+      verifierAddress = parameters.universalSignatureVerifierAddress ??
+      client.chain?.contracts?.erc6492Verifier?.address,
   } = parameters
 
-  const signatureHex = (() => {
+  const signature = (() => {
+    const signature = parameters.signature
     if (isHex(signature)) return signature
     if (typeof signature === 'object' && 'r' in signature && 's' in signature)
       return serializeSignature(signature)
     return bytesToHex(signature)
   })()
 
-  const wrappedSignature = await (async () => {
-    // If no `factory` or `factoryData` is provided, it is assumed that the
-    // address is not a Smart Account, or the Smart Account is already deployed.
-    if (!factory && !factoryData) return signatureHex
-
-    // If the signature is already wrapped, return the signature.
-    if (isErc6492Signature(signatureHex)) return signatureHex
-
-    // If the Smart Account is not deployed, wrap the signature with a 6492 wrapper
-    // to perform counterfactual validation.
-    return serializeErc6492Signature({
-      address: factory!,
-      data: factoryData!,
-      signature: signatureHex,
-    })
-  })()
-
   try {
-    const args = universalSignatureVerifierAddress
-      ? ({
-          to: universalSignatureVerifierAddress,
-          data: encodeFunctionData({
-            abi: universalSignatureValidatorAbi,
-            functionName: 'isValidSig',
-            args: [address, hash, wrappedSignature],
-          }),
-          ...rest,
-        } as unknown as CallParameters)
-      : ({
-          data: encodeDeployData({
-            abi: universalSignatureValidatorAbi,
-            args: [address, hash, wrappedSignature],
-            bytecode: universalSignatureValidatorByteCode,
-          }),
-          ...rest,
-        } as unknown as CallParameters)
-
-    const { data } = await getAction(client, call, 'call')(args)
-
-    return hexToBool(data ?? '0x0')
+    if (SignatureErc8010.validate(signature))
+      return await verifyErc8010(client, {
+        ...parameters,
+        signature,
+      })
+    return await verifyErc6492(client, {
+      ...parameters,
+      verifierAddress,
+      signature,
+    })
   } catch (error) {
     // Fallback attempt to verify the signature via ECDSA recovery.
     try {
@@ -128,7 +116,7 @@ export async function verifyHash<chain extends Chain | undefined>(
       if (verified) return true
     } catch {}
 
-    if (error instanceof CallExecutionError) {
+    if (error instanceof VerificationError) {
       // if the execution fails, the signature was not valid and an internal method inside of the validator reverted
       // this can happen for many reasons, for example if signer can not be recovered from the signature
       // or if the signature has no valid format
@@ -138,3 +126,214 @@ export async function verifyHash<chain extends Chain | undefined>(
     throw error
   }
 }
+
+/** @internal */
+export async function verifyErc8010(
+  client: Client,
+  parameters: verifyErc8010.Parameters,
+) {
+  const { address, blockNumber, blockTag, hash } = parameters
+
+  const {
+    authorization,
+    data: initData,
+    signature,
+  } = SignatureErc8010.unwrap(parameters.signature)
+
+  // Check if already delegated
+  const code = await getCode(client, {
+    address,
+    blockNumber,
+    blockTag,
+  } as never)
+
+  // If already delegated, perform standard ERC-1271 verification.
+  if (code === concatHex(['0xef0100', authorization.address]))
+    return await verifyErc1271(client, {
+      address,
+      blockNumber,
+      blockTag,
+      hash,
+      signature,
+    })
+
+  // Deployless verification.
+  const results = await getAction(
+    client,
+    readContract,
+    'readContract',
+  )({
+    authorizationList: [
+      {
+        address: authorization.address,
+        chainId: Number(authorization.chainId),
+        nonce: Number(authorization.nonce),
+        r: numberToHex(authorization.r, { size: 32 }),
+        s: numberToHex(authorization.s, { size: 32 }),
+        yParity: authorization.yParity,
+      },
+    ],
+    abi: multicall3Abi,
+    blockNumber,
+    blockTag: 'pending',
+    code: multicall3Bytecode,
+    functionName: 'aggregate3',
+    args: [
+      [
+        ...(initData
+          ? [
+              {
+                allowFailure: false,
+                target: address,
+                callData: initData,
+              },
+            ]
+          : []),
+        {
+          allowFailure: false,
+          target: address,
+          callData: encodeFunctionData({
+            abi: erc1271Abi,
+            functionName: 'isValidSignature',
+            args: [hash, signature],
+          }),
+        },
+      ],
+    ],
+  })
+
+  const data = results[results.length - 1]?.returnData
+
+  if (data?.startsWith('0x1626ba7e')) return true
+  throw new VerificationError()
+}
+
+export namespace verifyErc8010 {
+  export type Parameters = Pick<CallParameters, 'blockNumber' | 'blockTag'> & {
+    /** The address that signed the original message. */
+    address: Address
+    /** The hash to be verified. */
+    hash: Hex
+    /** The signature that was generated by signing the message with the address's private key. */
+    signature: Hex
+  }
+}
+
+/** @internal */
+// biome-ignore lint/correctness/noUnusedVariables: _
+async function verifyErc6492(
+  client: Client,
+  parameters: verifyErc6492.Parameters,
+) {
+  const {
+    address,
+    factory,
+    factoryData,
+    hash,
+    signature,
+    verifierAddress,
+    ...rest
+  } = parameters
+
+  const wrappedSignature = await (async () => {
+    // If no `factory` or `factoryData` is provided, it is assumed that the
+    // address is not a Smart Account, or the Smart Account is already deployed.
+    if (!factory && !factoryData) return signature
+
+    // If the signature is already wrapped, return the signature.
+    if (SignatureErc6492.validate(signature)) return signature
+
+    // If the Smart Account is not deployed, wrap the signature with a 6492 wrapper
+    // to perform counterfactual validation.
+    return SignatureErc6492.wrap({
+      data: factoryData!,
+      signature,
+      to: factory!,
+    })
+  })()
+
+  const args = verifierAddress
+    ? ({
+        to: verifierAddress,
+        data: encodeFunctionData({
+          abi: erc6492SignatureValidatorAbi,
+          functionName: 'isValidSig',
+          args: [address, hash, wrappedSignature],
+        }),
+        ...rest,
+      } as unknown as CallParameters)
+    : ({
+        data: encodeDeployData({
+          abi: erc6492SignatureValidatorAbi,
+          args: [address, hash, wrappedSignature],
+          bytecode: erc6492SignatureValidatorByteCode,
+        }),
+        ...rest,
+      } as unknown as CallParameters)
+
+  const { data } = await getAction(
+    client,
+    call,
+    'call',
+  )(args).catch((error) => {
+    if (error instanceof CallExecutionError) throw new VerificationError()
+    throw error
+  })
+
+  if (hexToBool(data ?? '0x0')) return true
+  throw new VerificationError()
+}
+
+export namespace verifyErc6492 {
+  export type Parameters = Pick<CallParameters, 'blockNumber' | 'blockTag'> & {
+    /** The address that signed the original message. */
+    address: Address
+    /** The hash to be verified. */
+    hash: Hex
+    /** The signature that was generated by signing the message with the address's private key. */
+    signature: Hex
+    /** The address of the ERC-6492 signature verifier contract. */
+    verifierAddress?: Address | undefined
+  } & OneOf<{ factory: Address; factoryData: Hex } | {}>
+}
+
+/** @internal */
+export async function verifyErc1271(
+  client: Client,
+  parameters: verifyErc1271.Parameters,
+) {
+  const { address, blockNumber, blockTag, hash, signature } = parameters
+
+  const result = await getAction(
+    client,
+    readContract,
+    'readContract',
+  )({
+    address,
+    abi: erc1271Abi,
+    args: [hash, signature],
+    blockNumber,
+    blockTag,
+    functionName: 'isValidSignature',
+  }).catch((error) => {
+    if (error instanceof ContractFunctionExecutionError)
+      throw new VerificationError()
+    throw error
+  })
+
+  if (result.startsWith('0x1626ba7e')) return true
+  throw new VerificationError()
+}
+
+export namespace verifyErc1271 {
+  export type Parameters = Pick<CallParameters, 'blockNumber' | 'blockTag'> & {
+    /** The address that signed the original message. */
+    address: Address
+    /** The hash to be verified. */
+    hash: Hex
+    /** The signature that was generated by signing the message with the address's private key. */
+    signature: Hex
+  }
+}
+
+class VerificationError extends Error {}

package/actions/public/verifyMessage.ts

@@ -11,8 +11,8 @@ import type {
   Signature,
 } from '../../types/misc.js'
 import type { Prettify } from '../../types/utils.js'
-import { hashMessage } from '../../utils/signature/hashMessage.js'
 import type { HashMessageErrorType } from '../../utils/signature/hashMessage.js'
+import { hashMessage } from '../../utils/signature/hashMessage.js'
 import {
   type VerifyHashErrorType,
   type VerifyHashParameters,

package/actions/public/waitForTransactionReceipt.ts

@@ -166,7 +166,6 @@ export async function waitForTransactionReceipt<
   let receipt: GetTransactionReceiptReturnType<chain> | undefined
   let retrying = false
 
-  // biome-ignore lint/style/useConst:
   let _unobserve: () => void
   let _unwatch: () => void
 

package/actions/public/watchContractEvent.ts

@@ -2,10 +2,6 @@ import type { Abi, Address, ExtractAbiEvent } from 'abitype'
 
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
-import type { Chain } from '../../types/chain.js'
-import type { Filter } from '../../types/filter.js'
-import type { Log } from '../../types/log.js'
-
 import {
   DecodeLogDataMismatch,
   DecodeLogTopicsMismatch,
@@ -13,10 +9,13 @@ import {
 import { InvalidInputRpcError } from '../../errors/rpc.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type { BlockNumber } from '../../types/block.js'
+import type { Chain } from '../../types/chain.js'
 import type {
   ContractEventArgs,
   ContractEventName,
 } from '../../types/contract.js'
+import type { Filter } from '../../types/filter.js'
+import type { Log } from '../../types/log.js'
 import type { LogTopic } from '../../types/misc.js'
 import type { GetPollOptions } from '../../types/transport.js'
 import { decodeEventLog } from '../../utils/abi/decodeEventLog.js'

package/actions/public/watchEvent.ts

@@ -2,6 +2,13 @@ import type { AbiEvent, Address } from 'abitype'
 
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import {
+  DecodeLogDataMismatch,
+  DecodeLogTopicsMismatch,
+} from '../../errors/abi.js'
+import { InvalidInputRpcError } from '../../errors/rpc.js'
+import type { ErrorType } from '../../errors/utils.js'
+import type { BlockNumber } from '../../types/block.js'
 import type { Chain } from '../../types/chain.js'
 import type {
   MaybeAbiEventName,
@@ -11,24 +18,16 @@ import type { Filter } from '../../types/filter.js'
 import type { Log } from '../../types/log.js'
 import type { LogTopic } from '../../types/misc.js'
 import type { GetPollOptions } from '../../types/transport.js'
+import { decodeEventLog } from '../../utils/abi/decodeEventLog.js'
 import {
   type EncodeEventTopicsParameters,
   encodeEventTopics,
 } from '../../utils/abi/encodeEventTopics.js'
+import { formatLog } from '../../utils/formatters/log.js'
+import { getAction } from '../../utils/getAction.js'
 import { type ObserveErrorType, observe } from '../../utils/observe.js'
 import { poll } from '../../utils/poll.js'
 import { type StringifyErrorType, stringify } from '../../utils/stringify.js'
-
-import {
-  DecodeLogDataMismatch,
-  DecodeLogTopicsMismatch,
-} from '../../errors/abi.js'
-import { InvalidInputRpcError } from '../../errors/rpc.js'
-import type { ErrorType } from '../../errors/utils.js'
-import type { BlockNumber } from '../../types/block.js'
-import { decodeEventLog } from '../../utils/abi/decodeEventLog.js'
-import { formatLog } from '../../utils/formatters/log.js'
-import { getAction } from '../../utils/getAction.js'
 import {
   type CreateEventFilterParameters,
   createEventFilter,

package/actions/siwe/verifySiweMessage.ts

@@ -4,8 +4,8 @@ import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
 import type { Hex } from '../../types/misc.js'
 import type { Prettify } from '../../types/utils.js'
-import { hashMessage } from '../../utils/signature/hashMessage.js'
 import type { HashMessageErrorType } from '../../utils/signature/hashMessage.js'
+import { hashMessage } from '../../utils/signature/hashMessage.js'
 import { parseSiweMessage } from '../../utils/siwe/parseSiweMessage.js'
 import {
   type ValidateSiweMessageParameters,

package/actions/wallet/deployContract.ts

@@ -3,14 +3,12 @@ import type { Abi } from 'abitype'
 import type { Account } from '../../accounts/types.js'
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
-import type { Chain } from '../../types/chain.js'
-import type { GetChainParameter } from '../../types/chain.js'
+import type { ErrorType } from '../../errors/utils.js'
+import type { Chain, GetChainParameter } from '../../types/chain.js'
 import type { ContractConstructorArgs } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
 import type { UnionEvaluate, UnionOmit } from '../../types/utils.js'
 import { encodeDeployData } from '../../utils/abi/encodeDeployData.js'
-
-import type { ErrorType } from '../../errors/utils.js'
 import {
   type SendTransactionErrorType,
   type SendTransactionParameters,

package/actions/wallet/prepareTransactionRequest.ts

@@ -30,8 +30,11 @@ import {
 } from '../../errors/fee.js'
 import type { DeriveAccount, GetAccountParameter } from '../../types/account.js'
 import type { Block } from '../../types/block.js'
-import type { Chain, DeriveChain } from '../../types/chain.js'
-import type { GetChainParameter } from '../../types/chain.js'
+import type {
+  Chain,
+  DeriveChain,
+  GetChainParameter,
+} from '../../types/chain.js'
 import type { GetTransactionRequestKzgParameter } from '../../types/kzg.js'
 import type {
   TransactionRequest,

package/actions/wallet/sendTransaction.ts

@@ -53,8 +53,8 @@ import {
 } from '../../utils/transaction/assertRequest.js'
 import { type GetChainIdErrorType, getChainId } from '../public/getChainId.js'
 import {
-  type PrepareTransactionRequestErrorType,
   defaultParameters,
+  type PrepareTransactionRequestErrorType,
   prepareTransactionRequest,
 } from './prepareTransactionRequest.js'
 import {