viem 1.7.0 → 1.8.1

package/src/chains/celo/formatters.ts

@@ -1,5 +1,6 @@
 import { type ChainFormatters } from '../../types/chain.js'
 import type { Hash } from '../../types/misc.js'
+import type { RpcTransaction } from '../../types/rpc.js'
 import { hexToBigInt } from '../../utils/encoding/fromHex.js'
 import { numberToHex } from '../../utils/encoding/toHex.js'
 import { defineBlock } from '../../utils/formatters/block.js'
@@ -12,13 +13,11 @@ import { defineTransactionRequest } from '../../utils/formatters/transactionRequ
 import type {
   CeloBlockOverrides,
   CeloRpcTransaction,
-  CeloRpcTransactionOverrides,
   CeloRpcTransactionReceiptOverrides,
-  CeloRpcTransactionRequestOverrides,
+  CeloRpcTransactionRequest,
   CeloTransaction,
-  CeloTransactionOverrides,
   CeloTransactionReceiptOverrides,
-  CeloTransactionRequestOverrides,
+  CeloTransactionRequest,
 } from './types.js'
 
 export const formattersCelo = {
@@ -34,7 +33,7 @@ export const formattersCelo = {
       const transactions = args.transactions?.map((transaction) => {
         if (typeof transaction === 'string') return transaction
         return {
-          ...formatTransaction(transaction),
+          ...formatTransaction(transaction as RpcTransaction),
           feeCurrency: transaction.feeCurrency,
           gatewayFee: transaction.gatewayFee
             ? hexToBigInt(transaction.gatewayFee)
@@ -49,12 +48,12 @@ export const formattersCelo = {
     },
   }),
   transaction: /*#__PURE__*/ defineTransaction({
-    format(args: CeloRpcTransactionOverrides): CeloTransactionOverrides {
+    format(args: CeloRpcTransaction): CeloTransaction {
       return {
         feeCurrency: args.feeCurrency,
         gatewayFee: args.gatewayFee ? hexToBigInt(args.gatewayFee) : null,
         gatewayFeeRecipient: args.gatewayFeeRecipient,
-      }
+      } as CeloTransaction
     },
   }),
   transactionReceipt: /*#__PURE__*/ defineTransactionReceipt({
@@ -69,17 +68,17 @@ export const formattersCelo = {
     },
   }),
   transactionRequest: /*#__PURE__*/ defineTransactionRequest({
-    format(
-      args: CeloTransactionRequestOverrides,
-    ): CeloRpcTransactionRequestOverrides {
-      return {
+    format(args: CeloTransactionRequest): CeloRpcTransactionRequest {
+      const request = {
         feeCurrency: args.feeCurrency,
         gatewayFee:
           typeof args.gatewayFee !== 'undefined'
             ? numberToHex(args.gatewayFee)
             : undefined,
         gatewayFeeRecipient: args.gatewayFeeRecipient,
-      }
+      } as CeloRpcTransactionRequest
+      if (args.type === 'cip42') request.type = '0x7c'
+      return request
     },
   }),
 } as const satisfies ChainFormatters

package/src/chains/celo/types.ts

@@ -4,17 +4,21 @@ import type { Block, BlockTag } from '../../types/block.js'
 import type { FeeValuesEIP1559 } from '../../types/fee.js'
 import type { Hex } from '../../types/misc.js'
 import type {
+  Index,
+  Quantity,
   RpcBlock,
-  RpcTransaction,
+  RpcTransaction as RpcTransaction_,
   RpcTransactionReceipt,
-  RpcTransactionRequest,
+  RpcTransactionRequest as RpcTransactionRequest_,
   TransactionType,
 } from '../../types/rpc.js'
 import type {
   AccessList,
-  Transaction,
+  Transaction as Transaction_,
+  TransactionBase,
   TransactionReceipt,
-  TransactionRequest,
+  TransactionRequest as TransactionRequest_,
+  TransactionRequestBase,
   TransactionSerializable,
   TransactionSerializableBase,
   TransactionSerialized,
@@ -68,13 +72,9 @@ export type CeloRpcBlock<
 > &
   CeloRpcBlockOverrides
 
-export type CeloRpcTransactionOverrides = {
-  feeCurrency: Address | null
-  gatewayFee: Hex | null
-  gatewayFeeRecipient: Address | null
-}
 export type CeloRpcTransaction<TPending extends boolean = boolean> =
-  RpcTransaction<TPending> & CeloRpcTransactionOverrides
+  | RpcTransaction<TPending>
+  | RpcTransactionCIP42<TPending>
 
 export type CeloRpcTransactionReceiptOverrides = {
   feeCurrency: Address | null
@@ -84,21 +84,13 @@ export type CeloRpcTransactionReceiptOverrides = {
 export type CeloRpcTransactionReceipt = RpcTransactionReceipt &
   CeloRpcTransactionReceiptOverrides
 
-export type CeloRpcTransactionRequestOverrides = {
-  feeCurrency?: Address
-  gatewayFee?: Hex
-  gatewayFeeRecipient?: Address
-}
-export type CeloRpcTransactionRequest = RpcTransactionRequest &
-  CeloRpcTransactionRequestOverrides
+export type CeloRpcTransactionRequest =
+  | RpcTransactionRequest
+  | RpcTransactionRequestCIP42
 
-export type CeloTransactionOverrides = {
-  feeCurrency: Address | null
-  gatewayFee: bigint | null
-  gatewayFeeRecipient: Address | null
-}
 export type CeloTransaction<TPending extends boolean = boolean> =
-  Transaction<TPending> & CeloTransactionOverrides
+  | Transaction<TPending>
+  | TransactionCIP42<TPending>
 
 export type CeloTransactionReceiptOverrides = {
   feeCurrency: Address | null
@@ -108,13 +100,9 @@ export type CeloTransactionReceiptOverrides = {
 export type CeloTransactionReceipt = TransactionReceipt &
   CeloTransactionReceiptOverrides
 
-export type CeloTransactionRequestOverrides = {
-  feeCurrency?: Address
-  gatewayFee?: bigint
-  gatewayFeeRecipient?: Address
-}
-export type CeloTransactionRequest = TransactionRequest &
-  CeloTransactionRequestOverrides
+export type CeloTransactionRequest =
+  | TransactionRequest
+  | TransactionRequestCIP42
 
 export type CeloTransactionSerializable =
   | TransactionSerializableCIP42
@@ -126,6 +114,74 @@ export type CeloTransactionSerialized<
 
 export type CeloTransactionType = TransactionType | 'cip42'
 
+type RpcTransaction<TPending extends boolean = boolean> =
+  RpcTransaction_<TPending> & {
+    feeCurrency: Address | null
+    gatewayFee: Hex | null
+    gatewayFeeRecipient: Address | null
+  }
+
+type RpcTransactionRequest = RpcTransactionRequest_ & {
+  feeCurrency?: Address
+  gatewayFee?: Hex
+  gatewayFeeRecipient?: Address
+}
+
+export type RpcTransactionCIP42<TPending extends boolean = boolean> =
+  TransactionBase<Quantity, Index, TPending> &
+    FeeValuesEIP1559<Quantity> & {
+      feeCurrency: Address | null
+      gatewayFee: Hex | null
+      gatewayFeeRecipient: Address | null
+      type: '0x7c'
+    }
+
+export type RpcTransactionRequestCIP42 = TransactionRequestBase<
+  Quantity,
+  Index
+> &
+  Partial<FeeValuesEIP1559<Quantity>> & {
+    accessList?: AccessList
+    feeCurrency?: Address
+    gatewayFee?: Hex
+    gatewayFeeRecipient?: Address
+    type?: '0x7c'
+  }
+
+type Transaction<TPending extends boolean = boolean> = Transaction_<
+  bigint,
+  number,
+  TPending
+> & {
+  feeCurrency: Address | null
+  gatewayFee: bigint | null
+  gatewayFeeRecipient: Address | null
+}
+
+export type TransactionCIP42<TPending extends boolean = boolean> =
+  TransactionBase<bigint, number, TPending> &
+    FeeValuesEIP1559 & {
+      feeCurrency: Address | null
+      gatewayFee: bigint | null
+      gatewayFeeRecipient: Address | null
+      type: 'cip42'
+    }
+
+type TransactionRequest = TransactionRequest_ & {
+  feeCurrency?: Address
+  gatewayFee?: bigint
+  gatewayFeeRecipient?: Address
+}
+
+export type TransactionRequestCIP42 = TransactionRequestBase &
+  Partial<FeeValuesEIP1559> & {
+    accessList?: AccessList
+    feeCurrency?: Address
+    gatewayFee?: bigint
+    gatewayFeeRecipient?: Address
+    type?: 'cip42'
+  }
+
 export type TransactionSerializableCIP42<
   TQuantity = bigint,
   TIndex = number,

package/src/chains/index.ts

@@ -66,6 +66,7 @@ export const haqqTestedge2 = /*#__PURE__*/ defineChain(chains.haqqTestedge2)
 export const hardhat = /*#__PURE__*/ defineChain(chains.hardhat)
 export const harmonyOne = /*#__PURE__*/ defineChain(chains.harmonyOne)
 export const klaytn = /*#__PURE__*/ defineChain(chains.klaytn)
+export const linea = /*#__PURE__*/ defineChain(chains.linea)
 export const lineaTestnet = /*#__PURE__*/ defineChain(chains.lineaTestnet)
 export const localhost = /*#__PURE__*/ defineChain(chains.localhost)
 export const mainnet = /*#__PURE__*/ defineChain(chains.mainnet)

package/src/chains/utils.ts

@@ -10,20 +10,20 @@ export type {
   CeloRpcBlock,
   CeloRpcBlockOverrides,
   CeloRpcTransaction,
-  CeloRpcTransactionOverrides,
   CeloRpcTransactionReceipt,
   CeloRpcTransactionReceiptOverrides,
   CeloRpcTransactionRequest,
-  CeloRpcTransactionRequestOverrides,
   CeloTransaction,
-  CeloTransactionOverrides,
   CeloTransactionReceipt,
   CeloTransactionReceiptOverrides,
   CeloTransactionRequest,
-  CeloTransactionRequestOverrides,
   CeloTransactionSerializable,
   CeloTransactionSerialized,
   CeloTransactionType,
+  RpcTransactionCIP42,
+  RpcTransactionRequestCIP42,
+  TransactionCIP42,
+  TransactionRequestCIP42,
   TransactionSerializableCIP42,
   TransactionSerializedCIP42,
 } from './celo/types.js'

package/src/clients/decorators/public.ts

@@ -206,6 +206,16 @@ import {
   type WatchPendingTransactionsReturnType,
   watchPendingTransactions,
 } from '../../actions/public/watchPendingTransactions.js'
+import {
+  type PrepareTransactionRequestParameters,
+  type PrepareTransactionRequestReturnType,
+  prepareTransactionRequest,
+} from '../../actions/wallet/prepareTransactionRequest.js'
+import {
+  type SendRawTransactionParameters,
+  type SendRawTransactionReturnType,
+  sendRawTransaction,
+} from '../../actions/wallet/sendRawTransaction.js'
 import type { Account } from '../../types/account.js'
 import type { BlockNumber, BlockTag } from '../../types/block.js'
 import type { Chain } from '../../types/chain.js'
@@ -1199,6 +1209,47 @@ export type PublicActions<
   >(
     args: MulticallParameters<TContracts, TAllowFailure>,
   ) => Promise<MulticallReturnType<TContracts, TAllowFailure>>
+  /**
+   * 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'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const request = await client.prepareTransactionRequest({
+   *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   *   to: '0x0000000000000000000000000000000000000000',
+   *   value: 1n,
+   * })
+   *
+   * @example
+   * // Account Hoisting
+   * import { createWalletClient, http } from 'viem'
+   * import { privateKeyToAccount } from 'viem/accounts'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   account: privateKeyToAccount('0x…'),
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const request = await client.prepareTransactionRequest({
+   *   to: '0x0000000000000000000000000000000000000000',
+   *   value: 1n,
+   * })
+   */
+  prepareTransactionRequest: <TChainOverride extends Chain | undefined,>(
+    args: PrepareTransactionRequestParameters<TChain, TAccount, TChainOverride>,
+  ) => Promise<PrepareTransactionRequestReturnType>
   /**
    * Calls a read-only function on a contract, and returns the response.
    *
@@ -1236,6 +1287,33 @@ export type PublicActions<
   >(
     args: ReadContractParameters<TAbi, TFunctionName>,
   ) => Promise<ReadContractReturnType<TAbi, TFunctionName>>
+  /**
+   * 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 client.sendRawTransaction({
+   *   serializedTransaction: '0x02f850018203118080825208808080c080a04012522854168b27e5dc3d5839bab5e6b39e1a0ffd343901ce1622e3d64b48f1a04e00902ae0502c4728cbf12156290df99c3ed7de85b1dbfe20b5c36931733a33'
+   * })
+   */
+  sendRawTransaction: (
+    args: SendRawTransactionParameters,
+  ) => Promise<SendRawTransactionReturnType>
   /**
    * Simulates/validates a contract interaction. This is useful for retrieving **return data** and **revert reasons** of contract write functions.
    *
@@ -1567,7 +1645,10 @@ export function publicActions<
     getTransactionCount: (args) => getTransactionCount(client, args),
     getTransactionReceipt: (args) => getTransactionReceipt(client, args),
     multicall: (args) => multicall(client, args as any) as any,
+    prepareTransactionRequest: (args) =>
+      prepareTransactionRequest(client as any, args as any),
     readContract: (args) => readContract(client, args),
+    sendRawTransaction: (args) => sendRawTransaction(client, args),
     simulateContract: (args) => simulateContract(client, args),
     verifyMessage: (args) => verifyMessage(client, args),
     verifyTypedData: (args) => verifyTypedData(client, args),

package/src/clients/decorators/wallet.ts

@@ -22,6 +22,11 @@ import {
   type GetPermissionsReturnType,
   getPermissions,
 } from '../../actions/wallet/getPermissions.js'
+import {
+  type PrepareTransactionRequestParameters,
+  type PrepareTransactionRequestReturnType,
+  prepareTransactionRequest,
+} from '../../actions/wallet/prepareTransactionRequest.js'
 import {
   type RequestAddressesReturnType,
   requestAddresses,
@@ -31,6 +36,11 @@ import {
   type RequestPermissionsReturnType,
   requestPermissions,
 } from '../../actions/wallet/requestPermissions.js'
+import {
+  type SendRawTransactionParameters,
+  type SendRawTransactionReturnType,
+  sendRawTransaction,
+} from '../../actions/wallet/sendRawTransaction.js'
 import {
   type SendTransactionParameters,
   type SendTransactionReturnType,
@@ -41,6 +51,11 @@ import {
   type SignMessageReturnType,
   signMessage,
 } from '../../actions/wallet/signMessage.js'
+import {
+  type SignTransactionParameters,
+  type SignTransactionReturnType,
+  signTransaction,
+} from '../../actions/wallet/signTransaction.js'
 import {
   type SignTypedDataParameters,
   type SignTypedDataReturnType,
@@ -175,6 +190,47 @@ export type WalletActions<
    * const permissions = await client.getPermissions()
    */
   getPermissions: () => Promise<GetPermissionsReturnType>
+  /**
+   * 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'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const request = await client.prepareTransactionRequest({
+   *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   *   to: '0x0000000000000000000000000000000000000000',
+   *   value: 1n,
+   * })
+   *
+   * @example
+   * // Account Hoisting
+   * import { createWalletClient, http } from 'viem'
+   * import { privateKeyToAccount } from 'viem/accounts'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   account: privateKeyToAccount('0x…'),
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const request = await client.prepareTransactionRequest({
+   *   to: '0x0000000000000000000000000000000000000000',
+   *   value: 1n,
+   * })
+   */
+  prepareTransactionRequest: <TChainOverride extends Chain | undefined,>(
+    args: PrepareTransactionRequestParameters<TChain, TAccount, TChainOverride>,
+  ) => Promise<PrepareTransactionRequestReturnType>
   /**
    * Requests a list of accounts managed by a wallet.
    *
@@ -222,6 +278,33 @@ export type WalletActions<
   requestPermissions: (
     args: RequestPermissionsParameters,
   ) => Promise<RequestPermissionsReturnType>
+  /**
+   * 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 client.sendRawTransaction({
+   *   serializedTransaction: '0x02f850018203118080825208808080c080a04012522854168b27e5dc3d5839bab5e6b39e1a0ffd343901ce1622e3d64b48f1a04e00902ae0502c4728cbf12156290df99c3ed7de85b1dbfe20b5c36931733a33'
+   * })
+   */
+  sendRawTransaction: (
+    args: SendRawTransactionParameters,
+  ) => Promise<SendRawTransactionReturnType>
   /**
    * Creates, signs, and sends a new transaction to the network.
    *
@@ -313,6 +396,52 @@ export type WalletActions<
   signMessage: (
     args: SignMessageParameters<TAccount>,
   ) => Promise<SignMessageReturnType>
+  /**
+   * Signs a transaction.
+   *
+   * - Docs: https://viem.sh/docs/actions/wallet/signTransaction.html
+   * - JSON-RPC Methods:
+   *   - JSON-RPC Accounts: [`eth_signTransaction`](https://ethereum.github.io/execution-apis/api-documentation/)
+   *   - Local Accounts: Signs locally. No JSON-RPC request.
+   *
+   * @param args - {@link SignTransactionParameters}
+   * @returns The signed message. {@link SignTransactionReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const request = await client.prepareTransactionRequest({
+   *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   *   to: '0x0000000000000000000000000000000000000000',
+   *   value: 1n,
+   * })
+   * const signature = await client.signTransaction(request)
+   *
+   * @example
+   * // Account Hoisting
+   * import { createWalletClient, http } from 'viem'
+   * import { privateKeyToAccount } from 'viem/accounts'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   account: privateKeyToAccount('0x…'),
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const request = await client.prepareTransactionRequest({
+   *   to: '0x0000000000000000000000000000000000000000',
+   *   value: 1n,
+   * })
+   * const signature = await client.signTransaction(request)
+   */
+  signTransaction: <TChainOverride extends Chain | undefined,>(
+    args: SignTransactionParameters<TChain, TAccount, TChainOverride>,
+  ) => Promise<SignTransactionReturnType>
   /**
    * 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))`.
    *
@@ -536,10 +665,14 @@ export function walletActions<
     getAddresses: () => getAddresses(client),
     getChainId: () => getChainId(client),
     getPermissions: () => getPermissions(client),
+    prepareTransactionRequest: (args) =>
+      prepareTransactionRequest(client as any, args as any),
     requestAddresses: () => requestAddresses(client),
     requestPermissions: (args) => requestPermissions(client, args),
+    sendRawTransaction: (args) => sendRawTransaction(client, args),
     sendTransaction: (args) => sendTransaction(client, args),
     signMessage: (args) => signMessage(client, args),
+    signTransaction: (args) => signTransaction(client, args),
     signTypedData: (args) => signTypedData(client, args),
     switchChain: (args) => switchChain(client, args),
     watchAsset: (args) => watchAsset(client, args),

package/src/errors/rpc.ts

@@ -60,7 +60,7 @@ export type ProviderRpcErrorCode =
   | 4200 // Unsupported Method
   | 4900 // Disconnected
   | 4901 // Chain Disconnected
-  | 4902 // Chain Not Recongnized
+  | 4902 // Chain Not Recognized
 
 /**
  * Error subclass implementing Ethereum Provider errors per EIP-1193.

package/src/errors/version.ts

@@ -1 +1 @@
-export const version = '1.7.0'
+export const version = '1.8.1'

package/src/index.ts

@@ -203,6 +203,12 @@ export type {
   SendTransactionParameters,
   SendTransactionReturnType,
 } from './actions/wallet/sendTransaction.js'
+export type {
+  PrepareTransactionRequestParameters,
+  PrepareTransactionRequestReturnType,
+  /** @deprecated import `prepareTransactionRequest` from `viem/actions` instead. */
+  prepareTransactionRequest as prepareRequest,
+} from './actions/wallet/prepareTransactionRequest.js'
 export type {
   SendUnsignedTransactionParameters,
   SendUnsignedTransactionReturnType,
@@ -740,6 +746,7 @@ export {
   type FormattedTransactionRequest,
   defineTransactionRequest,
   formatTransactionRequest,
+  rpcTransactionType,
 } from './utils/formatters/transactionRequest.js'
 export {
   type GetAbiItemParameters,
@@ -862,7 +869,6 @@ export { parseEther } from './utils/unit/parseEther.js'
 export { parseGwei } from './utils/unit/parseGwei.js'
 export { parseTransaction } from './utils/transaction/parseTransaction.js'
 export { parseUnits } from './utils/unit/parseUnits.js'
-export { prepareRequest } from './utils/transaction/prepareRequest.js'
 export { serializeAccessList } from './utils/transaction/serializeAccessList.js'
 export {
   serializeTransaction,

package/src/types/chain.ts

@@ -1,6 +1,7 @@
 import type { Address } from 'abitype'
 
 import type { EstimateFeesPerGasReturnType } from '../actions/public/estimateFeesPerGas.js'
+import type { PrepareTransactionRequestParameters } from '../actions/wallet/prepareTransactionRequest.js'
 import type { Client } from '../clients/createClient.js'
 import type { Transport } from '../clients/transports/createTransport.js'
 import type { Account } from '../types/account.js'
@@ -11,7 +12,6 @@ import type {
 } from '../types/transaction.js'
 import type { IsUndefined, Prettify } from '../types/utils.js'
 import type { FormattedBlock } from '../utils/formatters/block.js'
-import type { PrepareRequestParameters } from '../utils/transaction/prepareRequest.js'
 import type { SerializeTransactionFn } from '../utils/transaction/serializeTransaction.js'
 
 export type Chain<
@@ -112,7 +112,7 @@ export type ChainFeesFnParameters<
    * is outside of a transaction request context (e.g. a direct call to
    * the `estimateFeesPerGas` Action).
    */
-  request?: PrepareRequestParameters<
+  request?: PrepareTransactionRequestParameters<
     Omit<Chain, 'formatters'> & { formatters: formatters },
     Account | undefined,
     undefined

package/src/types/eip1193.ts

@@ -639,7 +639,7 @@ export type PublicRpcSchema = [
     ReturnType: string
   },
   /**
-   * @description Sends and already-signed transaction to the network
+   * @description Sends a **signed** transaction to the network
    * @link https://eips.ethereum.org/EIPS/eip-1474
    * @example
    * provider.request({ method: 'eth_sendRawTransaction', params: ['0x...'] })

package/src/utils/data/isBytesEqual.ts

@@ -1,6 +1,9 @@
-import { type ByteArray, type Hex, isHex, toBytes } from '../../index.js'
 import { equalBytes } from '@noble/curves/abstract/utils'
 
+import type { ByteArray, Hex } from '../../types/misc.js'
+import { toBytes } from '../encoding/toBytes.js'
+import { isHex } from './isHex.js'
+
 export function isBytesEqual(a_: ByteArray | Hex, b_: ByteArray | Hex) {
   const a = isHex(a_) ? toBytes(a_) : a_
   const b = isHex(b_) ? toBytes(b_) : b_

package/src/utils/ens/encodeLabelhash.ts

@@ -1,4 +1,4 @@
-import type { Hex } from '../../index.js'
+import type { Hex } from '../../types/misc.js'
 
 export function encodeLabelhash(hash: Hex): `[${string}]` {
   return `[${hash.slice(2)}]`

package/src/utils/ens/encodedLabelToLabelhash.ts

@@ -1,5 +1,5 @@
-import type { Hex } from '../../index.js'
-import { isHex } from '../index.js'
+import type { Hex } from '../../types/misc.js'
+import { isHex } from '../data/isHex.js'
 
 export function encodedLabelToLabelhash(label: string): Hex | null {
   if (label.length !== 66) return null