viem 2.9.11 → 2.9.13

package/actions/public/watchContractEvent.ts

@@ -12,6 +12,7 @@ import {
 } from '../../errors/abi.js'
 import { InvalidInputRpcError } from '../../errors/rpc.js'
 import type { ErrorType } from '../../errors/utils.js'
+import type { BlockNumber } from '../../types/block.js'
 import type {
   ContractEventArgs,
   ContractEventName,
@@ -73,6 +74,8 @@ export type WatchContractEventParameters<
     | undefined
   /** Contract event. */
   eventName?: eventName | ContractEventName<abi> | undefined
+  /** Block to start listening from. */
+  fromBlock?: BlockNumber<bigint> | undefined
   /** The callback to call when an error occurred when trying to get for a new block. */
   onError?: ((error: Error) => void) | undefined
   /** The callback to call when new event logs are received. */
@@ -143,6 +146,7 @@ export function watchContractEvent<
     args,
     batch = true,
     eventName,
+    fromBlock,
     onError,
     onLogs,
     poll: poll_,
@@ -151,7 +155,9 @@ export function watchContractEvent<
   } = parameters
 
   const enablePolling =
-    typeof poll_ !== 'undefined' ? poll_ : client.transport.type !== 'webSocket'
+    typeof poll_ !== 'undefined'
+      ? poll_
+      : client.transport.type !== 'webSocket' || typeof fromBlock === 'number'
 
   const pollContractEvent = () => {
     const strict = strict_ ?? false
@@ -164,10 +170,12 @@ export function watchContractEvent<
       eventName,
       pollingInterval,
       strict,
+      fromBlock,
     ])
 
     return observe(observerId, { onLogs, onError }, (emit) => {
       let previousBlockNumber: bigint
+      if (fromBlock !== undefined) previousBlockNumber = fromBlock - 1n
       let filter: Filter<'event', abi, eventName> | undefined
       let initialized = false
 
@@ -185,6 +193,7 @@ export function watchContractEvent<
                 args: args as any,
                 eventName: eventName as any,
                 strict: strict as any,
+                fromBlock,
               })) as Filter<'event', abi, eventName>
             } catch {}
             initialized = true

package/actions/public/watchEvent.ts

@@ -22,6 +22,7 @@ import {
 } from '../../errors/abi.js'
 import { InvalidInputRpcError } from '../../errors/rpc.js'
 import type { ErrorType } from '../../errors/utils.js'
+import type { BlockNumber } from '../../types/block.js'
 import { getAction } from '../../utils/getAction.js'
 import {
   decodeEventLog,
@@ -70,6 +71,8 @@ export type WatchEventParameters<
 > = {
   /** The address of the contract. */
   address?: Address | Address[] | undefined
+  /** Block to start listening from. */
+  fromBlock?: BlockNumber<bigint> | undefined
   /** The callback to call when an error occurred when trying to get for a new block. */
   onError?: ((error: Error) => void) | undefined
   /** The callback to call when new event logs are received. */
@@ -161,6 +164,7 @@ export function watchEvent<
     batch = true,
     event,
     events,
+    fromBlock,
     onError,
     onLogs,
     poll: poll_,
@@ -169,7 +173,9 @@ export function watchEvent<
   }: WatchEventParameters<TAbiEvent, TAbiEvents, TStrict, TTransport>,
 ): WatchEventReturnType {
   const enablePolling =
-    typeof poll_ !== 'undefined' ? poll_ : client.transport.type !== 'webSocket'
+    typeof poll_ !== 'undefined'
+      ? poll_
+      : client.transport.type !== 'webSocket' || typeof fromBlock === 'bigint'
   const strict = strict_ ?? false
 
   const pollEvent = () => {
@@ -181,10 +187,12 @@ export function watchEvent<
       client.uid,
       event,
       pollingInterval,
+      fromBlock,
     ])
 
     return observe(observerId, { onLogs, onError }, (emit) => {
       let previousBlockNumber: bigint
+      if (fromBlock !== undefined) previousBlockNumber = fromBlock - 1n
       let filter: Filter<'event', TAbiEvents, _EventName, any>
       let initialized = false
 
@@ -202,6 +210,7 @@ export function watchEvent<
                 event: event!,
                 events,
                 strict,
+                fromBlock,
               } as unknown as CreateEventFilterParameters)) as unknown as Filter<
                 'event',
                 TAbiEvents,

package/clients/transports/ipc.ts

@@ -3,7 +3,11 @@ import { type UrlRequiredErrorType } from '../../errors/transport.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type { Hash } from '../../types/misc.js'
 import type { RpcResponse } from '../../types/rpc.js'
-import { type IpcRpcClient, getIpcRpcClient } from '../../utils/rpc/ipc.js'
+import {
+  type GetIpcRpcClientOptions,
+  type IpcRpcClient,
+  getIpcRpcClient,
+} from '../../utils/rpc/ipc.js'
 import {
   type CreateTransportErrorType,
   type Transport,
@@ -38,6 +42,11 @@ export type IpcTransportConfig = {
   key?: TransportConfig['key'] | undefined
   /** The name of the Ipc transport. */
   name?: TransportConfig['name'] | undefined
+  /**
+   * Whether or not to attempt to reconnect on socket failure.
+   * @default true
+   */
+  reconnect?: GetIpcRpcClientOptions['reconnect'] | undefined
   /** The max number of times to retry. */
   retryCount?: TransportConfig['retryCount'] | undefined
   /** The base delay (in ms) between retries. */
@@ -66,7 +75,7 @@ export function ipc(
   path: string,
   config: IpcTransportConfig = {},
 ): IpcTransport {
-  const { key = 'ipc', name = 'IPC JSON-RPC', retryDelay } = config
+  const { key = 'ipc', name = 'IPC JSON-RPC', reconnect, retryDelay } = config
   return ({ retryCount: retryCount_, timeout: timeout_ }) => {
     const retryCount = config.retryCount ?? retryCount_
     const timeout = timeout_ ?? config.timeout ?? 10_000
@@ -76,7 +85,7 @@ export function ipc(
         name,
         async request({ method, params }) {
           const body = { method, params }
-          const rpcClient = await getIpcRpcClient(path)
+          const rpcClient = await getIpcRpcClient(path, { reconnect })
           const { error, result } = await rpcClient.requestAsync({
             body,
             timeout,

package/clients/transports/webSocket.ts

@@ -8,7 +8,10 @@ import type { Hash } from '../../types/misc.js'
 import type { RpcResponse } from '../../types/rpc.js'
 import { getSocket } from '../../utils/rpc/compat.js'
 import type { SocketRpcClient } from '../../utils/rpc/socket.js'
-import { getWebSocketRpcClient } from '../../utils/rpc/webSocket.js'
+import {
+  type GetWebSocketRpcClientOptions,
+  getWebSocketRpcClient,
+} from '../../utils/rpc/webSocket.js'
 import {
   type CreateTransportErrorType,
   type Transport,
@@ -43,6 +46,11 @@ export type WebSocketTransportConfig = {
   key?: TransportConfig['key'] | undefined
   /** The name of the WebSocket transport. */
   name?: TransportConfig['name'] | undefined
+  /**
+   * Whether or not to attempt to reconnect on socket failure.
+   * @default true
+   */
+  reconnect?: GetWebSocketRpcClientOptions['reconnect'] | undefined
   /** The max number of times to retry. */
   retryCount?: TransportConfig['retryCount'] | undefined
   /** The base delay (in ms) between retries. */
@@ -76,7 +84,12 @@ export function webSocket(
   url?: string,
   config: WebSocketTransportConfig = {},
 ): WebSocketTransport {
-  const { key = 'webSocket', name = 'WebSocket JSON-RPC', retryDelay } = config
+  const {
+    key = 'webSocket',
+    name = 'WebSocket JSON-RPC',
+    reconnect,
+    retryDelay,
+  } = config
   return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
     const retryCount = config.retryCount ?? retryCount_
     const timeout = timeout_ ?? config.timeout ?? 10_000
@@ -88,7 +101,7 @@ export function webSocket(
         name,
         async request({ method, params }) {
           const body = { method, params }
-          const rpcClient = await getWebSocketRpcClient(url_)
+          const rpcClient = await getWebSocketRpcClient(url_, { reconnect })
           const { error, result } = await rpcClient.requestAsync({
             body,
             timeout,

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.9.11'
+export const version = '2.9.13'

package/package.json

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

package/utils/abi/decodeEventLog.ts

@@ -139,7 +139,7 @@ export function decodeEventLog<
         abiItem,
         param: param as AbiParameter & { indexed: boolean },
       })
-    args[param.name || i] = decodeTopic({ param, value: topic })
+    args[isUnnamed ? i : param.name || i] = decodeTopic({ param, value: topic })
   }
 
   // Decode data (non-indexed args).

package/utils/rpc/ipc.ts

@@ -1,11 +1,17 @@
 import { type Socket as NetSocket, connect } from 'node:net'
 import { WebSocketRequestError } from '../../index.js'
 import {
+  type GetSocketRpcClientParameters,
   type Socket,
   type SocketRpcClient,
   getSocketRpcClient,
 } from './socket.js'
 
+export type GetIpcRpcClientOptions = Pick<
+  GetSocketRpcClientParameters,
+  'reconnect'
+>
+
 const openingBrace = '{'.charCodeAt(0)
 const closingBrace = '}'.charCodeAt(0)
 
@@ -33,14 +39,21 @@ export function extractMessages(buffer: Buffer): [Buffer[], Buffer] {
 
 export type IpcRpcClient = SocketRpcClient<NetSocket>
 
-export async function getIpcRpcClient(path: string): Promise<IpcRpcClient> {
+export async function getIpcRpcClient(
+  path: string,
+  options: GetIpcRpcClientOptions = {},
+): Promise<IpcRpcClient> {
+  const { reconnect } = options
+
   return getSocketRpcClient({
-    async getSocket({ onResponse }) {
+    async getSocket({ onError, onOpen, onResponse }) {
       const socket = connect(path)
 
       function onClose() {
         socket.off('close', onClose)
         socket.off('message', onData)
+        socket.off('error', onError)
+        socket.off('connect', onOpen)
       }
 
       let lastRemaining = Buffer.alloc(0)
@@ -57,6 +70,8 @@ export async function getIpcRpcClient(path: string): Promise<IpcRpcClient> {
 
       socket.on('close', onClose)
       socket.on('data', onData)
+      socket.on('error', onError)
+      socket.on('connect', onOpen)
 
       // Wait for the socket to open.
       await new Promise<void>((resolve, reject) => {
@@ -84,6 +99,7 @@ export async function getIpcRpcClient(path: string): Promise<IpcRpcClient> {
         },
       } as Socket<{}>)
     },
+    reconnect,
     url: path,
   })
 }

package/utils/rpc/socket.ts

@@ -9,10 +9,15 @@ import { withTimeout } from '../promise/withTimeout.js'
 import { idCache } from './id.js'
 
 type Id = string | number
-type CallbackFn = (message: any) => void
+type CallbackFn = {
+  onResponse: (message: any) => void
+  onError?: ((error?: Error | Event | undefined) => void) | undefined
+}
 type CallbackMap = Map<Id, CallbackFn>
 
 export type GetSocketParameters = {
+  onError: (error?: Error | Event | undefined) => void
+  onOpen: () => void
   onResponse: (data: RpcResponse) => void
 }
 
@@ -28,7 +33,7 @@ export type SocketRpcClient<socket extends {}> = {
   socket: Socket<socket>
   request(params: {
     body: RpcRequest
-    onError?: ((error: Error) => void) | undefined
+    onError?: ((error?: Error | Event | undefined) => void) | undefined
     onResponse: (message: RpcResponse) => void
   }): void
   requestAsync(params: {
@@ -40,9 +45,28 @@ export type SocketRpcClient<socket extends {}> = {
   url: string
 }
 
-export type GetSocketRpcClientParameters<socket extends {}> = {
-  url: string
+export type GetSocketRpcClientParameters<socket extends {} = {}> = {
   getSocket(params: GetSocketParameters): Promise<Socket<socket>>
+  /**
+   * Whether or not to attempt to reconnect on socket failure.
+   * @default true
+   */
+  reconnect?:
+    | boolean
+    | {
+        /**
+         * The maximum number of reconnection attempts.
+         * @default 5
+         */
+        attempts?: number | undefined
+        /**
+         * The delay (in ms) between reconnection attempts.
+         * @default 2_000
+         */
+        delay?: number | undefined
+      }
+    | undefined
+  url: string
 }
 
 export type GetSocketRpcClientErrorType =
@@ -57,13 +81,16 @@ export const socketClientCache = /*#__PURE__*/ new Map<
 export async function getSocketRpcClient<socket extends {}>(
   params: GetSocketRpcClientParameters<socket>,
 ): Promise<SocketRpcClient<socket>> {
-  const { getSocket, url } = params
+  const { getSocket, reconnect = true, url } = params
+  const { attempts = 5, delay = 2_000 } =
+    typeof reconnect === 'object' ? reconnect : {}
 
   let socketClient = socketClientCache.get(url)
 
   // If the socket already exists, return it.
   if (socketClient) return socketClient as {} as SocketRpcClient<socket>
 
+  let reconnectCount = 0
   const { schedule } = createBatchScheduler<
     undefined,
     [SocketRpcClient<socket>]
@@ -76,17 +103,46 @@ export async function getSocketRpcClient<socket extends {}>(
       // Set up a cache for subscriptions (eth_subscribe).
       const subscriptions = new Map<Id, CallbackFn>()
 
+      let error: Error | Event | undefined
+      let socket: Socket<any>
       // Set up socket implementation.
-      const socket = await getSocket({
-        onResponse(data) {
-          const isSubscription = data.method === 'eth_subscription'
-          const id = isSubscription ? data.params.subscription : data.id
-          const cache = isSubscription ? subscriptions : requests
-          const callback = cache.get(id)
-          if (callback) callback(data)
-          if (!isSubscription) cache.delete(id)
-        },
-      })
+      async function setup() {
+        return getSocket({
+          onError(error_) {
+            error = error_
+
+            // Notify all requests and subscriptions of the error.
+            for (const request of requests.values()) request.onError?.(error)
+            for (const subscription of subscriptions.values())
+              subscription.onError?.(error)
+
+            // Clear all requests and subscriptions.
+            requests.clear()
+            subscriptions.clear()
+
+            // Attempt to reconnect.
+            if (reconnect && reconnectCount < attempts)
+              setTimeout(async () => {
+                reconnectCount++
+                socket = await setup().catch(console.error)
+              }, delay)
+          },
+          onOpen() {
+            error = undefined
+            reconnectCount = 0
+          },
+          onResponse(data) {
+            const isSubscription = data.method === 'eth_subscription'
+            const id = isSubscription ? data.params.subscription : data.id
+            const cache = isSubscription ? subscriptions : requests
+            const callback = cache.get(id)
+            if (callback) callback.onResponse(data)
+            if (!isSubscription) cache.delete(id)
+          },
+        })
+      }
+      socket = await setup()
+      error = undefined
 
       // Create a new socket instance.
       socketClient = {
@@ -96,6 +152,8 @@ export async function getSocketRpcClient<socket extends {}>(
         },
         socket,
         request({ body, onError, onResponse }) {
+          if (error && onError) onError(error)
+
           const id = body.id ?? idCache.take()
 
           const callback = (response: RpcResponse) => {
@@ -107,18 +165,19 @@ export async function getSocketRpcClient<socket extends {}>(
               body.method === 'eth_subscribe' &&
               typeof response.result === 'string'
             )
-              subscriptions.set(response.result, callback)
+              subscriptions.set(response.result, {
+                onResponse: callback,
+                onError,
+              })
 
             // If we are unsubscribing from a topic, we want to remove the listener.
             if (body.method === 'eth_unsubscribe')
               subscriptions.delete(body.params?.[0])
 
             onResponse(response)
-
-            // TODO: delete request?
           }
 
-          requests.set(id, callback)
+          requests.set(id, { onResponse: callback, onError })
           try {
             socket.request({
               body: {

package/utils/rpc/webSocket.ts

@@ -2,22 +2,33 @@ import type { MessageEvent } from 'isows'
 
 import { WebSocketRequestError } from '../../errors/request.js'
 import {
+  type GetSocketRpcClientParameters,
   type Socket,
   type SocketRpcClient,
   getSocketRpcClient,
 } from './socket.js'
 
+export type GetWebSocketRpcClientOptions = Pick<
+  GetSocketRpcClientParameters,
+  'reconnect'
+>
+
 export async function getWebSocketRpcClient(
   url: string,
+  options: GetWebSocketRpcClientOptions | undefined = {},
 ): Promise<SocketRpcClient<WebSocket>> {
+  const { reconnect } = options
+
   return getSocketRpcClient({
-    async getSocket({ onResponse }) {
+    async getSocket({ onError, onOpen, onResponse }) {
       const WebSocket = await import('isows').then((module) => module.WebSocket)
       const socket = new WebSocket(url)
 
       function onClose() {
         socket.removeEventListener('close', onClose)
         socket.removeEventListener('message', onMessage)
+        socket.removeEventListener('error', onError)
+        socket.removeEventListener('open', onOpen)
       }
       function onMessage({ data }: MessageEvent) {
         onResponse(JSON.parse(data))
@@ -26,6 +37,8 @@ export async function getWebSocketRpcClient(
       // Setup event listeners for RPC & subscription responses.
       socket.addEventListener('close', onClose)
       socket.addEventListener('message', onMessage)
+      socket.addEventListener('error', onError)
+      socket.addEventListener('open', onOpen)
 
       // Wait for the socket to open.
       if (socket.readyState === WebSocket.CONNECTING) {
@@ -58,6 +71,7 @@ export async function getWebSocketRpcClient(
         },
       } as Socket<WebSocket>)
     },
+    reconnect,
     url,
   })
 }