viem 0.2.11 → 0.2.13

package/src/accounts/types.ts

@@ -0,0 +1,64 @@
+import type { HDKey } from '@scure/bip32'
+import type { Address, TypedData } from 'abitype'
+import type {
+  Hash,
+  Hex,
+  TransactionSerializable,
+  TypedDataDefinition,
+} from '../types/index.js'
+
+export type Account<TAddress extends Address = Address> =
+  | JsonRpcAccount<TAddress>
+  | LocalAccount<string, TAddress>
+
+export type AccountSource = Address | CustomSource
+export type CustomSource = {
+  address: Address
+  signMessage: ({ message }: { message: string }) => Promise<Hash>
+  signTransaction: (transaction: TransactionSerializable) => Promise<Hash>
+  signTypedData: <
+    TTypedData extends TypedData | { [key: string]: unknown },
+    TPrimaryType extends string = string,
+  >(
+    typedData: TypedDataDefinition<TTypedData, TPrimaryType>,
+  ) => Promise<Hash>
+}
+
+export type JsonRpcAccount<TAddress extends Address = Address> = {
+  address: TAddress
+  type: 'json-rpc'
+}
+
+export type LocalAccount<
+  TSource extends string = 'custom',
+  TAddress extends Address = Address,
+> = CustomSource & {
+  address: TAddress
+  publicKey: Hex
+  source: TSource
+  type: 'local'
+}
+
+export type HDAccount = LocalAccount<'hd'> & {
+  getHdKey(): HDKey
+}
+
+export type HDOptions =
+  | {
+      /** The account index to use in the path (`"m/44'/60'/${accountIndex}'/0/0"`). */
+      accountIndex?: number
+      /** The address index to use in the path (`"m/44'/60'/0'/0/${addressIndex}"`). */
+      addressIndex?: number
+      /** The change index to use in the path (`"m/44'/60'/0'/${changeIndex}/0"`). */
+      changeIndex?: number
+      path?: never
+    }
+  | {
+      accountIndex?: never
+      addressIndex?: never
+      changeIndex?: never
+      /** The HD path. */
+      path: `m/44'/60'/${string}`
+    }
+
+export type PrivateKeyAccount = LocalAccount<'privateKey'>

package/src/accounts/utils/index.ts

@@ -0,0 +1,23 @@
+export { parseAccount } from './parseAccount.js'
+
+export { publicKeyToAddress } from './publicKeyToAddress.js'
+
+export type {
+  SignMessageParameters,
+  SignMessageReturnType,
+} from './signMessage.js'
+export { signMessage } from './signMessage.js'
+
+export { signatureToHex } from './signatureToHex.js'
+
+export type {
+  SignTransactionArgs,
+  SignTransactionReturnType,
+} from './signTransaction.js'
+export { signTransaction } from './signTransaction.js'
+
+export type {
+  SignTypedDataParameters,
+  SignTypedDataReturnType,
+} from './signTypedData.js'
+export { signTypedData } from './signTypedData.js'

package/src/accounts/utils/parseAccount.ts

@@ -0,0 +1,7 @@
+import type { Address } from '../../types/index.js'
+import type { Account } from '../types.js'
+
+export function parseAccount(account: Address | Account): Account {
+  if (typeof account === 'string') return { address: account, type: 'json-rpc' }
+  return account
+}

package/src/accounts/utils/publicKeyToAddress.ts

@@ -0,0 +1,15 @@
+import type { Address, Hex } from '../../types/index.js'
+import { keccak256 } from '../../utils/index.js'
+import { checksumAddress } from '../../utils/address/index.js'
+
+/**
+ * @description Converts an ECDSA public key to an address.
+ *
+ * @param publicKey The public key to convert.
+ *
+ * @returns The address.
+ */
+export function publicKeyToAddress(publicKey: Hex): Address {
+  const address = keccak256(`0x${publicKey.substring(4)}`).substring(26)
+  return checksumAddress(`0x${address}`) as Address
+}

package/src/accounts/utils/sign.ts

@@ -0,0 +1,30 @@
+import { secp256k1 } from '@noble/curves/secp256k1'
+
+import type { Hex, Signature } from '../../types/index.js'
+import { toHex } from '../../utils/index.js'
+
+export type SignParameters = {
+  hash: Hex
+  privateKey: Hex
+}
+export type SignReturnType = Signature
+
+/**
+ * @description Signs a hash with a given private key.
+ *
+ * @param hash The hash to sign.
+ * @param privateKey The private key to sign with.
+ *
+ * @returns The signature.
+ */
+export async function sign({
+  hash,
+  privateKey,
+}: SignParameters): Promise<SignReturnType> {
+  const { r, s, recovery } = secp256k1.sign(hash.slice(2), privateKey.slice(2))
+  return {
+    r: toHex(r),
+    s: toHex(s),
+    v: recovery ? 28n : 27n,
+  }
+}

package/src/accounts/utils/signMessage.ts

@@ -0,0 +1,26 @@
+import type { Hex } from '../../types/index.js'
+import { hashMessage } from '../../utils/index.js'
+import { sign } from './sign.js'
+import { signatureToHex } from './signatureToHex.js'
+
+export type SignMessageParameters = {
+  /** The message to sign. */
+  message: string
+  /** The private key to sign with. */
+  privateKey: Hex
+}
+export type SignMessageReturnType = Hex
+
+/**
+ * @description Calculates an Ethereum-specific signature in [EIP-191 format](https://eips.ethereum.org/EIPS/eip-191):
+ * `keccak256("\x19Ethereum Signed Message:\n" + len(message) + message))`.
+ *
+ * @returns The signature.
+ */
+export async function signMessage({
+  message,
+  privateKey,
+}: SignMessageParameters): Promise<SignMessageReturnType> {
+  const signature = await sign({ hash: hashMessage(message), privateKey })
+  return signatureToHex(signature)
+}

package/src/accounts/utils/signTransaction.ts

@@ -0,0 +1,35 @@
+import type {
+  Hex,
+  TransactionSerializable,
+  TransactionSerialized,
+  TransactionType,
+} from '../../types/index.js'
+import { keccak256, serializeTransaction } from '../../utils/index.js'
+import type { GetTransactionType } from '../../utils/index.js'
+import { sign } from './sign.js'
+
+export type SignTransactionArgs<
+  TTransactionSerializable extends TransactionSerializable = TransactionSerializable,
+> = {
+  privateKey: Hex
+  transaction: TTransactionSerializable
+}
+export type SignTransactionReturnType<
+  TTransactionSerializable extends TransactionSerializable = TransactionSerializable,
+  TTransactionType extends TransactionType = GetTransactionType<TTransactionSerializable>,
+> = TransactionSerialized<TTransactionType>
+
+export async function signTransaction<
+  TTransactionSerializable extends TransactionSerializable,
+>({
+  privateKey,
+  transaction,
+}: SignTransactionArgs<TTransactionSerializable>): Promise<
+  SignTransactionReturnType<TTransactionSerializable>
+> {
+  const signature = await sign({
+    hash: keccak256(serializeTransaction(transaction)),
+    privateKey,
+  })
+  return serializeTransaction(transaction, signature)
+}

package/src/accounts/utils/signTypedData.ts

@@ -0,0 +1,40 @@
+import type { TypedData } from 'abitype'
+
+import type { Hex, TypedDataDefinition } from '../../types/index.js'
+import type { HashTypedDataParameters } from '../../utils/index.js'
+import { hashTypedData } from '../../utils/index.js'
+import { sign } from './sign.js'
+import { signatureToHex } from './signatureToHex.js'
+
+export type SignTypedDataParameters<
+  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
+  TPrimaryType extends string = string,
+> = TypedDataDefinition<TTypedData, TPrimaryType> & {
+  /** The private key to sign with. */
+  privateKey: Hex
+}
+
+export type SignTypedDataReturnType = Hex
+
+/**
+ * @description Signs typed data and calculates an Ethereum-specific signature in [EIP-191 format](https://eips.ethereum.org/EIPS/eip-191):
+ * `keccak256("\x19Ethereum Signed Message:\n" + len(message) + message))`.
+ *
+ * @returns The signature.
+ */
+export async function signTypedData<
+  TTypedData extends TypedData | { [key: string]: unknown },
+  TPrimaryType extends string = string,
+>({
+  privateKey,
+  ...typedData
+}: SignTypedDataParameters<
+  TTypedData,
+  TPrimaryType
+>): Promise<SignTypedDataReturnType> {
+  const signature = await sign({
+    hash: hashTypedData(typedData as HashTypedDataParameters),
+    privateKey,
+  })
+  return signatureToHex(signature)
+}

package/src/accounts/utils/signatureToHex.ts

@@ -0,0 +1,11 @@
+import { secp256k1 } from '@noble/curves/secp256k1'
+
+import type { Hex, Signature } from '../../types/index.js'
+import { hexToBigInt, toHex } from '../../utils/index.js'
+
+export function signatureToHex({ r, s, v }: Signature): Hex {
+  return `0x${new secp256k1.Signature(
+    hexToBigInt(r),
+    hexToBigInt(s),
+  ).toCompactHex()}${toHex(v).slice(2)}`
+}

package/src/accounts/wordlists/czech.ts

@@ -0,0 +1 @@
+export { wordlist as czech } from '@scure/bip39/wordlists/czech.js'

package/src/accounts/wordlists/english.ts

@@ -0,0 +1 @@
+export { wordlist as english } from '@scure/bip39/wordlists/english.js'

package/src/accounts/wordlists/french.ts

@@ -0,0 +1 @@
+export { wordlist as french } from '@scure/bip39/wordlists/french.js'

package/src/accounts/wordlists/italian.ts

@@ -0,0 +1 @@
+export { wordlist as italian } from '@scure/bip39/wordlists/italian.js'

package/src/accounts/wordlists/japanese.ts

@@ -0,0 +1 @@
+export { wordlist as japanese } from '@scure/bip39/wordlists/japanese.js'

package/src/accounts/wordlists/korean.ts

@@ -0,0 +1 @@
+export { wordlist as korean } from '@scure/bip39/wordlists/korean.js'

package/src/accounts/wordlists/simplifiedChinese.ts

@@ -0,0 +1 @@
+export { wordlist as simplifiedChinese } from '@scure/bip39/wordlists/simplified-chinese.js'

package/src/accounts/wordlists/spanish.ts

@@ -0,0 +1 @@
+export { wordlist as spanish } from '@scure/bip39/wordlists/spanish.js'

package/src/accounts/wordlists/traditionalChinese.ts

@@ -0,0 +1 @@
+export { wordlist as traditionalChinese } from '@scure/bip39/wordlists/traditional-chinese.js'

package/src/actions/ens/getEnsAddress.ts

@@ -0,0 +1,83 @@
+import type { PublicClient, Transport } from '../../clients/index.js'
+import {
+  singleAddressResolverAbi,
+  universalResolverAbi,
+} from '../../constants/abis.js'
+import type { Address, Chain, Prettify } from '../../types/index.js'
+import {
+  decodeFunctionResult,
+  encodeFunctionData,
+  getChainContractAddress,
+  toHex,
+  trim,
+} from '../../utils/index.js'
+import { namehash, packetToBytes } from '../../utils/ens/index.js'
+import { readContract } from '../public/index.js'
+import type { ReadContractParameters } from '../public/index.js'
+
+export type GetEnsAddressParameters = Prettify<
+  Pick<ReadContractParameters, 'blockNumber' | 'blockTag'> & {
+    /** ENS name to get address. */
+    name: string
+    /** Address of ENS Universal Resolver Contract */
+    universalResolverAddress?: Address
+  }
+>
+
+export type GetEnsAddressReturnType = Address | null
+
+/**
+ * @description Gets address for ENS name.
+ *
+ * - Calls `resolve(bytes, bytes)` on ENS Universal Resolver Contract.
+ * - Since ENS names prohibit certain forbidden characters (e.g. underscore) and have other validation rules, you likely want to [normalize ENS names](https://docs.ens.domains/contract-api-reference/name-processing#normalising-names) with [UTS-46 normalization](https://unicode.org/reports/tr46) before passing them to `getEnsAddress`. You can use the built-in [`normalize`](https://viem.sh/docs/ens/utilities/normalize.html) function for this.
+ */
+export async function getEnsAddress<TChain extends Chain | undefined,>(
+  client: PublicClient<Transport, TChain>,
+  {
+    blockNumber,
+    blockTag,
+    name,
+    universalResolverAddress: universalResolverAddress_,
+  }: GetEnsAddressParameters,
+): Promise<GetEnsAddressReturnType> {
+  let universalResolverAddress = universalResolverAddress_
+  if (!universalResolverAddress) {
+    if (!client.chain)
+      throw new Error(
+        'client chain not configured. universalResolverAddress is required.',
+      )
+
+    universalResolverAddress = getChainContractAddress({
+      blockNumber,
+      chain: client.chain,
+      contract: 'ensUniversalResolver',
+    })
+  }
+
+  const res = await readContract(client, {
+    address: universalResolverAddress,
+    abi: universalResolverAbi,
+    functionName: 'resolve',
+    args: [
+      toHex(packetToBytes(name)),
+      encodeFunctionData({
+        abi: singleAddressResolverAbi,
+        functionName: 'addr',
+        args: [namehash(name)],
+      }),
+    ],
+    blockNumber,
+    blockTag,
+  })
+
+  if (res[0] === '0x') return null
+
+  const address = decodeFunctionResult({
+    abi: singleAddressResolverAbi,
+    functionName: 'addr',
+    data: res[0],
+  })
+
+  return trim(address) === '0x0' ? null : address
+}

package/src/actions/ens/getEnsAvatar.ts

@@ -0,0 +1,42 @@
+import type { PublicClient, Transport } from '../../clients/index.js'
+import type { AssetGatewayUrls, Chain, Prettify } from '../../types/index.js'
+import { parseAvatarRecord } from '../../utils/ens/index.js'
+import { getEnsText } from './getEnsText.js'
+import type { GetEnsTextParameters } from './getEnsText.js'
+
+export type GetEnsAvatarParameters = Prettify<
+  Omit<GetEnsTextParameters, 'key'> & {
+    /** Custom gateways to use */
+    gatewayUrls?: AssetGatewayUrls
+  }
+>
+
+export type GetEnsAvatarReturnType = string | null
+
+/**
+ * @description Gets avatar URI for ENS name.
+ */
+export async function getEnsAvatar<TChain extends Chain | undefined>(
+  client: PublicClient<Transport, TChain>,
+  {
+    blockNumber,
+    blockTag,
+    gatewayUrls,
+    name,
+    universalResolverAddress,
+  }: GetEnsAvatarParameters,
+): Promise<GetEnsAvatarReturnType> {
+  const record = await getEnsText(client, {
+    blockNumber,
+    blockTag,
+    key: 'avatar',
+    name,
+    universalResolverAddress,
+  })
+  if (!record) return null
+  try {
+    return await parseAvatarRecord(client, { record, gatewayUrls })
+  } catch {
+    return null
+  }
+}

package/src/actions/ens/getEnsName.ts

@@ -0,0 +1,89 @@
+import type { PublicClient, Transport } from '../../clients/index.js'
+import { panicReasons } from '../../constants/index.js'
+import type { ContractFunctionRevertedError } from '../../errors/index.js'
+import { ContractFunctionExecutionError } from '../../errors/index.js'
+import type { Address, Chain, Prettify } from '../../types/index.js'
+import { getChainContractAddress, toHex } from '../../utils/index.js'
+import { packetToBytes } from '../../utils/ens/index.js'
+import { readContract } from '../public/index.js'
+import type { ReadContractParameters } from '../public/index.js'
+
+export type GetEnsNameParameters = Prettify<
+  Pick<ReadContractParameters, 'blockNumber' | 'blockTag'> & {
+    /** Address to get ENS name for. */
+    address: Address
+    /** Address of ENS Universal Resolver Contract. */
+    universalResolverAddress?: Address
+  }
+>
+
+export type GetEnsNameReturnType = string | null
+
+/**
+ * @description Gets primary name for specified address.
+ *
+ * - Calls `reverse(bytes)` on ENS Universal Resolver Contract.
+ *
+ * @example
+ * const ensName = await getEnsName(publicClient, {
+ *   address: '0xd2135CfB216b74109775236E36d4b433F1DF507B',
+ * })
+ * // 'wagmi-dev.eth'
+ */
+export async function getEnsName<TChain extends Chain | undefined>(
+  client: PublicClient<Transport, TChain>,
+  {
+    address,
+    blockNumber,
+    blockTag,
+    universalResolverAddress: universalResolverAddress_,
+  }: GetEnsNameParameters,
+): Promise<GetEnsNameReturnType> {
+  let universalResolverAddress = universalResolverAddress_
+  if (!universalResolverAddress) {
+    if (!client.chain)
+      throw new Error(
+        'client chain not configured. universalResolverAddress is required.',
+      )
+
+    universalResolverAddress = getChainContractAddress({
+      blockNumber,
+      chain: client.chain,
+      contract: 'ensUniversalResolver',
+    })
+  }
+
+  const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`
+  try {
+    const res = await readContract(client, {
+      address: universalResolverAddress,
+      abi: [
+        {
+          name: 'reverse',
+          type: 'function',
+          stateMutability: 'view',
+          inputs: [{ type: 'bytes', name: 'reverseName' }],
+          outputs: [
+            { type: 'string', name: 'resolvedName' },
+            { type: 'address', name: 'resolvedAddress' },
+            { type: 'address', name: 'reverseResolver' },
+            { type: 'address', name: 'resolver' },
+          ],
+        },
+      ],
+      functionName: 'reverse',
+      args: [toHex(packetToBytes(reverseNode))],
+      blockNumber,
+      blockTag,
+    })
+    return res[0]
+  } catch (error) {
+    if (
+      error instanceof ContractFunctionExecutionError &&
+      (error.cause as ContractFunctionRevertedError).reason === panicReasons[50]
+    )
+      // No primary name set for address.
+      return null
+    throw error
+  }
+}

package/src/actions/ens/getEnsResolver.ts

@@ -0,0 +1,62 @@
+import type { PublicClient, Transport } from '../../clients/index.js'
+import type { Address, Chain, Prettify } from '../../types/index.js'
+import { getChainContractAddress, toHex } from '../../utils/index.js'
+import { packetToBytes } from '../../utils/ens/index.js'
+import { readContract } from '../public/index.js'
+import type { ReadContractParameters } from '../public/index.js'
+
+export type GetEnsResolverParameters = Prettify<
+  Pick<ReadContractParameters, 'blockNumber' | 'blockTag'> & {
+    /** ENS name to get resolver. */
+    name: string
+    /** Address of ENS Universal Resolver Contract */
+    universalResolverAddress?: Address
+  }
+>
+
+export type GetEnsResolverReturnType = Address
+
+/**
+ * @description Gets resolver for ENS name.
+ */
+export async function getEnsResolver<TChain extends Chain | undefined>(
+  client: PublicClient<Transport, TChain>,
+  {
+    blockNumber,
+    blockTag,
+    name,
+    universalResolverAddress: universalResolverAddress_,
+  }: GetEnsResolverParameters,
+) {
+  let universalResolverAddress = universalResolverAddress_
+  if (!universalResolverAddress) {
+    if (!client.chain)
+      throw new Error(
+        'client chain not configured. universalResolverAddress is required.',
+      )
+
+    universalResolverAddress = getChainContractAddress({
+      blockNumber,
+      chain: client.chain,
+      contract: 'ensUniversalResolver',
+    })
+  }
+
+  const [resolverAddress] = await readContract(client, {
+    address: universalResolverAddress,
+    abi: [
+      {
+        inputs: [{ type: 'bytes' }],
+        name: 'findResolver',
+        outputs: [{ type: 'address' }, { type: 'bytes32' }],
+        stateMutability: 'view',
+        type: 'function',
+      },
+    ],
+    functionName: 'findResolver',
+    args: [toHex(packetToBytes(name))],
+    blockNumber,
+    blockTag,
+  })
+  return resolverAddress
+}

package/src/actions/ens/getEnsText.ts

@@ -0,0 +1,91 @@
+import type { PublicClient, Transport } from '../../clients/index.js'
+import { textResolverAbi, universalResolverAbi } from '../../constants/abis.js'
+import type { Address, Chain, Prettify } from '../../types/index.js'
+import {
+  decodeFunctionResult,
+  encodeFunctionData,
+  getChainContractAddress,
+  toHex,
+} from '../../utils/index.js'
+import { namehash, packetToBytes } from '../../utils/ens/index.js'
+import { readContract } from '../public/index.js'
+import type { ReadContractParameters } from '../public/index.js'
+
+export type GetEnsTextParameters = Prettify<
+  Pick<ReadContractParameters, 'blockNumber' | 'blockTag'> & {
+    /** ENS name to get ENS avatar for. */
+    name: string
+    /** Text record to retrieve */
+    key: string
+    /** Address of ENS Universal Resolver Contract. */
+    universalResolverAddress?: Address
+  }
+>
+
+export type GetEnsTextReturnType = string | null
+
+/**
+ * @description Gets text record for ENS name.
+ *
+ * - Calls `resolve(bytes, bytes)` on ENS Universal Resolver Contract.
+ * - Since ENS names prohibit certain forbidden characters (e.g. underscore) and have other validation rules, you likely want to [normalize ENS names](https://docs.ens.domains/contract-api-reference/name-processing#normalising-names) with [UTS-46 normalization](https://unicode.org/reports/tr46) before passing them to `getEnsAddress`. You can use the built-in [`normalize`](https://viem.sh/docs/ens/utilities/normalize.html) function for this.
+ *
+ * @example
+ * import { normalize } from 'viem/ens'
+ *
+ * const twitterRecord = await getEnsText(publicClient, {
+ *   name: normalize('wagmi-dev.eth'),
+ *   key: 'com.twitter',
+ * })
+ * // 'wagmi_sh'
+ */
+export async function getEnsText<TChain extends Chain | undefined>(
+  client: PublicClient<Transport, TChain>,
+  {
+    blockNumber,
+    blockTag,
+    name,
+    key,
+    universalResolverAddress: universalResolverAddress_,
+  }: GetEnsTextParameters,
+): Promise<GetEnsTextReturnType> {
+  let universalResolverAddress = universalResolverAddress_
+  if (!universalResolverAddress) {
+    if (!client.chain)
+      throw new Error(
+        'client chain not configured. universalResolverAddress is required.',
+      )
+
+    universalResolverAddress = getChainContractAddress({
+      blockNumber,
+      chain: client.chain,
+      contract: 'ensUniversalResolver',
+    })
+  }
+
+  const res = await readContract(client, {
+    address: universalResolverAddress,
+    abi: universalResolverAbi,
+    functionName: 'resolve',
+    args: [
+      toHex(packetToBytes(name)),
+      encodeFunctionData({
+        abi: textResolverAbi,
+        functionName: 'text',
+        args: [namehash(name), key],
+      }),
+    ],
+    blockNumber,
+    blockTag,
+  })
+
+  if (res[0] === '0x') return null
+
+  const record = decodeFunctionResult({
+    abi: textResolverAbi,
+    functionName: 'text',
+    data: res[0],
+  })
+
+  return record === '' ? null : record
+}