ox 1.0.0-beta.9 → 1.0.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "ox",
   "description": "Ethereum Standard Library",
   "type": "module",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.0",
   "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/_test/AbiParameters.decode.test.ts

@@ -1601,22 +1601,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 +1788,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\`.]`,
+    )
+  })
+})

package/src/core/internal/abiParameters.ts

@@ -150,7 +150,8 @@ export function decodeArray(
 
   // If the length of the array is not known in advance (dynamic array),
   // this means we will need to wonder off to the pointer and decode.
-  if (!length) {
+  // Note: zero-length fixed arrays (`T[0]`) are not dynamic.
+  if (length === null) {
     // Dealing with a dynamic type, so get the offset of the array data.
     const offset = Bytes.toNumber(cursor.readBytes(sizeOfOffset))
 
@@ -177,6 +178,12 @@ export function decodeArray(
       })
       consumed += consumed_
       value.push(data)
+      // Charge zero-width elements against the read limit to bound work
+      // on huge lengths of zero-width types (e.g. `uint256[0][]`).
+      if (consumed_ === 0) {
+        cursor.assertReadLimit()
+        cursor._touch()
+      }
     }
 
     // As we have gone wondering, restore to the original position + next slot.
@@ -206,7 +213,10 @@ export function decodeArray(
     }
 
     // As we have gone wondering, restore to the original position + next slot.
-    cursor.setPosition(staticPosition + 32)
+    // Zero-length arrays of dynamic types (e.g. `string[0]`) have no tail, so
+    // the next slot may sit past the end of the data.
+    if (staticPosition + 32 < cursor.bytes.length)
+      cursor.setPosition(staticPosition + 32)
     return [value, 32]
   }
 
@@ -221,6 +231,12 @@ export function decodeArray(
     })
     consumed += consumed_
     value.push(data)
+    // Charge zero-width elements against the read limit to bound work
+    // on huge lengths of zero-width types (e.g. `uint256[0][4294967295]`).
+    if (consumed_ === 0) {
+      cursor.assertReadLimit()
+      cursor._touch()
+    }
   }
   return [value, consumed]
 }
@@ -593,7 +609,9 @@ export function encodeArray<const parameter extends AbiParameters.Parameter>(
       type: `${parameter.type}[${length}]`,
     })
 
-  let dynamicChild = false
+  // Zero-length fixed arrays of dynamic types (e.g. `string[0]`) are dynamic
+  // per the ABI spec, even though they have no elements to inspect.
+  let dynamicChild = value.length === 0 && hasDynamicChild(parameter)
   const preparedParameters: PreparedParameter[] = []
   for (let i = 0; i < value.length; i++) {
     const preparedParam = prepareParameter({

package/src/core/internal/rpcSchemas/eth.ts

@@ -218,6 +218,26 @@ export type Eth = RpcSchema.From<
       }
       ReturnType: Fee.FeeHistoryRpc
     }
+  /**
+   * Fills the defaults (nonce, gas, gasPrice, or 1559 fields) on a given unsigned transaction, and returns the unsigned transaction along with its raw form
+   *
+   * @example
+   * ```
+   * request({ method: 'eth_fillTransaction', params: [{ from: '0x...', to: '0x...', value: '0x...' }] })
+   * // { raw: '0x...', tx: { ... } }
+   * ```
+   */
+  | {
+      Request: {
+        method: 'eth_fillTransaction'
+        params: [transaction: TransactionRequest.Rpc]
+      }
+      ReturnType: {
+        capabilities?: Record<string, unknown> | undefined
+        raw: Hex.Hex
+        tx: Transaction.Rpc
+      }
+    }
   /**
    * Returns the current price of gas expressed in wei
    *
@@ -425,6 +445,22 @@ export type Eth = RpcSchema.From<
       }
       ReturnType: AccountProof.Rpc
     }
+  /**
+   * Returns the raw, serialized transaction specified by hash
+   *
+   * @example
+   * ```
+   * request({ method: 'eth_getRawTransactionByHash', params: ['0x...'] })
+   * // '0x...'
+   * ```
+   */
+  | {
+      Request: {
+        method: 'eth_getRawTransactionByHash'
+        params: [hash: Hex.Hex]
+      }
+      ReturnType: Hex.Hex | null
+    }
   /**
    * Returns the value from a storage position at an address
    *