viem 2.54.1 → 2.54.3

package/utils/abi/encodeAbiParameters.ts

@@ -26,7 +26,7 @@ import { IntegerOutOfRangeError } from '../../errors/encoding.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type { Hex } from '../../types/misc.js'
 import { type IsAddressErrorType, isAddress } from '../address/isAddress.js'
-import { type ConcatErrorType, concat } from '../data/concat.js'
+import { type ConcatHexErrorType, concatHex } from '../data/concat.js'
 import { type PadHexErrorType, padHex } from '../data/pad.js'
 import { type SizeErrorType, size } from '../data/size.js'
 import { type SliceErrorType, slice } from '../data/slice.js'
@@ -101,9 +101,7 @@ export function encodeAbiParameters<
     params: params as readonly AbiParameter[],
     values: values as any,
   })
-  const data = encodeParams(preparedParams)
-  if (data.length === 0) return '0x'
-  return data
+  return encodeParams(preparedParams)
 }
 
 /////////////////////////////////////////////////////////////////
@@ -212,7 +210,8 @@ function encodeParams(preparedParams: PreparedParam[]): Hex {
   }
 
   // 3. Concatenate static and dynamic parts.
-  return concat([...staticParams, ...dynamicParams])
+  // `concatHex` returns `'0x'` for empty input (zero-width parameters).
+  return concatHex([...staticParams, ...dynamicParams])
 }
 
 /////////////////////////////////////////////////////////////////
@@ -229,7 +228,7 @@ function encodeAddress(value: Hex): PreparedParam {
 
 type EncodeArrayErrorType =
   | AbiEncodingArrayLengthMismatchErrorType
-  | ConcatErrorType
+  | ConcatHexErrorType
   | EncodeParamsErrorType
   | InvalidArrayErrorType
   | NumberToHexErrorType
@@ -257,7 +256,9 @@ function encodeArray<const param extends AbiParameter>(
       type: `${param.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 && isDynamicType(param)
   const preparedParams: PreparedParam[] = []
   for (let i = 0; i < value.length; i++) {
     const preparedParam = prepareParam({ param, value: value[i] })
@@ -271,20 +272,20 @@ function encodeArray<const param extends AbiParameter>(
       const length = numberToHex(preparedParams.length, { size: 32 })
       return {
         dynamic: true,
-        encoded: preparedParams.length > 0 ? concat([length, data]) : length,
+        encoded: concatHex([length, data]),
       }
     }
     if (dynamicChild) return { dynamic: true, encoded: data }
   }
   return {
     dynamic: false,
-    encoded: concat(preparedParams.map(({ encoded }) => encoded)),
+    encoded: concatHex(preparedParams.map(({ encoded }) => encoded)),
   }
 }
 
 type EncodeBytesErrorType =
   | AbiEncodingBytesSizeMismatchErrorType
-  | ConcatErrorType
+  | ConcatHexErrorType
   | PadHexErrorType
   | NumberToHexErrorType
   | SizeErrorType
@@ -307,7 +308,10 @@ function encodeBytes<const param extends AbiParameter>(
       })
     return {
       dynamic: true,
-      encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_]),
+      encoded: concatHex([
+        padHex(numberToHex(bytesSize, { size: 32 })),
+        value_,
+      ]),
     }
   }
   if (bytesSize !== Number.parseInt(paramSize, 10))
@@ -356,7 +360,7 @@ function encodeNumber(
 }
 
 type EncodeStringErrorType =
-  | ConcatErrorType
+  | ConcatHexErrorType
   | NumberToHexErrorType
   | PadHexErrorType
   | SizeErrorType
@@ -377,7 +381,7 @@ function encodeString(value: string): PreparedParam {
   }
   return {
     dynamic: true,
-    encoded: concat([
+    encoded: concatHex([
       padHex(numberToHex(size(hexValue), { size: 32 })),
       ...parts,
     ]),
@@ -385,7 +389,7 @@ function encodeString(value: string): PreparedParam {
 }
 
 type EncodeTupleErrorType =
-  | ConcatErrorType
+  | ConcatHexErrorType
   | EncodeParamsErrorType
   // TODO: Add back once circular type reference is resolved
   // | PrepareParamErrorType
@@ -413,7 +417,7 @@ function encodeTuple<
     dynamic,
     encoded: dynamic
       ? encodeParams(preparedParams)
-      : concat(preparedParams.map(({ encoded }) => encoded)),
+      : concatHex(preparedParams.map(({ encoded }) => encoded)),
   }
 }
 
@@ -428,3 +432,16 @@ export function getArrayComponents(
       [matches[2] ? Number(matches[2]) : null, matches[1]]
     : undefined
 }
+
+function isDynamicType(param: AbiParameter): boolean {
+  const { type } = param
+  if (type === 'string') return true
+  if (type === 'bytes') return true
+  if (type.endsWith('[]')) return true
+  if (type === 'tuple')
+    return (param as TupleAbiParameter).components.some(isDynamicType)
+  const arrayComponents = getArrayComponents(type)
+  if (arrayComponents)
+    return isDynamicType({ ...param, type: arrayComponents[1] })
+  return false
+}

package/utils/encoding/fromRlp.ts

@@ -4,6 +4,10 @@ import {
   type InvalidHexValueErrorType,
   RlpDepthLimitExceededError,
   type RlpDepthLimitExceededErrorType,
+  RlpListBoundaryExceededError,
+  type RlpListBoundaryExceededErrorType,
+  RlpTrailingBytesError,
+  type RlpTrailingBytesErrorType,
 } from '../../errors/encoding.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
@@ -31,6 +35,7 @@ export type FromRlpErrorType =
   | HexToBytesErrorType
   | InvalidHexValueErrorType
   | RlpDepthLimitExceededErrorType
+  | RlpTrailingBytesErrorType
   | ErrorType
 
 export function fromRlp<to extends To = 'hex'>(
@@ -51,6 +56,12 @@ export function fromRlp<to extends To = 'hex'>(
   })
   const result = fromRlpCursor(cursor, to)
 
+  // RLP payloads encode exactly one item (Yellow Paper, Appendix B).
+  if (cursor.position < cursor.bytes.length)
+    throw new RlpTrailingBytesError({
+      count: cursor.bytes.length - cursor.position,
+    })
+
   return result as FromRlpReturnType<to>
 }
 
@@ -105,7 +116,7 @@ function readLength(cursor: Cursor, prefix: number, offset: number) {
   throw new BaseError('Invalid RLP prefix')
 }
 
-type ReadListErrorType = ErrorType
+type ReadListErrorType = RlpListBoundaryExceededErrorType | ErrorType
 
 function readList<to extends To>(
   cursor: Cursor,
@@ -117,5 +128,11 @@ function readList<to extends To>(
   const value: FromRlpReturnType<to>[] = []
   while (cursor.position - position < length)
     value.push(fromRlpCursor(cursor, to, recursiveDepth))
+  // Items must consume exactly the declared list length.
+  if (cursor.position - position !== length)
+    throw new RlpListBoundaryExceededError({
+      consumed: cursor.position - position,
+      declared: length,
+    })
   return value
 }