viem 2.15.1 → 2.16.1

package/experimental/solady/actions/signTypedData.ts

@@ -0,0 +1,251 @@
+import type { Address, TypedData, TypedDataDomain } from 'abitype'
+
+import type { Account } from '../../../accounts/types.js'
+import { parseAccount } from '../../../accounts/utils/parseAccount.js'
+import {
+  type GetEip712DomainParameters,
+  getEip712Domain,
+} from '../../../actions/public/getEip712Domain.js'
+import { signTypedData as signTypedData_ } from '../../../actions/wallet/signTypedData.js'
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import { AccountNotFoundError } 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 { Hex } from '../../../types/misc.js'
+import type { TypedDataDefinition } from '../../../types/typedData.js'
+import type { OneOf, RequiredBy } from '../../../types/utils.js'
+import { getAction } from '../../../utils/getAction.js'
+import type { GetVerifierParameter } from '../types.js'
+import { wrapTypedDataSignature } from '../utils/wrapTypedDataSignature.js'
+
+export type SignTypedDataParameters<
+  typedData extends TypedData | Record<string, unknown> = TypedData,
+  primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData,
+  account extends Account | undefined = undefined,
+  accountOverride extends Account | undefined = undefined,
+  verifier extends Address | undefined = Address | undefined,
+  ///
+  primaryTypes = typedData extends TypedData ? keyof typedData : string,
+> = TypedDataDefinition<typedData, primaryType, primaryTypes> &
+  Pick<GetEip712DomainParameters, 'factory' | 'factoryData'> &
+  GetAccountParameter<account, accountOverride> &
+  OneOf<
+    | {
+        verifierDomain: RequiredBy<
+          TypedDataDomain,
+          'chainId' | 'name' | 'verifyingContract' | 'salt' | 'version'
+        >
+        fields: Hex
+        extensions: readonly bigint[]
+        verifier?: undefined
+      }
+    | (GetVerifierParameter<verifier> & {
+        verifierDomain?:
+          | RequiredBy<
+              TypedDataDomain,
+              'chainId' | 'name' | 'verifyingContract' | 'salt' | 'version'
+            >
+          | undefined
+        fields?: Hex | undefined
+        extensions?: readonly bigint[] | undefined
+      })
+  >
+
+export type SignTypedDataReturnType = Hex
+
+export type SignTypedDataErrorType = ErrorType
+
+/**
+ * Signs an [EIP-712](https://eips.ethereum.org/EIPS/eip-712) typed data message via Solady's [ERC1271 `TypedDataSign` format](https://github.com/Vectorized/solady/blob/678c9163550810b08f0ffb09624c9f7532392303/src/accounts/ERC1271.sol#L130-L151).
+ *
+ * This Action is suitable to sign messages for Smart Accounts that implement (or conform to) Solady's [ERC1271.sol](https://github.com/Vectorized/solady/blob/main/src/accounts/ERC1271.sol).
+ *
+ * - Docs: https://viem.sh/experimental/solady/signTypedData
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SignTypedDataParameters}
+ * @returns The signed data. {@link SignTypedDataReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { signTypedData } from 'viem/experimental/solady'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const signature = await signTypedData(client, {
+ *   account: '0xE8Df82fA4E10e6A12a9Dab552bceA2acd26De9bb',
+ *   domain: {
+ *     name: 'Ether Mail',
+ *     version: '1',
+ *     chainId: 1,
+ *     verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
+ *   },
+ *   types: {
+ *     Person: [
+ *       { name: 'name', type: 'string' },
+ *       { name: 'wallet', type: 'address' },
+ *     ],
+ *     Mail: [
+ *       { name: 'from', type: 'Person' },
+ *       { name: 'to', type: 'Person' },
+ *       { name: 'contents', type: 'string' },
+ *     ],
+ *   },
+ *   primaryType: 'Mail',
+ *   message: {
+ *     from: {
+ *       name: 'Cow',
+ *       wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
+ *     },
+ *     to: {
+ *       name: 'Bob',
+ *       wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
+ *     },
+ *     contents: 'Hello, Bob!',
+ *   },
+ *   verifier: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { signTypedData } from 'viem/experimental/solady'
+ *
+ * const client = createWalletClient({
+ *   account: '0xE8Df82fA4E10e6A12a9Dab552bceA2acd26De9bb'
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const signature = await signTypedData(client, {
+ *   domain: {
+ *     name: 'Ether Mail',
+ *     version: '1',
+ *     chainId: 1,
+ *     verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
+ *   },
+ *   types: {
+ *     Person: [
+ *       { name: 'name', type: 'string' },
+ *       { name: 'wallet', type: 'address' },
+ *     ],
+ *     Mail: [
+ *       { name: 'from', type: 'Person' },
+ *       { name: 'to', type: 'Person' },
+ *       { name: 'contents', type: 'string' },
+ *     ],
+ *   },
+ *   primaryType: 'Mail',
+ *   message: {
+ *     from: {
+ *       name: 'Cow',
+ *       wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
+ *     },
+ *     to: {
+ *       name: 'Bob',
+ *       wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
+ *     },
+ *     contents: 'Hello, Bob!',
+ *   },
+ *   verifier: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ * })
+ */
+export async function signTypedData<
+  const typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | 'EIP712Domain',
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  accountOverride extends Account | undefined = undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: SignTypedDataParameters<
+    typedData,
+    primaryType,
+    account,
+    accountOverride
+  >,
+): Promise<SignTypedDataReturnType> {
+  const {
+    account: account_ = client.account,
+    domain,
+    factory,
+    factoryData,
+    message,
+    primaryType,
+    types,
+    verifier,
+  } = parameters as unknown as SignTypedDataParameters
+
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: '/experimental/solady/signTypedData',
+    })
+  const account = parseAccount(account_!)
+
+  // Retrieve account EIP712 domain.
+  const {
+    domain: verifierDomain,
+    fields,
+    extensions,
+  } = await (async () => {
+    if (parameters.verifierDomain && parameters.fields && parameters.extensions)
+      return {
+        domain: parameters.verifierDomain,
+        fields: parameters.fields,
+        extensions: parameters.extensions,
+      }
+    return getAction(
+      client,
+      getEip712Domain,
+      'getEip712Domain',
+    )({
+      address: verifier!,
+      factory,
+      factoryData,
+    })
+  })()
+
+  // Sign with typed data wrapper.
+  const signature = await getAction(
+    client,
+    signTypedData_,
+    'signTypedData',
+  )({
+    account,
+    domain,
+    types: {
+      ...types,
+      TypedDataSign: [
+        { name: 'contents', type: primaryType },
+        { name: 'fields', type: 'bytes1' },
+        { name: 'name', type: 'string' },
+        { name: 'version', type: 'string' },
+        { name: 'chainId', type: 'uint256' },
+        { name: 'verifyingContract', type: 'address' },
+        { name: 'salt', type: 'bytes32' },
+        { name: 'extensions', type: 'uint256[]' },
+      ],
+    },
+    primaryType: 'TypedDataSign',
+    message: {
+      contents: message as any,
+      fields,
+      extensions,
+      ...(verifierDomain as any),
+    },
+  })
+
+  return wrapTypedDataSignature({
+    domain,
+    message,
+    primaryType,
+    signature,
+    types,
+  })
+}

package/experimental/solady/decorators/solady.ts

@@ -0,0 +1,232 @@
+import type { Address, TypedData } from 'abitype'
+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 SignMessageParameters,
+  type SignMessageReturnType,
+  signMessage,
+} from '../actions/signMessage.js'
+import {
+  type SignTypedDataParameters,
+  type SignTypedDataReturnType,
+  signTypedData,
+} from '../actions/signTypedData.js'
+
+export type SoladyActions<
+  account extends Account | undefined = Account | undefined,
+  verifier extends Address | undefined = Address | undefined,
+> = {
+  /**
+   * Signs a [EIP-191](https://eips.ethereum.org/EIPS/eip-191) personal sign message via Solady's [ERC1271 `PersonalSign` format](https://github.com/Vectorized/solady/blob/678c9163550810b08f0ffb09624c9f7532392303/src/accounts/ERC1271.sol#L154-L166).
+   *
+   * This Action is suitable to sign messages for Smart Accounts that implement (or conform to) Solady's [ERC1271.sol](https://github.com/Vectorized/solady/blob/main/src/accounts/ERC1271.sol).
+   *
+   * - Docs: https://viem.sh/experimental/solady/signMessage
+   *
+   * With the calculated signature, you can:
+   * - use [`verifyMessage`](https://viem.sh/docs/utilities/verifyMessage) to verify the signature,
+   *
+   * @param client - Client to use
+   * @param parameters - {@link SignMessageParameters}
+   * @returns The signed message. {@link SignMessageReturnType}
+   *
+   * @example
+   * ```ts
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   * import { soladyActions } from 'viem/experimental/solady'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * }).extend(soladyActions())
+   *
+   * const signature = await client.signMessage({
+   *   account: '0xE8Df82fA4E10e6A12a9Dab552bceA2acd26De9bb',
+   *   message: 'hello world',
+   *   verifier: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   * })
+   * ```
+   *
+   * @example Account & Signer Hoisting
+   * ```ts
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   * import { soladyActions } from 'viem/experimental/solady'
+   *
+   * const client = createWalletClient({
+   *   account: '0xE8Df82fA4E10e6A12a9Dab552bceA2acd26De9bb',
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * }).extend(soladyActions({ verifier: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e' }))
+   *
+   * const signature = await client.signMessage({
+   *   message: 'hello world',
+   * })
+   * ```
+   */
+  signMessage: <accountOverride extends Account | undefined = undefined>(
+    parameters: SignMessageParameters<account, accountOverride, verifier>,
+  ) => Promise<SignMessageReturnType>
+  /**
+   * Signs an [EIP-712](https://eips.ethereum.org/EIPS/eip-712) typed data message via Solady's [ERC1271 `TypedDataSign` format](https://github.com/Vectorized/solady/blob/678c9163550810b08f0ffb09624c9f7532392303/src/accounts/ERC1271.sol#L130-L151).
+   *
+   * This Action is suitable to sign messages for Smart Accounts that implement (or conform to) Solady's [ERC1271.sol](https://github.com/Vectorized/solady/blob/main/src/accounts/ERC1271.sol).
+   *
+   * - Docs: https://viem.sh/experimental/solady/signTypedData
+   *
+   * @param client - Client to use
+   * @param parameters - {@link SignTypedDataParameters}
+   * @returns The signed data. {@link SignTypedDataReturnType}
+   *
+   * @example
+   * ```ts
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   * import { soladyActions } from 'viem/experimental/solady'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * }).extend(soladyActions())
+   *
+   * const signature = await client.signTypedData({
+   *   account: '0xE8Df82fA4E10e6A12a9Dab552bceA2acd26De9bb',
+   *   domain: {
+   *     name: 'Ether Mail',
+   *     version: '1',
+   *     chainId: 1,
+   *     verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
+   *   },
+   *   types: {
+   *     Person: [
+   *       { name: 'name', type: 'string' },
+   *       { name: 'wallet', type: 'address' },
+   *     ],
+   *     Mail: [
+   *       { name: 'from', type: 'Person' },
+   *       { name: 'to', type: 'Person' },
+   *       { name: 'contents', type: 'string' },
+   *     ],
+   *   },
+   *   primaryType: 'Mail',
+   *   message: {
+   *     from: {
+   *       name: 'Cow',
+   *       wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
+   *     },
+   *     to: {
+   *       name: 'Bob',
+   *       wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
+   *     },
+   *     contents: 'Hello, Bob!',
+   *   },
+   *   verifier: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   * })
+   * ```
+   *
+   * @example Account & Signer Hoisting
+   * ```ts
+   * import { createWalletClient, http } from 'viem'
+   * import { privateKeyToAccount } from 'viem/accounts'
+   * import { mainnet } from 'viem/chains'
+   * import { soladyActions } from 'viem/experimental/solady'
+   *
+   * const client = createWalletClient({
+   *   account: '0xE8Df82fA4E10e6A12a9Dab552bceA2acd26De9bb',
+   *   chain: mainnet,
+   *   transport: http(),
+   * }).extend(soladyActions({ verifier: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e' }))
+   *
+   * const signature = await client.signTypedData({
+   *   domain: {
+   *     name: 'Ether Mail',
+   *     version: '1',
+   *     chainId: 1,
+   *     verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
+   *   },
+   *   types: {
+   *     Person: [
+   *       { name: 'name', type: 'string' },
+   *       { name: 'wallet', type: 'address' },
+   *     ],
+   *     Mail: [
+   *       { name: 'from', type: 'Person' },
+   *       { name: 'to', type: 'Person' },
+   *       { name: 'contents', type: 'string' },
+   *     ],
+   *   },
+   *   primaryType: 'Mail',
+   *   message: {
+   *     from: {
+   *       name: 'Cow',
+   *       wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
+   *     },
+   *     to: {
+   *       name: 'Bob',
+   *       wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
+   *     },
+   *     contents: 'Hello, Bob!',
+   *   },
+   * })
+   * ```
+   */
+  signTypedData: <
+    const typedData extends TypedData | Record<string, unknown>,
+    primaryType extends keyof typedData | 'EIP712Domain',
+    accountOverride extends Account | undefined = undefined,
+  >(
+    parameters: SignTypedDataParameters<
+      typedData,
+      primaryType,
+      account,
+      accountOverride
+    >,
+  ) => Promise<SignTypedDataReturnType>
+}
+
+export type SoladyActionsParameters<
+  verifier extends Account | Address | undefined =
+    | Account
+    | Address
+    | undefined,
+> = {
+  verifier?: verifier | undefined
+}
+
+/**
+ * A suite of Actions based on [Solady contracts](https://github.com/Vectorized/solady).
+ *
+ * @example
+ * import { createPublicClient, createWalletClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { soladyActions } from 'viem/experimental'
+ *
+ * const walletClient = createWalletClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * }).extend(soladyActions())
+ *
+ * const result = await walletClient.signMessage({...})
+ */
+export function soladyActions<verifier extends Address | undefined = undefined>(
+  parameters: SoladyActionsParameters<verifier> = {},
+) {
+  const { verifier } = parameters
+  return <
+    transport extends Transport,
+    chain extends Chain | undefined = Chain | undefined,
+    account extends Account | undefined = Account | undefined,
+  >(
+    client: Client<transport, chain, account>,
+  ): SoladyActions<account, verifier> => {
+    return {
+      signMessage: (parameters) =>
+        signMessage(client, { verifier, ...parameters }),
+      signTypedData: (parameters) =>
+        signTypedData(client, { verifier, ...(parameters as any) }),
+    }
+  }
+}

package/experimental/solady/index.ts

@@ -0,0 +1,36 @@
+// biome-ignore lint/performance/noBarrelFile: entrypoint
+export {
+  type SignMessageErrorType,
+  type SignMessageParameters,
+  type SignMessageReturnType,
+  signMessage,
+} from './actions/signMessage.js'
+export {
+  type SignTypedDataErrorType,
+  type SignTypedDataParameters,
+  type SignTypedDataReturnType,
+  signTypedData,
+} from './actions/signTypedData.js'
+export {
+  type SoladyActions,
+  type SoladyActionsParameters,
+  soladyActions,
+} from './decorators/solady.js'
+export {
+  type HashMessageErrorType,
+  type HashMessageParameters,
+  type HashMessageReturnType,
+  hashMessage,
+} from './utils/hashMessage.js'
+export {
+  type HashTypedDataErrorType,
+  type HashTypedDataParameters,
+  type HashTypedDataReturnType,
+  hashTypedData,
+} from './utils/hashTypedData.js'
+export {
+  type WrapTypedDataSignatureErrorType,
+  type WrapTypedDataSignatureParameters,
+  type WrapTypedDataSignatureReturnType,
+  wrapTypedDataSignature,
+} from './utils/wrapTypedDataSignature.js'

package/experimental/solady/types.ts

@@ -0,0 +1,7 @@
+import type { Address } from 'abitype'
+
+export type GetVerifierParameter<
+  verifier extends Address | undefined = Address,
+> = verifier extends Address
+  ? { verifier?: Address | undefined }
+  : { verifier: Address }

package/experimental/solady/utils/hashMessage.ts

@@ -0,0 +1,60 @@
+import type { TypedDataDomain } from 'abitype'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Hex, SignableMessage } from '../../../types/misc.js'
+import type { RequiredBy } from '../../../types/utils.js'
+import { hashTypedData } from '../../../utils/index.js'
+import type { HashTypedDataErrorType } from '../../../utils/signature/hashTypedData.js'
+import {
+  type ToPrefixedMessageErrorType,
+  toPrefixedMessage,
+} from '../../../utils/signature/toPrefixedMessage.js'
+
+export type HashMessageParameters = {
+  message: SignableMessage
+  verifierDomain: RequiredBy<
+    TypedDataDomain,
+    'chainId' | 'name' | 'verifyingContract' | 'version'
+  >
+}
+
+export type HashMessageReturnType = Hex
+
+export type HashMessageErrorType =
+  | HashTypedDataErrorType
+  | ToPrefixedMessageErrorType
+  | ErrorType
+
+/**
+ * Generates a signable hash for a Solady ERC-1271 personal sign message.
+ *
+ * @example
+ * ```ts
+ * const hash = hashMessage({
+ *   message: 'hello world',
+ *   verifierDomain: {
+ *     name: 'Smart Account',
+ *     version: '1',
+ *     verifyingContract: '0x1234567890abcdef1234567890abcdef12345678',
+ *     chainId: 1,
+ *   },
+ * })
+ * ```
+ */
+export function hashMessage(
+  parameters: HashMessageParameters,
+): HashMessageReturnType {
+  const {
+    message,
+    verifierDomain: { salt, ...domain },
+  } = parameters
+  return hashTypedData({
+    domain,
+    types: {
+      PersonalSign: [{ name: 'prefixed', type: 'bytes' }],
+    },
+    primaryType: 'PersonalSign',
+    message: {
+      prefixed: toPrefixedMessage(message),
+    },
+  })
+}

package/experimental/solady/utils/hashTypedData.ts

@@ -0,0 +1,112 @@
+import type { TypedData, TypedDataDomain } from 'abitype'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Hex } from '../../../types/misc.js'
+import type { TypedDataDefinition } from '../../../types/typedData.js'
+import type { RequiredBy } from '../../../types/utils.js'
+import {
+  type HashTypedDataErrorType as HashTypedDataErrorType_,
+  hashTypedData as hashTypedData_,
+} from '../../../utils/signature/hashTypedData.js'
+
+export type HashTypedDataParameters<
+  typedData extends TypedData | Record<string, unknown> = TypedData,
+  primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData,
+  ///
+  primaryTypes = typedData extends TypedData ? keyof typedData : string,
+> = TypedDataDefinition<typedData, primaryType, primaryTypes> & {
+  fields: Hex
+  extensions: readonly bigint[]
+  verifierDomain: RequiredBy<
+    TypedDataDomain,
+    'chainId' | 'name' | 'verifyingContract' | 'version'
+  >
+}
+
+export type HashTypedDataReturnType = Hex
+
+export type HashTypedDataErrorType = HashTypedDataErrorType_ | ErrorType
+
+/**
+ * Generates a signable hash for Solady ERC-1271 typed data.
+ *
+ * @example
+ * ```ts
+ * const hash = hashTypedData({
+ *   domain: {
+ *     name: 'Ether Mail',
+ *     version: '1',
+ *     chainId: 1,
+ *     verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
+ *   },
+ *   types: {
+ *     Person: [
+ *       { name: 'name', type: 'string' },
+ *       { name: 'wallet', type: 'address' },
+ *     ],
+ *     Mail: [
+ *       { name: 'from', type: 'Person' },
+ *       { name: 'to', type: 'Person' },
+ *       { name: 'contents', type: 'string' },
+ *     ],
+ *   },
+ *   primaryType: 'Mail',
+ *   message: {
+ *     from: {
+ *       name: 'Cow',
+ *       wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
+ *     },
+ *     to: {
+ *       name: 'Bob',
+ *       wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
+ *     },
+ *     contents: 'Hello, Bob!',
+ *   },
+ *   verifierDomain: {
+ *     name: 'Smart Account',
+ *     version: '1',
+ *     verifyingContract: '0x1234567890abcdef1234567890abcdef12345678',
+ *     chainId: 1,
+ *   },
+ * })
+ * ```
+ */
+export function hashTypedData<
+  const typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | 'EIP712Domain',
+>(
+  parameters: HashTypedDataParameters<typedData, primaryType>,
+): HashTypedDataReturnType {
+  const {
+    domain,
+    extensions,
+    fields,
+    message,
+    primaryType,
+    types,
+    verifierDomain,
+  } = parameters
+
+  return hashTypedData_({
+    domain: domain as any,
+    types: {
+      ...types,
+      TypedDataSign: [
+        { name: 'contents', type: primaryType },
+        { name: 'fields', type: 'bytes1' },
+        { name: 'name', type: 'string' },
+        { name: 'version', type: 'string' },
+        { name: 'chainId', type: 'uint256' },
+        { name: 'verifyingContract', type: 'address' },
+        { name: 'salt', type: 'bytes32' },
+        { name: 'extensions', type: 'uint256[]' },
+      ],
+    },
+    primaryType: 'TypedDataSign',
+    message: {
+      contents: message as any,
+      fields,
+      extensions,
+      ...(verifierDomain as any),
+    },
+  })
+}