viem 0.0.1-cjs.10 → 0.0.1-sushi.26

package/src/utils/index.test.ts

@@ -0,0 +1,111 @@
+import { expect, test } from 'vitest'
+
+import * as utils from './index'
+
+test('exports utils', () => {
+  expect(utils).toMatchInlineSnapshot(`
+    {
+      "boolToBytes": [Function],
+      "boolToHex": [Function],
+      "buildRequest": [Function],
+      "bytesToBigint": [Function],
+      "bytesToBool": [Function],
+      "bytesToHex": [Function],
+      "bytesToNumber": [Function],
+      "bytesToString": [Function],
+      "decodeAbi": [Function],
+      "decodeBytes": [Function],
+      "decodeErrorResult": [Function],
+      "decodeEventLog": [Function],
+      "decodeFunctionData": [Function],
+      "decodeFunctionResult": [Function],
+      "decodeHex": [Function],
+      "decodeRlp": [Function],
+      "defineBlock": [Function],
+      "defineChain": [Function],
+      "defineFormatter": [Function],
+      "defineTransaction": [Function],
+      "defineTransactionReceipt": [Function],
+      "defineTransactionRequest": [Function],
+      "encodeAbi": [Function],
+      "encodeBytes": [Function],
+      "encodeDeployData": [Function],
+      "encodeErrorResult": [Function],
+      "encodeEventTopics": [Function],
+      "encodeFunctionData": [Function],
+      "encodeFunctionResult": [Function],
+      "encodeHex": [Function],
+      "encodeRlp": [Function],
+      "etherUnits": {
+        "gwei": 9,
+        "wei": 18,
+      },
+      "extract": [Function],
+      "extractFunctionName": [Function],
+      "extractFunctionParams": [Function],
+      "extractFunctionParts": [Function],
+      "extractFunctionType": [Function],
+      "format": [Function],
+      "formatAbiItem": [Function],
+      "formatAbiItemWithArgs": [Function],
+      "formatBlock": [Function],
+      "formatEther": [Function],
+      "formatGwei": [Function],
+      "formatTransaction": [Function],
+      "formatTransactionRequest": [Function],
+      "formatUnit": [Function],
+      "getAbiItem": [Function],
+      "getAddress": [Function],
+      "getContractAddress": [Function],
+      "getContractError": [Function],
+      "getCreate2Address": [Function],
+      "getCreateAddress": [Function],
+      "getEventSignature": [Function],
+      "getFunctionSignature": [Function],
+      "gweiUnits": {
+        "ether": -9,
+        "wei": 9,
+      },
+      "hexToBigInt": [Function],
+      "hexToBool": [Function],
+      "hexToBytes": [Function],
+      "hexToNumber": [Function],
+      "hexToString": [Function],
+      "isAddress": [Function],
+      "isAddressEqual": [Function],
+      "isBytes": [Function],
+      "isHex": [Function],
+      "keccak256": [Function],
+      "numberToBytes": [Function],
+      "numberToHex": [Function],
+      "pad": [Function],
+      "padBytes": [Function],
+      "padHex": [Function],
+      "parseEther": [Function],
+      "parseGwei": [Function],
+      "parseUnit": [Function],
+      "rpc": {
+        "http": [Function],
+        "webSocket": [Function],
+        "webSocketAsync": [Function],
+      },
+      "size": [Function],
+      "slice": [Function],
+      "sliceBytes": [Function],
+      "sliceHex": [Function],
+      "stringToBytes": [Function],
+      "stringToHex": [Function],
+      "stringify": [Function],
+      "transactionType": {
+        "0x0": "legacy",
+        "0x1": "eip2930",
+        "0x2": "eip1559",
+      },
+      "trim": [Function],
+      "weiUnits": {
+        "ether": -18,
+        "gwei": -9,
+      },
+    }
+  `)
+})

package/src/utils/index.ts

@@ -0,0 +1,142 @@
+export type {
+  DecodeAbiArgs,
+  DecodeErrorResultArgs,
+  DecodeErrorResultResponse,
+  DecodeEventLogArgs,
+  DecodeEventLogResponse,
+  DecodeFunctionDataArgs,
+  DecodeFunctionResultArgs,
+  DecodeFunctionResultResponse,
+  EncodeAbiArgs,
+  EncodeDeployDataArgs,
+  EncodeErrorResultArgs,
+  EncodeEventTopicsArgs,
+  EncodeFunctionDataArgs,
+  EncodeFunctionResultArgs,
+  GetAbiItemArgs,
+} from './abi'
+export {
+  decodeAbi,
+  decodeErrorResult,
+  decodeEventLog,
+  decodeFunctionData,
+  decodeFunctionResult,
+  encodeAbi,
+  encodeDeployData,
+  encodeErrorResult,
+  encodeEventTopics,
+  encodeFunctionData,
+  encodeFunctionResult,
+  formatAbiItemWithArgs,
+  formatAbiItem,
+  getAbiItem,
+} from './abi'
+
+export type {
+  GetContractAddressOptions,
+  GetCreate2AddressOptions,
+  GetCreateAddressOptions,
+} from './address'
+export {
+  getAddress,
+  getContractAddress,
+  getCreateAddress,
+  getCreate2Address,
+  isAddress,
+  isAddressEqual,
+} from './address'
+
+export { buildRequest } from './buildRequest'
+
+export { defineChain } from './chain'
+
+export {
+  extractFunctionName,
+  extractFunctionParams,
+  extractFunctionType,
+  extractFunctionParts,
+  getContractError,
+} from './contract'
+
+export {
+  isBytes,
+  isHex,
+  pad,
+  padBytes,
+  padHex,
+  size,
+  slice,
+  sliceBytes,
+  sliceHex,
+  trim,
+} from './data'
+
+export type {
+  BlockFormatter,
+  ExtractFormatter,
+  Formatted,
+  FormattedBlock,
+  FormattedTransaction,
+  FormattedTransactionReceipt,
+  FormattedTransactionRequest,
+  TransactionFormatter,
+  TransactionReceiptFormatter,
+  TransactionRequestFormatter,
+} from './formatters'
+export {
+  defineBlock,
+  defineFormatter,
+  defineTransaction,
+  defineTransactionReceipt,
+  defineTransactionRequest,
+  extract,
+  format,
+  formatBlock,
+  formatTransaction,
+  formatTransactionRequest,
+  transactionType,
+} from './formatters'
+
+export type { EncodeRlpResponse } from './encoding'
+export {
+  boolToBytes,
+  boolToHex,
+  bytesToBigint,
+  bytesToBool,
+  bytesToHex,
+  bytesToNumber,
+  bytesToString,
+  decodeBytes,
+  decodeHex,
+  decodeRlp,
+  encodeBytes,
+  encodeHex,
+  encodeRlp,
+  hexToBool,
+  hexToBigInt,
+  hexToBytes,
+  hexToNumber,
+  hexToString,
+  numberToBytes,
+  numberToHex,
+  stringToBytes,
+  stringToHex,
+} from './encoding'
+
+export { getEventSignature, getFunctionSignature, keccak256 } from './hash'
+
+export { rpc } from './rpc'
+
+export { stringify } from './stringify'
+
+export {
+  etherUnits,
+  formatEther,
+  formatGwei,
+  formatUnit,
+  gweiUnits,
+  parseUnit,
+  parseEther,
+  parseGwei,
+  weiUnits,
+} from './unit'

package/src/utils/observe.test.ts

@@ -0,0 +1,176 @@
+import { expect, test, vi } from 'vitest'
+
+import { observe } from './observe'
+import { wait } from './wait'
+
+test('emits data to callbacks', async () => {
+  const id = 'mock'
+  const callback1 = vi.fn()
+  const callback2 = vi.fn()
+  const callback3 = vi.fn()
+
+  const emitter = vi.fn(({ emit }) => {
+    setTimeout(() => emit({ foo: 'bar' }), 100)
+    return () => {
+      //
+    }
+  })
+
+  const unwatch1 = observe(id, { emit: callback1 }, emitter)
+  const unwatch2 = observe(id, { emit: callback2 }, emitter)
+  const unwatch3 = observe(id, { emit: callback3 }, emitter)
+
+  await wait(100)
+
+  expect(emitter).toHaveBeenCalledOnce()
+  expect(callback1).toHaveBeenNthCalledWith(1, { foo: 'bar' })
+  expect(callback2).toHaveBeenNthCalledWith(1, { foo: 'bar' })
+  expect(callback3).toHaveBeenNthCalledWith(1, { foo: 'bar' })
+
+  unwatch1()
+  unwatch2()
+  unwatch3()
+})
+
+test('scopes to id', async () => {
+  const id1 = 'mock'
+  const callback1 = vi.fn()
+  const emitter1 = vi.fn(({ emit }) => {
+    setTimeout(() => emit({ foo: 'bar1' }), 100)
+    return () => {
+      //
+    }
+  })
+  const unwatch1 = observe(id1, { emit: callback1 }, emitter1)
+
+  const id2 = 'mock2'
+  const callback2 = vi.fn()
+  const emitter2 = vi.fn(({ emit }) => {
+    setTimeout(() => emit({ foo: 'bar2' }), 100)
+    return () => {
+      //
+    }
+  })
+  const unwatch2 = observe(id2, { emit: callback2 }, emitter2)
+
+  await wait(100)
+
+  expect(emitter1).toHaveBeenCalledTimes(1)
+  expect(emitter2).toHaveBeenCalledTimes(1)
+  expect(callback1).toHaveBeenNthCalledWith(1, { foo: 'bar1' })
+  expect(callback2).toHaveBeenNthCalledWith(1, { foo: 'bar2' })
+
+  unwatch1()
+  unwatch2()
+})
+
+test('cleans up listeners correctly (staggered unwatch)', async () => {
+  const id = 'mock'
+  const callback1 = vi.fn()
+  const callback2 = vi.fn()
+  const callback3 = vi.fn()
+
+  const emitter = vi.fn(({ emit }) => {
+    setTimeout(() => emit({ foo: 'bar' }), 100)
+    setTimeout(() => emit({ foo: 'bar' }), 200)
+    setTimeout(() => emit({ foo: 'bar' }), 300)
+    return () => {
+      //
+    }
+  })
+
+  const unwatch1 = observe(id, { emit: callback1 }, emitter)
+  const unwatch2 = observe(id, { emit: callback2 }, emitter)
+  const unwatch3 = observe(id, { emit: callback3 }, emitter)
+
+  unwatch1()
+
+  expect(emitter).toHaveBeenCalledOnce()
+
+  await wait(100)
+
+  expect(emitter).toHaveBeenCalledOnce()
+  expect(callback1).toHaveBeenCalledTimes(0)
+  expect(callback2).toHaveBeenCalledTimes(1)
+
+  unwatch2()
+
+  await wait(100)
+
+  expect(emitter).toHaveBeenCalledOnce()
+  expect(callback3).toHaveBeenCalledTimes(2)
+
+  unwatch3()
+})
+
+test('cleans up listeners correctly (immediately unwatch)', async () => {
+  const id = 'mock'
+  const callback1 = vi.fn()
+  const callback2 = vi.fn()
+  const callback3 = vi.fn()
+
+  const emitter = vi.fn(({ emit }) => {
+    setTimeout(() => emit({ foo: 'bar' }), 100)
+    setTimeout(() => emit({ foo: 'bar' }), 200)
+    return () => {
+      //
+    }
+  })
+
+  const unwatch1 = observe(id, { emit: callback1 }, emitter)
+  const unwatch2 = observe(id, { emit: callback2 }, emitter)
+  const unwatch3 = observe(id, { emit: callback3 }, emitter)
+
+  unwatch1()
+  unwatch2()
+  unwatch3()
+
+  await wait(300)
+
+  expect(emitter).toHaveBeenCalledOnce()
+  expect(callback1).toHaveBeenCalledTimes(0)
+  expect(callback2).toHaveBeenCalledTimes(0)
+  expect(callback3).toHaveBeenCalledTimes(0)
+})
+
+test('cleans up emit function correctly', async () => {
+  const id = 'mock'
+  const callback = vi.fn()
+
+  let active = true
+  const emitter = vi.fn(({ emit }) => {
+    setTimeout(() => emit({ foo: 'bar' }), 100)
+    setTimeout(() => emit({ foo: 'bar' }), 200)
+    setTimeout(() => emit({ foo: 'bar' }), 300)
+    return () => {
+      active = false
+    }
+  })
+
+  const unwatch1 = observe(id, { emit: callback }, emitter)
+  const unwatch2 = observe(id, { emit: callback }, emitter)
+  const unwatch3 = observe(id, { emit: callback }, emitter)
+
+  await wait(100)
+  expect(emitter).toHaveBeenCalledTimes(1)
+  expect(callback).toHaveBeenNthCalledWith(1, { foo: 'bar' })
+  expect(active).toBe(true)
+
+  unwatch1()
+
+  await wait(100)
+  expect(emitter).toHaveBeenCalledTimes(1)
+  expect(callback).toHaveBeenNthCalledWith(1, { foo: 'bar' })
+  expect(active).toBe(true)
+
+  unwatch2()
+
+  await wait(100)
+  expect(emitter).toHaveBeenCalledTimes(1)
+  expect(callback).toHaveBeenNthCalledWith(1, { foo: 'bar' })
+  expect(active).toBe(true)
+
+  unwatch3()
+
+  expect(active).toBe(false)
+})

package/src/utils/observe.ts

@@ -0,0 +1,66 @@
+import type { MaybePromise } from '../types/utils'
+
+type Callback = ((...args: any[]) => any) | undefined
+type Callbacks = Record<string, Callback>
+
+const listenersCache = new Map<string, { id: number; fns: Callbacks }[]>()
+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
+
+  let 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.test.ts

@@ -0,0 +1,127 @@
+import { expect, test } from 'vitest'
+
+import { poll } from './poll'
+import { wait } from './wait'
+
+test('polls on a given interval', async () => {
+  let items: string[] = []
+  poll(
+    async () => {
+      items.push('wagmi')
+    },
+    {
+      interval: 100,
+    },
+  )
+
+  await wait(500)
+  expect(items).toMatchInlineSnapshot(`
+    [
+      "wagmi",
+      "wagmi",
+      "wagmi",
+      "wagmi",
+    ]
+  `)
+})
+
+test('emitOnBegin', async () => {
+  let items: string[] = []
+  poll(
+    async () => {
+      items.push('wagmi')
+    },
+    {
+      emitOnBegin: true,
+      interval: 100,
+    },
+  )
+
+  await wait(500)
+  expect(items).toMatchInlineSnapshot(`
+    [
+      "wagmi",
+      "wagmi",
+      "wagmi",
+      "wagmi",
+      "wagmi",
+    ]
+  `)
+})
+
+test('initialWaitTime', async () => {
+  let items: string[] = []
+  poll(
+    async () => {
+      items.push('wagmi')
+    },
+    {
+      initialWaitTime: async () => 200,
+      interval: 100,
+    },
+  )
+
+  await wait(500)
+  expect(items).toMatchInlineSnapshot(`
+    [
+      "wagmi",
+      "wagmi",
+      "wagmi",
+    ]
+  `)
+})
+
+test('stop polling', async () => {
+  let items: string[] = []
+  const unpoll = poll(
+    async () => {
+      items.push('wagmi')
+    },
+    {
+      interval: 100,
+    },
+  )
+
+  await wait(500)
+  expect(items).toMatchInlineSnapshot(`
+    [
+      "wagmi",
+      "wagmi",
+      "wagmi",
+      "wagmi",
+    ]
+  `)
+
+  unpoll()
+
+  await wait(500)
+  expect(items).toMatchInlineSnapshot(`
+    [
+      "wagmi",
+      "wagmi",
+      "wagmi",
+      "wagmi",
+    ]
+  `)
+})
+
+test('stop polling via callback', async () => {
+  let items: string[] = []
+  poll(
+    async ({ unpoll }) => {
+      items.push('wagmi')
+      if (items.length === 2) unpoll()
+    },
+    {
+      interval: 100,
+    },
+  )
+
+  await wait(500)
+  expect(items).toMatchInlineSnapshot(`
+    [
+      "wagmi",
+      "wagmi",
+    ]
+  `)
+})

package/src/utils/poll.ts

@@ -0,0 +1,42 @@
+import { wait } from './wait'
+
+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.test.ts

@@ -0,0 +1,14 @@
+import { expect, test } from 'vitest'
+
+import * as utils from './index'
+
+test('exports utils', () => {
+  expect(utils).toMatchInlineSnapshot(`
+    {
+      "getCache": [Function],
+      "withCache": [Function],
+      "withRetry": [Function],
+      "withTimeout": [Function],
+    }
+  `)
+})

package/src/utils/promise/index.ts

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