viem 0.0.0-tsc-and-nodenext-20230405154910 → 0.0.0-w-20230711200108

package/src/actions/wallet/getAddresses.ts

@@ -1,16 +1,38 @@
 import type { Address } from 'abitype'
 
-import type { Transport, WalletClient } from '../../clients/index.js'
-import type { Account, Chain } from '../../types/index.js'
-import { checksumAddress } from '../../utils/address/index.js'
+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 { checksumAddress } from '../../utils/address/getAddress.js'
 
 export type GetAddressesReturnType = Address[]
 
+/**
+ * Returns a list of account addresses owned by the wallet or client.
+ *
+ * - Docs: https://viem.sh/docs/actions/wallet/getAddresses.html
+ * - JSON-RPC Methods: [`eth_accounts`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_accounts)
+ *
+ * @param client - Client to use
+ * @returns List of account addresses owned by the wallet or client. {@link GetAddressesReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { getAddresses } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const accounts = await getAddresses(client)
+ */
 export async function getAddresses<
   TChain extends Chain | undefined,
   TAccount extends Account | undefined = undefined,
 >(
-  client: WalletClient<Transport, TChain, TAccount>,
+  client: Client<Transport, TChain, TAccount>,
 ): Promise<GetAddressesReturnType> {
   const addresses = await client.request({ method: 'eth_accounts' })
   return addresses.map((address) => checksumAddress(address))

package/src/actions/wallet/getPermissions.ts

@@ -1,13 +1,35 @@
-import type { Transport, WalletClient } from '../../clients/index.js'
-import type { Account, Chain } from '../../types/index.js'
+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 { WalletPermission } from '../../types/eip1193.js'
 
 export type GetPermissionsReturnType = WalletPermission[]
 
+/**
+ * Gets the wallets current permissions.
+ *
+ * - Docs: https://viem.sh/docs/actions/wallet/getPermissions.html
+ * - JSON-RPC Methods: [`wallet_getPermissions`](https://eips.ethereum.org/EIPS/eip-2255)
+ *
+ * @param client - Client to use
+ * @returns The wallet permissions. {@link GetPermissionsReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { getPermissions } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const permissions = await getPermissions(client)
+ */
 export async function getPermissions<
   TChain extends Chain | undefined,
   TAccount extends Account | undefined = undefined,
->(client: WalletClient<Transport, TChain, TAccount>) {
+>(client: Client<Transport, TChain, TAccount>) {
   const permissions = await client.request({ method: 'wallet_getPermissions' })
   return permissions
 }

package/src/actions/wallet/requestAddresses.ts

@@ -1,16 +1,42 @@
 import type { Address } from 'abitype'
 
-import type { Transport, WalletClient } from '../../clients/index.js'
-import type { Account, Chain } from '../../types/index.js'
-import { getAddress } from '../../utils/index.js'
+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 { getAddress } from '../../utils/address/getAddress.js'
 
 export type RequestAddressesReturnType = Address[]
 
+/**
+ * Requests a list of accounts managed by a wallet.
+ *
+ * - Docs: https://viem.sh/docs/actions/wallet/requestAddresses.html
+ * - JSON-RPC Methods: [`eth_requestAccounts`](https://eips.ethereum.org/EIPS/eip-1102)
+ *
+ * Sends a request to the wallet, asking for permission to access the user's accounts. After the user accepts the request, it will return a list of accounts (addresses).
+ *
+ * This API can be useful for dapps that need to access the user's accounts in order to execute transactions or interact with smart contracts.
+ *
+ * @param client - Client to use
+ * @returns List of accounts managed by a wallet {@link RequestAddressesReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { requestAddresses } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const accounts = await requestAddresses(client)
+ */
 export async function requestAddresses<
   TChain extends Chain | undefined,
   TAccount extends Account | undefined = undefined,
 >(
-  client: WalletClient<Transport, TChain, TAccount>,
+  client: Client<Transport, TChain, TAccount>,
 ): Promise<RequestAddressesReturnType> {
   const addresses = await client.request({ method: 'eth_requestAccounts' })
   return addresses.map((address) => getAddress(address))

package/src/actions/wallet/requestPermissions.ts

@@ -1,19 +1,47 @@
-import type { Transport, WalletClient } from '../../clients/index.js'
-import type { Account, Chain } from '../../types/index.js'
+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 { WalletPermission } from '../../types/eip1193.js'
+import type { Prettify } from '../../types/utils.js'
 
-export type RequestPermissionsParameters = {
-  eth_accounts: Record<string, any>
-} & {
-  [key: string]: Record<string, any>
-}
+export type RequestPermissionsParameters = Prettify<
+  {
+    eth_accounts: Record<string, any>
+  } & {
+    [key: string]: Record<string, any>
+  }
+>
 export type RequestPermissionsReturnType = WalletPermission[]
 
+/**
+ * Requests permissions for a wallet.
+ *
+ * - Docs: https://viem.sh/docs/actions/wallet/requestPermissions.html
+ * - JSON-RPC Methods: [`wallet_requestPermissions`](https://eips.ethereum.org/EIPS/eip-2255)
+ *
+ * @param client - Client to use
+ * @param parameters - {@link RequestPermissionsParameters}
+ * @returns The wallet permissions. {@link RequestPermissionsReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { requestPermissions } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const permissions = await requestPermissions(client, {
+ *   eth_accounts: {}
+ * })
+ */
 export async function requestPermissions<
   TChain extends Chain | undefined,
   TAccount extends Account | undefined = undefined,
 >(
-  client: WalletClient<Transport, TChain, TAccount>,
+  client: Client<Transport, TChain, TAccount>,
   permissions: RequestPermissionsParameters,
 ) {
   return client.request({

package/src/actions/wallet/sendTransaction.ts

@@ -1,59 +1,94 @@
-import type { Transport, WalletClient } from '../../clients/index.js'
-import type { BaseError } from '../../errors/index.js'
-import {
-  AccountNotFoundError,
-  ChainMismatchError,
-  ChainNotFoundError,
-} from '../../errors/index.js'
+import type { Account } from '../../accounts/types.js'
+import { parseAccount } from '../../accounts/utils/parseAccount.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import { AccountNotFoundError } from '../../errors/account.js'
+import type { BaseError } from '../../errors/base.js'
+import type { GetAccountParameter } from '../../types/account.js'
+import type { Chain, GetChain } from '../../types/chain.js'
+import type { Hash } from '../../types/misc.js'
 import type {
-  Account,
-  GetAccountParameter,
-  Chain,
-  Formatter,
-  GetChain,
-  Hash,
-  MergeIntersectionProperties,
   TransactionRequest,
   TransactionSerializable,
-} from '../../types/index.js'
+} from '../../types/transaction.js'
+import type { IsUndefined, UnionOmit } from '../../types/utils.js'
+import { assertCurrentChain } from '../../utils/chain.js'
+import { getTransactionError } from '../../utils/errors/getTransactionError.js'
+import { extract } from '../../utils/formatters/extract.js'
 import {
-  assertRequest,
-  extract,
-  format,
+  type FormattedTransactionRequest,
   formatTransactionRequest,
-  getTransactionError,
-  parseAccount,
-  prepareRequest,
-} from '../../utils/index.js'
-import type {
-  Formatted,
-  TransactionRequestFormatter,
-} from '../../utils/index.js'
-import { getChainId } from '../public/index.js'
-
-export type FormattedTransactionRequest<
-  TFormatter extends Formatter | undefined = Formatter,
-> = MergeIntersectionProperties<
-  Omit<Formatted<TFormatter, TransactionRequest, true>, 'from'>,
-  TransactionRequest
->
+} from '../../utils/formatters/transactionRequest.js'
+import { assertRequest } from '../../utils/transaction/assertRequest.js'
+import { prepareRequest } from '../../utils/transaction/prepareRequest.js'
+import { getChainId } from '../public/getChainId.js'
 
 export type SendTransactionParameters<
   TChain extends Chain | undefined = Chain | undefined,
   TAccount extends Account | undefined = Account | undefined,
   TChainOverride extends Chain | undefined = Chain,
-> = FormattedTransactionRequest<TransactionRequestFormatter<TChainOverride>> &
+> = UnionOmit<
+  FormattedTransactionRequest<
+    IsUndefined<TChain> extends true ? TChainOverride : TChain
+  >,
+  'from'
+> &
   GetAccountParameter<TAccount> &
   GetChain<TChain, TChainOverride>
 
 export type SendTransactionReturnType = Hash
 
+/**
+ * Creates, signs, and sends a new transaction to the network.
+ *
+ * - Docs: https://viem.sh/docs/actions/wallet/sendTransaction.html
+ * - Examples: https://stackblitz.com/github/wagmi-dev/viem/tree/main/examples/transactions/sending-transactions
+ * - JSON-RPC Methods:
+ *   - JSON-RPC Accounts: [`eth_sendTransaction`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sendtransaction)
+ *   - Local Accounts: [`eth_sendRawTransaction`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sendrawtransaction)
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SendTransactionParameters}
+ * @returns The [Transaction](https://viem.sh/docs/glossary/terms.html#transaction) hash. {@link SendTransactionReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { sendTransaction } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const hash = await sendTransaction(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { sendTransaction } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const hash = await sendTransaction(client, {
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ * })
+ */
 export async function sendTransaction<
   TChain extends Chain | undefined,
   TAccount extends Account | undefined,
   TChainOverride extends Chain | undefined,
 >(
-  client: WalletClient<Transport, TChain, TAccount>,
+  client: Client<Transport, TChain, TAccount>,
   args: SendTransactionParameters<TChain, TAccount, TChainOverride>,
 ): Promise<SendTransactionReturnType> {
   const {
@@ -80,10 +115,13 @@ export async function sendTransaction<
   try {
     assertRequest(args)
 
-    const chainId = await getChainId(client)
-    if (chain !== null && chainId !== chain?.id) {
-      if (!chain) throw new ChainNotFoundError()
-      throw new ChainMismatchError({ chain, currentChainId: chainId })
+    let chainId
+    if (chain !== null) {
+      chainId = await getChainId(client)
+      assertCurrentChain({
+        currentChainId: chainId,
+        chain,
+      })
     }
 
     if (account.type === 'local') {
@@ -103,36 +141,38 @@ export async function sendTransaction<
         ...rest,
       })
 
-      const signedRequest = (await account.signTransaction({
-        chainId,
-        ...request,
-      } as TransactionSerializable)) as Hash
+      if (!chainId) chainId = await getChainId(client)
+
+      const serializer = chain?.serializers?.transaction
+      const signedRequest = (await account.signTransaction(
+        {
+          ...request,
+          chainId,
+        } as TransactionSerializable,
+        { serializer },
+      )) as Hash
       return await client.request({
         method: 'eth_sendRawTransaction',
         params: [signedRequest],
       })
     }
 
-    const formatter = chain?.formatters?.transactionRequest
-    const request = format(
-      {
-        accessList,
-        data,
-        from: account.address,
-        gas,
-        gasPrice,
-        maxFeePerGas,
-        maxPriorityFeePerGas,
-        nonce,
-        to,
-        value,
-        // Pick out extra data that might exist on the chain's transaction request type.
-        ...extract(rest, { formatter }),
-      } as TransactionRequest,
-      {
-        formatter: formatter || formatTransactionRequest,
-      },
-    )
+    const format =
+      chain?.formatters?.transactionRequest?.format || formatTransactionRequest
+    const request = format({
+      // Pick out extra data that might exist on the chain's transaction request type.
+      ...extract(rest, { format }),
+      accessList,
+      data,
+      from: account.address,
+      gas,
+      gasPrice,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      nonce,
+      to,
+      value,
+    } as TransactionRequest)
     return await client.request({
       method: 'eth_sendTransaction',
       params: [request],

package/src/actions/wallet/signMessage.ts

@@ -1,26 +1,72 @@
-import type { Transport, WalletClient } from '../../clients/index.js'
-import { AccountNotFoundError } from '../../errors/index.js'
-import type {
-  Account,
-  Chain,
-  GetAccountParameter,
-  Hex,
-} from '../../types/index.js'
-import { parseAccount, toHex } from '../../utils/index.js'
+import type { Account } from '../../accounts/types.js'
+import { parseAccount } from '../../accounts/utils/parseAccount.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import { AccountNotFoundError } from '../../errors/account.js'
+import type { GetAccountParameter } from '../../types/account.js'
+import type { Chain } from '../../types/chain.js'
+import type { Hex, SignableMessage } from '../../types/misc.js'
+import { stringToHex, toHex } from '../../utils/encoding/toHex.js'
 
 export type SignMessageParameters<
   TAccount extends Account | undefined = Account | undefined,
 > = GetAccountParameter<TAccount> & {
-  message: string
+  message: SignableMessage
 }
 
 export type SignMessageReturnType = Hex
 
+/**
+ * Calculates an Ethereum-specific signature in [EIP-191 format](https://eips.ethereum.org/EIPS/eip-191): `keccak256("\x19Ethereum Signed Message:\n" + len(message) + message))`.
+ *
+ * - Docs: https://viem.sh/docs/actions/wallet/signMessage.html
+ * - JSON-RPC Methods:
+ *   - JSON-RPC Accounts: [`personal_sign`](https://docs.metamask.io/guide/signing-data.html#personal-sign)
+ *   - Local Accounts: Signs locally. No JSON-RPC request.
+ *
+ * With the calculated signature, you can:
+ * - use [`verifyMessage`](https://viem.sh/docs/utilities/verifyMessage.html) to verify the signature,
+ * - use [`recoverMessageAddress`](https://viem.sh/docs/utilities/recoverMessageAddress.html) to recover the signing address from a signature.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SignMessageParameters}
+ * @returns The signed message. {@link SignMessageReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { signMessage } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const signature = await signMessage(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   message: 'hello world',
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, custom } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { signMessage } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const signature = await signMessage(client, {
+ *   message: 'hello world',
+ * })
+ */
 export async function signMessage<
   TChain extends Chain | undefined,
   TAccount extends Account | undefined,
 >(
-  client: WalletClient<Transport, TChain, TAccount>,
+  client: Client<Transport, TChain, TAccount>,
   {
     account: account_ = client.account,
     message,
@@ -32,8 +78,15 @@ export async function signMessage<
     })
   const account = parseAccount(account_)
   if (account.type === 'local') return account.signMessage({ message })
+
+  const message_ = (() => {
+    if (typeof message === 'string') return stringToHex(message)
+    if (message.raw instanceof Uint8Array) return toHex(message.raw)
+    return message.raw
+  })()
+
   return client.request({
     method: 'personal_sign',
-    params: [toHex(message), account.address],
+    params: [message_, account.address],
   })
 }

package/src/actions/wallet/signTypedData.ts

@@ -1,19 +1,17 @@
 import type { TypedData } from 'abitype'
-import type { Transport, WalletClient } from '../../clients/index.js'
-import { AccountNotFoundError } from '../../errors/index.js'
-import type {
-  Account,
-  Chain,
-  GetAccountParameter,
-  Hex,
-  TypedDataDefinition,
-} from '../../types/index.js'
-import {
-  isHex,
-  parseAccount,
-  stringify,
-  validateTypedData,
-} from '../../utils/index.js'
+
+import type { Account } from '../../accounts/types.js'
+import { parseAccount } from '../../accounts/utils/parseAccount.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import { AccountNotFoundError } from '../../errors/account.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 { isHex } from '../../utils/data/isHex.js'
+import { stringify } from '../../utils/stringify.js'
+import { validateTypedData } from '../../utils/typedData.js'
 
 export type SignTypedDataParameters<
   TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
@@ -24,13 +22,111 @@ export type SignTypedDataParameters<
 
 export type SignTypedDataReturnType = Hex
 
+/**
+ * Signs typed data and calculates an Ethereum-specific signature in [https://eips.ethereum.org/EIPS/eip-712](https://eips.ethereum.org/EIPS/eip-712): `sign(keccak256("\x19\x01" ‖ domainSeparator ‖ hashStruct(message)))`
+ *
+ * - Docs: https://viem.sh/docs/actions/wallet/signTypedData.html
+ * - JSON-RPC Methods:
+ *   - JSON-RPC Accounts: [`eth_signTypedData_v4`](https://docs.metamask.io/guide/signing-data.html#signtypeddata-v4)
+ *   - Local Accounts: Signs locally. No JSON-RPC request.
+ *
+ * @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/wallet'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const signature = await signTypedData(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   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!',
+ *   },
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { signTypedData } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   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!',
+ *   },
+ * })
+ */
 export async function signTypedData<
   TTypedData extends TypedData | { [key: string]: unknown },
   TPrimaryType extends string,
   TChain extends Chain | undefined,
   TAccount extends Account | undefined,
 >(
-  client: WalletClient<Transport, TChain, TAccount>,
+  client: Client<Transport, TChain, TAccount>,
   {
     account: account_ = client.account,
     domain,
@@ -47,9 +143,12 @@ export async function signTypedData<
 
   const types = {
     EIP712Domain: [
-      domain?.name && { name: 'name', type: 'string' },
+      typeof domain?.name === 'string' && { name: 'name', type: 'string' },
       domain?.version && { name: 'version', type: 'string' },
-      domain?.chainId && { name: 'chainId', type: 'uint256' },
+      typeof domain?.chainId === 'number' && {
+        name: 'chainId',
+        type: 'uint256',
+      },
       domain?.verifyingContract && {
         name: 'verifyingContract',
         type: 'address',