viem 0.0.1-sushi.27 → 0.1.1

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

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

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

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

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

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

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

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

@@ -1,167 +0,0 @@
-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"',
-  )
-})