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

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

@@ -1,367 +0,0 @@
-import { describe, expect, test } from 'vitest'
-
-import { pad, padBytes, padHex } from './pad'
-
-test('default', () => {
-  expect(pad('0xa4e12a45')).toMatchInlineSnapshot(
-    '"0x00000000000000000000000000000000000000000000000000000000a4e12a45"',
-  )
-
-  expect(pad(new Uint8Array([1, 122, 51, 123]))).toMatchInlineSnapshot(
-    `
-    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,
-    ]
-  `,
-  )
-})
-
-describe('hex', () => {
-  test('default', () => {
-    expect(padHex('0x1')).toMatchInlineSnapshot(
-      '"0x0000000000000000000000000000000000000000000000000000000000000001"',
-    )
-
-    expect(padHex('0xa4e12a45')).toMatchInlineSnapshot(
-      '"0x00000000000000000000000000000000000000000000000000000000a4e12a45"',
-    )
-
-    expect(padHex('0x1a4e12a45')).toMatchInlineSnapshot(
-      '"0x00000000000000000000000000000000000000000000000000000001a4e12a45"',
-    )
-
-    expect(() =>
-      padHex(
-        '0x1a4e12a45a21323123aaa87a897a897a898a6567a578a867a98778a667a85a875a87a6a787a65a675a6a9',
-      ),
-    ).toThrowErrorMatchingInlineSnapshot(
-      `
-      "Hex size (43) exceeds padding size (32).
-
-      Version: viem@1.0.2"
-    `,
-    )
-  })
-
-  test('args: size', () => {
-    expect(padHex('0x1', { size: 4 })).toMatchInlineSnapshot('"0x00000001"')
-
-    expect(padHex('0xa4e12a45', { size: 4 })).toMatchInlineSnapshot(
-      '"0xa4e12a45"',
-    )
-
-    expect(() =>
-      padHex('0x1a4e12a45', { size: 4 }),
-    ).toThrowErrorMatchingInlineSnapshot(
-      `
-      "Hex size (5) exceeds padding size (4).
-
-      Version: viem@1.0.2"
-    `,
-    )
-  })
-
-  test('args: dir', () => {
-    expect(padHex('0x1', { dir: 'right' })).toMatchInlineSnapshot(
-      '"0x1000000000000000000000000000000000000000000000000000000000000000"',
-    )
-
-    expect(padHex('0xa4e12a45', { dir: 'right' })).toMatchInlineSnapshot(
-      '"0xa4e12a4500000000000000000000000000000000000000000000000000000000"',
-    )
-
-    expect(padHex('0x1a4e12a45', { dir: 'right' })).toMatchInlineSnapshot(
-      '"0x1a4e12a450000000000000000000000000000000000000000000000000000000"',
-    )
-  })
-})
-
-describe('bytes', () => {
-  test('default', () => {
-    expect(padBytes(new Uint8Array([1]))).toMatchInlineSnapshot(
-      `
-      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,
-      ]
-    `,
-    )
-
-    expect(padBytes(new Uint8Array([1, 122, 51, 123]))).toMatchInlineSnapshot(
-      `
-      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,
-      ]
-    `,
-    )
-
-    expect(() =>
-      padBytes(
-        new Uint8Array([
-          1, 122, 51, 123, 1, 122, 51, 123, 1, 122, 51, 123, 1, 122, 51, 123, 1,
-          122, 51, 123, 1, 122, 51, 123, 1, 122, 51, 123, 1, 122, 51, 123, 1,
-          122, 51, 123, 1, 122, 51, 123, 1, 122, 51, 123,
-        ]),
-      ),
-    ).toThrowErrorMatchingInlineSnapshot(
-      `
-      "Bytes size (44) exceeds padding size (32).
-
-      Version: viem@1.0.2"
-    `,
-    )
-  })
-
-  test('args: size', () => {
-    expect(padBytes(new Uint8Array([1]), { size: 4 })).toMatchInlineSnapshot(
-      `
-      Uint8Array [
-        0,
-        0,
-        0,
-        1,
-      ]
-    `,
-    )
-
-    expect(
-      padBytes(new Uint8Array([1, 122, 51, 123]), { size: 4 }),
-    ).toMatchInlineSnapshot(
-      `
-      Uint8Array [
-        1,
-        122,
-        51,
-        123,
-      ]
-    `,
-    )
-
-    expect(() =>
-      padBytes(new Uint8Array([1, 122, 51, 123, 11]), { size: 4 }),
-    ).toThrowErrorMatchingInlineSnapshot(
-      `
-      "Bytes size (5) exceeds padding size (4).
-
-      Version: viem@1.0.2"
-    `,
-    )
-  })
-
-  test('args: dir', () => {
-    expect(
-      padBytes(new Uint8Array([1]), { dir: 'right' }),
-    ).toMatchInlineSnapshot(
-      `
-      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,
-      ]
-    `,
-    )
-
-    expect(
-      padBytes(new Uint8Array([1, 122, 51, 123]), { dir: 'right' }),
-    ).toMatchInlineSnapshot(
-      `
-      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,
-      ]
-    `,
-    )
-
-    expect(
-      padBytes(new Uint8Array([1, 122, 51, 123, 11]), { dir: 'right' }),
-    ).toMatchInlineSnapshot(
-      `
-      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,
-      ]
-    `,
-    )
-  })
-})

package/src/utils/data/pad.ts

@@ -1,53 +0,0 @@
-import { SizeExceedsPaddingSizeError } from '../../errors'
-import type { ByteArray, Hex } from '../../types'
-
-type PadOptions = {
-  dir?: 'left' | 'right'
-  size?: number
-}
-type PadResult<TValue extends ByteArray | Hex> = TValue extends Hex
-  ? Hex
-  : ByteArray
-
-export function pad<TValue extends ByteArray | Hex>(
-  hexOrBytes: TValue,
-  { dir, size = 32 }: PadOptions = {},
-): PadResult<TValue> {
-  if (typeof hexOrBytes === 'string')
-    return padHex(hexOrBytes, { dir, size }) as PadResult<TValue>
-  return padBytes(hexOrBytes, { dir, size }) as PadResult<TValue>
-}
-
-export function padHex(hex_: Hex, { dir, size = 32 }: PadOptions = {}) {
-  let hex = hex_.replace('0x', '')
-  if (hex.length > size * 2)
-    throw new SizeExceedsPaddingSizeError({
-      size: Math.ceil(hex.length / 2),
-      targetSize: size,
-      type: 'hex',
-    })
-
-  return `0x${hex[dir === 'right' ? 'padEnd' : 'padStart'](
-    size * 2,
-    '0',
-  )}` as Hex
-}
-
-export function padBytes(
-  bytes: ByteArray,
-  { dir, size = 32 }: PadOptions = {},
-) {
-  if (bytes.length > size)
-    throw new SizeExceedsPaddingSizeError({
-      size: bytes.length,
-      targetSize: size,
-      type: 'bytes',
-    })
-  const paddedBytes = new Uint8Array(size)
-  for (let i = 0; i < size; i++) {
-    const padEnd = dir === 'right'
-    paddedBytes[padEnd ? i : size - i - 1] =
-      bytes[padEnd ? i : bytes.length - i - 1]
-  }
-  return paddedBytes
-}

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

@@ -1,18 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { size } from './size'
-
-test('hex', () => {
-  expect(size('0x')).toBe(0)
-  expect(size('0x1')).toBe(1)
-  expect(size('0x12')).toBe(1)
-  expect(size('0x1234')).toBe(2)
-  expect(size('0x12345678')).toBe(4)
-})
-
-test('bytes', () => {
-  expect(size(new Uint8Array([]))).toBe(0)
-  expect(size(new Uint8Array([1]))).toBe(1)
-  expect(size(new Uint8Array([1, 2]))).toBe(2)
-  expect(size(new Uint8Array([1, 2, 3, 4]))).toBe(4)
-})

package/src/utils/data/size.ts

@@ -1,13 +0,0 @@
-import type { ByteArray, Hex } from '../../types'
-import { isHex } from './isHex'
-
-/**
- * @description Retrieves the size of the value (in bytes).
- *
- * @param value The value (hex or byte array) to retrieve the size of.
- * @returns The size of the value (in bytes).
- */
-export function size(value: Hex | ByteArray) {
-  if (isHex(value)) return Math.ceil((value.length - 2) / 2)
-  return value.length
-}

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

@@ -1,203 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { slice, sliceBytes, sliceHex } from './slice'
-
-test('hex', () => {
-  expect(sliceHex('0x')).toMatchInlineSnapshot('"0x"')
-  expect(sliceHex('0x0123456789')).toMatchInlineSnapshot('"0x0123456789"')
-
-  expect(sliceHex('0x', 0)).toMatchInlineSnapshot('"0x"')
-  expect(sliceHex('0x0123456789', 0, 4)).toMatchInlineSnapshot('"0x01234567"')
-  expect(sliceHex('0x0123456789', 1, 4)).toMatchInlineSnapshot('"0x234567"')
-  expect(sliceHex('0x0123456789', 2, 5)).toMatchInlineSnapshot('"0x456789"')
-  expect(sliceHex('0x0123456789', 2)).toMatchInlineSnapshot('"0x456789"')
-  expect(slice('0x0123456789', 2)).toMatchInlineSnapshot('"0x456789"')
-  expect(
-    slice(
-      '0x0000000000000000000000000000000000000000000000000000000000010f2c000000000000000000000000000000000000000000000000000000000000a45500000000000000000000000000000000000000000000000000000000190f1b44',
-      33,
-      65,
-    ),
-  ).toBe('0x0000000000000000000000000000000000000000000000000000000000a45500')
-
-  expect(sliceHex('0x0123456789', -1)).toMatchInlineSnapshot('"0x89"')
-  expect(sliceHex('0x0123456789', -3, -1)).toMatchInlineSnapshot('"0x4567"')
-  expect(sliceHex('0x0123456789', -5)).toMatchInlineSnapshot('"0x0123456789"')
-  expect(slice('0x0123456789', -5)).toMatchInlineSnapshot('"0x0123456789"')
-
-  expect(sliceHex('0x0123456789', 0, 10)).toMatchInlineSnapshot(
-    '"0x0123456789"',
-  )
-  expect(sliceHex('0x0123456789', -10)).toMatchInlineSnapshot('"0x0123456789"')
-
-  expect(() => sliceHex('0x0123456789', 5)).toThrowErrorMatchingInlineSnapshot(
-    '"Slice starting at offset \\"5\\" is out-of-bounds (size: 5)."',
-  )
-})
-
-test('bytes', () => {
-  expect(sliceBytes(new Uint8Array([]))).toMatchInlineSnapshot('Uint8Array []')
-  expect(
-    sliceBytes(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])),
-  ).toMatchInlineSnapshot(`
-    Uint8Array [
-      0,
-      1,
-      2,
-      3,
-      4,
-      5,
-      6,
-      7,
-      8,
-      9,
-    ]
-  `)
-
-  expect(sliceBytes(new Uint8Array([]), 0)).toMatchInlineSnapshot(
-    'Uint8Array []',
-  )
-  expect(
-    sliceBytes(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), 0, 4),
-  ).toMatchInlineSnapshot(`
-    Uint8Array [
-      0,
-      1,
-      2,
-      3,
-    ]
-  `)
-  expect(
-    sliceBytes(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), 2, 8),
-  ).toMatchInlineSnapshot(`
-      Uint8Array [
-        2,
-        3,
-        4,
-        5,
-        6,
-        7,
-      ]
-    `)
-  expect(
-    sliceBytes(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), 5, 9),
-  ).toMatchInlineSnapshot(`
-      Uint8Array [
-        5,
-        6,
-        7,
-        8,
-      ]
-    `)
-  expect(
-    sliceBytes(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), 2),
-  ).toMatchInlineSnapshot(`
-    Uint8Array [
-      2,
-      3,
-      4,
-      5,
-      6,
-      7,
-      8,
-      9,
-    ]
-  `)
-  expect(
-    slice(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), 2),
-  ).toMatchInlineSnapshot(`
-    Uint8Array [
-      2,
-      3,
-      4,
-      5,
-      6,
-      7,
-      8,
-      9,
-    ]
-  `)
-
-  expect(
-    sliceBytes(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), -1),
-  ).toMatchInlineSnapshot(`
-    Uint8Array [
-      9,
-    ]
-  `)
-  expect(
-    sliceBytes(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), -3, -1),
-  ).toMatchInlineSnapshot(`
-    Uint8Array [
-      7,
-      8,
-    ]
-  `)
-  expect(
-    sliceBytes(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), -8),
-  ).toMatchInlineSnapshot(`
-      Uint8Array [
-        2,
-        3,
-        4,
-        5,
-        6,
-        7,
-        8,
-        9,
-      ]
-    `)
-  expect(
-    slice(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), -8),
-  ).toMatchInlineSnapshot(`
-      Uint8Array [
-        2,
-        3,
-        4,
-        5,
-        6,
-        7,
-        8,
-        9,
-      ]
-    `)
-
-  expect(
-    sliceBytes(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), 0, 10),
-  ).toMatchInlineSnapshot(`
-    Uint8Array [
-      0,
-      1,
-      2,
-      3,
-      4,
-      5,
-      6,
-      7,
-      8,
-      9,
-    ]
-  `)
-  expect(
-    sliceBytes(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), -10),
-  ).toMatchInlineSnapshot(`
-    Uint8Array [
-      0,
-      1,
-      2,
-      3,
-      4,
-      5,
-      6,
-      7,
-      8,
-      9,
-    ]
-  `)
-
-  expect(() =>
-    sliceBytes(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), 10),
-  ).toThrowErrorMatchingInlineSnapshot(
-    '"Slice starting at offset \\"10\\" is out-of-bounds (size: 10)."',
-  )
-})

package/src/utils/data/slice.ts

@@ -1,60 +0,0 @@
-import type { ByteArray, Hex } from '../../types'
-import { isHex } from './isHex'
-import { size } from './size'
-
-type SliceResult<TValue extends ByteArray | Hex> = TValue extends Hex
-  ? Hex
-  : ByteArray
-
-/**
- * @description Returns a section of the hex or byte array given a start/end bytes offset.
- *
- * @param value The hex or byte array to slice.
- * @param start The start offset (in bytes).
- * @param end The end offset (in bytes).
- */
-export function slice<TValue extends ByteArray | Hex>(
-  value: TValue,
-  start?: number,
-  end?: number,
-): SliceResult<TValue> {
-  if (isHex(value))
-    return sliceHex(value as Hex, start, end) as SliceResult<TValue>
-  return sliceBytes(value as ByteArray, start, end) as SliceResult<TValue>
-}
-
-function assertStartOffset(value: Hex | ByteArray, start?: number) {
-  if (typeof start === 'number' && start > 0 && start > size(value) - 1)
-    throw new Error(
-      `Slice starting at offset "${start}" is out-of-bounds (size: ${size(
-        value,
-      )}).`,
-    )
-}
-
-/**
- * @description Returns a section of the byte array given a start/end bytes offset.
- *
- * @param value The byte array to slice.
- * @param start The start offset (in bytes).
- * @param end The end offset (in bytes).
- */
-export function sliceBytes(value: ByteArray, start?: number, end?: number) {
-  assertStartOffset(value, start)
-  return value.slice(start, end)
-}
-
-/**
- * @description Returns a section of the hex value given a start/end bytes offset.
- *
- * @param value The hex value to slice.
- * @param start The start offset (in bytes).
- * @param end The end offset (in bytes).
- */
-export function sliceHex(value_: Hex, start?: number, end?: number) {
-  assertStartOffset(value_, start)
-  const value = value_
-    .replace('0x', '')
-    .slice((start ?? 0) * 2, (end ?? value_.length) * 2)
-  return `0x${value}`
-}