feat: update core verifier with public values constraints

core/src/stark/machine.rs

@@ -242,31 +242,50 @@ impl<SC: StarkGenericConfig, A: MachineAir<Val<SC>>> MachineStark<SC, A> {
     {
         // Observe the preprocessed commitment.
         challenger.observe(vk.commit.clone());
-        // TODO: Observe the challenges in a tree-like structure for easily verifiable reconstruction
-        // in a map-reduce recursion setting.
-        tracing::debug_span!("observe challenges for all shards").in_scope(|| {
-            proof.shard_proofs.iter().for_each(|proof| {
-                challenger.observe(proof.commitment.main_commit.clone());
-                let public_values =
-                    PublicValues::<Word<Val<SC>>, Val<SC>>::new(proof.public_values);
-                challenger.observe_slice(&public_values.to_vec());
-            });
+
+        // Observe the challenges.
+        proof.shard_proofs.iter().for_each(|proof| {
+            challenger.observe(proof.commitment.main_commit.clone());
+            let public_values = PublicValues::<Word<Val<SC>>, Val<SC>>::new(proof.public_values);
+            challenger.observe_slice(&public_values.to_vec());
         });
 
-        // Verify the segment proofs.
-        tracing::info!("verifying shard proofs");
-        for (i, proof) in proof.shard_proofs.iter().enumerate() {
-            tracing::debug_span!("verifying shard", segment = i).in_scope(|| {
-                let chips = self
-                    .shard_chips_ordered(&proof.chip_ordering)
-                    .collect::<Vec<_>>();
-                Verifier::verify_shard(&self.config, vk, &chips, &mut challenger.clone(), proof)
-                    .map_err(ProgramVerificationError::InvalidSegmentProof)
-            })?;
+        // Verify the shards.
+        for proof in proof.shard_proofs.iter() {
+            let chips = self
+                .shard_chips_ordered(&proof.chip_ordering)
+                .collect::<Vec<_>>();
+            Verifier::verify_shard(&self.config, vk, &chips, &mut challenger.clone(), proof)
+                .map_err(ProgramVerificationError::InvalidSegmentProof)?;
+        }
+
+        // Verify the public values for each shard.
+        for i in 0..proof.shard_proofs.len() {
+            let curr = &proof.shard_proofs[i];
+
+            // Assert that the shard number is correct.
+            assert_eq!(curr.public_values.shard, (i + 1) as u32);
         }
-        tracing::info!("verifying individual shards succeeded");
 
-        tracing::info!("verifying cumulative sum is 0");
+        // Verify the public values between shards.
+        for i in 1..proof.shard_proofs.len() {
+            let curr = &proof.shard_proofs[i];
+            let prev = &proof.shard_proofs[i - 1];
+
+            // Assert that the program counter is carried over correctly.
+            assert_eq!(prev.public_values.next_pc, curr.public_values.start_pc);
+
+            // Assert that the public values digest is the same.
+            assert_eq!(
+                prev.public_values.committed_value_digest,
+                curr.public_values.committed_value_digest
+            );
+        }
+
+        // Verify the public values of the last shard.
+        let last = &proof.shard_proofs[proof.shard_proofs.len() - 1];
+        assert_eq!(last.public_values.exit_code, 0);
+
         // Verify the cumulative sum is 0.
         let mut sum = SC::Challenge::zero();
         for proof in proof.shard_proofs.iter() {

core/src/stark/verifier.rs

@@ -169,8 +169,6 @@ impl<SC: StarkGenericConfig, A: MachineAir<Val<SC>>> Verifier<SC, A> {
             )
             .map_err(|_| VerificationError::InvalidopeningArgument)?;
 
-        // Verify the constrtaint evaluations.
-
         for (chip, trace_domain, qc_domains, values) in izip!(
             chips.iter(),
             trace_domains,

eval/src/main.rs

@@ -1,3 +1,5 @@
+#![feature(generic_const_exprs)]
+
 use clap::{command, Parser};
 use csv::WriterBuilder;
 use serde::Serialize;