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

package/src/utils/encoding/encodeHex.bench.ts

@@ -0,0 +1,49 @@
+import { hexlify } from 'ethers/lib/utils'
+import { bench, describe } from 'vitest'
+import Web3 from 'web3'
+
+import { bytesToHex, numberToHex, stringToHex } from './encodeHex'
+
+describe('Number to Hex', () => {
+  bench('viem: `numberToHex`', () => {
+    numberToHex(52)
+  })
+
+  bench('ethers: `hexlify`', () => {
+    hexlify(52)
+  })
+
+  bench('web3.js: `numberToHex`', () => {
+    Web3.utils.numberToHex(52)
+  })
+})
+
+describe('String to Hex', () => {
+  bench('viem: `stringToHex`', () => {
+    stringToHex('Hello world.')
+  })
+
+  bench('web3.js: `stringToHex`', () => {
+    Web3.utils.stringToHex('Hello world.')
+  })
+})
+
+describe('Bytes to Hex', () => {
+  bench('viem: `bytesToHex`', () => {
+    bytesToHex(
+      new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),
+    )
+  })
+
+  bench('ethers: `hexlify`', () => {
+    hexlify(
+      new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),
+    )
+  })
+
+  bench('web3.js: `bytesToHex`', () => {
+    Web3.utils.bytesToHex([
+      72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33,
+    ])
+  })
+})

package/src/utils/encoding/encodeHex.test.ts

@@ -0,0 +1,232 @@
+import { describe, expect, test } from 'vitest'
+
+import {
+  boolToHex,
+  bytesToHex,
+  encodeHex,
+  numberToHex,
+  stringToHex,
+} from './encodeHex'
+
+describe('converts numbers to hex', () => {
+  test('default', () => {
+    expect(encodeHex(0)).toMatchInlineSnapshot('"0x0"')
+    expect(encodeHex(7)).toMatchInlineSnapshot('"0x7"')
+    expect(encodeHex(69)).toMatchInlineSnapshot('"0x45"')
+    expect(encodeHex(420)).toMatchInlineSnapshot('"0x1a4"')
+
+    expect(numberToHex(0)).toMatchInlineSnapshot('"0x0"')
+    expect(numberToHex(7)).toMatchInlineSnapshot('"0x7"')
+    expect(numberToHex(69)).toMatchInlineSnapshot('"0x45"')
+    expect(numberToHex(420)).toMatchInlineSnapshot('"0x1a4"')
+
+    expect(() =>
+      numberToHex(420182738912731283712937129),
+    ).toThrowErrorMatchingInlineSnapshot(
+      '"Number \\"4.2018273891273126e+26\\" is not in safe integer range (0 to 9007199254740991)"',
+    )
+    expect(() => numberToHex(-69)).toThrowErrorMatchingInlineSnapshot(
+      '"Number \\"-69\\" is not in safe integer range (0 to 9007199254740991)"',
+    )
+  })
+
+  test('args: size', () => {
+    expect(numberToHex(7, { size: 1 })).toBe('0x07')
+    expect(numberToHex(10, { size: 2 })).toBe('0x000a')
+    expect(numberToHex(69, { size: 4 })).toBe('0x00000045')
+
+    expect(() =>
+      numberToHex(-7, { size: 1 }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      '"Number \\"-7\\" is not in safe 8-bit unsigned integer range (0 to 255)"',
+    )
+    expect(() =>
+      numberToHex(256, { size: 1 }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      '"Number \\"256\\" is not in safe 8-bit unsigned integer range (0 to 255)"',
+    )
+    expect(() =>
+      numberToHex(65536, { size: 2 }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      '"Number \\"65536\\" is not in safe 16-bit unsigned integer range (0 to 65535)"',
+    )
+  })
+
+  test('args: signed', () => {
+    expect(numberToHex(32, { size: 1, signed: true })).toBe('0x20')
+    expect(
+      numberToHex(-32, {
+        size: 1,
+        signed: true,
+      }),
+    ).toBe('0xe0')
+    expect(
+      numberToHex(-32, {
+        size: 4,
+        signed: true,
+      }),
+    ).toBe('0xffffffe0')
+
+    expect(numberToHex(127, { size: 2, signed: true })).toBe('0x007f')
+    expect(numberToHex(-127, { size: 2, signed: true })).toBe('0xff81')
+    expect(numberToHex(32767, { size: 2, signed: true })).toBe('0x7fff')
+    expect(numberToHex(-32768, { size: 2, signed: true })).toBe('0x8000')
+    expect(() =>
+      numberToHex(32768, { size: 2, signed: true }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      '"Number \\"32768\\" is not in safe 16-bit signed integer range (-32768 to 32767)"',
+    )
+    expect(() =>
+      numberToHex(-32769, { size: 2, signed: true }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      '"Number \\"-32769\\" is not in safe 16-bit signed integer range (-32768 to 32767)"',
+    )
+  })
+})
+
+describe('converts bigints to hex', () => {
+  test('default', () => {
+    expect(encodeHex(0)).toMatchInlineSnapshot('"0x0"')
+    expect(encodeHex(7n)).toMatchInlineSnapshot('"0x7"')
+    expect(encodeHex(69n)).toMatchInlineSnapshot('"0x45"')
+    expect(encodeHex(420n)).toMatchInlineSnapshot('"0x1a4"')
+    expect(
+      encodeHex(4206942069420694206942069420694206942069n),
+    ).toMatchInlineSnapshot('"0xc5cf39211876fb5e5884327fa56fc0b75"')
+
+    expect(numberToHex(0)).toMatchInlineSnapshot('"0x0"')
+    expect(numberToHex(7n)).toMatchInlineSnapshot('"0x7"')
+    expect(numberToHex(69n)).toMatchInlineSnapshot('"0x45"')
+    expect(numberToHex(420n)).toMatchInlineSnapshot('"0x1a4"')
+    expect(
+      numberToHex(4206942069420694206942069420694206942069n),
+    ).toMatchInlineSnapshot('"0xc5cf39211876fb5e5884327fa56fc0b75"')
+
+    expect(() => numberToHex(-69n)).toThrowErrorMatchingInlineSnapshot(
+      '"Number \\"-69n\\" is not in safe integer range (above 0)"',
+    )
+  })
+
+  test('args: size', () => {
+    expect(numberToHex(7n, { size: 1 })).toBe('0x07')
+    expect(numberToHex(10n, { size: 2 })).toBe('0x000a')
+    expect(numberToHex(69n, { size: 4 })).toBe('0x00000045')
+    expect(numberToHex(6123123124124124213123129n, { size: 32 })).toBe(
+      '0x00000000000000000000000000000000000000000005109f2b700e30e5b39839',
+    )
+
+    expect(() =>
+      numberToHex(-7n, { size: 1 }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      '"Number \\"-7n\\" is not in safe 8-bit unsigned integer range (0n to 255n)"',
+    )
+    expect(() =>
+      numberToHex(256n, { size: 1 }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      '"Number \\"256n\\" is not in safe 8-bit unsigned integer range (0n to 255n)"',
+    )
+    expect(() =>
+      numberToHex(65536n, { size: 2 }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      '"Number \\"65536n\\" is not in safe 16-bit unsigned integer range (0n to 65535n)"',
+    )
+    expect(() =>
+      numberToHex(18446744073709551616n, { size: 8 }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      '"Number \\"18446744073709551616n\\" is not in safe 64-bit unsigned integer range (0n to 18446744073709551615n)"',
+    )
+  })
+
+  test('args: signed', () => {
+    expect(numberToHex(32n, { size: 1, signed: true })).toBe('0x20')
+    expect(
+      numberToHex(-32n, {
+        size: 1,
+        signed: true,
+      }),
+    ).toBe('0xe0')
+    expect(
+      numberToHex(-32n, {
+        size: 4,
+        signed: true,
+      }),
+    ).toBe('0xffffffe0')
+
+    expect(numberToHex(127n, { size: 2, signed: true })).toBe('0x007f')
+    expect(numberToHex(-127n, { size: 2, signed: true })).toBe('0xff81')
+    expect(numberToHex(32767n, { size: 2, signed: true })).toBe('0x7fff')
+    expect(numberToHex(-32768n, { size: 2, signed: true })).toBe('0x8000')
+
+    expect(numberToHex(12312312312312312412n, { size: 32, signed: true })).toBe(
+      '0x000000000000000000000000000000000000000000000000aade1ed08b0b325c',
+    )
+    expect(
+      numberToHex(-12312312312312312412n, { size: 32, signed: true }),
+    ).toBe('0xffffffffffffffffffffffffffffffffffffffffffffffff5521e12f74f4cda4')
+
+    expect(() =>
+      numberToHex(170141183460469231731687303715884105728n, {
+        size: 16,
+        signed: true,
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      '"Number \\"170141183460469231731687303715884105728n\\" is not in safe 128-bit signed integer range (-170141183460469231731687303715884105728n to 170141183460469231731687303715884105727n)"',
+    )
+    expect(() =>
+      numberToHex(-170141183460469231731687303715884105729n, {
+        size: 16,
+        signed: true,
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      '"Number \\"-170141183460469231731687303715884105729n\\" is not in safe 128-bit signed integer range (-170141183460469231731687303715884105728n to 170141183460469231731687303715884105727n)"',
+    )
+  })
+})
+
+test('converts boolean to hex', () => {
+  expect(encodeHex(true)).toMatchInlineSnapshot('"0x1"')
+  expect(encodeHex(false)).toMatchInlineSnapshot('"0x0"')
+
+  expect(boolToHex(true)).toMatchInlineSnapshot('"0x1"')
+  expect(boolToHex(false)).toMatchInlineSnapshot('"0x0"')
+})
+
+test('converts string to hex', () => {
+  expect(encodeHex('')).toMatchInlineSnapshot('"0x"')
+  expect(encodeHex('a')).toMatchInlineSnapshot('"0x61"')
+  expect(encodeHex('abc')).toMatchInlineSnapshot('"0x616263"')
+  expect(encodeHex('Hello World!')).toMatchInlineSnapshot(
+    '"0x48656c6c6f20576f726c6421"',
+  )
+
+  expect(stringToHex('')).toMatchInlineSnapshot('"0x"')
+  expect(stringToHex('a')).toMatchInlineSnapshot('"0x61"')
+  expect(stringToHex('abc')).toMatchInlineSnapshot('"0x616263"')
+  expect(stringToHex('Hello World!')).toMatchInlineSnapshot(
+    '"0x48656c6c6f20576f726c6421"',
+  )
+})
+
+test('converts bytes to hex', () => {
+  expect(encodeHex(new Uint8Array([]))).toMatchInlineSnapshot('"0x"')
+  expect(encodeHex(new Uint8Array([97]))).toMatchInlineSnapshot('"0x61"')
+  expect(encodeHex(new Uint8Array([97, 98, 99]))).toMatchInlineSnapshot(
+    '"0x616263"',
+  )
+  expect(
+    encodeHex(
+      new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),
+    ),
+  ).toMatchInlineSnapshot('"0x48656c6c6f20576f726c6421"')
+
+  expect(bytesToHex(new Uint8Array([]))).toMatchInlineSnapshot('"0x"')
+  expect(bytesToHex(new Uint8Array([97]))).toMatchInlineSnapshot('"0x61"')
+  expect(bytesToHex(new Uint8Array([97, 98, 99]))).toMatchInlineSnapshot(
+    '"0x616263"',
+  )
+  expect(
+    bytesToHex(
+      new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),
+    ),
+  ).toMatchInlineSnapshot('"0x48656c6c6f20576f726c6421"')
+})

package/src/utils/encoding/encodeHex.ts

@@ -0,0 +1,104 @@
+import { pad } from '../data'
+import type { ByteArray, Hex } from '../../types'
+
+const hexes = Array.from({ length: 256 }, (v, i) =>
+  i.toString(16).padStart(2, '0'),
+)
+
+/**
+ * @description Encodes a boolean into a hex string
+ */
+export function boolToHex(value: boolean): Hex {
+  return `0x${Number(value)}`
+}
+
+/**
+ * @description Encodes a bytes array into a hex string
+ */
+export function bytesToHex(value: ByteArray): Hex {
+  let hex = ''
+  for (let i = 0; i < value.length; i++) {
+    hex += hexes[value[i]]
+  }
+  return `0x${hex}`
+}
+
+/**
+ * @description Encodes a string, number, bigint, or ByteArray into a hex string
+ */
+export function encodeHex(
+  value: string | number | bigint | boolean | ByteArray,
+): Hex {
+  if (typeof value === 'number' || typeof value === 'bigint')
+    return numberToHex(value)
+  if (typeof value === 'string') {
+    return stringToHex(value)
+  }
+  if (typeof value === 'boolean') return boolToHex(value)
+  return bytesToHex(value)
+}
+
+export type NumberToHexOpts =
+  | {
+      // Whether or not the number of a signed representation.
+      signed?: boolean
+      // The size of the output hex (in bytes).
+      size: number
+    }
+  | {
+      signed?: never
+      size?: never
+    }
+
+/**
+ * @description Encodes a number or bigint into a hex string
+ */
+export function numberToHex(
+  value_: number | bigint,
+  opts: NumberToHexOpts = {},
+): Hex {
+  const { signed, size } = opts
+
+  let value = BigInt(value_)
+
+  let maxValue
+  if (size) {
+    if (signed) maxValue = (1n << (BigInt(size) * 8n - 1n)) - 1n
+    else maxValue = 2n ** (BigInt(size) * 8n) - 1n
+  } else if (typeof value_ === 'number') {
+    maxValue = BigInt(Number.MAX_SAFE_INTEGER)
+  }
+
+  const minValue = typeof maxValue === 'bigint' && signed ? -maxValue - 1n : 0
+
+  if ((maxValue && value > maxValue) || value < minValue) {
+    const suffix = typeof value_ === 'bigint' ? 'n' : ''
+    throw new Error(
+      `Number "${value_}${suffix}" is not in safe ${
+        size ? `${size * 8}-bit ${signed ? 'signed' : 'unsigned'} ` : ''
+      }integer range ${
+        maxValue
+          ? `(${minValue}${suffix} to ${maxValue}${suffix})`
+          : `(above ${minValue})`
+      }`,
+    )
+  }
+
+  const hex = `0x${(signed && value < 0
+    ? (1n << BigInt(size * 8)) + BigInt(value)
+    : value
+  ).toString(16)}` as Hex
+  if (size) return pad(hex, { size }) as Hex
+  return hex
+}
+
+/**
+ * @description Encodes a UTF-8 string into a hex string
+ */
+export function stringToHex(value: string): Hex {
+  let hex = ''
+  for (let i = 0; i < value.length; i++) {
+    hex += value.charCodeAt(i).toString(16)
+  }
+  return `0x${hex}`
+}

package/src/utils/encoding/encodeRlp.bench.ts

@@ -0,0 +1,54 @@
+import { RLP } from 'ethers/lib/utils'
+import { bench, describe } from 'vitest'
+
+import { encodeRlp } from './encodeRlp'
+
+describe('RLP Encoding (128 bytes)', () => {
+  bench('viem: `encodeRlp`', () => {
+    encodeRlp(
+      '0x1000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000000000000000000000000000000000',
+    )
+  })
+
+  bench('ethers: `RLP.encode`', () => {
+    RLP.encode(
+      '0x1000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000000000000000000000000000000000',
+    )
+  })
+})
+
+describe('RLP Encoding (nested array)', () => {
+  bench('viem: `encodeRlp`', () => {
+    encodeRlp([['0x11'], [['0x11']], [['0x11'], [['0x11']]]])
+  })
+
+  bench('ethers: `RLP.encode`', () => {
+    RLP.encode([['0x11'], [['0x11']], [['0x11'], [['0x11']]]])
+  })
+})
+
+describe('RLP Encoding (nested array of 128 bytes)', () => {
+  bench('viem: `encodeRlp`', () => {
+    encodeRlp([
+      '0x1000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000000000000000000000000000000000',
+      [
+        '0x1000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000000000000000000000000000000000',
+        [
+          '0x1000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000000000000000000000000000000000',
+        ],
+      ],
+    ])
+  })
+
+  bench('ethers: `RLP.encode`', () => {
+    RLP.encode([
+      '0x1000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000000000000000000000000000000000',
+      [
+        '0x1000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000000000000000000000000000000000',
+        [
+          '0x1000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000000000000000000000000000000000',
+        ],
+      ],
+    ])
+  })
+})