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

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

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

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

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

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

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

@@ -0,0 +1,60 @@
+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}`
+}