status-im/eth2.0-specs
2
0
Fork 0
mirror of https://github.com/status-im/eth2.0-specs.git synced 2025-03-01 18:50:35 +00:00
Code Issues Projects Releases Wiki Activity

In batch cell verification, take commitment for each cell (#3834)

Browse Source
This commit is contained in:
Justin Traglia 2024-07-10 10:41:37 -05:00 committed by GitHub
parent 5cce790dec
commit 9a9fa965b0
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
5 changed files with 106 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
specs/_features/eip7594/p2p-interface.md
View File

@ -68,19 +68,17 @@ class DataColumnIdentifier(Container):
```python
def verify_data_column_sidecar_kzg_proofs(sidecar: DataColumnSidecar) -> bool:
"""
Verify if the proofs are correct
Verify if the proofs are correct.
"""
assert sidecar.index < NUMBER_OF_COLUMNS
assert len(sidecar.column) == len(sidecar.kzg_commitments) == len(sidecar.kzg_proofs)
row_indices = [RowIndex(i) for i in range(len(sidecar.column))]
column_indices = [sidecar.index] * len(sidecar.column)
# KZG batch verifies that the cells match the corresponding commitments and proofs
return verify_cell_kzg_proof_batch(
row_commitments_bytes=sidecar.kzg_commitments,
row_indices=row_indices, # all rows
column_indices=column_indices, # specific column
commitments_bytes=sidecar.kzg_commitments,
column_indices=column_indices,
cells=sidecar.column,
proofs_bytes=sidecar.kzg_proofs,
)

39
specs/_features/eip7594/polynomial-commitments-sampling.md
View File

@ -481,12 +481,18 @@ def verify_cell_kzg_proof_batch_impl(row_commitments: Sequence[KZGCommitment],
cosets_evals: Sequence[CosetEvals],
proofs: Sequence[KZGProof]) -> bool:
"""
Verify a set of cells, given their corresponding proofs and their coordinates (row_index, column_index) in the blob
matrix. The i-th cell is in row row_indices[i] and in column column_indices[i].
The list of all commitments is provided in row_commitments_bytes.
Helper: Verify that a set of cells belong to their corresponding commitment.
This function is the internal implementation of verify_cell_kzg_proof_batch.
Given a list of ``row_commitments`` and four lists representing tuples of (``row_index``,
``column_index``, ``evals``, ``proof``), the function verifies ``proof`` which shows that
``evals`` are the evaluations of the polynomial associated with ``row_commitments[row_index]``,
evaluated over the domain specified by ``column_index``.
This function is the internal implementation of ``verify_cell_kzg_proof_batch``.
"""
assert len(row_indices) == len(column_indices) == len(cosets_evals) == len(proofs)
for row_index in row_indices:
assert row_index < len(row_commitments)
# The verification equation that we will check is pairing (LL, LR) = pairing (RL, [1]), where
# LL = sum_k r^k proofs[k],
@ -670,15 +676,16 @@ def verify_cell_kzg_proof(commitment_bytes: Bytes48,
#### `verify_cell_kzg_proof_batch`
```python
def verify_cell_kzg_proof_batch(row_commitments_bytes: Sequence[Bytes48],
row_indices: Sequence[RowIndex],
def verify_cell_kzg_proof_batch(commitments_bytes: Sequence[Bytes48],
column_indices: Sequence[ColumnIndex],
cells: Sequence[Cell],
proofs_bytes: Sequence[Bytes48]) -> bool:
"""
Verify a set of cells, given their corresponding proofs and their coordinates (row_index, column_index) in the blob
matrix. The i-th cell is in row = row_indices[i] and in column = column_indices[i].
The list of all commitments is provided in row_commitments_bytes.
Verify that a set of cells belong to their corresponding commitments.
Given four lists representing tuples of (``commitment``, ``column_index``, ``cell``, ``proof``),
the function verifies ``proof`` which shows that ``cell`` are the evaluations of the polynomial
associated with ``commitment``, evaluated over the domain specified by ``column_index``.
This function implements the universal verification equation that has been introduced here:
https://ethresear.ch/t/a-universal-verification-equation-for-data-availability-sampling/13240
@ -686,11 +693,9 @@ def verify_cell_kzg_proof_batch(row_commitments_bytes: Sequence[Bytes48],
Public method.
"""
assert len(cells) == len(proofs_bytes) == len(row_indices) == len(column_indices)
for commitment_bytes in row_commitments_bytes:
assert len(commitments_bytes) == len(cells) == len(proofs_bytes) == len(column_indices)
for commitment_bytes in commitments_bytes:
assert len(commitment_bytes) == BYTES_PER_COMMITMENT
for row_index in row_indices:
assert row_index < len(row_commitments_bytes)
for column_index in column_indices:
assert column_index < CELLS_PER_EXT_BLOB
for cell in cells:
@ -698,8 +703,12 @@ def verify_cell_kzg_proof_batch(row_commitments_bytes: Sequence[Bytes48],
for proof_bytes in proofs_bytes:
assert len(proof_bytes) == BYTES_PER_PROOF
# Get objects from bytes
row_commitments = [bytes_to_kzg_commitment(commitment_bytes) for commitment_bytes in row_commitments_bytes]
# Create the list of unique commitments we are dealing with
deduplicated_commitments = list(set(commitments_bytes))
row_commitments = [bytes_to_kzg_commitment(commitment_bytes) for commitment_bytes in deduplicated_commitments]
# Create indices list mapping initial commitments (that potentially contains duplicates) to the unique commitments.
row_indices = [deduplicated_commitments.index(commitment_bytes) for commitment_bytes in commitments_bytes]
cosets_evals = [cell_to_coset_evals(cell) for cell in cells]
proofs = [bytes_to_kzg_proof(proof_bytes) for proof_bytes in proofs_bytes]

17
tests/core/pyspec/eth2spec/test/eip7594/unittests/polynomial_commitments/test_polynomial_commitments.py
View File

@ -128,8 +128,7 @@ def test_verify_cell_kzg_proof(spec):
def test_verify_cell_kzg_proof_batch_zero_cells(spec):
# Verify with zero cells should return true
assert spec.verify_cell_kzg_proof_batch(
row_commitments_bytes=[],
row_indices=[],
commitments_bytes=[],
column_indices=[],
cells=[],
proofs_bytes=[],
@ -149,8 +148,7 @@ def test_verify_cell_kzg_proof_batch(spec):
assert len(cells) == len(proofs)
assert spec.verify_cell_kzg_proof_batch(
row_commitments_bytes=[commitment],
row_indices=[0, 0],
commitments_bytes=[commitment, commitment],
column_indices=[0, 4],
cells=[cells[0], cells[4]],
proofs_bytes=[proofs[0], proofs[4]],
@ -178,11 +176,11 @@ def test_verify_cell_kzg_proof_batch(spec):
column_indices = [0, 4, 0, 1, 2]
cells = [all_cells[i][j] for (i, j) in zip(row_indices, column_indices)]
proofs = [all_proofs[i][j] for (i, j) in zip(row_indices, column_indices)]
commitments = [all_commitments[i] for i in row_indices]
# do the check
assert spec.verify_cell_kzg_proof_batch(
row_commitments_bytes=all_commitments,
row_indices=row_indices,
commitments_bytes=commitments,
column_indices=column_indices,
cells=cells,
proofs_bytes=proofs,
@ -202,8 +200,7 @@ def test_verify_cell_kzg_proof_batch_invalid(spec):
assert len(cells) == len(proofs)
assert not spec.verify_cell_kzg_proof_batch(
row_commitments_bytes=[commitment],
row_indices=[0, 0],
commitments_bytes=[commitment, commitment],
column_indices=[0, 4],
cells=[cells[0], cells[5]], # Note: this is where it should go wrong
proofs_bytes=[proofs[0], proofs[4]],
@ -231,14 +228,14 @@ def test_verify_cell_kzg_proof_batch_invalid(spec):
column_indices = [0, 4, 0, 1, 2]
cells = [all_cells[i][j] for (i, j) in zip(row_indices, column_indices)]
proofs = [all_proofs[i][j] for (i, j) in zip(row_indices, column_indices)]
commitments = [all_commitments[i] for i in row_indices]
# let's change one of the cells. Then it should not verify
cells[1] = all_cells[1][3]
# do the check
assert not spec.verify_cell_kzg_proof_batch(
row_commitments_bytes=all_commitments,
row_indices=row_indices,
commitments_bytes=commitments,
column_indices=column_indices,
cells=cells,
proofs_bytes=proofs,

8
tests/formats/kzg_7594/verify_cell_kzg_proof_batch.md
View File

@ -1,6 +1,6 @@
# Test format: Verify cell KZG proof batch
Use the cell KZG `proofs` to verify that the KZG `row_commitments` for the given `cells` are correct.
Use the cell KZG `proofs` to verify that the KZG `commitments` for the given `cells` are correct.
## Test case format
@ -8,8 +8,7 @@ The test data is declared in a `data.yaml` file:
```yaml
input:
row_commitments: List[Bytes48] -- the KZG commitments
row_indices: List[RowIndex] -- the commitment index for each cell
commitments: List[Bytes48] -- the KZG commitments for each cell
column_indices: List[ColumnIndex] -- the column index for each cell
cells: List[Cell] -- the cells
proofs: List[Bytes48] -- the KZG proof for each cell
@ -17,7 +16,6 @@ output: bool -- true (all proofs are correct) or false (some proofs incorrect)
```
- `Bytes48` is a 48-byte hexadecimal string, prefixed with `0x`.
- `RowIndex` is an unsigned 64-bit integer.
- `ColumnIndex` is an unsigned 64-bit integer.
- `Cell` is a 2048-byte hexadecimal string, prefixed with `0x`.
@ -25,4 +23,4 @@ All byte(s) fields are encoded as strings, hexadecimal encoding, prefixed with `
## Condition
The `verify_cell_kzg_proof_batch` handler should verify that `row_commitments` are correct KZG commitments to `cells` by using the cell KZG proofs `proofs`, and the result should match the expected `output`. If any of the commitments or proofs are invalid (e.g. not on the curve or not in the G1 subgroup of the BLS curve), any cell is invalid (e.g. incorrect length or one of the 32-byte blocks does not represent a BLS field element), or any `cell_index` is invalid (e.g. greater than the number of cells for an extended blob), it should error, i.e. the output should be `null`.
The `verify_cell_kzg_proof_batch` handler should verify that `commitments` are correct KZG commitments to `cells` by using the cell KZG proofs `proofs`, and the result should match the expected `output`. If any of the commitments or proofs are invalid (e.g. not on the curve or not in the G1 subgroup of the BLS curve), any cell is invalid (e.g. incorrect length or one of the 32-byte blocks does not represent a BLS field element), or any `cell_index` is invalid (e.g. greater than the number of cells for an extended blob), it should error, i.e. the output should be `null`.

228
tests/generators/kzg_7594/main.py
View File

@ -220,15 +220,13 @@ def case_verify_cell_kzg_proof_batch():
# Valid cases
for i in range(len(VALID_BLOBS)):
cells, proofs = VALID_CELLS_AND_PROOFS[i]
row_commitments = [VALID_COMMITMENTS[i]]
row_indices = [0] * spec.CELLS_PER_EXT_BLOB
commitments = [VALID_COMMITMENTS[i] for _ in cells]
column_indices = list(range(spec.CELLS_PER_EXT_BLOB))
assert spec.verify_cell_kzg_proof_batch(row_commitments, row_indices, column_indices, cells, proofs)
identifier = make_id(row_commitments, row_indices, column_indices, cells, proofs)
assert spec.verify_cell_kzg_proof_batch(commitments, column_indices, cells, proofs)
identifier = make_id(commitments, column_indices, cells, proofs)
yield f'verify_cell_kzg_proof_batch_case_valid_{identifier}', {
'input': {
'row_commitments': encode_hex_list(row_commitments),
'row_indices': row_indices,
'commitments': encode_hex_list(commitments),
'column_indices': column_indices,
'cells': encode_hex_list(cells),
'proofs': encode_hex_list(proofs),
@ -237,13 +235,12 @@ def case_verify_cell_kzg_proof_batch():
}
# Valid: zero cells
cells, row_commitments, row_indices, column_indices, proofs = [], [], [], [], []
assert spec.verify_cell_kzg_proof_batch(row_commitments, row_indices, column_indices, cells, proofs)
identifier = make_id(row_commitments, row_indices, column_indices, cells, proofs)
cells, commitments, column_indices, proofs = [], [], [], []
assert spec.verify_cell_kzg_proof_batch(commitments, column_indices, cells, proofs)
identifier = make_id(commitments, column_indices, cells, proofs)
yield f'verify_cell_kzg_proof_batch_case_valid_zero_cells_{identifier}', {
'input': {
'row_commitments': encode_hex_list(row_commitments),
'row_indices': row_indices,
'commitments': encode_hex_list(commitments),
'column_indices': column_indices,
'cells': encode_hex_list(cells),
'proofs': encode_hex_list(proofs),
@ -254,37 +251,15 @@ def case_verify_cell_kzg_proof_batch():
# Valid: Verify cells from multiple blobs
cells0, proofs0 = VALID_CELLS_AND_PROOFS[0]
cells1, proofs1 = VALID_CELLS_AND_PROOFS[1]
row_commitments = VALID_COMMITMENTS[:2]
row_indices = [0, 1]
commitments = [VALID_COMMITMENTS[0], VALID_COMMITMENTS[1]]
column_indices = [0, 0]
cells = [cells0[0], cells1[0]]
proofs = [proofs0[0], proofs1[0]]
assert spec.verify_cell_kzg_proof_batch(row_commitments, row_indices, column_indices, cells, proofs)
identifier = make_id(row_commitments, row_indices, column_indices, cells, proofs)
assert spec.verify_cell_kzg_proof_batch(commitments, column_indices, cells, proofs)
identifier = make_id(commitments, column_indices, cells, proofs)
yield f'verify_cell_kzg_proof_batch_case_valid_multiple_blobs_{identifier}', {
'input': {
'row_commitments': encode_hex_list(row_commitments),
'row_indices': row_indices,
'column_indices': column_indices,
'cells': encode_hex_list(cells),
'proofs': encode_hex_list(proofs),
},
'output': True
}
# Valid: Unused row commitments
cells, proofs = VALID_CELLS_AND_PROOFS[2]
cells, proofs = cells[:3], proofs[:3]
# Provide list of all commitments
row_commitments = VALID_COMMITMENTS
row_indices = [2] * len(cells)
column_indices = list(range(len(cells)))
assert spec.verify_cell_kzg_proof_batch(row_commitments, row_indices, column_indices, cells, proofs)
identifier = make_id(row_commitments, row_indices, column_indices, cells, proofs)
yield f'verify_cell_kzg_proof_batch_case_valid_unused_row_commitments_{identifier}', {
'input': {
'row_commitments': encode_hex_list(row_commitments),
'row_indices': row_indices,
'commitments': encode_hex_list(commitments),
'column_indices': column_indices,
'cells': encode_hex_list(cells),
'proofs': encode_hex_list(proofs),
@ -293,18 +268,16 @@ def case_verify_cell_kzg_proof_batch():
}
# Valid: Same cell multiple times
row_commitments = [VALID_COMMITMENTS[3]]
num_duplicates = 3
row_indices = [0] * num_duplicates
commitments = [VALID_COMMITMENTS[3]] * num_duplicates
column_indices = [0] * num_duplicates
cells = [VALID_CELLS_AND_PROOFS[3][0][0]] * num_duplicates
proofs = [VALID_CELLS_AND_PROOFS[3][1][0]] * num_duplicates
assert spec.verify_cell_kzg_proof_batch(row_commitments, row_indices, column_indices, cells, proofs)
identifier = make_id(row_commitments, row_indices, column_indices, cells, proofs)
assert spec.verify_cell_kzg_proof_batch(commitments, column_indices, cells, proofs)
identifier = make_id(commitments, column_indices, cells, proofs)
yield f'verify_cell_kzg_proof_batch_case_valid_same_cell_multiple_times_{identifier}', {
'input': {
'row_commitments': encode_hex_list(row_commitments),
'row_indices': row_indices,
'commitments': encode_hex_list(commitments),
'column_indices': column_indices,
'cells': encode_hex_list(cells),
'proofs': encode_hex_list(proofs),
@ -312,19 +285,17 @@ def case_verify_cell_kzg_proof_batch():
'output': True
}
# Incorrect row commitment
# Incorrect commitment
cells, proofs = VALID_CELLS_AND_PROOFS[5]
cells, proofs = cells[:1], proofs[:1]
# Change commitment so it's wrong
row_commitments = [bls_add_one(VALID_COMMITMENTS[5])]
row_indices = [0] * len(cells)
# Use the wrong commitment
commitments = [bls_add_one(VALID_COMMITMENTS[5])]
column_indices = list(range(len(cells)))
assert not spec.verify_cell_kzg_proof_batch(row_commitments, row_indices, column_indices, cells, proofs)
identifier = make_id(row_commitments, row_indices, column_indices, cells, proofs)
yield f'verify_cell_kzg_proof_batch_case_incorrect_row_commitment_{identifier}', {
assert not spec.verify_cell_kzg_proof_batch(commitments, column_indices, cells, proofs)
identifier = make_id(commitments, column_indices, cells, proofs)
yield f'verify_cell_kzg_proof_batch_case_incorrect_commitment_{identifier}', {
'input': {
'row_commitments': encode_hex_list(row_commitments),
'row_indices': row_indices,
'commitments': encode_hex_list(commitments),
'column_indices': column_indices,
'cells': encode_hex_list(cells),
'proofs': encode_hex_list(proofs),
@ -335,17 +306,15 @@ def case_verify_cell_kzg_proof_batch():
# Incorrect cell
cells, proofs = VALID_CELLS_AND_PROOFS[6]
cells, proofs = cells[:1], proofs[:1]
row_commitments = [VALID_COMMITMENTS[6]]
row_indices = [0] * len(cells)
commitments = [VALID_COMMITMENTS[6]]
column_indices = list(range(len(cells)))
# Change last cell so it's wrong
cells[-1] = CELL_RANDOM_VALID2
assert not spec.verify_cell_kzg_proof_batch(row_commitments, row_indices, column_indices, cells, proofs)
identifier = make_id(row_commitments, row_indices, column_indices, cells, proofs)
assert not spec.verify_cell_kzg_proof_batch(commitments, column_indices, cells, proofs)
identifier = make_id(commitments, column_indices, cells, proofs)
yield f'verify_cell_kzg_proof_batch_case_incorrect_cell_{identifier}', {
'input': {
'row_commitments': encode_hex_list(row_commitments),
'row_indices': row_indices,
'commitments': encode_hex_list(commitments),
'column_indices': column_indices,
'cells': encode_hex_list(cells),
'proofs': encode_hex_list(proofs),
@ -356,17 +325,15 @@ def case_verify_cell_kzg_proof_batch():
# Incorrect proof
cells, proofs = VALID_CELLS_AND_PROOFS[0]
cells, proofs = cells[:1], proofs[:1]
row_commitments = [VALID_COMMITMENTS[0]]
row_indices = [0] * len(cells)
commitments = [VALID_COMMITMENTS[0]]
column_indices = list(range(len(cells)))
# Change last proof so it's wrong
proofs[-1] = bls_add_one(proofs[-1])
assert not spec.verify_cell_kzg_proof_batch(row_commitments, row_indices, column_indices, cells, proofs)
identifier = make_id(row_commitments, row_indices, column_indices, cells, proofs)
assert not spec.verify_cell_kzg_proof_batch(commitments, column_indices, cells, proofs)
identifier = make_id(commitments, column_indices, cells, proofs)
yield f'verify_cell_kzg_proof_batch_case_incorrect_proof_{identifier}', {
'input': {
'row_commitments': encode_hex_list(row_commitments),
'row_indices': row_indices,
'commitments': encode_hex_list(commitments),
'column_indices': column_indices,
'cells': encode_hex_list(cells),
'proofs': encode_hex_list(proofs),
@ -374,20 +341,18 @@ def case_verify_cell_kzg_proof_batch():
'output': False
}
# Edge case: Invalid row commitment
# Edge case: Invalid commitment
for i, commitment in enumerate(INVALID_G1_POINTS):
cells, proofs = VALID_CELLS_AND_PROOFS[i % len(INVALID_G1_POINTS)]
cells, proofs = cells[:1], proofs[:1]
# Set row_commitments to the invalid commitment
row_commitments = [commitment]
row_indices = [0] * len(cells)
# Set commitments to the invalid commitment
commitments = [commitment]
column_indices = list(range(len(cells)))
expect_exception(spec.verify_cell_kzg_proof_batch, row_commitments, row_indices, column_indices, cells, proofs)
identifier = make_id(row_commitments, row_indices, column_indices, cells, proofs)
yield f'verify_cell_kzg_proof_batch_case_invalid_row_commitment_{identifier}', {
expect_exception(spec.verify_cell_kzg_proof_batch, commitments, column_indices, cells, proofs)
identifier = make_id(commitments, column_indices, cells, proofs)
yield f'verify_cell_kzg_proof_batch_case_invalid_commitment_{identifier}', {
'input': {
'row_commitments': encode_hex_list(row_commitments),
'row_indices': row_indices,
'commitments': encode_hex_list(commitments),
'column_indices': column_indices,
'cells': encode_hex_list(cells),
'proofs': encode_hex_list(proofs),
@ -395,41 +360,18 @@ def case_verify_cell_kzg_proof_batch():
'output': None
}
# Edge case: Invalid row_index
cells, proofs = VALID_CELLS_AND_PROOFS[0]
cells, proofs = cells[:1], proofs[:1]
row_commitments = [VALID_COMMITMENTS[0]]
row_indices = [0] * len(cells)
# Set first row index to an invalid value
row_indices[0] = 1
column_indices = list(range(len(cells)))
expect_exception(spec.verify_cell_kzg_proof_batch, row_commitments, row_indices, column_indices, cells, proofs)
identifier = make_id(row_commitments, row_indices, column_indices, cells, proofs)
yield f'verify_cell_kzg_proof_batch_case_invalid_row_index_{identifier}', {
'input': {
'row_commitments': encode_hex_list(row_commitments),
'row_indices': row_indices,
'column_indices': column_indices,
'cells': encode_hex_list(cells),
'proofs': encode_hex_list(proofs),
},
'output': None
}
# Edge case: Invalid column_index
cells, proofs = VALID_CELLS_AND_PROOFS[1]
cells, proofs = cells[:1], proofs[:1]
row_commitments = [VALID_COMMITMENTS[1]]
row_indices = [0] * len(cells)
commitments = [VALID_COMMITMENTS[1]]
column_indices = list(range(len(cells)))
# Set first column index to an invalid value
column_indices[0] = spec.CELLS_PER_EXT_BLOB
expect_exception(spec.verify_cell_kzg_proof_batch, row_commitments, row_indices, column_indices, cells, proofs)
identifier = make_id(row_commitments, row_indices, column_indices, cells, proofs)
expect_exception(spec.verify_cell_kzg_proof_batch, commitments, column_indices, cells, proofs)
identifier = make_id(commitments, column_indices, cells, proofs)
yield f'verify_cell_kzg_proof_batch_case_invalid_column_index_{identifier}', {
'input': {
'row_commitments': encode_hex_list(row_commitments),
'row_indices': row_indices,
'commitments': encode_hex_list(commitments),
'column_indices': column_indices,
'cells': encode_hex_list(cells),
'proofs': encode_hex_list(proofs),
@ -441,17 +383,15 @@ def case_verify_cell_kzg_proof_batch():
for i, cell in enumerate(INVALID_INDIVIDUAL_CELL_BYTES):
cells, proofs = VALID_CELLS_AND_PROOFS[i % len(INVALID_INDIVIDUAL_CELL_BYTES)]
cells, proofs = cells[:1], proofs[:1]
row_commitments = [VALID_COMMITMENTS[i % len(INVALID_INDIVIDUAL_CELL_BYTES)]]
row_indices = [0] * len(cells)
commitments = [VALID_COMMITMENTS[i % len(INVALID_INDIVIDUAL_CELL_BYTES)]]
column_indices = list(range(len(cells)))
# Set first cell to the invalid cell
cells[0] = cell
expect_exception(spec.verify_cell_kzg_proof_batch, row_commitments, row_indices, column_indices, cells, proofs)
identifier = make_id(row_commitments, row_indices, column_indices, cells, proofs)
expect_exception(spec.verify_cell_kzg_proof_batch, commitments, column_indices, cells, proofs)
identifier = make_id(commitments, column_indices, cells, proofs)
yield f'verify_cell_kzg_proof_batch_case_invalid_cell_{identifier}', {
'input': {
'row_commitments': encode_hex_list(row_commitments),
'row_indices': row_indices,
'commitments': encode_hex_list(commitments),
'column_indices': column_indices,
'cells': encode_hex_list(cells),
'proofs': encode_hex_list(proofs),
@ -463,17 +403,15 @@ def case_verify_cell_kzg_proof_batch():
for i, proof in enumerate(INVALID_G1_POINTS):
cells, proofs = VALID_CELLS_AND_PROOFS[i % len(INVALID_G1_POINTS)]
cells, proofs = cells[:1], proofs[:1]
row_commitments = [VALID_COMMITMENTS[i % len(INVALID_G1_POINTS)]]
row_indices = [0] * len(cells)
commitments = [VALID_COMMITMENTS[i % len(INVALID_G1_POINTS)]]
column_indices = list(range(len(cells)))
# Set first proof to the invalid proof
proofs[0] = proof
expect_exception(spec.verify_cell_kzg_proof_batch, row_commitments, row_indices, column_indices, cells, proofs)
identifier = make_id(row_commitments, row_indices, column_indices, cells, proofs)
expect_exception(spec.verify_cell_kzg_proof_batch, commitments, column_indices, cells, proofs)
identifier = make_id(commitments, column_indices, cells, proofs)
yield f'verify_cell_kzg_proof_batch_case_invalid_proof_{identifier}', {
'input': {
'row_commitments': encode_hex_list(row_commitments),
'row_indices': row_indices,
'commitments': encode_hex_list(commitments),
'column_indices': column_indices,
'cells': encode_hex_list(cells),
'proofs': encode_hex_list(proofs),
@ -481,39 +419,17 @@ def case_verify_cell_kzg_proof_batch():
'output': None
}
# Edge case: Missing a row commitment
# Edge case: Missing a commitment
cells, proofs = VALID_CELLS_AND_PROOFS[0]
cells, proofs = cells[:1], proofs[:1]
# Do not include the row commitment
row_commitments = []
row_indices = [0] * len(cells)
column_indices = list(range(len(cells)))
expect_exception(spec.verify_cell_kzg_proof_batch, row_commitments, row_indices, column_indices, cells, proofs)
identifier = make_id(row_commitments, row_indices, column_indices, cells, proofs)
yield f'verify_cell_kzg_proof_batch_case_invalid_missing_row_commitment_{identifier}', {
'input': {
'row_commitments': encode_hex_list(row_commitments),
'row_indices': row_indices,
'column_indices': column_indices,
'cells': encode_hex_list(cells),
'proofs': encode_hex_list(proofs),
},
'output': None
}
# Edge case: Missing a row index
cells, proofs = VALID_CELLS_AND_PROOFS[1]
cells, proofs = cells[:2], proofs[:2]
row_commitments = [VALID_COMMITMENTS[1]]
# Leave off one of the row indices
row_indices = [0] * (len(cells) - 1)
# Do not include the second commitment
commitments = [VALID_COMMITMENTS[0]]
column_indices = list(range(len(cells)))
expect_exception(spec.verify_cell_kzg_proof_batch, row_commitments, row_indices, column_indices, cells, proofs)
identifier = make_id(row_commitments, row_indices, column_indices, cells, proofs)
yield f'verify_cell_kzg_proof_batch_case_invalid_missing_row_index_{identifier}', {
expect_exception(spec.verify_cell_kzg_proof_batch, commitments, column_indices, cells, proofs)
identifier = make_id(commitments, column_indices, cells, proofs)
yield f'verify_cell_kzg_proof_batch_case_invalid_missing_commitment_{identifier}', {
'input': {
'row_commitments': encode_hex_list(row_commitments),
'row_indices': row_indices,
'commitments': encode_hex_list(commitments),
'column_indices': column_indices,
'cells': encode_hex_list(cells),
'proofs': encode_hex_list(proofs),
@ -524,16 +440,14 @@ def case_verify_cell_kzg_proof_batch():
# Edge case: Missing a column index
cells, proofs = VALID_CELLS_AND_PROOFS[2]
cells, proofs = cells[:2], proofs[:2]
row_commitments = [VALID_COMMITMENTS[2]]
row_indices = [0] * len(cells)
commitments = [VALID_COMMITMENTS[2], VALID_COMMITMENTS[2]]
# Leave off one of the column indices
column_indices = list(range(len(cells) - 1))
expect_exception(spec.verify_cell_kzg_proof_batch, row_commitments, row_indices, column_indices, cells, proofs)
identifier = make_id(row_commitments, row_indices, column_indices, cells, proofs)
expect_exception(spec.verify_cell_kzg_proof_batch, commitments, column_indices, cells, proofs)
identifier = make_id(commitments, column_indices, cells, proofs)
yield f'verify_cell_kzg_proof_batch_case_invalid_missing_column_index_{identifier}', {
'input': {
'row_commitments': encode_hex_list(row_commitments),
'row_indices': row_indices,
'commitments': encode_hex_list(commitments),
'column_indices': column_indices,
'cells': encode_hex_list(cells),
'proofs': encode_hex_list(proofs),
@ -544,17 +458,15 @@ def case_verify_cell_kzg_proof_batch():
# Edge case: Missing a cell
cells, proofs = VALID_CELLS_AND_PROOFS[3]
cells, proofs = cells[:2], proofs[:2]
row_commitments = [VALID_COMMITMENTS[3]]
row_indices = [0] * len(cells)
commitments = [VALID_COMMITMENTS[3], VALID_COMMITMENTS[3]]
column_indices = list(range(len(cells)))
# Remove the last proof
cells = cells[:-1]
expect_exception(spec.verify_cell_kzg_proof_batch, row_commitments, row_indices, column_indices, cells, proofs)
identifier = make_id(row_commitments, row_indices, column_indices, cells, proofs)
expect_exception(spec.verify_cell_kzg_proof_batch, commitments, column_indices, cells, proofs)
identifier = make_id(commitments, column_indices, cells, proofs)
yield f'verify_cell_kzg_proof_batch_case_invalid_missing_cell_{identifier}', {
'input': {
'row_commitments': encode_hex_list(row_commitments),
'row_indices': row_indices,
'commitments': encode_hex_list(commitments),
'column_indices': column_indices,
'cells': encode_hex_list(cells),
'proofs': encode_hex_list(proofs),
@ -565,17 +477,15 @@ def case_verify_cell_kzg_proof_batch():
# Edge case: Missing a proof
cells, proofs = VALID_CELLS_AND_PROOFS[4]
cells, proofs = cells[:2], proofs[:2]
row_commitments = [VALID_COMMITMENTS[4]]
row_indices = [0] * len(cells)
commitments = [VALID_COMMITMENTS[4], VALID_COMMITMENTS[4]]
column_indices = list(range(len(cells)))
# Remove the last proof
proofs = proofs[:-1]
expect_exception(spec.verify_cell_kzg_proof_batch, row_commitments, row_indices, column_indices, cells, proofs)
identifier = make_id(row_commitments, row_indices, column_indices, cells, proofs)
expect_exception(spec.verify_cell_kzg_proof_batch, commitments, column_indices, cells, proofs)
identifier = make_id(commitments, column_indices, cells, proofs)
yield f'verify_cell_kzg_proof_batch_case_invalid_missing_proof_{identifier}', {
'input': {
'row_commitments': encode_hex_list(row_commitments),
'row_indices': row_indices,
'commitments': encode_hex_list(commitments),
'column_indices': column_indices,
'cells': encode_hex_list(cells),
'proofs': encode_hex_list(proofs),