Bind ELF to ProofData

bin/citrea/src/guests.rs

@@ -42,16 +42,16 @@ lazy_static! {
     };
     /// The following 2 are used as latest guest builds for tests that use Bitcoin DA.
     pub(crate) static ref BATCH_PROOF_LATEST_BITCOIN_GUESTS: HashMap<SpecId, (Digest, Vec<u8>)> = {
-        let mut m = HashMap::new();
-
-        m.insert(
-            SpecId::Fork1,
-            (
-                Digest::new(citrea_risc0_batch_proof::BATCH_PROOF_BITCOIN_ID),
-                citrea_risc0_batch_proof::BATCH_PROOF_BITCOIN_ELF.to_vec(),
-            )
-        );
-        m
+        HashMap::from(
+            [
+                #[cfg(feature = "testing")]
+                (SpecId::Genesis, guest!("../../../resources/guests/risc0/devnet/batch-0.elf")),
+                (SpecId::Fork1,
+                    (Digest::new(citrea_risc0_batch_proof::BATCH_PROOF_BITCOIN_ID),
+                    citrea_risc0_batch_proof::BATCH_PROOF_BITCOIN_ELF.to_vec())
+                )
+            ]
+        )
     };
     pub(crate) static ref LIGHT_CLIENT_LATEST_BITCOIN_GUESTS: HashMap<SpecId, (Digest, Vec<u8>)> = {
         let mut m = HashMap::new();

bin/citrea/src/main.rs

@@ -20,7 +20,7 @@ use sov_modules_api::Spec;
 use sov_modules_rollup_blueprint::RollupBlueprint;
 use sov_rollup_interface::Network;
 use sov_state::storage::NativeStorage;
-use tracing::{debug, error, info, instrument};
+use tracing::{debug, error, info, instrument, trace};
 
 #[cfg(test)]
 mod test_rpc;
@@ -155,6 +155,11 @@ async fn main() -> Result<(), anyhow::Error> {
 
     info!("Starting node on {network}");
 
+    trace!("Running with env :");
+    for (key, value) in std::env::vars() {
+        trace!("    {}: {}", key, value);
+    }
+
     match args.da_layer {
         SupportedDaLayer::Mock => {
             start_rollup::<MockDemoRollup, MockDaConfig>(

bin/citrea/tests/bitcoin_e2e/batch_prover_test.rs

@@ -18,8 +18,11 @@ use citrea_e2e::node::{Config, NodeKind};
 use citrea_e2e::test_case::{TestCase, TestCaseRunner};
 use citrea_e2e::traits::NodeT;
 use citrea_e2e::Result;
+use citrea_primitives::forks::{fork_from_block_number, get_forks};
 use citrea_primitives::{TO_BATCH_PROOF_PREFIX, TO_LIGHT_CLIENT_PREFIX};
 use sov_ledger_rpc::LedgerRpcClient;
+use sov_modules_api::fork::ForkManager;
+use sov_modules_api::SpecId;
 use sov_rollup_interface::da::{DaData, SequencerCommitment};
 use sov_rollup_interface::rpc::VerifiedBatchProofResponse;
 use tokio::time::sleep;
@@ -523,3 +526,102 @@ async fn parallel_proving_test() -> Result<()> {
         .run()
         .await
 }
+
+struct ForkElfSwitchingTest;
+
+#[async_trait]
+impl TestCase for ForkElfSwitchingTest {
+    fn test_config() -> TestCaseConfig {
+        TestCaseConfig {
+            with_batch_prover: true,
+            with_full_node: true,
+            ..Default::default()
+        }
+    }
+
+    fn sequencer_config() -> SequencerConfig {
+        let fork_1_height = ForkManager::new(get_forks(), 0)
+            .next_fork()
+            .unwrap()
+            .activation_height;
+
+        // Set just below fork1 height so we can generate first soft com txs in genesis
+        // and second batch above fork1
+        SequencerConfig {
+            min_soft_confirmations_per_commitment: fork_1_height - 5,
+            ..Default::default()
+        }
+    }
+
+    async fn run_test(&mut self, f: &mut TestFramework) -> Result<()> {
+        let da = f.bitcoin_nodes.get(0).unwrap();
+        let sequencer = f.sequencer.as_ref().unwrap();
+        let batch_prover = f.batch_prover.as_ref().unwrap();
+        let full_node = f.full_node.as_ref().unwrap();
+
+        let min_soft_confirmations = sequencer.min_soft_confirmations_per_commitment();
+
+        for _ in 0..min_soft_confirmations {
+            sequencer.client.send_publish_batch_request().await?;
+        }
+
+        let height = sequencer
+            .client
+            .ledger_get_head_soft_confirmation_height()
+            .await?;
+
+        assert_eq!(fork_from_block_number(height).spec_id, SpecId::Genesis);
+
+        // Generate softcom in fork1
+        for _ in 0..min_soft_confirmations {
+            sequencer.client.send_publish_batch_request().await?;
+        }
+
+        let height = sequencer
+            .client
+            .ledger_get_head_soft_confirmation_height()
+            .await?;
+        assert_eq!(fork_from_block_number(height).spec_id, SpecId::Fork1);
+
+        da.wait_mempool_len(4, None).await?;
+
+        da.generate(FINALITY_DEPTH).await?;
+
+        let finalized_height = da.get_finalized_height().await?;
+
+        batch_prover
+            .wait_for_l1_height(finalized_height, None)
+            .await?;
+
+        // Wait for batch proof tx to hit mempool
+        da.wait_mempool_len(4, None).await?;
+        da.generate(FINALITY_DEPTH).await?;
+
+        full_node
+            .wait_for_l1_height(finalized_height + FINALITY_DEPTH, None)
+            .await?;
+        let proofs = wait_for_zkproofs(full_node, finalized_height + FINALITY_DEPTH, None)
+            .await
+            .unwrap();
+
+        assert_eq!(proofs.len(), 2);
+        assert_eq!(
+            fork_from_block_number(proofs[0].proof_output.last_l2_height).spec_id,
+            SpecId::Genesis
+        );
+        assert_eq!(
+            fork_from_block_number(proofs[1].proof_output.last_l2_height).spec_id,
+            SpecId::Fork1
+        );
+
+        Ok(())
+    }
+}
+
+#[tokio::test]
+async fn test_fork_elf_switching() -> Result<()> {
+    TestCaseRunner::new(ForkElfSwitchingTest)
+        .set_citrea_path(get_citrea_path())
+        .run()
+        .await
+}

crates/batch-prover/src/proving.rs

@@ -17,7 +17,7 @@ use sov_rollup_interface::da::{BlockHeaderTrait, DaNamespace, DaSpec, SequencerC
 use sov_rollup_interface::rpc::SoftConfirmationStatus;
 use sov_rollup_interface::services::da::DaService;
 use sov_rollup_interface::zk::{
-    BatchProofCircuitInput, OldBatchProofCircuitOutput, Proof, ZkvmHost,
+    BatchProofCircuitInput, BatchProofCircuitInputV1, OldBatchProofCircuitOutput, Proof, ZkvmHost,
 };
 use sov_stf_runner::ProverService;
 use tokio::sync::Mutex;
@@ -228,32 +228,33 @@ where
     Tx: Clone + BorshSerialize,
 {
     let submitted_proofs = ledger
-        .get_proofs_by_l1_height(l1_block.header().height())
-        .map_err(|e| anyhow!("{e}"))?
+        .get_proofs_by_l1_height(l1_block.header().height())?
         .unwrap_or(vec![]);
 
     // Add each non-proven proof's data to ProverService
-    for input in inputs {
+    for (i, input) in inputs.into_iter().enumerate() {
         if !state_transition_already_proven::<StateRoot, Witness, Da, Tx>(&input, &submitted_proofs)
         {
-            prover_service
-                .add_proof_data((borsh::to_vec(&input)?, vec![]))
-                .await;
+            let seq_com = sequencer_commitments.get(i).expect("Commitment exists");
+            let last_l2_height = seq_com.l2_end_block_number;
+
+            let current_spec = fork_from_block_number(last_l2_height).spec_id;
+            let elf = elfs_by_spec
+                .get(&current_spec)
+                .expect("Every fork should have an elf attached")
+                .clone();
+
+            let input = match current_spec {
+                SpecId::Genesis => borsh::to_vec(&BatchProofCircuitInputV1::from(input))?,
+                _ => borsh::to_vec(&input)?,
+            };
+
+            prover_service.add_proof_data((input, vec![], elf)).await;
         }
     }
 
-    let last_l2_height = sequencer_commitments
-        .last()
-        .expect("Should have at least 1 commitment")
-        .l2_end_block_number;
-    let current_spec = fork_from_block_number(last_l2_height).spec_id;
-    let elf = elfs_by_spec
-        .get(&current_spec)
-        .expect("Every fork should have an elf attached")
-        .clone();
-
     // Prove all proofs in parallel
-    let proofs = prover_service.prove(elf).await?;
+    let proofs = prover_service.prove().await?;
 
     let txs_and_proofs = prover_service.submit_proofs(proofs).await?;
 
@@ -262,8 +263,7 @@ where
         txs_and_proofs,
         code_commitments_by_spec.clone(),
     )
-    .await
-    .map_err(|e| anyhow!("{e}"))?;
+    .await?;
 
     save_commitments(
         ledger.clone(),

crates/batch-prover/tests/prover_tests.rs

@@ -29,6 +29,7 @@ async fn test_successful_prover_execution() {
         .add_proof_data((
             borsh::to_vec(&make_transition_data(header_hash)).unwrap(),
             vec![],
+            vec![],
         ))
         .await;
 
@@ -68,6 +69,7 @@ async fn test_parallel_proofs_equal_to_limit() {
         .add_proof_data((
             borsh::to_vec(&make_transition_data(header_hash_1)).unwrap(),
             vec![],
+            vec![],
         ))
         .await;
     // 2nd proof
@@ -76,6 +78,7 @@ async fn test_parallel_proofs_equal_to_limit() {
         .add_proof_data((
             borsh::to_vec(&make_transition_data(header_hash_2)).unwrap(),
             vec![],
+            vec![],
         ))
         .await;
 
@@ -120,6 +123,7 @@ async fn test_parallel_proofs_higher_than_limit() {
         .add_proof_data((
             borsh::to_vec(&make_transition_data(header_hash_1)).unwrap(),
             vec![],
+            vec![],
         ))
         .await;
     // 2nd proof
@@ -128,6 +132,7 @@ async fn test_parallel_proofs_higher_than_limit() {
         .add_proof_data((
             borsh::to_vec(&make_transition_data(header_hash_2)).unwrap(),
             vec![],
+            vec![],
         ))
         .await;
     // 3rd proof
@@ -136,6 +141,7 @@ async fn test_parallel_proofs_higher_than_limit() {
         .add_proof_data((
             borsh::to_vec(&make_transition_data(header_hash_3)).unwrap(),
             vec![],
+            vec![],
         ))
         .await;
     // 4th proof
@@ -144,6 +150,7 @@ async fn test_parallel_proofs_higher_than_limit() {
         .add_proof_data((
             borsh::to_vec(&make_transition_data(header_hash_4)).unwrap(),
             vec![],
+            vec![],
         ))
         .await;
     // 5th proof
@@ -152,6 +159,7 @@ async fn test_parallel_proofs_higher_than_limit() {
         .add_proof_data((
             borsh::to_vec(&make_transition_data(header_hash_5)).unwrap(),
             vec![],
+            vec![],
         ))
         .await;
 
@@ -218,6 +226,7 @@ async fn test_multiple_parallel_proof_run() {
         .add_proof_data((
             borsh::to_vec(&make_transition_data(header_hash_1)).unwrap(),
             vec![],
+            vec![],
         ))
         .await;
     // 2nd proof
@@ -226,6 +235,7 @@ async fn test_multiple_parallel_proof_run() {
         .add_proof_data((
             borsh::to_vec(&make_transition_data(header_hash_2)).unwrap(),
             vec![],
+            vec![],
         ))
         .await;
 
@@ -250,6 +260,7 @@ async fn test_multiple_parallel_proof_run() {
         .add_proof_data((
             borsh::to_vec(&make_transition_data(header_hash_3)).unwrap(),
             vec![],
+            vec![],
         ))
         .await;
     // 2nd proof
@@ -258,6 +269,7 @@ async fn test_multiple_parallel_proof_run() {
         .add_proof_data((
             borsh::to_vec(&make_transition_data(header_hash_4)).unwrap(),
             vec![],
+            vec![],
         ))
         .await;
     // 3rd proof
@@ -266,6 +278,7 @@ async fn test_multiple_parallel_proof_run() {
         .add_proof_data((
             borsh::to_vec(&make_transition_data(header_hash_5)).unwrap(),
             vec![],
+            vec![],
         ))
         .await;
 
@@ -346,7 +359,7 @@ async fn spawn_prove(
 ) -> oneshot::Receiver<Vec<Proof>> {
     let (tx, rx) = oneshot::channel();
     tokio::spawn(async move {
-        let proofs = prover_service.prove(vec![]).await.unwrap();
+        let proofs = prover_service.prove().await.unwrap();
         tx.send(proofs).unwrap();
     });
 

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

@@ -337,10 +337,14 @@ where
         let prover_service = self.prover_service.as_ref();
 
         prover_service
-            .add_proof_data((borsh::to_vec(&circuit_input)?, assumptions))
+            .add_proof_data((
+                borsh::to_vec(&circuit_input)?,
+                assumptions,
+                light_client_elf,
+            ))
             .await;
 
-        let proofs = self.prover_service.prove(light_client_elf).await?;
+        let proofs = self.prover_service.prove().await?;
 
         assert_eq!(proofs.len(), 1);
 

crates/primitives/src/forks.rs

@@ -60,6 +60,9 @@ pub const DEVNET_FORKS: [Fork; 2] = [
     Fork::new(SpecId::Fork1, 999_999_999),
 ];
 
+#[cfg(feature = "testing")]
+pub const NIGHTLY_FORKS: [Fork; 2] = [Fork::new(SpecId::Genesis, 0), Fork::new(SpecId::Fork1, 100)];
+#[cfg(not(feature = "testing"))]
 pub const NIGHTLY_FORKS: [Fork; 1] = [Fork::new(SpecId::Fork1, 0)];
 
 const _CHECK_FORKS: () = {