viem 2.18.7 → 2.19.0

package/errors/transaction.ts

@@ -28,13 +28,13 @@ export type FeeConflictErrorType = FeeConflictError & {
   name: 'FeeConflictError'
 }
 export class FeeConflictError extends BaseError {
-  override name = 'FeeConflictError'
   constructor() {
     super(
       [
         'Cannot specify both a `gasPrice` and a `maxFeePerGas`/`maxPriorityFeePerGas`.',
         'Use `maxFeePerGas`/`maxPriorityFeePerGas` for EIP-1559 compatible networks, and `gasPrice` for others.',
       ].join('\n'),
+      { name: 'FeeConflictError' },
     )
   }
 }
@@ -43,10 +43,10 @@ export type InvalidLegacyVErrorType = InvalidLegacyVError & {
   name: 'InvalidLegacyVError'
 }
 export class InvalidLegacyVError extends BaseError {
-  override name = 'InvalidLegacyVError'
-
   constructor({ v }: { v: bigint }) {
-    super(`Invalid \`v\` value "${v}". Expected 27 or 28.`)
+    super(`Invalid \`v\` value "${v}". Expected 27 or 28.`, {
+      name: 'InvalidLegacyVError',
+    })
   }
 }
 
@@ -55,8 +55,6 @@ export type InvalidSerializableTransactionErrorType =
     name: 'InvalidSerializableTransactionError'
   }
 export class InvalidSerializableTransactionError extends BaseError {
-  override name = 'InvalidSerializableTransactionError'
-
   constructor({ transaction }: { transaction: Record<string, unknown> }) {
     super('Cannot infer a transaction type from provided transaction.', {
       metaMessages: [
@@ -70,8 +68,10 @@ export class InvalidSerializableTransactionError extends BaseError {
         '- an EIP-1559 Transaction with `maxFeePerGas`, or',
         '- an EIP-2930 Transaction with `gasPrice` & `accessList`, or',
         '- an EIP-4844 Transaction with `blobs`, `blobVersionedHashes`, `sidecars`, or',
+        '- an EIP-7702 Transaction with `authorizationList`, or',
         '- a Legacy Transaction with `gasPrice`',
       ],
+      name: 'InvalidSerializableTransactionError',
     })
   }
 }
@@ -81,12 +81,12 @@ export type InvalidSerializedTransactionTypeErrorType =
     name: 'InvalidSerializedTransactionTypeError'
   }
 export class InvalidSerializedTransactionTypeError extends BaseError {
-  override name = 'InvalidSerializedTransactionType'
-
   serializedType: Hex
 
   constructor({ serializedType }: { serializedType: Hex }) {
-    super(`Serialized transaction type "${serializedType}" is invalid.`)
+    super(`Serialized transaction type "${serializedType}" is invalid.`, {
+      name: 'InvalidSerializedTransactionType',
+    })
 
     this.serializedType = serializedType
   }
@@ -97,8 +97,6 @@ export type InvalidSerializedTransactionErrorType =
     name: 'InvalidSerializedTransactionError'
   }
 export class InvalidSerializedTransactionError extends BaseError {
-  override name = 'InvalidSerializedTransactionError'
-
   serializedTransaction: Hex
   type: TransactionType
 
@@ -119,6 +117,7 @@ export class InvalidSerializedTransactionError extends BaseError {
         `Serialized Transaction: "${serializedTransaction}"`,
         missing.length > 0 ? `Missing Attributes: ${missing.join(', ')}` : '',
       ].filter(Boolean),
+      name: 'InvalidSerializedTransactionError',
     })
 
     this.serializedTransaction = serializedTransaction
@@ -130,13 +129,12 @@ export type InvalidStorageKeySizeErrorType = InvalidStorageKeySizeError & {
   name: 'InvalidStorageKeySizeError'
 }
 export class InvalidStorageKeySizeError extends BaseError {
-  override name = 'InvalidStorageKeySizeError'
-
   constructor({ storageKey }: { storageKey: Hex }) {
     super(
       `Size for storage key "${storageKey}" is invalid. Expected 32 bytes. Got ${Math.floor(
         (storageKey.length - 2) / 2,
       )} bytes.`,
+      { name: 'InvalidStorageKeySizeError' },
     )
   }
 }
@@ -147,8 +145,6 @@ export type TransactionExecutionErrorType = TransactionExecutionError & {
 export class TransactionExecutionError extends BaseError {
   override cause: BaseError
 
-  override name = 'TransactionExecutionError'
-
   constructor(
     cause: BaseError,
     {
@@ -197,6 +193,7 @@ export class TransactionExecutionError extends BaseError {
         'Request Arguments:',
         prettyArgs,
       ].filter(Boolean) as string[],
+      name: 'TransactionExecutionError',
     })
     this.cause = cause
   }
@@ -206,7 +203,6 @@ export type TransactionNotFoundErrorType = TransactionNotFoundError & {
   name: 'TransactionNotFoundError'
 }
 export class TransactionNotFoundError extends BaseError {
-  override name = 'TransactionNotFoundError'
   constructor({
     blockHash,
     blockNumber,
@@ -228,7 +224,9 @@ export class TransactionNotFoundError extends BaseError {
     if (blockNumber && index !== undefined)
       identifier = `Transaction at block number "${blockNumber}" at index "${index}"`
     if (hash) identifier = `Transaction with hash "${hash}"`
-    super(`${identifier} could not be found.`)
+    super(`${identifier} could not be found.`, {
+      name: 'TransactionNotFoundError',
+    })
   }
 }
 
@@ -237,10 +235,12 @@ export type TransactionReceiptNotFoundErrorType =
     name: 'TransactionReceiptNotFoundError'
   }
 export class TransactionReceiptNotFoundError extends BaseError {
-  override name = 'TransactionReceiptNotFoundError'
   constructor({ hash }: { hash: Hash }) {
     super(
       `Transaction receipt with hash "${hash}" could not be found. The Transaction may not be processed on a block yet.`,
+      {
+        name: 'TransactionReceiptNotFoundError',
+      },
     )
   }
 }
@@ -250,10 +250,10 @@ export type WaitForTransactionReceiptTimeoutErrorType =
     name: 'WaitForTransactionReceiptTimeoutError'
   }
 export class WaitForTransactionReceiptTimeoutError extends BaseError {
-  override name = 'WaitForTransactionReceiptTimeoutError'
   constructor({ hash }: { hash: Hash }) {
     super(
       `Timed out while waiting for transaction with hash "${hash}" to be confirmed.`,
+      { name: 'WaitForTransactionReceiptTimeoutError' },
     )
   }
 }

package/errors/transport.ts

@@ -9,6 +9,7 @@ export class UrlRequiredError extends BaseError {
       'No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.',
       {
         docsPath: '/docs/clients/intro',
+        name: 'UrlRequiredError',
       },
     )
   }

package/errors/utils.ts

@@ -1,9 +1,6 @@
 import type { Address } from 'abitype'
 
-import { version } from './version.js'
-
 export type ErrorType<name extends string = 'Error'> = Error & { name: name }
 
 export const getContractAddress = (address: Address) => address
 export const getUrl = (url: string) => url
-export const getVersion = () => `viem@${version}`

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.18.7'
+export const version = '2.19.0'

package/experimental/eip5792/decorators/eip5792.ts

@@ -28,7 +28,7 @@ import {
   writeContracts,
 } from '../actions/writeContracts.js'
 
-export type WalletActionsEip5792<
+export type Eip5792Actions<
   chain extends Chain | undefined = Chain | undefined,
   account extends Account | undefined = Account | undefined,
 > = {
@@ -44,12 +44,12 @@ export type WalletActionsEip5792<
    * @example
    * import { createWalletClient, custom } from 'viem'
    * import { mainnet } from 'viem/chains'
-   * import { walletActionsEip5792 } from 'viem/experimental'
+   * import { eip5792Actions } from 'viem/experimental'
    *
    * const client = createWalletClient({
    *   chain: mainnet,
    *   transport: custom(window.ethereum),
-   * }).extend(walletActionsEip5792())
+   * }).extend(eip5792Actions())
    *
    * const { receipts, status } = await client.getCallsStatus({ id: '0xdeadbeef' })
    */
@@ -68,12 +68,12 @@ export type WalletActionsEip5792<
    * @example
    * import { createWalletClient, custom } from 'viem'
    * import { mainnet } from 'viem/chains'
-   * import { walletActionsEip5792 } from 'viem/experimental'
+   * import { eip5792Actions } from 'viem/experimental'
    *
    * const client = createWalletClient({
    *   chain: mainnet,
    *   transport: custom(window.ethereum),
-   * }).extend(walletActionsEip5792())
+   * }).extend(eip5792Actions())
    *
    * const capabilities = await client.getCapabilities({
    *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
@@ -96,12 +96,12 @@ export type WalletActionsEip5792<
    * @example
    * import { createWalletClient, custom } from 'viem'
    * import { mainnet } from 'viem/chains'
-   * import { walletActionsEip5792 } from 'viem/experimental'
+   * import { eip5792Actions } from 'viem/experimental'
    *
    * const client = createWalletClient({
    *   chain: mainnet,
    *   transport: custom(window.ethereum),
-   * }).extend(walletActionsEip5792())
+   * }).extend(eip5792Actions())
    *
    * const id = await client.sendCalls({
    *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
@@ -133,12 +133,12 @@ export type WalletActionsEip5792<
    * @example
    * import { createWalletClient, custom } from 'viem'
    * import { mainnet } from 'viem/chains'
-   * import { walletActionsEip5792 } from 'viem/experimental'
+   * import { eip5792Actions } from 'viem/experimental'
    *
    * const client = createWalletClient({
    *   chain: mainnet,
    *   transport: custom(window.ethereum),
-   * }).extend(walletActionsEip5792())
+   * }).extend(eip5792Actions())
    *
    * await client.showCallsStatus({ id: '0xdeadbeef' })
    */
@@ -210,23 +210,23 @@ export type WalletActionsEip5792<
  * @example
  * import { createPublicClient, createWalletClient, http } from 'viem'
  * import { mainnet } from 'viem/chains'
- * import { walletActionsEip5792 } from 'viem/experimental'
+ * import { eip5792Actions } from 'viem/experimental'
  *
  * const walletClient = createWalletClient({
  *   chain: mainnet,
  *   transport: http(),
- * }).extend(walletActionsEip5792())
+ * }).extend(eip5792Actions())
  *
  * const hash = await walletClient.sendCalls({...})
  */
-export function walletActionsEip5792() {
+export function eip5792Actions() {
   return <
     transport extends Transport,
     chain extends Chain | undefined = Chain | undefined,
     account extends Account | undefined = Account | undefined,
   >(
     client: Client<transport, chain, account>,
-  ): WalletActionsEip5792<chain, account> => {
+  ): Eip5792Actions<chain, account> => {
     return {
       getCallsStatus: (parameters) => getCallsStatus(client, parameters),
       getCapabilities: ((parameters: any) =>

package/experimental/eip7702/actions/signAuthorization.ts

@@ -0,0 +1,136 @@
+import type { Account } from '../../../accounts/types.js'
+import {
+  type ParseAccountErrorType,
+  parseAccount,
+} from '../../../accounts/utils/parseAccount.js'
+import type {
+  SignAuthorizationErrorType as SignAuthorizationErrorType_account,
+  SignAuthorizationReturnType as SignAuthorizationReturnType_account,
+} from '../../../accounts/utils/signAuthorization.js'
+import { getChainId } from '../../../actions/public/getChainId.js'
+import { getTransactionCount } from '../../../actions/public/getTransactionCount.js'
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import {
+  AccountNotFoundError,
+  type AccountNotFoundErrorType,
+  AccountTypeNotSupportedError,
+  type AccountTypeNotSupportedErrorType,
+} from '../../../errors/account.js'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { GetAccountParameter } from '../../../types/account.js'
+import type { Chain } from '../../../types/chain.js'
+import type { PartialBy } from '../../../types/utils.js'
+import type { RequestErrorType } from '../../../utils/buildRequest.js'
+import { getAction } from '../../../utils/getAction.js'
+import type { Authorization } from '../types/authorization.js'
+
+export type SignAuthorizationParameters<
+  account extends Account | undefined = Account | undefined,
+> = GetAccountParameter<account> & PartialBy<Authorization, 'chainId' | 'nonce'>
+
+export type SignAuthorizationReturnType = SignAuthorizationReturnType_account
+
+export type SignAuthorizationErrorType =
+  | ParseAccountErrorType
+  | RequestErrorType
+  | AccountNotFoundErrorType
+  | AccountTypeNotSupportedErrorType
+  | SignAuthorizationErrorType_account
+  | ErrorType
+
+/**
+ * Signs an [EIP-7702 Authorization](https://eips.ethereum.org/EIPS/eip-7702) object.
+ *
+ * With the calculated signature, you can:
+ * - use [`verifyAuthorization`](https://viem.sh/experimental/eip7702/verifyAuthorization) to verify the signed Authorization object,
+ * - use [`recoverAuthorizationAddress`](https://viem.sh/experimental/eip7702/recoverAuthorizationAddress) to recover the signing address from the signed Authorization object.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SignAuthorizationParameters}
+ * @returns The signed Authorization object. {@link SignAuthorizationReturnType}
+ *
+ * @example
+ * import { createClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { signAuthorization } from 'viem/experimental'
+ *
+ * const client = createClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const signature = await signAuthorization(client, {
+ *   account: privateKeyToAccount('0x..'),
+ *   address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { signAuthorization } from 'viem/experimental'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const signature = await signAuthorization(client, {
+ *   address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ * })
+ */
+export async function signAuthorization<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: SignAuthorizationParameters<account>,
+): Promise<SignAuthorizationReturnType> {
+  const {
+    account: account_ = client.account,
+    contractAddress,
+    chainId,
+    nonce,
+  } = parameters
+
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: '/experimental/eip7702/signAuthorization',
+    })
+  const account = parseAccount(account_)
+
+  if (!account.experimental_signAuthorization)
+    throw new AccountTypeNotSupportedError({
+      docsPath: '/experimental/eip7702/signAuthorization',
+      metaMessages: [
+        'The `signAuthorization` Action does not support JSON-RPC Accounts.',
+      ],
+      type: account.type,
+    })
+
+  const authorization = {
+    contractAddress,
+    chainId,
+    nonce,
+  } as Authorization
+
+  if (typeof authorization.chainId === 'undefined')
+    authorization.chainId =
+      client.chain?.id ??
+      (await getAction(client, getChainId, 'getChainId')({}))
+
+  if (typeof authorization.nonce === 'undefined') {
+    authorization.nonce = await getAction(
+      client,
+      getTransactionCount,
+      'getTransactionCount',
+    )({
+      address: account.address,
+      blockTag: 'pending',
+    })
+  }
+
+  return account.experimental_signAuthorization(authorization)
+}

package/experimental/eip7702/decorators/eip7702.ts

@@ -0,0 +1,86 @@
+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 SignAuthorizationParameters,
+  type SignAuthorizationReturnType,
+  signAuthorization,
+} from '../actions/signAuthorization.js'
+
+export type Eip7702Actions<
+  account extends Account | undefined = Account | undefined,
+> = {
+  /**
+   * Signs an [EIP-7702 Authorization](https://eips.ethereum.org/EIPS/eip-7702) object.
+   *
+   * With the calculated signature, you can:
+   * - use [`verifyAuthorization`](https://viem.sh/experimental/eip7702/verifyAuthorization) to verify the signed Authorization object,
+   * - use [`recoverAuthorizationAddress`](https://viem.sh/experimental/eip7702/recoverAuthorizationAddress) to recover the signing address from the signed Authorization object.
+   *
+   * @param client - Client to use
+   * @param parameters - {@link SignAuthorizationParameters}
+   * @returns The signed Authorization object. {@link SignAuthorizationReturnType}
+   *
+   * @example
+   * import { createClient, http } from 'viem'
+   * import { privateKeyToAccount } from 'viem/accounts'
+   * import { mainnet } from 'viem/chains'
+   * import { eip7702Actions } from 'viem/experimental'
+   *
+   * const client = createClient({
+   *   chain: mainnet,
+   *   transport: http(),
+   * }).extend(eip7702Actions())
+   *
+   * const signature = await client.signAuthorization({
+   *   account: privateKeyToAccount('0x..'),
+   *   authorization: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   * })
+   *
+   * @example
+   * // Account Hoisting
+   * import { createClient, http } from 'viem'
+   * import { privateKeyToAccount } from 'viem/accounts'
+   * import { mainnet } from 'viem/chains'
+   * import { eip7702Actions } from 'viem/experimental'
+   *
+   * const client = createClient({
+   *   account: privateKeyToAccount('0x…'),
+   *   chain: mainnet,
+   *   transport: http(),
+   * }).extend(eip7702Actions())
+   *
+   * const signature = await client.signAuthorization({
+   *   authorization: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   * })
+   */
+  signAuthorization: (
+    parameters: SignAuthorizationParameters<account>,
+  ) => Promise<SignAuthorizationReturnType>
+}
+
+/**
+ * A suite of EIP-7702 Actions.
+ *
+ * @example
+ * import { createClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { eip7702Actions } from 'viem/experimental'
+ *
+ * const client = createClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * }).extend(eip7702Actions())
+ *
+ * const hash = await client.signAuthorization({ ... })
+ */
+export function eip7702Actions() {
+  return <account extends Account | undefined = Account | undefined>(
+    client: Client<Transport, Chain | undefined, account>,
+  ): Eip7702Actions<account> => {
+    return {
+      signAuthorization: (parameters) => signAuthorization(client, parameters),
+    }
+  }
+}

package/experimental/eip7702/types/authorization.ts

@@ -0,0 +1,30 @@
+import type { Address } from 'abitype'
+import type { Hex, Signature } from '../../../types/misc.js'
+import type { ExactPartial } from '../../../types/utils.js'
+
+export type Authorization<uint32 = number, signed extends boolean = false> = {
+  /** Address of the contract to set as code for the Authority. */
+  contractAddress: Address
+  /** Chain ID to authorize. */
+  chainId: uint32
+  /** Nonce of the Authority to authorize. */
+  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>
+export type SignedAuthorizationList<uint32 = number> =
+  readonly SignedAuthorization<uint32>[]
+
+export type SerializedAuthorization = readonly [
+  chainId: Hex,
+  address: Hex,
+  nonce: Hex,
+  yParity: Hex,
+  r: Hex,
+  s: Hex,
+]
+export type SerializedAuthorizationList = readonly SerializedAuthorization[]

package/experimental/eip7702/types/rpc.ts

@@ -0,0 +1,12 @@
+import type { Address } from 'abitype'
+import type { Hex, Signature } from '../../../types/misc.js'
+
+export type RpcAuthorization = {
+  /** Address of the contract to set as code for the Authority. */
+  address: Address
+  /** Chain ID to authorize. */
+  chainId: Hex
+  /** Nonce of the Authority to authorize. */
+  nonce: Hex
+} & Signature
+export type RpcAuthorizationList = readonly RpcAuthorization[]

package/experimental/eip7702/utils/hashAuthorization.ts

@@ -0,0 +1,60 @@
+import type { ErrorType } from '../../../errors/utils.js'
+import type { ByteArray, Hex } from '../../../types/misc.js'
+import {
+  type ConcatHexErrorType,
+  concatHex,
+} from '../../../utils/data/concat.js'
+import {
+  type HexToBytesErrorType,
+  hexToBytes,
+} from '../../../utils/encoding/toBytes.js'
+import {
+  type NumberToHexErrorType,
+  numberToHex,
+} from '../../../utils/encoding/toHex.js'
+import { type ToRlpErrorType, toRlp } from '../../../utils/encoding/toRlp.js'
+import {
+  type Keccak256ErrorType,
+  keccak256,
+} from '../../../utils/hash/keccak256.js'
+import type { Authorization } from '../types/authorization.js'
+
+type To = 'hex' | 'bytes'
+
+export type HashAuthorizationParameters<to extends To> = Authorization & {
+  /** Output format. @default "hex" */
+  to?: to | To | undefined
+}
+
+export type HashAuthorizationReturnType<to extends To> =
+  | (to extends 'bytes' ? ByteArray : never)
+  | (to extends 'hex' ? Hex : never)
+
+export type HashAuthorizationErrorType =
+  | Keccak256ErrorType
+  | ConcatHexErrorType
+  | ToRlpErrorType
+  | NumberToHexErrorType
+  | HexToBytesErrorType
+  | ErrorType
+
+/**
+ * Computes an Authorization hash in [EIP-7702 format](https://eips.ethereum.org/EIPS/eip-7702): `keccak256('0x05' || rlp([chain_id, address, nonce]))`.
+ */
+export function hashAuthorization<to extends To = 'hex'>(
+  parameters: HashAuthorizationParameters<to>,
+): HashAuthorizationReturnType<to> {
+  const { chainId, contractAddress, nonce, to } = parameters
+  const hash = keccak256(
+    concatHex([
+      '0x05',
+      toRlp([
+        numberToHex(chainId),
+        contractAddress,
+        [nonce ? numberToHex(nonce) : '0x'],
+      ]),
+    ]),
+  )
+  if (to === 'bytes') return hexToBytes(hash) as HashAuthorizationReturnType<to>
+  return hash as HashAuthorizationReturnType<to>
+}

package/experimental/eip7702/utils/recoverAuthorizationAddress.ts

@@ -0,0 +1,61 @@
+import type { Address } from 'abitype'
+
+import type { ErrorType } from '../../../errors/utils.js'
+import type { ByteArray, Hex, Signature } from '../../../types/misc.js'
+import type { OneOf } from '../../../types/utils.js'
+import {
+  type RecoverAddressErrorType,
+  recoverAddress,
+} from '../../../utils/signature/recoverAddress.js'
+import type {
+  Authorization,
+  SignedAuthorization,
+} from '../types/authorization.js'
+import {
+  type HashAuthorizationErrorType,
+  hashAuthorization,
+} from './hashAuthorization.js'
+
+export type RecoverAuthorizationAddressParameters<
+  authorization extends OneOf<Authorization | SignedAuthorization> = OneOf<
+    Authorization | SignedAuthorization
+  >,
+  //
+  _signature = Hex | ByteArray | OneOf<Signature | SignedAuthorization>,
+> = {
+  /**
+   * The Authorization object.
+   *
+   * - 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 extends SignedAuthorization
+  ? {
+      /** Signature of the Authorization. Not required if the `authorization` is signed. */
+      signature?: _signature | undefined
+    }
+  : {
+      /** Signature of the Authorization. Not required if the `authorization` is signed. */
+      signature: _signature
+    })
+
+export type RecoverAuthorizationAddressReturnType = Address
+
+export type RecoverAuthorizationAddressErrorType =
+  | HashAuthorizationErrorType
+  | RecoverAddressErrorType
+  | ErrorType
+
+export async function recoverAuthorizationAddress<
+  const authorization extends OneOf<Authorization | SignedAuthorization>,
+>(
+  parameters: RecoverAuthorizationAddressParameters<authorization>,
+): Promise<RecoverAuthorizationAddressReturnType> {
+  const { authorization, signature } = parameters
+
+  return recoverAddress({
+    hash: hashAuthorization(authorization as Authorization),
+    signature: (signature ?? authorization) as Signature,
+  })
+}