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

package/src/utils/rpc.ts

@@ -0,0 +1,294 @@
+import fetch from 'isomorphic-unfetch'
+import WebSocket from 'isomorphic-ws'
+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 = 150,
+    retryCount = 3,
+    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 ~~(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: (event: WebSocket.MessageEvent) => void = ({ data }) => {
+    const message: RpcResponse = JSON.parse(data as string)
+    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

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

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

package/src/utils/uid.ts

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

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

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

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

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

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

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

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

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

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

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

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