viem 2.24.0 → 2.24.2

package/accounts/utils/signAuthorization.ts

@@ -1,6 +1,6 @@
 import type { ErrorType } from '../../errors/utils.js'
 import type {
-  Authorization,
+  AuthorizationRequest,
   SignedAuthorization,
 } from '../../types/authorization.js'
 import type { Hex, Signature } from '../../types/misc.js'
@@ -19,7 +19,7 @@ import {
 type To = 'object' | 'bytes' | 'hex'
 
 export type SignAuthorizationParameters<to extends To = 'object'> =
-  Authorization & {
+  AuthorizationRequest & {
     /** The private key to sign with. */
     privateKey: Hex
     to?: SignParameters<to>['to'] | undefined
@@ -41,15 +41,15 @@ export async function signAuthorization<to extends To = 'object'>(
   parameters: SignAuthorizationParameters<to>,
 ): Promise<SignAuthorizationReturnType<to>> {
   const { chainId, nonce, privateKey, to = 'object' } = parameters
-  const contractAddress = parameters.contractAddress ?? parameters.address
+  const address = parameters.contractAddress ?? parameters.address
   const signature = await sign({
-    hash: hashAuthorization({ contractAddress, chainId, nonce }),
+    hash: hashAuthorization({ address, chainId, nonce }),
     privateKey,
     to,
   })
   if (to === 'object')
     return {
-      contractAddress,
+      address,
       chainId,
       nonce,
       ...(signature as Signature),

package/actions/public/estimateGas.ts

@@ -211,14 +211,14 @@ export async function estimateGas<
       const value = await getBalance(client, { address: request.from })
       const estimates = await Promise.all(
         authorizationList.map(async (authorization) => {
-          const { contractAddress } = authorization
+          const { address } = authorization
           const estimate = await estimateGas_rpc({
             block,
             request: {
               authorizationList: undefined,
               data,
               from: account?.address,
-              to: contractAddress,
+              to: address,
               value: numberToHex(value),
             },
             rpcStateOverride,

package/actions/wallet/prepareAuthorization.ts

@@ -1,3 +1,4 @@
+import type { Address } from 'abitype'
 import type { Account } from '../../accounts/types.js'
 import {
   type ParseAccountErrorType,
@@ -11,9 +12,13 @@ import {
 } from '../../errors/account.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type { GetAccountParameter } from '../../types/account.js'
-import type { Authorization } from '../../types/authorization.js'
+import type {
+  Authorization,
+  AuthorizationRequest,
+} from '../../types/authorization.js'
 import type { Chain } from '../../types/chain.js'
 import type { PartialBy } from '../../types/utils.js'
+import { isAddressEqual } from '../../utils/address/isAddressEqual.js'
 import type { RequestErrorType } from '../../utils/buildRequest.js'
 import { getAction } from '../../utils/getAction.js'
 import { getChainId } from '../public/getChainId.js'
@@ -22,14 +27,14 @@ import { getTransactionCount } from '../public/getTransactionCount.js'
 export type PrepareAuthorizationParameters<
   account extends Account | undefined = Account | undefined,
 > = GetAccountParameter<account> &
-  PartialBy<Authorization, 'chainId' | 'nonce'> & {
+  PartialBy<AuthorizationRequest, 'chainId' | 'nonce'> & {
     /**
      * Whether the EIP-7702 Transaction will be executed by the EOA (signing this Authorization) or another Account.
      *
      * By default, it will be assumed that the EIP-7702 Transaction will
      * be executed by another Account.
      */
-    executor?: 'self' | undefined
+    executor?: 'self' | Account | Address | undefined
   }
 
 export type PrepareAuthorizationReturnType = Authorization
@@ -88,12 +93,7 @@ export async function prepareAuthorization<
   client: Client<Transport, chain, account>,
   parameters: PrepareAuthorizationParameters<account>,
 ): Promise<PrepareAuthorizationReturnType> {
-  const {
-    account: account_ = client.account,
-    chainId,
-    executor,
-    nonce,
-  } = parameters
+  const { account: account_ = client.account, chainId, nonce } = parameters
 
   if (!account_)
     throw new AccountNotFoundError({
@@ -101,8 +101,14 @@ export async function prepareAuthorization<
     })
   const account = parseAccount(account_)
 
+  const executor = (() => {
+    if (!parameters.executor) return undefined
+    if (parameters.executor === 'self') return parameters.executor
+    return parseAccount(parameters.executor)
+  })()
+
   const authorization = {
-    contractAddress: parameters.contractAddress ?? parameters.address,
+    address: parameters.contractAddress ?? parameters.address,
     chainId,
     nonce,
   } as Authorization
@@ -121,7 +127,11 @@ export async function prepareAuthorization<
       address: account.address,
       blockTag: 'pending',
     })
-    if (executor === 'self') authorization.nonce += 1
+    if (
+      executor === 'self' ||
+      (executor?.address && isAddressEqual(executor.address, account.address))
+    )
+      authorization.nonce += 1
   }
 
   return authorization

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.24.0'
+export const version = '2.24.2'

package/experimental/erc7821/actions/execute.ts

@@ -144,7 +144,7 @@ export async function execute<
 ): Promise<ExecuteReturnType> {
   const { authorizationList, calls, opData } = parameters
 
-  const address = authorizationList?.[0]?.contractAddress ?? parameters.address
+  const address = authorizationList?.[0]?.address ?? parameters.address
   const mode = opData ? executionMode.opData : executionMode.default
 
   const supported = await withCache(

package/experimental/erc7821/actions/executeBatches.ts

@@ -167,7 +167,7 @@ export async function executeBatches<
 ): Promise<ExecuteBatchesReturnType> {
   const { authorizationList, batches } = parameters
 
-  const address = authorizationList?.[0]?.contractAddress ?? parameters.address
+  const address = authorizationList?.[0]?.address ?? parameters.address
 
   const supported = await withCache(
     () =>

package/experimental/index.ts

@@ -43,6 +43,91 @@ export {
   eip5792Actions,
 } from './eip5792/decorators/eip5792.js'
 
+export {
+  /** @deprecated This is no longer experimental – use `import type { WalletActions } from 'viem'` instead. */
+  type WalletActions as Eip7702Actions,
+  /** @deprecated This is no longer experimental – use `import { createWalletClient } from 'viem'` or `import { walletActions } from 'viem'` instead. */
+  walletActions as eip7702Actions,
+} from '../clients/decorators/wallet.js'
+export {
+  /** @deprecated This is no longer experimental – use `import type { PrepareAuthorizationParameters } from 'viem/actions'` instead. */
+  type PrepareAuthorizationParameters,
+  /** @deprecated This is no longer experimental – use `import type { PrepareAuthorizationReturnType } from 'viem/actions'` instead. */
+  type PrepareAuthorizationReturnType,
+  /** @deprecated This is no longer experimental – use `import type { PrepareAuthorizationErrorType } from 'viem/actions'` instead. */
+  type PrepareAuthorizationErrorType,
+  /** @deprecated This is no longer experimental – use `import { prepareAuthorization } from 'viem/actions'` instead. */
+  prepareAuthorization,
+} from '../actions/wallet/prepareAuthorization.js'
+export {
+  /** @deprecated This is no longer experimental – use `import type { SignAuthorizationParameters } from 'viem/actions'` instead. */
+  type SignAuthorizationParameters,
+  /** @deprecated This is no longer experimental – use `import type { SignAuthorizationReturnType } from 'viem/actions'` instead. */
+  type SignAuthorizationReturnType,
+  /** @deprecated This is no longer experimental – use `import type { SignAuthorizationErrorType } from 'viem/actions'` instead. */
+  type SignAuthorizationErrorType,
+  /** @deprecated This is no longer experimental – use `import { signAuthorization } from 'viem/actions'` instead. */
+  signAuthorization,
+} from '../actions/wallet/signAuthorization.js'
+export {
+  /** @deprecated This is no longer experimental – use `import type { Authorization } from 'viem'` instead. */
+  type Authorization,
+  /** @deprecated This is no longer experimental – use `import type { SignedAuthorization } from 'viem'` instead. */
+  type SignedAuthorization,
+  /** @deprecated This is no longer experimental – use `import type { AuthorizationList } from 'viem'` instead. */
+  type AuthorizationList,
+  /** @deprecated This is no longer experimental – use `import type { SignedAuthorizationList } from 'viem'` instead. */
+  type SignedAuthorizationList,
+  /** @deprecated This is no longer experimental – use `import type { SerializedAuthorization } from 'viem'` instead. */
+  type SerializedAuthorization,
+  /** @deprecated This is no longer experimental – use `import type { SerializedAuthorizationList } from 'viem'` instead. */
+  type SerializedAuthorizationList,
+} from '../types/authorization.js'
+export {
+  /** @deprecated This is no longer experimental – use `import type { RpcAuthorizationList } from 'viem'` instead. */
+  type RpcAuthorizationList,
+  /** @deprecated This is no longer experimental – use `import type { RpcAuthorization } from 'viem'` instead. */
+  type RpcAuthorization,
+} from '../types/rpc.js'
+export {
+  /** @deprecated This is no longer experimental – use `import type { HashAuthorizationParameters } from 'viem/utils'` instead. */
+  type HashAuthorizationParameters,
+  /** @deprecated This is no longer experimental – use `import type { HashAuthorizationReturnType } from 'viem/utils'` instead. */
+  type HashAuthorizationReturnType,
+  /** @deprecated This is no longer experimental – use `import type { HashAuthorizationErrorType } from 'viem/utils'` instead. */
+  type HashAuthorizationErrorType,
+  /** @deprecated This is no longer experimental – use `import { hashAuthorization } from 'viem/utils'` instead. */
+  hashAuthorization,
+} from '../utils/authorization/hashAuthorization.js'
+export {
+  /** @deprecated This is no longer experimental – use `import type { RecoverAuthorizationAddressParameters } from 'viem/utils'` instead. */
+  type RecoverAuthorizationAddressParameters,
+  /** @deprecated This is no longer experimental – use `import type { RecoverAuthorizationAddressReturnType } from 'viem/utils'` instead. */
+  type RecoverAuthorizationAddressReturnType,
+  /** @deprecated This is no longer experimental – use `import type { RecoverAuthorizationAddressErrorType } from 'viem/utils'` instead. */
+  type RecoverAuthorizationAddressErrorType,
+  /** @deprecated This is no longer experimental – use `import { recoverAuthorizationAddress } from 'viem/utils'` instead. */
+  recoverAuthorizationAddress,
+} from '../utils/authorization/recoverAuthorizationAddress.js'
+export {
+  /** @deprecated This is no longer experimental – use `import type { SerializeAuthorizationListReturnType } from 'viem/utils'` instead. */
+  type SerializeAuthorizationListReturnType,
+  /** @deprecated This is no longer experimental – use `import type { SerializeAuthorizationListErrorType } from 'viem/utils'` instead. */
+  type SerializeAuthorizationListErrorType,
+  /** @deprecated This is no longer experimental – use `import { serializeAuthorizationList } from 'viem/utils'` instead. */
+  serializeAuthorizationList,
+} from '../utils/authorization/serializeAuthorizationList.js'
+export {
+  /** @deprecated This is no longer experimental – use `import type { VerifyAuthorizationParameters } from 'viem/utils'` instead. */
+  type VerifyAuthorizationParameters,
+  /** @deprecated This is no longer experimental – use `import type { VerifyAuthorizationReturnType } from 'viem/utils'` instead. */
+  type VerifyAuthorizationReturnType,
+  /** @deprecated This is no longer experimental – use `import type { VerifyAuthorizationErrorType } from 'viem/utils'` instead. */
+  type VerifyAuthorizationErrorType,
+  /** @deprecated This is no longer experimental – use `import { verifyAuthorization } from 'viem/utils'` instead. */
+  verifyAuthorization,
+} from '../utils/authorization/verifyAuthorization.js'
+
 export {
   type GrantPermissionsParameters,
   type GrantPermissionsReturnType,

package/package.json

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

package/types/authorization.ts

@@ -2,10 +2,25 @@ import type { Address } from 'abitype'
 import type { Hex, Signature } from './misc.js'
 import type { ExactPartial, OneOf } from './utils.js'
 
-export type Authorization<
+export type Authorization<uint32 = number, signed extends boolean = false> = {
+  /** Address of the contract to delegate to. */
+  address: Address
+  /** Chain ID. */
+  chainId: uint32
+  /** Nonce of the EOA to delegate to. */
+  nonce: uint32
+} & (signed extends true ? Signature : ExactPartial<Signature>)
+
+export type AuthorizationList<
   uint32 = number,
   signed extends boolean = false,
-> = OneOf<
+> = readonly Authorization<uint32, signed>[]
+
+export type AuthorizationRequest<uint32 = number> = OneOf<
+  | {
+      /** Address of the contract to delegate to. */
+      address: Address
+    }
   | {
       /**
        * Address of the contract to delegate to.
@@ -13,21 +28,12 @@ export type Authorization<
        */
       contractAddress: Address
     }
-  | {
-      /** Address of the contract to delegate to. */
-      address: Address
-    }
 > & {
   /** Chain ID. */
   chainId: uint32
   /** Nonce of the EOA to delegate to. */
   nonce: uint32
-} & (signed extends true ? Signature : ExactPartial<Signature>)
-
-export type AuthorizationList<
-  uint32 = number,
-  signed extends boolean = false,
-> = readonly Authorization<uint32, signed>[]
+}
 
 export type SignedAuthorization<uint32 = number> = Authorization<uint32, true>
 

package/utils/authorization/hashAuthorization.ts

@@ -1,5 +1,5 @@
 import type { ErrorType } from '../../errors/utils.js'
-import type { Authorization } from '../../types/authorization.js'
+import type { AuthorizationRequest } from '../../types/authorization.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
 import { type ConcatHexErrorType, concatHex } from '../data/concat.js'
 import { type HexToBytesErrorType, hexToBytes } from '../encoding/toBytes.js'
@@ -9,10 +9,11 @@ import { type Keccak256ErrorType, keccak256 } from '../hash/keccak256.js'
 
 type To = 'hex' | 'bytes'
 
-export type HashAuthorizationParameters<to extends To> = Authorization & {
-  /** Output format. @default "hex" */
-  to?: to | To | undefined
-}
+export type HashAuthorizationParameters<to extends To> =
+  AuthorizationRequest & {
+    /** Output format. @default "hex" */
+    to?: to | To | undefined
+  }
 
 export type HashAuthorizationReturnType<to extends To> =
   | (to extends 'bytes' ? ByteArray : never)
@@ -33,13 +34,13 @@ export function hashAuthorization<to extends To = 'hex'>(
   parameters: HashAuthorizationParameters<to>,
 ): HashAuthorizationReturnType<to> {
   const { chainId, nonce, to } = parameters
-  const contractAddress = parameters.contractAddress ?? parameters.address
+  const address = parameters.contractAddress ?? parameters.address
   const hash = keccak256(
     concatHex([
       '0x05',
       toRlp([
         chainId ? numberToHex(chainId) : '0x',
-        contractAddress,
+        address,
         nonce ? numberToHex(nonce) : '0x',
       ]),
     ]),

package/utils/authorization/recoverAuthorizationAddress.ts

@@ -3,6 +3,7 @@ import type { Address } from 'abitype'
 import type { ErrorType } from '../../errors/utils.js'
 import type {
   Authorization,
+  AuthorizationRequest,
   SignedAuthorization,
 } from '../../types/authorization.js'
 import type { ByteArray, Hex, Signature } from '../../types/misc.js'
@@ -17,9 +18,9 @@ import {
 } from './hashAuthorization.js'
 
 export type RecoverAuthorizationAddressParameters<
-  authorization extends OneOf<Authorization | SignedAuthorization> = OneOf<
-    Authorization | SignedAuthorization
-  >,
+  authorization extends OneOf<
+    Authorization | AuthorizationRequest | SignedAuthorization
+  > = OneOf<Authorization | AuthorizationRequest | SignedAuthorization>,
   //
   _signature = Hex | ByteArray | OneOf<Signature | SignedAuthorization>,
 > = {
@@ -29,7 +30,9 @@ export type RecoverAuthorizationAddressParameters<
    * - If an unsigned `authorization` is provided, the `signature` property is required.
    * - If a signed `authorization` is provided, the `signature` property does not need to be provided.
    */
-  authorization: authorization | OneOf<Authorization | SignedAuthorization>
+  authorization:
+    | authorization
+    | OneOf<Authorization | AuthorizationRequest | SignedAuthorization>
 } & (authorization extends SignedAuthorization
   ? {
       /** Signature of the Authorization. Not required if the `authorization` is signed. */
@@ -48,14 +51,16 @@ export type RecoverAuthorizationAddressErrorType =
   | ErrorType
 
 export async function recoverAuthorizationAddress<
-  const authorization extends OneOf<Authorization | SignedAuthorization>,
+  const authorization extends OneOf<
+    Authorization | AuthorizationRequest | SignedAuthorization
+  >,
 >(
   parameters: RecoverAuthorizationAddressParameters<authorization>,
 ): Promise<RecoverAuthorizationAddressReturnType> {
   const { authorization, signature } = parameters
 
   return recoverAddress({
-    hash: hashAuthorization(authorization as Authorization),
+    hash: hashAuthorization(authorization as AuthorizationRequest),
     signature: (signature ?? authorization) as Signature,
   })
 }

package/utils/authorization/serializeAuthorizationList.ts

@@ -21,8 +21,7 @@ export function serializeAuthorizationList(
   const serializedAuthorizationList = []
   for (const authorization of authorizationList) {
     const { chainId, nonce, ...signature } = authorization
-    const contractAddress =
-      authorization.contractAddress ?? authorization.address
+    const contractAddress = authorization.address
     serializedAuthorizationList.push([
       chainId ? toHex(chainId) : '0x',
       contractAddress,

package/utils/formatters/transaction.ts

@@ -127,7 +127,7 @@ function formatAuthorizationList(
   authorizationList: RpcAuthorizationList,
 ): SignedAuthorizationList {
   return authorizationList.map((authorization) => ({
-    contractAddress: (authorization as any).address,
+    address: (authorization as any).address,
     chainId: Number(authorization.chainId),
     nonce: Number(authorization.nonce),
     r: authorization.r,

package/utils/formatters/transactionRequest.ts

@@ -92,7 +92,7 @@ function formatAuthorizationList(
   return authorizationList.map(
     (authorization) =>
       ({
-        address: authorization.contractAddress,
+        address: authorization.address,
         r: authorization.r
           ? numberToHex(BigInt(authorization.r))
           : authorization.r,

package/utils/transaction/assertTransaction.ts

@@ -49,7 +49,7 @@ export function assertTransactionEIP7702(
   if (authorizationList) {
     for (const authorization of authorizationList) {
       const { chainId } = authorization
-      const address = authorization.contractAddress ?? authorization.address
+      const address = authorization.address
       if (!isAddress(address)) throw new InvalidAddressError({ address })
       if (chainId < 0) throw new InvalidChainIdError({ chainId })
     }

package/utils/transaction/parseTransaction.ts

@@ -576,12 +576,12 @@ function parseAuthorizationList(
 ): SignedAuthorizationList {
   const authorizationList: Mutable<SignedAuthorizationList> = []
   for (let i = 0; i < serializedAuthorizationList.length; i++) {
-    const [chainId, contractAddress, nonce, yParity, r, s] =
+    const [chainId, address, nonce, yParity, r, s] =
       serializedAuthorizationList[i]
 
     authorizationList.push({
+      address,
       chainId: hexToNumber(chainId),
-      contractAddress,
       nonce: hexToNumber(nonce),
       ...parseEIP155Signature([yParity, r, s]),
     })