viem 1.6.7 → 1.8.0

package/src/actions/public/estimateFeesPerGas.ts

@@ -0,0 +1,154 @@
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import {
+  BaseFeeScalarError,
+  Eip1559FeesNotSupportedError,
+} from '../../errors/fee.js'
+import type { Block } from '../../types/block.js'
+import type {
+  Chain,
+  ChainEstimateFeesPerGasFnParameters,
+  ChainFeesFnParameters,
+} from '../../types/chain.js'
+import type { GetChain } from '../../types/chain.js'
+import type {
+  FeeValuesEIP1559,
+  FeeValuesLegacy,
+  FeeValuesType,
+} from '../../types/fee.js'
+import type { PrepareTransactionRequestParameters } from '../wallet/prepareTransactionRequest.js'
+import { internal_estimateMaxPriorityFeePerGas } from './estimateMaxPriorityFeePerGas.js'
+import { getBlock } from './getBlock.js'
+import { getGasPrice } from './getGasPrice.js'
+
+export type EstimateFeesPerGasParameters<
+  chain extends Chain | undefined = Chain | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+  type extends FeeValuesType = FeeValuesType,
+> = {
+  /**
+   * The type of fee values to return.
+   *
+   * - `legacy`: Returns the legacy gas price.
+   * - `eip1559`: Returns the max fee per gas and max priority fee per gas.
+   *
+   * @default 'eip1559'
+   */
+  type?: type | FeeValuesType
+} & GetChain<chain, chainOverride>
+
+export type EstimateFeesPerGasReturnType<
+  type extends FeeValuesType = FeeValuesType,
+> =
+  | (type extends 'legacy' ? FeeValuesLegacy : never)
+  | (type extends 'eip1559' ? FeeValuesEIP1559 : never)
+
+/**
+ * Returns an estimate for the fees per gas (in wei) for a
+ * transaction to be likely included in the next block.
+ * Defaults to [`chain.fees.estimateFeesPerGas`](/docs/clients/chains.html#fees-estimatefeespergas) if set.
+ *
+ * - Docs: https://viem.sh/docs/actions/public/estimateFeesPerGas.html
+ *
+ * @param client - Client to use
+ * @param parameters - {@link EstimateFeesPerGasParameters}
+ * @returns An estimate (in wei) for the fees per gas. {@link EstimateFeesPerGasReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { estimateFeesPerGas } from 'viem/actions'
+ *
+ * const client = createPublicClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const maxPriorityFeePerGas = await estimateFeesPerGas(client)
+ * // { maxFeePerGas: ..., maxPriorityFeePerGas: ... }
+ */
+export async function estimateFeesPerGas<
+  chain extends Chain | undefined,
+  chainOverride extends Chain | undefined,
+  type extends FeeValuesType = 'eip1559',
+>(
+  client: Client<Transport, chain>,
+  args?: EstimateFeesPerGasParameters<chain, chainOverride, type>,
+): Promise<EstimateFeesPerGasReturnType<type>> {
+  return internal_estimateFeesPerGas(client, args as any)
+}
+
+export async function internal_estimateFeesPerGas<
+  chain extends Chain | undefined,
+  chainOverride extends Chain | undefined,
+  type extends FeeValuesType = 'eip1559',
+>(
+  client: Client<Transport, chain>,
+  args: EstimateFeesPerGasParameters<chain, chainOverride, type> & {
+    block?: Block
+    request?: PrepareTransactionRequestParameters
+  },
+): Promise<EstimateFeesPerGasReturnType<type>> {
+  const {
+    block: block_,
+    chain = client.chain,
+    request,
+    type = 'eip1559',
+  } = args || {}
+
+  const baseFeeMultiplier = await (async () => {
+    if (typeof chain?.fees?.baseFeeMultiplier === 'function')
+      return chain.fees.baseFeeMultiplier({
+        block: block_ as Block,
+        client,
+        request,
+      } as ChainFeesFnParameters)
+    return chain?.fees?.baseFeeMultiplier ?? 1.2
+  })()
+  if (baseFeeMultiplier < 1) throw new BaseFeeScalarError()
+
+  const decimals = baseFeeMultiplier.toString().split('.')[1].length
+  const denominator = 10 ** decimals
+  const multiply = (base: bigint) =>
+    (base * BigInt(baseFeeMultiplier * denominator)) / BigInt(denominator)
+
+  const block = block_ ? block_ : await getBlock(client)
+
+  if (typeof chain?.fees?.estimateFeesPerGas === 'function')
+    return chain.fees.estimateFeesPerGas({
+      block: block_ as Block,
+      client,
+      multiply,
+      request,
+      type,
+    } as ChainEstimateFeesPerGasFnParameters) as unknown as EstimateFeesPerGasReturnType<type>
+
+  if (type === 'eip1559') {
+    if (typeof block.baseFeePerGas !== 'bigint')
+      throw new Eip1559FeesNotSupportedError()
+
+    const maxPriorityFeePerGas = request?.maxPriorityFeePerGas
+      ? request.maxPriorityFeePerGas
+      : await internal_estimateMaxPriorityFeePerGas(
+          client as Client<Transport, Chain>,
+          {
+            block,
+            chain,
+            request,
+          },
+        )
+
+    const baseFeePerGas = multiply(block.baseFeePerGas)
+    const maxFeePerGas =
+      request?.maxFeePerGas ?? baseFeePerGas + maxPriorityFeePerGas
+
+    return {
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+    } as EstimateFeesPerGasReturnType<type>
+  }
+
+  const gasPrice = request?.gasPrice ?? multiply(await getGasPrice(client))
+  return {
+    gasPrice,
+  } as EstimateFeesPerGasReturnType<type>
+}

package/src/actions/public/estimateGas.ts

@@ -21,9 +21,9 @@ import {
   assertRequest,
 } from '../../utils/transaction/assertRequest.js'
 import {
-  type PrepareRequestParameters,
-  prepareRequest,
-} from '../../utils/transaction/prepareRequest.js'
+  type PrepareTransactionRequestParameters,
+  prepareTransactionRequest,
+} from '../wallet/prepareTransactionRequest.js'
 
 export type FormattedEstimateGas<
   TChain extends Chain | undefined = Chain | undefined,
@@ -107,9 +107,9 @@ export async function estimateGas<
       ...rest
     } =
       account.type === 'local'
-        ? ((await prepareRequest(
+        ? ((await prepareTransactionRequest(
             client,
-            args as PrepareRequestParameters,
+            args as PrepareTransactionRequestParameters,
           )) as EstimateGasParameters)
         : args
 

package/src/actions/public/estimateMaxPriorityFeePerGas.ts

@@ -0,0 +1,98 @@
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import { Eip1559FeesNotSupportedError } from '../../errors/fee.js'
+import type { Account } from '../../types/account.js'
+import type { Block } from '../../types/block.js'
+import type { Chain, ChainFeesFnParameters } from '../../types/chain.js'
+import type { GetChain } from '../../types/chain.js'
+import { hexToBigInt } from '../../utils/encoding/fromHex.js'
+import type { PrepareTransactionRequestParameters } from '../wallet/prepareTransactionRequest.js'
+import { getBlock } from './getBlock.js'
+import { getGasPrice } from './getGasPrice.js'
+
+export type EstimateMaxPriorityFeePerGasParameters<
+  chain extends Chain | undefined = Chain | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+> = GetChain<chain, chainOverride>
+export type EstimateMaxPriorityFeePerGasReturnType = bigint
+
+/**
+ * Returns an estimate for the max priority fee per gas (in wei) for a
+ * transaction to be likely included in the next block.
+ * Defaults to [`chain.fees.defaultPriorityFee`](/docs/clients/chains.html#fees-defaultpriorityfee) if set.
+ *
+ * - Docs: https://viem.sh/docs/actions/public/estimateMaxPriorityFeePerGas.html
+ *
+ * @param client - Client to use
+ * @returns An estimate (in wei) for the max priority fee per gas. {@link EstimateMaxPriorityFeePerGasReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { estimateMaxPriorityFeePerGas } from 'viem/actions'
+ *
+ * const client = createPublicClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const maxPriorityFeePerGas = await estimateMaxPriorityFeePerGas(client)
+ * // 10000000n
+ */
+export async function estimateMaxPriorityFeePerGas<
+  chain extends Chain | undefined,
+  chainOverride extends Chain | undefined,
+>(
+  client: Client<Transport, chain>,
+  args?: EstimateMaxPriorityFeePerGasParameters<chain, chainOverride>,
+): Promise<EstimateMaxPriorityFeePerGasReturnType> {
+  return internal_estimateMaxPriorityFeePerGas(client, args as any)
+}
+
+export async function internal_estimateMaxPriorityFeePerGas<
+  chain extends Chain | undefined,
+  chainOverride extends Chain | undefined,
+>(
+  client: Client<Transport, chain>,
+  args: EstimateMaxPriorityFeePerGasParameters<chain, chainOverride> & {
+    block?: Block
+    request?: PrepareTransactionRequestParameters<
+      chain,
+      Account | undefined,
+      chainOverride
+    >
+  },
+): Promise<EstimateMaxPriorityFeePerGasReturnType> {
+  const { block: block_, chain = client.chain, request } = args || {}
+  if (typeof chain?.fees?.defaultPriorityFee === 'function') {
+    const block = block_ || (await getBlock(client))
+    return chain.fees.defaultPriorityFee({
+      block,
+      client,
+      request,
+    } as ChainFeesFnParameters)
+  } else if (chain?.fees?.defaultPriorityFee)
+    return chain?.fees?.defaultPriorityFee
+
+  try {
+    const maxPriorityFeePerGasHex = await client.request({
+      method: 'eth_maxPriorityFeePerGas',
+    })
+    return hexToBigInt(maxPriorityFeePerGasHex)
+  } catch {
+    // If the RPC Provider does not support `eth_maxPriorityFeePerGas`
+    // fall back to calculating it manually via `gasPrice - baseFeePerGas`.
+    // See: https://github.com/ethereum/pm/issues/328#:~:text=eth_maxPriorityFeePerGas%20after%20London%20will%20effectively%20return%20eth_gasPrice%20%2D%20baseFee
+    const [block, gasPrice] = await Promise.all([
+      block_ ? Promise.resolve(block_) : getBlock(client),
+      getGasPrice(client),
+    ])
+
+    if (typeof block.baseFeePerGas !== 'bigint')
+      throw new Eip1559FeesNotSupportedError()
+
+    const maxPriorityFeePerGas = gasPrice - block.baseFeePerGas
+
+    if (maxPriorityFeePerGas < 0n) return 0n
+    return maxPriorityFeePerGas
+  }
+}

package/src/actions/public/verifyHash.ts

@@ -1,11 +1,11 @@
 import type { Address } from 'abitype'
 
-import type { Chain } from '../../chains/index.js'
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import { universalSignatureValidatorAbi } from '../../constants/abis.js'
 import { universalSignatureValidatorByteCode } from '../../constants/contracts.js'
 import { CallExecutionError } from '../../errors/contract.js'
+import type { Chain } from '../../types/chain.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
 import { isBytesEqual } from '../../utils/data/isBytesEqual.js'
 import { encodeDeployData, isHex, toHex } from '../../utils/index.js'

package/src/actions/public/verifyMessage.ts

@@ -1,10 +1,11 @@
-import type { Chain } from '../../chains/index.js'
+import type { Address } from 'abitype'
+
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Chain } from '../../types/chain.js'
 import type { ByteArray, Hex, SignableMessage } from '../../types/misc.js'
 import { hashMessage } from '../../utils/index.js'
 import { type VerifyHashParameters, verifyHash } from './verifyHash.js'
-import type { Address } from 'abitype'
 
 export type VerifyMessageParameters = Omit<VerifyHashParameters, 'hash'> & {
   /** The address that signed the original message. */

package/src/actions/public/verifyTypedData.ts

@@ -1,11 +1,12 @@
-import type { Chain } from '../../chains/index.js'
+import type { Address, TypedData } from 'abitype'
+
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Chain } from '../../types/chain.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
 import type { TypedDataDefinition } from '../../types/typedData.js'
 import { hashTypedData } from '../../utils/signature/hashTypedData.js'
 import { type VerifyHashParameters, verifyHash } from './verifyHash.js'
-import type { Address, TypedData } from 'abitype'
 
 export type VerifyTypedDataParameters<
   TTypedData extends TypedData | { [key: string]: unknown } = TypedData,

package/src/actions/public/watchContractEvent.ts

@@ -2,7 +2,6 @@ import type { Abi, AbiEvent, Address, ExtractAbiEvent } from 'abitype'
 
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
-import type { EncodeEventTopicsParameters, LogTopic } from '../../index.js'
 import type { Chain } from '../../types/chain.js'
 import type { GetEventArgs, InferEventName } from '../../types/contract.js'
 import type { Filter } from '../../types/filter.js'
@@ -17,14 +16,18 @@ import { observe } from '../../utils/observe.js'
 import { poll } from '../../utils/poll.js'
 import { stringify } from '../../utils/stringify.js'
 
-import { DecodeLogDataMismatch } from '../../errors/abi.js'
 import {
+  DecodeLogDataMismatch,
   DecodeLogTopicsMismatch,
-  InvalidInputRpcError,
-  decodeEventLog,
+} from '../../errors/abi.js'
+import { InvalidInputRpcError } from '../../errors/rpc.js'
+import type { LogTopic } from '../../types/misc.js'
+import { decodeEventLog } from '../../utils/abi/decodeEventLog.js'
+import {
+  type EncodeEventTopicsParameters,
   encodeEventTopics,
-  formatLog,
-} from '../../index.js'
+} from '../../utils/abi/encodeEventTopics.js'
+import { formatLog } from '../../utils/formatters/log.js'
 import {
   type CreateContractEventFilterParameters,
   createContractEventFilter,

package/src/actions/wallet/deployContract.ts

@@ -3,7 +3,8 @@ import type { Abi } from 'abitype'
 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, GetChain } from '../../types/chain.js'
+import type { Chain } from '../../types/chain.js'
+import type { GetChain } from '../../types/chain.js'
 import type { GetConstructorArgs } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
 import type { UnionOmit } from '../../types/utils.js'

package/src/actions/wallet/prepareTransactionRequest.ts

@@ -0,0 +1,179 @@
+import type { Account } from '../../accounts/types.js'
+import { parseAccount } from '../../accounts/utils/parseAccount.js'
+import { internal_estimateFeesPerGas } from '../../actions/public/estimateFeesPerGas.js'
+import {
+  type EstimateGasParameters,
+  estimateGas,
+} from '../../actions/public/estimateGas.js'
+import { getBlock } from '../../actions/public/getBlock.js'
+import { getTransactionCount } from '../../actions/public/getTransactionCount.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import { AccountNotFoundError } 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 { TransactionSerializable } from '../../types/transaction.js'
+import type { UnionOmit } from '../../types/utils.js'
+import type { FormattedTransactionRequest } from '../../utils/formatters/transactionRequest.js'
+import type { AssertRequestParameters } from '../../utils/transaction/assertRequest.js'
+import { assertRequest } from '../../utils/transaction/assertRequest.js'
+import { getTransactionType } from '../../utils/transaction/getTransactionType.js'
+
+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>
+
+export type PrepareTransactionRequestReturnType<
+  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>
+
+/**
+ * Prepares a transaction request for signing.
+ *
+ * - Docs: https://viem.sh/docs/actions/wallet/prepareTransactionRequest.html
+ *
+ * @param args - {@link PrepareTransactionRequestParameters}
+ * @returns The transaction request. {@link PrepareTransactionRequestReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { prepareTransactionRequest } from 'viem/actions'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const request = await prepareTransactionRequest(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: 1n,
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { prepareTransactionRequest } from 'viem/actions'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const request = await prepareTransactionRequest(client, {
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: 1n,
+ * })
+ */
+export async function prepareTransactionRequest<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+  TChainOverride extends Chain | undefined,
+>(
+  client: Client<Transport, TChain, TAccount>,
+  args: PrepareTransactionRequestParameters<TChain, TAccount, TChainOverride>,
+): Promise<
+  PrepareTransactionRequestReturnType<TChain, TAccount, TChainOverride>
+> {
+  const { account: account_ = client.account, chain, gas, nonce, type } = args
+  if (!account_) throw new AccountNotFoundError()
+  const account = parseAccount(account_)
+
+  const block = await getBlock(client, { blockTag: 'latest' })
+
+  const request = { ...args, from: account.address }
+
+  if (typeof nonce === 'undefined')
+    request.nonce = await getTransactionCount(client, {
+      address: account.address,
+      blockTag: 'pending',
+    })
+
+  if (typeof type === 'undefined') {
+    try {
+      request.type = getTransactionType(
+        request as TransactionSerializable,
+      ) as any
+    } catch {
+      // infer type from block
+      request.type =
+        typeof block.baseFeePerGas === 'bigint' ? 'eip1559' : 'legacy'
+    }
+  }
+
+  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 (typeof gas === 'undefined')
+    request.gas = await estimateGas(client, {
+      ...request,
+      account: { address: account.address, type: 'json-rpc' },
+    } as EstimateGasParameters)
+
+  assertRequest(request as AssertRequestParameters)
+
+  return request as PrepareTransactionRequestReturnType<
+    TChain,
+    TAccount,
+    TChainOverride
+  >
+}

package/src/actions/wallet/sendRawTransaction.ts

@@ -0,0 +1,48 @@
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Chain } from '../../types/chain.js'
+import type { Hash } from '../../types/misc.js'
+import type { TransactionSerialized } from '../../types/transaction.js'
+
+export type SendRawTransactionParameters = {
+  /**
+   * The signed serialized tranasction.
+   */
+  serializedTransaction: TransactionSerialized
+}
+
+export type SendRawTransactionReturnType = Hash
+
+/**
+ * Sends a **signed** transaction to the network
+ *
+ * - Docs: https://viem.sh/docs/actions/wallet/sendRawTransaction.html
+ * - JSON-RPC Method: [`eth_sendRawTransaction`](https://ethereum.github.io/execution-apis/api-documentation/)
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SendRawTransactionParameters}
+ * @returns The transaction hash. {@link SendRawTransactionReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { sendRawTransaction } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ *
+ * const hash = await sendRawTransaction(client, {
+ *   serializedTransaction: '0x02f850018203118080825208808080c080a04012522854168b27e5dc3d5839bab5e6b39e1a0ffd343901ce1622e3d64b48f1a04e00902ae0502c4728cbf12156290df99c3ed7de85b1dbfe20b5c36931733a33'
+ * })
+ */
+export async function sendRawTransaction<TChain extends Chain | undefined,>(
+  client: Client<Transport, TChain>,
+  { serializedTransaction }: SendRawTransactionParameters,
+): Promise<SendRawTransactionReturnType> {
+  return client.request({
+    method: 'eth_sendRawTransaction',
+    params: [serializedTransaction],
+  })
+}

package/src/actions/wallet/sendTransaction.ts

@@ -5,7 +5,8 @@ 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 { Chain } from '../../types/chain.js'
+import type { GetChain } from '../../types/chain.js'
 import type { Hash } from '../../types/misc.js'
 import type {
   TransactionRequest,
@@ -23,8 +24,9 @@ import {
   type AssertRequestParameters,
   assertRequest,
 } from '../../utils/transaction/assertRequest.js'
-import { prepareRequest } from '../../utils/transaction/prepareRequest.js'
 import { getChainId } from '../public/getChainId.js'
+import { prepareTransactionRequest } from './prepareTransactionRequest.js'
+import { sendRawTransaction } from './sendRawTransaction.js'
 
 export type SendTransactionParameters<
   TChain extends Chain | undefined = Chain | undefined,
@@ -129,7 +131,7 @@ export async function sendTransaction<
 
     if (account.type === 'local') {
       // Prepare the request for signing (assign appropriate fees, etc.)
-      const request = await prepareRequest(client, {
+      const request = await prepareTransactionRequest(client, {
         account,
         accessList,
         chain,
@@ -147,16 +149,15 @@ export async function sendTransaction<
       if (!chainId) chainId = await getChainId(client)
 
       const serializer = chain?.serializers?.transaction
-      const signedRequest = (await account.signTransaction(
+      const serializedTransaction = (await account.signTransaction(
         {
           ...request,
           chainId,
         } as TransactionSerializable,
         { serializer },
       )) as Hash
-      return await client.request({
-        method: 'eth_sendRawTransaction',
-        params: [signedRequest],
+      return await sendRawTransaction(client, {
+        serializedTransaction,
       })
     }