viem 0.0.0-portable-types-20230522163654 → 0.0.0-refactor-generics-20230831161903

package/src/actions/public/readContract.ts

@@ -1,12 +1,14 @@
 import type { Abi } from 'abitype'
 
-import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { BaseError } from '../../errors/base.js'
 import type { Chain } from '../../types/chain.js'
 import type {
-  ContractFunctionConfig,
-  ContractFunctionResult,
+  ContractFunctionArgs,
+  ContractFunctionName,
+  ContractFunctionParameters,
+  ContractFunctionReturnType,
 } from '../../types/contract.js'
 import {
   type DecodeFunctionResultParameters,
@@ -22,14 +24,30 @@ import { type CallParameters, call } from './call.js'
 
 export type ReadContractParameters<
   TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = string,
-> = Pick<CallParameters, 'blockNumber' | 'blockTag'> &
-  ContractFunctionConfig<TAbi, TFunctionName, 'view' | 'pure'>
+  TFunctionName extends ContractFunctionName<
+    TAbi,
+    'pure' | 'view'
+  > = ContractFunctionName<TAbi, 'pure' | 'view'>,
+  TArgs extends ContractFunctionArgs<
+    TAbi,
+    'pure' | 'view',
+    TFunctionName
+  > = ContractFunctionArgs<TAbi, 'pure' | 'view', TFunctionName>,
+> = Pick<CallParameters, 'account' | 'blockNumber' | 'blockTag'> &
+  ContractFunctionParameters<TAbi, 'pure' | 'view', TFunctionName, TArgs>
 
 export type ReadContractReturnType<
   TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = string,
-> = ContractFunctionResult<TAbi, TFunctionName>
+  TFunctionName extends ContractFunctionName<
+    TAbi,
+    'pure' | 'view'
+  > = ContractFunctionName<TAbi, 'pure' | 'view'>,
+  TArgs extends ContractFunctionArgs<
+    TAbi,
+    'pure' | 'view',
+    TFunctionName
+  > = ContractFunctionArgs<TAbi, 'pure' | 'view', TFunctionName>,
+> = ContractFunctionReturnType<TAbi, 'pure' | 'view', TFunctionName, TArgs>
 
 /**
  * Calls a read-only function on a contract, and returns the response.
@@ -39,7 +57,7 @@ export type ReadContractReturnType<
  *
  * A "read-only" function (constant function) on a Solidity contract is denoted by a `view` or `pure` keyword. They can only read the state of the contract, and cannot make any changes to it. Since read-only methods do not change the state of the contract, they do not require any gas to be executed, and can be called by any user without the need to pay for gas.
  *
- * Internally, uses a [Public Client](https://viem.sh/docs/clients/public) to call the [`call` action](https://viem.sh/docs/actions/public/call) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData).
+ * Internally, uses a [Public Client](https://viem.sh/docs/clients/public.html) to call the [`call` action](https://viem.sh/docs/actions/public/call.html) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData.html).
  *
  * @param client - Client to use
  * @param parameters - {@link ReadContractParameters}
@@ -64,18 +82,19 @@ export type ReadContractReturnType<
  */
 export async function readContract<
   TChain extends Chain | undefined,
-  TAbi extends Abi | readonly unknown[],
-  TFunctionName extends string,
+  const TAbi extends Abi | readonly unknown[],
+  TFunctionName extends ContractFunctionName<TAbi, 'pure' | 'view'>,
+  TArgs extends ContractFunctionArgs<TAbi, 'pure' | 'view', TFunctionName>,
 >(
-  client: PublicClient<Transport, TChain>,
+  client: Client<Transport, TChain>,
   {
     abi,
     address,
     args,
     functionName,
     ...callRequest
-  }: ReadContractParameters<TAbi, TFunctionName>,
-): Promise<ReadContractReturnType<TAbi, TFunctionName>> {
+  }: ReadContractParameters<TAbi, TFunctionName, TArgs>,
+): Promise<ReadContractReturnType<TAbi, TFunctionName, TArgs>> {
   const calldata = encodeFunctionData({
     abi,
     args,

package/src/actions/public/simulateContract.ts

@@ -1,7 +1,7 @@
 import type { Abi } from 'abitype'
 
 import { parseAccount } from '../../accounts/utils/parseAccount.js'
-import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { BaseError } from '../../errors/base.js'
 import type { Chain } from '../../types/chain.js'
@@ -11,6 +11,7 @@ import type {
   GetValue,
 } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
+import type { UnionOmit } from '../../types/utils.js'
 import {
   type DecodeFunctionResultParameters,
   decodeFunctionResult,
@@ -28,26 +29,32 @@ export type SimulateContractParameters<
   TAbi extends Abi | readonly unknown[] = Abi,
   TFunctionName extends string = any,
   TChain extends Chain | undefined = Chain | undefined,
-  TChainOverride extends Chain | undefined = undefined,
+  TChainOverride extends Chain | undefined = Chain | undefined,
 > = {
   chain?: TChainOverride
   /** 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
 } & ContractFunctionConfig<TAbi, TFunctionName, 'payable' | 'nonpayable'> &
-  Omit<
+  UnionOmit<
     CallParameters<TChainOverride extends Chain ? TChainOverride : TChain>,
     'batch' | 'to' | 'data' | 'value'
   > &
-  GetValue<TAbi, TFunctionName, CallParameters<TChain>['value']>
+  GetValue<
+    TAbi,
+    TFunctionName,
+    CallParameters<TChain> extends CallParameters
+      ? CallParameters<TChain>['value']
+      : CallParameters['value']
+  >
 
 export type SimulateContractReturnType<
   TAbi extends Abi | readonly unknown[] = Abi,
   TFunctionName extends string = string,
   TChain extends Chain | undefined = Chain | undefined,
-  TChainOverride extends Chain | undefined = undefined,
+  TChainOverride extends Chain | undefined = Chain | undefined,
 > = {
   result: ContractFunctionResult<TAbi, TFunctionName>
-  request: Omit<
+  request: UnionOmit<
     WriteContractParameters<
       TAbi,
       TFunctionName,
@@ -68,9 +75,9 @@ export type SimulateContractReturnType<
  * - Docs: https://viem.sh/docs/contract/simulateContract.html
  * - Examples: https://stackblitz.com/github/wagmi-dev/viem/tree/main/examples/contracts/writing-to-contracts
  *
- * This function does not require gas to execute and _**does not**_ change the state of the blockchain. It is almost identical to [`readContract`](https://viem.sh/docs/contract/readContract), but also supports contract write functions.
+ * This function does not require gas to execute and _**does not**_ change the state of the blockchain. It is almost identical to [`readContract`](https://viem.sh/docs/contract/readContract.html), but also supports contract write functions.
  *
- * Internally, uses a [Public Client](https://viem.sh/docs/clients/public) to call the [`call` action](https://viem.sh/docs/actions/public/call) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData).
+ * Internally, uses a [Public Client](https://viem.sh/docs/clients/public.html) to call the [`call` action](https://viem.sh/docs/actions/public/call.html) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData.html).
  *
  * @param client - Client to use
  * @param parameters - {@link SimulateContractParameters}
@@ -95,11 +102,11 @@ export type SimulateContractReturnType<
  */
 export async function simulateContract<
   TChain extends Chain | undefined,
-  TAbi extends Abi | readonly unknown[],
+  const TAbi extends Abi | readonly unknown[],
   TFunctionName extends string,
   TChainOverride extends Chain | undefined,
 >(
-  client: PublicClient<Transport, TChain>,
+  client: Client<Transport, TChain>,
   {
     abi,
     address,
@@ -138,6 +145,7 @@ export async function simulateContract<
         abi,
         address,
         args,
+        dataSuffix,
         functionName,
         ...callRequest,
       },

package/src/actions/public/uninstallFilter.ts

@@ -1,4 +1,4 @@
-import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { Chain } from '../../types/chain.js'
 import type { Filter } from '../../types/filter.js'
@@ -15,9 +15,9 @@ export type UninstallFilterReturnType = boolean
  * - JSON-RPC Methods: [`eth_uninstallFilter`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_uninstallFilter)
  *
  * Destroys a Filter that was created from one of the following Actions:
- * - [`createBlockFilter`](https://viem.sh/docs/actions/public/createBlockFilter)
- * - [`createEventFilter`](https://viem.sh/docs/actions/public/createEventFilter)
- * - [`createPendingTransactionFilter`](https://viem.sh/docs/actions/public/createPendingTransactionFilter)
+ * - [`createBlockFilter`](https://viem.sh/docs/actions/public/createBlockFilter.html)
+ * - [`createEventFilter`](https://viem.sh/docs/actions/public/createEventFilter.html)
+ * - [`createPendingTransactionFilter`](https://viem.sh/docs/actions/public/createPendingTransactionFilter.html)
  *
  * @param client - Client to use
  * @param parameters - {@link UninstallFilterParameters}
@@ -36,7 +36,7 @@ export async function uninstallFilter<
   TTransport extends Transport,
   TChain extends Chain | undefined,
 >(
-  _client: PublicClient<TTransport, TChain>,
+  _client: Client<TTransport, TChain>,
   { filter }: UninstallFilterParameters,
 ): Promise<UninstallFilterReturnType> {
   return filter.request({

package/src/actions/public/verifyHash.ts

@@ -1,11 +1,11 @@
 import type { Address } from 'abitype'
 
-import type { Chain } from '../../chains.js'
-import type { PublicClient } from '../../clients/createPublicClient.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'
@@ -33,7 +33,7 @@ export type VerifyHashReturnType = boolean
  * @returns Whether or not the signature is valid. {@link VerifyHashReturnType}
  */
 export async function verifyHash<TChain extends Chain | undefined,>(
-  client: PublicClient<Transport, TChain>,
+  client: Client<Transport, TChain>,
   { address, hash, signature, ...callRequest }: VerifyHashParameters,
 ): Promise<VerifyHashReturnType> {
   const signatureHex = isHex(signature) ? signature : toHex(signature)

package/src/actions/public/verifyMessage.ts

@@ -1,16 +1,17 @@
-import type { Chain } from '../../chains.js'
-import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Address } from 'abitype'
+
+import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
-import type { ByteArray, Hex } from '../../types/misc.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. */
   address: Address
   /** The message to be verified. */
-  message: string
+  message: SignableMessage
   /** The signature that was generated by signing the message with the address's private key. */
   signature: Hex | ByteArray
 }
@@ -29,7 +30,7 @@ export type VerifyMessageReturnType = boolean
  * @returns Whether or not the signature is valid. {@link VerifyMessageReturnType}
  */
 export async function verifyMessage<TChain extends Chain | undefined,>(
-  client: PublicClient<Transport, TChain>,
+  client: Client<Transport, TChain>,
   { address, message, signature, ...callRequest }: VerifyMessageParameters,
 ): Promise<VerifyMessageReturnType> {
   const hash = hashMessage(message)

package/src/actions/public/verifyTypedData.ts

@@ -1,11 +1,12 @@
-import type { Chain } from '../../chains.js'
-import type { PublicClient } from '../../clients/createPublicClient.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/index.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,
@@ -30,7 +31,7 @@ export type VerifyTypedDataReturnType = boolean
  * @returns Whether or not the signature is valid. {@link VerifyTypedDataReturnType}
  */
 export async function verifyTypedData<TChain extends Chain | undefined,>(
-  client: PublicClient<Transport, TChain>,
+  client: Client<Transport, TChain>,
   {
     address,
     signature,

package/src/actions/public/waitForTransactionReceipt.ts

@@ -1,4 +1,4 @@
-import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import {
   TransactionNotFoundError,
@@ -99,7 +99,7 @@ export type WaitForTransactionReceiptParameters<
 export async function waitForTransactionReceipt<
   TChain extends Chain | undefined,
 >(
-  client: PublicClient<Transport, TChain>,
+  client: Client<Transport, TChain>,
   {
     confirmations = 1,
     hash,
@@ -126,7 +126,7 @@ export async function waitForTransactionReceipt<
       observerId,
       { onReplaced, resolve, reject },
       (emit) => {
-        const unwatch = watchBlockNumber(client, {
+        const _unwatch = watchBlockNumber(client, {
           emitMissed: true,
           emitOnBegin: true,
           poll: true,
@@ -136,8 +136,8 @@ export async function waitForTransactionReceipt<
 
             let blockNumber = blockNumber_
 
-            const done = async (fn: () => void) => {
-              unwatch()
+            const done = (fn: () => void) => {
+              _unwatch()
               fn()
               _unobserve()
             }
@@ -192,63 +192,66 @@ export async function waitForTransactionReceipt<
                 (err instanceof TransactionNotFoundError ||
                   err instanceof TransactionReceiptNotFoundError)
               ) {
-                replacedTransaction = transaction
-
-                // Let's retrieve the transactions from the current block.
-                const block = await getBlock(client, {
-                  blockNumber,
-                  includeTransactions: true,
-                })
-
-                const replacementTransaction = (
-                  block.transactions as Transaction[]
-                ).find(
-                  ({ from, nonce }) =>
-                    from === replacedTransaction!.from &&
-                    nonce === replacedTransaction!.nonce,
-                )
+                try {
+                  replacedTransaction = transaction
 
-                // If we couldn't find a replacement transaction, continue polling.
-                if (!replacementTransaction) return
+                  // Let's retrieve the transactions from the current block.
+                  const block = await getBlock(client, {
+                    blockNumber,
+                    includeTransactions: true,
+                  })
 
-                // If we found a replacement transaction, return it's receipt.
-                receipt = await getTransactionReceipt(client, {
-                  hash: replacementTransaction.hash,
-                })
+                  const replacementTransaction = (
+                    block.transactions as Transaction[]
+                  ).find(
+                    ({ from, nonce }) =>
+                      from === replacedTransaction!.from &&
+                      nonce === replacedTransaction!.nonce,
+                  )
 
-                // Check if we have enough confirmations. If not, continue polling.
-                if (blockNumber - receipt.blockNumber + 1n < confirmations)
-                  return
+                  // If we couldn't find a replacement transaction, continue polling.
+                  if (!replacementTransaction) return
 
-                let reason: ReplacementReason = 'replaced'
-                if (
-                  replacementTransaction.to === replacedTransaction.to &&
-                  replacementTransaction.value === replacedTransaction.value
-                ) {
-                  reason = 'repriced'
-                } else if (
-                  replacementTransaction.from === replacementTransaction.to &&
-                  replacementTransaction.value === 0n
-                ) {
-                  reason = 'cancelled'
-                }
+                  // If we found a replacement transaction, return it's receipt.
+                  receipt = await getTransactionReceipt(client, {
+                    hash: replacementTransaction.hash,
+                  })
+
+                  // Check if we have enough confirmations. If not, continue polling.
+                  if (blockNumber - receipt.blockNumber + 1n < confirmations)
+                    return
 
-                done(() => {
-                  emit.onReplaced?.({
-                    reason,
-                    replacedTransaction: replacedTransaction!,
-                    transaction: replacementTransaction,
-                    transactionReceipt: receipt,
+                  let reason: ReplacementReason = 'replaced'
+                  if (
+                    replacementTransaction.to === replacedTransaction.to &&
+                    replacementTransaction.value === replacedTransaction.value
+                  ) {
+                    reason = 'repriced'
+                  } else if (
+                    replacementTransaction.from === replacementTransaction.to &&
+                    replacementTransaction.value === 0n
+                  ) {
+                    reason = 'cancelled'
+                  }
+
+                  done(() => {
+                    emit.onReplaced?.({
+                      reason,
+                      replacedTransaction: replacedTransaction!,
+                      transaction: replacementTransaction,
+                      transactionReceipt: receipt,
+                    })
+                    emit.resolve(receipt)
                   })
-                  emit.resolve(receipt)
-                })
+                } catch (err_) {
+                  done(() => emit.reject(err_))
+                }
               } else {
                 done(() => emit.reject(err))
               }
             }
           },
         })
-        return unwatch
       },
     )
   })

package/src/actions/public/watchBlockNumber.ts

@@ -1,4 +1,4 @@
-import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { Chain } from '../../types/chain.js'
 import type { GetTransportConfig } from '../../types/transport.js'
@@ -69,7 +69,7 @@ export type WatchBlockNumberReturnType = () => void
  *   chain: mainnet,
  *   transport: http(),
  * })
- * const unwatch = await watchBlockNumber(client, {
+ * const unwatch = watchBlockNumber(client, {
  *   onBlockNumber: (blockNumber) => console.log(blockNumber),
  * })
  */
@@ -77,7 +77,7 @@ export function watchBlockNumber<
   TChain extends Chain | undefined,
   TTransport extends Transport,
 >(
-  client: PublicClient<TTransport, TChain>,
+  client: Client<TTransport, TChain>,
   {
     emitOnBegin = false,
     emitMissed = false,
@@ -105,7 +105,7 @@ export function watchBlockNumber<
       poll(
         async () => {
           try {
-            const blockNumber = await getBlockNumber(client, { maxAge: 0 })
+            const blockNumber = await getBlockNumber(client, { cacheTime: 0 })
 
             if (prevBlockNumber) {
               // If the current block number is the same as the previous,

package/src/actions/public/watchBlocks.ts

@@ -1,31 +1,44 @@
-import type { PublicClient } from '../../clients/createPublicClient.js'
+import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { BlockTag } from '../../types/block.js'
 import type { Chain } from '../../types/chain.js'
 import type { GetTransportConfig } from '../../types/transport.js'
+import { formatBlock } from '../../utils/formatters/block.js'
 import { observe } from '../../utils/observe.js'
 import { poll } from '../../utils/poll.js'
 import { stringify } from '../../utils/stringify.js'
 
 import { type GetBlockReturnType, getBlock } from './getBlock.js'
 
-export type OnBlockParameter<TChain extends Chain | undefined = Chain> =
-  GetBlockReturnType<TChain>
+export type OnBlockParameter<
+  TChain extends Chain | undefined = Chain,
+  TIncludeTransactions extends boolean = false,
+  TBlockTag extends BlockTag = 'latest',
+> = GetBlockReturnType<TChain, TIncludeTransactions, TBlockTag>
 
-export type OnBlock<TChain extends Chain | undefined = Chain> = (
-  block: OnBlockParameter<TChain>,
-  prevBlock: OnBlockParameter<TChain> | undefined,
+export type OnBlock<
+  TChain extends Chain | undefined = Chain,
+  TIncludeTransactions extends boolean = false,
+  TBlockTag extends BlockTag = 'latest',
+> = (
+  block: OnBlockParameter<TChain, TIncludeTransactions, TBlockTag>,
+  prevBlock:
+    | OnBlockParameter<TChain, TIncludeTransactions, TBlockTag>
+    | undefined,
 ) => void
 
-type PollOptions = {
+type PollOptions<
+  TIncludeTransactions extends boolean = false,
+  TBlockTag extends BlockTag = 'latest',
+> = {
   /** The block tag. Defaults to "latest". */
-  blockTag?: BlockTag
+  blockTag?: TBlockTag | BlockTag
   /** Whether or not to emit the missed blocks to the callback. */
   emitMissed?: boolean
   /** Whether or not to emit the block to the callback when the subscription opens. */
   emitOnBegin?: boolean
   /** Whether or not to include transaction data in the response. */
-  includeTransactions?: boolean
+  includeTransactions?: TIncludeTransactions
   /** Polling frequency (in ms). Defaults to the client's pollingInterval config. */
   pollingInterval?: number
 }
@@ -33,9 +46,11 @@ type PollOptions = {
 export type WatchBlocksParameters<
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain,
+  TIncludeTransactions extends boolean = false,
+  TBlockTag extends BlockTag = 'latest',
 > = {
   /** The callback to call when a new block is received. */
-  onBlock: OnBlock<TChain>
+  onBlock: OnBlock<TChain, TIncludeTransactions, TBlockTag>
   /** The callback to call when an error occurred when trying to get for a new block. */
   onError?: (error: Error) => void
 } & (GetTransportConfig<TTransport>['type'] extends 'webSocket'
@@ -49,8 +64,8 @@ export type WatchBlocksParameters<
           poll?: false
           pollingInterval?: never
         }
-      | (PollOptions & { poll?: true })
-  : PollOptions & { poll?: true })
+      | (PollOptions<TIncludeTransactions, TBlockTag> & { poll?: true })
+  : PollOptions<TIncludeTransactions, TBlockTag> & { poll?: true })
 
 export type WatchBlocksReturnType = () => void
 
@@ -75,30 +90,35 @@ export type WatchBlocksReturnType = () => void
  *   chain: mainnet,
  *   transport: http(),
  * })
- * const unwatch = await watchBlocks(client, {
+ * const unwatch = watchBlocks(client, {
  *   onBlock: (block) => console.log(block),
  * })
  */
 export function watchBlocks<
   TTransport extends Transport,
   TChain extends Chain | undefined,
+  TIncludeTransactions extends boolean = false,
+  TBlockTag extends BlockTag = 'latest',
 >(
-  client: PublicClient<TTransport, TChain>,
+  client: Client<TTransport, TChain>,
   {
     blockTag = 'latest',
     emitMissed = false,
     emitOnBegin = false,
     onBlock,
     onError,
-    includeTransactions = false,
+    includeTransactions: includeTransactions_,
     poll: poll_,
     pollingInterval = client.pollingInterval,
-  }: WatchBlocksParameters<TTransport, TChain>,
+  }: WatchBlocksParameters<TTransport, TChain, TIncludeTransactions, TBlockTag>,
 ): WatchBlocksReturnType {
   const enablePolling =
     typeof poll_ !== 'undefined' ? poll_ : client.transport.type !== 'webSocket'
+  const includeTransactions = includeTransactions_ ?? false
 
-  let prevBlock: GetBlockReturnType<TChain> | undefined
+  let prevBlock:
+    | GetBlockReturnType<TChain, false | TIncludeTransactions, 'latest'>
+    | undefined
 
   const pollBlocks = () => {
     const observerId = stringify([
@@ -131,7 +151,7 @@ export function watchBlocks<
                     blockNumber: i,
                     includeTransactions,
                   })
-                  emit.onBlock(block, prevBlock)
+                  emit.onBlock(block as any, prevBlock as any)
                   prevBlock = block
                 }
               }
@@ -146,8 +166,8 @@ export function watchBlocks<
               // We don't want to emit blocks in the past.
               (block.number && block.number > prevBlock.number)
             ) {
-              emit.onBlock(block, prevBlock)
-              prevBlock = block
+              emit.onBlock(block as any, prevBlock as any)
+              prevBlock = block as any
             }
           } catch (err) {
             emit.onError?.(err as Error)
@@ -170,8 +190,10 @@ export function watchBlocks<
           params: ['newHeads'],
           onData(data: any) {
             if (!active) return
-            const block = data.result
-            onBlock(block, prevBlock)
+            const format =
+              client.chain?.formatters?.block?.format || formatBlock
+            const block = format(data.result)
+            onBlock(block, prevBlock as any)
             prevBlock = block
           },
           onError(error: Error) {