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

package/src/utils/data/trim.bench.ts

@@ -0,0 +1,34 @@
+import { hexStripZeros, stripZeros } from 'ethers/lib/utils'
+
+import { bench, describe } from 'vitest'
+
+import { trim } from './trim'
+
+describe('Trim Hex', () => {
+  bench('viem: `trimHex`', () => {
+    trim('0x00000000000000000000000a4e12a45')
+  })
+
+  bench('ethers: `hexStripZeros`', () => {
+    hexStripZeros('0x00000000000000000000000a4e12a45')
+  })
+})
+
+describe('Trim Bytes', () => {
+  bench('viem: `trimBytes`', () => {
+    trim(
+      new Uint8Array([
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 122, 51, 123,
+      ]),
+    )
+  })
+
+  bench('ethers: `stripZeros`', () => {
+    stripZeros(
+      new Uint8Array([
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 122, 51,
+        123,
+      ]),
+    )
+  })
+})

package/src/utils/data/trim.test.ts

@@ -0,0 +1,175 @@
+import { describe, expect, test } from 'vitest'
+
+import { trim } from './trim'
+
+test('default', () => {
+  expect(trim('0x000000')).toMatchInlineSnapshot('"0x0"')
+  expect(trim(new Uint8Array([0, 0, 0, 0, 0]))).toMatchInlineSnapshot(
+    `
+    Uint8Array [
+      0,
+    ]
+  `,
+  )
+
+  expect(
+    trim('0x00000000000000000000000000000000000000000000000000000000a4e12a45'),
+  ).toMatchInlineSnapshot('"0xa4e12a45"')
+
+  expect(
+    trim(
+      new Uint8Array([
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 1, 122, 51, 123,
+      ]),
+    ),
+  ).toMatchInlineSnapshot(
+    `
+    Uint8Array [
+      1,
+      122,
+      51,
+      123,
+    ]
+  `,
+  )
+})
+
+describe('hex', () => {
+  test('default', () => {
+    expect(
+      trim(
+        '0x0000000000000000000000000000000000000000000000000000000000000001',
+      ),
+    ).toMatchInlineSnapshot('"0x1"')
+
+    expect(
+      trim(
+        '0x00000000000000000000000000000000000000000000000000000000a4e12a45',
+      ),
+    ).toMatchInlineSnapshot('"0xa4e12a45"')
+
+    expect(
+      trim(
+        '0x00000000000000000000000000000000000000000000000000000001a4e12a45',
+      ),
+    ).toMatchInlineSnapshot('"0x1a4e12a45"')
+  })
+
+  test('args: dir', () => {
+    expect(
+      trim(
+        '0x1000000000000000000000000000000000000000000000000000000000000000',
+        { dir: 'right' },
+      ),
+    ).toMatchInlineSnapshot('"0x10"')
+
+    expect(
+      trim(
+        '0xa4e12a4500000000000000000000000000000000000000000000000000000000',
+        { dir: 'right' },
+      ),
+    ).toMatchInlineSnapshot('"0xa4e12a45"')
+
+    expect(
+      trim(
+        '0x1a4e12a450000000000000000000000000000000000000000000000000000000',
+        { dir: 'right' },
+      ),
+    ).toMatchInlineSnapshot('"0x1a4e12a45"')
+  })
+})
+
+describe('bytes', () => {
+  test('default', () => {
+    expect(
+      trim(
+        new Uint8Array([
+          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+          0, 0, 0, 0, 0, 0, 0, 0, 1,
+        ]),
+      ),
+    ).toMatchInlineSnapshot(
+      `
+      Uint8Array [
+        1,
+      ]
+    `,
+    )
+
+    expect(
+      trim(
+        new Uint8Array([
+          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+          0, 0, 0, 0, 0, 1, 122, 51, 123,
+        ]),
+      ),
+    ).toMatchInlineSnapshot(
+      `
+      Uint8Array [
+        1,
+        122,
+        51,
+        123,
+      ]
+    `,
+    )
+  })
+
+  test('args: dir', () => {
+    expect(
+      trim(
+        new Uint8Array([
+          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+          0, 0, 0, 0, 0, 0, 0, 0, 0,
+        ]),
+        { dir: 'right' },
+      ),
+    ).toMatchInlineSnapshot(
+      `
+      Uint8Array [
+        1,
+      ]
+    `,
+    )
+
+    expect(
+      trim(
+        new Uint8Array([
+          1, 122, 51, 123, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+          0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        ]),
+        { dir: 'right' },
+      ),
+    ).toMatchInlineSnapshot(
+      `
+      Uint8Array [
+        1,
+        122,
+        51,
+        123,
+      ]
+    `,
+    )
+
+    expect(
+      trim(
+        new Uint8Array([
+          1, 122, 51, 123, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        ]),
+        { dir: 'right' },
+      ),
+    ).toMatchInlineSnapshot(
+      `
+      Uint8Array [
+        1,
+        122,
+        51,
+        123,
+        11,
+      ]
+    `,
+    )
+  })
+})

package/src/utils/data/trim.ts

@@ -0,0 +1,33 @@
+import type { ByteArray, Hex } from '../../types'
+
+type TrimOptions = {
+  dir?: 'left' | 'right'
+}
+type TrimResult<TValue extends ByteArray | Hex> = TValue extends Hex
+  ? Hex
+  : ByteArray
+
+export function trim<TValue extends ByteArray | Hex>(
+  hexOrBytes: TValue,
+  { dir = 'left' }: TrimOptions = {},
+): TrimResult<TValue> {
+  let data: any =
+    typeof hexOrBytes === 'string' ? hexOrBytes.replace('0x', '') : hexOrBytes
+
+  let sliceLength = 0
+  for (let i = 0; i < data.length - 1; i++) {
+    if (data[dir === 'left' ? i : data.length - i - 1].toString() === '0')
+      sliceLength++
+    else break
+  }
+  data =
+    dir === 'left'
+      ? data.slice(sliceLength)
+      : data.slice(0, data.length - sliceLength)
+
+  if (typeof hexOrBytes === 'string') {
+    if (data.length === 1 && dir === 'right') data = `${data}0`
+    return `0x${data}` as TrimResult<TValue>
+  }
+  return data as TrimResult<TValue>
+}

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

@@ -0,0 +1,40 @@
+import { hexlify, toUtf8String } from 'ethers/lib/utils'
+
+import { bench, describe } from 'vitest'
+import Web3 from 'web3'
+
+import { bytesToHex, bytesToString } from './decodeBytes'
+
+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,
+    ])
+  })
+})
+
+describe('Bytes to String', () => {
+  bench('viem: `bytesToString`', () => {
+    bytesToString(
+      new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),
+    )
+  })
+
+  bench('ethers: `toUtf8String`', () => {
+    toUtf8String(
+      new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),
+    )
+  })
+})

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

@@ -0,0 +1,144 @@
+import { expect, test } from 'vitest'
+
+import {
+  bytesToBigint,
+  bytesToBool,
+  bytesToHex,
+  bytesToNumber,
+  bytesToString,
+  decodeBytes,
+} from './decodeBytes'
+
+test('converts bytes to number', () => {
+  expect(decodeBytes(new Uint8Array([0]), 'number')).toMatchInlineSnapshot('0')
+  expect(decodeBytes(new Uint8Array([7]), 'number')).toMatchInlineSnapshot('7')
+  expect(decodeBytes(new Uint8Array([69]), 'number')).toMatchInlineSnapshot(
+    '69',
+  )
+  expect(decodeBytes(new Uint8Array([1, 164]), 'number')).toMatchInlineSnapshot(
+    '420',
+  )
+
+  expect(bytesToNumber(new Uint8Array([0]))).toMatchInlineSnapshot('0')
+  expect(bytesToNumber(new Uint8Array([7]))).toMatchInlineSnapshot('7')
+  expect(bytesToNumber(new Uint8Array([69]))).toMatchInlineSnapshot('69')
+  expect(bytesToNumber(new Uint8Array([1, 164]))).toMatchInlineSnapshot('420')
+})
+
+test('converts bytes to bigint', () => {
+  expect(decodeBytes(new Uint8Array([0]), 'bigint')).toMatchInlineSnapshot('0n')
+  expect(decodeBytes(new Uint8Array([7]), 'bigint')).toMatchInlineSnapshot('7n')
+  expect(decodeBytes(new Uint8Array([69]), 'bigint')).toMatchInlineSnapshot(
+    '69n',
+  )
+  expect(decodeBytes(new Uint8Array([1, 164]), 'bigint')).toMatchInlineSnapshot(
+    '420n',
+  )
+  expect(
+    decodeBytes(
+      new Uint8Array([
+        12, 92, 243, 146, 17, 135, 111, 181, 229, 136, 67, 39, 250, 86, 252, 11,
+        117,
+      ]),
+      'bigint',
+    ),
+  ).toMatchInlineSnapshot('4206942069420694206942069420694206942069n')
+
+  expect(bytesToBigint(new Uint8Array([0]))).toMatchInlineSnapshot('0n')
+  expect(bytesToBigint(new Uint8Array([7]))).toMatchInlineSnapshot('7n')
+  expect(bytesToBigint(new Uint8Array([69]))).toMatchInlineSnapshot('69n')
+  expect(bytesToBigint(new Uint8Array([1, 164]))).toMatchInlineSnapshot('420n')
+  expect(
+    bytesToBigint(
+      new Uint8Array([
+        12, 92, 243, 146, 17, 135, 111, 181, 229, 136, 67, 39, 250, 86, 252, 11,
+        117,
+      ]),
+    ),
+  ).toMatchInlineSnapshot('4206942069420694206942069420694206942069n')
+})
+
+test('converts bytes to boolean', () => {
+  expect(decodeBytes(new Uint8Array([0]), 'boolean')).toMatchInlineSnapshot(
+    'false',
+  )
+  expect(decodeBytes(new Uint8Array([1]), 'boolean')).toMatchInlineSnapshot(
+    'true',
+  )
+
+  expect(bytesToBool(new Uint8Array([0]))).toMatchInlineSnapshot('false')
+  expect(bytesToBool(new Uint8Array([1]))).toMatchInlineSnapshot('true')
+
+  expect(() =>
+    bytesToBool(new Uint8Array([69])),
+  ).toThrowErrorMatchingInlineSnapshot(`
+    "Bytes value \\"69\\" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.
+
+    Version: viem@1.0.2"
+  `)
+  expect(() =>
+    bytesToBool(new Uint8Array([1, 2])),
+  ).toThrowErrorMatchingInlineSnapshot(`
+    "Bytes value \\"1,2\\" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.
+
+    Version: viem@1.0.2"
+  `)
+})
+
+test('converts bytes to string', () => {
+  expect(decodeBytes(new Uint8Array([]), 'string')).toMatchInlineSnapshot(`""`)
+  expect(decodeBytes(new Uint8Array([97]), 'string')).toMatchInlineSnapshot(
+    `"a"`,
+  )
+  expect(
+    decodeBytes(new Uint8Array([97, 98, 99]), 'string'),
+  ).toMatchInlineSnapshot(`"abc"`)
+  expect(
+    decodeBytes(
+      new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),
+      'string',
+    ),
+  ).toMatchInlineSnapshot(`"Hello World!"`)
+
+  expect(bytesToString(new Uint8Array([]))).toMatchInlineSnapshot(`""`)
+  expect(bytesToString(new Uint8Array([97]))).toMatchInlineSnapshot(`"a"`)
+  expect(bytesToString(new Uint8Array([97, 98, 99]))).toMatchInlineSnapshot(
+    `"abc"`,
+  )
+  expect(
+    bytesToString(
+      new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),
+    ),
+  ).toMatchInlineSnapshot(`"Hello World!"`)
+})
+
+test('converts bytes to hex', () => {
+  expect(
+    decodeBytes(new Uint8Array([97, 98, 99]), 'hex'),
+  ).toMatchInlineSnapshot('"0x616263"')
+  expect(decodeBytes(new Uint8Array([97]), 'hex')).toMatchInlineSnapshot(
+    '"0x61"',
+  )
+  expect(
+    decodeBytes(new Uint8Array([97, 98, 99]), 'hex'),
+  ).toMatchInlineSnapshot('"0x616263"')
+  expect(
+    decodeBytes(
+      new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),
+      'hex',
+    ),
+  ).toMatchInlineSnapshot('"0x48656c6c6f20576f726c6421"')
+
+  expect(bytesToHex(new Uint8Array([97, 98, 99]))).toMatchInlineSnapshot(
+    '"0x616263"',
+  )
+  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/decodeBytes.ts

@@ -0,0 +1,63 @@
+import { InvalidBytesBooleanError } from '../../errors'
+import type { ByteArray, Hex } from '../../types'
+import { hexToBigInt, hexToNumber } from './decodeHex'
+import { bytesToHex } from './encodeHex'
+
+type DecodeBytesResponse<TTo> = TTo extends 'string'
+  ? string
+  : TTo extends 'hex'
+  ? Hex
+  : TTo extends 'bigint'
+  ? bigint
+  : TTo extends 'number'
+  ? number
+  : TTo extends 'boolean'
+  ? boolean
+  : never
+
+/**
+ * @description Decodes a byte array into a UTF-8 string, hex value, number, bigint or boolean.
+ */
+export function decodeBytes<
+  TTo extends 'string' | 'hex' | 'bigint' | 'number' | 'boolean',
+>(bytes: ByteArray, to: TTo): DecodeBytesResponse<TTo> {
+  if (to === 'number') return bytesToNumber(bytes) as DecodeBytesResponse<TTo>
+  if (to === 'bigint') return bytesToBigint(bytes) as DecodeBytesResponse<TTo>
+  if (to === 'boolean') return bytesToBool(bytes) as DecodeBytesResponse<TTo>
+  if (to === 'string') return bytesToString(bytes) as DecodeBytesResponse<TTo>
+  return bytesToHex(bytes) as DecodeBytesResponse<TTo>
+}
+
+/**
+ * @description Decodes a byte array into a bigint.
+ */
+export function bytesToBigint(bytes: ByteArray): bigint {
+  const hex = bytesToHex(bytes)
+  return hexToBigInt(hex)
+}
+
+/**
+ * @description Decodes a byte array into a boolean.
+ */
+export function bytesToBool(bytes: ByteArray): boolean {
+  if (bytes.length > 1 || bytes[0] > 1)
+    throw new InvalidBytesBooleanError(bytes)
+  return Boolean(bytes[0])
+}
+
+export { bytesToHex }
+
+/**
+ * @description Decodes a byte array into a number.
+ */
+export function bytesToNumber(bytes: ByteArray): number {
+  const hex = bytesToHex(bytes)
+  return hexToNumber(hex)
+}
+
+/**
+ * @description Decodes a byte array into a UTF-8 string.
+ */
+export function bytesToString(bytes: ByteArray): string {
+  return new TextDecoder().decode(bytes)
+}

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

@@ -0,0 +1,24 @@
+import { bench, describe } from 'vitest'
+import Web3 from 'web3'
+
+import { hexToNumber, hexToString } from './decodeHex'
+
+describe('Hex to Number', () => {
+  bench('viem: `hexToNumber`', () => {
+    hexToNumber('0x1a4')
+  })
+
+  bench('web3.js: `hexToNumber`', () => {
+    Web3.utils.hexToNumber('0x1a4')
+  })
+})
+
+describe('Hex to String', () => {
+  bench('viem: `hexToString`', () => {
+    hexToString('0x48656c6c6f20576f726c6421')
+  })
+
+  bench('web3.js: `hexToString`', () => {
+    Web3.utils.hexToString('0x48656c6c6f20576f726c6421')
+  })
+})

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

@@ -0,0 +1,167 @@
+import { describe, expect, test } from 'vitest'
+
+import {
+  decodeHex,
+  hexToBigInt,
+  hexToBool,
+  hexToNumber,
+  hexToString,
+} from './decodeHex'
+
+describe('converts hex to number', () => {
+  test('default', () => {
+    expect(decodeHex('0x0', 'number')).toMatchInlineSnapshot('0')
+    expect(decodeHex('0x7', 'number')).toMatchInlineSnapshot('7')
+    expect(decodeHex('0x45', 'number')).toMatchInlineSnapshot('69')
+    expect(decodeHex('0x1a4', 'number')).toMatchInlineSnapshot('420')
+
+    expect(hexToNumber('0x0')).toMatchInlineSnapshot('0')
+    expect(hexToNumber('0x7')).toMatchInlineSnapshot('7')
+    expect(hexToNumber('0x45')).toMatchInlineSnapshot('69')
+    expect(hexToNumber('0x1a4')).toMatchInlineSnapshot('420')
+  })
+
+  test('args: signed', () => {
+    expect(hexToNumber('0x20', { signed: true })).toBe(32)
+    expect(
+      hexToNumber('0xe0', {
+        signed: true,
+      }),
+    ).toBe(-32)
+    expect(
+      hexToNumber('0xffffffe0', {
+        signed: true,
+      }),
+    ).toBe(-32)
+
+    expect(hexToNumber('0x007f', { signed: true })).toBe(127)
+    expect(hexToNumber('0xff81', { signed: true })).toBe(-127)
+    expect(hexToNumber('0x7fff', { signed: true })).toBe(32767)
+    expect(hexToNumber('0x8000', { signed: true })).toBe(-32768)
+
+    expect(hexToNumber('0xffff', { signed: true })).toBe(-1)
+    expect(hexToNumber('0x4961769b', { signed: true })).toBe(1231124123)
+    expect(hexToNumber('0x00027760a62ec2ac', { signed: true })).toBe(
+      694206942069420,
+    )
+  })
+})
+
+describe('converts hex to bigint', () => {
+  test('default', () => {
+    expect(decodeHex('0x0', 'bigint')).toMatchInlineSnapshot('0n')
+    expect(decodeHex('0x7', 'bigint')).toMatchInlineSnapshot('7n')
+    expect(decodeHex('0x45', 'bigint')).toMatchInlineSnapshot('69n')
+    expect(decodeHex('0x1a4', 'bigint')).toMatchInlineSnapshot('420n')
+    expect(
+      decodeHex('0xc5cf39211876fb5e5884327fa56fc0b75', 'bigint'),
+    ).toMatchInlineSnapshot('4206942069420694206942069420694206942069n')
+
+    expect(hexToBigInt('0x0')).toMatchInlineSnapshot('0n')
+    expect(hexToBigInt('0x7')).toMatchInlineSnapshot('7n')
+    expect(hexToBigInt('0x45')).toMatchInlineSnapshot('69n')
+    expect(hexToBigInt('0x1a4')).toMatchInlineSnapshot('420n')
+    expect(
+      hexToBigInt('0xc5cf39211876fb5e5884327fa56fc0b75'),
+    ).toMatchInlineSnapshot('4206942069420694206942069420694206942069n')
+  })
+
+  test('signed', () => {
+    expect(hexToBigInt('0x20', { signed: true })).toBe(32n)
+    expect(
+      hexToBigInt('0xe0', {
+        signed: true,
+      }),
+    ).toBe(-32n)
+
+    expect(hexToBigInt('0x007f', { signed: true })).toBe(127n)
+    expect(hexToBigInt('0xff81', { signed: true })).toBe(-127n)
+    expect(hexToBigInt('0x7fff', { signed: true })).toBe(32767n)
+    expect(hexToBigInt('0x8000', { signed: true })).toBe(-32768n)
+
+    expect(
+      hexToBigInt(
+        '0x000000000000000000000000000000000000000000000000aade1ed08b0b325c',
+        { signed: true },
+      ),
+    ).toBe(12312312312312312412n)
+    expect(
+      hexToBigInt(
+        '0xffffffffffffffffffffffffffffffffffffffffffffffff5521e12f74f4cda4',
+        { signed: true },
+      ),
+    ).toBe(-12312312312312312412n)
+  })
+})
+
+test('converts hex to boolean', () => {
+  expect(decodeHex('0x0', 'boolean')).toMatchInlineSnapshot('false')
+  expect(decodeHex('0x1', 'boolean')).toMatchInlineSnapshot('true')
+
+  expect(hexToBool('0x0')).toMatchInlineSnapshot('false')
+  expect(hexToBool('0x1')).toMatchInlineSnapshot('true')
+
+  expect(() => hexToBool('0xa')).toThrowErrorMatchingInlineSnapshot(
+    `
+    "Hex value \\"0xa\\" is not a valid boolean. The hex value must be \\"0x0\\" (false) or \\"0x1\\" (true).
+
+    Version: viem@1.0.2"
+  `,
+  )
+})
+
+test('converts hex to string', () => {
+  expect(decodeHex('0x', 'string')).toMatchInlineSnapshot(`""`)
+  expect(decodeHex('0x61', 'string')).toMatchInlineSnapshot(`"a"`)
+  expect(decodeHex('0x616263', 'string')).toMatchInlineSnapshot(`"abc"`)
+  expect(
+    decodeHex('0x48656c6c6f20576f726c6421', 'string'),
+  ).toMatchInlineSnapshot(`"Hello World!"`)
+
+  expect(hexToString('0x')).toMatchInlineSnapshot(`""`)
+  expect(hexToString('0x61')).toMatchInlineSnapshot(`"a"`)
+  expect(hexToString('0x616263')).toMatchInlineSnapshot(`"abc"`)
+  expect(hexToString('0x48656c6c6f20576f726c6421')).toMatchInlineSnapshot(
+    `"Hello World!"`,
+  )
+})
+
+test('converts hex to bytes', () => {
+  expect(decodeHex('0x', 'bytes')).toMatchInlineSnapshot('Uint8Array []')
+  expect(decodeHex('0x61', 'bytes')).toMatchInlineSnapshot(`
+    Uint8Array [
+      97,
+    ]
+  `)
+  expect(decodeHex('0x616263', 'bytes')).toMatchInlineSnapshot(
+    `
+    Uint8Array [
+      97,
+      98,
+      99,
+    ]
+  `,
+  )
+  expect(
+    decodeHex('0x48656c6c6f20576f726c6421', 'bytes'),
+  ).toMatchInlineSnapshot(`
+    Uint8Array [
+      72,
+      101,
+      108,
+      108,
+      111,
+      32,
+      87,
+      111,
+      114,
+      108,
+      100,
+      33,
+    ]
+  `)
+
+  expect(() => decodeHex('0xgg', 'bytes')).toThrowErrorMatchingInlineSnapshot(
+    '"Invalid byte sequence"',
+  )
+})