viem 0.0.1-sushi.26 → 0.1.0

package/src/utils/index.test.ts

@@ -1,111 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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

@@ -1,176 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

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