viem 2.0.10 → 2.1.1

package/utils/cursor.ts

@@ -1,6 +1,7 @@
 import {
   NegativeOffsetError,
   PositionOutOfBoundsError,
+  RecursiveReadLimitExceededError,
 } from '../errors/cursor.js'
 import type { ErrorType } from '../errors/utils.js'
 import type { ByteArray } from '../types/misc.js'
@@ -9,8 +10,13 @@ export type Cursor = {
   bytes: ByteArray
   dataView: DataView
   position: number
+  positionReadCount: Map<number, number>
+  recursiveReadCount: number
+  recursiveReadLimit: number
+  assertReadLimit(position?: number): void
   assertPosition(position: number): void
   decrementPosition(offset: number): void
+  getReadCount(position?: number): number
   incrementPosition(offset: number): void
   inspectByte(position?: number): ByteArray[number]
   inspectBytes(length: number, position?: number): ByteArray
@@ -25,12 +31,13 @@ export type Cursor = {
   pushUint24(value: number): void
   pushUint32(value: number): void
   readByte(): ByteArray[number]
-  readBytes(length: number): ByteArray
+  readBytes(length: number, size?: number): ByteArray
   readUint8(): number
   readUint16(): number
   readUint24(): number
   readUint32(): number
-  setPosition(position: number): void
+  setPosition(position: number): () => void
+  _touch(): void
 }
 
 export type CreateCursorErrorType = ErrorType
@@ -51,6 +58,16 @@ const staticCursor: Cursor = {
   bytes: new Uint8Array(),
   dataView: new DataView(new ArrayBuffer(0)),
   position: 0,
+  positionReadCount: new Map(),
+  recursiveReadCount: 0,
+  recursiveReadLimit: Infinity,
+  assertReadLimit() {
+    if (this.recursiveReadCount >= this.recursiveReadLimit)
+      throw new RecursiveReadLimitExceededError({
+        count: this.recursiveReadCount + 1,
+        limit: this.recursiveReadLimit,
+      })
+  },
   assertPosition(position) {
     if (position < 0 || position > this.bytes.length - 1)
       throw new PositionOutOfBoundsError({
@@ -64,6 +81,9 @@ const staticCursor: Cursor = {
     this.assertPosition(position)
     this.position = position
   },
+  getReadCount(position) {
+    return this.positionReadCount.get(position || this.position) || 0
+  },
   incrementPosition(offset) {
     if (offset < 0) throw new NegativeOffsetError({ offset })
     const position = this.position + offset
@@ -135,48 +155,75 @@ const staticCursor: Cursor = {
     this.position += 4
   },
   readByte() {
+    this.assertReadLimit()
+    this._touch()
     const value = this.inspectByte()
     this.position++
     return value
   },
-  readBytes(length) {
+  readBytes(length, size) {
+    this.assertReadLimit()
+    this._touch()
     const value = this.inspectBytes(length)
-    this.position += length
+    this.position += size ?? length
     return value
   },
   readUint8() {
+    this.assertReadLimit()
+    this._touch()
     const value = this.inspectUint8()
     this.position += 1
     return value
   },
   readUint16() {
+    this.assertReadLimit()
+    this._touch()
     const value = this.inspectUint16()
     this.position += 2
     return value
   },
   readUint24() {
+    this.assertReadLimit()
+    this._touch()
     const value = this.inspectUint24()
     this.position += 3
     return value
   },
   readUint32() {
+    this.assertReadLimit()
+    this._touch()
     const value = this.inspectUint32()
     this.position += 4
     return value
   },
   setPosition(position) {
+    const oldPosition = this.position
     this.assertPosition(position)
     this.position = position
+    return () => (this.position = oldPosition)
+  },
+  _touch() {
+    if (this.recursiveReadLimit === Infinity) return
+    const count = this.getReadCount()
+    this.positionReadCount.set(this.position, count + 1)
+    if (count > 0) this.recursiveReadCount++
   },
 }
 
-export function createCursor(bytes: ByteArray): Cursor {
-  const cursor = Object.create(staticCursor)
+type CursorConfig = { recursiveReadLimit?: number }
+
+export function createCursor(
+  bytes: ByteArray,
+  { recursiveReadLimit = 8_192 }: CursorConfig = {},
+): Cursor {
+  const cursor: Cursor = Object.create(staticCursor)
   cursor.bytes = bytes
   cursor.dataView = new DataView(
     bytes.buffer,
     bytes.byteOffset,
     bytes.byteLength,
   )
+  cursor.positionReadCount = new Map()
+  cursor.recursiveReadLimit = recursiveReadLimit
   return cursor
 }

package/utils/encoding/fromBytes.ts

@@ -119,7 +119,7 @@ export function bytesToBigInt(
 ): bigint {
   if (typeof opts.size !== 'undefined') assertSize(bytes, { size: opts.size })
   const hex = bytesToHex(bytes, opts)
-  return hexToBigInt(hex)
+  return hexToBigInt(hex, opts)
 }
 
 export type BytesToBoolOpts = {
@@ -187,7 +187,7 @@ export function bytesToNumber(
 ): number {
   if (typeof opts.size !== 'undefined') assertSize(bytes, { size: opts.size })
   const hex = bytesToHex(bytes, opts)
-  return hexToNumber(hex)
+  return hexToNumber(hex, opts)
 }
 
 export type BytesToStringOpts = {

package/utils/encoding/fromRlp.ts

@@ -41,7 +41,7 @@ export function fromRlp<to extends To = 'hex'>(
     return value
   })()
 
-  const cursor = createCursor(bytes)
+  const cursor = createCursor(bytes, { recursiveReadLimit: Infinity })
   const result = fromRlpCursor(cursor, to)
 
   return result as FromRlpReturnType<to>