viem 0.3.0-tsc-nodenext-2.20230407T050527 → 0.3.0

package/src/utils/errors/getNodeError.ts

@@ -1,5 +1,5 @@
 import type { SendTransactionParameters } from '../../actions/index.js'
-import type { BaseError } from '../../errors/index.js'
+import { RpcRequestError, type BaseError } from '../../errors/index.js'
 import {
   ExecutionRevertedError,
   FeeCapTooHighError,
@@ -11,7 +11,6 @@ import {
   NonceMaxValueError,
   NonceTooHighError,
   NonceTooLowError,
-  RpcError,
   TipAboveFeeCapError,
   TransactionRejectedRpcError,
   TransactionTypeNotSupportedError,
@@ -22,7 +21,7 @@ export function containsNodeError(err: BaseError) {
   return (
     err instanceof TransactionRejectedRpcError ||
     err instanceof InvalidInputRpcError ||
-    (err instanceof RpcError && err.code === ExecutionRevertedError.code)
+    (err instanceof RpcRequestError && err.code === ExecutionRevertedError.code)
   )
 }
 

package/src/utils/filters/createFilterRequestScope.ts

@@ -0,0 +1,42 @@
+import type { Chain } from '../../chains.js'
+import type { PublicClient, Transport } from '../../clients/index.js'
+import type { OnResponseFn } from '../../clients/transports/fallback.js'
+import type { Requests } from '../../types/eip1193.js'
+import type { Hex } from '../../types/index.js'
+
+type CreateFilterRequestScopeParameters = {
+  method:
+    | 'eth_newFilter'
+    | 'eth_newPendingTransactionFilter'
+    | 'eth_newBlockFilter'
+}
+// TODO: Narrow `request` to filter-based methods (ie. `eth_getFilterLogs`, etc).
+type CreateFilterRequestScopeReturnType = (id: Hex) => Requests['request']
+
+/**
+ * Scopes `request` to the filter ID. If the client is a fallback, it will
+ * listen for responses and scope the child transport `request` function
+ * to the successful filter ID.
+ */
+export function createFilterRequestScope<TChain extends Chain | undefined>(
+  client: PublicClient<Transport, TChain>,
+  { method }: CreateFilterRequestScopeParameters,
+): CreateFilterRequestScopeReturnType {
+  const requestMap: Record<Hex, PublicClient<Transport, TChain>['request']> = {}
+
+  if (client.transport.type === 'fallback')
+    client.transport.onResponse?.(
+      ({
+        method: method_,
+        response: id,
+        status,
+        transport,
+      }: Parameters<OnResponseFn>[0]) => {
+        if (status === 'success' && method === method_)
+          requestMap[id as Hex] = transport.request
+      },
+    )
+
+  return ((id) =>
+    requestMap[id] || client.request) as CreateFilterRequestScopeReturnType
+}

package/src/utils/rpc.ts

@@ -2,7 +2,7 @@ import WebSocket from 'isomorphic-ws'
 import type { MessageEvent } from 'isomorphic-ws'
 import {
   HttpRequestError,
-  RpcError,
+  RpcRequestError,
   TimeoutError,
   WebSocketRequestError,
 } from '../errors/index.js'
@@ -107,12 +107,12 @@ async function http(
     }
 
     if (data.error) {
-      throw new RpcError({ body, error: data.error, url })
+      throw new RpcRequestError({ body, error: data.error, url })
     }
     return data as RpcResponse
   } catch (err) {
     if (err instanceof HttpRequestError) throw err
-    if (err instanceof RpcError) throw err
+    if (err instanceof RpcRequestError) throw err
     if (err instanceof TimeoutError) throw err
     throw new HttpRequestError({
       body,
@@ -224,7 +224,9 @@ function webSocket(
     if (typeof message.id === 'number' && id_ !== message.id) return
 
     if (message.error) {
-      onError?.(new RpcError({ body, error: message.error, url: socket.url }))
+      onError?.(
+        new RpcRequestError({ body, error: message.error, url: socket.url }),
+      )
     } else {
       onData?.(message)
     }