Set ZK constants in compile time

crates/citrea-stf/src/lib.rs

@@ -12,5 +12,5 @@ use sov_rollup_interface::da::DaVerifier;
 use verifier::StateTransitionVerifier;
 
 /// Alias for StateTransitionVerifier.
-pub type StfVerifier<DA, Vm, ZkContext, RT> =
-    StateTransitionVerifier<StfBlueprint<ZkContext, <DA as DaVerifier>::Spec, RT>, DA, Vm>;
+pub type StfVerifier<DA, ZkContext, RT> =
+    StateTransitionVerifier<StfBlueprint<ZkContext, <DA as DaVerifier>::Spec, RT>, DA>;

crates/citrea-stf/src/verifier.rs

@@ -1,45 +1,34 @@
-use std::marker::PhantomData;
-
 use sov_rollup_interface::da::{BlockHeaderTrait, DaNamespace, DaVerifier};
 use sov_rollup_interface::stf::{ApplySequencerCommitmentsOutput, StateTransitionFunction};
-use sov_rollup_interface::zk::{BatchProofCircuitInput, BatchProofCircuitOutput, Zkvm, ZkvmGuest};
+use sov_rollup_interface::zk::{BatchProofCircuitInput, BatchProofCircuitOutput};
 
 /// Verifies a state transition
-pub struct StateTransitionVerifier<ST, Da, Zk>
+pub struct StateTransitionVerifier<ST, Da>
 where
     Da: DaVerifier,
-    Zk: Zkvm,
     ST: StateTransitionFunction<Da::Spec>,
 {
     app: ST,
     da_verifier: Da,
-    phantom: PhantomData<Zk>,
 }
 
-impl<Stf, Da, Zk> StateTransitionVerifier<Stf, Da, Zk>
+impl<Stf, Da> StateTransitionVerifier<Stf, Da>
 where
     Da: DaVerifier,
-    Zk: ZkvmGuest,
     Stf: StateTransitionFunction<Da::Spec>,
 {
     /// Create a [`StateTransitionVerifier`]
     pub fn new(app: Stf, da_verifier: Da) -> Self {
-        Self {
-            app,
-            da_verifier,
-            phantom: Default::default(),
-        }
+        Self { app, da_verifier }
     }
 
     /// Verify the next block
     pub fn run_sequencer_commitments_in_da_slot(
         &mut self,
-        zkvm: Zk,
+        data: BatchProofCircuitInput<Stf::StateRoot, Stf::Witness, Da::Spec, Stf::Transaction>,
         pre_state: Stf::PreState,
-    ) -> Result<(), Da::Error> {
+    ) -> Result<BatchProofCircuitOutput<Da::Spec, Stf::StateRoot>, Da::Error> {
         println!("Running sequencer commitments in DA slot");
-        let data: BatchProofCircuitInput<Stf::StateRoot, _, Da::Spec, Stf::Transaction> =
-            zkvm.read_from_host();
 
         if !data.da_block_header_of_commitments.verify_hash() {
             panic!("Invalid hash of DA block header of commitments");
@@ -88,7 +77,7 @@ where
 
         println!("out of apply_soft_confirmations_from_sequencer_commitments");
 
-        let out: BatchProofCircuitOutput<Da::Spec, _> = BatchProofCircuitOutput {
+        let out = BatchProofCircuitOutput {
             initial_state_root: data.initial_state_root,
             final_state_root,
             final_soft_confirmation_hash,
@@ -102,7 +91,6 @@ where
             last_l2_height,
         };
 
-        zkvm.commit(&out);
-        Ok(())
+        Ok(out)
     }
 }

crates/light-client-prover/src/circuit.rs

@@ -17,10 +17,8 @@ pub enum LightClientVerificationError {
 
 pub fn run_circuit<DaV: DaVerifier, G: ZkvmGuest>(
     da_verifier: DaV,
-    guest: &G,
+    input: LightClientCircuitInput<DaV::Spec>,
 ) -> Result<LightClientCircuitOutput<DaV::Spec>, LightClientVerificationError> {
-    let input: LightClientCircuitInput<DaV::Spec> = guest.read_from_host();
-
     // Extract previous light client proof output
     let previous_light_client_proof_output =
         if let Some(journal) = input.previous_light_client_proof_journal {

crates/light-client-prover/src/tests/mod.rs

@@ -1,6 +1,6 @@
 mod test_utils;
 
-use sov_mock_da::{MockBlockHeader, MockDaSpec, MockDaVerifier};
+use sov_mock_da::{MockBlockHeader, MockDaVerifier};
 use sov_mock_zkvm::MockZkGuest;
 use sov_rollup_interface::zk::LightClientCircuitInput;
 use test_utils::{create_mock_blob, create_prev_lcp_serialized};
@@ -18,7 +18,7 @@ fn test_light_client_circuit_valid_da_valid_data() {
 
     let block_header_1 = MockBlockHeader::from_height(1);
 
-    let input = LightClientCircuitInput::<MockDaSpec> {
+    let input = LightClientCircuitInput {
         previous_light_client_proof_journal: None,
         light_client_proof_method_id,
         da_block_header: block_header_1,
@@ -30,11 +30,7 @@ fn test_light_client_circuit_valid_da_valid_data() {
         batch_prover_da_pub_key: [9; 32].to_vec(),
     };
 
-    let serialized_input = borsh::to_vec(&input).expect("should serialize");
-
-    let mut guest = MockZkGuest::new(serialized_input);
-
-    let output_1 = run_circuit(da_verifier.clone(), &guest).unwrap();
+    let output_1 = run_circuit::<_, MockZkGuest>(da_verifier.clone(), input).unwrap();
 
     // Check that the state transition actually happened
     assert_eq!(output_1.state_root, [3; 32]);
@@ -49,7 +45,7 @@ fn test_light_client_circuit_valid_da_valid_data() {
 
     let mock_output_1_serialized = create_prev_lcp_serialized(output_1, true);
 
-    let input_2 = LightClientCircuitInput::<MockDaSpec> {
+    let input_2 = LightClientCircuitInput {
         previous_light_client_proof_journal: Some(mock_output_1_serialized),
         da_block_header: block_header_2,
         da_data: vec![blob_3, blob_4],
@@ -61,11 +57,7 @@ fn test_light_client_circuit_valid_da_valid_data() {
         batch_prover_da_pub_key: [9; 32].to_vec(),
     };
 
-    let serialized_input_2 = borsh::to_vec(&input_2).expect("should serialize");
-
-    guest.input = serialized_input_2;
-
-    let output_2 = run_circuit(da_verifier, &guest).unwrap();
+    let output_2 = run_circuit::<_, MockZkGuest>(da_verifier.clone(), input_2).unwrap();
 
     // Check that the state transition actually happened
     assert_eq!(output_2.state_root, [5; 32]);
@@ -83,7 +75,7 @@ fn test_wrong_order_da_blocks_should_still_work() {
 
     let block_header_1 = MockBlockHeader::from_height(1);
 
-    let input = LightClientCircuitInput::<MockDaSpec> {
+    let input = LightClientCircuitInput {
         previous_light_client_proof_journal: None,
         light_client_proof_method_id,
         da_block_header: block_header_1,
@@ -95,11 +87,7 @@ fn test_wrong_order_da_blocks_should_still_work() {
         batch_prover_da_pub_key: [9; 32].to_vec(),
     };
 
-    let serialized_input = borsh::to_vec(&input).expect("should serialize");
-
-    let guest = MockZkGuest::new(serialized_input);
-
-    let output_1 = run_circuit(da_verifier.clone(), &guest).unwrap();
+    let output_1 = run_circuit::<_, MockZkGuest>(da_verifier.clone(), input).unwrap();
 
     // Check that the state transition actually happened
     assert_eq!(output_1.state_root, [3; 32]);
@@ -117,7 +105,7 @@ fn create_unchainable_outputs_then_chain_them_on_next_block() {
     let blob_1 = create_mock_blob([2u8; 32], [3u8; 32], 3, true);
     let blob_2 = create_mock_blob([3u8; 32], [4u8; 32], 4, true);
 
-    let input = LightClientCircuitInput::<MockDaSpec> {
+    let input = LightClientCircuitInput {
         previous_light_client_proof_journal: None,
         light_client_proof_method_id,
         da_block_header: block_header_1,
@@ -129,11 +117,7 @@ fn create_unchainable_outputs_then_chain_them_on_next_block() {
         batch_prover_da_pub_key: [9; 32].to_vec(),
     };
 
-    let serialized_input = borsh::to_vec(&input).expect("should serialize");
-
-    let mut guest = MockZkGuest::new(serialized_input);
-
-    let output_1 = run_circuit(da_verifier.clone(), &guest).unwrap();
+    let output_1 = run_circuit::<_, MockZkGuest>(da_verifier.clone(), input).unwrap();
 
     // Check that the state transition has not happened because we are missing 1->2
     assert_eq!(output_1.state_root, [1; 32]);
@@ -159,17 +143,19 @@ fn create_unchainable_outputs_then_chain_them_on_next_block() {
 
     let mock_output_1_ser = create_prev_lcp_serialized(output_1, true);
 
-    let input_2 = LightClientCircuitInput::<MockDaSpec> {
+    let input_2 = LightClientCircuitInput {
         previous_light_client_proof_journal: Some(mock_output_1_ser),
+        light_client_proof_method_id,
         da_block_header: block_header_2,
         da_data: vec![blob_1],
+        inclusion_proof: [1u8; 32],
+        completeness_proof: (),
         l2_genesis_state_root: None,
-        ..input
+        batch_proof_method_id: light_client_proof_method_id,
+        batch_prover_da_pub_key: [9; 32].to_vec(),
     };
 
-    guest.input = borsh::to_vec(&input_2).unwrap();
-
-    let output_2 = run_circuit(da_verifier, &guest).unwrap();
+    let output_2 = run_circuit::<_, MockZkGuest>(da_verifier, input_2).unwrap();
 
     // Check that the state transition actually happened from 1-4 now
 
@@ -188,7 +174,7 @@ fn test_header_chain_proof_height_and_hash() {
 
     let block_header_1 = MockBlockHeader::from_height(1);
 
-    let input = LightClientCircuitInput::<MockDaSpec> {
+    let input = LightClientCircuitInput {
         previous_light_client_proof_journal: None,
         light_client_proof_method_id,
         da_block_header: block_header_1,
@@ -200,11 +186,7 @@ fn test_header_chain_proof_height_and_hash() {
         batch_prover_da_pub_key: [9; 32].to_vec(),
     };
 
-    let serialized_input = borsh::to_vec(&input).expect("should serialize");
-
-    let mut guest = MockZkGuest::new(serialized_input);
-
-    let output_1 = run_circuit(da_verifier.clone(), &guest).unwrap();
+    let output_1 = run_circuit::<_, MockZkGuest>(da_verifier.clone(), input).unwrap();
 
     // Check that the state transition actually happened
     assert_eq!(output_1.state_root, [3; 32]);
@@ -219,7 +201,7 @@ fn test_header_chain_proof_height_and_hash() {
 
     let prev_lcp_out = create_prev_lcp_serialized(output_1, true);
 
-    let input_2 = LightClientCircuitInput::<MockDaSpec> {
+    let input_2 = LightClientCircuitInput {
         previous_light_client_proof_journal: Some(prev_lcp_out),
         da_block_header: block_header_2,
         da_data: vec![blob_3, blob_4],
@@ -231,12 +213,8 @@ fn test_header_chain_proof_height_and_hash() {
         batch_prover_da_pub_key: [9; 32].to_vec(),
     };
 
-    let serialized_input_2 = borsh::to_vec(&input_2).expect("should serialize");
-
-    guest.input = serialized_input_2;
-
     // Header chain verification must fail because the l1 block 3 was given before l1 block 2
-    let res = run_circuit(da_verifier, &guest);
+    let res = run_circuit::<_, MockZkGuest>(da_verifier, input_2);
     assert!(matches!(
         res,
         Err(LightClientVerificationError::HeaderChainVerificationFailed)
@@ -254,7 +232,7 @@ fn test_unverifiable_batch_proofs() {
 
     let block_header_1 = MockBlockHeader::from_height(1);
 
-    let input = LightClientCircuitInput::<MockDaSpec> {
+    let input = LightClientCircuitInput {
         previous_light_client_proof_journal: None,
         light_client_proof_method_id,
         da_block_header: block_header_1,
@@ -266,11 +244,7 @@ fn test_unverifiable_batch_proofs() {
         batch_prover_da_pub_key: [9; 32].to_vec(),
     };
 
-    let serialized_input = borsh::to_vec(&input).expect("should serialize");
-
-    let guest = MockZkGuest::new(serialized_input);
-
-    let output_1 = run_circuit(da_verifier.clone(), &guest).unwrap();
+    let output_1 = run_circuit::<_, MockZkGuest>(da_verifier.clone(), input).unwrap();
 
     // Check that the state transition actually happened but only for verified batch proof
     // and assert the unverified is ignored, so it is not even in the unchained outputs
@@ -291,7 +265,7 @@ fn test_unverifiable_prev_light_client_proof() {
 
     let block_header_1 = MockBlockHeader::from_height(1);
 
-    let input = LightClientCircuitInput::<MockDaSpec> {
+    let input = LightClientCircuitInput {
         previous_light_client_proof_journal: None,
         light_client_proof_method_id,
         da_block_header: block_header_1,
@@ -303,11 +277,7 @@ fn test_unverifiable_prev_light_client_proof() {
         batch_prover_da_pub_key: [9; 32].to_vec(),
     };
 
-    let serialized_input = borsh::to_vec(&input).expect("should serialize");
-
-    let mut guest = MockZkGuest::new(serialized_input);
-
-    let output_1 = run_circuit(da_verifier.clone(), &guest).unwrap();
+    let output_1 = run_circuit::<_, MockZkGuest>(da_verifier.clone(), input).unwrap();
 
     // Check that the state transition actually happened but only for verified batch proof
     // and assert the unverified is ignored, so it is not even in the unchained outputs
@@ -320,7 +290,7 @@ fn test_unverifiable_prev_light_client_proof() {
 
     let prev_lcp_out = create_prev_lcp_serialized(output_1, false);
 
-    let input_2 = LightClientCircuitInput::<MockDaSpec> {
+    let input_2 = LightClientCircuitInput {
         previous_light_client_proof_journal: Some(prev_lcp_out),
         da_block_header: block_header_2,
         da_data: vec![],
@@ -332,9 +302,7 @@ fn test_unverifiable_prev_light_client_proof() {
         batch_prover_da_pub_key: [9; 32].to_vec(),
     };
 
-    guest.input = borsh::to_vec(&input_2).unwrap();
-
-    let res = run_circuit(da_verifier, &guest);
+    let res = run_circuit::<_, MockZkGuest>(da_verifier, input_2);
     assert!(matches!(
         res,
         Err(LightClientVerificationError::InvalidPreviousLightClientProof)

crates/prover-services/src/lib.rs

@@ -1,21 +1,19 @@
 use citrea_stf::verifier::StateTransitionVerifier;
 use sov_rollup_interface::services::da::DaService;
 use sov_rollup_interface::stf::StateTransitionFunction;
-use sov_rollup_interface::zk::ZkvmHost;
 
 mod parallel;
 pub use parallel::*;
 
-pub enum ProofGenMode<Da, Vm, Stf>
+pub enum ProofGenMode<Da, Stf>
 where
     Da: DaService,
-    Vm: ZkvmHost,
     Stf: StateTransitionFunction<Da::Spec>,
 {
     /// Skips proving.
     Skip,
     /// The simulator runs the rollup verifier logic without even emulating the zkVM
-    Simulate(StateTransitionVerifier<Stf, Da::Verifier, Vm::Guest>),
+    Simulate(StateTransitionVerifier<Stf, Da::Verifier>),
     /// The executor runs the rollup verification logic in the zkVM, but does not actually
     /// produce a zk proof
     Execute,