viem 0.4.0-main.20230430T213120 → 1.0.0

package/src/utils/rpc.ts

@@ -1,10 +1,12 @@
-import type { WebSocket, MessageEvent } from 'isomorphic-ws'
+import type { MessageEvent, WebSocket } from 'isomorphic-ws'
+
 import {
   HttpRequestError,
-  RpcRequestError,
   TimeoutError,
   WebSocketRequestError,
-} from '../errors/index.js'
+} from '../errors/request.js'
+
+import { createBatchScheduler } from './promise/createBatchScheduler.js'
 import { withTimeout } from './promise/withTimeout.js'
 import { stringify } from './stringify.js'
 
@@ -38,7 +40,7 @@ type Subscription<TResult, TError> = {
   )
 }
 
-type RpcRequest = { method: string; params?: any }
+export type RpcRequest = { method: string; params?: any }
 
 export type RpcResponse<TResult = any, TError = any> = {
   jsonrpc: `${number}`
@@ -52,26 +54,39 @@ export type RpcResponse<TResult = any, TError = any> = {
 ///////////////////////////////////////////////////
 // HTTP
 
-export type HttpOptions = {
-  // The RPC request body.
-  body: RpcRequest
-  // Request configuration to pass to `fetch`.
-  fetchOptions?: Omit<RequestInit, 'body'>
-  // The timeout (in ms) for the request.
-  timeout?: number
-}
+export type HttpOptions<TBody extends RpcRequest | RpcRequest[] = RpcRequest,> =
+  {
+    // The RPC request body.
+    body: TBody
+    // Request configuration to pass to `fetch`.
+    fetchOptions?: Omit<RequestInit, 'body'>
+    // The timeout (in ms) for the request.
+    timeout?: number
+  }
+
+export type HttpReturnType<
+  TBody extends RpcRequest | RpcRequest[] = RpcRequest,
+> = TBody extends RpcRequest[] ? RpcResponse[] : RpcResponse
 
-async function http(
+async function http<TBody extends RpcRequest | RpcRequest[]>(
   url: string,
-  { body, fetchOptions = {}, timeout = 10_000 }: HttpOptions,
-) {
+  { body, fetchOptions = {}, timeout = 10_000 }: HttpOptions<TBody>,
+): Promise<HttpReturnType<TBody>> {
   const { headers, method, signal: signal_ } = fetchOptions
   try {
     const response = await withTimeout(
       async ({ signal }) => {
         const response = await fetch(url, {
           ...fetchOptions,
-          body: stringify({ jsonrpc: '2.0', id: id++, ...body }),
+          body: Array.isArray(body)
+            ? stringify(
+                body.map((body) => ({
+                  jsonrpc: '2.0',
+                  id: id++,
+                  ...body,
+                })),
+              )
+            : stringify({ jsonrpc: '2.0', id: id++, ...body }),
           headers: {
             ...headers,
             'Content-Type': 'application/json',
@@ -105,13 +120,9 @@ async function http(
       })
     }
 
-    if (data.error) {
-      throw new RpcRequestError({ body, error: data.error, url })
-    }
-    return data as RpcResponse
+    return data
   } catch (err) {
     if (err instanceof HttpRequestError) throw err
-    if (err instanceof RpcRequestError) throw err
     if (err instanceof TimeoutError) throw err
     throw new HttpRequestError({
       body,
@@ -144,78 +155,85 @@ export async function getSocket(url_: string) {
   // If the socket already exists, return it.
   if (socket) return socket
 
-  let WebSocket = await import('isomorphic-ws')
-  // Workaround for Vite.
-  // https://github.com/vitejs/vite/issues/9703
-  // TODO: Remove when issue is resolved.
-  if (
-    (WebSocket as unknown as { default?: typeof WebSocket }).default
-      ?.constructor
-  )
-    WebSocket = (WebSocket as unknown as { default: typeof WebSocket }).default
-  else WebSocket = WebSocket.WebSocket
-
-  const webSocket = new WebSocket(url)
-
-  // Set up a cache for incoming "synchronous" requests.
-  const requests = new Map<Id, CallbackFn>()
-
-  // Set up a cache for subscriptions (eth_subscribe).
-  const subscriptions = new Map<Id, CallbackFn>()
+  const { schedule } = createBatchScheduler<undefined, [Socket]>({
+    id: urlKey,
+    fn: async () => {
+      let WebSocket = await import('isomorphic-ws')
+      // Workaround for Vite.
+      // https://github.com/vitejs/vite/issues/9703
+      // TODO: Remove when issue is resolved.
+      if (
+        (WebSocket as unknown as { default?: typeof WebSocket }).default
+          ?.constructor
+      )
+        WebSocket = (WebSocket as unknown as { default: typeof WebSocket })
+          .default
+      else WebSocket = WebSocket.WebSocket
+
+      const webSocket = new WebSocket(url)
+
+      // Set up a cache for incoming "synchronous" requests.
+      const requests = new Map<Id, CallbackFn>()
+
+      // Set up a cache for subscriptions (eth_subscribe).
+      const subscriptions = new Map<Id, CallbackFn>()
+
+      const onMessage: (event: MessageEvent) => void = ({ data }) => {
+        const message: RpcResponse = JSON.parse(data as string)
+        const isSubscription = message.method === 'eth_subscription'
+        const id = isSubscription ? message.params.subscription : message.id
+        const cache = isSubscription ? subscriptions : requests
+        const callback = cache.get(id)
+        if (callback) callback({ data })
+        if (!isSubscription) cache.delete(id)
+      }
+      const onClose = () => {
+        sockets.delete(urlKey)
+        webSocket.removeEventListener('close', onClose)
+        webSocket.removeEventListener('message', onMessage)
+      }
 
-  const onMessage: (event: MessageEvent) => void = ({ data }) => {
-    const message: RpcResponse = JSON.parse(data as string)
-    const isSubscription = message.method === 'eth_subscription'
-    const id = isSubscription ? message.params.subscription : message.id
-    const cache = isSubscription ? subscriptions : requests
-    const callback = cache.get(id)
-    if (callback) callback({ data })
-    if (!isSubscription) cache.delete(id)
-  }
-  const onClose = () => {
-    sockets.delete(urlKey)
-    webSocket.removeEventListener('close', onClose)
-    webSocket.removeEventListener('message', onMessage)
-  }
+      // Setup event listeners for RPC & subscription responses.
+      webSocket.addEventListener('close', onClose)
+      webSocket.addEventListener('message', onMessage)
 
-  // Setup event listeners for RPC & subscription responses.
-  webSocket.addEventListener('close', onClose)
-  webSocket.addEventListener('message', onMessage)
+      // Wait for the socket to open.
+      if (webSocket.readyState === WebSocket.CONNECTING) {
+        await new Promise((resolve, reject) => {
+          if (!webSocket) return
+          webSocket.onopen = resolve
+          webSocket.onerror = reject
+        })
+      }
 
-  // Wait for the socket to open.
-  if (webSocket.readyState === WebSocket.CONNECTING) {
-    await new Promise((resolve, reject) => {
-      if (!webSocket) return
-      webSocket.onopen = resolve
-      webSocket.onerror = reject
-    })
-  }
+      // Create a new socket instance.
+      socket = Object.assign(webSocket, {
+        requests,
+        subscriptions,
+      })
+      sockets.set(urlKey, socket)
 
-  // Create a new socket instance.
-  socket = Object.assign(webSocket, {
-    requests,
-    subscriptions,
+      return [socket]
+    },
   })
-  sockets.set(urlKey, socket)
 
-  return socket
+  const [_, [socket_]] = await schedule()
+  return socket_
+}
+
+export type WebSocketOptions = {
+  /** The RPC request body. */
+  body: RpcRequest
+  /** The callback to invoke on response. */
+  onResponse?: (message: RpcResponse) => void
 }
 
+export type WebSocketReturnType = Socket
+
 function webSocket(
   socket: Socket,
-  {
-    body,
-    onData,
-    onError,
-  }: {
-    // The RPC request body.
-    body: RpcRequest
-    // The callback to invoke when the request is successful.
-    onData?: (message: RpcResponse) => void
-    // The callback to invoke if the request errors.
-    onError?: (message: RpcResponse['error']) => void
-  },
-) {
+  { body, onResponse }: WebSocketOptions,
+): WebSocketReturnType {
   if (
     socket.readyState === socket.CLOSED ||
     socket.readyState === socket.CLOSING
@@ -233,13 +251,7 @@ function webSocket(
 
     if (typeof message.id === 'number' && id_ !== message.id) return
 
-    if (message.error) {
-      onError?.(
-        new RpcRequestError({ body, error: message.error, url: socket.url }),
-      )
-    } else {
-      onData?.(message)
-    }
+    onResponse?.(message)
 
     // If we are subscribing to a topic, we want to set up a listener for incoming
     // messages.
@@ -259,25 +271,25 @@ function webSocket(
   return socket
 }
 
+export type WebSocketAsyncOptions = {
+  /** The RPC request body. */
+  body: RpcRequest
+  /** The timeout (in ms) for the request. */
+  timeout?: number
+}
+
+export type WebSocketAsyncReturnType = RpcResponse
+
 async function webSocketAsync(
   socket: Socket,
-  {
-    body,
-    timeout = 10_000,
-  }: {
-    // The RPC request body.
-    body: RpcRequest
-    // The timeout (in ms) for the request.
-    timeout?: number
-  },
-) {
+  { body, timeout = 10_000 }: WebSocketAsyncOptions,
+): Promise<WebSocketAsyncReturnType> {
   return withTimeout(
     () =>
-      new Promise<RpcResponse>((onData, onError) =>
+      new Promise<RpcResponse>((onResponse) =>
         rpc.webSocket(socket, {
           body,
-          onData,
-          onError,
+          onResponse,
         }),
       ),
     {

package/src/utils/signature/hashMessage.ts

@@ -1,6 +1,6 @@
-import type { ByteArray, Hex } from '../../types/index.js'
-import { concat } from '../data/index.js'
-import { toBytes } from '../encoding/index.js'
+import type { ByteArray, Hex, SignableMessage } from '../../types/misc.js'
+import { concat } from '../data/concat.js'
+import { stringToBytes, toBytes } from '../encoding/toBytes.js'
 import { keccak256 } from '../hash/keccak256.js'
 
 type To = 'hex' | 'bytes'
@@ -10,11 +10,15 @@ export type HashMessage<TTo extends To> =
   | (TTo extends 'hex' ? Hex : never)
 
 export function hashMessage<TTo extends To = 'hex'>(
-  message: string,
+  message: SignableMessage,
   to_?: TTo,
 ): HashMessage<TTo> {
-  const messageBytes = toBytes(message)
-  const prefixBytes = toBytes(
+  const messageBytes = (() => {
+    if (typeof message === 'string') return stringToBytes(message)
+    if (message.raw instanceof Uint8Array) return message.raw
+    return toBytes(message.raw)
+  })()
+  const prefixBytes = stringToBytes(
     `\x19Ethereum Signed Message:\n${messageBytes.length}`,
   )
   return keccak256(concat([prefixBytes, messageBytes]), to_)

package/src/utils/signature/hashTypedData.ts

@@ -2,11 +2,12 @@
 
 import type { AbiParameter, TypedData, TypedDataDomain } from 'abitype'
 
-import type { Hex, TypedDataDefinition } from '../../types/index.js'
-import { encodeAbiParameters } from '../abi/index.js'
-import { concat } from '../data/index.js'
-import { toHex } from '../encoding/index.js'
-import { keccak256 } from '../hash/index.js'
+import type { Hex } from '../../types/misc.js'
+import type { TypedDataDefinition } from '../../types/typedData.js'
+import { encodeAbiParameters } from '../abi/encodeAbiParameters.js'
+import { concat } from '../data/concat.js'
+import { toHex } from '../encoding/toHex.js'
+import { keccak256 } from '../hash/keccak256.js'
 import { validateTypedData } from '../typedData.js'
 
 type MessageTypeProperty = {

package/src/utils/signature/recoverAddress.ts

@@ -1,5 +1,8 @@
-import type { Address, ByteArray, Hex } from '../../types/index.js'
-import { publicKeyToAddress } from '../accounts.js'
+import type { Address } from 'abitype'
+
+import { publicKeyToAddress } from '../../accounts/utils/publicKeyToAddress.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
+
 import { recoverPublicKey } from './recoverPublicKey.js'
 
 export type RecoverAddressParameters = {

package/src/utils/signature/recoverMessageAddress.ts

@@ -1,9 +1,12 @@
-import type { Address, ByteArray, Hex } from '../../types/index.js'
+import type { Address } from 'abitype'
+
+import type { ByteArray, Hex, SignableMessage } from '../../types/misc.js'
+
 import { hashMessage } from './hashMessage.js'
 import { recoverAddress } from './recoverAddress.js'
 
 export type RecoverMessageAddressParameters = {
-  message: string
+  message: SignableMessage
   signature: Hex | ByteArray
 }
 export type RecoverMessageAddressReturnType = Address

package/src/utils/signature/recoverPublicKey.ts

@@ -1,6 +1,7 @@
-import type { ByteArray, Hex } from '../../types/index.js'
-import { isHex } from '../data/index.js'
-import { hexToNumber, toHex } from '../encoding/index.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
+import { isHex } from '../data/isHex.js'
+import { hexToNumber } from '../encoding/fromHex.js'
+import { toHex } from '../encoding/toHex.js'
 
 export type RecoverPublicKeyParameters = {
   hash: Hex | ByteArray
@@ -17,7 +18,8 @@ export async function recoverPublicKey({
 
   // 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)}`)
+  let v = hexToNumber(`0x${signatureHex.slice(130)}`)
+  if (v === 0 || v === 1) v += 27
 
   const { secp256k1 } = await import('@noble/curves/secp256k1')
   const publicKey = secp256k1.Signature.fromCompact(

package/src/utils/signature/recoverTypedDataAddress.ts

@@ -1,10 +1,8 @@
-import type { TypedData } from 'abitype'
-import type {
-  Address,
-  ByteArray,
-  Hex,
-  TypedDataDefinition,
-} from '../../types/index.js'
+import type { Address, TypedData } from 'abitype'
+
+import type { ByteArray, Hex } from '../../types/misc.js'
+import type { TypedDataDefinition } from '../../types/typedData.js'
+
 import { hashTypedData } from './hashTypedData.js'
 import { recoverAddress } from './recoverAddress.js'
 

package/src/utils/signature/verifyMessage.ts

@@ -1,15 +1,34 @@
 import type { Address } from 'abitype'
-import type { Hex, ByteArray } from '../../types/index.js'
-import { getAddress, isAddressEqual, recoverMessageAddress } from '../index.js'
+
+import type { ByteArray, Hex } from '../../types/misc.js'
+import { getAddress } from '../address/getAddress.js'
+import { isAddressEqual } from '../address/isAddressEqual.js'
+
+import { recoverMessageAddress } from './recoverMessageAddress.js'
 
 export type VerifyMessageParameters = {
+  /** The address that signed the original message. */
   address: Address
+  /** The message to be verified. */
   message: string
+  /** The signature that was generated by signing the message with the address's private key. */
   signature: Hex | ByteArray
 }
 
 export type VerifyMessageReturnType = boolean
 
+/**
+ * Verify that a message was signed by the provided address.
+ *
+ * Note:  Only supports Externally Owned Accounts. Does not support Contract Accounts.
+ *        It is highly recommended to use `publicClient.verifyMessage` instead to ensure
+ *        wallet interoperability.
+ *
+ * - Docs {@link https://viem.sh/docs/utilities/verifyMessage.html}
+ *
+ * @param parameters - {@link VerifyMessageParameters}
+ * @returns Whether or not the signature is valid. {@link VerifyMessageReturnType}
+ */
 export async function verifyMessage({
   address,
   message,

package/src/utils/signature/verifyTypedData.ts

@@ -1,19 +1,39 @@
 import type { Address, TypedData } from 'abitype'
-import type { Hex, ByteArray, TypedDataDefinition } from '../../types/index.js'
-import { getAddress, isAddressEqual } from '../index.js'
-import { recoverTypedDataAddress } from './recoverTypedDataAddress.js'
-import type { RecoverTypedDataAddressParameters } from './recoverTypedDataAddress.js'
+
+import type { ByteArray, Hex } from '../../types/misc.js'
+import type { TypedDataDefinition } from '../../types/typedData.js'
+import { getAddress } from '../address/getAddress.js'
+import { isAddressEqual } from '../address/isAddressEqual.js'
+
+import {
+  type RecoverTypedDataAddressParameters,
+  recoverTypedDataAddress,
+} from './recoverTypedDataAddress.js'
 
 export type VerifyTypedDataParameters<
   TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
   TPrimaryType extends string = string,
 > = TypedDataDefinition<TTypedData, TPrimaryType> & {
+  /** The address to verify the typed data for. */
   address: Address
+  /** The signature to verify */
   signature: Hex | ByteArray
 }
 
 export type VerifyTypedDataReturnType = boolean
 
+/**
+ * Verify that typed data was signed by the provided address.
+ *
+ * Note:  Only supports Externally Owned Accounts. Does not support Contract Accounts.
+ *        It is highly recommended to use `publicClient.verifyTypedData` instead to ensure
+ *        wallet interoperability.
+ *
+ * - Docs {@link https://viem.sh/docs/utilities/verifyTypedData.html}
+ *
+ * @param parameters - {@link VerifyTypedDataParameters}
+ * @returns Whether or not the signature is valid. {@link VerifyTypedDataReturnType}
+ */
 export async function verifyTypedData<
   TTypedData extends TypedData | { [key: string]: unknown },
   TPrimaryType extends string = string,

package/src/utils/transaction/assertRequest.ts

@@ -1,13 +1,10 @@
-import type { SendTransactionParameters } from '../../actions/index.js'
-import {
-  FeeCapTooHighError,
-  InvalidAddressError,
-  TipAboveFeeCapError,
-} from '../../errors/index.js'
+import { parseAccount } from '../../accounts/utils/parseAccount.js'
+import type { SendTransactionParameters } from '../../actions/wallet/sendTransaction.js'
+import { InvalidAddressError } from '../../errors/address.js'
+import { FeeCapTooHighError, TipAboveFeeCapError } from '../../errors/node.js'
 import { FeeConflictError } from '../../errors/transaction.js'
-import type { Chain } from '../../types/index.js'
-import { parseAccount } from '../accounts.js'
-import { isAddress } from '../address/index.js'
+import type { Chain } from '../../types/chain.js'
+import { isAddress } from '../address/isAddress.js'
 
 export function assertRequest(args: Partial<SendTransactionParameters<Chain>>) {
   const {

package/src/utils/transaction/assertTransaction.ts

@@ -1,16 +1,13 @@
-import {
-  BaseError,
-  FeeCapTooHighError,
-  InvalidAddressError,
-  InvalidChainIdError,
-  TipAboveFeeCapError,
-} from '../../errors/index.js'
+import { InvalidAddressError } from '../../errors/address.js'
+import { BaseError } from '../../errors/base.js'
+import { InvalidChainIdError } from '../../errors/chain.js'
+import { FeeCapTooHighError, TipAboveFeeCapError } from '../../errors/node.js'
 import type {
   TransactionSerializableEIP1559,
   TransactionSerializableEIP2930,
   TransactionSerializableLegacy,
-} from '../../types/index.js'
-import { isAddress } from '../address/index.js'
+} from '../../types/transaction.js'
+import { isAddress } from '../address/isAddress.js'
 
 export function assertTransactionEIP1559(
   transaction: TransactionSerializableEIP1559,

package/src/utils/transaction/getSerializedTransactionType.ts

@@ -4,8 +4,8 @@ import type {
   TransactionSerializedEIP1559,
   TransactionSerializedEIP2930,
 } from '../../types/transaction.js'
-import { sliceHex } from '../data/index.js'
-import { hexToNumber } from '../encoding/index.js'
+import { sliceHex } from '../data/slice.js'
+import { hexToNumber } from '../encoding/fromHex.js'
 
 export type GetSerializedTransactionType<
   TTransactionSerialized extends TransactionSerialized = TransactionSerialized,

package/src/utils/transaction/getTransactionType.ts

@@ -1,5 +1,8 @@
 import { InvalidSerializableTransactionError } from '../../errors/transaction.js'
-import type { AccessList, TransactionSerializable } from '../../types/index.js'
+import type {
+  AccessList,
+  TransactionSerializable,
+} from '../../types/transaction.js'
 
 export type GetTransactionType<
   TTransactionSerializable extends TransactionSerializable = TransactionSerializable,

package/src/utils/transaction/parseTransaction.ts

@@ -1,12 +1,11 @@
-import { InvalidAddressError } from '../../errors/index.js'
+import { InvalidAddressError } from '../../errors/address.js'
 import {
   InvalidLegacyVError,
   InvalidSerializedTransactionError,
-} from '../../errors/index.js'
+} from '../../errors/transaction.js'
+import type { Hex, Signature } from '../../types/misc.js'
 import type {
   AccessList,
-  Hex,
-  Signature,
   TransactionRequestEIP2930,
   TransactionRequestLegacy,
   TransactionSerializableEIP1559,
@@ -16,19 +15,25 @@ import type {
   TransactionSerializedEIP1559,
   TransactionSerializedEIP2930,
   TransactionType,
-} from '../../types/index.js'
-import { isAddress } from '../address/index.js'
-import { isHex, padHex, trim } from '../data/index.js'
-import { fromRlp, hexToBigInt, hexToNumber } from '../encoding/index.js'
+} from '../../types/transaction.js'
+import { isAddress } from '../address/isAddress.js'
+import { isHex } from '../data/isHex.js'
+import { padHex } from '../data/pad.js'
+import { trim } from '../data/trim.js'
+import { hexToBigInt, hexToNumber } from '../encoding/fromHex.js'
+import { fromRlp } from '../encoding/fromRlp.js'
 import type { RecursiveArray } from '../encoding/toRlp.js'
-import { isHash } from '../hash/index.js'
+import { isHash } from '../hash/isHash.js'
+
 import {
   assertTransactionEIP1559,
   assertTransactionEIP2930,
   assertTransactionLegacy,
 } from './assertTransaction.js'
-import { getSerializedTransactionType } from './getSerializedTransactionType.js'
-import type { GetSerializedTransactionType } from './getSerializedTransactionType.js'
+import {
+  type GetSerializedTransactionType,
+  getSerializedTransactionType,
+} from './getSerializedTransactionType.js'
 
 export type ParseTransactionReturnType<
   TSerialized extends TransactionSerialized = TransactionSerialized,