viem 2.49.3 → 2.50.4

package/utils/ccipTunnel.ts

@@ -0,0 +1,67 @@
+import { batchGatewayAbi } from '../constants/abis.js'
+import { solidityError } from '../constants/solidity.js'
+import { HttpRequestError } from '../errors/request.js'
+import { decodeErrorResult } from './abi/decodeErrorResult.js'
+import { decodeFunctionResult } from './abi/decodeFunctionResult.js'
+import { encodeFunctionData } from './abi/encodeFunctionData.js'
+import { ccipRequest as ccipRequest_ } from './ccip.js'
+import { localBatchGatewayUrl } from './ens/localBatchGatewayRequest.js'
+
+export type CcipReadTunnelParameters = {
+  batchGateways: string[]
+  ccipRequest?: typeof ccipRequest_
+}
+
+export function ccipReadTunnel({
+  batchGateways,
+  ccipRequest = ccipRequest_,
+}: CcipReadTunnelParameters): { request: typeof ccipRequest_ } {
+  return {
+    async request({ data, sender, urls }) {
+      if (urls.includes(localBatchGatewayUrl)) {
+        return ccipRequest({
+          data,
+          sender,
+          urls: batchGateways,
+        })
+      } else {
+        const [failures, responses] = decodeFunctionResult({
+          abi: batchGatewayAbi,
+          functionName: 'query',
+          data: await ccipRequest({
+            data: encodeFunctionData({
+              abi: batchGatewayAbi,
+              functionName: 'query',
+              args: [[{ sender, data, urls }]],
+            }),
+            sender,
+            urls: batchGateways,
+          }),
+        })
+        if (failures[0]) {
+          let error: Error | undefined
+          try {
+            const res = decodeErrorResult({
+              abi: [...batchGatewayAbi, solidityError],
+              data: responses[0],
+            })
+            if (res.errorName === 'HttpError') {
+              error = new HttpRequestError({
+                body: { message: res.args[1] },
+                status: res.args[0],
+                url: urls.join(' | '),
+              })
+            } else {
+              const message = res.args[0]
+              if (message) {
+                error = new Error(message)
+              }
+            }
+          } catch {}
+          throw error ?? new Error('An unknown error occurred.')
+        }
+        return responses[0]
+      }
+    },
+  }
+}

package/utils/index.ts

@@ -155,6 +155,10 @@ export {
   offchainLookupAbiItem,
   offchainLookupSignature,
 } from './ccip.js'
+export {
+  type CcipReadTunnelParameters,
+  ccipReadTunnel,
+} from './ccipTunnel.js'
 export {
   type AssertCurrentChainErrorType,
   type AssertCurrentChainParameters,

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)
         },