ox 1.0.0-beta.9 → 1.0.1

package/package.json

@@ -2,7 +2,7 @@
   "name": "ox",
   "description": "Ethereum Standard Library",
   "type": "module",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.1",
   "main": "./dist/index.js",
   "sideEffects": false,
   "license": "MIT",
@@ -26,6 +26,7 @@
     "evm"
   ],
   "files": [
+    "CHANGELOG.md",
     "dist",
     "src"
   ],
@@ -559,11 +560,6 @@
       "types": "./dist/tempo/Tick.d.ts",
       "default": "./dist/tempo/Tick.js"
     },
-    "./tempo/TokenId": {
-      "src": "./src/tempo/TokenId.ts",
-      "types": "./dist/tempo/TokenId.d.ts",
-      "default": "./dist/tempo/TokenId.js"
-    },
     "./tempo/TokenRole": {
       "src": "./src/tempo/TokenRole.ts",
       "types": "./dist/tempo/TokenRole.d.ts",
@@ -659,6 +655,56 @@
       "types": "./dist/zod/index.d.ts",
       "default": "./dist/zod/index.js"
     },
+    "./zod/Abi": {
+      "src": "./src/zod/Abi.ts",
+      "types": "./dist/zod/Abi.d.ts",
+      "default": "./dist/zod/Abi.js"
+    },
+    "./zod/AbiConstructor": {
+      "src": "./src/zod/AbiConstructor.ts",
+      "types": "./dist/zod/AbiConstructor.d.ts",
+      "default": "./dist/zod/AbiConstructor.js"
+    },
+    "./zod/AbiError": {
+      "src": "./src/zod/AbiError.ts",
+      "types": "./dist/zod/AbiError.d.ts",
+      "default": "./dist/zod/AbiError.js"
+    },
+    "./zod/AbiEvent": {
+      "src": "./src/zod/AbiEvent.ts",
+      "types": "./dist/zod/AbiEvent.d.ts",
+      "default": "./dist/zod/AbiEvent.js"
+    },
+    "./zod/AbiFallback": {
+      "src": "./src/zod/AbiFallback.ts",
+      "types": "./dist/zod/AbiFallback.d.ts",
+      "default": "./dist/zod/AbiFallback.js"
+    },
+    "./zod/AbiFunction": {
+      "src": "./src/zod/AbiFunction.ts",
+      "types": "./dist/zod/AbiFunction.d.ts",
+      "default": "./dist/zod/AbiFunction.js"
+    },
+    "./zod/AbiItem": {
+      "src": "./src/zod/AbiItem.ts",
+      "types": "./dist/zod/AbiItem.d.ts",
+      "default": "./dist/zod/AbiItem.js"
+    },
+    "./zod/AbiParameter": {
+      "src": "./src/zod/AbiParameter.ts",
+      "types": "./dist/zod/AbiParameter.d.ts",
+      "default": "./dist/zod/AbiParameter.js"
+    },
+    "./zod/AbiParameters": {
+      "src": "./src/zod/AbiParameters.ts",
+      "types": "./dist/zod/AbiParameters.d.ts",
+      "default": "./dist/zod/AbiParameters.js"
+    },
+    "./zod/AbiReceive": {
+      "src": "./src/zod/AbiReceive.ts",
+      "types": "./dist/zod/AbiReceive.d.ts",
+      "default": "./dist/zod/AbiReceive.js"
+    },
     "./zod/AccessList": {
       "src": "./src/zod/AccessList.ts",
       "types": "./dist/zod/AccessList.d.ts",
@@ -749,6 +795,11 @@
       "types": "./dist/zod/Signature.d.ts",
       "default": "./dist/zod/Signature.js"
     },
+    "./zod/Solidity": {
+      "src": "./src/zod/Solidity.ts",
+      "types": "./dist/zod/Solidity.d.ts",
+      "default": "./dist/zod/Solidity.js"
+    },
     "./zod/StateOverrides": {
       "src": "./src/zod/StateOverrides.ts",
       "types": "./dist/zod/StateOverrides.d.ts",
@@ -799,6 +850,11 @@
       "types": "./dist/zod/TxEnvelopeLegacy.d.ts",
       "default": "./dist/zod/TxEnvelopeLegacy.js"
     },
+    "./zod/TypedData": {
+      "src": "./src/zod/TypedData.ts",
+      "types": "./dist/zod/TypedData.d.ts",
+      "default": "./dist/zod/TypedData.js"
+    },
     "./zod/Uint": {
       "src": "./src/zod/Uint.ts",
       "types": "./dist/zod/Uint.d.ts",
@@ -849,11 +905,6 @@
       "types": "./dist/zod/tempo/Tick.d.ts",
       "default": "./dist/zod/tempo/Tick.js"
     },
-    "./zod/tempo/TokenId": {
-      "src": "./src/zod/tempo/TokenId.ts",
-      "types": "./dist/zod/tempo/TokenId.d.ts",
-      "default": "./dist/zod/tempo/TokenId.js"
-    },
     "./zod/tempo/TokenRole": {
       "src": "./src/zod/tempo/TokenRole.ts",
       "types": "./dist/zod/tempo/TokenRole.d.ts",

package/src/core/AbiParameters.ts

@@ -109,7 +109,9 @@ export function decode(
   for (let i = 0; i < parameters.length; ++i) {
     const param = parameters[i] as Parameter
     try {
-      cursor.setPosition(consumed)
+      // Zero-width types (e.g. `uint256[0]`, empty tuples) at the end of the
+      // data consume no bytes, so the cursor may already be exhausted.
+      if (consumed < bytes.length) cursor.setPosition(consumed)
       const [data_, consumed_] = internal.decodeParameter(cursor, param, {
         checksumAddress,
         staticPosition: 0,

package/src/core/Rlp.ts

@@ -5,6 +5,9 @@ import * as internal_bytes from './internal/bytes.js'
 import * as Cursor from './internal/cursor.js'
 import type { ExactPartial, RecursiveArray } from './internal/types.js'
 
+/** Maximum nesting depth permitted when decoding an RLP value. */
+const depthLimit = 1_024
+
 /**
  * Decodes a Recursive-Length Prefix (RLP) value into a {@link ox#Bytes.Bytes} value.
  *
@@ -68,6 +71,12 @@ export function to<
   })
   const result = decodeRlpCursor(cursor, to_)
 
+  // RLP payloads encode exactly one item (Yellow Paper, Appendix B).
+  if (cursor.position < cursor.bytes.length)
+    throw new TrailingBytesError({
+      count: cursor.bytes.length - cursor.position,
+    })
+
   return result as to.ReturnType<to>
 }
 
@@ -82,6 +91,7 @@ export declare namespace to {
     | decodeRlpCursor.ErrorType
     | Cursor.create.ErrorType
     | Hex.InvalidLengthError
+    | TrailingBytesError
     | Errors.GlobalErrorType
 }
 
@@ -91,7 +101,11 @@ export declare namespace to {
 export function decodeRlpCursor<to extends 'Hex' | 'Bytes' = 'Hex'>(
   cursor: Cursor.Cursor,
   to: to | 'Hex' | 'Bytes' | undefined = 'Hex',
+  depth = 0,
 ): decodeRlpCursor.ReturnType<to> {
+  if (depth >= depthLimit)
+    throw new DepthLimitExceededError({ limit: depthLimit })
+
   if (cursor.bytes.length === 0)
     return (
       to === 'Hex' ? Hex.fromBytes(cursor.bytes) : cursor.bytes
@@ -111,7 +125,12 @@ export function decodeRlpCursor<to extends 'Hex' | 'Bytes' = 'Hex'>(
 
   // list
   const length = readLength(cursor, prefix, 0xc0)
-  return readList(cursor, length, to) as {} as decodeRlpCursor.ReturnType<to>
+  return readList(
+    cursor,
+    length,
+    to,
+    depth + 1,
+  ) as {} as decodeRlpCursor.ReturnType<to>
 }
 
 /** @internal */
@@ -121,6 +140,7 @@ export declare namespace decodeRlpCursor {
     | Hex.fromBytes.ErrorType
     | readLength.ErrorType
     | readList.ErrorType
+    | DepthLimitExceededError
     | Errors.GlobalErrorType
 }
 
@@ -149,17 +169,27 @@ export function readList<to extends 'Hex' | 'Bytes'>(
   cursor: Cursor.Cursor,
   length: number,
   to: to | 'Hex' | 'Bytes',
+  depth = 0,
 ) {
   const position = cursor.position
   const value: decodeRlpCursor.ReturnType<to>[] = []
   while (cursor.position - position < length)
-    value.push(decodeRlpCursor(cursor, to))
+    value.push(decodeRlpCursor(cursor, to, depth))
+  // Items must consume exactly the declared list length.
+  if (cursor.position - position !== length)
+    throw new ListBoundaryExceededError({
+      consumed: cursor.position - position,
+      declared: length,
+    })
   return value
 }
 
 /** @internal */
 export declare namespace readList {
-  type ErrorType = Errors.GlobalErrorType
+  type ErrorType =
+    | DepthLimitExceededError
+    | ListBoundaryExceededError
+    | Errors.GlobalErrorType
 }
 
 /**
@@ -643,3 +673,36 @@ function writeBigEndian(
 function invalidNibble(hex: Hex.Hex): Errors.BaseError {
   return new Errors.BaseError(`Invalid hex string \`${hex}\`.`)
 }
+
+/** Thrown when an RLP value nests deeper than the decode depth limit. */
+export class DepthLimitExceededError extends Errors.BaseError {
+  override readonly name = 'Rlp.DepthLimitExceededError'
+
+  constructor({ limit }: { limit: number }) {
+    super(`RLP depth limit of \`${limit}\` exceeded.`)
+  }
+}
+
+/** Thrown when RLP list items overrun the list's declared length. */
+export class ListBoundaryExceededError extends Errors.BaseError {
+  override readonly name = 'Rlp.ListBoundaryExceededError'
+
+  constructor({ consumed, declared }: { consumed: number; declared: number }) {
+    super(
+      `RLP list items consumed \`${consumed}\` bytes but the list declared a length of \`${declared}\`.`,
+    )
+  }
+}
+
+/** Thrown when an RLP payload contains bytes after the decoded item. */
+export class TrailingBytesError extends Errors.BaseError {
+  override readonly name = 'Rlp.TrailingBytesError'
+
+  constructor({ count }: { count: number }) {
+    super(
+      `RLP payload encodes a single item, but \`${count}\` trailing ${
+        count === 1 ? 'byte remains' : 'bytes remain'
+      }.`,
+    )
+  }
+}

package/src/core/RpcSchema.ts

@@ -331,7 +331,7 @@ export type Schema = Generic | FromZod.Namespace
 
 /**
  * Resolves a {@link ox#RpcSchema.Schema} input to an Ox {@link ox#RpcSchema.Generic}.
- * A Zod namespace is converted via {@link ox#RpcSchema.FromZod}; a `Generic` is
+ * A Zod namespace is converted via {@link ox#RpcSchema.(FromZod:type)}; a `Generic` is
  * passed through; otherwise falls back to {@link ox#RpcSchema.Default}.
  */
 export type ToGeneric<schema extends Schema | undefined> =

package/src/core/Siwe.ts

@@ -32,7 +32,7 @@ export type Message = {
   /**
    * The [EIP-155](https://eips.ethereum.org/EIPS/eip-155) Chain ID to which the session is bound,
    */
-  chainId: bigint
+  chainId: number
   /**
    * [RFC 3986](https://www.rfc-editor.org/rfc/rfc3986) authority that is requesting the signing.
    */
@@ -88,7 +88,7 @@ export type Message = {
  *
  * Siwe.createMessage({
  *   address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
- *   chainId: 1n,
+ *   chainId: 1,
  *   domain: 'example.com',
  *   nonce: 'foobarbaz',
  *   uri: 'https://example.com/path',
@@ -126,7 +126,7 @@ export function createMessage(value: Message): string {
   // Validate fields
   {
     // Required fields
-    if (typeof chainId !== 'bigint' || chainId < 0n)
+    if (!Number.isInteger(chainId) || chainId < 0)
       throw new InvalidMessageFieldError({
         field: 'chainId',
         metaMessages: [
@@ -351,7 +351,7 @@ function splitUri(value: string) {
  * Issued At: 2023-02-01T00:00:00.000Z`)
  * // @log: {
  * // @log:   address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
- * // @log:   chainId: 1n,
+ * // @log:   chainId: 1,
  * // @log:   domain: 'example.com',
  * // @log:   issuedAt: '2023-02-01T00:00:00.000Z',
  * // @log:   nonce: 'foobarbaz',
@@ -387,7 +387,7 @@ export function parseMessage(message: string): ExactPartial<Message> {
   return {
     ...prefix,
     ...suffix,
-    ...(chainId ? { chainId: BigInt(chainId) } : {}),
+    ...(chainId ? { chainId: Number(chainId) } : {}),
     ...(expirationTime ? { expirationTime: new Date(expirationTime) } : {}),
     ...(issuedAt ? { issuedAt: new Date(issuedAt) } : {}),
     ...(notBefore ? { notBefore: new Date(notBefore) } : {}),
@@ -410,7 +410,7 @@ export function parseMessage(message: string): ExactPartial<Message> {
  *   domain: 'example.com',
  *   message: {
  *     address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
- *     chainId: 1n,
+ *     chainId: 1,
  *     domain: 'example.com',
  *     nonce: 'foobarbaz',
  *     uri: 'https://example.com/path',

package/src/core/_test/AbiParameters.decode.test.ts

@@ -443,6 +443,19 @@ describe('dynamic', () => {
       expect(result).toEqual([''])
     })
 
+    test('leading NUL byte', () => {
+      const result = AbiParameters.decode(
+        AbiParameters.from('string'),
+        '0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000030061620000000000000000000000000000000000000000000000000000000000',
+      )
+      assertType<readonly [string]>(result)
+      expect(result).toMatchInlineSnapshot(`
+        [
+          "\u0000ab",
+        ]
+      `)
+    })
+
     test('default', () => {
       expect(
         AbiParameters.decode(
@@ -1601,22 +1614,12 @@ test('zst', () => {
   expect(() =>
     AbiParameters.decode([{ type: 'uint256[0][4294967295]' }], payload),
   ).toThrowErrorMatchingInlineSnapshot(
-    `
-    [AbiParameters.DataSizeTooSmallError: Data size of 64 bytes is too small for given parameters.
-
-    Params: (uint256[0][4294967295])
-    Data:   0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000FFFFFFFF (64 bytes)]
-  `,
+    '[Cursor.RecursiveReadLimitExceededError: Recursive read limit of `8192` exceeded (recursive read count: `8193`).]',
   )
   expect(() =>
     AbiParameters.decode([{ type: 'uint32[0][4294967295]' }], payload),
   ).toThrowErrorMatchingInlineSnapshot(
-    `
-    [AbiParameters.DataSizeTooSmallError: Data size of 64 bytes is too small for given parameters.
-
-    Params: (uint32[0][4294967295])
-    Data:   0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000FFFFFFFF (64 bytes)]
-  `,
+    '[Cursor.RecursiveReadLimitExceededError: Recursive read limit of `8192` exceeded (recursive read count: `8193`).]',
   )
   expect(() =>
     AbiParameters.decode(
@@ -1798,3 +1801,89 @@ test('recursive 2', () => {
     '[Cursor.RecursiveReadLimitExceededError: Recursive read limit of `8192` exceeded (recursive read count: `8193`).]',
   )
 })
+
+describe('zero-width types', () => {
+  test('zero-length fixed array', () => {
+    expect(
+      AbiParameters.decode(
+        [{ type: 'uint256[0]' }, { type: 'uint256' }],
+        '0x0000000000000000000000000000000000000000000000000000000000000003',
+      ),
+    ).toEqual([[], 3n])
+  })
+
+  test('trailing empty tuple', () => {
+    expect(
+      AbiParameters.decode(
+        [{ type: 'uint256' }, { type: 'tuple', components: [] }],
+        '0x0000000000000000000000000000000000000000000000000000000000000005',
+      ),
+    ).toEqual([5n, []])
+  })
+
+  test('zero-length fixed array of dynamic type', () => {
+    expect(
+      AbiParameters.decode(
+        [{ type: 'string[0]' }, { type: 'uint256' }],
+        '0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000003',
+      ),
+    ).toEqual([[], 3n])
+  })
+
+  test('standalone zero-length fixed array of dynamic type', () => {
+    // The head is a single offset word pointing at an empty tail.
+    expect(
+      AbiParameters.decode(
+        [{ type: 'string[0]' }],
+        '0x0000000000000000000000000000000000000000000000000000000000000020',
+      ),
+    ).toEqual([[]])
+    expect(
+      AbiParameters.decode(
+        [{ type: 'bytes[0]' }],
+        '0x0000000000000000000000000000000000000000000000000000000000000020',
+      ),
+    ).toEqual([[]])
+  })
+
+  test('round-trip', () => {
+    const cases = [
+      {
+        parameters: [{ type: 'uint256[0]' }, { type: 'uint256' }],
+        values: [[], 3n],
+      },
+      {
+        parameters: [{ type: 'uint256' }, { type: 'tuple', components: [] }],
+        values: [5n, []],
+      },
+      {
+        parameters: [{ type: 'string[0]' }, { type: 'uint256' }],
+        values: [[], 3n],
+      },
+      {
+        parameters: [{ type: 'uint256[0]' }, { type: 'string' }],
+        values: [[], 'hello'],
+      },
+      {
+        parameters: [{ type: 'uint256[0][2]' }, { type: 'uint256' }],
+        values: [[[], []], 9n],
+      },
+      {
+        parameters: [{ type: 'string[0]' }],
+        values: [[]],
+      },
+      {
+        parameters: [{ type: 'tuple', components: [{ type: 'string[0]' }] }],
+        values: [[[]]],
+      },
+    ] as const
+    for (const { parameters, values } of cases) {
+      expect(
+        AbiParameters.decode(
+          parameters,
+          AbiParameters.encode(parameters, values as never),
+        ),
+      ).toEqual(values)
+    }
+  })
+})

package/src/core/_test/AbiParameters.encode.test.ts

@@ -1963,3 +1963,71 @@ test('https://github.com/wevm/viem/issues/1960', () => {
     `[BaseError: Invalid boolean value: "true" (type: string). Expected: \`true\` or \`false\`.]`,
   )
 })
+
+describe('zero-width types', () => {
+  // Per the ABI spec, `enc(T[0])` and `enc(())` are zero-length: a zero-length
+  // fixed array or empty tuple contributes no bytes. Expected values verified
+  // against ethers `AbiCoder.defaultAbiCoder()`.
+  test('zero-length fixed array', () => {
+    expect(
+      AbiParameters.encode(
+        [{ type: 'uint256[0]' }, { type: 'uint256' }],
+        [[], 3n],
+      ),
+    ).toBe('0x0000000000000000000000000000000000000000000000000000000000000003')
+  })
+
+  test('empty tuple', () => {
+    expect(
+      AbiParameters.encode(
+        [{ type: 'uint256' }, { type: 'tuple', components: [] }],
+        [5n, []],
+      ),
+    ).toBe('0x0000000000000000000000000000000000000000000000000000000000000005')
+  })
+
+  test('empty tuple only', () => {
+    expect(
+      AbiParameters.encode([{ type: 'tuple', components: [] }], [[]]),
+    ).toBe('0x')
+  })
+
+  test('nested zero-length fixed arrays', () => {
+    expect(
+      AbiParameters.encode(
+        [{ type: 'uint256[0][2]' }, { type: 'uint256' }],
+        [[[], []], 9n],
+      ),
+    ).toBe('0x0000000000000000000000000000000000000000000000000000000000000009')
+    expect(
+      AbiParameters.encode(
+        [{ type: 'uint256[2][0]' }, { type: 'uint256' }],
+        [[], 9n],
+      ),
+    ).toBe('0x0000000000000000000000000000000000000000000000000000000000000009')
+  })
+
+  test('offsets skip zero-width parameters', () => {
+    expect(
+      AbiParameters.encode(
+        [{ type: 'uint256[0]' }, { type: 'string' }],
+        [[], 'hello'],
+      ),
+    ).toBe(
+      '0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000568656c6c6f000000000000000000000000000000000000000000000000000000',
+    )
+  })
+
+  // `T[0]` of a dynamic `T` is dynamic per the ABI spec: 32-byte offset
+  // pointing at a zero-length tail.
+  test('zero-length fixed array of dynamic type', () => {
+    expect(
+      AbiParameters.encode(
+        [{ type: 'string[0]' }, { type: 'uint256' }],
+        [[], 3n],
+      ),
+    ).toBe(
+      '0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000003',
+    )
+  })
+})

package/src/core/_test/Rlp.test.ts

@@ -13,6 +13,9 @@ test('exports', () => {
       "from",
       "fromBytes",
       "fromHex",
+      "DepthLimitExceededError",
+      "ListBoundaryExceededError",
+      "TrailingBytesError",
     ]
   `)
 })
@@ -337,3 +340,101 @@ describe('Rlp.to', () => {
     )
   })
 })
+
+describe('decode depth limit', () => {
+  // Builds an RLP-encoded value of `depth` nested empty lists without recursing
+  // (so we can exceed the decoder's depth limit without overflowing the encoder).
+  const nestedEmptyLists = (depth: number) => {
+    let bytes = Uint8Array.from([0xc0])
+    for (let i = 0; i < depth; i++) {
+      const length = bytes.length
+      const prefix =
+        length <= 55
+          ? [0xc0 + length]
+          : (() => {
+              const lengthBytes: number[] = []
+              let n = length
+              while (n > 0) {
+                lengthBytes.unshift(n & 0xff)
+                n >>= 8
+              }
+              return [0xf7 + lengthBytes.length, ...lengthBytes]
+            })()
+      const next = new Uint8Array(prefix.length + bytes.length)
+      next.set(prefix, 0)
+      next.set(bytes, prefix.length)
+      bytes = next
+    }
+    return bytes
+  }
+
+  test('decodes up to the depth limit', () => {
+    expect(() => Rlp.toBytes(nestedEmptyLists(1_023))).not.toThrow()
+  })
+
+  test('throws when the depth limit is exceeded', () => {
+    expect(() =>
+      Rlp.toBytes(nestedEmptyLists(2_000)),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Rlp.DepthLimitExceededError: RLP depth limit of \`1024\` exceeded.]`,
+    )
+  })
+})
+
+describe('trailing bytes', () => {
+  // RLP payloads encode exactly one item (Yellow Paper, Appendix B).
+  test('after string item', () => {
+    expect(() => Rlp.toHex('0x80deadbeef')).toThrowErrorMatchingInlineSnapshot(
+      `[Rlp.TrailingBytesError: RLP payload encodes a single item, but \`4\` trailing bytes remain.]`,
+    )
+  })
+
+  test('after list item', () => {
+    expect(() => Rlp.toHex('0xc2010203')).toThrowErrorMatchingInlineSnapshot(
+      `[Rlp.TrailingBytesError: RLP payload encodes a single item, but \`1\` trailing byte remains.]`,
+    )
+  })
+
+  test('after empty list', () => {
+    expect(() => Rlp.toHex('0xc000')).toThrowErrorMatchingInlineSnapshot(
+      `[Rlp.TrailingBytesError: RLP payload encodes a single item, but \`1\` trailing byte remains.]`,
+    )
+  })
+
+  test('bytes input', () => {
+    expect(() =>
+      Rlp.toHex(Uint8Array.from([0x80, 0xde, 0xad])),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Rlp.TrailingBytesError: RLP payload encodes a single item, but \`2\` trailing bytes remain.]`,
+    )
+  })
+
+  test('valid single items still decode', () => {
+    expect(Rlp.toHex('0x80')).toEqual('0x')
+    expect(Rlp.toHex('0xc0')).toEqual([])
+    expect(Rlp.toHex('0xc1c0')).toEqual([[]])
+    expect(Rlp.toHex('0x83646f67')).toEqual('0x646f67')
+  })
+})
+
+describe('list boundary', () => {
+  // Items must consume exactly the declared list length.
+  test('item extends beyond list', () => {
+    // `0xc1` declares 1 payload byte; `0x82aabb` consumes 3.
+    expect(() => Rlp.toHex('0xc182aabb')).toThrowErrorMatchingInlineSnapshot(
+      `[Rlp.ListBoundaryExceededError: RLP list items consumed \`3\` bytes but the list declared a length of \`1\`.]`,
+    )
+  })
+
+  test('item extends beyond nested list', () => {
+    expect(() => Rlp.toHex('0xc3c182aabb')).toThrowErrorMatchingInlineSnapshot(
+      `[Rlp.ListBoundaryExceededError: RLP list items consumed \`3\` bytes but the list declared a length of \`1\`.]`,
+    )
+  })
+
+  test('item extends beyond list with trailing bytes', () => {
+    expect(() => Rlp.toHex('0xc182aabbff')).toThrowErrorMatchingInlineSnapshot(
+      `[Rlp.ListBoundaryExceededError: RLP list items consumed \`3\` bytes but the list declared a length of \`1\`.]`,
+    )
+  })
+})