Refactor recursive circuit initialization and per table proving and v…

…erification with macros (0xPolygonZero#647) * refactoring * fix clippy * fix clippy
okx · Sep 22, 2024 · bdc886f · bdc886f
1 parent e13af35
commit bdc886f
Show file tree

Hide file tree

Showing 12 changed files with 100 additions and 312 deletions.
diff --git a/evm_arithmetization/src/arithmetic/arithmetic_stark.rs b/evm_arithmetization/src/arithmetic/arithmetic_stark.rs
@@ -191,7 +191,8 @@ impl<F: RichField, const D: usize> ArithmeticStark<F, D> {
 }
 
 impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for ArithmeticStark<F, D> {
-    type EvaluationFrame<FE, P, const D2: usize> = EvmStarkFrame<P, FE, NUM_ARITH_COLUMNS>
+    type EvaluationFrame<FE, P, const D2: usize>
+        = EvmStarkFrame<P, FE, NUM_ARITH_COLUMNS>
     where
         FE: FieldExtension<D2, BaseField = F>,
         P: PackedField<Scalar = FE>;

diff --git a/evm_arithmetization/src/byte_packing/byte_packing_stark.rs b/evm_arithmetization/src/byte_packing/byte_packing_stark.rs
@@ -285,7 +285,8 @@ impl<F: RichField + Extendable<D>, const D: usize> BytePackingStark<F, D> {
 }
 
 impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for BytePackingStark<F, D> {
-    type EvaluationFrame<FE, P, const D2: usize> = EvmStarkFrame<P, FE, NUM_COLUMNS>
+    type EvaluationFrame<FE, P, const D2: usize>
+        = EvmStarkFrame<P, FE, NUM_COLUMNS>
     where
         FE: FieldExtension<D2, BaseField = F>,
         P: PackedField<Scalar = FE>;

diff --git a/evm_arithmetization/src/cpu/cpu_stark.rs b/evm_arithmetization/src/cpu/cpu_stark.rs
@@ -581,7 +581,8 @@ pub(crate) struct CpuStark<F, const D: usize> {
 }
 
 impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for CpuStark<F, D> {
-    type EvaluationFrame<FE, P, const D2: usize> = EvmStarkFrame<P, FE, NUM_CPU_COLUMNS>
+    type EvaluationFrame<FE, P, const D2: usize>
+        = EvmStarkFrame<P, FE, NUM_CPU_COLUMNS>
     where
         FE: FieldExtension<D2, BaseField = F>,
         P: PackedField<Scalar = FE>;

diff --git a/evm_arithmetization/src/fixed_recursive_verifier.rs b/evm_arithmetization/src/fixed_recursive_verifier.rs
@@ -697,77 +697,30 @@ where
         // Sanity check on the provided config
         assert_eq!(DEFAULT_CAP_LEN, 1 << stark_config.fri_config.cap_height);
 
-        let arithmetic = RecursiveCircuitsForTable::new(
-            Table::Arithmetic,
-            &all_stark.arithmetic_stark,
-            degree_bits_ranges[*Table::Arithmetic].clone(),
-            &all_stark.cross_table_lookups,
-            stark_config,
-        );
-        let byte_packing = RecursiveCircuitsForTable::new(
-            Table::BytePacking,
-            &all_stark.byte_packing_stark,
-            degree_bits_ranges[*Table::BytePacking].clone(),
-            &all_stark.cross_table_lookups,
-            stark_config,
-        );
-        let cpu = RecursiveCircuitsForTable::new(
-            Table::Cpu,
-            &all_stark.cpu_stark,
-            degree_bits_ranges[*Table::Cpu].clone(),
-            &all_stark.cross_table_lookups,
-            stark_config,
-        );
-        let keccak = RecursiveCircuitsForTable::new(
-            Table::Keccak,
-            &all_stark.keccak_stark,
-            degree_bits_ranges[*Table::Keccak].clone(),
-            &all_stark.cross_table_lookups,
-            stark_config,
-        );
-        let keccak_sponge = RecursiveCircuitsForTable::new(
-            Table::KeccakSponge,
-            &all_stark.keccak_sponge_stark,
-            degree_bits_ranges[*Table::KeccakSponge].clone(),
-            &all_stark.cross_table_lookups,
-            stark_config,
-        );
-        let logic = RecursiveCircuitsForTable::new(
-            Table::Logic,
-            &all_stark.logic_stark,
-            degree_bits_ranges[*Table::Logic].clone(),
-            &all_stark.cross_table_lookups,
-            stark_config,
-        );
-        let memory = RecursiveCircuitsForTable::new(
-            Table::Memory,
-            &all_stark.memory_stark,
-            degree_bits_ranges[*Table::Memory].clone(),
-            &all_stark.cross_table_lookups,
-            stark_config,
-        );
-        let mem_before = RecursiveCircuitsForTable::new(
-            Table::MemBefore,
-            &all_stark.mem_before_stark,
-            degree_bits_ranges[*Table::MemBefore].clone(),
-            &all_stark.cross_table_lookups,
-            stark_config,
-        );
-        let mem_after = RecursiveCircuitsForTable::new(
-            Table::MemAfter,
-            &all_stark.mem_after_stark,
-            degree_bits_ranges[*Table::MemAfter].clone(),
-            &all_stark.cross_table_lookups,
-            stark_config,
-        );
+        macro_rules! create_recursive_circuit {
+            ($table_enum:expr, $stark_field:ident) => {
+                RecursiveCircuitsForTable::new(
+                    $table_enum,
+                    &all_stark.$stark_field,
+                    degree_bits_ranges[*$table_enum].clone(),
+                    &all_stark.cross_table_lookups,
+                    stark_config,
+                )
+            };
+        }
+
+        let arithmetic = create_recursive_circuit!(Table::Arithmetic, arithmetic_stark);
+        let byte_packing = create_recursive_circuit!(Table::BytePacking, byte_packing_stark);
+        let cpu = create_recursive_circuit!(Table::Cpu, cpu_stark);
+        let keccak = create_recursive_circuit!(Table::Keccak, keccak_stark);
+        let keccak_sponge = create_recursive_circuit!(Table::KeccakSponge, keccak_sponge_stark);
+        let logic = create_recursive_circuit!(Table::Logic, logic_stark);
+        let memory = create_recursive_circuit!(Table::Memory, memory_stark);
+        let mem_before = create_recursive_circuit!(Table::MemBefore, mem_before_stark);
+        let mem_after = create_recursive_circuit!(Table::MemAfter, mem_after_stark);
+
         #[cfg(feature = "cdk_erigon")]
-        let poseidon = RecursiveCircuitsForTable::new(
-            Table::Poseidon,
-            &all_stark.poseidon_stark,
-            degree_bits_ranges[*Table::Poseidon].clone(),
-            &all_stark.cross_table_lookups,
-            stark_config,
-        );
+        let poseidon = create_recursive_circuit!(Table::Poseidon, poseidon_stark);
 
         let by_table = [
             arithmetic,
@@ -782,13 +735,15 @@ where
             #[cfg(feature = "cdk_erigon")]
             poseidon,
         ];
+
         let root = Self::create_segment_circuit(&by_table, stark_config);
         let segment_aggregation = Self::create_segment_aggregation_circuit(&root);
         let txn_aggregation =
             Self::create_txn_aggregation_circuit(&segment_aggregation, stark_config);
         let block = Self::create_block_circuit(&txn_aggregation);
         let block_wrapper = Self::create_block_wrapper_circuit(&block);
         let two_to_one_block = Self::create_two_to_one_block_circuit(&block_wrapper);
+
         Self {
             root,
             segment_aggregation,

diff --git a/evm_arithmetization/src/keccak/keccak_stark.rs b/evm_arithmetization/src/keccak/keccak_stark.rs
@@ -255,7 +255,8 @@ impl<F: RichField + Extendable<D>, const D: usize> KeccakStark<F, D> {
 }
 
 impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for KeccakStark<F, D> {
-    type EvaluationFrame<FE, P, const D2: usize> = EvmStarkFrame<P, FE, NUM_COLUMNS>
+    type EvaluationFrame<FE, P, const D2: usize>
+        = EvmStarkFrame<P, FE, NUM_COLUMNS>
     where
         FE: FieldExtension<D2, BaseField = F>,
         P: PackedField<Scalar = FE>;

diff --git a/evm_arithmetization/src/keccak_sponge/keccak_sponge_stark.rs b/evm_arithmetization/src/keccak_sponge/keccak_sponge_stark.rs
@@ -534,7 +534,8 @@ impl<F: RichField + Extendable<D>, const D: usize> KeccakSpongeStark<F, D> {
 }
 
 impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for KeccakSpongeStark<F, D> {
-    type EvaluationFrame<FE, P, const D2: usize> = EvmStarkFrame<P, FE, NUM_KECCAK_SPONGE_COLUMNS>
+    type EvaluationFrame<FE, P, const D2: usize>
+        = EvmStarkFrame<P, FE, NUM_KECCAK_SPONGE_COLUMNS>
     where
         FE: FieldExtension<D2, BaseField = F>,
         P: PackedField<Scalar = FE>;

diff --git a/evm_arithmetization/src/logic.rs b/evm_arithmetization/src/logic.rs
@@ -237,7 +237,8 @@ impl<F: RichField, const D: usize> LogicStark<F, D> {
 }
 
 impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for LogicStark<F, D> {
-    type EvaluationFrame<FE, P, const D2: usize> = EvmStarkFrame<P, FE, NUM_COLUMNS>
+    type EvaluationFrame<FE, P, const D2: usize>
+        = EvmStarkFrame<P, FE, NUM_COLUMNS>
     where
         FE: FieldExtension<D2, BaseField = F>,
         P: PackedField<Scalar = FE>;

diff --git a/evm_arithmetization/src/memory/memory_stark.rs b/evm_arithmetization/src/memory/memory_stark.rs
@@ -463,7 +463,8 @@ impl<F: RichField + Extendable<D>, const D: usize> MemoryStark<F, D> {
 }
 
 impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for MemoryStark<F, D> {
-    type EvaluationFrame<FE, P, const D2: usize> = EvmStarkFrame<P, FE, NUM_COLUMNS>
+    type EvaluationFrame<FE, P, const D2: usize>
+        = EvmStarkFrame<P, FE, NUM_COLUMNS>
     where
         FE: FieldExtension<D2, BaseField = F>,
         P: PackedField<Scalar = FE>;

diff --git a/evm_arithmetization/src/memory_continuation/memory_continuation_stark.rs b/evm_arithmetization/src/memory_continuation/memory_continuation_stark.rs
@@ -99,7 +99,8 @@ impl<F: RichField + Extendable<D>, const D: usize> MemoryContinuationStark<F, D>
 }
 
 impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for MemoryContinuationStark<F, D> {
-    type EvaluationFrame<FE, P, const D2: usize> = EvmStarkFrame<P, FE, NUM_COLUMNS>
+    type EvaluationFrame<FE, P, const D2: usize>
+        = EvmStarkFrame<P, FE, NUM_COLUMNS>
     where
         FE: FieldExtension<D2, BaseField = F>,
         P: PackedField<Scalar = FE>;

diff --git a/evm_arithmetization/src/poseidon/poseidon_stark.rs b/evm_arithmetization/src/poseidon/poseidon_stark.rs
@@ -427,10 +427,11 @@ impl<F: RichField + Extendable<D>, const D: usize> PoseidonStark<F, D> {
 }
 
 impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for PoseidonStark<F, D> {
-    type EvaluationFrame<FE, P, const D2: usize> = EvmStarkFrame<P, FE, NUM_COLUMNS>
-        where
-            FE: FieldExtension<D2, BaseField = F>,
-            P: PackedField<Scalar = FE>;
+    type EvaluationFrame<FE, P, const D2: usize>
+        = EvmStarkFrame<P, FE, NUM_COLUMNS>
+    where
+        FE: FieldExtension<D2, BaseField = F>,
+        P: PackedField<Scalar = FE>;
 
     type EvaluationFrameTarget = EvmStarkFrame<ExtensionTarget<D>, ExtensionTarget<D>, NUM_COLUMNS>;