viem 2.49.2 → 2.50.3

package/utils/nonceManager.ts

@@ -50,6 +50,10 @@ export function createNonceManager(
 
   const getKey = ({ address, chainId }: FunctionParameters) =>
     `${address}.${chainId}`
+  const resetCache = (key: string) => {
+    deltaMap.delete(key)
+    promiseMap.delete(key)
+  }
 
   return {
     async consume({ address, chainId, client }) {
@@ -83,7 +87,7 @@ export function createNonceManager(
             nonceMap.delete(key)
             return nonce
           } finally {
-            this.reset({ address, chainId })
+            resetCache(key)
           }
         })()
         promiseMap.set(key, promise)
@@ -94,8 +98,8 @@ export function createNonceManager(
     },
     reset({ address, chainId }) {
       const key = getKey({ address, chainId })
-      deltaMap.delete(key)
-      promiseMap.delete(key)
+      nonceMap.delete(key)
+      resetCache(key)
     },
   }
 }

package/utils/observe.ts

@@ -39,10 +39,13 @@ export function observe<callbacks extends Callbacks>(
 
   const unsubscribe = () => {
     const listeners = getListeners()
-    listenersCache.set(
-      observerId,
-      listeners.filter((cb: any) => cb.id !== callbackId),
-    )
+    const nextListeners = listeners.filter((cb: any) => cb.id !== callbackId)
+    if (nextListeners.length === 0) {
+      listenersCache.delete(observerId)
+      cleanupCache.delete(observerId)
+      return
+    }
+    listenersCache.set(observerId, nextListeners)
   }
 
   const unwatch = () => {

package/utils/rpc/socket.ts

@@ -131,11 +131,13 @@ export async function getSocketRpcClient<socket extends {}>(
       let error: Error | Event | undefined
       let socket: Socket<{}>
       let keepAliveTimer: ReturnType<typeof setInterval> | undefined
+      let reconnectTimer: ReturnType<typeof setTimeout> | undefined
 
       let reconnectInProgress = false
+      let intentionallyClosed = false
       function attemptReconnect() {
         // Attempt to reconnect.
-        if (reconnect && reconnectCount < attempts) {
+        if (reconnect && !intentionallyClosed && reconnectCount < attempts) {
           if (reconnectInProgress) return
           reconnectInProgress = true
           reconnectCount++
@@ -143,7 +145,13 @@ export async function getSocketRpcClient<socket extends {}>(
           // Make sure the previous socket is definitely closed.
           socket?.close()
 
-          setTimeout(async () => {
+          reconnectTimer = setTimeout(async () => {
+            reconnectTimer = undefined
+            // Bail if the client was intentionally closed during the delay.
+            if (intentionallyClosed) {
+              reconnectInProgress = false
+              return
+            }
             // biome-ignore lint/suspicious/noConsole: _
             await setup().catch(console.error)
             reconnectInProgress = false
@@ -192,6 +200,11 @@ export async function getSocketRpcClient<socket extends {}>(
           },
         })
 
+        if (intentionallyClosed) {
+          result.close()
+          return result
+        }
+
         socket = result
 
         if (keepAlive) {
@@ -220,7 +233,13 @@ export async function getSocketRpcClient<socket extends {}>(
       // Create a new socket instance.
       socketClient = {
         close() {
+          intentionallyClosed = true
           keepAliveTimer && clearInterval(keepAliveTimer)
+          if (reconnectTimer) {
+            clearTimeout(reconnectTimer)
+            reconnectTimer = undefined
+            reconnectInProgress = false
+          }
           socket.close()
           socketClientCache.delete(id)
         },