Fixes

evm/src/all_stark.rs

@@ -242,6 +242,7 @@ mod tests {
     fn make_logic_trace<R: Rng>(
         num_rows: usize,
         logic_stark: &LogicStark<F, D>,
+        config: &StarkConfig,
         rng: &mut R,
     ) -> Vec<PolynomialValues<F>> {
         let all_ops = [logic::Op::And, logic::Op::Or, logic::Op::Xor];
@@ -253,7 +254,11 @@ mod tests {
                 Operation::new(op, input0, input1)
             })
             .collect();
-        logic_stark.generate_trace(ops, &mut TimingTree::default())
+        logic_stark.generate_trace(
+            ops,
+            config.fri_config.num_cap_elements(),
+            &mut TimingTree::default(),
+        )
     }
 
     fn make_memory_trace<R: Rng>(
@@ -705,7 +710,8 @@ mod tests {
 
         let keccak_trace = make_keccak_trace(num_keccak_perms, &all_stark.keccak_stark, &mut rng);
         let keccak_memory_trace = make_keccak_memory_trace(&all_stark.keccak_memory_stark, config);
-        let logic_trace = make_logic_trace(num_logic_rows, &all_stark.logic_stark, &mut rng);
+        let logic_trace =
+            make_logic_trace(num_logic_rows, &all_stark.logic_stark, config, &mut rng);
         let mem_trace = make_memory_trace(num_memory_ops, &all_stark.memory_stark, &mut rng);
         let mut memory_trace = mem_trace.0;
         let num_memory_ops = mem_trace.1;

evm/src/cpu/kernel/asm/main.asm

@@ -1,8 +1,9 @@
 global main:
     // First, initialise the shift table
     %shift_table_init
+
     // Second, load all MPT data from the prover.
-    PUSH txn_loop
+    PUSH hash_initial_tries
     %jump(load_all_mpts)
 
 hash_initial_tries:

evm/src/logic.rs

@@ -138,12 +138,13 @@ impl<F: RichField, const D: usize> LogicStark<F, D> {
     pub(crate) fn generate_trace(
         &self,
         operations: Vec<Operation>,
+        min_rows: usize,
         timing: &mut TimingTree,
     ) -> Vec<PolynomialValues<F>> {
         let trace_rows = timed!(
             timing,
             "generate trace rows",
-            self.generate_trace_rows(operations)
+            self.generate_trace_rows(operations, min_rows)
         );
         let trace_polys = timed!(
             timing,
@@ -153,9 +154,13 @@ impl<F: RichField, const D: usize> LogicStark<F, D> {
         trace_polys
     }
 
-    fn generate_trace_rows(&self, operations: Vec<Operation>) -> Vec<[F; NUM_COLUMNS]> {
+    fn generate_trace_rows(
+        &self,
+        operations: Vec<Operation>,
+        min_rows: usize,
+    ) -> Vec<[F; NUM_COLUMNS]> {
         let len = operations.len();
-        let padded_len = len.next_power_of_two();
+        let padded_len = len.max(min_rows).next_power_of_two();
 
         let mut rows = Vec::with_capacity(padded_len);
         for op in operations {

evm/src/memory/memory_stark.rs

@@ -43,19 +43,6 @@ pub struct MemoryStark<F, const D: usize> {
     pub(crate) f: PhantomData<F>,
 }
 
-// TODO: Remove
-// #[derive(Clone, Debug)]
-// pub(crate) struct MemoryOp {
-//     /// true if this is an actual memory operation, or false if it's a padding row.
-//     pub filter: bool,
-//     pub timestamp: usize,
-//     pub is_read: bool,
-//     pub context: usize,
-//     pub segment: Segment,
-//     pub virt: usize,
-//     pub value: U256,
-// }
-
 impl MemoryOp {
     /// Generate a row for a given memory operation. Note that this does not generate columns which
     /// depend on the next operation, such as `CONTEXT_FIRST_CHANGE`; those are generated later.

evm/src/witness/operation.rs

@@ -110,7 +110,7 @@ pub(crate) fn generate_keccak_general<F: Field>(
         stack_pop_with_log_and_fill::<4, _>(state, &mut row)?;
     let len = len.as_usize();
 
-    let mut base_address = MemoryAddress::new_u256s(context, segment, base_virt);
+    let base_address = MemoryAddress::new_u256s(context, segment, base_virt);
     let input = (0..len)
         .map(|i| {
             let address = MemoryAddress {
@@ -156,7 +156,7 @@ pub(crate) fn generate_prover_input<F: Field>(
 
 pub(crate) fn generate_pop<F: Field>(
     state: &mut GenerationState<F>,
-    mut row: CpuColumnsView<F>,
+    row: CpuColumnsView<F>,
 ) -> Result<(), ProgramError> {
     if state.registers.stack_len == 0 {
         return Err(ProgramError::StackUnderflow);

evm/src/witness/traces.rs

@@ -99,6 +99,7 @@ impl<T: Copy> Traces<T> {
     where
         T: RichField + Extendable<D>,
     {
+        let cap_elements = config.fri_config.num_cap_elements();
         let Traces {
             cpu,
             logic_ops,
@@ -114,10 +115,12 @@ impl<T: Copy> Traces<T> {
         let keccak_trace = all_stark.keccak_stark.generate_trace(keccak_inputs, timing);
         let keccak_memory_trace = all_stark.keccak_memory_stark.generate_trace(
             keccak_memory_inputs,
-            config.fri_config.num_cap_elements(),
+            cap_elements,
             timing,
         );
-        let logic_trace = all_stark.logic_stark.generate_trace(logic_ops, timing);
+        let logic_trace = all_stark
+            .logic_stark
+            .generate_trace(logic_ops, cap_elements, timing);
         let memory_trace = all_stark.memory_stark.generate_trace(memory_ops, timing);
 
         [

plonky2/src/hash/merkle_tree.rs

@@ -135,7 +135,9 @@ impl<F: RichField, H: Hasher<F>> MerkleTree<F, H> {
         let log2_leaves_len = log2_strict(leaves.len());
         assert!(
             cap_height <= log2_leaves_len,
-            "cap height should be at most log2(leaves.len())"
+            "cap_height={} should be at most log2(leaves.len())={}",
+            cap_height,
+            log2_leaves_len
         );
 
         let num_digests = 2 * (leaves.len() - (1 << cap_height));