Assert validity of padded lengths

0xPolygonZero · Jul 29, 2024 · 9c7117a · 9c7117a
1 parent 1309f83
commit 9c7117a
Show file tree

Hide file tree

Showing 8 changed files with 10 additions and 0 deletions.
diff --git a/evm_arithmetization/src/arithmetic/arithmetic_stark.rs b/evm_arithmetization/src/arithmetic/arithmetic_stark.rs
@@ -179,6 +179,7 @@ impl<F: RichField, const D: usize> ArithmeticStark<F, D> {
         // to accommodate the range check columns. Also make sure the
         // trace length is a power of two.
         let padded_len = 1 << ALL_DEGREE_LOGS[TABLE_TO_SORTED_INDEX[*Table::Arithmetic]];
+        assert!(padded_len >= trace_rows.len());
         for _ in trace_rows.len()..std::cmp::max(padded_len, RANGE_MAX) {
             trace_rows.push(vec![F::ZERO; columns::NUM_ARITH_COLUMNS]);
         }

diff --git a/evm_arithmetization/src/byte_packing/byte_packing_stark.rs b/evm_arithmetization/src/byte_packing/byte_packing_stark.rs
@@ -184,6 +184,7 @@ impl<F: RichField + Extendable<D>, const D: usize> BytePackingStark<F, D> {
                 rows.push(self.generate_row_for_op(op));
             }
         }
+        assert!(num_rows >= rows.len());
 
         for _ in rows.len()..num_rows {
             rows.push(self.generate_padding_row());

diff --git a/evm_arithmetization/src/generation/mod.rs b/evm_arithmetization/src/generation/mod.rs
@@ -486,6 +486,9 @@ fn simulate_cpu<F: Field>(
     row.gas = F::from_canonical_u64(state.registers.gas_used);
     row.stack_len = F::from_canonical_usize(state.registers.stack_len);
 
+    let padded_len = 1 << ALL_DEGREE_LOGS[TABLE_TO_SORTED_INDEX[*Table::Cpu]];
+    assert!(padded_len >= state.traces.clock());
+
     loop {
         // Padding.
         state.push_cpu(row);

diff --git a/evm_arithmetization/src/keccak/keccak_stark.rs b/evm_arithmetization/src/keccak/keccak_stark.rs
@@ -80,6 +80,7 @@ impl<F: RichField + Extendable<D>, const D: usize> KeccakStark<F, D> {
             rows.extend(rows_for_perm);
         }
 
+        assert!(num_rows >= rows.len());
         while rows.len() < num_rows {
             rows.push([F::ZERO; NUM_COLUMNS]);
         }

diff --git a/evm_arithmetization/src/keccak_sponge/keccak_sponge_stark.rs b/evm_arithmetization/src/keccak_sponge/keccak_sponge_stark.rs
@@ -291,6 +291,7 @@ impl<F: RichField + Extendable<D>, const D: usize> KeccakSpongeStark<F, D> {
         }
         // Pad the trace.
         let padded_rows = 1 << ALL_DEGREE_LOGS[TABLE_TO_SORTED_INDEX[*Table::KeccakSponge]];
+        assert!(padded_rows >= rows.len());
         for _ in rows.len()..padded_rows {
             rows.push(self.generate_padding_row());
         }

diff --git a/evm_arithmetization/src/logic.rs b/evm_arithmetization/src/logic.rs
@@ -221,6 +221,7 @@ impl<F: RichField, const D: usize> LogicStark<F, D> {
     ) -> Vec<[F; NUM_COLUMNS]> {
         let len = operations.len();
         let padded_len = 1 << ALL_DEGREE_LOGS[TABLE_TO_SORTED_INDEX[*Table::Logic]];
+        assert!(padded_len >= len);
 
         let mut rows = Vec::with_capacity(padded_len);
         for op in operations {

diff --git a/evm_arithmetization/src/memory/memory_stark.rs b/evm_arithmetization/src/memory/memory_stark.rs
@@ -354,6 +354,7 @@ impl<F: RichField + Extendable<D>, const D: usize> MemoryStark<F, D> {
         // We want at least one padding row, so that the last real operation can have
         // its flags set correctly.
         let num_ops_padded = 1 << ALL_DEGREE_LOGS[TABLE_TO_SORTED_INDEX[*Table::Memory]];
+        assert!(num_ops_padded >= num_ops);
         for _ in num_ops..num_ops_padded {
             memory_ops.push(padding_op);
         }

diff --git a/evm_arithmetization/src/memory_continuation/memory_continuation_stark.rs b/evm_arithmetization/src/memory_continuation/memory_continuation_stark.rs
@@ -87,6 +87,7 @@ impl<F: RichField + Extendable<D>, const D: usize> MemoryContinuationStark<F, D>
 
         let num_rows = rows.len();
         let num_rows_padded = 1 << log_padded;
+        assert!(num_rows_padded >= num_rows);
         for _ in num_rows..num_rows_padded {
             rows.push(vec![F::ZERO; NUM_COLUMNS]);
         }