viem 0.3.0-tsc-nodenext-2.20230407T050527 → 0.3.1

package/src/utils/buildRequest.ts

@@ -18,10 +18,23 @@ import {
   UnknownRpcError,
   UserRejectedRequestError,
 } from '../errors/index.js'
+import {
+  ChainDisconnectedError,
+  ProviderDisconnectedError,
+  UnauthorizedProviderError,
+  UnsupportedProviderMethodError,
+} from '../errors/rpc.js'
 import { withRetry } from './promise/index.js'
 
 export const isDeterministicError = (error: Error) => {
-  if ('code' in error) return error.code !== -32603 && error.code !== -32005
+  if ('code' in error)
+    return (
+      error.code !== -1 &&
+      error.code !== -32004 &&
+      error.code !== -32005 &&
+      error.code !== -32042 &&
+      error.code !== -32603
+    )
   if (error instanceof HttpRequestError && error.status)
     return (
       error.status !== 408 &&
@@ -66,7 +79,12 @@ export function buildRequest<TRequest extends (args: any) => Promise<any>>(
           if (err.code === -32004) throw new MethodNotSupportedRpcError(err)
           if (err.code === -32005) throw new LimitExceededRpcError(err)
           if (err.code === -32006) throw new JsonRpcVersionUnsupportedError(err)
+          if (err.code === -32042) throw new MethodNotSupportedRpcError(err)
           if (err.code === 4001) throw new UserRejectedRequestError(err)
+          if (err.code === 4100) throw new UnauthorizedProviderError(err)
+          if (err.code === 4200) throw new UnsupportedProviderMethodError(err)
+          if (err.code === 4900) throw new ProviderDisconnectedError(err)
+          if (err.code === 4901) throw new ChainDisconnectedError(err)
           if (err.code === 4902) throw new SwitchChainError(err)
           if (err_ instanceof BaseError) throw err_
           throw new UnknownRpcError(err as Error)

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/index.ts

@@ -165,6 +165,8 @@ export type {
   RecoverAddressReturnType,
   RecoverMessageAddressParameters,
   RecoverMessageAddressReturnType,
+  RecoverPublicKeyParameters,
+  RecoverPublicKeyReturnType,
   RecoverTypedDataAddressParameters,
   RecoverTypedDataAddressReturnType,
   VerifyMessageParameters,
@@ -177,6 +179,7 @@ export {
   hashTypedData,
   recoverAddress,
   recoverMessageAddress,
+  recoverPublicKey,
   recoverTypedDataAddress,
   verifyMessage,
   verifyTypedData,

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

package/src/utils/signature/index.ts

@@ -18,6 +18,12 @@ export type {
 } from './recoverMessageAddress.js'
 export { recoverMessageAddress } from './recoverMessageAddress.js'
 
+export type {
+  RecoverPublicKeyParameters,
+  RecoverPublicKeyReturnType,
+} from './recoverPublicKey.js'
+export { recoverPublicKey } from './recoverPublicKey.js'
+
 export type {
   RecoverTypedDataAddressParameters,
   RecoverTypedDataAddressReturnType,

package/src/utils/signature/recoverAddress.ts

@@ -1,7 +1,6 @@
 import type { Address, ByteArray, Hex } from '../../types/index.js'
 import { publicKeyToAddress } from '../accounts.js'
-import { isHex } from '../data/index.js'
-import { hexToNumber, toHex } from '../encoding/index.js'
+import { recoverPublicKey } from './recoverPublicKey.js'
 
 export type RecoverAddressParameters = {
   hash: Hex | ByteArray
@@ -13,19 +12,5 @@ export async function recoverAddress({
   hash,
   signature,
 }: RecoverAddressParameters): Promise<RecoverAddressReturnType> {
-  const signatureHex = isHex(signature) ? signature : toHex(signature)
-  const hashHex = isHex(hash) ? hash : toHex(hash)
-
-  // Derive v = recoveryId + 27 from end of the signature (27 is added when signing the message)
-  // The recoveryId represents the y-coordinate on the secp256k1 elliptic curve and can have a value [0, 1].
-  const v = hexToNumber(`0x${signatureHex.slice(130)}`)
-
-  const { secp256k1 } = await import('@noble/curves/secp256k1')
-  const publicKey = secp256k1.Signature.fromCompact(
-    signatureHex.substring(2, 130),
-  )
-    .addRecoveryBit(v - 27)
-    .recoverPublicKey(hashHex.substring(2))
-    .toHex(false)
-  return publicKeyToAddress(`0x${publicKey}`)
+  return publicKeyToAddress(await recoverPublicKey({ hash: hash, signature }))
 }

package/src/utils/signature/recoverPublicKey.ts

@@ -0,0 +1,30 @@
+import type { ByteArray, Hex } from '../../types/index.js'
+import { isHex } from '../data/index.js'
+import { hexToNumber, toHex } from '../encoding/index.js'
+
+export type RecoverPublicKeyParameters = {
+  hash: Hex | ByteArray
+  signature: Hex | ByteArray
+}
+export type RecoverPublicKeyReturnType = Hex
+
+export async function recoverPublicKey({
+  hash,
+  signature,
+}: RecoverPublicKeyParameters): Promise<RecoverPublicKeyReturnType> {
+  const signatureHex = isHex(signature) ? signature : toHex(signature)
+  const hashHex = isHex(hash) ? hash : toHex(hash)
+
+  // Derive v = recoveryId + 27 from end of the signature (27 is added when signing the message)
+  // The recoveryId represents the y-coordinate on the secp256k1 elliptic curve and can have a value [0, 1].
+  const v = hexToNumber(`0x${signatureHex.slice(130)}`)
+
+  const { secp256k1 } = await import('@noble/curves/secp256k1')
+  const publicKey = secp256k1.Signature.fromCompact(
+    signatureHex.substring(2, 130),
+  )
+    .addRecoveryBit(v - 27)
+    .recoverPublicKey(hashHex.substring(2))
+    .toHex(false)
+  return `0x${publicKey}`
+}