viem 0.2.11 → 0.2.13

package/src/utils/index.ts

@@ -0,0 +1,212 @@
+export type {
+  DecodeAbiParametersReturnType,
+  DecodeErrorResultParameters,
+  DecodeErrorResultReturnType,
+  DecodeEventLogParameters,
+  DecodeEventLogReturnType,
+  DecodeFunctionDataParameters,
+  DecodeFunctionResultParameters,
+  DecodeFunctionResultReturnType,
+  EncodeAbiParametersReturnType,
+  EncodeDeployDataParameters,
+  EncodeErrorResultParameters,
+  EncodeEventTopicsParameters,
+  EncodeFunctionDataParameters,
+  EncodeFunctionResultParameters,
+  GetAbiItemParameters,
+  ParseAbi,
+  ParseAbiItem,
+  ParseAbiParameter,
+  ParseAbiParameters,
+} from './abi/index.js'
+export {
+  decodeAbiParameters,
+  decodeErrorResult,
+  decodeEventLog,
+  decodeFunctionData,
+  decodeFunctionResult,
+  encodeAbiParameters,
+  encodeDeployData,
+  encodeErrorResult,
+  encodeEventTopics,
+  encodeFunctionData,
+  encodeFunctionResult,
+  encodePacked,
+  formatAbiItemWithArgs,
+  formatAbiItem,
+  formatAbiParams,
+  getAbiItem,
+  parseAbi,
+  parseAbiItem,
+  parseAbiParameter,
+  parseAbiParameters,
+} from './abi/index.js'
+
+export { parseAccount, publicKeyToAddress } from './accounts.js'
+
+export type {
+  GetContractAddressOptions,
+  GetCreate2AddressOptions,
+  GetCreateAddressOptions,
+} from './address/index.js'
+export {
+  getAddress,
+  getContractAddress,
+  getCreateAddress,
+  getCreate2Address,
+  isAddress,
+  isAddressEqual,
+} from './address/index.js'
+
+export { buildRequest } from './buildRequest.js'
+
+export { defineChain, getChainContractAddress } from './chain.js'
+
+export {
+  extractFunctionName,
+  extractFunctionParams,
+  extractFunctionType,
+  extractFunctionParts,
+} from './contract/index.js'
+
+export {
+  concat,
+  concatBytes,
+  concatHex,
+  isBytes,
+  isHex,
+  pad,
+  padBytes,
+  padHex,
+  size,
+  slice,
+  sliceBytes,
+  sliceHex,
+  trim,
+} from './data/index.js'
+
+export type {
+  BlockFormatter,
+  ExtractFormatter,
+  Formatted,
+  FormattedBlock,
+  FormattedTransaction,
+  FormattedTransactionReceipt,
+  FormattedTransactionRequest,
+  TransactionFormatter,
+  TransactionReceiptFormatter,
+  TransactionRequestFormatter,
+} from './formatters/index.js'
+export {
+  defineBlock,
+  defineFormatter,
+  defineTransaction,
+  defineTransactionReceipt,
+  defineTransactionRequest,
+  extract,
+  format,
+  formatBlock,
+  formatTransaction,
+  formatTransactionRequest,
+  transactionType,
+} from './formatters/index.js'
+
+export type { ToRlpReturnType } from './encoding/index.js'
+export {
+  boolToBytes,
+  boolToHex,
+  bytesToBigint,
+  bytesToBool,
+  bytesToHex,
+  bytesToNumber,
+  bytesToString,
+  fromBytes,
+  fromHex,
+  fromRlp,
+  toBytes,
+  toHex,
+  toRlp,
+  hexToBool,
+  hexToBigInt,
+  hexToBytes,
+  hexToNumber,
+  hexToString,
+  numberToBytes,
+  numberToHex,
+  stringToBytes,
+  stringToHex,
+} from './encoding/index.js'
+
+export {
+  containsNodeError,
+  getCallError,
+  getContractError,
+  getEstimateGasError,
+  getNodeError,
+  getTransactionError,
+} from './errors/index.js'
+
+export {
+  getEventSelector,
+  getFunctionSelector,
+  isHash,
+  keccak256,
+} from './hash/index.js'
+
+export { arrayRegex, bytesRegex, integerRegex } from './regex.js'
+
+export type { HttpOptions, RpcResponse, Socket } from './rpc.js'
+export { getSocket, rpc } from './rpc.js'
+
+export type {
+  HashTypedDataParameters,
+  HashTypedDataReturnType,
+  RecoverAddressParameters,
+  RecoverAddressReturnType,
+  RecoverMessageAddressParameters,
+  RecoverMessageAddressReturnType,
+  RecoverTypedDataAddressParameters,
+  RecoverTypedDataAddressReturnType,
+  VerifyMessageParameters,
+  VerifyMessageReturnType,
+  VerifyTypedDataParameters,
+  VerifyTypedDataReturnType,
+} from './signature/index.js'
+export {
+  hashMessage,
+  hashTypedData,
+  recoverAddress,
+  recoverMessageAddress,
+  recoverTypedDataAddress,
+  verifyMessage,
+  verifyTypedData,
+} from './signature/index.js'
+
+export { stringify } from './stringify.js'
+
+export type {
+  GetSerializedTransactionType,
+  GetTransactionType,
+} from './transaction/index.js'
+export {
+  assertRequest,
+  assertTransactionEIP1559,
+  assertTransactionEIP2930,
+  assertTransactionLegacy,
+  getSerializedTransactionType,
+  getTransactionType,
+  parseTransaction,
+  prepareRequest,
+  serializeTransaction,
+} from './transaction/index.js'
+
+export { validateTypedData } from './typedData.js'
+
+export {
+  formatEther,
+  formatGwei,
+  formatUnits,
+  parseUnits,
+  parseEther,
+  parseGwei,
+} from './unit/index.js'

package/src/utils/observe.ts

@@ -0,0 +1,69 @@
+import type { MaybePromise } from '../types/utils.js'
+
+type Callback = ((...args: any[]) => any) | undefined
+type Callbacks = Record<string, Callback>
+
+export const listenersCache = new Map<
+  string,
+  { id: number; fns: Callbacks }[]
+>()
+export const cleanupCache = new Map<string, () => void>()
+
+type EmitFunction<TCallbacks extends Callbacks> = (
+  emit: TCallbacks,
+) => MaybePromise<void | (() => void)>
+
+let callbackCount = 0
+
+/**
+ * @description Sets up an observer for a given function. If another function
+ * is set up under the same observer id, the function will only be called once
+ * for both instances of the observer.
+ */
+export function observe<TCallbacks extends Callbacks>(
+  observerId: string,
+  callbacks: TCallbacks,
+  fn: EmitFunction<TCallbacks>,
+) {
+  const callbackId = ++callbackCount
+
+  const getListeners = () => listenersCache.get(observerId) || []
+
+  const unsubscribe = () => {
+    const listeners = getListeners()
+    listenersCache.set(
+      observerId,
+      listeners.filter((cb: any) => cb.id !== callbackId),
+    )
+  }
+
+  const unwatch = () => {
+    const cleanup = cleanupCache.get(observerId)
+    if (getListeners().length === 1 && cleanup) cleanup()
+    unsubscribe()
+  }
+
+  const listeners = getListeners()
+  listenersCache.set(observerId, [
+    ...listeners,
+    { id: callbackId, fns: callbacks },
+  ])
+
+  if (listeners && listeners.length > 0) return unwatch
+
+  const emit: TCallbacks = {} as TCallbacks
+  for (const key in callbacks) {
+    emit[key] = ((
+      ...args: Parameters<NonNullable<TCallbacks[keyof TCallbacks]>>
+    ) => {
+      const listeners = getListeners()
+      if (listeners.length === 0) return
+      listeners.forEach((listener) => listener.fns[key]?.(...args))
+    }) as TCallbacks[Extract<keyof TCallbacks, string>]
+  }
+
+  const cleanup = fn(emit)
+  if (typeof cleanup === 'function') cleanupCache.set(observerId, cleanup)
+
+  return unwatch
+}

package/src/utils/poll.ts

@@ -0,0 +1,42 @@
+import { wait } from './wait.js'
+
+type PollOptions<TData> = {
+  // Whether or not to emit when the polling starts.
+  emitOnBegin?: boolean
+  // The initial wait time (in ms) before polling.
+  initialWaitTime?: (data: TData | void) => Promise<number>
+  // The interval (in ms).
+  interval: number
+}
+
+/**
+ * @description Polls a function at a specified interval.
+ */
+export function poll<TData>(
+  fn: ({ unpoll }: { unpoll: () => void }) => Promise<TData | void>,
+  { emitOnBegin, initialWaitTime, interval }: PollOptions<TData>,
+) {
+  let active = true
+
+  const unwatch = () => (active = false)
+
+  const watch = async () => {
+    let data: TData | void
+    if (emitOnBegin) data = await fn({ unpoll: unwatch })
+
+    const initialWait = (await initialWaitTime?.(data)) ?? interval
+    await wait(initialWait)
+
+    const poll = async () => {
+      if (!active) return
+      await fn({ unpoll: unwatch })
+      await wait(interval)
+      poll()
+    }
+
+    poll()
+  }
+  watch()
+
+  return unwatch
+}

package/src/utils/promise/index.ts

@@ -0,0 +1,3 @@
+export { getCache, withCache } from './withCache.js'
+export { withRetry } from './withRetry.js'
+export { withTimeout } from './withTimeout.js'

package/src/utils/promise/withCache.ts

@@ -0,0 +1,73 @@
+export const promiseCache = new Map()
+export const responseCache = new Map()
+
+export function getCache<TData>(cacheKey: string) {
+  const buildCache = <TData>(cacheKey: string, cache: Map<string, TData>) => ({
+    clear: () => cache.delete(cacheKey),
+    get: () => cache.get(cacheKey),
+    set: (data: TData) => cache.set(cacheKey, data),
+  })
+
+  const promise = buildCache<Promise<TData>>(cacheKey, promiseCache)
+  const response = buildCache<{ created: Date; data: TData }>(
+    cacheKey,
+    responseCache,
+  )
+
+  return {
+    clear: () => {
+      promise.clear()
+      response.clear()
+    },
+    promise,
+    response,
+  }
+}
+
+export type WithCacheParameters = {
+  /** The key to cache the data against. */
+  cacheKey: string
+  /** The maximum age (in ms) of the cached value. Default: Infinity (no expiry) */
+  maxAge?: number
+}
+
+/**
+ * @description Returns the result of a given promise, and caches the result for
+ * subsequent invocations against a provided cache key.
+ */
+export async function withCache<TData>(
+  fn: () => Promise<TData>,
+  { cacheKey, maxAge = Infinity }: WithCacheParameters,
+) {
+  const cache = getCache<TData>(cacheKey)
+
+  // If a response exists in the cache, and it's not expired, return it
+  // and do not invoke the promise.
+  // If the max age is 0, the cache is disabled.
+  const response = cache.response.get()
+  if (response && maxAge > 0) {
+    const age = new Date().getTime() - response.created.getTime()
+    if (age < maxAge) return response.data
+  }
+
+  let promise = cache.promise.get()
+  if (!promise) {
+    promise = fn()
+
+    // Store the promise in the cache so that subsequent invocations
+    // will wait for the same promise to resolve (deduping).
+    cache.promise.set(promise)
+  }
+
+  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 })
+
+  return data
+}

package/src/utils/promise/withRetry.ts

@@ -0,0 +1,47 @@
+import { wait } from '../wait.js'
+
+export function withRetry<TData>(
+  fn: () => Promise<TData>,
+  {
+    delay: delay_ = 100,
+    retryCount = 2,
+    shouldRetry = () => true,
+  }: {
+    // The delay (in ms) between retries.
+    delay?: ((config: { count: number; error: Error }) => number) | number
+    // The max number of times to retry.
+    retryCount?: number
+    // Whether or not to retry when an error is thrown.
+    shouldRetry?: ({
+      count,
+      error,
+    }: {
+      count: number
+      error: Error
+    }) => Promise<boolean> | boolean
+  } = {},
+) {
+  return new Promise<TData>((resolve, reject) => {
+    const attemptRetry = async ({ count = 0 } = {}) => {
+      const retry = async ({ error }: { error: Error }) => {
+        const delay =
+          typeof delay_ === 'function' ? delay_({ count, error }) : delay_
+        if (delay) await wait(delay)
+        attemptRetry({ count: count + 1 })
+      }
+
+      try {
+        const data = await fn()
+        resolve(data)
+      } catch (err) {
+        if (
+          count < retryCount &&
+          (await shouldRetry({ count, error: err as Error }))
+        )
+          return retry({ error: err as Error })
+        reject(err)
+      }
+    }
+    attemptRetry()
+  })
+}

package/src/utils/promise/withTimeout.ts

@@ -0,0 +1,39 @@
+export function withTimeout<TData>(
+  fn: ({ signal }: { signal?: AbortController['signal'] }) => Promise<TData>,
+  {
+    errorInstance,
+    timeout,
+    signal,
+  }: {
+    // The error instance to throw when the timeout is reached.
+    errorInstance: Error
+    // The timeout (in ms).
+    timeout: number
+    // Whether or not the timeout should use an abort signal.
+    signal?: boolean
+  },
+): Promise<TData> {
+  return new Promise((resolve, reject) => {
+    ;(async () => {
+      let timeoutId!: NodeJS.Timeout
+      try {
+        const controller = new AbortController()
+        if (timeout > 0) {
+          timeoutId = setTimeout(() => {
+            if (signal) {
+              controller.abort()
+            } else {
+              reject(errorInstance)
+            }
+          }, timeout)
+        }
+        resolve(await fn({ signal: controller?.signal }))
+      } catch (err) {
+        if ((err as Error).name === 'AbortError') reject(errorInstance)
+        reject(err)
+      } finally {
+        clearTimeout(timeoutId)
+      }
+    })()
+  })
+}

package/src/utils/regex.ts

@@ -0,0 +1,10 @@
+export const arrayRegex = /^(.*)\[([0-9]*)\]$/
+
+// `bytes<M>`: binary type of `M` bytes, `0 < M <= 32`
+// https://regexr.com/6va55
+export const bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/
+
+// `(u)int<M>`: (un)signed integer type of `M` bits, `0 < M <= 256`, `M % 8 == 0`
+// https://regexr.com/6v8hp
+export const integerRegex =
+  /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/