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

package/src/clients/transports/createTransport.ts

@@ -1,22 +1,18 @@
 import type { Chain } from '../../types/chain.js'
-import type { Requests } from '../../types/eip1193.js'
+import type { EIP1193RequestFn } from '../../types/eip1193.js'
 import { buildRequest } from '../../utils/buildRequest.js'
 import type { ClientConfig } from '../createClient.js'
 
-export type BaseRpcRequests = {
-  request(...args: any): Promise<any>
-}
-
 export type TransportConfig<
   TType extends string = string,
-  TRequests extends BaseRpcRequests['request'] = Requests['request'],
+  TEIP1193RequestFn extends EIP1193RequestFn = EIP1193RequestFn,
 > = {
   /** The name of the transport. */
   name: string
   /** The key of the transport. */
   key: string
   /** The JSON-RPC request function that matches the EIP-1193 request spec. */
-  request: TRequests
+  request: TEIP1193RequestFn
   /** The base delay (in ms) between retries. */
   retryDelay?: number
   /** The max number of times to retry. */
@@ -30,7 +26,7 @@ export type TransportConfig<
 export type Transport<
   TType extends string = string,
   TRpcAttributes = Record<string, any>,
-  TRequests extends BaseRpcRequests['request'] = Requests['request'],
+  TEIP1193RequestFn extends EIP1193RequestFn = EIP1193RequestFn,
 > = <TChain extends Chain | undefined = Chain>({
   chain,
 }: {
@@ -40,7 +36,7 @@ export type Transport<
   timeout?: TransportConfig['timeout']
 }) => {
   config: TransportConfig<TType>
-  request: TRequests
+  request: TEIP1193RequestFn
   value?: TRpcAttributes
 }
 

package/src/clients/transports/custom.ts

@@ -1,11 +1,10 @@
 import {
-  type BaseRpcRequests,
   type Transport,
   type TransportConfig,
   createTransport,
 } from './createTransport.js'
 
-type EthereumProvider = { request: BaseRpcRequests['request'] }
+type EthereumProvider = { request(...args: any): Promise<any> }
 
 export type CustomTransportConfig = {
   /** The key of the transport. */

package/src/clients/transports/fallback.ts

@@ -102,7 +102,7 @@ export function fallback(
         key,
         name,
         async request({ method, params }) {
-          const fetch = async (i: number = 0): Promise<any> => {
+          const fetch = async (i = 0): Promise<any> => {
             const transport = transports[i]({ chain, retryCount: 0, timeout })
             try {
               const response = await transport.request({

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

@@ -21,7 +21,7 @@ export type RpcErrorCode =
   | -32042 // Method not found
 
 type RpcErrorOptions<TCode extends number = RpcErrorCode> = {
-  code?: TCode
+  code?: TCode | (number & {})
   docsPath?: string
   metaMessages?: string[]
   shortMessage: string
@@ -34,7 +34,8 @@ type RpcErrorOptions<TCode extends number = RpcErrorCode> = {
  */
 export class RpcError<TCode extends number = RpcErrorCode> extends BaseError {
   override name = 'RpcError'
-  code: TCode
+
+  code: TCode | (number & {})
 
   constructor(
     cause: Error,

package/src/errors/version.ts

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