viem 0.2.11 → 0.2.13

package/src/utils/chain.ts

@@ -0,0 +1,42 @@
+import { ChainDoesNotSupportContract } from '../errors/index.js'
+import type { Chain, ChainContract, Formatters } from '../types/index.js'
+
+export function defineChain<
+  TFormatters extends Formatters = Formatters,
+  TChain extends Chain<TFormatters> = Chain<TFormatters>,
+>(chain: TChain) {
+  return chain
+}
+
+export function getChainContractAddress({
+  blockNumber,
+  chain,
+  contract: name,
+}: {
+  blockNumber?: bigint
+  chain: Chain
+  contract: string
+}) {
+  const contract = (chain?.contracts as Record<string, ChainContract>)?.[name]
+  if (!contract)
+    throw new ChainDoesNotSupportContract({
+      chain,
+      contract: { name },
+    })
+
+  if (
+    blockNumber &&
+    contract.blockCreated &&
+    contract.blockCreated > blockNumber
+  )
+    throw new ChainDoesNotSupportContract({
+      blockNumber,
+      chain,
+      contract: {
+        name,
+        blockCreated: contract.blockCreated,
+      },
+    })
+
+  return contract.address
+}

package/src/utils/contract/extractFunctionParts.ts

@@ -0,0 +1,27 @@
+const paramsRegex = /((function|event)\s)?(.*)(\((.*)\))/
+
+export function extractFunctionParts(def: string) {
+  const parts = def.match(paramsRegex)
+  const type = parts?.[2] || undefined
+  const name = parts?.[3]
+  const params = parts?.[5] || undefined
+  return { type, name, params }
+}
+
+export function extractFunctionName(def: string) {
+  return extractFunctionParts(def).name
+}
+
+export function extractFunctionParams(def: string) {
+  const params = extractFunctionParts(def).params
+  const splitParams = params?.split(',').map((x) => x.trim().split(' '))
+  return splitParams?.map((param) => ({
+    type: param[0],
+    name: param[1] === 'indexed' ? param[2] : param[1],
+    ...(param[1] === 'indexed' ? { indexed: true } : {}),
+  }))
+}
+
+export function extractFunctionType(def: string) {
+  return extractFunctionParts(def).type
+}

package/src/utils/contract/index.ts

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

package/src/utils/data/concat.ts

@@ -0,0 +1,33 @@
+import type { ByteArray, Hex } from '../../types/index.js'
+
+export type ConcatReturnType<TValue extends Hex | ByteArray> =
+  TValue extends Hex ? Hex : ByteArray
+
+export function concat<TValue extends Hex | ByteArray>(
+  values: TValue[],
+): ConcatReturnType<TValue> {
+  if (typeof values[0] === 'string')
+    return concatHex(values as Hex[]) as ConcatReturnType<TValue>
+  return concatBytes(values as ByteArray[]) as ConcatReturnType<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.ts

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

package/src/utils/data/isBytes.ts

@@ -0,0 +1,10 @@
+import type { ByteArray } from '../../types/index.js'
+
+export function isBytes(value: unknown): value is ByteArray {
+  if (!value) return false
+  if (typeof value !== 'object') return false
+  if (!('BYTES_PER_ELEMENT' in value)) return false
+  return (
+    value.BYTES_PER_ELEMENT === 1 && value.constructor.name === 'Uint8Array'
+  )
+}

package/src/utils/data/isHex.ts

@@ -0,0 +1,7 @@
+import type { Hex } from '../../types/index.js'
+
+export function isHex(value: unknown): value is Hex {
+  if (!value) return false
+  if (typeof value !== 'string') return false
+  return /^0x[0-9a-fA-F]*$/.test(value)
+}

package/src/utils/data/pad.ts

@@ -0,0 +1,55 @@
+import { SizeExceedsPaddingSizeError } from '../../errors/index.js'
+import type { ByteArray, Hex } from '../../types/index.js'
+
+type PadOptions = {
+  dir?: 'left' | 'right'
+  size?: number | null
+}
+export type PadReturnType<TValue extends ByteArray | Hex> = TValue extends Hex
+  ? Hex
+  : ByteArray
+
+export function pad<TValue extends ByteArray | Hex>(
+  hexOrBytes: TValue,
+  { dir, size = 32 }: PadOptions = {},
+): PadReturnType<TValue> {
+  if (typeof hexOrBytes === 'string')
+    return padHex(hexOrBytes, { dir, size }) as PadReturnType<TValue>
+  return padBytes(hexOrBytes, { dir, size }) as PadReturnType<TValue>
+}
+
+export function padHex(hex_: Hex, { dir, size = 32 }: PadOptions = {}) {
+  if (size === null) return hex_
+  const 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 (size === null) return bytes
+  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.ts

@@ -0,0 +1,13 @@
+import type { ByteArray, Hex } from '../../types/index.js'
+import { isHex } from './isHex.js'
+
+/**
+ * @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.ts

@@ -0,0 +1,64 @@
+import type { ByteArray, Hex } from '../../types/index.js'
+import { isHex } from './isHex.js'
+import { size } from './size.js'
+
+export type SliceReturnType<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,
+): SliceReturnType<TValue> {
+  if (isHex(value))
+    return sliceHex(value as Hex, start, end) as SliceReturnType<TValue>
+  return sliceBytes(value as ByteArray, start, end) as SliceReturnType<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,
+): ByteArray {
+  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): Hex {
+  assertStartOffset(value_, start)
+  const value = value_
+    .replace('0x', '')
+    .slice((start ?? 0) * 2, (end ?? value_.length) * 2)
+  return `0x${value}`
+}

package/src/utils/data/trim.ts

@@ -0,0 +1,33 @@
+import type { ByteArray, Hex } from '../../types/index.js'
+
+type TrimOptions = {
+  dir?: 'left' | 'right'
+}
+export type TrimReturnType<TValue extends ByteArray | Hex> = TValue extends Hex
+  ? Hex
+  : ByteArray
+
+export function trim<TValue extends ByteArray | Hex>(
+  hexOrBytes: TValue,
+  { dir = 'left' }: TrimOptions = {},
+): TrimReturnType<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 TrimReturnType<TValue>
+  }
+  return data as TrimReturnType<TValue>
+}

package/src/utils/encoding/fromBytes.ts

@@ -0,0 +1,63 @@
+import { InvalidBytesBooleanError } from '../../errors/index.js'
+import type { ByteArray, Hex } from '../../types/index.js'
+import { hexToBigInt, hexToNumber } from './fromHex.js'
+import { bytesToHex } from './toHex.js'
+
+type FromBytesReturnType<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 fromBytes<
+  TTo extends 'string' | 'hex' | 'bigint' | 'number' | 'boolean',
+>(bytes: ByteArray, to: TTo): FromBytesReturnType<TTo> {
+  if (to === 'number') return bytesToNumber(bytes) as FromBytesReturnType<TTo>
+  if (to === 'bigint') return bytesToBigint(bytes) as FromBytesReturnType<TTo>
+  if (to === 'boolean') return bytesToBool(bytes) as FromBytesReturnType<TTo>
+  if (to === 'string') return bytesToString(bytes) as FromBytesReturnType<TTo>
+  return bytesToHex(bytes) as FromBytesReturnType<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/fromHex.ts

@@ -0,0 +1,76 @@
+import { InvalidHexBooleanError } from '../../errors/index.js'
+import type { ByteArray, Hex } from '../../types/index.js'
+import { trim } from '../data/index.js'
+import { hexToBytes } from './toBytes.js'
+
+type FromHexReturnType<TTo> = TTo extends 'string'
+  ? string
+  : TTo extends 'bigint'
+  ? bigint
+  : TTo extends 'number'
+  ? number
+  : TTo extends 'bytes'
+  ? ByteArray
+  : TTo extends 'boolean'
+  ? boolean
+  : never
+
+/**
+ * @description Decodes a hex string into a string, number, bigint, boolean, or bytes32 array.
+ */
+export function fromHex<
+  TTo extends 'string' | 'bigint' | 'number' | 'bytes' | 'boolean',
+>(hex: Hex, to: TTo): FromHexReturnType<TTo> {
+  if (to === 'number') return hexToNumber(hex) as FromHexReturnType<TTo>
+  if (to === 'bigint') return hexToBigInt(hex) as FromHexReturnType<TTo>
+  if (to === 'string') return hexToString(hex) as FromHexReturnType<TTo>
+  if (to === 'boolean') return hexToBool(hex) as FromHexReturnType<TTo>
+  return hexToBytes(hex) as FromHexReturnType<TTo>
+}
+
+export type HexToBigIntOpts = {
+  // Whether or not the number of a signed representation.
+  signed?: boolean
+}
+
+/**
+ * @description Decodes a hex string into a bigint.
+ */
+export function hexToBigInt(hex: Hex, opts: HexToBigIntOpts = {}): bigint {
+  const { signed } = opts
+
+  const value = BigInt(hex)
+  if (!signed) return value
+
+  const size = (hex.length - 2) / 2
+  const max = (1n << (BigInt(size) * 8n - 1n)) - 1n
+  if (value <= max) return value
+
+  return value - BigInt(`0x${'f'.padStart(size * 2, 'f')}`) - 1n
+}
+
+/**
+ * @description Decodes a hex string into a boolean.
+ */
+export function hexToBool(hex: Hex): boolean {
+  if (trim(hex) === '0x0') return false
+  if (trim(hex) === '0x1') return true
+  throw new InvalidHexBooleanError(hex)
+}
+
+type NumberToHexOpts = HexToBigIntOpts
+
+/**
+ * @description Decodes a hex string into a number.
+ */
+export function hexToNumber(hex: Hex, opts: NumberToHexOpts = {}): number {
+  return Number(hexToBigInt(hex, opts))
+}
+
+/**
+ * @description Decodes a hex string into a UTF-8 string.
+ */
+export function hexToString(hex: Hex): string {
+  const bytes = hexToBytes(hex)
+  return new TextDecoder().decode(bytes)
+}

package/src/utils/encoding/fromRlp.ts

@@ -0,0 +1,118 @@
+import {
+  DataLengthTooLongError,
+  DataLengthTooShortError,
+  InvalidHexValueError,
+  OffsetOutOfBoundsError,
+} from '../../errors/index.js'
+import type { ByteArray, Hex } from '../../types/index.js'
+import { bytesToNumber } from './fromBytes.js'
+import { hexToBytes } from './toBytes.js'
+import { bytesToHex } from './toHex.js'
+import type { RecursiveArray } from './toRlp.js'
+
+type FromRlpReturnType<TTo> = TTo extends 'bytes'
+  ? ByteArray
+  : TTo extends 'hex'
+  ? Hex
+  : never
+
+export function fromRlp<TTo extends 'bytes' | 'hex'>(
+  value: ByteArray | Hex,
+  to: TTo,
+): RecursiveArray<FromRlpReturnType<TTo>> {
+  const bytes = parse(value)
+  const [data, consumed] = rlpToBytes(bytes)
+  if (consumed < bytes.length)
+    throw new DataLengthTooLongError({
+      consumed,
+      length: bytes.length,
+    })
+  return format(data, to)
+}
+
+function parse(value: ByteArray | Hex) {
+  if (typeof value === 'string') {
+    if (value.length > 3 && value.length % 2 !== 0)
+      throw new InvalidHexValueError(value)
+    return hexToBytes(value)
+  }
+  return value
+}
+
+function format<TTo extends 'bytes' | 'hex'>(
+  bytes: RecursiveArray<ByteArray>,
+  to: TTo,
+): RecursiveArray<FromRlpReturnType<TTo>> {
+  if (Array.isArray(bytes)) return bytes.map((b) => format(b, to))
+  return (to === 'hex' ? bytesToHex(bytes) : bytes) as FromRlpReturnType<TTo>
+}
+
+function rlpToBytes(
+  bytes: ByteArray,
+  offset = 0,
+): [result: RecursiveArray<ByteArray>, consumed: number] {
+  if (bytes.length === 0) return [new Uint8Array([]), 0]
+
+  const prefix = bytes[offset]
+
+  if (prefix <= 0x7f) return [new Uint8Array([bytes[offset]]), 1]
+
+  if (prefix <= 0xb7) {
+    const length = prefix - 0x80
+    const offset_ = offset + 1
+
+    if (offset_ + length > bytes.length)
+      throw new DataLengthTooShortError({
+        length: offset_ + length,
+        dataLength: bytes.length,
+      })
+
+    return [bytes.slice(offset_, offset_ + length), 1 + length]
+  }
+
+  if (prefix <= 0xbf) {
+    const lengthOfLength = prefix - 0xb7
+    const offset_ = offset + 1
+    const length = bytesToNumber(bytes.slice(offset_, offset_ + lengthOfLength))
+
+    if (offset_ + lengthOfLength + length > bytes.length)
+      throw new DataLengthTooShortError({
+        length: lengthOfLength + length,
+        dataLength: bytes.length - lengthOfLength,
+      })
+
+    return [
+      bytes.slice(offset_ + lengthOfLength, offset_ + lengthOfLength + length),
+      1 + lengthOfLength + length,
+    ]
+  }
+
+  let lengthOfLength = 0
+  let length = prefix - 0xc0
+  if (prefix > 0xf7) {
+    lengthOfLength = prefix - 0xf7
+    length = bytesToNumber(bytes.slice(offset + 1, offset + 1 + lengthOfLength))
+  }
+
+  let nextOffset = offset + 1 + lengthOfLength
+  if (nextOffset > bytes.length)
+    throw new DataLengthTooShortError({
+      length: nextOffset,
+      dataLength: bytes.length,
+    })
+
+  const consumed = 1 + lengthOfLength + length
+  const result = []
+  while (nextOffset < offset + consumed) {
+    const decoded = rlpToBytes(bytes, nextOffset)
+    result.push(decoded[0])
+    nextOffset += decoded[1]
+    if (nextOffset > offset + consumed)
+      throw new OffsetOutOfBoundsError({
+        nextOffset: nextOffset,
+        offset: offset + consumed,
+      })
+  }
+
+  return [result, consumed]
+}

package/src/utils/encoding/index.ts

@@ -0,0 +1,36 @@
+export {
+  boolToBytes,
+  toBytes,
+  hexToBytes,
+  numberToBytes,
+  stringToBytes,
+} from './toBytes.js'
+
+export {
+  boolToHex,
+  bytesToHex,
+  toHex,
+  numberToHex,
+  stringToHex,
+} from './toHex.js'
+
+export type { ToRlpReturnType } from './toRlp.js'
+export { toRlp } from './toRlp.js'
+
+export {
+  bytesToBigint,
+  bytesToBool,
+  bytesToNumber,
+  bytesToString,
+  fromBytes,
+} from './fromBytes.js'
+
+export {
+  fromHex,
+  hexToBigInt,
+  hexToBool,
+  hexToNumber,
+  hexToString,
+} from './fromHex.js'
+
+export { fromRlp } from './fromRlp.js'

package/src/utils/encoding/toBytes.ts

@@ -0,0 +1,62 @@
+import { BaseError } from '../../errors/index.js'
+import type { ByteArray, Hex } from '../../types/index.js'
+import { isHex } from '../data/isHex.js'
+import type { NumberToHexOpts } from './toHex.js'
+import { numberToHex } from './toHex.js'
+
+const encoder = new TextEncoder()
+
+/** @description Encodes a UTF-8 string, hex value, bigint, number or boolean to a byte array. */
+export function toBytes(
+  value: string | bigint | number | boolean | Hex,
+): ByteArray {
+  if (typeof value === 'number' || typeof value === 'bigint')
+    return numberToBytes(value)
+  if (typeof value === 'boolean') return boolToBytes(value)
+  if (isHex(value)) return hexToBytes(value)
+  return stringToBytes(value)
+}
+
+/**
+ * @description Encodes a boolean into a byte array.
+ */
+export function boolToBytes(value: boolean) {
+  const bytes = new Uint8Array(1)
+  bytes[0] = Number(value)
+  return bytes
+}
+
+/**
+ * @description Encodes a hex string into a byte array.
+ */
+export function hexToBytes(hex_: Hex): ByteArray {
+  let hex = hex_.slice(2) as string
+
+  if (hex.length % 2) hex = `0${hex}`
+
+  const bytes = new Uint8Array(hex.length / 2)
+  for (let index = 0; index < bytes.length; index++) {
+    const start = index * 2
+    const hexByte = hex.slice(start, start + 2)
+    const byte = Number.parseInt(hexByte, 16)
+    if (Number.isNaN(byte) || byte < 0)
+      throw new BaseError(`Invalid byte sequence ("${hexByte}" in "${hex}").`)
+    bytes[index] = byte
+  }
+  return bytes
+}
+
+/**
+ * @description Encodes a number into a byte array.
+ */
+export function numberToBytes(value: bigint | number, opts?: NumberToHexOpts) {
+  const hex = numberToHex(value, opts)
+  return hexToBytes(hex)
+}
+
+/**
+ * @description Encodes a UTF-8 string into a byte array.
+ */
+export function stringToBytes(value: string): ByteArray {
+  return encoder.encode(value)
+}