viem 2.18.1 → 2.18.4

package/errors/base.ts

@@ -15,13 +15,11 @@ export class BaseError extends Error {
   docsPath?: string | undefined
   metaMessages?: string[] | undefined
   shortMessage: string
+  version: string
 
   override name = 'ViemError'
-  version = getVersion()
 
   constructor(shortMessage: string, args: BaseErrorParameters = {}) {
-    super()
-
     const details =
       args.cause instanceof BaseError
         ? args.cause.details
@@ -32,8 +30,9 @@ export class BaseError extends Error {
       args.cause instanceof BaseError
         ? args.cause.docsPath || args.docsPath
         : args.docsPath
+    const version = getVersion()
 
-    this.message = [
+    const message = [
       shortMessage || 'An error occurred.',
       '',
       ...(args.metaMessages ? [...args.metaMessages, ''] : []),
@@ -45,14 +44,16 @@ export class BaseError extends Error {
           ]
         : []),
       ...(details ? [`Details: ${details}`] : []),
-      `Version: ${this.version}`,
+      `Version: ${version}`,
     ].join('\n')
 
-    if (args.cause) this.cause = args.cause
+    super(message, args.cause ? { cause: args.cause } : undefined)
+
     this.details = details
     this.docsPath = docsPath
     this.metaMessages = args.metaMessages
     this.shortMessage = shortMessage
+    this.version = version
   }
 
   walk(): Error

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.18.1'
+export const version = '2.18.4'

package/package.json

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

package/utils/rpc/socket.ts

@@ -16,6 +16,7 @@ type CallbackFn = {
 type CallbackMap = Map<Id, CallbackFn>
 
 export type GetSocketParameters = {
+  onClose: () => void
   onError: (error?: Error | Event | undefined) => void
   onOpen: () => void
   onResponse: (data: RpcResponse) => void
@@ -23,9 +24,8 @@ export type GetSocketParameters = {
 
 export type Socket<socket extends {}> = socket & {
   close(): void
-  request(params: {
-    body: RpcRequest
-  }): void
+  ping?: (() => void) | undefined
+  request(params: { body: RpcRequest }): void
 }
 
 export type SocketRpcClient<socket extends {}> = {
@@ -47,9 +47,23 @@ export type SocketRpcClient<socket extends {}> = {
 
 export type GetSocketRpcClientParameters<socket extends {} = {}> = {
   getSocket(params: GetSocketParameters): Promise<Socket<socket>>
+  /**
+   * Whether or not to send keep-alive messages.
+   * @default true
+   */
+  keepAlive?:
+    | boolean
+    | {
+        /**
+         * The interval (in ms) to send keep-alive messages.
+         * @default 30_000
+         */
+        interval?: number | undefined
+      }
+    | undefined
   key?: string
   /**
-   * Whether or not to attempt to reconnect on socket failure.
+   * Whether or not to attempt to reconnect on socket failure or closure.
    * @default true
    */
   reconnect?:
@@ -80,9 +94,17 @@ export const socketClientCache = /*#__PURE__*/ new Map<
 >()
 
 export async function getSocketRpcClient<socket extends {}>(
-  params: GetSocketRpcClientParameters<socket>,
+  parameters: GetSocketRpcClientParameters<socket>,
 ): Promise<SocketRpcClient<socket>> {
-  const { getSocket, key = 'socket', reconnect = true, url } = params
+  const {
+    getSocket,
+    keepAlive = true,
+    key = 'socket',
+    reconnect = true,
+    url,
+  } = parameters
+  const { interval: keepAliveInterval = 30_000 } =
+    typeof keepAlive === 'object' ? keepAlive : {}
   const { attempts = 5, delay = 2_000 } =
     typeof reconnect === 'object' ? reconnect : {}
 
@@ -105,10 +127,24 @@ export async function getSocketRpcClient<socket extends {}>(
       const subscriptions = new Map<Id, CallbackFn>()
 
       let error: Error | Event | undefined
-      let socket: Socket<any>
+      let socket: Socket<{}>
+      let keepAliveTimer: Timer | undefined
+
       // Set up socket implementation.
       async function setup() {
-        return getSocket({
+        const result = await getSocket({
+          onClose() {
+            // Clear all requests and subscriptions.
+            requests.clear()
+            subscriptions.clear()
+
+            // Attempt to reconnect.
+            if (reconnect && reconnectCount < attempts)
+              setTimeout(async () => {
+                reconnectCount++
+                await setup().catch(console.error)
+              }, delay)
+          },
           onError(error_) {
             error = error_
 
@@ -125,7 +161,7 @@ export async function getSocketRpcClient<socket extends {}>(
             if (reconnect && reconnectCount < attempts)
               setTimeout(async () => {
                 reconnectCount++
-                socket = await setup().catch(console.error)
+                await setup().catch(console.error)
               }, delay)
           },
           onOpen() {
@@ -141,17 +177,29 @@ export async function getSocketRpcClient<socket extends {}>(
             if (!isSubscription) cache.delete(id)
           },
         })
+
+        socket = result
+
+        if (keepAlive) {
+          if (keepAliveTimer) clearInterval(keepAliveTimer)
+          keepAliveTimer = setInterval(() => socket.ping?.(), keepAliveInterval)
+        }
+
+        return result
       }
-      socket = await setup()
+      await setup()
       error = undefined
 
       // Create a new socket instance.
       socketClient = {
         close() {
+          keepAliveTimer && clearInterval(keepAliveTimer)
           socket.close()
           socketClientCache.delete(`${key}:${url}`)
         },
-        socket,
+        get socket() {
+          return socket
+        },
         request({ body, onError, onResponse }) {
           if (error && onError) onError(error)
 

package/utils/rpc/webSocket.ts

@@ -10,22 +10,23 @@ import {
 
 export type GetWebSocketRpcClientOptions = Pick<
   GetSocketRpcClientParameters,
-  'reconnect'
+  'keepAlive' | 'reconnect'
 >
 
 export async function getWebSocketRpcClient(
   url: string,
   options: GetWebSocketRpcClientOptions | undefined = {},
 ): Promise<SocketRpcClient<WebSocket>> {
-  const { reconnect } = options
+  const { keepAlive, reconnect } = options
 
   return getSocketRpcClient({
-    async getSocket({ onError, onOpen, onResponse }) {
+    async getSocket({ onClose, onError, onOpen, onResponse }) {
       const WebSocket = await import('isows').then((module) => module.WebSocket)
       const socket = new WebSocket(url)
 
-      function onClose() {
-        socket.removeEventListener('close', onClose)
+      function onClose_() {
+        onClose()
+        socket.removeEventListener('close', onClose_)
         socket.removeEventListener('message', onMessage)
         socket.removeEventListener('error', onError)
         socket.removeEventListener('open', onOpen)
@@ -35,7 +36,7 @@ export async function getWebSocketRpcClient(
       }
 
       // Setup event listeners for RPC & subscription responses.
-      socket.addEventListener('close', onClose)
+      socket.addEventListener('close', onClose_)
       socket.addEventListener('message', onMessage)
       socket.addEventListener('error', onError)
       socket.addEventListener('open', onOpen)
@@ -56,6 +57,23 @@ export async function getWebSocketRpcClient(
           close_.bind(socket)()
           onClose()
         },
+        ping() {
+          try {
+            if (
+              socket.readyState === socket.CLOSED ||
+              socket.readyState === socket.CLOSING
+            )
+              throw new WebSocketRequestError({
+                body: {},
+                url: socket.url,
+                details: 'Socket is closed.',
+              })
+
+            socket.send('ping')
+          } catch (error) {
+            onError(error as Error)
+          }
+        },
         request({ body }) {
           if (
             socket.readyState === socket.CLOSED ||
@@ -71,6 +89,7 @@ export async function getWebSocketRpcClient(
         },
       } as Socket<WebSocket>)
     },
+    keepAlive,
     reconnect,
     url,
   })