viem 0.2.11 → 0.2.13

package/src/actions/wallet/requestAddresses.ts

@@ -0,0 +1,17 @@
+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'
+
+export type RequestAddressesReturnType = Address[]
+
+export async function requestAddresses<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined = undefined,
+>(
+  client: WalletClient<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

@@ -0,0 +1,23 @@
+import type { Transport, WalletClient } from '../../clients/index.js'
+import type { Account, Chain } from '../../types/index.js'
+import type { WalletPermission } from '../../types/eip1193.js'
+
+export type RequestPermissionsParameters = {
+  eth_accounts: Record<string, any>
+} & {
+  [key: string]: Record<string, any>
+}
+export type RequestPermissionsReturnType = WalletPermission[]
+
+export async function requestPermissions<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined = undefined,
+>(
+  client: WalletClient<Transport, TChain, TAccount>,
+  permissions: RequestPermissionsParameters,
+) {
+  return client.request({
+    method: 'wallet_requestPermissions',
+    params: [permissions],
+  })
+}

package/src/actions/wallet/sendTransaction.ts

@@ -0,0 +1,147 @@
+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,
+  GetAccountParameter,
+  Chain,
+  Formatter,
+  GetChain,
+  Hash,
+  MergeIntersectionProperties,
+  TransactionRequest,
+  TransactionSerializable,
+} from '../../types/index.js'
+import {
+  assertRequest,
+  extract,
+  format,
+  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
+>
+
+export type SendTransactionParameters<
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends Account | undefined = Account | undefined,
+  TChainOverride extends Chain | undefined = Chain,
+> = FormattedTransactionRequest<TransactionRequestFormatter<TChainOverride>> &
+  GetAccountParameter<TAccount> &
+  GetChain<TChain, TChainOverride>
+
+export type SendTransactionReturnType = Hash
+
+export async function sendTransaction<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+  TChainOverride extends Chain | undefined,
+>(
+  client: WalletClient<Transport, TChain, TAccount>,
+  args: SendTransactionParameters<TChain, TAccount, TChainOverride>,
+): Promise<SendTransactionReturnType> {
+  const {
+    account: account_ = client.account,
+    chain = client.chain,
+    accessList,
+    data,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    to,
+    value,
+    ...rest
+  } = args
+
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: '/docs/actions/wallet/sendTransaction',
+    })
+  const account = parseAccount(account_)
+
+  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 })
+    }
+
+    if (account.type === 'local') {
+      // Prepare the request for signing (assign appropriate fees, etc.)
+      const request = await prepareRequest(client, {
+        account,
+        accessList,
+        chain,
+        data,
+        gas,
+        gasPrice,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce,
+        to,
+        value,
+        ...rest,
+      })
+
+      const signedRequest = (await account.signTransaction({
+        chainId,
+        ...request,
+      } as TransactionSerializable)) 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,
+      },
+    )
+    return await client.request({
+      method: 'eth_sendTransaction',
+      params: [request],
+    })
+  } catch (err) {
+    throw getTransactionError(err as BaseError, {
+      ...args,
+      account,
+      chain: args.chain || undefined,
+    })
+  }
+}

package/src/actions/wallet/signMessage.ts

@@ -0,0 +1,39 @@
+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'
+
+export type SignMessageParameters<
+  TAccount extends Account | undefined = Account | undefined,
+> = GetAccountParameter<TAccount> & {
+  message: string
+}
+
+export type SignMessageReturnType = Hex
+
+export async function signMessage<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+>(
+  client: WalletClient<Transport, TChain, TAccount>,
+  {
+    account: account_ = client.account,
+    message,
+  }: SignMessageParameters<TAccount>,
+): Promise<SignMessageReturnType> {
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: '/docs/actions/wallet/signMessage',
+    })
+  const account = parseAccount(account_)
+  if (account.type === 'local') return account.signMessage({ message })
+  return client.request({
+    method: 'personal_sign',
+    params: [toHex(message), account.address],
+  })
+}

package/src/actions/wallet/signTypedData.ts

@@ -0,0 +1,87 @@
+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'
+
+export type SignTypedDataParameters<
+  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
+  TPrimaryType extends string = string,
+  TAccount extends Account | undefined = undefined,
+> = GetAccountParameter<TAccount> &
+  TypedDataDefinition<TTypedData, TPrimaryType>
+
+export type SignTypedDataReturnType = Hex
+
+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>,
+  {
+    account: account_ = client.account,
+    domain,
+    message,
+    primaryType,
+    types: types_,
+  }: SignTypedDataParameters<TTypedData, TPrimaryType, TAccount>,
+): Promise<SignTypedDataReturnType> {
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: '/docs/actions/wallet/signTypedData',
+    })
+  const account = parseAccount(account_)
+
+  const types = {
+    EIP712Domain: [
+      domain?.name && { name: 'name', type: 'string' },
+      domain?.version && { name: 'version', type: 'string' },
+      domain?.chainId && { name: 'chainId', type: 'uint256' },
+      domain?.verifyingContract && {
+        name: 'verifyingContract',
+        type: 'address',
+      },
+      domain?.salt && { name: 'salt', type: 'bytes32' },
+    ].filter(Boolean),
+    ...(types_ as TTypedData),
+  }
+
+  // Need to do a runtime validation check on addresses, byte ranges, integer ranges, etc
+  // as we can't statically check this with TypeScript.
+  validateTypedData({
+    domain,
+    message,
+    primaryType,
+    types,
+  } as TypedDataDefinition)
+
+  if (account.type === 'local')
+    return account.signTypedData({
+      domain,
+      primaryType,
+      types,
+      message,
+    } as TypedDataDefinition)
+
+  const typedData = stringify(
+    { domain: domain ?? {}, primaryType, types, message },
+    (_, value) => (isHex(value) ? value.toLowerCase() : value),
+  )
+  return client.request({
+    method: 'eth_signTypedData_v4',
+    params: [account.address, typedData],
+  })
+}

package/src/actions/wallet/switchChain.ts

@@ -0,0 +1,22 @@
+import type { Transport, WalletClient } from '../../clients/index.js'
+import type { Account, Chain } from '../../types/index.js'
+import { numberToHex } from '../../utils/index.js'
+
+export type SwitchChainParameters = { id: Chain['id'] }
+
+export async function switchChain<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined = undefined,
+>(
+  client: WalletClient<Transport, TChain, TAccount>,
+  { id }: SwitchChainParameters,
+) {
+  await client.request({
+    method: 'wallet_switchEthereumChain',
+    params: [
+      {
+        chainId: numberToHex(id),
+      },
+    ],
+  })
+}

package/src/actions/wallet/watchAsset.ts

@@ -0,0 +1,20 @@
+import type { Transport, WalletClient } from '../../clients/index.js'
+import type { Account, Chain } from '../../types/index.js'
+import type { WatchAssetParams } from '../../types/eip1193.js'
+
+export type WatchAssetParameters = WatchAssetParams
+export type WatchAssetReturnType = boolean
+
+export async function watchAsset<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined = undefined,
+>(
+  client: WalletClient<Transport, TChain, TAccount>,
+  params: WatchAssetParameters,
+): Promise<WatchAssetReturnType> {
+  const added = await client.request({
+    method: 'wallet_watchAsset',
+    params: [params],
+  })
+  return added
+}

package/src/actions/wallet/writeContract.ts

@@ -0,0 +1,68 @@
+import type { Abi } from 'abitype'
+
+import type { Transport, WalletClient } from '../../clients/index.js'
+import type {
+  Account,
+  Chain,
+  ContractFunctionConfig,
+  GetChain,
+  GetValue,
+} from '../../types/index.js'
+import { encodeFunctionData } from '../../utils/index.js'
+import type { EncodeFunctionDataParameters } from '../../utils/index.js'
+import { sendTransaction } from './sendTransaction.js'
+import type {
+  SendTransactionParameters,
+  SendTransactionReturnType,
+} from './sendTransaction.js'
+
+export type WriteContractParameters<
+  TAbi extends Abi | readonly unknown[] = Abi,
+  TFunctionName extends string = string,
+  TChain extends Chain | undefined = Chain,
+  TAccount extends Account | undefined = undefined,
+  TChainOverride extends Chain | undefined = undefined,
+> = ContractFunctionConfig<TAbi, TFunctionName, 'payable' | 'nonpayable'> &
+  Omit<
+    SendTransactionParameters<TChain, TAccount, TChainOverride>,
+    'chain' | 'to' | 'data' | 'value'
+  > &
+  GetChain<TChain, TChainOverride> &
+  GetValue<TAbi, TFunctionName, SendTransactionParameters<TChain>['value']>
+
+export type WriteContractReturnType = SendTransactionReturnType
+
+export async function writeContract<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+  TAbi extends Abi | readonly unknown[],
+  TFunctionName extends string,
+  TChainOverride extends Chain | undefined = undefined,
+>(
+  client: WalletClient<Transport, TChain, TAccount>,
+  {
+    abi,
+    address,
+    args,
+    functionName,
+    ...request
+  }: WriteContractParameters<
+    TAbi,
+    TFunctionName,
+    TChain,
+    TAccount,
+    TChainOverride
+  >,
+): Promise<WriteContractReturnType> {
+  const data = encodeFunctionData({
+    abi,
+    args,
+    functionName,
+  } as unknown as EncodeFunctionDataParameters<TAbi, TFunctionName>)
+  const hash = await sendTransaction(client, {
+    data,
+    to: address,
+    ...request,
+  } as unknown as SendTransactionParameters<TChain, TAccount, TChainOverride>)
+  return hash
+}

package/src/adapters/ethers.ts

@@ -0,0 +1,92 @@
+import { toAccount } from '../accounts/toAccount.js'
+import type { Address, Hash } from '../types/index.js'
+import { toBytes } from '../utils/index.js'
+
+type BigNumberish = string | number | bigint
+type BytesLike = string | Uint8Array
+
+type TypedDataDomain = {
+  name?: string
+  version?: string
+  chainId?: BigNumberish
+  verifyingContract?: string
+  salt?: BytesLike
+}
+type TypedDataField = {
+  name: string
+  type: string
+}
+
+type EthersWallet = {
+  address: string
+  signMessage(message: Uint8Array): Promise<string>
+  signTransaction(txn: any): Promise<string>
+} & (
+  | {
+      signTypedData(
+        domain: TypedDataDomain,
+        types: Record<string, TypedDataField[]>,
+        value: Record<string, any>,
+      ): Promise<string>
+      _signTypedData?: never
+    }
+  | {
+      signTypedData?: never
+      _signTypedData(
+        domain: TypedDataDomain,
+        types: Record<string, TypedDataField[]>,
+        value: Record<string, any>,
+      ): Promise<string>
+    }
+)
+
+export const ethersWalletToAccount = (wallet: EthersWallet) =>
+  toAccount({
+    address: wallet.address as Address,
+    async signMessage({ message }) {
+      return (await wallet.signMessage(toBytes(message))) as Hash
+    },
+    async signTransaction(txn) {
+      // ethers type mappings
+      // https://github.com/ethers-io/ethers.js/blob/0802b70a724321f56d4c170e4c8a46b7804dfb48/src.ts/transaction/transaction.ts#L394
+      let type = null
+      if (txn.type === 'legacy') {
+        type = 0
+      } else if (txn.type === 'eip1559') {
+        type = 2
+      } else if (txn.type === 'eip2930') {
+        type = 1
+      }
+      return (await wallet.signTransaction({
+        // allowed fields for `ethers.TransactionRequest`
+        chainId: txn.chainId,
+        data: txn.data,
+        gasLimit: txn.gas,
+        gasPrice: txn.gasPrice,
+        nonce: txn.nonce,
+        to: txn.to,
+        type,
+        value: txn.value,
+        // untyped transactions do not support accessList
+        ...(txn.type && txn.accessList ? { accessList: txn.accessList } : {}),
+        // eip1559 properties
+        ...(txn.type === 'eip1559' && txn.maxPriorityFeePerGas
+          ? { maxPriorityFeePerGas: txn.maxPriorityFeePerGas }
+          : {}),
+        ...(txn.type === 'eip1559' && txn.maxFeePerGas
+          ? { maxFeePerGas: txn.maxFeePerGas }
+          : {}),
+      })) as Hash
+    },
+    async signTypedData({ domain, types: types_, message }) {
+      const { EIP712Domain: _, ...types } = types_ as any
+      const signTypedData = wallet.signTypedData
+        ? wallet.signTypedData.bind(wallet)
+        : wallet._signTypedData.bind(wallet)
+      return (await signTypedData(
+        domain ?? {},
+        types as Record<string, TypedDataField[]>,
+        message,
+      )) as Hash
+    },
+  })

package/src/chains.ts

@@ -0,0 +1,142 @@
+import * as chains from '@wagmi/chains'
+
+import type { Address, Hex, Quantity } from './types/index.js'
+import {
+  defineBlock,
+  defineChain,
+  defineTransaction,
+  defineTransactionReceipt,
+  defineTransactionRequest,
+} from './utils/index.js'
+
+export type { Chain } from './types/index.js'
+export { defineChain } from './utils/index.js'
+
+const celoFormatters = {
+  block: defineBlock({
+    exclude: ['difficulty', 'gasLimit', 'mixHash', 'nonce', 'uncles'],
+    format: (block) => ({
+      randomness: block.randomness as {
+        committed: Hex
+        revealed: Hex
+      },
+    }),
+  }),
+  transaction: defineTransaction({
+    format: (transaction) => ({
+      feeCurrency: transaction.feeCurrency as Address | null,
+      gatewayFee: transaction.gatewayFee
+        ? BigInt(transaction.gatewayFee as Quantity)
+        : null,
+      gatewayFeeRecipient: transaction.gatewayFeeRecipient as Address | null,
+    }),
+  }),
+  transactionReceipt: defineTransactionReceipt({
+    format: (transaction) => ({
+      feeCurrency: transaction.feeCurrency as Address | null,
+      gatewayFee: transaction.gatewayFee
+        ? BigInt(transaction.gatewayFee as Quantity)
+        : null,
+      gatewayFeeRecipient: transaction.gatewayFeeRecipient as Address | null,
+    }),
+  }),
+  transactionRequest: defineTransactionRequest({
+    format: (transactionRequest) => ({
+      feeCurrency: transactionRequest.feeCurrency as Address | undefined,
+      gatewayFee: transactionRequest.gatewayFee as Quantity | undefined,
+      gatewayFeeRecipient: transactionRequest.gatewayFeeRecipient as
+        | Address
+        | undefined,
+    }),
+  }),
+}
+
+export const arbitrum = defineChain(chains.arbitrum)
+export const arbitrumGoerli = defineChain(chains.arbitrumGoerli)
+export const aurora = defineChain(chains.aurora)
+export const auroraTestnet = defineChain(chains.auroraTestnet)
+export const avalanche = defineChain(chains.avalanche)
+export const avalancheFuji = defineChain(chains.avalancheFuji)
+export const baseGoerli = defineChain(chains.baseGoerli)
+export const boba = defineChain(chains.boba)
+export const bronos = defineChain(chains.bronos)
+export const bronosTestnet = defineChain(chains.bronosTestnet)
+export const bsc = defineChain(chains.bsc)
+export const bscTestnet = defineChain(chains.bscTestnet)
+export const canto = defineChain(chains.canto)
+export const celo = defineChain({
+  ...chains.celo,
+  formatters: celoFormatters,
+})
+export const celoAlfajores = defineChain({
+  ...chains.celoAlfajores,
+  formatters: celoFormatters,
+})
+export const cronos = defineChain(chains.cronos)
+export const crossbell = defineChain(chains.crossbell)
+export const dfk = defineChain(chains.dfk)
+export const dogechain = defineChain(chains.dogechain)
+export const evmos = defineChain(chains.evmos)
+export const evmosTestnet = defineChain(chains.evmosTestnet)
+export const fantom = defineChain(chains.fantom)
+export const fantomTestnet = defineChain(chains.fantomTestnet)
+export const filecoin = defineChain(chains.filecoin)
+export const filecoinCalibration = defineChain(chains.filecoinCalibration)
+export const filecoinHyperspace = defineChain(chains.filecoinHyperspace)
+export const flare = defineChain(chains.flare)
+export const flareTestnet = defineChain(chains.flareTestnet)
+export const foundry = defineChain(chains.foundry)
+export const iotex = defineChain(chains.iotex)
+export const iotexTestnet = defineChain(chains.iotexTestnet)
+export const goerli = defineChain(chains.goerli)
+export const gnosis = defineChain(chains.gnosis)
+export const gnosisChiado = defineChain(chains.gnosisChiado)
+export const hardhat = defineChain(chains.hardhat)
+export const harmonyOne = defineChain(chains.harmonyOne)
+export const klaytn = defineChain(chains.klaytn)
+export const localhost = defineChain(chains.localhost)
+export const mainnet = defineChain(chains.mainnet)
+export const metis = defineChain(chains.metis)
+export const metisGoerli = defineChain(chains.metisGoerli)
+export const moonbaseAlpha = defineChain(chains.moonbaseAlpha)
+export const moonbeam = defineChain(chains.moonbeam)
+export const moonriver = defineChain(chains.moonriver)
+export const nexi = defineChain(chains.nexi)
+export const okc = defineChain(chains.okc)
+export const optimism = defineChain(chains.optimism)
+export const optimismGoerli = defineChain(chains.optimismGoerli)
+export const polygon = defineChain(chains.polygon)
+export const polygonMumbai = defineChain(chains.polygonMumbai)
+export const polygonZkEvm = defineChain(chains.polygonZkEvm)
+export const polygonZkEvmTestnet = defineChain(chains.polygonZkEvmTestnet)
+export const scrollTestnet = defineChain(chains.scrollTestnet)
+export const sepolia = defineChain(chains.sepolia)
+export const skaleBlockBrawlers = defineChain(chains.skaleBlockBrawlers)
+export const skaleCalypso = defineChain(chains.skaleCalypso)
+export const skaleCalypsoTestnet = defineChain(chains.skaleCalypsoTestnet)
+export const skaleChaosTestnet = defineChain(chains.skaleChaosTestnet)
+export const skaleCryptoBlades = defineChain(chains.skaleCryptoBlades)
+export const skaleCryptoColosseum = defineChain(chains.skaleCryptoColosseum)
+export const skaleEuropa = defineChain(chains.skaleEuropa)
+export const skaleEuropaTestnet = defineChain(chains.skaleEuropaTestnet)
+export const skaleExorde = defineChain(chains.skaleExorde)
+export const skaleHumanProtocol = defineChain(chains.skaleHumanProtocol)
+export const skaleNebula = defineChain(chains.skaleNebula)
+export const skaleNebulaTestnet = defineChain(chains.skaleNebulaTestnet)
+export const skaleRazor = defineChain(chains.skaleRazor)
+export const skaleTitan = defineChain(chains.skaleTitan)
+export const skaleTitanTestnet = defineChain(chains.skaleTitanTestnet)
+export const songbird = defineChain(chains.songbird)
+export const songbirdTestnet = defineChain(chains.songbirdTestnet)
+export const shardeumSphinx = defineChain(chains.shardeumSphinx)
+export const taraxa = defineChain(chains.taraxa)
+export const taraxaTestnet = defineChain(chains.taraxaTestnet)
+export const telos = defineChain(chains.telos)
+export const telosTestnet = defineChain(chains.telosTestnet)
+export const wanchain = defineChain(chains.wanchain)
+export const wanchainTestnet = defineChain(chains.wanchainTestnet)
+export const xdc = defineChain(chains.xdc)
+export const xdcTestnet = defineChain(chains.xdcTestnet)
+export const zhejiang = defineChain(chains.zhejiang)
+export const zkSync = defineChain(chains.zkSync)
+export const zkSyncTestnet = defineChain(chains.zkSyncTestnet)