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

package/utils/encoding/fromRlp.ts

@@ -1,119 +1,118 @@
+import { BaseError, type BaseErrorType } from '../../errors/base.js'
 import {
-  DataLengthTooLongError,
-  DataLengthTooShortError,
   InvalidHexValueError,
-  OffsetOutOfBoundsError,
+  type InvalidHexValueErrorType,
 } from '../../errors/encoding.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
+import {
+  type CreateCursorErrorType,
+  type Cursor,
+  createCursor,
+} from '../cursor.js'
+import { type HexToBytesErrorType, hexToBytes } from './toBytes.js'
+import { type BytesToHexErrorType, bytesToHex } from './toHex.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
+type To = 'hex' | 'bytes'
 
-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)
-}
+export type FromRlpReturnType<to extends To> =
+  | (to extends 'bytes' ? RecursiveArray<ByteArray> : never)
+  | (to extends 'hex' ? RecursiveArray<Hex> : never)
 
-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
-}
+export type FromRlpErrorType =
+  | CreateCursorErrorType
+  | FromRlpCursorErrorType
+  | HexToBytesErrorType
+  | InvalidHexValueErrorType
+  | ErrorType
 
-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>
+export function fromRlp<to extends To = 'hex'>(
+  value: ByteArray | Hex,
+  to: to | To | undefined = 'hex',
+): FromRlpReturnType<to> {
+  const bytes = (() => {
+    if (typeof value === 'string') {
+      if (value.length > 3 && value.length % 2 !== 0)
+        throw new InvalidHexValueError(value)
+      return hexToBytes(value)
+    }
+    return value
+  })()
+
+  const cursor = createCursor(bytes)
+  const result = fromRlpCursor(cursor, to)
+
+  return result as FromRlpReturnType<to>
 }
 
-function rlpToBytes(
-  bytes: ByteArray,
-  offset = 0,
-): [result: RecursiveArray<ByteArray>, consumed: number] {
-  if (bytes.length === 0) return [new Uint8Array([]), 0]
+export type RlpToBytesErrorType = FromRlpErrorType | ErrorType
 
-  const prefix = bytes[offset]
-
-  if (prefix <= 0x7f) return [new Uint8Array([bytes[offset]]), 1]
+export function rlpToBytes<to extends To = 'bytes'>(
+  bytes: ByteArray,
+  to: to | To | undefined = 'bytes',
+): FromRlpReturnType<to> {
+  return fromRlp(bytes, to)
+}
 
-  if (prefix <= 0xb7) {
-    const length = prefix - 0x80
-    const offset_ = offset + 1
+export type RlpToHexErrorType = FromRlpErrorType | ErrorType
 
-    if (offset_ + length > bytes.length)
-      throw new DataLengthTooShortError({
-        length: offset_ + length,
-        dataLength: bytes.length,
-      })
+export function rlpToHex<to extends To = 'hex'>(
+  hex: Hex,
+  to: to | To | undefined = 'hex',
+): FromRlpReturnType<to> {
+  return fromRlp(hex, to)
+}
 
-    return [bytes.slice(offset_, offset_ + length), 1 + length]
+export type FromRlpCursorErrorType =
+  | BytesToHexErrorType
+  | ReadLengthErrorType
+  | ReadListErrorType
+  | ErrorType
+
+function fromRlpCursor<to extends To = 'hex'>(
+  cursor: Cursor,
+  to: to | To | undefined = 'hex',
+): FromRlpReturnType<to> {
+  if (cursor.bytes.length === 0)
+    return (
+      to === 'hex' ? bytesToHex(cursor.bytes) : cursor.bytes
+    ) as FromRlpReturnType<to>
+
+  const prefix = cursor.readByte()
+  if (prefix < 0x80) cursor.decrementPosition(1)
+
+  // bytes
+  if (prefix < 0xc0) {
+    const length = readLength(cursor, prefix, 0x80)
+    const bytes = cursor.readBytes(length)
+    return (to === 'hex' ? bytesToHex(bytes) : bytes) as FromRlpReturnType<to>
   }
 
-  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,
-    ]
-  }
+  // list
+  const length = readLength(cursor, prefix, 0xc0)
+  return readList(cursor, length, to) as {} as FromRlpReturnType<to>
+}
 
-  let lengthOfLength = 0
-  let length = prefix - 0xc0
-  if (prefix > 0xf7) {
-    lengthOfLength = prefix - 0xf7
-    length = bytesToNumber(bytes.slice(offset + 1, offset + 1 + lengthOfLength))
-  }
+export type ReadLengthErrorType = BaseErrorType | ErrorType
 
-  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,
-      })
-  }
+function readLength(cursor: Cursor, prefix: number, offset: number) {
+  if (offset === 0x80 && prefix < 0x80) return 1
+  if (prefix <= offset + 55) return prefix - offset
+  if (prefix === offset + 55 + 1) return cursor.readUint8()
+  if (prefix === offset + 55 + 2) return cursor.readUint16()
+  if (prefix === offset + 55 + 3) return cursor.readUint24()
+  if (prefix === offset + 55 + 4) return cursor.readUint32()
+  throw new BaseError('Invalid RLP prefix')
+}
 
-  return [result, consumed]
+export type ReadListErrorType = ErrorType
+
+function readList<to extends To>(cursor: Cursor, length: number, to: to | To) {
+  const position = cursor.position
+  const value: FromRlpReturnType<to>[] = []
+  while (cursor.position - position < length)
+    value.push(fromRlpCursor(cursor, to))
+  return value
 }

package/utils/encoding/toBytes.ts

@@ -1,10 +1,15 @@
 import { BaseError } from '../../errors/base.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
-import { isHex } from '../data/isHex.js'
-import { pad } from '../data/pad.js'
+import { type IsHexErrorType, isHex } from '../data/isHex.js'
+import { type PadErrorType, pad } from '../data/pad.js'
 
-import { assertSize } from './fromHex.js'
-import { type NumberToHexOpts, numberToHex } from './toHex.js'
+import { type AssertSizeErrorType, assertSize } from './fromHex.js'
+import {
+  type NumberToHexErrorType,
+  type NumberToHexOpts,
+  numberToHex,
+} from './toHex.js'
 
 const encoder = /*#__PURE__*/ new TextEncoder()
 
@@ -13,6 +18,14 @@ export type ToBytesParameters = {
   size?: number
 }
 
+export type ToBytesErrorType =
+  | NumberToBytesErrorType
+  | BoolToBytesErrorType
+  | HexToBytesErrorType
+  | StringToBytesErrorType
+  | IsHexErrorType
+  | ErrorType
+
 /**
  * Encodes a UTF-8 string, hex value, bigint, number or boolean to a byte array.
  *
@@ -49,11 +62,16 @@ export function toBytes(
   return stringToBytes(value, opts)
 }
 
-export type BoolToHexOpts = {
+export type BoolToBytesOpts = {
   /** Size of the output bytes. */
   size?: number
 }
 
+export type BoolToBytesErrorType =
+  | AssertSizeErrorType
+  | PadErrorType
+  | ErrorType
+
 /**
  * Encodes a boolean into a byte array.
  *
@@ -73,7 +91,7 @@ export type BoolToHexOpts = {
  * const data = boolToBytes(true, { size: 32 })
  * // 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, 1])
  */
-export function boolToBytes(value: boolean, opts: BoolToHexOpts = {}) {
+export function boolToBytes(value: boolean, opts: BoolToBytesOpts = {}) {
   const bytes = new Uint8Array(1)
   bytes[0] = Number(value)
   if (typeof opts.size === 'number') {
@@ -83,11 +101,33 @@ export function boolToBytes(value: boolean, opts: BoolToHexOpts = {}) {
   return bytes
 }
 
+// We use very optimized technique to convert hex string to byte array
+const charCodeMap = {
+  zero: 48,
+  nine: 57,
+  A: 65,
+  F: 70,
+  a: 97,
+  f: 102,
+} as const
+
+function charCodeToBase16(char: number) {
+  if (char >= charCodeMap.zero && char <= charCodeMap.nine)
+    return char - charCodeMap.zero
+  else if (char >= charCodeMap.A && char <= charCodeMap.F)
+    return char - (charCodeMap.A - 10)
+  else if (char >= charCodeMap.a && char <= charCodeMap.f)
+    return char - (charCodeMap.a - 10)
+  return undefined
+}
+
 export type HexToBytesOpts = {
   /** Size of the output bytes. */
   size?: number
 }
 
+export type HexToBytesErrorType = AssertSizeErrorType | PadErrorType | ErrorType
+
 /**
  * Encodes a hex string into a byte array.
  *
@@ -117,20 +157,28 @@ export function hexToBytes(hex_: Hex, opts: HexToBytesOpts = {}): ByteArray {
   let hexString = hex.slice(2) as string
   if (hexString.length % 2) hexString = `0${hexString}`
 
-  const bytes = new Uint8Array(hexString.length / 2)
-  for (let index = 0; index < bytes.length; index++) {
-    const start = index * 2
-    const hexByte = hexString.slice(start, start + 2)
-    const byte = Number.parseInt(hexByte, 16)
-    if (Number.isNaN(byte) || byte < 0)
+  const length = hexString.length / 2
+  const bytes = new Uint8Array(length)
+  for (let index = 0, j = 0; index < length; index++) {
+    const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++))
+    const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++))
+    if (nibbleLeft === undefined || nibbleRight === undefined) {
       throw new BaseError(
-        `Invalid byte sequence ("${hexByte}" in "${hexString}").`,
+        `Invalid byte sequence ("${hexString[j - 2]}${
+          hexString[j - 1]
+        }" in "${hexString}").`,
       )
-    bytes[index] = byte
+    }
+    bytes[index] = nibbleLeft * 16 + nibbleRight
   }
   return bytes
 }
 
+export type NumberToBytesErrorType =
+  | NumberToHexErrorType
+  | HexToBytesErrorType
+  | ErrorType
+
 /**
  * Encodes a number into a byte array.
  *
@@ -160,6 +208,11 @@ export type StringToBytesOpts = {
   size?: number
 }
 
+export type StringToBytesErrorType =
+  | AssertSizeErrorType
+  | PadErrorType
+  | ErrorType
+
 /**
  * Encodes a UTF-8 string into a byte array.
  *

package/utils/encoding/toHex.ts

@@ -1,8 +1,12 @@
-import { IntegerOutOfRangeError } from '../../errors/encoding.js'
+import {
+  IntegerOutOfRangeError,
+  type IntegerOutOfRangeErrorType,
+} from '../../errors/encoding.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
-import { pad } from '../data/pad.js'
+import { type PadErrorType, pad } from '../data/pad.js'
 
-import { assertSize } from './fromHex.js'
+import { type AssertSizeErrorType, assertSize } from './fromHex.js'
 
 const hexes = /*#__PURE__*/ Array.from({ length: 256 }, (_v, i) =>
   i.toString(16).padStart(2, '0'),
@@ -13,6 +17,13 @@ export type ToHexParameters = {
   size?: number
 }
 
+export type ToHexErrorType =
+  | BoolToHexErrorType
+  | BytesToHexErrorType
+  | NumberToHexErrorType
+  | StringToHexErrorType
+  | ErrorType
+
 /**
  * Encodes a string, number, bigint, or ByteArray into a hex string
  *
@@ -56,6 +67,8 @@ export type BoolToHexOpts = {
   size?: number
 }
 
+export type BoolToHexErrorType = AssertSizeErrorType | PadErrorType | ErrorType
+
 /**
  * Encodes a boolean into a hex string
  *
@@ -94,6 +107,8 @@ export type BytesToHexOpts = {
   size?: number
 }
 
+export type BytesToHexErrorType = AssertSizeErrorType | PadErrorType | ErrorType
+
 /**
  * Encodes a bytes array into a hex string
  *
@@ -114,12 +129,12 @@ export type BytesToHexOpts = {
  * // '0x48656c6c6f20576f726c64210000000000000000000000000000000000000000'
  */
 export function bytesToHex(value: ByteArray, opts: BytesToHexOpts = {}): Hex {
-  let hexString = ''
+  let string = ''
   for (let i = 0; i < value.length; i++) {
-    hexString += hexes[value[i]]
+    string += hexes[value[i]]
   }
+  const hex = `0x${string}` as const
 
-  const hex: Hex = `0x${hexString}`
   if (typeof opts.size === 'number') {
     assertSize(hex, { size: opts.size })
     return pad(hex, { dir: 'right', size: opts.size })
@@ -140,6 +155,11 @@ export type NumberToHexOpts =
       size?: number
     }
 
+export type NumberToHexErrorType =
+  | IntegerOutOfRangeErrorType
+  | PadErrorType
+  | ErrorType
+
 /**
  * Encodes a number or bigint into a hex string
  *
@@ -201,6 +221,8 @@ export type StringToHexOpts = {
   size?: number
 }
 
+export type StringToHexErrorType = BytesToHexErrorType | ErrorType
+
 const encoder = /*#__PURE__*/ new TextEncoder()
 
 /**

package/utils/encoding/toRlp.ts

@@ -1,49 +1,133 @@
+import type { ErrorType } from '../../errors/utils.js'
+import { BaseError } from '../../index.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
-import { concat } from '../data/concat.js'
+import {
+  type CreateCursorErrorType,
+  type Cursor,
+  createCursor,
+} from '../cursor.js'
 
-import { toBytes } from './toBytes.js'
-import { bytesToHex } from './toHex.js'
+import { type HexToBytesErrorType, hexToBytes } from './toBytes.js'
+import { type BytesToHexErrorType, bytesToHex } from './toHex.js'
 
 export type RecursiveArray<T> = T | RecursiveArray<T>[]
 
 type To = 'hex' | 'bytes'
 
-export type ToRlpReturnType<TTo extends To> = TTo extends 'bytes'
-  ? ByteArray
-  : TTo extends 'hex'
-  ? Hex
-  : never
+type Encodable = {
+  length: number
+  encode(cursor: Cursor): void
+}
+
+export type ToRlpReturnType<to extends To> =
+  | (to extends 'bytes' ? ByteArray : never)
+  | (to extends 'hex' ? Hex : never)
+
+export type ToRlpErrorType =
+  | CreateCursorErrorType
+  | BytesToHexErrorType
+  | HexToBytesErrorType
+  | ErrorType
+
+export function toRlp<to extends To = 'hex'>(
+  bytes: RecursiveArray<ByteArray> | RecursiveArray<Hex>,
+  to: to | To | undefined = 'hex',
+): ToRlpReturnType<to> {
+  const encodable = getEncodable(bytes)
+  const cursor = createCursor(new Uint8Array(encodable.length))
+  encodable.encode(cursor)
+
+  if (to === 'hex') return bytesToHex(cursor.bytes) as ToRlpReturnType<to>
+  return cursor.bytes as ToRlpReturnType<to>
+}
+
+export type BytesToRlpErrorType = ToRlpErrorType | ErrorType
 
-export function toRlp<TTo extends To = 'hex'>(
-  hexOrBytes: RecursiveArray<Hex> | RecursiveArray<ByteArray>,
-  to_?: TTo,
-) {
-  const to = to_ || ('hex' as const)
-  return format(bytesToRlp(parse(hexOrBytes)), to) as ToRlpReturnType<TTo>
+export function bytesToRlp<to extends To = 'bytes'>(
+  bytes: RecursiveArray<ByteArray>,
+  to: to | To | undefined = 'bytes',
+): ToRlpReturnType<to> {
+  return toRlp(bytes, to)
 }
 
-function parse(
-  hexOrBytes: RecursiveArray<Hex> | RecursiveArray<ByteArray>,
-): RecursiveArray<ByteArray> {
-  if (Array.isArray(hexOrBytes)) return hexOrBytes.map(parse)
-  return typeof hexOrBytes === 'string' ? toBytes(hexOrBytes) : hexOrBytes
+export type HexToRlpErrorType = ToRlpErrorType | ErrorType
+
+export function hexToRlp<to extends To = 'hex'>(
+  hex: RecursiveArray<Hex>,
+  to: to | To | undefined = 'hex',
+): ToRlpReturnType<to> {
+  return toRlp(hex, to)
 }
 
-function format(bytes: ByteArray, type: 'hex' | 'bytes' = 'bytes') {
-  return type === 'hex' ? bytesToHex(bytes) : bytes
+function getEncodable(
+  bytes: RecursiveArray<ByteArray> | RecursiveArray<Hex>,
+): Encodable {
+  if (Array.isArray(bytes))
+    return getEncodableList(bytes.map((x) => getEncodable(x)))
+  return getEncodableBytes(bytes)
 }
 
-export function bytesToRlp(bytes: RecursiveArray<ByteArray>): ByteArray {
-  if (Array.isArray(bytes)) {
-    const encoded = concat(bytes.map(bytesToRlp))
-    return new Uint8Array([...encodeLength(encoded.length, 0xc0), ...encoded])
+function getEncodableList(list: Encodable[]): Encodable {
+  const bodyLength = list.reduce((acc, x) => acc + x.length, 0)
+
+  const sizeOfBodyLength = getSizeOfLength(bodyLength)
+  const length = (() => {
+    if (bodyLength <= 55) return 1 + bodyLength
+    return 1 + sizeOfBodyLength + bodyLength
+  })()
+
+  return {
+    length,
+    encode(cursor: Cursor) {
+      if (bodyLength <= 55) {
+        cursor.pushByte(0xc0 + bodyLength)
+      } else {
+        cursor.pushByte(0xc0 + 55 + sizeOfBodyLength)
+        if (sizeOfBodyLength === 1) cursor.pushUint8(bodyLength)
+        else if (sizeOfBodyLength === 2) cursor.pushUint16(bodyLength)
+        else if (sizeOfBodyLength === 3) cursor.pushUint24(bodyLength)
+        else cursor.pushUint32(bodyLength)
+      }
+      list.forEach((x) => x.encode(cursor))
+    },
   }
+}
 
-  if (bytes.length === 1 && bytes[0] < 0x80) return bytes
-  return new Uint8Array([...encodeLength(bytes.length, 0x80), ...bytes])
+function getEncodableBytes(bytesOrHex: ByteArray | Hex): Encodable {
+  const bytes =
+    typeof bytesOrHex === 'string' ? hexToBytes(bytesOrHex) : bytesOrHex
+
+  const sizeOfBytesLength = getSizeOfLength(bytes.length)
+  const length = (() => {
+    if (bytes.length === 1 && bytes[0] < 0x80) return 1
+    if (bytes.length <= 55) return 1 + bytes.length
+    return 1 + sizeOfBytesLength + bytes.length
+  })()
+
+  return {
+    length,
+    encode(cursor: Cursor) {
+      if (bytes.length === 1 && bytes[0] < 0x80) {
+        cursor.pushBytes(bytes)
+      } else if (bytes.length <= 55) {
+        cursor.pushByte(0x80 + bytes.length)
+        cursor.pushBytes(bytes)
+      } else {
+        cursor.pushByte(0x80 + 55 + sizeOfBytesLength)
+        if (sizeOfBytesLength === 1) cursor.pushUint8(bytes.length)
+        else if (sizeOfBytesLength === 2) cursor.pushUint16(bytes.length)
+        else if (sizeOfBytesLength === 3) cursor.pushUint24(bytes.length)
+        else cursor.pushUint32(bytes.length)
+        cursor.pushBytes(bytes)
+      }
+    },
+  }
 }
 
-function encodeLength(length: number, offset: number) {
-  if (length < 56) return [offset + length]
-  return [toBytes(length).length + offset + 55, ...toBytes(length)]
+function getSizeOfLength(length: number) {
+  if (length < 2 ** 8) return 1
+  if (length < 2 ** 16) return 2
+  if (length < 2 ** 24) return 3
+  if (length < 2 ** 32) return 4
+  throw new BaseError('Length is too large.')
 }

package/utils/ens/avatar/parseAvatarRecord.ts

@@ -1,9 +1,16 @@
 import type { Client } from '../../../clients/createClient.js'
 import type { Transport } from '../../../clients/transports/createTransport.js'
+import type { ErrorType } from '../../../errors/utils.js'
 import type { Chain } from '../../../types/chain.js'
 import type { AssetGatewayUrls } from '../../../types/ens.js'
 
 import {
+  type GetJsonImageErrorType,
+  type GetMetadataAvatarUriErrorType,
+  type GetNftTokenUriErrorType,
+  type ParseAvatarUriErrorType,
+  type ParseNftUriErrorType,
+  type ResolveAvatarUriErrorType,
   getJsonImage,
   getMetadataAvatarUri,
   getNftTokenUri,
@@ -12,6 +19,11 @@ import {
   resolveAvatarUri,
 } from './utils.js'
 
+export type ParseAvatarRecordErrorType =
+  | ParseNftAvatarUriErrorType
+  | ParseAvatarUriErrorType
+  | ErrorType
+
 export async function parseAvatarRecord<TChain extends Chain | undefined>(
   client: Client<Transport, TChain>,
   {
@@ -27,6 +39,15 @@ export async function parseAvatarRecord<TChain extends Chain | undefined>(
   return parseAvatarUri({ uri: record, gatewayUrls })
 }
 
+export type ParseNftAvatarUriErrorType =
+  | ParseNftUriErrorType
+  | GetNftTokenUriErrorType
+  | ResolveAvatarUriErrorType
+  | ParseAvatarUriErrorType
+  | GetJsonImageErrorType
+  | GetMetadataAvatarUriErrorType
+  | ErrorType
+
 async function parseNftAvatarUri<TChain extends Chain | undefined>(
   client: Client<Transport, TChain>,
   {