Allow empty blobs and commitments

specs/eip4844/polynomial-commitments.md

@@ -41,7 +41,6 @@
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 <!-- /TOC -->
 
-
 ## Introduction
 
 This document specifies basic polynomial operations and KZG polynomial commitment operations as they are needed for the EIP-4844 specification. The implementations are not optimized for performance, but readability. All practical implementations should optimize the polynomial operations.
@@ -167,7 +166,8 @@ def blob_to_polynomial(blob: Blob) -> Polynomial:
 
 ```python
 def hash_to_bls_field(polys: Sequence[Polynomial],
-                      comms: Sequence[KZGCommitment]) -> BLSFieldElement:
+                      comms: Sequence[KZGCommitment],
+                      challenge_index: int) -> BLSFieldElement:
     """
     Compute 32-byte hash of serialized polynomials and commitments concatenated.
     This hash is then converted to a BLS field element, where the result is not uniform over the BLS field.
@@ -187,6 +187,10 @@ def hash_to_bls_field(polys: Sequence[Polynomial],
     for commitment in comms:
         data += commitment
 
+    # Append challenge index last so we can cache the data buffer
+    # in the case of multiple challenges
+    data += int.to_bytes(challenge_index, 1, ENDIANNESS)
+
     return bytes_to_bls_field(hash(data))
 ```
 
@@ -234,7 +238,8 @@ def poly_lincomb(polys: Sequence[Polynomial],
     Given a list of ``polynomials``, interpret it as a 2D matrix and compute the linear combination
     of each column with `scalars`: return the resulting polynomials.
     """
-    result = [0] * len(polys[0])
+    assert len(polys) == len(scalars)
+    result = [0] * FIELD_ELEMENTS_PER_BLOB
     for v, s in zip(polys, scalars):
         for i, x in enumerate(v):
             result[i] = (result[i] + int(s) * int(x)) % BLS_MODULUS
@@ -256,6 +261,7 @@ def compute_powers(x: BLSFieldElement, n: uint64) -> Sequence[BLSFieldElement]:
     return powers
 ```
 
+
 ### Polynomials
 
 #### `evaluate_polynomial_in_evaluation_form`
@@ -367,14 +373,17 @@ def compute_aggregated_poly_and_commitment(
     """
     Return (1) the aggregated polynomial, (2) the aggregated KZG commitment,
     and (3) the polynomial evaluation random challenge.
+    This function should also work with blobs == [] and kzg_commitments == []
     """
+    assert len(blobs) == len(kzg_commitments)
+
     # Convert blobs to polynomials
     polynomials = [blob_to_polynomial(blob) for blob in blobs]
 
-    # Generate random linear combination challenges
-    r = hash_to_bls_field(polynomials, kzg_commitments)
+    # Generate random linear combination and evaluation challenges
+    r = hash_to_bls_field(polynomials, kzg_commitments, 0)
     r_powers = compute_powers(r, len(kzg_commitments))
-    evaluation_challenge = int(r_powers[-1]) * r % BLS_MODULUS
+    evaluation_challenge = hash_to_bls_field(polynomials, kzg_commitments, 1)
 
     # Create aggregated polynomial in evaluation form
     aggregated_poly = Polynomial(poly_lincomb(polynomials, r_powers))
@@ -390,6 +399,7 @@ def compute_aggregated_poly_and_commitment(
 ```python
 def compute_aggregate_kzg_proof(blobs: Sequence[Blob]) -> KZGProof:
     """
+    Given a list of blobs, return the aggregated KZG proof that is used to verify them against their commitments.
     Public method.
     """
     commitments = [blob_to_kzg_commitment(blob) for blob in blobs]
@@ -407,6 +417,8 @@ def verify_aggregate_kzg_proof(blobs: Sequence[Blob],
                                expected_kzg_commitments: Sequence[KZGCommitment],
                                kzg_aggregated_proof: KZGProof) -> bool:
     """
+    Given a list of blobs and an aggregated KZG proof, verify that they correspond to the provided commitments.
+
     Public method.
     """
     aggregated_poly, aggregated_poly_commitment, evaluation_challenge = compute_aggregated_poly_and_commitment(

tests/core/pyspec/eth2spec/test/eip4844/unittests/validator/test_validator.py

@@ -25,6 +25,12 @@ def _run_validate_blobs_sidecar_test(spec, state, blob_count):
     spec.validate_blobs_sidecar(block.slot, block.hash_tree_root(), expected_commitments, blobs_sidecar)
 
 
+@with_eip4844_and_later
+@spec_state_test
+def test_validate_blobs_sidecar_zero_blobs(spec, state):
+    _run_validate_blobs_sidecar_test(spec, state, blob_count=0)
+
+
 @with_eip4844_and_later
 @spec_state_test
 def test_validate_blobs_sidecar_one_blob(spec, state):