Add Tests for Segment Proving Without Keccak Tables

evm_arithmetization/src/fixed_recursive_verifier.rs

@@ -2944,3 +2944,101 @@ where
  circuit.verifier_only.circuit_digest.elements.len()
  + (1 << circuit.common.config.fri_config.cap_height) * NUM_HASH_OUT_ELTS
 }
+
+#[cfg(test)]
+mod tests {
+ use plonky2::field::goldilocks_field::GoldilocksField;
+ use plonky2::plonk::config::PoseidonGoldilocksConfig;
+ use plonky2::timed;
+
+ use super::*;
+ use crate::testing_utils::{dummy_payload, init_logger};
+
+ type F = GoldilocksField;
+ const D: usize = 2;
+ type C = PoseidonGoldilocksConfig;
+
+ #[test]
+ #[ignore]
+ fn test_segment_proof_generation_without_keccak() -> anyhow::Result<()> {
+ let timing = &mut TimingTree::new("Segment Proof Generation", log::Level::Info);
+ init_logger();
+
+ let all_stark = AllStark::<F, D>::default();
+ let config = StarkConfig::standard_fast_config();
+
+ let all_circuits = timed!(
+ timing,
+ log::Level::Info,
+ "Create all recursive circuits",
+ AllRecursiveCircuits::<F, C, D>::new(
+ &all_stark,
+ &[
+ 16..17,
+ 8..9,
+ 9..10,
+ 4..5,
+ 8..9,
+ 4..5,
+ 17..18,
+ 17..18,
+ 17..18
+ ],
+ &config,
+ )
+ );
+
+ // Generate a dummy payload for testing
+ let dummy_payload = timed!(
+ timing,
+ log::Level::Info,
+ "Generate dummy payload",
+ dummy_payload(100, true)?
+ );
+
+ let max_cpu_len_log = 9;
+ let segment_iterator = SegmentDataIterator::<F>::new(&dummy_payload, Some(max_cpu_len_log));
+
+ let mut proofs_without_keccak = vec![];
+
+ let skip_proofs_before_index = 3;
+ for (i, segment_run) in segment_iterator.enumerate() {
+ if i < skip_proofs_before_index {
+ continue;
+ }
+
+ // Process and prove segment
+ let (_, mut segment_data) =
+ segment_run.map_err(|e: SegmentError| anyhow::format_err!(e))?;
+ let segment_proof = timed!(
+ timing,
+ log::Level::Info,
+ "Prove segment",
+ all_circuits.prove_segment(
+ &all_stark,
+ &config,
+ dummy_payload.trim(),
+ &mut segment_data,
+ timing,
+ None,
+ )?
+ );
+
+ proofs_without_keccak.push(segment_proof);
+ break; // Process only one proof
+ }
+
+ // Verify the generated segment proof
+ timed!(
+ timing,
+ log::Level::Info,
+ "Verify segment proof",
+ all_circuits.verify_root(proofs_without_keccak[0].proof_with_pis.clone())?
+ );
+
+ // Print timing details
+ timing.print();
+
+ Ok(())
+ }
+}

evm_arithmetization/src/testing_utils.rs

@@ -1,18 +1,22 @@
 //! A set of utility functions and constants to be used by `evm_arithmetization`
 //! unit and integration tests.
 
+use anyhow::Result;
 use env_logger::{try_init_from_env, Env, DEFAULT_FILTER_ENV};
-use ethereum_types::{BigEndianHash, H256, U256};
+use ethereum_types::{Address, BigEndianHash, H256, U256};
 use hex_literal::hex;
 use keccak_hash::keccak;
 use mpt_trie::{
  nibbles::Nibbles,
  partial_trie::{HashedPartialTrie, Node, PartialTrie},
 };
+use plonky2::field::goldilocks_field::GoldilocksField;
 
 pub use crate::cpu::kernel::cancun_constants::*;
 pub use crate::cpu::kernel::constants::global_exit_root::*;
-use crate::{generation::mpt::AccountRlp, proof::BlockMetadata, util::h2u};
+use crate::generation::TrieInputs;
+use crate::proof::TrieRoots;
+use crate::{generation::mpt::AccountRlp, proof::BlockMetadata, util::h2u, GenerationInputs};
 
 pub const EMPTY_NODE_HASH: H256 = H256(hex!(
  "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"
@@ -161,3 +165,79 @@ pub fn scalable_contract_from_storage(storage_trie: &HashedPartialTrie) -> Accou
  ..Default::default()
  }
 }
+
+/// Get `GenerationInputs` for a dummy payload, where the block has the given
+/// timestamp.
+pub fn dummy_payload(
+ timestamp: u64,
+ is_first_payload: bool,
+) -> Result<GenerationInputs<GoldilocksField>> {
+ let beneficiary = hex!("deadbeefdeadbeefdeadbeefdeadbeefdeadbeef");
+
+ let block_metadata = BlockMetadata {
+ block_beneficiary: Address::from(beneficiary),
+ block_timestamp: timestamp.into(),
+ block_number: 1.into(),
+ block_difficulty: 0x020000.into(),
+ block_random: H256::from_uint(&0x020000.into()),
+ block_gaslimit: 0xff112233u32.into(),
+ block_chain_id: 1.into(),
+ block_base_fee: 0xa.into(),
+ ..Default::default()
+ };
+
+ let (mut state_trie_before, mut storage_tries) = preinitialized_state_and_storage_tries()?;
+ let checkpoint_state_trie_root = state_trie_before.hash();
+ let mut beacon_roots_account_storage = storage_tries[0].1.clone();
+
+ update_beacon_roots_account_storage(
+ &mut beacon_roots_account_storage,
+ block_metadata.block_timestamp,
+ block_metadata.parent_beacon_block_root,
+ )?;
+ let updated_beacon_roots_account =
+ beacon_roots_contract_from_storage(&beacon_roots_account_storage);
+
+ if !is_first_payload {
+ // This isn't the first dummy payload being processed. We need to update the
+ // initial state trie to account for the update on the beacon roots contract.
+ state_trie_before.insert(
+ beacon_roots_account_nibbles(),
+ rlp::encode(&updated_beacon_roots_account).to_vec(),
+ )?;
+ storage_tries[0].1 = beacon_roots_account_storage;
+ }
+
+ let tries_before = TrieInputs {
+ state_trie: state_trie_before,
+ storage_tries,
+ ..Default::default()
+ };
+
+ let expected_state_trie_after: HashedPartialTrie = {
+ let mut state_trie_after = HashedPartialTrie::from(crate::Node::Empty);
+ state_trie_after.insert(
+ beacon_roots_account_nibbles(),
+ rlp::encode(&updated_beacon_roots_account).to_vec(),
+ )?;
+
+ state_trie_after
+ };
+
+ let trie_roots_after = TrieRoots {
+ state_root: expected_state_trie_after.hash(),
+ transactions_root: tries_before.transactions_trie.hash(),
+ receipts_root: tries_before.receipts_trie.hash(),
+ };
+
+ let inputs = GenerationInputs {
+ tries: tries_before.clone(),
+ burn_addr: None,
+ trie_roots_after,
+ checkpoint_state_trie_root,
+ block_metadata,
+ ..Default::default()
+ };
+
+ Ok(inputs)
+}

evm_arithmetization/tests/two_to_one_block.rs

@@ -1,22 +1,12 @@
 #![cfg(feature = "eth_mainnet")]
 
-use ethereum_types::{Address, BigEndianHash, H256};
 use evm_arithmetization::fixed_recursive_verifier::{
  extract_block_final_public_values, extract_two_to_one_block_hash,
 };
-use evm_arithmetization::generation::{GenerationInputs, TrieInputs};
-use evm_arithmetization::proof::{
- BlockMetadata, FinalPublicValues, PublicValues, TrieRoots, EMPTY_CONSOLIDATED_BLOCKHASH,
-};
-use evm_arithmetization::testing_utils::{
- beacon_roots_account_nibbles, beacon_roots_contract_from_storage, init_logger,
- preinitialized_state_and_storage_tries, update_beacon_roots_account_storage,
-};
-use evm_arithmetization::{AllRecursiveCircuits, AllStark, Node, StarkConfig};
-use hex_literal::hex;
-use mpt_trie::partial_trie::{HashedPartialTrie, PartialTrie};
+use evm_arithmetization::proof::{FinalPublicValues, PublicValues};
+use evm_arithmetization::testing_utils::{dummy_payload, init_logger};
+use evm_arithmetization::{AllRecursiveCircuits, AllStark, StarkConfig};
 use plonky2::field::goldilocks_field::GoldilocksField;
-use plonky2::field::types::Field;
 use plonky2::hash::poseidon::PoseidonHash;
 use plonky2::plonk::config::{Hasher, PoseidonGoldilocksConfig};
 use plonky2::plonk::proof::ProofWithPublicInputs;
@@ -26,80 +16,6 @@ type F = GoldilocksField;
 const D: usize = 2;
 type C = PoseidonGoldilocksConfig;
 
-/// Get `GenerationInputs` for a dummy payload, where the block has the given
-/// timestamp.
-fn dummy_payload(timestamp: u64, is_first_payload: bool) -> anyhow::Result<GenerationInputs<F>> {
- let beneficiary = hex!("deadbeefdeadbeefdeadbeefdeadbeefdeadbeef");
-
- let block_metadata = BlockMetadata {
- block_beneficiary: Address::from(beneficiary),
- block_timestamp: timestamp.into(),
- block_number: 1.into(),
- block_difficulty: 0x020000.into(),
- block_random: H256::from_uint(&0x020000.into()),
- block_gaslimit: 0xff112233u32.into(),
- block_chain_id: 1.into(),
- block_base_fee: 0xa.into(),
- ..Default::default()
- };
-
- let (mut state_trie_before, mut storage_tries) = preinitialized_state_and_storage_tries()?;
- let checkpoint_state_trie_root = state_trie_before.hash();
- let mut beacon_roots_account_storage = storage_tries[0].1.clone();
-
- update_beacon_roots_account_storage(
- &mut beacon_roots_account_storage,
- block_metadata.block_timestamp,
- block_metadata.parent_beacon_block_root,
- )?;
- let updated_beacon_roots_account =
- beacon_roots_contract_from_storage(&beacon_roots_account_storage);
-
- if !is_first_payload {
- // This isn't the first dummy payload being processed. We need to update the
- // initial state trie to account for the update on the beacon roots contract.
- state_trie_before.insert(
- beacon_roots_account_nibbles(),
- rlp::encode(&updated_beacon_roots_account).to_vec(),
- )?;
- storage_tries[0].1 = beacon_roots_account_storage;
- }
-
- let tries_before = TrieInputs {
- state_trie: state_trie_before,
- storage_tries,
- ..Default::default()
- };
-
- let expected_state_trie_after: HashedPartialTrie = {
- let mut state_trie_after = HashedPartialTrie::from(Node::Empty);
- state_trie_after.insert(
- beacon_roots_account_nibbles(),
- rlp::encode(&updated_beacon_roots_account).to_vec(),
- )?;
-
- state_trie_after
- };
-
- let trie_roots_after = TrieRoots {
- state_root: expected_state_trie_after.hash(),
- transactions_root: tries_before.transactions_trie.hash(),
- receipts_root: tries_before.receipts_trie.hash(),
- };
-
- let inputs = GenerationInputs {
- tries: tries_before.clone(),
- burn_addr: None,
- trie_roots_after,
- checkpoint_state_trie_root,
- checkpoint_consolidated_hash: EMPTY_CONSOLIDATED_BLOCKHASH.map(F::from_canonical_u64),
- block_metadata,
- ..Default::default()
- };
-
- Ok(inputs)
-}
-
 fn get_test_block_proof(
  timestamp: u64,
  all_circuits: &AllRecursiveCircuits<GoldilocksField, PoseidonGoldilocksConfig, 2>,