viem 2.32.0 → 2.33.0

package/actions/public/waitForTransactionReceipt.ts

@@ -53,6 +53,11 @@ export type WaitForTransactionReceiptReturnType<
 export type WaitForTransactionReceiptParameters<
   chain extends Chain | undefined = Chain | undefined,
 > = {
+  /**
+   * Whether to check for transaction replacements.
+   * @default true
+   */
+  checkReplacement?: boolean | undefined
   /**
    * The number of confirmations (blocks that have passed) to wait before resolving.
    * @default 1
@@ -135,21 +140,30 @@ export async function waitForTransactionReceipt<
   chain extends Chain | undefined,
 >(
   client: Client<Transport, chain>,
-  {
+  parameters: WaitForTransactionReceiptParameters<chain>,
+): Promise<WaitForTransactionReceiptReturnType<chain>> {
+  const {
+    checkReplacement = true,
     confirmations = 1,
     hash,
     onReplaced,
-    pollingInterval = client.pollingInterval,
     retryCount = 6,
     retryDelay = ({ count }) => ~~(1 << count) * 200, // exponential backoff
     timeout = 180_000,
-  }: WaitForTransactionReceiptParameters<chain>,
-): Promise<WaitForTransactionReceiptReturnType<chain>> {
+  } = parameters
+
   const observerId = stringify(['waitForTransactionReceipt', client.uid, hash])
 
+  const pollingInterval = (() => {
+    if (parameters.pollingInterval) return parameters.pollingInterval
+    if (client.chain?.experimental_preconfirmationTime)
+      return client.chain.experimental_preconfirmationTime
+    return client.pollingInterval
+  })()
+
   let transaction: GetTransactionReturnType<chain> | undefined
   let replacedTransaction: GetTransactionReturnType<chain> | undefined
-  let receipt: GetTransactionReceiptReturnType<chain>
+  let receipt: GetTransactionReceiptReturnType<chain> | undefined
   let retrying = false
 
   // biome-ignore lint/style/useConst:
@@ -167,181 +181,198 @@ export async function waitForTransactionReceipt<
       }, timeout)
     : undefined
 
-  _unobserve = observe(observerId, { onReplaced, resolve, reject }, (emit) => {
-    _unwatch = getAction(
-      client,
-      watchBlockNumber,
-      'watchBlockNumber',
-    )({
-      emitMissed: true,
-      emitOnBegin: true,
-      poll: true,
-      pollingInterval,
-      async onBlockNumber(blockNumber_) {
-        const done = (fn: () => void) => {
-          clearTimeout(timer)
-          _unwatch()
-          fn()
-          _unobserve()
-        }
-
-        let blockNumber = blockNumber_
-
-        if (retrying) return
-
-        try {
-          // If we already have a valid receipt, let's check if we have enough
-          // confirmations. If we do, then we can resolve.
-          if (receipt) {
-            if (
-              confirmations > 1 &&
-              (!receipt.blockNumber ||
-                blockNumber - receipt.blockNumber + 1n < confirmations)
-            )
-              return
+  _unobserve = observe(
+    observerId,
+    { onReplaced, resolve, reject },
+    async (emit) => {
+      receipt = await getAction(
+        client,
+        getTransactionReceipt,
+        'getTransactionReceipt',
+      )({ hash }).catch(() => undefined)
 
-            done(() => emit.resolve(receipt))
-            return
-          }
+      if (receipt && confirmations <= 1) {
+        clearTimeout(timer)
+        emit.resolve(receipt)
+        _unobserve()
+        return
+      }
 
-          // Get the transaction to check if it's been replaced.
-          // We need to retry as some RPC Providers may be slow to sync
-          // up mined transactions.
-          if (!transaction) {
-            retrying = true
-            await withRetry(
-              async () => {
-                transaction = (await getAction(
-                  client,
-                  getTransaction,
-                  'getTransaction',
-                )({ hash })) as GetTransactionReturnType<chain>
-                if (transaction.blockNumber)
-                  blockNumber = transaction.blockNumber
-              },
-              {
-                delay: retryDelay,
-                retryCount,
-              },
-            )
-            retrying = false
+      _unwatch = getAction(
+        client,
+        watchBlockNumber,
+        'watchBlockNumber',
+      )({
+        emitMissed: true,
+        emitOnBegin: true,
+        poll: true,
+        pollingInterval,
+        async onBlockNumber(blockNumber_) {
+          const done = (fn: () => void) => {
+            clearTimeout(timer)
+            _unwatch()
+            fn()
+            _unobserve()
           }
 
-          // Get the receipt to check if it's been processed.
-          receipt = await getAction(
-            client,
-            getTransactionReceipt,
-            'getTransactionReceipt',
-          )({ hash })
-
-          // Check if we have enough confirmations. If not, continue polling.
-          if (
-            confirmations > 1 &&
-            (!receipt.blockNumber ||
-              blockNumber - receipt.blockNumber + 1n < confirmations)
-          )
-            return
-
-          done(() => emit.resolve(receipt))
-        } catch (err) {
-          // If the receipt is not found, the transaction will be pending.
-          // We need to check if it has potentially been replaced.
-          if (
-            err instanceof TransactionNotFoundError ||
-            err instanceof TransactionReceiptNotFoundError
-          ) {
-            if (!transaction) {
-              retrying = false
+          let blockNumber = blockNumber_
+
+          if (retrying) return
+
+          try {
+            // If we already have a valid receipt, let's check if we have enough
+            // confirmations. If we do, then we can resolve.
+            if (receipt) {
+              if (
+                confirmations > 1 &&
+                (!receipt.blockNumber ||
+                  blockNumber - receipt.blockNumber + 1n < confirmations)
+              )
+                return
+
+              done(() => emit.resolve(receipt!))
               return
             }
 
-            try {
-              replacedTransaction = transaction
-
-              // Let's retrieve the transactions from the current block.
-              // We need to retry as some RPC Providers may be slow to sync
-              // up mined blocks.
+            // Get the transaction to check if it's been replaced.
+            // We need to retry as some RPC Providers may be slow to sync
+            // up mined transactions.
+            if (checkReplacement && !transaction) {
               retrying = true
-              const block = await withRetry(
-                () =>
-                  getAction(
+              await withRetry(
+                async () => {
+                  transaction = (await getAction(
                     client,
-                    getBlock,
-                    'getBlock',
-                  )({
-                    blockNumber,
-                    includeTransactions: true,
-                  }),
+                    getTransaction,
+                    'getTransaction',
+                  )({ hash })) as GetTransactionReturnType<chain>
+                  if (transaction.blockNumber)
+                    blockNumber = transaction.blockNumber
+                },
                 {
                   delay: retryDelay,
                   retryCount,
-                  shouldRetry: ({ error }) =>
-                    error instanceof BlockNotFoundError,
                 },
               )
               retrying = false
+            }
 
-              const replacementTransaction = (
-                block.transactions as {} as Transaction[]
-              ).find(
-                ({ from, nonce }) =>
-                  from === replacedTransaction!.from &&
-                  nonce === replacedTransaction!.nonce,
-              )
-
-              // If we couldn't find a replacement transaction, continue polling.
-              if (!replacementTransaction) return
+            // Get the receipt to check if it's been processed.
+            receipt = await getAction(
+              client,
+              getTransactionReceipt,
+              'getTransactionReceipt',
+            )({ hash })
 
-              // If we found a replacement transaction, return it's receipt.
-              receipt = await getAction(
-                client,
-                getTransactionReceipt,
-                'getTransactionReceipt',
-              )({
-                hash: replacementTransaction.hash,
-              })
+            // Check if we have enough confirmations. If not, continue polling.
+            if (
+              confirmations > 1 &&
+              (!receipt.blockNumber ||
+                blockNumber - receipt.blockNumber + 1n < confirmations)
+            )
+              return
 
-              // Check if we have enough confirmations. If not, continue polling.
-              if (
-                confirmations > 1 &&
-                (!receipt.blockNumber ||
-                  blockNumber - receipt.blockNumber + 1n < confirmations)
-              )
+            done(() => emit.resolve(receipt!))
+          } catch (err) {
+            // If the receipt is not found, the transaction will be pending.
+            // We need to check if it has potentially been replaced.
+            if (
+              err instanceof TransactionNotFoundError ||
+              err instanceof TransactionReceiptNotFoundError
+            ) {
+              if (!transaction) {
+                retrying = false
                 return
-
-              let reason: ReplacementReason = 'replaced'
-              if (
-                replacementTransaction.to === replacedTransaction.to &&
-                replacementTransaction.value === replacedTransaction.value &&
-                replacementTransaction.input === replacedTransaction.input
-              ) {
-                reason = 'repriced'
-              } else if (
-                replacementTransaction.from === replacementTransaction.to &&
-                replacementTransaction.value === 0n
-              ) {
-                reason = 'cancelled'
               }
 
-              done(() => {
-                emit.onReplaced?.({
-                  reason,
-                  replacedTransaction: replacedTransaction! as any,
-                  transaction: replacementTransaction,
-                  transactionReceipt: receipt,
+              try {
+                replacedTransaction = transaction
+
+                // Let's retrieve the transactions from the current block.
+                // We need to retry as some RPC Providers may be slow to sync
+                // up mined blocks.
+                retrying = true
+                const block = await withRetry(
+                  () =>
+                    getAction(
+                      client,
+                      getBlock,
+                      'getBlock',
+                    )({
+                      blockNumber,
+                      includeTransactions: true,
+                    }),
+                  {
+                    delay: retryDelay,
+                    retryCount,
+                    shouldRetry: ({ error }) =>
+                      error instanceof BlockNotFoundError,
+                  },
+                )
+                retrying = false
+
+                const replacementTransaction = (
+                  block.transactions as {} as Transaction[]
+                ).find(
+                  ({ from, nonce }) =>
+                    from === replacedTransaction!.from &&
+                    nonce === replacedTransaction!.nonce,
+                )
+
+                // If we couldn't find a replacement transaction, continue polling.
+                if (!replacementTransaction) return
+
+                // If we found a replacement transaction, return it's receipt.
+                receipt = await getAction(
+                  client,
+                  getTransactionReceipt,
+                  'getTransactionReceipt',
+                )({
+                  hash: replacementTransaction.hash,
+                })
+
+                // Check if we have enough confirmations. If not, continue polling.
+                if (
+                  confirmations > 1 &&
+                  (!receipt.blockNumber ||
+                    blockNumber - receipt.blockNumber + 1n < confirmations)
+                )
+                  return
+
+                let reason: ReplacementReason = 'replaced'
+                if (
+                  replacementTransaction.to === replacedTransaction.to &&
+                  replacementTransaction.value === replacedTransaction.value &&
+                  replacementTransaction.input === replacedTransaction.input
+                ) {
+                  reason = 'repriced'
+                } else if (
+                  replacementTransaction.from === replacementTransaction.to &&
+                  replacementTransaction.value === 0n
+                ) {
+                  reason = 'cancelled'
+                }
+
+                done(() => {
+                  emit.onReplaced?.({
+                    reason,
+                    replacedTransaction: replacedTransaction! as any,
+                    transaction: replacementTransaction,
+                    transactionReceipt: receipt!,
+                  })
+                  emit.resolve(receipt!)
                 })
-                emit.resolve(receipt)
-              })
-            } catch (err_) {
-              done(() => emit.reject(err_))
+              } catch (err_) {
+                done(() => emit.reject(err_))
+              }
+            } else {
+              done(() => emit.reject(err))
             }
-          } else {
-            done(() => emit.reject(err))
           }
-        }
-      },
-    })
-  })
+        },
+      })
+    },
+  )
 
   return promise
 }

package/actions/public/watchBlocks.ts

@@ -103,7 +103,7 @@ export function watchBlocks<
 >(
   client: Client<transport, chain>,
   {
-    blockTag = 'latest',
+    blockTag = client.experimental_blockTag ?? 'latest',
     emitMissed = false,
     emitOnBegin = false,
     onBlock,

package/chains/definitions/base.ts

@@ -51,3 +51,13 @@ export const base = /*#__PURE__*/ defineChain({
   },
   sourceId,
 })
+
+export const basePreconf = /*#__PURE__*/ defineChain({
+  ...base,
+  experimental_preconfirmationTime: 200,
+  rpcUrls: {
+    default: {
+      http: ['https://mainnet-preconf.base.org'],
+    },
+  },
+})

package/chains/definitions/baseSepolia.ts

@@ -53,3 +53,13 @@ export const baseSepolia = /*#__PURE__*/ defineChain({
   testnet: true,
   sourceId,
 })
+
+export const baseSepoliaPreconf = /*#__PURE__*/ defineChain({
+  ...baseSepolia,
+  experimental_preconfirmationTime: 200,
+  rpcUrls: {
+    default: {
+      http: ['https://sepolia-preconf.base.org'],
+    },
+  },
+})

package/chains/index.ts

@@ -41,10 +41,10 @@ export { avalancheFuji } from './definitions/avalancheFuji.js'
 export { b3 } from './definitions/b3.js'
 export { b3Sepolia } from './definitions/b3Sepolia.js'
 export { bahamut } from './definitions/bahamut.js'
-export { base } from './definitions/base.js'
+export { base, basePreconf } from './definitions/base.js'
 export { basecampTestnet } from './definitions/basecampTestnet.js'
 export { baseGoerli } from './definitions/baseGoerli.js'
-export { baseSepolia } from './definitions/baseSepolia.js'
+export { baseSepolia, baseSepoliaPreconf } from './definitions/baseSepolia.js'
 export { beam } from './definitions/beam.js'
 export { beamTestnet } from './definitions/beamTestnet.js'
 export { bearNetworkChainMainnet } from './definitions/bearNetworkChainMainnet.js'

package/clients/createClient.ts

@@ -7,6 +7,7 @@ import {
 } from '../accounts/utils/parseAccount.js'
 import type { ErrorType } from '../errors/utils.js'
 import type { Account } from '../types/account.js'
+import type { BlockTag } from '../types/block.js'
 import type { Chain } from '../types/chain.js'
 import type {
   EIP1193RequestFn,
@@ -41,6 +42,15 @@ export type ClientConfig<
         multicall?: boolean | Prettify<MulticallBatchOptions> | undefined
       }
     | undefined
+  /**
+   * Default block tag to use for RPC requests.
+   *
+   * If the chain supports a pre-confirmation mechanism
+   * (set via `chain.experimental_preconfirmationTime`), defaults to `'pending'`.
+   *
+   * @default 'latest'
+   */
+  experimental_blockTag?: BlockTag | undefined
   /**
    * Time (in ms) that cached data will remain in memory.
    * @default chain.blockTime / 3
@@ -161,6 +171,8 @@ type Client_Base<
   ccipRead?: ClientConfig['ccipRead'] | undefined
   /** Chain for the client. */
   chain: chain
+  /** Default block tag to use for RPC requests. */
+  experimental_blockTag?: BlockTag | undefined
   /** A key for the client. */
   key: string
   /** A name for the client. */
@@ -223,6 +235,11 @@ export function createClient(parameters: ClientConfig): Client {
     type = 'base',
   } = parameters
 
+  const experimental_blockTag =
+    parameters.experimental_blockTag ??
+    (typeof chain?.experimental_preconfirmationTime === 'number'
+      ? 'pending'
+      : undefined)
   const blockTime = chain?.blockTime ?? 12_000
 
   const defaultPollingInterval = Math.min(
@@ -254,6 +271,7 @@ export function createClient(parameters: ClientConfig): Client {
     transport,
     type,
     uid: uid(),
+    ...(experimental_blockTag ? { experimental_blockTag } : {}),
   }
 
   function extend(base: typeof client) {

package/clients/createPublicClient.ts

@@ -25,6 +25,7 @@ export type PublicClientConfig<
     | 'cacheTime'
     | 'ccipRead'
     | 'chain'
+    | 'experimental_blockTag'
     | 'key'
     | 'name'
     | 'pollingInterval'

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.32.0'
+export const version = '2.33.0'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.32.0",
+  "version": "2.33.0",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",

package/types/chain.ts

@@ -54,6 +54,8 @@ export type Chain<
   name: string
   /** Currency used by chain */
   nativeCurrency: ChainNativeCurrency
+  /** Preconfirmation time in milliseconds. */
+  experimental_preconfirmationTime?: number | undefined
   /** Collection of RPC endpoints */
   rpcUrls: {
     [key: string]: ChainRpcUrls

package/utils/rpc/socket.ts

@@ -132,6 +132,29 @@ export async function getSocketRpcClient<socket extends {}>(
       let socket: Socket<{}>
       let keepAliveTimer: ReturnType<typeof setInterval> | undefined
 
+      let reconnectInProgress = false
+      function attemptReconnect() {
+        // Attempt to reconnect.
+        if (reconnect && reconnectCount < attempts) {
+          if (reconnectInProgress) return
+          reconnectInProgress = true
+          reconnectCount++
+
+          // Make sure the previous socket is definitely closed.
+          socket?.close()
+
+          setTimeout(async () => {
+            await setup().catch(console.error)
+            reconnectInProgress = false
+          }, delay)
+        }
+        // Otherwise, clear all requests and subscriptions.
+        else {
+          requests.clear()
+          subscriptions.clear()
+        }
+      }
+
       // Set up socket implementation.
       async function setup() {
         const result = await getSocket({
@@ -142,17 +165,7 @@ export async function getSocketRpcClient<socket extends {}>(
             for (const subscription of subscriptions.values())
               subscription.onError?.(new SocketClosedError({ url }))
 
-            // Attempt to reconnect.
-            if (reconnect && reconnectCount < attempts)
-              setTimeout(async () => {
-                reconnectCount++
-                await setup().catch(console.error)
-              }, delay)
-            // Otherwise, clear all requests and subscriptions.
-            else {
-              requests.clear()
-              subscriptions.clear()
-            }
+            attemptReconnect()
           },
           onError(error_) {
             error = error_
@@ -162,20 +175,7 @@ export async function getSocketRpcClient<socket extends {}>(
             for (const subscription of subscriptions.values())
               subscription.onError?.(error)
 
-            // Make sure socket is definitely closed.
-            socketClient?.close()
-
-            // Attempt to reconnect.
-            if (reconnect && reconnectCount < attempts)
-              setTimeout(async () => {
-                reconnectCount++
-                await setup().catch(console.error)
-              }, delay)
-            // Otherwise, clear all requests and subscriptions.
-            else {
-              requests.clear()
-              subscriptions.clear()
-            }
+            attemptReconnect()
           },
           onOpen() {
             error = undefined