viem 0.0.0-portable-types-20230522163654 → 0.0.0-tmm-sign-typed-data-types.20230619T221425

package/src/clients/transports/http.ts

@@ -1,5 +1,7 @@
+import { RpcRequestError } from '../../errors/request.js'
 import { UrlRequiredError } from '../../errors/transport.js'
-import { type HttpOptions, rpc } from '../../utils/rpc.js'
+import { createBatchScheduler } from '../../utils/promise/createBatchScheduler.js'
+import { type HttpOptions, type RpcRequest, rpc } from '../../utils/rpc.js'
 
 import {
   type Transport,
@@ -7,7 +9,19 @@ import {
   createTransport,
 } from './createTransport.js'
 
+export type BatchOptions = {
+  /** The maximum number of JSON-RPC requests to send in a batch. @default 1_000 */
+  batchSize?: number
+  /** The maximum number of milliseconds to wait before sending a batch. @default 0 */
+  wait?: number
+}
+
 export type HttpTransportConfig = {
+  /**
+   * Whether to enable Batch JSON-RPC.
+   * @link https://www.jsonrpc.org/specification#batch
+   */
+  batch?: boolean | BatchOptions
   /**
    * Request configuration to pass to `fetch`.
    * @link https://developer.mozilla.org/en-US/docs/Web/API/fetch
@@ -41,12 +55,15 @@ export function http(
   config: HttpTransportConfig = {},
 ): HttpTransport {
   const {
+    batch,
     fetchOptions,
     key = 'http',
     name = 'HTTP JSON-RPC',
     retryDelay,
   } = config
   return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
+    const { batchSize = 1000, wait = 0 } =
+      typeof batch === 'object' ? batch : {}
     const retryCount = config.retryCount ?? retryCount_
     const timeout = timeout_ ?? config.timeout ?? 10_000
     const url_ = url || chain?.rpcUrls.default.http[0]
@@ -56,14 +73,34 @@ export function http(
         key,
         name,
         async request({ method, params }) {
-          const { result } = await rpc.http(url_, {
-            body: {
-              method,
-              params,
+          const body = { method, params }
+
+          const { schedule } = createBatchScheduler({
+            id: `${url}`,
+            wait,
+            shouldSplitBatch(requests) {
+              return requests.length > batchSize
             },
-            fetchOptions,
-            timeout,
+            fn: (body: RpcRequest[]) =>
+              rpc.http(url_, {
+                body,
+                fetchOptions,
+                timeout,
+              }),
           })
+
+          const fn = async (body: RpcRequest) =>
+            batch
+              ? schedule(body)
+              : [await rpc.http(url_, { body, fetchOptions, timeout })]
+
+          const [{ error, result }] = await fn(body)
+          if (error)
+            throw new RpcRequestError({
+              body,
+              error,
+              url: url_,
+            })
           return result
         },
         retryCount,

package/src/clients/transports/webSocket.ts

@@ -1,9 +1,9 @@
 import type { WebSocket } from 'isomorphic-ws'
 
+import { RpcRequestError } from '../../errors/request.js'
 import { UrlRequiredError } from '../../errors/transport.js'
 import type { Hash } from '../../types/misc.js'
 import { type RpcResponse, getSocket, rpc } from '../../utils/rpc.js'
-
 import {
   type Transport,
   type TransportConfig,
@@ -72,11 +72,18 @@ export function webSocket(
         key,
         name,
         async request({ method, params }) {
+          const body = { method, params }
           const socket = await getSocket(url_)
-          const { result } = await rpc.webSocketAsync(socket, {
-            body: { method, params },
+          const { error, result } = await rpc.webSocketAsync(socket, {
+            body,
             timeout,
           })
+          if (error)
+            throw new RpcRequestError({
+              body,
+              error,
+              url: url_,
+            })
           return result
         },
         retryCount,
@@ -97,31 +104,32 @@ export function webSocket(
                   method: 'eth_subscribe',
                   params,
                 },
-                onData: (data) => {
-                  if (typeof data.id === 'number') {
-                    resolve(data)
+                onResponse(response) {
+                  if (response.error) {
+                    reject(response.error)
+                    onError?.(response.error)
                     return
                   }
-                  if (data.method !== 'eth_subscription') return
-                  onData(data.params)
-                },
-                onError: (error) => {
-                  reject(error)
-                  onError?.(error)
+
+                  if (typeof response.id === 'number') {
+                    resolve(response)
+                    return
+                  }
+                  if (response.method !== 'eth_subscription') return
+                  onData(response.params)
                 },
               }),
           )
           return {
             subscriptionId,
             async unsubscribe() {
-              return new Promise<any>((resolve, reject) =>
+              return new Promise<any>((resolve) =>
                 rpc.webSocket(socket, {
                   body: {
                     method: 'eth_unsubscribe',
                     params: [subscriptionId],
                   },
-                  onData: resolve,
-                  onError: reject,
+                  onResponse: resolve,
                 }),
               )
             },

package/src/contract.ts

@@ -23,9 +23,9 @@ export {
   type MulticallReturnType,
   multicall,
 } from './actions/public/multicall.js'
-export {
-  type OnLogsFn,
-  type OnLogsParameter,
+export type {
+  OnLogsFn,
+  OnLogsParameter,
 } from './actions/public/watchEvent.js'
 export {
   type ReadContractParameters,

package/src/errors/abi.ts

@@ -1,6 +1,5 @@
-import type { AbiParameter } from 'abitype'
+import type { AbiEvent, AbiParameter } from 'abitype'
 
-import type { AbiItem } from '../types/contract.js'
 import type { Hex } from '../types/misc.js'
 import { formatAbiItem, formatAbiParams } from '../utils/abi/formatAbiItem.js'
 import { size } from '../utils/data/size.js'
@@ -278,15 +277,22 @@ export class BytesSizeMismatchError extends BaseError {
 export class DecodeLogDataMismatch extends BaseError {
   override name = 'DecodeLogDataMismatch'
 
+  abiItem: AbiEvent
   data: Hex
   params: readonly AbiParameter[]
   size: number
 
   constructor({
+    abiItem,
     data,
     params,
     size,
-  }: { data: Hex; params: readonly AbiParameter[]; size: number }) {
+  }: {
+    abiItem: AbiEvent
+    data: Hex
+    params: readonly AbiParameter[]
+    size: number
+  }) {
     super(
       [
         `Data size of ${size} bytes is too small for non-indexed event parameters.`,
@@ -299,6 +305,7 @@ export class DecodeLogDataMismatch extends BaseError {
       },
     )
 
+    this.abiItem = abiItem
     this.data = data
     this.params = params
     this.size = size
@@ -307,11 +314,14 @@ export class DecodeLogDataMismatch extends BaseError {
 
 export class DecodeLogTopicsMismatch extends BaseError {
   override name = 'DecodeLogTopicsMismatch'
+
+  abiItem: AbiEvent
+
   constructor({
     abiItem,
     param,
   }: {
-    abiItem: AbiItem
+    abiItem: AbiEvent
     param: AbiParameter & { indexed: boolean }
   }) {
     super(
@@ -321,6 +331,8 @@ export class DecodeLogTopicsMismatch extends BaseError {
         } on event "${formatAbiItem(abiItem, { includeName: true })}".`,
       ].join('\n'),
     )
+
+    this.abiItem = abiItem
   }
 }
 

package/src/errors/base.ts

@@ -61,12 +61,12 @@ export class BaseError extends Error {
   }
 
   walk(fn?: (err: unknown) => boolean) {
-    return this.#walk(this, fn)
+    return walk(this, fn)
   }
+}
 
-  #walk(err: unknown, fn?: (err: unknown) => boolean): unknown {
-    if (fn?.(err)) return err
-    if ((err as Error).cause) return this.#walk((err as Error).cause, fn)
-    return err
-  }
+function walk(err: unknown, fn?: (err: unknown) => boolean): unknown {
+  if (fn?.(err)) return err
+  if ((err as Error).cause) return walk((err as Error).cause, fn)
+  return err
 }

package/src/errors/request.ts

@@ -6,7 +6,7 @@ import { getUrl } from './utils.js'
 export class HttpRequestError extends BaseError {
   override name = 'HttpRequestError'
 
-  body?: { [key: string]: unknown }
+  body?: { [x: string]: unknown } | { [y: string]: unknown }[]
   headers?: Headers
   status?: number
   url: string
@@ -18,7 +18,7 @@ export class HttpRequestError extends BaseError {
     status,
     url,
   }: {
-    body?: { [key: string]: unknown }
+    body?: { [x: string]: unknown } | { [y: string]: unknown }[]
     details?: string
     headers?: Headers
     status?: number
@@ -68,7 +68,7 @@ export class RpcRequestError extends BaseError {
     error,
     url,
   }: {
-    body: { [key: string]: unknown }
+    body: { [x: string]: unknown } | { [y: string]: unknown }[]
     error: { code: number; message: string }
     url: string
   }) {
@@ -88,7 +88,7 @@ export class TimeoutError extends BaseError {
     body,
     url,
   }: {
-    body: { [key: string]: unknown }
+    body: { [x: string]: unknown } | { [y: string]: unknown }[]
     url: string
   }) {
     super('The request took too long to respond.', {

package/src/errors/rpc.ts

@@ -1,10 +1,27 @@
+import type { Prettify } from '../types/utils.js'
 import { BaseError } from './base.js'
 import { RpcRequestError } from './request.js'
 
 const unknownErrorCode = -1
 
-type RpcErrorOptions = {
-  code?: number
+export type RpcErrorCode =
+  | -1
+  | -32700 // Parse error
+  | -32600 // Invalid request
+  | -32601 // Method not found
+  | -32602 // Invalid params
+  | -32603 // Internal error
+  | -32000 // Invalid input
+  | -32001 // Resource not found
+  | -32002 // Resource unavailable
+  | -32003 // Transaction rejected
+  | -32004 // Method not supported
+  | -32005 // Limit exceeded
+  | -32006 // JSON-RPC version not supported
+  | -32042 // Method not found
+
+type RpcErrorOptions<TCode extends number = RpcErrorCode> = {
+  code?: TCode | (number & {})
   docsPath?: string
   metaMessages?: string[]
   shortMessage: string
@@ -15,17 +32,14 @@ type RpcErrorOptions = {
  *
  * - EIP https://eips.ethereum.org/EIPS/eip-1474
  */
-export class RpcError extends BaseError {
-  code: number
+export class RpcError<TCode extends number = RpcErrorCode> extends BaseError {
+  override name = 'RpcError'
+
+  code: TCode | (number & {})
 
   constructor(
     cause: Error,
-    {
-      code = unknownErrorCode,
-      docsPath,
-      metaMessages,
-      shortMessage,
-    }: RpcErrorOptions,
+    { code, docsPath, metaMessages, shortMessage }: RpcErrorOptions<TCode>,
   ) {
     super(shortMessage, {
       cause,
@@ -34,25 +48,39 @@ export class RpcError extends BaseError {
         metaMessages || (cause as { metaMessages?: string[] })?.metaMessages,
     })
     this.name = cause.name
-    this.code = cause instanceof RpcRequestError ? cause.code : code
+    this.code = (
+      cause instanceof RpcRequestError ? cause.code : code ?? unknownErrorCode
+    ) as TCode
   }
 }
 
+export type ProviderRpcErrorCode =
+  | 4001 // User Rejected Request
+  | 4100 // Unauthorized
+  | 4200 // Unsupported Method
+  | 4900 // Disconnected
+  | 4901 // Chain Disconnected
+  | 4902 // Chain Not Recongnized
+
 /**
  * Error subclass implementing Ethereum Provider errors per EIP-1193.
  *
  * - EIP https://eips.ethereum.org/EIPS/eip-1193
  */
-export class ProviderRpcError<T = undefined> extends RpcError {
+export class ProviderRpcError<
+  T = undefined,
+> extends RpcError<ProviderRpcErrorCode> {
   override name = 'ProviderRpcError'
 
   data?: T
 
   constructor(
     cause: Error,
-    options: RpcErrorOptions & {
-      data?: T
-    },
+    options: Prettify<
+      RpcErrorOptions<ProviderRpcErrorCode> & {
+        data?: T
+      }
+    >,
   ) {
     super(cause, options)
 

package/src/errors/version.ts

@@ -1 +1 @@
-export const version = '0.3.33'
+export const version = '0.0.0-tmm-sign-typed-data-types.20230619T221425'