purge unused committee circuit

Author: jonas089

Cargo.lock

@@ -5,7 +5,6 @@ members = [
     "prover",
     "iso-step",
     "circuits/sp1-step",
-    "circuits/sp1-committee",
     "circuits/sp1-rotation",
     "preprocessor",
     "eth-types",

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["sp1-committee", "sp1-step", "sp1-rotation"]
+members = ["sp1-step", "sp1-rotation"]
 
 [workspace.dependencies]
 sp1-zkvm = "4.0.1"

circuits/Cargo.lock

@@ -34,21 +34,6 @@ pub struct CommitteeUpdateArgs {
     pub sync_committee_branch: Branch,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, BorshSerialize, BorshDeserialize)]
-pub struct CommitteeCircuitOutput {
-    pub commitment: [u8; 32],
-    pub finalized_header_root: [u8; 32],
-}
-
-impl CommitteeCircuitOutput {
-    pub fn new(commitment: [u8; 32], finalized_header_root: [u8; 32]) -> Self {
-        Self {
-            commitment,
-            finalized_header_root,
-        }
-    }
-}
-
 lazy_static! {
     pub static ref ZERO_HASHES: [[u8; 32]; 2] = {
         std::iter::successors(Some([0; 32]), |&prev| {
@@ -60,10 +45,3 @@ lazy_static! {
         .unwrap()
     };
 }
-
-sol! {
-    struct WrappedOutput{
-        bytes32 commitment;
-        bytes32 finalized_header_root;
-    }
-}

circuits/Cargo.toml

@@ -8,6 +8,5 @@ fn main() {
         args.features = vec!["wrapped".to_string()];
     }
     build_program_with_args("../circuits/sp1-step", args.clone());
-    build_program_with_args("../circuits/sp1-committee", args.clone());
     build_program_with_args("../circuits/sp1-rotation", Default::default());
 }

circuits/sp1-committee/Cargo.toml

@@ -1,24 +1,12 @@
 use std::path::PathBuf;
 
+use crate::ProverOps;
 use alloy_sol_types::SolType;
-use committee_iso::types::WrappedOutput as CommitteeWrappedOutput;
 use rotation_iso::types::WrappedOutput as RotatoinWrappedOutput;
 use serde::{Deserialize, Serialize};
 use sp1_sdk::{HashableKey, SP1ProofWithPublicValues, SP1VerifyingKey};
 use step_iso::types::WrappedOutput as StepWrappedOutput;
 
-use crate::ProverOps;
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct CommitteeUpdateFixture {
-    root: String,
-    commitment: String,
-    vkey: String,
-    public_values: String,
-    proof: String,
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct StepUpdateFixture {
@@ -42,37 +30,6 @@ struct RotationUpdateFixture {
     proof: String,
 }
 
-pub fn create_committee_proof_fixture(
-    proof: &SP1ProofWithPublicValues,
-    vk: &SP1VerifyingKey,
-    ops: &ProverOps,
-) {
-    let bytes = proof.public_values.as_slice();
-    let CommitteeWrappedOutput {
-        finalized_header_root,
-        commitment,
-    } = CommitteeWrappedOutput::abi_decode(bytes, false).unwrap();
-    let fixture = CommitteeUpdateFixture {
-        root: format!("0x{}", hex::encode(finalized_header_root)),
-        commitment: format!("0x{}", hex::encode(commitment)),
-        vkey: vk.bytes32().to_string(),
-        public_values: format!("0x{}", hex::encode(bytes)),
-        proof: format!("0x{}", hex::encode(proof.bytes())),
-    };
-    let prefix = match ops {
-        ProverOps::Default => panic!("No point in generating a fixture for a default proof!"),
-        ProverOps::Groth16 => "groth16-fixture.json",
-        ProverOps::Plonk => "plonk-fixture.json",
-    };
-    let fixture_path = PathBuf::from("./");
-    std::fs::create_dir_all(&fixture_path).expect("failed to create fixture path");
-    std::fs::write(
-        fixture_path.join(prefix),
-        serde_json::to_string_pretty(&fixture).unwrap(),
-    )
-    .expect("failed to write fixture");
-}
-
 pub fn create_step_proof_fixture(
     proof: &SP1ProofWithPublicValues,
     vk: &SP1VerifyingKey,

circuits/sp1-committee/src/main.rs

@@ -1,6 +1,5 @@
 pub mod eth;
 pub mod fixture;
-use committee_iso::types::CommitteeUpdateArgs;
 use rotation_iso::types::RotationCircuitInputs;
 use sp1_sdk::{include_elf, ProverClient, SP1ProofWithPublicValues, SP1Stdin, SP1VerifyingKey};
 use step_iso::types::{SyncStepArgs, SyncStepCircuitInput};
@@ -15,62 +14,6 @@ pub enum ProverOps {
     Plonk,
 }
 
-pub fn generate_committee_update_proof_sp1(
-    ops: &ProverOps,
-    committee_update: CommitteeUpdateArgs,
-    compressed: &ProofCompressionBool,
-) -> (SP1ProofWithPublicValues, SP1VerifyingKey) {
-    use std::time::Instant;
-    let start_time = Instant::now();
-    #[allow(deprecated)]
-    let client = ProverClient::new();
-    let mut stdin = SP1Stdin::new();
-    stdin.write_vec(borsh::to_vec(&committee_update).expect("Failed to serialize"));
-
-    let (proof, _, vk) = match ops {
-        ProverOps::Default => {
-            const COMMITTEE_ELF: &[u8] = include_elf!("sp1-committee");
-            let (pk, vk) = client.setup(COMMITTEE_ELF);
-            let proof = match compressed {
-                ProofCompressionBool::Compressed => client
-                    .prove(&pk, &stdin)
-                    .compressed()
-                    .run()
-                    .expect("failed to generate proof"),
-                ProofCompressionBool::Uncompressed => client
-                    .prove(&pk, &stdin)
-                    .run()
-                    .expect("failed to generate proof"),
-            };
-            (proof, pk, vk)
-        }
-        ProverOps::Groth16 => {
-            const COMMITTEE_ELF: &[u8] = include_elf!("sp1-committee");
-            let (pk, vk) = client.setup(COMMITTEE_ELF);
-            let proof = client
-                .prove(&pk, &stdin)
-                .groth16()
-                .run()
-                .expect("failed to generate proof");
-            (proof, pk, vk)
-        }
-        ProverOps::Plonk => {
-            const COMMITTEE_ELF: &[u8] = include_elf!("sp1-committee");
-            let (pk, vk) = client.setup(COMMITTEE_ELF);
-            let proof = client
-                .prove(&pk, &stdin)
-                .plonk()
-                .run()
-                .expect("failed to generate proof");
-            (proof, pk, vk)
-        }
-    };
-    println!("Successfully generated proof!");
-    let duration = start_time.elapsed();
-    println!("Elapsed time: {:?}", duration);
-    (proof, vk)
-}
-
 pub fn generate_step_proof_sp1(
     ops: &ProverOps,
     commitment: [u8; 32],