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

package/src/utils/ens/packetToBytes.ts

@@ -1,29 +1,33 @@
 // Adapted from https://github.com/mafintosh/dns-packet
 import type { ByteArray } from '../../types/misc.js'
 import { stringToBytes } from '../encoding/toBytes.js'
+import { encodeLabelhash } from './encodeLabelhash.js'
+import { labelhash } from './labelhash.js'
 
 /*
  * @description Encodes a DNS packet into a ByteArray containing a UDP payload.
  */
 export function packetToBytes(packet: string): ByteArray {
-  function length(value: string) {
-    if (value === '.' || value === '..') return 1
-    return stringToBytes(value.replace(/^\.|\.$/gm, '')).length + 2
-  }
-
-  const bytes = new Uint8Array(length(packet))
   // strip leading and trailing `.`
   const value = packet.replace(/^\.|\.$/gm, '')
-  if (!value.length) return bytes
+  if (value.length === 0) return new Uint8Array(1)
+
+  const bytes = new Uint8Array(stringToBytes(value).byteLength + 2)
 
   let offset = 0
   const list = value.split('.')
   for (let i = 0; i < list.length; i++) {
-    const encoded = stringToBytes(list[i])
+    let encoded = stringToBytes(list[i])
+    // if the length is > 255, make the encoded label value a labelhash
+    // this is compatible with the universal resolver
+    if (encoded.byteLength > 255)
+      encoded = stringToBytes(encodeLabelhash(labelhash(list[i])))
     bytes[offset] = encoded.length
     bytes.set(encoded, offset + 1)
     offset += encoded.length + 1
   }
 
+  if (bytes.byteLength !== offset + 1) return bytes.slice(0, offset + 1)
+
   return bytes
 }

package/src/utils/filters/createFilterRequestScope.ts

@@ -2,8 +2,9 @@ import type { PublicClient } from '../../clients/createPublicClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { OnResponseFn } from '../../clients/transports/fallback.js'
 import type { Chain } from '../../types/chain.js'
-import type { Requests } from '../../types/eip1193.js'
+import type { EIP1193RequestFn, PublicRpcSchema } from '../../types/eip1193.js'
 import type { Hex } from '../../types/misc.js'
+import type { Filter } from '../../types/utils.js'
 
 type CreateFilterRequestScopeParameters = {
   method:
@@ -11,8 +12,15 @@ type CreateFilterRequestScopeParameters = {
     | 'eth_newPendingTransactionFilter'
     | 'eth_newBlockFilter'
 }
-// TODO: Narrow `request` to filter-based methods (ie. `eth_getFilterLogs`, etc).
-type CreateFilterRequestScopeReturnType = (id: Hex) => Requests['request']
+
+type FilterRpcSchema = Filter<
+  PublicRpcSchema,
+  { Method: 'eth_getFilterLogs' | 'eth_getFilterChanges' }
+>
+
+type CreateFilterRequestScopeReturnType = (
+  id: Hex,
+) => EIP1193RequestFn<FilterRpcSchema>
 
 /**
  * Scopes `request` to the filter ID. If the client is a fallback, it will
@@ -23,7 +31,7 @@ export function createFilterRequestScope<TChain extends Chain | undefined>(
   client: PublicClient<Transport, TChain>,
   { method }: CreateFilterRequestScopeParameters,
 ): CreateFilterRequestScopeReturnType {
-  const requestMap: Record<Hex, PublicClient<Transport, TChain>['request']> = {}
+  const requestMap: Record<Hex, EIP1193RequestFn> = {}
 
   if (client.transport.type === 'fallback')
     client.transport.onResponse?.(

package/src/utils/formatters/block.ts

@@ -44,4 +44,6 @@ export function formatBlock(block: Partial<RpcBlock>) {
   } as Block
 }
 
-export const defineBlock = defineFormatter({ format: formatBlock })
+export const defineBlock = /*#__PURE__*/ defineFormatter({
+  format: formatBlock,
+})

package/src/utils/formatters/log.ts

@@ -9,10 +9,10 @@ export function formatLog(
     ...log,
     blockHash: log.blockHash ? log.blockHash : null,
     blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,
-    logIndex: log.logIndex ? BigInt(log.logIndex) : null,
+    logIndex: log.logIndex ? Number(log.logIndex) : null,
     transactionHash: log.transactionHash ? log.transactionHash : null,
     transactionIndex: log.transactionIndex
-      ? BigInt(log.transactionIndex)
+      ? Number(log.transactionIndex)
       : null,
     ...(eventName ? { args, eventName } : {}),
   } as Log

package/src/utils/formatters/transaction.ts

@@ -67,4 +67,6 @@ export function formatTransaction(transaction: Partial<RpcTransaction>) {
   return transaction_ as Transaction
 }
 
-export const defineTransaction = defineFormatter({ format: formatTransaction })
+export const defineTransaction = /*#__PURE__*/ defineFormatter({
+  format: formatTransaction,
+})

package/src/utils/formatters/transactionReceipt.ts

@@ -62,11 +62,13 @@ export function formatTransactionReceipt(
       ? statuses[transactionReceipt.status]
       : null,
     type: transactionReceipt.type
-      ? transactionType[transactionReceipt.type]
+      ? transactionType[
+          transactionReceipt.type as keyof typeof transactionType
+        ] || transactionReceipt.type
       : null,
   } as TransactionReceipt
 }
 
-export const defineTransactionReceipt = defineFormatter({
+export const defineTransactionReceipt = /*#__PURE__*/ defineFormatter({
   format: formatTransactionReceipt,
 })

package/src/utils/formatters/transactionRequest.ts

@@ -56,6 +56,6 @@ export function formatTransactionRequest(
   } as RpcTransactionRequest
 }
 
-export const defineTransactionRequest = defineFormatter({
+export const defineTransactionRequest = /*#__PURE__*/ defineFormatter({
   format: formatTransactionRequest,
 })

package/src/utils/hash/getEventSelector.ts

@@ -1,5 +1,9 @@
 import type { EventDefinition } from '../../types/contract.js'
+import type { AbiEvent } from 'abitype'
 
-import { hashFunction } from './hashFunction.js'
+import { hashAbiItem, hashFunction } from './hashFunction.js'
 
-export const getEventSelector = (event: EventDefinition) => hashFunction(event)
+export const getEventSelector = (event: EventDefinition | AbiEvent) => {
+  if (typeof event === 'string') return hashFunction(event)
+  return hashAbiItem(event)
+}

package/src/utils/hash/getFunctionSelector.ts

@@ -1,5 +1,9 @@
 import { slice } from '../data/slice.js'
+import type { AbiFunction } from 'abitype'
 
-import { hashFunction } from './hashFunction.js'
+import { hashAbiItem, hashFunction } from './hashFunction.js'
 
-export const getFunctionSelector = (fn: string) => slice(hashFunction(fn), 0, 4)
+export const getFunctionSelector = (fn: string | AbiFunction) => {
+  if (typeof fn === 'string') return slice(hashFunction(fn), 0, 4)
+  return slice(hashAbiItem(fn), 0, 4)
+}

package/src/utils/hash/hashFunction.ts

@@ -3,6 +3,7 @@ import {
   extractFunctionParams,
 } from '../contract/extractFunctionParts.js'
 import { toBytes } from '../encoding/toBytes.js'
+import type { AbiEvent, AbiFunction } from 'abitype'
 
 import { keccak256 } from './keccak256.js'
 
@@ -10,7 +11,10 @@ const hash = (value: string) => keccak256(toBytes(value))
 
 export function hashFunction(def: string) {
   const name = extractFunctionName(def)
-  const params = extractFunctionParams(def)
-  if (!params || params.length === 0) return hash(def.replace(/ /g, ''))
+  const params = extractFunctionParams(def) || []
   return hash(`${name}(${params.map(({ type }) => type).join(',')})`)
 }
+
+export function hashAbiItem(def: AbiFunction | AbiEvent) {
+  return hash(`${def.name}(${def.inputs.map(({ type }) => type).join(',')})`)
+}

package/src/utils/index.ts

@@ -17,8 +17,14 @@ export { arrayRegex, bytesRegex, integerRegex } from './regex.js'
 
 export {
   type HttpOptions,
+  type HttpReturnType,
+  type RpcRequest,
   type RpcResponse,
   type Socket,
+  type WebSocketAsyncOptions,
+  type WebSocketAsyncReturnType,
+  type WebSocketOptions,
+  type WebSocketReturnType,
   getSocket,
   rpc,
 } from './rpc.js'

package/src/utils/observe.ts

@@ -3,11 +3,11 @@ import type { MaybePromise } from '../types/utils.js'
 type Callback = ((...args: any[]) => any) | undefined
 type Callbacks = Record<string, Callback>
 
-export const listenersCache = new Map<
+export const listenersCache = /*#__PURE__*/ new Map<
   string,
   { id: number; fns: Callbacks }[]
 >()
-export const cleanupCache = new Map<string, () => void>()
+export const cleanupCache = /*#__PURE__*/ new Map<string, () => void>()
 
 type EmitFunction<TCallbacks extends Callbacks> = (
   emit: TCallbacks,

package/src/utils/promise/createBatchScheduler.ts

@@ -29,7 +29,7 @@ export type CreateBatchSchedulerReturnType<
     : (args: TParameters) => Promise<Resolved<TReturnType>>
 }
 
-const schedulerCache = new Map<number | string, SchedulerItem[]>()
+const schedulerCache = /*#__PURE__*/ new Map<number | string, SchedulerItem[]>()
 
 export function createBatchScheduler<
   TParameters,

package/src/utils/promise/withCache.ts

@@ -1,5 +1,5 @@
-export const promiseCache = new Map()
-export const responseCache = new Map()
+export const promiseCache = /*#__PURE__*/ new Map()
+export const responseCache = /*#__PURE__*/ new Map()
 
 export function getCache<TData>(cacheKey: string) {
   const buildCache = <TData>(cacheKey: string, cache: Map<string, TData>) => ({
@@ -59,15 +59,17 @@ export async function withCache<TData>(
     cache.promise.set(promise)
   }
 
-  const data = await promise
+  try {
+    const data = await promise
 
-  // Clear the promise cache so that subsequent invocations will
-  // invoke the promise again.
-  cache.promise.clear()
+    // Store the response in the cache so that subsequent invocations
+    // will return the same response.
+    cache.response.set({ created: new Date(), data })
 
-  // Store the response in the cache so that subsequent invocations
-  // will return the same response.
-  cache.response.set({ created: new Date(), data })
-
-  return data
+    return data
+  } finally {
+    // Clear the promise cache so that subsequent invocations will
+    // invoke the promise again.
+    cache.promise.clear()
+  }
 }

package/src/utils/rpc.ts

@@ -2,7 +2,6 @@ import type { MessageEvent, WebSocket } from 'isomorphic-ws'
 
 import {
   HttpRequestError,
-  RpcRequestError,
   TimeoutError,
   WebSocketRequestError,
 } from '../errors/request.js'
@@ -41,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}`
@@ -55,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',
@@ -108,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,
@@ -136,7 +144,7 @@ export type Socket = WebSocket & {
   subscriptions: CallbackMap
 }
 
-const sockets = new Map<string, Socket>()
+const sockets = /*#__PURE__*/ new Map<string, Socket>()
 
 export async function getSocket(url_: string) {
   const url = new URL(url_)
@@ -213,21 +221,19 @@ export async function getSocket(url_: string) {
   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
@@ -245,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.
@@ -271,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/misc.js'
+import type { ByteArray, Hex, SignableMessage } from '../../types/misc.js'
 import { concat } from '../data/concat.js'
-import { stringToBytes } from '../encoding/toBytes.js'
+import { stringToBytes, toBytes } from '../encoding/toBytes.js'
 import { keccak256 } from '../hash/keccak256.js'
 
 type To = 'hex' | 'bytes'
@@ -10,10 +10,14 @@ 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 = stringToBytes(message)
+  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}`,
   )

package/src/utils/signature/hashTypedData.ts

@@ -16,15 +16,15 @@ type MessageTypeProperty = {
 }
 
 export type HashTypedDataParameters<
-  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
-  TPrimaryType extends string = string,
+  TTypedData extends TypedData | Record<string, unknown> = TypedData,
+  TPrimaryType extends keyof TTypedData = keyof TTypedData,
 > = TypedDataDefinition<TTypedData, TPrimaryType>
 
 export type HashTypedDataReturnType = Hex
 
 export function hashTypedData<
-  TTypedData extends TypedData | { [key: string]: unknown },
-  TPrimaryType extends string = string,
+  const TTypedData extends TypedData | Record<string, unknown>, // `Record<string, unknown>` allows for non-const asserted types
+  TPrimaryType extends keyof TTypedData,
 >({
   domain: domain_,
   message,

package/src/utils/signature/recoverMessageAddress.ts

@@ -1,12 +1,12 @@
 import type { Address } from 'abitype'
 
-import type { ByteArray, Hex } from '../../types/misc.js'
+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/recoverTypedDataAddress.ts

@@ -7,16 +7,16 @@ import { hashTypedData } from './hashTypedData.js'
 import { recoverAddress } from './recoverAddress.js'
 
 export type RecoverTypedDataAddressParameters<
-  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
-  TPrimaryType extends string = string,
+  TTypedData extends TypedData | Record<string, unknown> = TypedData,
+  TPrimaryType extends keyof TTypedData = keyof TTypedData,
 > = TypedDataDefinition<TTypedData, TPrimaryType> & {
   signature: Hex | ByteArray
 }
 export type RecoverTypedDataAddressReturnType = Address
 
 export async function recoverTypedDataAddress<
-  TTypedData extends TypedData | { [key: string]: unknown },
-  TPrimaryType extends string = string,
+  const TTypedData extends TypedData | Record<string, unknown>, // `Record<string, unknown>` allows for non-const asserted types
+  TPrimaryType extends keyof TTypedData,
 >({
   domain,
   message,

package/src/utils/signature/verifyTypedData.ts

@@ -11,8 +11,8 @@ import {
 } from './recoverTypedDataAddress.js'
 
 export type VerifyTypedDataParameters<
-  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
-  TPrimaryType extends string = string,
+  TTypedData extends TypedData | Record<string, unknown> = TypedData,
+  TPrimaryType extends keyof TTypedData = keyof TTypedData,
 > = TypedDataDefinition<TTypedData, TPrimaryType> & {
   /** The address to verify the typed data for. */
   address: Address
@@ -35,8 +35,8 @@ export type VerifyTypedDataReturnType = boolean
  * @returns Whether or not the signature is valid. {@link VerifyTypedDataReturnType}
  */
 export async function verifyTypedData<
-  TTypedData extends TypedData | { [key: string]: unknown },
-  TPrimaryType extends string = string,
+  const TTypedData extends TypedData | Record<string, unknown>, // `Record<string, unknown>` allows for non-const asserted types
+  TPrimaryType extends keyof TTypedData,
 >({
   address,
   domain,

package/src/utils/transaction/getTransactionType.ts

@@ -1,24 +1,25 @@
 import { InvalidSerializableTransactionError } from '../../errors/transaction.js'
 import type {
-  AccessList,
   TransactionSerializable,
+  TransactionSerializableEIP1559,
+  TransactionSerializableEIP2930,
+  TransactionSerializableGeneric,
+  TransactionSerializableLegacy,
 } from '../../types/transaction.js'
 
 export type GetTransactionType<
   TTransactionSerializable extends TransactionSerializable = TransactionSerializable,
 > =
-  | (TTransactionSerializable['maxFeePerGas'] extends bigint
-      ? 'eip1559'
+  | (TTransactionSerializable extends TransactionSerializableLegacy
+      ? 'legacy'
       : never)
-  | (TTransactionSerializable['maxPriorityFeePerGas'] extends bigint
+  | (TTransactionSerializable extends TransactionSerializableEIP1559
       ? 'eip1559'
       : never)
-  | (TTransactionSerializable['gasPrice'] extends bigint
-      ? TTransactionSerializable['accessList'] extends AccessList
-        ? 'eip2930'
-        : 'legacy'
+  | (TTransactionSerializable extends TransactionSerializableEIP2930
+      ? 'eip2930'
       : never)
-  | (TTransactionSerializable['type'] extends string
+  | (TTransactionSerializable extends TransactionSerializableGeneric
       ? TTransactionSerializable['type']
       : never)
 

package/src/utils/transaction/prepareRequest.ts

@@ -17,7 +17,6 @@ import { AccountNotFoundError } from '../../errors/account.js'
 import { BaseError } from '../../errors/base.js'
 import type { GetAccountParameter } from '../../types/account.js'
 import type { Chain } from '../../types/chain.js'
-import { parseGwei } from '../unit/parseGwei.js'
 
 import { assertRequest } from './assertRequest.js'
 
@@ -43,7 +42,7 @@ export type PrepareRequestReturnType<
   nonce: SendTransactionParameters['nonce']
 }
 
-export const defaultTip = parseGwei('1.5')
+export const defaultTip = 1_500_000_000n // 1.5 gwei
 
 export async function prepareRequest<
   TChain extends Chain | undefined,

package/src/utils/transaction/serializeTransaction.ts

@@ -49,18 +49,18 @@ export function serializeTransaction<
     return serializeTransactionEIP1559(
       transaction as TransactionSerializableEIP1559,
       signature,
-    ) as SerializedTransactionReturnType
+    ) as SerializedTransactionReturnType<TTransactionSerializable>
 
   if (type === 'eip2930')
     return serializeTransactionEIP2930(
       transaction as TransactionSerializableEIP2930,
       signature,
-    ) as SerializedTransactionReturnType
+    ) as SerializedTransactionReturnType<TTransactionSerializable>
 
   return serializeTransactionLegacy(
     transaction as TransactionSerializableLegacy,
     signature,
-  ) as SerializedTransactionReturnType
+  ) as SerializedTransactionReturnType<TTransactionSerializable>
 }
 
 function serializeTransactionEIP1559(

package/src/utils/typedData.ts

@@ -11,8 +11,8 @@ import { numberToHex } from './encoding/toHex.js'
 import { bytesRegex, integerRegex } from './regex.js'
 
 export function validateTypedData<
-  TTypedData extends TypedData | { [key: string]: unknown },
-  TPrimaryType extends string = string,
+  const TTypedData extends TypedData | Record<string, unknown>, // `Record<string, unknown>` allows for non-const asserted types
+  TPrimaryType extends keyof TTypedData,
 >({
   domain,
   message,
@@ -68,7 +68,7 @@ export function validateTypedData<
 
   if (primaryType !== 'EIP712Domain') {
     // Validate message types.
-    const type = types[primaryType]
+    const type = types[primaryType as string]
     validateData(type, message as Record<string, unknown>)
   }
 }