viem 0.0.1-alpha.24 → 0.0.1-alpha.26

package/src/utils/rpc.ts

@@ -1,292 +0,0 @@
-import {
-  HttpRequestError,
-  RpcError,
-  TimeoutError,
-  WebSocketRequestError,
-} from '../errors'
-import { withRetry } from './promise'
-import { withTimeout } from './promise/withTimeout'
-import { stringify } from './stringify'
-
-let id = 0
-
-type SuccessResult<T> = {
-  method?: never
-  result: T
-  error?: never
-}
-type ErrorResult<T> = {
-  method?: never
-  result?: never
-  error: T
-}
-type Subscription<TResult, TError> = {
-  method: 'eth_subscription'
-  error?: never
-  result?: never
-  params: {
-    subscription: string
-  } & (
-    | {
-        result: TResult
-        error?: never
-      }
-    | {
-        result?: never
-        error: TError
-      }
-  )
-}
-
-type RpcRequest = { method: string; params?: any[] }
-
-export type RpcResponse<TResult = any, TError = any> = {
-  jsonrpc: `${number}`
-  id: number
-} & (
-  | SuccessResult<TResult>
-  | ErrorResult<TError>
-  | Subscription<TResult, TError>
-)
-
-///////////////////////////////////////////////////
-// HTTP
-
-async function http(
-  url: string,
-  {
-    body,
-    retryDelay = 100,
-    retryCount = 2,
-    timeout = 0,
-  }: {
-    // The RPC request body.
-    body: RpcRequest
-    // The base delay (in ms) between retries.
-    retryDelay?: number
-    // The max number of times to retry.
-    retryCount?: number
-    // The timeout (in ms) for the request.
-    timeout?: number
-  },
-) {
-  const response = await withRetry(
-    () =>
-      withTimeout(
-        async ({ signal }) => {
-          const response = await fetch(url, {
-            headers: {
-              'Content-Type': 'application/json',
-            },
-            method: 'POST',
-            body: stringify({ jsonrpc: '2.0', id: id++, ...body }),
-            signal: timeout > 0 ? signal : undefined,
-          })
-          return response
-        },
-        {
-          errorInstance: new TimeoutError({ body, url }),
-          timeout,
-          signal: true,
-        },
-      ),
-    {
-      delay: ({ count, data }) => {
-        // If we find a Retry-After header, let's retry after the given time.
-        const retryAfter = data?.headers.get('Retry-After')
-        if (retryAfter?.match(/\d/)) return parseInt(retryAfter) * 1000
-
-        // Otherwise, let's retry with an exponential backoff.
-        return ~~((Math.random() + 0.5) * (1 << count)) * retryDelay
-      },
-      retryCount,
-      shouldRetryOnResponse: async ({ data }) => {
-        if (data.status >= 500) return true
-        if ([408, 413, 429].includes(data.status)) return true
-        return false
-      },
-    },
-  )
-
-  let data
-  if (response.headers.get('Content-Type')?.startsWith('application/json')) {
-    data = await response.json()
-  } else {
-    data = await response.text()
-  }
-
-  if (!response.ok) {
-    throw new HttpRequestError({
-      body,
-      details: stringify(data.error) || response.statusText,
-      status: response.status,
-      url,
-    })
-  }
-
-  if (data.error) {
-    throw new RpcError({ body, error: data.error, url })
-  }
-  return data as RpcResponse
-}
-
-///////////////////////////////////////////////////
-// WebSocket
-
-type Id = string | number
-type CallbackFn = (message: any) => void
-type CallbackMap = Map<Id, CallbackFn>
-
-export type Socket = WebSocket & {
-  requests: CallbackMap
-  subscriptions: CallbackMap
-}
-
-const sockets = new Map<string, Socket>()
-
-export async function getSocket(url_: string) {
-  const url = new URL(url_)
-  const urlKey = url.toString()
-
-  let socket = sockets.get(urlKey)
-
-  // If the socket already exists, return it.
-  if (socket) return socket
-
-  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 = ({ data }: { data: string }) => {
-    const message: RpcResponse = JSON.parse(data)
-    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)
-
-  // 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)
-
-  return 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
-  },
-) {
-  if (
-    socket.readyState === socket.CLOSED ||
-    socket.readyState === socket.CLOSING
-  )
-    throw new WebSocketRequestError({
-      body,
-      url: socket.url,
-      details: 'Socket is closed.',
-    })
-
-  const id_ = id++
-
-  const callback = ({ data }: { data: any }) => {
-    const message: RpcResponse = JSON.parse(data)
-
-    if (typeof message.id === 'number' && id_ !== message.id) return
-
-    if (message.error) {
-      onError?.(new RpcError({ body, error: message.error, url: socket.url }))
-    } else {
-      onData?.(message)
-    }
-
-    // If we are subscribing to a topic, we want to set up a listener for incoming
-    // messages.
-    if (body.method === 'eth_subscribe' && typeof message.result === 'string') {
-      socket.subscriptions.set(message.result, callback)
-    }
-
-    // If we are unsubscribing from a topic, we want to remove the listener.
-    if (body.method === 'eth_unsubscribe') {
-      socket.subscriptions.delete(body.params?.[0])
-    }
-  }
-  socket.requests.set(id_, callback)
-
-  socket.send(JSON.stringify({ jsonrpc: '2.0', ...body, id: id_ }))
-
-  return socket
-}
-
-async function webSocketAsync(
-  socket: Socket,
-  {
-    body,
-    timeout = 0,
-  }: {
-    // The RPC request body.
-    body: RpcRequest
-    // The timeout (in ms) for the request.
-    timeout?: number
-  },
-) {
-  return withTimeout(
-    () =>
-      new Promise<RpcResponse>((onData, onError) =>
-        rpc.webSocket(socket, {
-          body,
-          onData,
-          onError,
-        }),
-      ),
-    {
-      errorInstance: new TimeoutError({ body, url: socket.url }),
-      timeout,
-    },
-  )
-}
-
-///////////////////////////////////////////////////
-
-export const rpc = {
-  http,
-  webSocket,
-  webSocketAsync,
-}

package/src/utils/stringify.test.ts

@@ -1,13 +0,0 @@
-import { expect, test } from 'vitest'
-import { stringify } from './stringify'
-
-test('default', () => {
-  expect(
-    stringify({
-      foo: 'bar',
-      baz: {
-        value: 69n,
-      },
-    }),
-  ).toEqual('{"foo":"bar","baz":{"value":"69"}}')
-})

package/src/utils/stringify.ts

@@ -1,5 +0,0 @@
-export function stringify(value: unknown) {
-  return JSON.stringify(value, (_, value) =>
-    typeof value === 'bigint' ? value.toString() : value,
-  )
-}

package/src/utils/uid.ts

@@ -1,14 +0,0 @@
-let size = 256
-let index = size
-let buffer: string
-
-export function uid(length = 11) {
-  if (!buffer || index + length > size * 2) {
-    buffer = ''
-    index = 0
-    for (let i = 0; i < size; i++) {
-      buffer += ((256 + Math.random() * 256) | 0).toString(16).substring(1)
-    }
-  }
-  return buffer.substring(index, index++ + length)
-}

package/src/utils/unit/constants.test.ts

@@ -1,22 +0,0 @@
-import { expect, test } from 'vitest'
-
-import * as constants from './constants'
-
-test('exports constants', () => {
-  expect(constants).toMatchInlineSnapshot(`
-    {
-      "etherUnits": {
-        "gwei": 9,
-        "wei": 18,
-      },
-      "gweiUnits": {
-        "ether": -9,
-        "wei": 9,
-      },
-      "weiUnits": {
-        "ether": -18,
-        "gwei": -9,
-      },
-    }
-  `)
-})

package/src/utils/unit/constants.ts

@@ -1,12 +0,0 @@
-export const etherUnits = {
-  gwei: 9,
-  wei: 18,
-}
-export const gweiUnits = {
-  ether: -9,
-  wei: 9,
-}
-export const weiUnits = {
-  ether: -18,
-  gwei: -9,
-}

package/src/utils/unit/formatEther.test.ts

@@ -1,75 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { formatEther } from './formatEther'
-
-test('converts wei to ether', () => {
-  expect(formatEther(6942069420123456789123450000n)).toMatchInlineSnapshot(
-    '"6942069420.12345678912345"',
-  )
-  expect(formatEther(6942069420000000000000000000n)).toMatchInlineSnapshot(
-    '"6942069420"',
-  )
-  expect(formatEther(1000000000000000000n)).toMatchInlineSnapshot('"1"')
-  expect(formatEther(500000000000000000n)).toMatchInlineSnapshot('"0.5"')
-  expect(formatEther(100000000000000000n)).toMatchInlineSnapshot('"0.1"')
-  expect(formatEther(10000000n)).toMatchInlineSnapshot('"0.00000000001"')
-  expect(formatEther(1000000n)).toMatchInlineSnapshot('"0.000000000001"')
-  expect(formatEther(100000n)).toMatchInlineSnapshot('"0.0000000000001"')
-  expect(formatEther(10000n)).toMatchInlineSnapshot('"0.00000000000001"')
-  expect(formatEther(1000n)).toMatchInlineSnapshot('"0.000000000000001"')
-  expect(formatEther(100n)).toMatchInlineSnapshot('"0.0000000000000001"')
-  expect(formatEther(10n)).toMatchInlineSnapshot('"0.00000000000000001"')
-  expect(formatEther(1n)).toMatchInlineSnapshot('"0.000000000000000001"')
-  expect(formatEther(-6942069420123456789123450000n)).toMatchInlineSnapshot(
-    '"-6942069420.12345678912345"',
-  )
-  expect(formatEther(-6942069420000000000000000000n)).toMatchInlineSnapshot(
-    '"-6942069420"',
-  )
-  expect(formatEther(-1000000000000000000n)).toMatchInlineSnapshot('"-1"')
-  expect(formatEther(-500000000000000000n)).toMatchInlineSnapshot('"-0.5"')
-  expect(formatEther(-100000000000000000n)).toMatchInlineSnapshot('"-0.1"')
-  expect(formatEther(-10000000n)).toMatchInlineSnapshot('"-0.00000000001"')
-  expect(formatEther(-1000000n)).toMatchInlineSnapshot('"-0.000000000001"')
-  expect(formatEther(-100000n)).toMatchInlineSnapshot('"-0.0000000000001"')
-  expect(formatEther(-10000n)).toMatchInlineSnapshot('"-0.00000000000001"')
-  expect(formatEther(-1000n)).toMatchInlineSnapshot('"-0.000000000000001"')
-  expect(formatEther(-100n)).toMatchInlineSnapshot('"-0.0000000000000001"')
-  expect(formatEther(-10n)).toMatchInlineSnapshot('"-0.00000000000000001"')
-  expect(formatEther(-1n)).toMatchInlineSnapshot('"-0.000000000000000001"')
-})
-
-test('converts gwei to ether', () => {
-  expect(formatEther(69420123456700n, 'gwei')).toMatchInlineSnapshot(
-    '"69420.1234567"',
-  )
-  expect(formatEther(69420000000000n, 'gwei')).toMatchInlineSnapshot('"69420"')
-  expect(formatEther(1000000000n, 'gwei')).toMatchInlineSnapshot('"1"')
-  expect(formatEther(500000000n, 'gwei')).toMatchInlineSnapshot('"0.5"')
-  expect(formatEther(100000000n, 'gwei')).toMatchInlineSnapshot('"0.1"')
-  expect(formatEther(10000000n, 'gwei')).toMatchInlineSnapshot('"1000000"')
-  expect(formatEther(1000000n, 'gwei')).toMatchInlineSnapshot('"10000"')
-  expect(formatEther(100000n, 'gwei')).toMatchInlineSnapshot('"100"')
-  expect(formatEther(10000n, 'gwei')).toMatchInlineSnapshot('"1"')
-  expect(formatEther(1000n, 'gwei')).toMatchInlineSnapshot('"0.000001"')
-  expect(formatEther(100n, 'gwei')).toMatchInlineSnapshot('"0.0000001"')
-  expect(formatEther(10n, 'gwei')).toMatchInlineSnapshot('"0.00000001"')
-  expect(formatEther(1n, 'gwei')).toMatchInlineSnapshot('"0.000000001"')
-  expect(formatEther(-69420123456700n, 'gwei')).toMatchInlineSnapshot(
-    '"-69420.1234567"',
-  )
-  expect(formatEther(-69420000000000n, 'gwei')).toMatchInlineSnapshot(
-    '"-69420"',
-  )
-  expect(formatEther(-1000000000n, 'gwei')).toMatchInlineSnapshot('"-1"')
-  expect(formatEther(-500000000n, 'gwei')).toMatchInlineSnapshot('"-0.5"')
-  expect(formatEther(-100000000n, 'gwei')).toMatchInlineSnapshot('"-0.1"')
-  expect(formatEther(-10000000n, 'gwei')).toMatchInlineSnapshot('"-1000000"')
-  expect(formatEther(-1000000n, 'gwei')).toMatchInlineSnapshot('"-10000"')
-  expect(formatEther(-100000n, 'gwei')).toMatchInlineSnapshot('"-100"')
-  expect(formatEther(-10000n, 'gwei')).toMatchInlineSnapshot('"-1"')
-  expect(formatEther(-1000n, 'gwei')).toMatchInlineSnapshot('"-0.000001"')
-  expect(formatEther(-100n, 'gwei')).toMatchInlineSnapshot('"-0.0000001"')
-  expect(formatEther(-10n, 'gwei')).toMatchInlineSnapshot('"-0.00000001"')
-  expect(formatEther(-1n, 'gwei')).toMatchInlineSnapshot('"-0.000000001"')
-})

package/src/utils/unit/formatEther.ts

@@ -1,6 +0,0 @@
-import { etherUnits } from '../../utils'
-import { formatUnit } from './formatUnit'
-
-export function formatEther(wei: bigint, unit: 'wei' | 'gwei' = 'wei') {
-  return formatUnit(wei, etherUnits[unit])
-}

package/src/utils/unit/formatGwei.test.ts

@@ -1,32 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { formatGwei } from './formatGwei'
-
-test('converts wei to gwei', () => {
-  expect(formatGwei(69420123456700n)).toMatchInlineSnapshot('"69420.1234567"')
-  expect(formatGwei(69420000000000n)).toMatchInlineSnapshot('"69420"')
-  expect(formatGwei(1000000000n)).toMatchInlineSnapshot('"1"')
-  expect(formatGwei(500000000n)).toMatchInlineSnapshot('"0.5"')
-  expect(formatGwei(100000000n)).toMatchInlineSnapshot('"0.1"')
-  expect(formatGwei(10000000n)).toMatchInlineSnapshot('"1000000"')
-  expect(formatGwei(1000000n)).toMatchInlineSnapshot('"10000"')
-  expect(formatGwei(100000n)).toMatchInlineSnapshot('"100"')
-  expect(formatGwei(10000n)).toMatchInlineSnapshot('"1"')
-  expect(formatGwei(1000n)).toMatchInlineSnapshot('"0.000001"')
-  expect(formatGwei(100n)).toMatchInlineSnapshot('"0.0000001"')
-  expect(formatGwei(10n)).toMatchInlineSnapshot('"0.00000001"')
-  expect(formatGwei(1n)).toMatchInlineSnapshot('"0.000000001"')
-  expect(formatGwei(-69420123456700n)).toMatchInlineSnapshot('"-69420.1234567"')
-  expect(formatGwei(-69420000000000n)).toMatchInlineSnapshot('"-69420"')
-  expect(formatGwei(-1000000000n)).toMatchInlineSnapshot('"-1"')
-  expect(formatGwei(-500000000n)).toMatchInlineSnapshot('"-0.5"')
-  expect(formatGwei(-100000000n)).toMatchInlineSnapshot('"-0.1"')
-  expect(formatGwei(-10000000n)).toMatchInlineSnapshot('"-1000000"')
-  expect(formatGwei(-1000000n)).toMatchInlineSnapshot('"-10000"')
-  expect(formatGwei(-100000n)).toMatchInlineSnapshot('"-100"')
-  expect(formatGwei(-10000n)).toMatchInlineSnapshot('"-1"')
-  expect(formatGwei(-1000n)).toMatchInlineSnapshot('"-0.000001"')
-  expect(formatGwei(-100n)).toMatchInlineSnapshot('"-0.0000001"')
-  expect(formatGwei(-10n)).toMatchInlineSnapshot('"-0.00000001"')
-  expect(formatGwei(-1n)).toMatchInlineSnapshot('"-0.000000001"')
-})

package/src/utils/unit/formatGwei.ts

@@ -1,6 +0,0 @@
-import { gweiUnits } from '../../utils'
-import { formatUnit } from './formatUnit'
-
-export function formatGwei(wei: bigint, unit: 'wei' = 'wei') {
-  return formatUnit(wei, gweiUnits[unit])
-}

package/src/utils/unit/formatUnit.bench.ts

@@ -1,21 +0,0 @@
-import { bench, describe } from 'vitest'
-import { utils } from 'ethers'
-import Web3 from 'web3'
-
-import { formatUnit } from './formatUnit'
-
-const web3 = new Web3()
-
-describe('Format Unit', () => {
-  bench('viem: `formatUnit`', () => {
-    formatUnit(40000000000000000000n, 18)
-  })
-
-  bench('ethers: `formatUnits`', () => {
-    utils.formatUnits(40000000000000000000n, 18)
-  })
-
-  bench('web3.js: `toWei`', () => {
-    web3.utils.toWei('40000000000000000000')
-  })
-})

package/src/utils/unit/formatUnit.test.ts

@@ -1,40 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { formatUnit } from './formatUnit'
-
-test('converts value to number', () => {
-  expect(formatUnit(69n, 0)).toMatchInlineSnapshot('"69"')
-  expect(formatUnit(69n, 5)).toMatchInlineSnapshot('"0.00069"')
-  expect(formatUnit(690n, 1)).toMatchInlineSnapshot('"69"')
-  expect(formatUnit(1300000n, 5)).toMatchInlineSnapshot('"13"')
-  expect(formatUnit(4200000000000n, 10)).toMatchInlineSnapshot('"420"')
-  expect(formatUnit(20000000000n, 9)).toMatchInlineSnapshot('"20"')
-  expect(formatUnit(40000000000000000000n, 18)).toMatchInlineSnapshot('"40"')
-  expect(formatUnit(12345n, 4)).toMatchInlineSnapshot('"1.2345"')
-  expect(formatUnit(12345n, 4)).toMatchInlineSnapshot('"1.2345"')
-  expect(formatUnit(6942069420123456789123450000n, 18)).toMatchInlineSnapshot(
-    '"6942069420.12345678912345"',
-  )
-  expect(
-    formatUnit(
-      694212312312306942012345444446789123450000000000000000000000000000000n,
-      50,
-    ),
-  ).toMatchInlineSnapshot('"6942123123123069420.1234544444678912345"')
-  expect(formatUnit(-690n, 1)).toMatchInlineSnapshot('"-69"')
-  expect(formatUnit(-1300000n, 5)).toMatchInlineSnapshot('"-13"')
-  expect(formatUnit(-4200000000000n, 10)).toMatchInlineSnapshot('"-420"')
-  expect(formatUnit(-20000000000n, 9)).toMatchInlineSnapshot('"-20"')
-  expect(formatUnit(-40000000000000000000n, 18)).toMatchInlineSnapshot('"-40"')
-  expect(formatUnit(-12345n, 4)).toMatchInlineSnapshot('"-1.2345"')
-  expect(formatUnit(-12345n, 4)).toMatchInlineSnapshot('"-1.2345"')
-  expect(formatUnit(-6942069420123456789123450000n, 18)).toMatchInlineSnapshot(
-    '"-6942069420.12345678912345"',
-  )
-  expect(
-    formatUnit(
-      -694212312312306942012345444446789123450000000000000000000000000000000n,
-      50,
-    ),
-  ).toMatchInlineSnapshot('"-6942123123123069420.1234544444678912345"')
-})

package/src/utils/unit/formatUnit.ts

@@ -1,16 +0,0 @@
-export function formatUnit(value: bigint, decimals: number) {
-  let display = value.toString()
-
-  const negative = display.startsWith('-')
-  if (negative) display = display.slice(1)
-
-  let [integer, fraction] = [
-    display.slice(0, display.length - decimals),
-    display.slice(display.length - decimals),
-  ]
-  fraction = fraction.padStart(decimals, '0')
-  fraction = fraction.replace(/(0+)$/, '')
-  return `${negative ? '-' : ''}${integer || '0'}${
-    fraction ? `.${fraction}` : ''
-  }`
-}

package/src/utils/unit/index.test.ts

@@ -1,28 +0,0 @@
-import { expect, test } from 'vitest'
-
-import * as value from './index'
-
-test('exports value utils', () => {
-  expect(value).toMatchInlineSnapshot(`
-    {
-      "etherUnits": {
-        "gwei": 9,
-        "wei": 18,
-      },
-      "formatEther": [Function],
-      "formatGwei": [Function],
-      "formatUnit": [Function],
-      "gweiUnits": {
-        "ether": -9,
-        "wei": 9,
-      },
-      "parseEther": [Function],
-      "parseGwei": [Function],
-      "parseUnit": [Function],
-      "weiUnits": {
-        "ether": -18,
-        "gwei": -9,
-      },
-    }
-  `)
-})

package/src/utils/unit/index.ts

@@ -1,7 +0,0 @@
-export { etherUnits, gweiUnits, weiUnits } from './constants'
-export { formatEther } from './formatEther'
-export { formatGwei } from './formatGwei'
-export { formatUnit } from './formatUnit'
-export { parseUnit } from './parseUnit'
-export { parseEther } from './parseEther'
-export { parseGwei } from './parseGwei'