wip (#957)

Co-authored-by: Mason Liang <mason@scroll.io>

Author: z2trillion

zkevm-circuits/src/evm_circuit/execution/callop.rs

@@ -1599,7 +1599,11 @@ mod test {
             .handle_block(&block.eth_block, &block.geth_traces)
             .unwrap();
         let block = block_convert::<Fr>(&builder.block, &builder.code_db).unwrap();
+        dbg!(block.mpt_updates.clone());
+        panic!();
         let mpt_circuit = MptCircuit::new_from_block(&block);
+        // dbg!(mpt_circuit.proofs);
+        panic!();
         let prover = MockProver::<Fr>::run(12, &mpt_circuit, vec![]).unwrap();
         println!("prover result: {:?}", prover.verify());
         assert!(prover.verify().is_ok());

zkevm-circuits/src/mpt_circuit.rs

@@ -12,7 +12,11 @@ use halo2_proofs::{
     plonk::{Advice, Circuit, Column, ConstraintSystem, Error, Fixed},
 };
 use itertools::Itertools;
-use mpt_zktrie::mpt_circuits::{gadgets::poseidon::PoseidonLookup, mpt, types::Proof};
+use mpt_zktrie::mpt_circuits::{
+    gadgets::{mpt_update::hash_traces, poseidon::PoseidonLookup},
+    mpt,
+    types::Proof,
+};
 
 impl PoseidonLookup for PoseidonTable {
     fn lookup_columns_generic(&self) -> (Column<Fixed>, [Column<Advice>; 6]) {
@@ -94,6 +98,9 @@ impl SubCircuit<Fr> for MptCircuit<Fr> {
             .zip_eq(block.mpt_updates.smt_traces.iter().cloned())
             .collect();
 
+        dbg!(traces.clone());
+        panic!();
+
         Self {
             proofs: traces.into_iter().map(Proof::from).collect(),
             row_limit: block.circuits_params.max_mpt_rows,
@@ -137,7 +144,7 @@ impl SubCircuit<Fr> for MptCircuit<Fr> {
 
 #[cfg(any(feature = "test", test))]
 impl Circuit<Fr> for MptCircuit<Fr> {
-    type Config = (MptCircuitConfig<Fr>, Challenges);
+    type Config = (MptCircuitConfig<Fr>, PoseidonTable, Challenges);
     type FloorPlanner = SimpleFloorPlanner;
 
     fn without_witnesses(&self) -> Self {
@@ -149,7 +156,7 @@ impl Circuit<Fr> for MptCircuit<Fr> {
 
     fn configure(meta: &mut ConstraintSystem<Fr>) -> Self::Config {
         let challenges = Challenges::construct(meta);
-        let poseidon_table = PoseidonTable::dev_construct(meta);
+        let poseidon_table = PoseidonTable::construct(meta);
         let mpt_table = MptTable::construct(meta);
 
         let config = {
@@ -163,15 +170,46 @@ impl Circuit<Fr> for MptCircuit<Fr> {
             )
         };
 
-        (config, challenges)
+        (config, poseidon_table, challenges)
     }
 
     fn synthesize(
         &self,
-        (config, challenges): Self::Config,
+        (mpt_config, poseidon_table, challenges): Self::Config,
         mut layouter: impl Layouter<Fr>,
     ) -> Result<(), Error> {
+        // let hashes_traces =
+        // mpt_zktrie::mpt_circuits::gadgets::mpt_update::hash_traces(&self.proofs);
+
+        //             q_enable: meta.fixed_column(),
+        // hash_id: meta.advice_column(),
+        // input0: meta.advice_column(),
+        // input1: meta.advice_column(),
+        // control: meta.advice_column(),
+        // domain_spec: meta.advice_column(),
+        // heading_mark: meta.advice_column(),
+
+        dbg!(self.proofs.clone());
+        dbg!(hash_traces(&self.proofs));
+        // panic!();
+
+        let poseidon_table_rows: Vec<_> = hash_traces(&self.proofs)
+            .iter()
+            .map(|([left, right], domain, hash)| {
+                // dbg!(left, right, hash, domain);
+                [
+                    *hash,
+                    *left,
+                    *right,
+                    Fr::zero(),
+                    *domain,
+                    Fr::one(),
+                ]
+                .map(Value::known)
+            })
+            .collect();
+        poseidon_table.load(&mut layouter, &poseidon_table_rows)?;
         let challenges = challenges.values(&layouter);
-        self.synthesize_sub(&config, &challenges, &mut layouter)
+        self.synthesize_sub(&mpt_config, &challenges, &mut layouter)
     }
 }

zkevm-circuits/src/table.rs

@@ -891,16 +891,11 @@ impl PoseidonTable {
         }
     }
 
-    /// Construct a new PoseidonTable for dev
-    pub(crate) fn dev_construct<F: FieldExt>(meta: &mut ConstraintSystem<F>) -> Self {
-        Self::construct(meta)
-    }
-
     pub(crate) fn assign<F: Field>(
         &self,
         region: &mut Region<'_, F>,
         offset: usize,
-        row: &[Value<F>],
+        row: [Value<F>; 6],
     ) -> Result<(), Error> {
         region.assign_fixed(
             || "assign poseidon table row value",
@@ -914,32 +909,31 @@ impl PoseidonTable {
                 || "assign poseidon table row value",
                 *column,
                 offset,
-                || *value,
+                || value,
             )?;
         }
         Ok(())
     }
 
-    // Is this method used anyhwhere?
     pub(crate) fn load<'d, F: Field>(
         &self,
         layouter: &mut impl Layouter<F>,
-        hashes: impl Iterator<Item = &'d [Value<F>]> + Clone,
+        hashes: &[[Value<F>; 6]],
     ) -> Result<(), Error> {
         layouter.assign_region(
             || "poseidon table",
-            |mut region| self.load_with_region(&mut region, hashes.clone()),
+            |mut region| self.load_with_region(&mut region, hashes),
         )
     }
 
     pub(crate) fn load_with_region<'d, F: Field>(
         &self,
         region: &mut Region<'_, F>,
-        hashes: impl Iterator<Item = &'d [Value<F>]>,
+        hashes: &[[Value<F>; 6]],
     ) -> Result<(), Error> {
-        self.assign(region, 0, [Value::known(F::zero()); 6].as_slice())?;
-        for (offset, row) in hashes.enumerate() {
-            self.assign(region, offset + 1, row)?;
+        self.assign(region, 0, [Value::known(F::zero()); 6])?;
+        for (offset, row) in hashes.iter().enumerate() {
+            self.assign(region, offset + 1, *row)?;
         }
         Ok(())
     }

zkevm-circuits/src/witness/block.rs

@@ -518,6 +518,8 @@ pub fn block_convert<F: Field>(
         log::error!("withdraw root is not avaliable");
     }
 
+    dbg!(mpt_updates.len());
+
     Ok(Block {
         randomness: F::from_u128(DEFAULT_RAND),
         context: block.into(),

zkevm-circuits/src/witness/mpt.rs

@@ -233,6 +233,8 @@ impl MptUpdates {
                 )
             })
             .collect();
+        dbg!(rows_len, updates.len());
+        // panic!();
         MptUpdates {
             updates,
             old_root,