viem 2.0.0-alpha.9 → 2.0.0-beta.1

package/utils/cursor.ts

@@ -0,0 +1,182 @@
+import {
+  NegativeOffsetError,
+  PositionOutOfBoundsError,
+} from '../errors/cursor.js'
+import type { ErrorType } from '../errors/utils.js'
+import type { ByteArray } from '../types/misc.js'
+
+export type Cursor = {
+  bytes: ByteArray
+  dataView: DataView
+  position: number
+  assertPosition(position: number): void
+  decrementPosition(offset: number): void
+  incrementPosition(offset: number): void
+  inspectByte(position?: number): ByteArray[number]
+  inspectBytes(length: number, position?: number): ByteArray
+  inspectUint8(position?: number): number
+  inspectUint16(position?: number): number
+  inspectUint24(position?: number): number
+  inspectUint32(position?: number): number
+  pushByte(byte: ByteArray[number]): void
+  pushBytes(bytes: ByteArray): void
+  pushUint8(value: number): void
+  pushUint16(value: number): void
+  pushUint24(value: number): void
+  pushUint32(value: number): void
+  readByte(): ByteArray[number]
+  readBytes(length: number): ByteArray
+  readUint8(): number
+  readUint16(): number
+  readUint24(): number
+  readUint32(): number
+  setPosition(position: number): void
+}
+
+export type CreateCursorErrorType = ErrorType
+
+export type CursorErrorType =
+  | CursorAssertPositionErrorType
+  | CursorDecrementPositionErrorType
+  | CursorIncrementPositionErrorType
+  | ErrorType
+
+export type CursorAssertPositionErrorType = PositionOutOfBoundsError | ErrorType
+
+export type CursorDecrementPositionErrorType = NegativeOffsetError | ErrorType
+
+export type CursorIncrementPositionErrorType = NegativeOffsetError | ErrorType
+
+const staticCursor: Cursor = {
+  bytes: new Uint8Array(),
+  dataView: new DataView(new ArrayBuffer(0)),
+  position: 0,
+  assertPosition(position) {
+    if (position < 0 || position > this.bytes.length - 1)
+      throw new PositionOutOfBoundsError({
+        length: this.bytes.length,
+        position,
+      })
+  },
+  decrementPosition(offset) {
+    if (offset < 0) throw new NegativeOffsetError({ offset })
+    const position = this.position - offset
+    this.assertPosition(position)
+    this.position = position
+  },
+  incrementPosition(offset) {
+    if (offset < 0) throw new NegativeOffsetError({ offset })
+    const position = this.position + offset
+    this.assertPosition(position)
+    this.position = position
+  },
+  inspectByte(position_) {
+    const position = position_ ?? this.position
+    this.assertPosition(position)
+    return this.bytes[position]
+  },
+  inspectBytes(length, position_) {
+    const position = position_ ?? this.position
+    this.assertPosition(position + length - 1)
+    return this.bytes.subarray(position, position + length)
+  },
+  inspectUint8(position_) {
+    const position = position_ ?? this.position
+    this.assertPosition(position)
+    return this.bytes[position]
+  },
+  inspectUint16(position_) {
+    const position = position_ ?? this.position
+    this.assertPosition(position + 1)
+    return this.dataView.getUint16(position)
+  },
+  inspectUint24(position_) {
+    const position = position_ ?? this.position
+    this.assertPosition(position + 2)
+    return (
+      (this.dataView.getUint16(position) << 8) +
+      this.dataView.getUint8(position + 2)
+    )
+  },
+  inspectUint32(position_) {
+    const position = position_ ?? this.position
+    this.assertPosition(position + 3)
+    return this.dataView.getUint32(position)
+  },
+  pushByte(byte: ByteArray[number]) {
+    this.assertPosition(this.position)
+    this.bytes[this.position] = byte
+    this.position++
+  },
+  pushBytes(bytes: ByteArray) {
+    this.assertPosition(this.position + bytes.length - 1)
+    this.bytes.set(bytes, this.position)
+    this.position += bytes.length
+  },
+  pushUint8(value: number) {
+    this.assertPosition(this.position)
+    this.bytes[this.position] = value
+    this.position++
+  },
+  pushUint16(value: number) {
+    this.assertPosition(this.position + 1)
+    this.dataView.setUint16(this.position, value)
+    this.position += 2
+  },
+  pushUint24(value: number) {
+    this.assertPosition(this.position + 2)
+    this.dataView.setUint16(this.position, value >> 8)
+    this.dataView.setUint8(this.position + 2, value & ~4294967040)
+    this.position += 3
+  },
+  pushUint32(value: number) {
+    this.assertPosition(this.position + 3)
+    this.dataView.setUint32(this.position, value)
+    this.position += 4
+  },
+  readByte() {
+    const value = this.inspectByte()
+    this.position++
+    return value
+  },
+  readBytes(length) {
+    const value = this.inspectBytes(length)
+    this.position += length
+    return value
+  },
+  readUint8() {
+    const value = this.inspectUint8()
+    this.position += 1
+    return value
+  },
+  readUint16() {
+    const value = this.inspectUint16()
+    this.position += 2
+    return value
+  },
+  readUint24() {
+    const value = this.inspectUint24()
+    this.position += 3
+    return value
+  },
+  readUint32() {
+    const value = this.inspectUint32()
+    this.position += 4
+    return value
+  },
+  setPosition(position) {
+    this.assertPosition(position)
+    this.position = position
+  },
+}
+
+export function createCursor(bytes: ByteArray): Cursor {
+  const cursor = Object.create(staticCursor)
+  cursor.bytes = bytes
+  cursor.dataView = new DataView(
+    bytes.buffer,
+    bytes.byteOffset,
+    bytes.byteLength,
+  )
+  return cursor
+}

package/utils/data/concat.ts

@@ -1,17 +1,25 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
 
 export type ConcatReturnType<TValue extends Hex | ByteArray> =
   TValue extends Hex ? Hex : ByteArray
 
+export type ConcatErrorType =
+  | ConcatBytesErrorType
+  | ConcatHexErrorType
+  | ErrorType
+
 export function concat<TValue extends Hex | ByteArray>(
-  values: TValue[],
+  values: readonly TValue[],
 ): ConcatReturnType<TValue> {
   if (typeof values[0] === 'string')
-    return concatHex(values as Hex[]) as ConcatReturnType<TValue>
-  return concatBytes(values as ByteArray[]) as ConcatReturnType<TValue>
+    return concatHex(values as readonly Hex[]) as ConcatReturnType<TValue>
+  return concatBytes(values as readonly ByteArray[]) as ConcatReturnType<TValue>
 }
 
-export function concatBytes(values: ByteArray[]): ByteArray {
+export type ConcatBytesErrorType = ErrorType
+
+export function concatBytes(values: readonly ByteArray[]): ByteArray {
   let length = 0
   for (const arr of values) {
     length += arr.length
@@ -25,7 +33,9 @@ export function concatBytes(values: ByteArray[]): ByteArray {
   return result
 }
 
-export function concatHex(values: Hex[]): Hex {
+export type ConcatHexErrorType = ErrorType
+
+export function concatHex(values: readonly Hex[]): Hex {
   return `0x${(values as Hex[]).reduce(
     (acc, x) => acc + x.replace('0x', ''),
     '',

package/utils/data/isBytes.ts

@@ -1,5 +1,8 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray } from '../../types/misc.js'
 
+export type IsBytesErrorType = ErrorType
+
 export function isBytes(value: unknown): value is ByteArray {
   if (!value) return false
   if (typeof value !== 'object') return false

package/utils/data/isBytesEqual.ts

@@ -1,8 +1,14 @@
 import { equalBytes } from '@noble/curves/abstract/utils'
 
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
-import { toBytes } from '../encoding/toBytes.js'
-import { isHex } from './isHex.js'
+import { type ToBytesErrorType, toBytes } from '../encoding/toBytes.js'
+import { type IsHexErrorType, isHex } from './isHex.js'
+
+export type IsBytesEqualErrorType =
+  | IsHexErrorType
+  | ToBytesErrorType
+  | ErrorType
 
 export function isBytesEqual(a_: ByteArray | Hex, b_: ByteArray | Hex) {
   const a = isHex(a_) ? toBytes(a_) : a_

package/utils/data/isHex.ts

@@ -1,5 +1,8 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { Hex } from '../../types/misc.js'
 
+export type IsHexErrorType = ErrorType
+
 export function isHex(
   value: unknown,
   { strict = true }: { strict?: boolean } = {},

package/utils/data/pad.ts

@@ -1,4 +1,8 @@
-import { SizeExceedsPaddingSizeError } from '../../errors/data.js'
+import {
+  SizeExceedsPaddingSizeError,
+  type SizeExceedsPaddingSizeErrorType,
+} from '../../errors/data.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
 
 type PadOptions = {
@@ -9,6 +13,8 @@ export type PadReturnType<TValue extends ByteArray | Hex> = TValue extends Hex
   ? Hex
   : ByteArray
 
+export type PadErrorType = PadHexErrorType | PadBytesErrorType | ErrorType
+
 export function pad<TValue extends ByteArray | Hex>(
   hexOrBytes: TValue,
   { dir, size = 32 }: PadOptions = {},
@@ -18,6 +24,8 @@ export function pad<TValue extends ByteArray | Hex>(
   return padBytes(hexOrBytes, { dir, size }) as PadReturnType<TValue>
 }
 
+export type PadHexErrorType = SizeExceedsPaddingSizeErrorType | ErrorType
+
 export function padHex(hex_: Hex, { dir, size = 32 }: PadOptions = {}) {
   if (size === null) return hex_
   const hex = hex_.replace('0x', '')
@@ -34,6 +42,8 @@ export function padHex(hex_: Hex, { dir, size = 32 }: PadOptions = {}) {
   )}` as Hex
 }
 
+export type PadBytesErrorType = SizeExceedsPaddingSizeErrorType | ErrorType
+
 export function padBytes(
   bytes: ByteArray,
   { dir, size = 32 }: PadOptions = {},

package/utils/data/size.ts

@@ -1,6 +1,9 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
 
-import { isHex } from './isHex.js'
+import { type IsHexErrorType, isHex } from './isHex.js'
+
+export type SizeErrorType = IsHexErrorType | ErrorType
 
 /**
  * @description Retrieves the size of the value (in bytes).

package/utils/data/slice.ts

@@ -1,13 +1,23 @@
-import { SliceOffsetOutOfBoundsError } from '../../errors/data.js'
+import {
+  SliceOffsetOutOfBoundsError,
+  type SliceOffsetOutOfBoundsErrorType,
+} from '../../errors/data.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
 
-import { isHex } from './isHex.js'
-import { size } from './size.js'
+import { type IsHexErrorType, isHex } from './isHex.js'
+import { type SizeErrorType, size } from './size.js'
 
 export type SliceReturnType<TValue extends ByteArray | Hex> = TValue extends Hex
   ? Hex
   : ByteArray
 
+export type SliceErrorType =
+  | IsHexErrorType
+  | SliceBytesErrorType
+  | SliceHexErrorType
+  | ErrorType
+
 /**
  * @description Returns a section of the hex or byte array given a start/end bytes offset.
  *
@@ -30,6 +40,11 @@ export function slice<TValue extends ByteArray | Hex>(
   }) as SliceReturnType<TValue>
 }
 
+export type AssertStartOffsetErrorType =
+  | SliceOffsetOutOfBoundsErrorType
+  | SizeErrorType
+  | ErrorType
+
 function assertStartOffset(value: Hex | ByteArray, start?: number) {
   if (typeof start === 'number' && start > 0 && start > size(value) - 1)
     throw new SliceOffsetOutOfBoundsError({
@@ -39,6 +54,11 @@ function assertStartOffset(value: Hex | ByteArray, start?: number) {
     })
 }
 
+export type AssertEndOffsetErrorType =
+  | SliceOffsetOutOfBoundsErrorType
+  | SizeErrorType
+  | ErrorType
+
 function assertEndOffset(value: Hex | ByteArray, start?: number, end?: number) {
   if (
     typeof start === 'number' &&
@@ -53,6 +73,11 @@ function assertEndOffset(value: Hex | ByteArray, start?: number, end?: number) {
   }
 }
 
+export type SliceBytesErrorType =
+  | AssertStartOffsetErrorType
+  | AssertEndOffsetErrorType
+  | ErrorType
+
 /**
  * @description Returns a section of the byte array given a start/end bytes offset.
  *
@@ -72,6 +97,11 @@ export function sliceBytes(
   return value
 }
 
+export type SliceHexErrorType =
+  | AssertStartOffsetErrorType
+  | AssertEndOffsetErrorType
+  | ErrorType
+
 /**
  * @description Returns a section of the hex value given a start/end bytes offset.
  *

package/utils/data/trim.ts

@@ -1,3 +1,4 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
 
 type TrimOptions = {
@@ -7,6 +8,8 @@ export type TrimReturnType<TValue extends ByteArray | Hex> = TValue extends Hex
   ? Hex
   : ByteArray
 
+export type TrimErrorType = ErrorType
+
 export function trim<TValue extends ByteArray | Hex>(
   hexOrBytes: TValue,
   { dir = 'left' }: TrimOptions = {},

package/utils/encoding/fromBytes.ts

@@ -1,9 +1,17 @@
 import { InvalidBytesBooleanError } from '../../errors/encoding.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
-import { trim } from '../data/trim.js'
+import { type TrimErrorType, trim } from '../data/trim.js'
 
-import { assertSize, hexToBigInt, hexToNumber } from './fromHex.js'
-import { bytesToHex } from './toHex.js'
+import {
+  type AssertSizeErrorType,
+  type HexToBigIntErrorType,
+  type HexToNumberErrorType,
+  assertSize,
+  hexToBigInt,
+  hexToNumber,
+} from './fromHex.js'
+import { type BytesToHexErrorType, bytesToHex } from './toHex.js'
 
 export type FromBytesParameters<
   TTo extends 'string' | 'hex' | 'bigint' | 'number' | 'boolean',
@@ -16,7 +24,7 @@ export type FromBytesParameters<
       to: TTo
     }
 
-type FromBytesReturnType<TTo> = TTo extends 'string'
+export type FromBytesReturnType<TTo> = TTo extends 'string'
   ? string
   : TTo extends 'hex'
   ? Hex
@@ -28,6 +36,14 @@ type FromBytesReturnType<TTo> = TTo extends 'string'
   ? boolean
   : never
 
+export type FromBytesErrorType =
+  | BytesToHexErrorType
+  | BytesToBigIntErrorType
+  | BytesToBoolErrorType
+  | BytesToNumberErrorType
+  | BytesToStringErrorType
+  | ErrorType
+
 /**
  * Decodes a byte array into a UTF-8 string, hex value, number, bigint or boolean.
  *
@@ -63,7 +79,7 @@ export function fromBytes<
   if (to === 'number')
     return bytesToNumber(bytes, opts) as FromBytesReturnType<TTo>
   if (to === 'bigint')
-    return bytesToBigint(bytes, opts) as FromBytesReturnType<TTo>
+    return bytesToBigInt(bytes, opts) as FromBytesReturnType<TTo>
   if (to === 'boolean')
     return bytesToBool(bytes, opts) as FromBytesReturnType<TTo>
   if (to === 'string')
@@ -78,6 +94,11 @@ export type BytesToBigIntOpts = {
   size?: number
 }
 
+export type BytesToBigIntErrorType =
+  | BytesToHexErrorType
+  | HexToBigIntErrorType
+  | ErrorType
+
 /**
  * Decodes a byte array into a bigint.
  *
@@ -88,11 +109,11 @@ export type BytesToBigIntOpts = {
  * @returns BigInt value.
  *
  * @example
- * import { bytesToBigint } from 'viem'
- * const data = bytesToBigint(new Uint8Array([1, 164]))
+ * import { bytesToBigInt } from 'viem'
+ * const data = bytesToBigInt(new Uint8Array([1, 164]))
  * // 420n
  */
-export function bytesToBigint(
+export function bytesToBigInt(
   bytes: ByteArray,
   opts: BytesToBigIntOpts = {},
 ): bigint {
@@ -106,6 +127,11 @@ export type BytesToBoolOpts = {
   size?: number
 }
 
+export type BytesToBoolErrorType =
+  | AssertSizeErrorType
+  | TrimErrorType
+  | ErrorType
+
 /**
  * Decodes a byte array into a boolean.
  *
@@ -136,6 +162,11 @@ export function bytesToBool(
 
 export type BytesToNumberOpts = BytesToBigIntOpts
 
+export type BytesToNumberErrorType =
+  | BytesToHexErrorType
+  | HexToNumberErrorType
+  | ErrorType
+
 /**
  * Decodes a byte array into a number.
  *
@@ -164,6 +195,11 @@ export type BytesToStringOpts = {
   size?: number
 }
 
+export type BytesToStringErrorType =
+  | AssertSizeErrorType
+  | TrimErrorType
+  | ErrorType
+
 /**
  * Decodes a byte array into a UTF-8 string.
  *

package/utils/encoding/fromHex.ts

@@ -1,12 +1,20 @@
 import {
   InvalidHexBooleanError,
+  type InvalidHexBooleanErrorType,
   SizeOverflowError,
+  type SizeOverflowErrorType,
 } from '../../errors/encoding.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
-import { size as size_ } from '../data/size.js'
-import { trim } from '../data/trim.js'
+import { type SizeErrorType, size as size_ } from '../data/size.js'
+import { type TrimErrorType, trim } from '../data/trim.js'
 
-import { hexToBytes } from './toBytes.js'
+import { type HexToBytesErrorType, hexToBytes } from './toBytes.js'
+
+export type AssertSizeErrorType =
+  | SizeOverflowErrorType
+  | SizeErrorType
+  | ErrorType
 
 export function assertSize(
   hexOrBytes: Hex | ByteArray,
@@ -42,6 +50,14 @@ export type FromHexReturnType<TTo> = TTo extends 'string'
   ? boolean
   : never
 
+export type FromHexErrorType =
+  | HexToNumberErrorType
+  | HexToBigIntErrorType
+  | HexToBoolErrorType
+  | HexToStringErrorType
+  | HexToBytesErrorType
+  | ErrorType
+
 /**
  * Decodes a hex string into a string, number, bigint, boolean, or byte array.
  *
@@ -90,6 +106,8 @@ export type HexToBigIntOpts = {
   size?: number
 }
 
+export type HexToBigIntErrorType = AssertSizeErrorType | ErrorType
+
 /**
  * Decodes a hex value into a bigint.
  *
@@ -129,6 +147,12 @@ export type HexToBoolOpts = {
   size?: number
 }
 
+export type HexToBoolErrorType =
+  | AssertSizeErrorType
+  | InvalidHexBooleanErrorType
+  | TrimErrorType
+  | ErrorType
+
 /**
  * Decodes a hex value into a boolean.
  *
@@ -161,6 +185,8 @@ export function hexToBool(hex_: Hex, opts: HexToBoolOpts = {}): boolean {
 
 export type HexToNumberOpts = HexToBigIntOpts
 
+export type HexToNumberErrorType = HexToBigIntErrorType | ErrorType
+
 /**
  * Decodes a hex string into a number.
  *
@@ -189,6 +215,12 @@ export type HexToStringOpts = {
   size?: number
 }
 
+export type HexToStringErrorType =
+  | AssertSizeErrorType
+  | HexToBytesErrorType
+  | TrimErrorType
+  | ErrorType
+
 /**
  * Decodes a hex value into a UTF-8 string.
  *