viem 0.0.0-main.20240101T200530 → 0.0.0-main.20240103T193934

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,59 @@ import type {
 import { assertRequest } from '../../utils/transaction/assertRequest.js'
 import { getTransactionType } from '../../utils/transaction/getTransactionType.js'
 
+export type PrepareTransactionRequestParameterType =
+  | 'fees'
+  | 'gas'
+  | 'nonce'
+  | 'type'
+type ParameterTypeToParameters<
+  TParameterType extends PrepareTransactionRequestParameterType,
+> = 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
+    PrepareTransactionRequestParameterType = PrepareTransactionRequestParameterType,
+  ///
+  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
+    PrepareTransactionRequestParameterType = PrepareTransactionRequestParameterType,
+  ///
+  derivedAccount extends Account | Address | 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,16 +149,36 @@ export type PrepareTransactionRequestErrorType =
 export async function prepareTransactionRequest<
   TChain extends Chain | undefined,
   TAccount extends Account | undefined,
+  TParameterType extends PrepareTransactionRequestParameterType,
+  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,
@@ -136,9 +186,9 @@ export async function prepareTransactionRequest<
     '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,
@@ -148,7 +198,10 @@ export async function prepareTransactionRequest<
       blockTag: 'pending',
     })
 
-  if (typeof type === 'undefined') {
+  if (
+    (parameters.includes('fees') || parameters.includes('type')) &&
+    typeof type === 'undefined'
+  ) {
     try {
       request.type = getTransactionType(
         request as TransactionSerializable,
@@ -160,58 +213,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
 
@@ -220,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
 
@@ -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

@@ -28,11 +28,13 @@ import {
 } from '../../utils/typedData.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>
+  typedData extends TypedData | Record<string, unknown> = TypedData,
+  primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData,
+  account extends Account | undefined = undefined,
+  ///
+  primaryTypes = typedData extends TypedData ? keyof typedData : string,
+> = TypedDataDefinition<typedData, primaryType, primaryTypes> &
+  GetAccountParameter<account>
 
 export type SignTypedDataReturnType = Hex
 
@@ -146,20 +148,21 @@ export type SignTypedDataErrorType =
  * })
  */
 export async function signTypedData<
-  const TTypedData extends TypedData | { [key: string]: unknown },
-  TPrimaryType extends string,
-  TChain extends Chain | undefined,
-  TAccount extends Account | undefined,
+  const typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | 'EIP712Domain',
+  chain extends Chain | undefined,
+  account extends Account | undefined,
 >(
-  client: Client<Transport, TChain, TAccount>,
-  {
+  client: Client<Transport, chain, account>,
+  parameters: SignTypedDataParameters<typedData, primaryType, account>,
+): Promise<SignTypedDataReturnType> {
+  const {
     account: account_ = client.account,
     domain,
     message,
     primaryType,
-    types: types_,
-  }: SignTypedDataParameters<TTypedData, TPrimaryType, TAccount>,
-): Promise<SignTypedDataReturnType> {
+  } = parameters as unknown as SignTypedDataParameters
+
   if (!account_)
     throw new AccountNotFoundError({
       docsPath: '/docs/actions/wallet/signTypedData',
@@ -168,32 +171,25 @@ export async function signTypedData<
 
   const types = {
     EIP712Domain: getTypesForEIP712Domain({ domain }),
-    ...(types_ as TTypedData),
+    ...parameters.types,
   }
 
   // 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)
+  validateTypedData({ domain, message, primaryType, types })
 
   if (account.type === 'local')
-    return account.signTypedData({
-      domain,
-      primaryType,
-      types,
-      message,
-    } as TypedDataDefinition)
+    return account.signTypedData({ domain, message, primaryType, types })
 
   const typedData = stringify(
-    { domain: domain ?? {}, primaryType, types, message },
+    { 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
 }