viem 2.0.0-beta.6 → 2.0.0-beta.9

package/actions/wallet/prepareTransactionRequest.ts

@@ -1,3 +1,4 @@
+import type { Address } from 'abitype'
 import type { Account } from '../../accounts/types.js'
 import {
   type ParseAccountErrorType,
@@ -22,19 +23,17 @@ import {
 } from '../../actions/public/getTransactionCount.js'
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
-import {
-  AccountNotFoundError,
-  type AccountNotFoundErrorType,
-} from '../../errors/account.js'
+import { type AccountNotFoundErrorType } from '../../errors/account.js'
 import {
   Eip1559FeesNotSupportedError,
   MaxFeePerGasTooLowError,
 } from '../../errors/fee.js'
-import type { GetAccountParameter } from '../../types/account.js'
-import type { Chain } from '../../types/chain.js'
-import type { GetChain } from '../../types/chain.js'
+import type { Block } from '../../index.js'
+import type { DeriveAccount, GetAccountParameter } from '../../types/account.js'
+import type { Chain, DeriveChain } from '../../types/chain.js'
+import type { GetChainParameter } from '../../types/chain.js'
 import type { TransactionSerializable } from '../../types/transaction.js'
-import type { UnionOmit } from '../../types/utils.js'
+import type { UnionOmit, UnionRequiredBy } from '../../types/utils.js'
 import type { FormattedTransactionRequest } from '../../utils/formatters/transactionRequest.js'
 import { getAction } from '../../utils/getAction.js'
 import type {
@@ -44,28 +43,52 @@ import type {
 import { assertRequest } from '../../utils/transaction/assertRequest.js'
 import { getTransactionType } from '../../utils/transaction/getTransactionType.js'
 
+export type ParameterType = 'fees' | 'gas' | 'nonce' | 'type'
+type ParameterTypeToParameters<TParameterType extends ParameterType> =
+  TParameterType extends 'fees'
+    ? 'maxFeePerGas' | 'maxPriorityFeePerGas' | 'gasPrice'
+    : TParameterType
+
 export type PrepareTransactionRequestParameters<
   TChain extends Chain | undefined = Chain | undefined,
   TAccount extends Account | undefined = Account | undefined,
   TChainOverride extends Chain | undefined = Chain | undefined,
-> = UnionOmit<
-  FormattedTransactionRequest<
-    TChainOverride extends Chain ? TChainOverride : TChain
-  >,
-  'from'
-> &
-  GetAccountParameter<TAccount> &
-  GetChain<TChain, TChainOverride>
+  TAccountOverride extends Account | Address | undefined =
+    | Account
+    | Address
+    | undefined,
+  TParameterType extends ParameterType = ParameterType,
+  ///
+  derivedChain extends Chain | undefined = DeriveChain<TChain, TChainOverride>,
+> = UnionOmit<FormattedTransactionRequest<derivedChain>, 'from'> &
+  GetAccountParameter<TAccount, TAccountOverride, false> &
+  GetChainParameter<TChain, TChainOverride> & {
+    parameters?: TParameterType[]
+  }
 
 export type PrepareTransactionRequestReturnType<
   TChain extends Chain | undefined = Chain | undefined,
   TAccount extends Account | undefined = Account | undefined,
   TChainOverride extends Chain | undefined = Chain | undefined,
-> = FormattedTransactionRequest<
-  TChainOverride extends Chain ? TChainOverride : TChain
+  TAccountOverride extends Account | Address | undefined =
+    | Account
+    | Address
+    | undefined,
+  TParameterType extends ParameterType = ParameterType,
+  ///
+  derivedAccount extends Account | undefined = DeriveAccount<
+    TAccount,
+    TAccountOverride
+  >,
+  derivedChain extends Chain | undefined = DeriveChain<TChain, TChainOverride>,
+> = UnionRequiredBy<
+  UnionOmit<FormattedTransactionRequest<derivedChain>, 'from'>,
+  ParameterTypeToParameters<TParameterType>
 > &
-  GetAccountParameter<TAccount> &
-  GetChain<TChain, TChainOverride>
+  GetChainParameter<TChain, TChainOverride> &
+  (derivedAccount extends Account
+    ? { account: derivedAccount; from: Address }
+    : { account?: undefined; from?: undefined })
 
 export type PrepareTransactionRequestErrorType =
   | AccountNotFoundErrorType
@@ -119,31 +142,59 @@ export type PrepareTransactionRequestErrorType =
 export async function prepareTransactionRequest<
   TChain extends Chain | undefined,
   TAccount extends Account | undefined,
+  TParameterType extends ParameterType,
+  TAccountOverride extends Account | Address | undefined = undefined,
   TChainOverride extends Chain | undefined = undefined,
 >(
   client: Client<Transport, TChain, TAccount>,
-  args: PrepareTransactionRequestParameters<TChain, TAccount, TChainOverride>,
+  args: PrepareTransactionRequestParameters<
+    TChain,
+    TAccount,
+    TChainOverride,
+    TAccountOverride,
+    TParameterType
+  >,
 ): Promise<
-  PrepareTransactionRequestReturnType<TChain, TAccount, TChainOverride>
+  PrepareTransactionRequestReturnType<
+    TChain,
+    TAccount,
+    TChainOverride,
+    TAccountOverride,
+    TParameterType
+  >
 > {
-  const { account: account_ = client.account, chain, gas, nonce, type } = args
-  if (!account_) throw new AccountNotFoundError()
-  const account = parseAccount(account_)
+  const {
+    account: account_ = client.account,
+    chain,
+    gas,
+    nonce,
+    parameters = ['fees', 'gas', 'nonce', 'type'],
+    type,
+  } = args
+  const account = account_ ? parseAccount(account_) : undefined
 
-  const block = await getAction(client, getBlock)({ blockTag: 'latest' })
+  const block = await getAction(
+    client,
+    getBlock,
+    'getBlock',
+  )({ blockTag: 'latest' })
 
-  const request = { ...args, from: account.address }
+  const request = { ...args, ...(account ? { from: account?.address } : {}) }
 
-  if (typeof nonce === 'undefined')
+  if (parameters.includes('nonce') && typeof nonce === 'undefined' && account)
     request.nonce = await getAction(
       client,
       getTransactionCount,
+      'getTransactionCount',
     )({
       address: account.address,
       blockTag: 'pending',
     })
 
-  if (typeof type === 'undefined') {
+  if (
+    (parameters.includes('fees') || parameters.includes('type')) &&
+    typeof type === 'undefined'
+  ) {
     try {
       request.type = getTransactionType(
         request as TransactionSerializable,
@@ -155,57 +206,69 @@ export async function prepareTransactionRequest<
     }
   }
 
-  if (request.type === 'eip1559') {
-    // EIP-1559 fees
-    const { maxFeePerGas, maxPriorityFeePerGas } =
-      await internal_estimateFeesPerGas(client, {
-        block,
-        chain,
-        request: request as PrepareTransactionRequestParameters,
-      })
-
-    if (
-      typeof args.maxPriorityFeePerGas === 'undefined' &&
-      args.maxFeePerGas &&
-      args.maxFeePerGas < maxPriorityFeePerGas
-    )
-      throw new MaxFeePerGasTooLowError({
-        maxPriorityFeePerGas,
-      })
-
-    request.maxPriorityFeePerGas = maxPriorityFeePerGas
-    request.maxFeePerGas = maxFeePerGas
-  } else {
-    // Legacy fees
-    if (
-      typeof args.maxFeePerGas !== 'undefined' ||
-      typeof args.maxPriorityFeePerGas !== 'undefined'
-    )
-      throw new Eip1559FeesNotSupportedError()
-
-    const { gasPrice: gasPrice_ } = await internal_estimateFeesPerGas(client, {
-      block,
-      chain,
-      request: request as PrepareTransactionRequestParameters,
-      type: 'legacy',
-    })
-    request.gasPrice = gasPrice_
+  if (parameters.includes('fees')) {
+    if (request.type === 'eip1559') {
+      // EIP-1559 fees
+      const { maxFeePerGas, maxPriorityFeePerGas } =
+        await internal_estimateFeesPerGas(client, {
+          block: block as Block,
+          chain,
+          request: request as PrepareTransactionRequestParameters,
+        })
+
+      if (
+        typeof args.maxPriorityFeePerGas === 'undefined' &&
+        args.maxFeePerGas &&
+        args.maxFeePerGas < maxPriorityFeePerGas
+      )
+        throw new MaxFeePerGasTooLowError({
+          maxPriorityFeePerGas,
+        })
+
+      request.maxPriorityFeePerGas = maxPriorityFeePerGas
+      request.maxFeePerGas = maxFeePerGas
+    } else {
+      // Legacy fees
+      if (
+        typeof args.maxFeePerGas !== 'undefined' ||
+        typeof args.maxPriorityFeePerGas !== 'undefined'
+      )
+        throw new Eip1559FeesNotSupportedError()
+
+      const { gasPrice: gasPrice_ } = await internal_estimateFeesPerGas(
+        client,
+        {
+          block: block as Block,
+          chain,
+          request: request as PrepareTransactionRequestParameters,
+          type: 'legacy',
+        },
+      )
+      request.gasPrice = gasPrice_
+    }
   }
 
-  if (typeof gas === 'undefined')
+  if (parameters.includes('gas') && typeof gas === 'undefined')
     request.gas = await getAction(
       client,
       estimateGas,
+      'estimateGas',
     )({
       ...request,
-      account: { address: account.address, type: 'json-rpc' },
+      account: account
+        ? { address: account.address, type: 'json-rpc' }
+        : undefined,
     } as EstimateGasParameters)
 
   assertRequest(request as AssertRequestParameters)
 
+  delete request.parameters
+
   return request as unknown as PrepareTransactionRequestReturnType<
     TChain,
     TAccount,
-    TChainOverride
+    TChainOverride,
+    TAccountOverride,
+    TParameterType
   >
 }

package/actions/wallet/requestAddresses.ts

@@ -42,6 +42,9 @@ export async function requestAddresses<
 >(
   client: Client<Transport, TChain, TAccount>,
 ): Promise<RequestAddressesReturnType> {
-  const addresses = await client.request({ method: 'eth_requestAccounts' })
+  const addresses = await client.request(
+    { method: 'eth_requestAccounts' },
+    { retryCount: 0 },
+  )
   return addresses.map((address) => getAddress(address))
 }

package/actions/wallet/requestPermissions.ts

@@ -48,8 +48,11 @@ export async function requestPermissions<
   client: Client<Transport, TChain, TAccount>,
   permissions: RequestPermissionsParameters,
 ) {
-  return client.request({
-    method: 'wallet_requestPermissions',
-    params: [permissions],
-  })
+  return client.request(
+    {
+      method: 'wallet_requestPermissions',
+      params: [permissions],
+    },
+    { retryCount: 0 },
+  )
 }

package/actions/wallet/sendRawTransaction.ts

@@ -45,8 +45,11 @@ export async function sendRawTransaction<TChain extends Chain | undefined>(
   client: Client<Transport, TChain>,
   { serializedTransaction }: SendRawTransactionParameters,
 ): Promise<SendRawTransactionReturnType> {
-  return client.request({
-    method: 'eth_sendRawTransaction',
-    params: [serializedTransaction],
-  })
+  return client.request(
+    {
+      method: 'eth_sendRawTransaction',
+      params: [serializedTransaction],
+    },
+    { retryCount: 0 },
+  )
 }

package/actions/wallet/sendTransaction.ts

@@ -10,8 +10,8 @@ import { AccountNotFoundError } from '../../errors/account.js'
 import type { BaseError } from '../../errors/base.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type { GetAccountParameter } from '../../types/account.js'
-import type { Chain } from '../../types/chain.js'
-import type { GetChain } from '../../types/chain.js'
+import type { Chain, DeriveChain } from '../../types/chain.js'
+import type { GetChainParameter } from '../../types/chain.js'
 import type { Hash } from '../../types/misc.js'
 import type {
   TransactionRequest,
@@ -52,14 +52,11 @@ export type SendTransactionParameters<
   TChain extends Chain | undefined = Chain | undefined,
   TAccount extends Account | undefined = Account | undefined,
   TChainOverride extends Chain | undefined = Chain | undefined,
-> = UnionOmit<
-  FormattedTransactionRequest<
-    TChainOverride extends Chain ? TChainOverride : TChain
-  >,
-  'from'
-> &
+  ///
+  derivedChain extends Chain | undefined = DeriveChain<TChain, TChainOverride>,
+> = UnionOmit<FormattedTransactionRequest<derivedChain>, 'from'> &
   GetAccountParameter<TAccount> &
-  GetChain<TChain, TChainOverride>
+  GetChainParameter<TChain, TChainOverride>
 
 export type SendTransactionReturnType = Hash
 
@@ -80,7 +77,7 @@ export type SendTransactionErrorType =
  * 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
+ * - Examples: https://stackblitz.com/github/wevm/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)
@@ -155,7 +152,7 @@ export async function sendTransaction<
 
     let chainId
     if (chain !== null) {
-      chainId = await getAction(client, getChainId)({})
+      chainId = await getAction(client, getChainId, 'getChainId')({})
       assertCurrentChain({
         currentChainId: chainId,
         chain,
@@ -167,6 +164,7 @@ export async function sendTransaction<
       const request = await getAction(
         client,
         prepareTransactionRequest,
+        'prepareTransactionRequest',
       )({
         account,
         accessList,
@@ -182,7 +180,8 @@ export async function sendTransaction<
         ...rest,
       } as any)
 
-      if (!chainId) chainId = await getAction(client, getChainId)({})
+      if (!chainId)
+        chainId = await getAction(client, getChainId, 'getChainId')({})
 
       const serializer = chain?.serializers?.transaction
       const serializedTransaction = (await account.signTransaction(
@@ -195,6 +194,7 @@ export async function sendTransaction<
       return await getAction(
         client,
         sendRawTransaction,
+        'sendRawTransaction',
       )({
         serializedTransaction,
       })
@@ -217,10 +217,13 @@ export async function sendTransaction<
       to,
       value,
     } as TransactionRequest)
-    return await client.request({
-      method: 'eth_sendTransaction',
-      params: [request],
-    })
+    return await client.request(
+      {
+        method: 'eth_sendTransaction',
+        params: [request],
+      },
+      { retryCount: 0 },
+    )
   } catch (err) {
     throw getTransactionError(err as BaseError, {
       ...args,

package/actions/wallet/signMessage.ts

@@ -102,8 +102,11 @@ export async function signMessage<
     return message.raw
   })()
 
-  return client.request({
-    method: 'personal_sign',
-    params: [message_, account.address],
-  })
+  return client.request(
+    {
+      method: 'personal_sign',
+      params: [message_, account.address],
+    },
+    { retryCount: 0 },
+  )
 }

package/actions/wallet/signTransaction.ts

@@ -9,7 +9,11 @@ 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, GetChain } from '../../types/chain.js'
+import type {
+  Chain,
+  DeriveChain,
+  GetChainParameter,
+} from '../../types/chain.js'
 import { type RpcTransactionRequest } from '../../types/rpc.js'
 import type {
   TransactionRequest,
@@ -39,14 +43,11 @@ export type SignTransactionParameters<
   TChain extends Chain | undefined = Chain | undefined,
   TAccount extends Account | undefined = Account | undefined,
   TChainOverride extends Chain | undefined = Chain | undefined,
-> = UnionOmit<
-  FormattedTransactionRequest<
-    TChainOverride extends Chain ? TChainOverride : TChain
-  >,
-  'from'
-> &
+  ///
+  derivedChain extends Chain | undefined = DeriveChain<TChain, TChainOverride>,
+> = UnionOmit<FormattedTransactionRequest<derivedChain>, 'from'> &
   GetAccountParameter<TAccount> &
-  GetChain<TChain, TChainOverride>
+  GetChainParameter<TChain, TChainOverride>
 
 export type SignTransactionReturnType = TransactionSerialized
 
@@ -128,7 +129,7 @@ export async function signTransaction<
     ...args,
   })
 
-  const chainId = await getAction(client, getChainId)({})
+  const chainId = await getAction(client, getChainId, 'getChainId')({})
   if (chain !== null)
     assertCurrentChain({
       currentChainId: chainId,
@@ -148,14 +149,17 @@ export async function signTransaction<
       { serializer: client.chain?.serializers?.transaction },
     ) as Promise<SignTransactionReturnType>
 
-  return await client.request({
-    method: 'eth_signTransaction',
-    params: [
-      {
-        ...format(transaction as unknown as TransactionRequest),
-        chainId: numberToHex(chainId),
-        from: account.address,
-      } as unknown as RpcTransactionRequest,
-    ],
-  })
+  return await client.request(
+    {
+      method: 'eth_signTransaction',
+      params: [
+        {
+          ...format(transaction as unknown as TransactionRequest),
+          chainId: numberToHex(chainId),
+          from: account.address,
+        } as unknown as RpcTransactionRequest,
+      ],
+    },
+    { retryCount: 0 },
+  )
 }

package/actions/wallet/signTypedData.ts

@@ -185,8 +185,11 @@ export async function signTypedData<
     { domain: domain ?? {}, message, primaryType, types },
     (_, value) => (isHex(value) ? value.toLowerCase() : value),
   )
-  return client.request({
-    method: 'eth_signTypedData_v4',
-    params: [account.address, typedData],
-  })
+  return client.request(
+    {
+      method: 'eth_signTypedData_v4',
+      params: [account.address, typedData],
+    },
+    { retryCount: 0 },
+  )
 }

package/actions/wallet/switchChain.ts

@@ -43,12 +43,15 @@ export async function switchChain<
   TChain extends Chain | undefined,
   TAccount extends Account | undefined = undefined,
 >(client: Client<Transport, TChain, TAccount>, { id }: SwitchChainParameters) {
-  await client.request({
-    method: 'wallet_switchEthereumChain',
-    params: [
-      {
-        chainId: numberToHex(id),
-      },
-    ],
-  })
+  await client.request(
+    {
+      method: 'wallet_switchEthereumChain',
+      params: [
+        {
+          chainId: numberToHex(id),
+        },
+      ],
+    },
+    { retryCount: 0 },
+  )
 }

package/actions/wallet/watchAsset.ts

@@ -45,9 +45,12 @@ export async function watchAsset<
   client: Client<Transport, TChain, TAccount>,
   params: WatchAssetParameters,
 ): Promise<WatchAssetReturnType> {
-  const added = await client.request({
-    method: 'wallet_watchAsset',
-    params,
-  })
+  const added = await client.request(
+    {
+      method: 'wallet_watchAsset',
+      params,
+    },
+    { retryCount: 0 },
+  )
   return added
 }

package/actions/wallet/writeContract.ts

@@ -5,7 +5,11 @@ import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type { GetAccountParameter } from '../../types/account.js'
-import type { Chain, GetChain } from '../../types/chain.js'
+import type {
+  Chain,
+  DeriveChain,
+  GetChainParameter,
+} from '../../types/chain.js'
 import type {
   ContractFunctionArgs,
   ContractFunctionName,
@@ -16,6 +20,7 @@ import type { Hex } from '../../types/misc.js'
 import type { Prettify, UnionEvaluate, UnionOmit } from '../../types/utils.js'
 import {
   type EncodeFunctionDataErrorType,
+  type EncodeFunctionDataParameters,
   encodeFunctionData,
 } from '../../utils/abi/encodeFunctionData.js'
 import type { FormattedTransactionRequest } from '../../utils/formatters/transactionRequest.js'
@@ -42,6 +47,7 @@ export type WriteContractParameters<
   chainOverride extends Chain | undefined = Chain | undefined,
   ///
   allFunctionNames = ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
 > = ContractFunctionParameters<
   abi,
   'nonpayable' | 'payable',
@@ -49,15 +55,13 @@ export type WriteContractParameters<
   args,
   allFunctionNames
 > &
-  GetChain<chain, chainOverride> &
+  GetChainParameter<chain, chainOverride> &
   Prettify<
     GetAccountParameter<account> &
       GetValue<
         abi,
         functionName,
-        FormattedTransactionRequest<
-          chainOverride extends Chain ? chainOverride : chain
-        >['value']
+        FormattedTransactionRequest<derivedChain>['value']
       > & {
         /** Data to append to the end of the calldata. Useful for adding a ["domain" tag](https://opensea.notion.site/opensea/Seaport-Order-Attributions-ec2d69bf455041a5baa490941aad307f). */
         dataSuffix?: Hex
@@ -65,9 +69,7 @@ export type WriteContractParameters<
   > &
   UnionEvaluate<
     UnionOmit<
-      FormattedTransactionRequest<
-        chainOverride extends Chain ? chainOverride : chain
-      >,
+      FormattedTransactionRequest<derivedChain>,
       'data' | 'from' | 'to' | 'value'
     >
   >
@@ -83,7 +85,7 @@ export type WriteContractErrorType =
  * Executes a write function on a contract.
  *
  * - Docs: https://viem.sh/docs/contract/writeContract.html
- * - Examples: https://stackblitz.com/github/wagmi-dev/viem/tree/main/examples/contracts/writing-to-contracts
+ * - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts/writing-to-contracts
  *
  * A "write" function on a Solidity contract modifies the state of the blockchain. These types of functions require gas to be executed, and hence a [Transaction](https://viem.sh/docs/glossary/terms.html) is needed to be broadcast in order to change the state.
  *
@@ -149,9 +151,16 @@ export async function writeContract<
 ): Promise<WriteContractReturnType> {
   const { abi, address, args, dataSuffix, functionName, ...request } =
     parameters as WriteContractParameters
-  const data = encodeFunctionData({ abi, args, functionName })
-  const action = getAction(client, sendTransaction)
-  return action({
+  const data = encodeFunctionData({
+    abi,
+    args,
+    functionName,
+  } as EncodeFunctionDataParameters)
+  return getAction(
+    client,
+    sendTransaction,
+    'sendTransaction',
+  )({
     data: `${data}${dataSuffix ? dataSuffix.replace('0x', '') : ''}`,
     to: address,
     ...request,

package/chains/celo/parsers.ts

@@ -31,9 +31,9 @@ export type ParseTransactionReturnType<
   ? TransactionSerializableCIP42
   : ParseTransactionReturnType_<TSerialized, TType>
 
-export function parseTransaction<
-  TSerialized extends CeloTransactionSerialized,
->(serializedTransaction: TSerialized): ParseTransactionReturnType<TSerialized> {
+export function parseTransaction<TSerialized extends CeloTransactionSerialized>(
+  serializedTransaction: TSerialized,
+): ParseTransactionReturnType<TSerialized> {
   const serializedType = sliceHex(serializedTransaction, 0, 1)
 
   if (serializedType === '0x7c')