viem 0.0.1-alpha.14 → 0.0.1-alpha.16

package/src/utils/contract/index.test.ts

@@ -0,0 +1,15 @@
+import { expect, test } from 'vitest'
+
+import * as utils from './index'
+
+test('exports utils', () => {
+  expect(utils).toMatchInlineSnapshot(`
+    {
+      "extractFunctionName": [Function],
+      "extractFunctionParams": [Function],
+      "extractFunctionParts": [Function],
+      "extractFunctionType": [Function],
+      "getContractError": [Function],
+    }
+  `)
+})

package/src/utils/contract/index.ts

@@ -0,0 +1,8 @@
+export {
+  extractFunctionName,
+  extractFunctionParams,
+  extractFunctionParts,
+  extractFunctionType,
+} from './extractFunctionParts'
+
+export { getContractError } from './getContractError'

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

@@ -0,0 +1,35 @@
+import { expect, test } from 'vitest'
+
+import { concat, concatBytes, concatHex } from './concat'
+
+test('concat', () => {
+  expect(concat(['0x0', '0x1'])).toBe('0x01')
+  expect(concat(['0x1', '0x69', '0x420'])).toBe('0x169420')
+  expect(concat(['0x00000001', '0x00000069', '0x00000420'])).toBe(
+    '0x000000010000006900000420',
+  )
+  expect(concatHex(['0x00000001', '0x00000069', '0x00000420'])).toBe(
+    '0x000000010000006900000420',
+  )
+
+  expect(concat([new Uint8Array([0]), new Uint8Array([1])])).toStrictEqual(
+    new Uint8Array([0, 1]),
+  )
+  expect(concatBytes([new Uint8Array([0]), new Uint8Array([1])])).toStrictEqual(
+    new Uint8Array([0, 1]),
+  )
+  expect(
+    concat([
+      new Uint8Array([1]),
+      new Uint8Array([69]),
+      new Uint8Array([420, 69]),
+    ]),
+  ).toStrictEqual(new Uint8Array([1, 69, 420, 69]))
+  expect(
+    concat([
+      new Uint8Array([0, 0, 0, 1]),
+      new Uint8Array([0, 0, 0, 69]),
+      new Uint8Array([0, 0, 420, 69]),
+    ]),
+  ).toStrictEqual(new Uint8Array([0, 0, 0, 1, 0, 0, 0, 69, 0, 0, 420, 69]))
+})

package/src/utils/data/concat.ts

@@ -0,0 +1,34 @@
+import type { ByteArray, Hex } from '../../types'
+
+type ConcatResult<TValue extends Hex | ByteArray> = TValue extends Hex
+  ? Hex
+  : ByteArray
+
+export function concat<TValue extends Hex | ByteArray>(
+  values: TValue[],
+): ConcatResult<TValue> {
+  if (typeof values[0] === 'string')
+    return concatHex(values as Hex[]) as ConcatResult<TValue>
+  return concatBytes(values as ByteArray[]) as ConcatResult<TValue>
+}
+
+export function concatBytes(values: ByteArray[]): ByteArray {
+  let length = 0
+  for (const arr of values) {
+    length += arr.length
+  }
+  const result = new Uint8Array(length)
+  let offset = 0
+  for (const arr of values) {
+    result.set(arr, offset)
+    offset += arr.length
+  }
+  return result
+}
+
+export function concatHex(values: Hex[]): Hex {
+  return `0x${(values as Hex[]).reduce(
+    (acc, x) => acc + x.replace('0x', ''),
+    '',
+  )}`
+}

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

@@ -0,0 +1,23 @@
+import { expect, test } from 'vitest'
+
+import * as utils from './index'
+
+test('exports utils', () => {
+  expect(utils).toMatchInlineSnapshot(`
+    {
+      "concat": [Function],
+      "concatBytes": [Function],
+      "concatHex": [Function],
+      "isBytes": [Function],
+      "isHex": [Function],
+      "pad": [Function],
+      "padBytes": [Function],
+      "padHex": [Function],
+      "size": [Function],
+      "slice": [Function],
+      "sliceBytes": [Function],
+      "sliceHex": [Function],
+      "trim": [Function],
+    }
+  `)
+})

package/src/utils/data/index.ts

@@ -0,0 +1,13 @@
+export { concat, concatBytes, concatHex } from './concat'
+
+export { isBytes } from './isBytes'
+
+export { isHex } from './isHex'
+
+export { pad, padBytes, padHex } from './pad'
+
+export { trim } from './trim'
+
+export { size } from './size'
+
+export { slice, sliceBytes, sliceHex } from './slice'

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

@@ -0,0 +1,9 @@
+import { expect, test } from 'vitest'
+
+import { isBytes } from './isBytes'
+
+test('is bytes', () => {
+  expect(isBytes(new Uint8Array([1, 69, 420])))
+  expect(isBytes('0x1')).toBeFalsy()
+  expect(isBytes(undefined)).toBeFalsy()
+})

package/src/utils/data/isBytes.ts

@@ -0,0 +1,7 @@
+export function isBytes(value: any) {
+  if (!value) return false
+  if (typeof value !== 'object') return false
+  return (
+    value.BYTES_PER_ELEMENT === 1 && value.constructor.name === 'Uint8Array'
+  )
+}

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

@@ -0,0 +1,13 @@
+import { expect, test } from 'vitest'
+
+import { isHex } from './isHex'
+
+test('is hex', () => {
+  expect(isHex('0x')).toBeTruthy()
+  expect(isHex('0x0')).toBeTruthy()
+  expect(isHex('0x0123456789abcdef')).toBeTruthy()
+  expect(isHex('0x0123456789abcdefABCDEF')).toBeTruthy()
+  expect(isHex('0x0123456789abcdefg')).toBeFalsy()
+  expect(isHex({ foo: 'bar' })).toBeFalsy()
+  expect(isHex(undefined)).toBeFalsy()
+})

package/src/utils/data/isHex.ts

@@ -0,0 +1,5 @@
+export function isHex(value: any) {
+  if (!value) return false
+  if (typeof value !== 'string') return false
+  return /^0x[0-9a-fA-F]*$/.test(value)
+}

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

@@ -0,0 +1,39 @@
+import { hexZeroPad, zeroPad } from 'ethers/lib/utils'
+import { hexZeroPad as hexZeroPad2, zeroPad as zeroPad2 } from 'essential-eth'
+
+import { bench, describe } from 'vitest'
+import Web3 from 'web3'
+
+import { padBytes, padHex } from './pad'
+
+describe('Pad Hex', () => {
+  bench('viem: `padHex`', () => {
+    padHex('0xa4e12a45')
+  })
+
+  bench('ethers: `hexZeroPad`', () => {
+    hexZeroPad('0xa4e12a45', 32)
+  })
+
+  bench('web3.js: `padLeft`', () => {
+    Web3.utils.padLeft('0xa4e12a45', 32)
+  })
+
+  bench('essential-eth: `hexZeroPad`', () => {
+    hexZeroPad2('0xa4e12a45', 32)
+  })
+})
+
+describe('Pad Bytes', () => {
+  bench('viem: `padBytes`', () => {
+    padBytes(new Uint8Array([1, 122, 51, 123]))
+  })
+
+  bench('ethers: `zeroPad`', () => {
+    zeroPad(new Uint8Array([1, 122, 51, 123]), 32)
+  })
+
+  bench('essential-eth: `zeroPad`', () => {
+    zeroPad2(new Uint8Array([1, 122, 51, 123]), 32)
+  })
+})

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
+}