viem 2.24.0 → 2.24.1

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