fix various logic error in index and padding

Author: hero78119

bus-mapping/src/circuit_input_builder.rs

@@ -556,16 +556,17 @@ impl<'a, C: CircuitsParams> CircuitInputBuilder<C> {
     pub fn commit_chunk(
         &mut self,
         to_next: bool,
-        end_tx: usize,
-        end_copy: usize,
+        next_tx_index: usize,
+        next_copy_index: usize,
         last_call: Option<Call>,
     ) {
         self.chunk_ctx.end_rwc = self.block_ctx.rwc.0;
-        self.chunk_ctx.end_tx = end_tx;
-        self.chunk_ctx.end_copy = end_copy;
+        self.chunk_ctx.end_tx_index = next_tx_index;
+        self.chunk_ctx.end_copy_index = next_copy_index;
         self.chunks[self.chunk_ctx.idx].ctx = self.chunk_ctx.clone();
         if to_next {
-            self.chunk_ctx.bump(self.block_ctx.rwc.0, end_tx, end_copy);
+            self.chunk_ctx
+                .bump(self.block_ctx.rwc.0, next_tx_index, next_copy_index);
             self.cur_chunk_mut().prev_last_call = last_call;
         }
     }

bus-mapping/src/circuit_input_builder/chunk.rs

@@ -33,14 +33,14 @@ pub struct ChunkContext {
     pub initial_rwc: usize,
     /// End global rw counter
     pub end_rwc: usize,
+    /// tx range in block: [initial_tx_index, end_tx_index)
+    pub initial_tx_index: usize,
     ///
-    pub initial_tx: usize,
+    pub end_tx_index: usize,
+    ///  copy range in block: [initial_copy_index, end_copy_index)
+    pub initial_copy_index: usize,
     ///
-    pub end_tx: usize,
-    ///
-    pub initial_copy: usize,
-    ///
-    pub end_copy: usize,
+    pub end_copy_index: usize,
     /// Druing dry run, chuncking is desabled
     pub enable: bool,
 }
@@ -60,10 +60,10 @@ impl ChunkContext {
             total_chunks,
             initial_rwc: 1, // rw counter start from 1
             end_rwc: 0,     // end_rwc should be set in later phase
-            initial_tx: 1,
-            end_tx: 0,
-            initial_copy: 0,
-            end_copy: 0,
+            initial_tx_index: 0,
+            end_tx_index: 0,
+            initial_copy_index: 0,
+            end_copy_index: 0,
             enable: true,
         }
     }
@@ -76,10 +76,10 @@ impl ChunkContext {
             total_chunks: 1,
             initial_rwc: 1, // rw counter start from 1
             end_rwc: 0,     // end_rwc should be set in later phase
-            initial_tx: 1,
-            end_tx: 0,
-            initial_copy: 0,
-            end_copy: 0,
+            initial_tx_index: 0,
+            end_tx_index: 0,
+            initial_copy_index: 0,
+            end_copy_index: 0,
             enable: true,
         }
     }
@@ -91,11 +91,11 @@ impl ChunkContext {
         self.idx += 1;
         self.rwc = RWCounter::new();
         self.initial_rwc = initial_rwc;
-        self.initial_tx = initial_tx;
-        self.initial_copy = initial_copy;
+        self.initial_tx_index = initial_tx;
+        self.initial_copy_index = initial_copy;
         self.end_rwc = 0;
-        self.end_tx = 0;
-        self.end_copy = 0;
+        self.end_tx_index = 0;
+        self.end_copy_index = 0;
     }
 
     /// Is first chunk

zkevm-circuits/src/copy_circuit.rs

@@ -849,7 +849,7 @@ impl<F: Field> SubCircuit<F> for CopyCircuit<F> {
     fn new_from_block(block: &witness::Block<F>, chunk: &Chunk<F>) -> Self {
         let chunked_copy_events = block
             .copy_events
-            .get(chunk.chunk_context.initial_copy..chunk.chunk_context.end_copy)
+            .get(chunk.chunk_context.initial_copy_index..chunk.chunk_context.end_copy_index)
             .unwrap_or_default();
         Self::new_with_external_data(
             chunked_copy_events.to_owned(),

zkevm-circuits/src/copy_circuit/test.rs

@@ -47,7 +47,7 @@ pub fn test_copy_circuit_from_block<F: Field>(
 ) -> Result<(), Vec<VerifyFailure>> {
     let chunked_copy_events = block
         .copy_events
-        .get(chunk.chunk_context.initial_copy..chunk.chunk_context.end_copy)
+        .get(chunk.chunk_context.initial_copy_index..chunk.chunk_context.end_copy_index)
         .unwrap_or_default();
     test_copy_circuit::<F>(
         k,

zkevm-circuits/src/evm_circuit/execution.rs

@@ -1127,7 +1127,7 @@ impl<F: Field> ExecutionConfig<F> {
                 let dummy_tx = Transaction::default();
                 let chunk_txs = block
                     .txs
-                    .get(chunk.chunk_context.initial_tx - 1..chunk.chunk_context.end_tx)
+                    .get(chunk.chunk_context.initial_tx_index..chunk.chunk_context.end_tx_index)
                     .unwrap_or_default();
 
                 let last_call = chunk_txs

zkevm-circuits/src/state_circuit/test.rs

@@ -45,7 +45,7 @@ fn test_state_circuit_ok(
         storage: storage_ops,
         ..Default::default()
     });
-    let chunk = Chunk::new_from_rw_map(&rw_map);
+    let chunk = Chunk::new_from_rw_map(&rw_map, None, None);
 
     let circuit = StateCircuit::<Fr>::new(&chunk);
     let instance = circuit.instance();
@@ -69,15 +69,19 @@ fn verifying_key_independent_of_rw_length() {
 
     let no_rows = StateCircuit::<Fr>::new(&chunk);
 
-    chunk = Chunk::new_from_rw_map(&RwMap::from(&OperationContainer {
-        memory: vec![Operation::new(
-            RWCounter::from(1),
-            RWCounter::from(1),
-            RW::WRITE,
-            MemoryOp::new(1, MemoryAddress::from(0), 32),
-        )],
-        ..Default::default()
-    }));
+    chunk = Chunk::new_from_rw_map(
+        &RwMap::from(&OperationContainer {
+            memory: vec![Operation::new(
+                RWCounter::from(1),
+                RWCounter::from(1),
+                RW::WRITE,
+                MemoryOp::new(1, MemoryAddress::from(0), 32),
+            )],
+            ..Default::default()
+        }),
+        None,
+        None,
+    );
     let one_row = StateCircuit::<Fr>::new(&chunk);
 
     let vk_no_rows = keygen_vk(&params, &no_rows).unwrap();
@@ -944,7 +948,11 @@ fn variadic_size_check() {
         },
     ];
     // let rw_map: RwMap = rows.clone().into();
-    let circuit = StateCircuit::new(&Chunk::new_from_rw_map(&RwMap::from(rows.clone())));
+    let circuit = StateCircuit::new(&Chunk::new_from_rw_map(
+        &RwMap::from(rows.clone()),
+        None,
+        None,
+    ));
     let power_of_randomness = circuit.instance();
     let prover1 = MockProver::<Fr>::run(17, &circuit, power_of_randomness).unwrap();
 
@@ -965,7 +973,7 @@ fn variadic_size_check() {
         },
     ]);
 
-    let circuit = StateCircuit::new(&Chunk::new_from_rw_map(&rows.into()));
+    let circuit = StateCircuit::new(&Chunk::new_from_rw_map(&rows.into(), None, None));
     let power_of_randomness = circuit.instance();
     let prover2 = MockProver::<Fr>::run(17, &circuit, power_of_randomness).unwrap();
 

zkevm-circuits/src/witness/chunk.rs

@@ -68,16 +68,21 @@ impl<F: Field> Default for Chunk<F> {
 
 impl<F: Field> Chunk<F> {
     #[allow(dead_code)]
-    pub(crate) fn new_from_rw_map(rws: &RwMap) -> Self {
+    pub(crate) fn new_from_rw_map(
+        rws: &RwMap,
+        padding_start_rw: Option<Rw>,
+        chrono_padding_start_rw: Option<Rw>,
+    ) -> Self {
         let (alpha, gamma) = get_permutation_randomness();
         let mut chunk = Chunk::default();
         let rw_fingerprints = get_permutation_fingerprint_of_rwmap(
             rws,
             chunk.fixed_param.max_rws,
-            alpha, // TODO
+            alpha,
             gamma,
             F::from(1),
             false,
+            padding_start_rw,
         );
         let chrono_rw_fingerprints = get_permutation_fingerprint_of_rwmap(
             rws,
@@ -86,6 +91,7 @@ impl<F: Field> Chunk<F> {
             gamma,
             F::from(1),
             true,
+            chrono_padding_start_rw,
         );
         chunk.rws = rws.clone();
         chunk.rw_fingerprints = rw_fingerprints;
@@ -121,6 +127,9 @@ pub fn chunk_convert<F: Field>(
 
     for (i, chunk) in builder.chunks.iter().enumerate() {
         // Get the Rws in the i-th chunk
+
+        // TODO this is just chronological rws, not by address sorted rws
+        // need another sorted method
         let cur_rws =
             RwMap::from_chunked(&block.container, chunk.ctx.initial_rwc, chunk.ctx.end_rwc);
         cur_rws.check_value();
@@ -164,7 +173,7 @@ pub fn chunk_convert<F: Field>(
     }
 
     // TODO(Cecilia): if we chunk across blocks then need to store the prev_block
-    let chunck = Chunk {
+    let chunk = Chunk {
         permu_alpha: challenges[idx][0],
         permu_gamma: challenges[idx][1],
         rw_fingerprints: rw_fingerprints[idx].clone(),
@@ -179,7 +188,7 @@ pub fn chunk_convert<F: Field>(
         prev_chunk_last_rw,
     };
 
-    Ok(chunck)
+    Ok(chunk)
 }
 
 ///
@@ -219,13 +228,15 @@ pub fn get_permutation_fingerprint_of_rwmap<F: Field>(
     gamma: F,
     prev_continuous_fingerprint: F,
     is_chrono: bool,
+    padding_start_rw: Option<Rw>,
 ) -> RwFingerprints<F> {
     get_permutation_fingerprint_of_rwvec(
         &rwmap.table_assignments(is_chrono),
         max_row,
         alpha,
         gamma,
         prev_continuous_fingerprint,
+        padding_start_rw,
     )
 }
 
@@ -236,6 +247,7 @@ pub fn get_permutation_fingerprint_of_rwvec<F: Field>(
     alpha: F,
     gamma: F,
     prev_continuous_fingerprint: F,
+    padding_start_rw: Option<Rw>,
 ) -> RwFingerprints<F> {
     get_permutation_fingerprint_of_rwrowvec(
         &rwvec
@@ -246,6 +258,7 @@ pub fn get_permutation_fingerprint_of_rwvec<F: Field>(
         alpha,
         gamma,
         prev_continuous_fingerprint,
+        padding_start_rw.map(|r| r.table_assignment()),
     )
 }
 
@@ -256,8 +269,9 @@ pub fn get_permutation_fingerprint_of_rwrowvec<F: Field>(
     alpha: F,
     gamma: F,
     prev_continuous_fingerprint: F,
+    padding_start_rwrow: Option<RwRow<Value<F>>>,
 ) -> RwFingerprints<F> {
-    let (rows, _) = RwRow::padding(rwrowvec, max_row, true);
+    let (rows, _) = RwRow::padding(rwrowvec, max_row, padding_start_rwrow);
     let x = rows.to2dvec();
     let fingerprints = get_permutation_fingerprints(
         &x,

zkevm-circuits/src/witness/rw.rs

@@ -133,7 +133,7 @@ impl RwMap {
     pub fn table_assignments_padding(
         rows: &[Rw],
         target_len: usize,
-        prev_chunk_last_rw: Option<Rw>,
+        padding_start_rw: Option<Rw>,
     ) -> (Vec<Rw>, usize) {
         // Remove Start/Padding rows as we will add them from scratch.
         let rows_trimmed: Vec<Rw> = rows
@@ -162,7 +162,7 @@ impl RwMap {
             .map(|rw_counter| Rw::Padding { rw_counter });
         (
             iter::empty()
-                .chain([prev_chunk_last_rw.unwrap_or(Rw::Start { rw_counter: 1 })])
+                .chain([padding_start_rw.unwrap_or(Rw::Start { rw_counter: 1 })])
                 .chain(rows_trimmed.into_iter())
                 .chain(padding.into_iter())
                 .collect(),