Update to work with airbender

This PR updates the entire codebase to work with airbender (instead of
old air_compiler). Additionally, makes `prove` function publicly
available (to be later used in snark proving for zksync-os). The split
to public is dirty.

Author: EmilLuta

Cargo.toml

@@ -22,11 +22,11 @@ rescue_poseidon = { git = "https://github.com/matter-labs/zksync-crypto.git", pa
 # rescue_poseidon = { path = "../zksync-crypto/crates/rescue-poseidon"}
 snark_wrapper = { git = "https://github.com/matter-labs/zksync-crypto.git", package="snark_wrapper", branch = "main" }
 # snark_wrapper = { path = "../zksync-crypto/crates/snark-wrapper"}
-risc_verifier = {git="https://github.com/matter-labs/air_compiler.git", package="final_reduced_risc_v_machine_verifier", features=["proof_utils"], branch="main"}
+risc_verifier = {git="https://github.com/matter-labs/zksync-airbender.git", package="final_reduced_risc_v_machine_verifier", features=["proof_utils"], branch="main"}
 # risc_verifier = {path="../air_compiler/circuit_defs/final_reduced_risc_v_machine/verifier", package="final_reduced_risc_v_machine_verifier", features=["proof_utils"]}
-execution_utils = {git="https://github.com/matter-labs/air_compiler.git", package="execution_utils", branch="main"}
+execution_utils = {git="https://github.com/matter-labs/zksync-airbender.git", package="execution_utils", branch="main"}
 # execution_utils = {path="../air_compiler/execution_utils"}
-setups = {git="https://github.com/matter-labs/air_compiler.git", package="setups", branch="main"}
+setups = {git="https://github.com/matter-labs/zksync-airbender.git", package="setups", branch="main"}
 # setups = {path="../../air_compiler/circuit_defs/setups"}
 circuit_mersenne_field = {path="circuit_mersenne_field"}
 serde_json = { version = "*" }

circuit_mersenne_field/Cargo.toml

@@ -6,6 +6,6 @@ edition = "2021"
 [dependencies]
 boojum = { git = "https://github.com/matter-labs/zksync-crypto.git", package="boojum", branch = "main" }
 # boojum = { path = "../../zksync-crypto/crates/boojum"}
-mersenne_field = {git="https://github.com/matter-labs/air_compiler.git", package="field", branch="main"}
+mersenne_field = {git="https://github.com/matter-labs/zksync-airbender.git", package="field", branch="main"}
 # mersenne_field = {path="../../air_compiler/field", package="field"}
 rand = "0.8"

src/lib.rs

@@ -11,6 +11,8 @@ pub mod wrapper_utils;
 #[cfg(test)]
 mod tests;
 
+use std::alloc::Global;
+use std::path::Path;
 use boojum::algebraic_props::round_function::AbsorptionModeOverwrite;
 use boojum::algebraic_props::sponge::GoldilocksPoseidon2Sponge;
 use boojum::config::{DevCSConfig, ProvingCSConfig, SetupCSConfig};
@@ -93,7 +95,7 @@ pub type SnarkWrapperTranscript =
     bellman::plonk::commitments::transcript::keccak_transcript::RollingKeccakTranscript<Fr>;
 
 pub use execution_utils::ProgramProof;
-
+use execution_utils::{final_recursion_layer_verifier_vk, recursion_layer_no_delegation_verifier_vk, recursion_layer_verifier_vk, universal_circuit_no_delegation_verifier_vk, universal_circuit_verifier_vk};
 //CircuitAlgebraicSpongeBasedTranscript<GoldilocksField, 8, 12, 4, R>,
 
 // RiscV -> Stark Wrapper
@@ -459,3 +461,191 @@ pub fn calculate_verification_key_hash(verification_key: SnarkWrapperVK) -> H256
 
     H256::from_slice(&computed_vk_hash)
 }
+
+/// Uploads trusted setup file to the RAM
+pub fn get_trusted_setup(crs_file_str: &String) -> Crs<Bn256, CrsForMonomialForm> {
+    let crs_file_path = std::path::Path::new(crs_file_str);
+    let crs_file = std::fs::File::open(&crs_file_path)
+        .expect(format!("Trying to open CRS FILE: {:?}", crs_file_path).as_str());
+    Crs::read(&crs_file).expect(format!("Trying to read CRS FILE: {:?}", crs_file_path).as_str())
+}
+
+pub fn serialize_to_file<T: serde::ser::Serialize>(content: &T, filename: &Path) {
+    let src = std::fs::File::create(filename).unwrap();
+    serde_json::to_writer_pretty(src, content).unwrap();
+}
+
+fn deserialize_from_file<T: serde::de::DeserializeOwned>(filename: &str) -> T {
+    let src = std::fs::File::open(filename).unwrap();
+    serde_json::from_reader(src).unwrap()
+}
+
+pub fn create_binary_commitment(
+    binary_path: String,
+    expected_end_params: &[u32; 8],
+) -> BinaryCommitment {
+    let bin = std::fs::read(binary_path).unwrap();
+
+    let worker = risc_verifier::prover::worker::Worker::new_with_num_threads(8);
+
+    let expected_final_pc = execution_utils::find_binary_exit_point(&bin);
+    let binary: Vec<u32> = execution_utils::get_padded_binary(&bin);
+
+    let base_params = execution_utils::compute_end_parameters(
+        expected_final_pc,
+        &setups::get_main_riscv_circuit_setup::<Global, Global>(&binary, &worker),
+    );
+
+    // Check which verifier was used.
+    if universal_circuit_no_delegation_verifier_vk().params == *expected_end_params {
+        let layers = vec![
+            [0u32; 8],
+            base_params,
+            universal_circuit_verifier_vk().params,
+            universal_circuit_no_delegation_verifier_vk().params,
+        ];
+        BinaryCommitment {
+            end_params: universal_circuit_no_delegation_verifier_vk().params,
+            aux_params: execution_utils::compute_chain_encoding(layers),
+        }
+    } else if final_recursion_layer_verifier_vk().params == *expected_end_params {
+        let layers = vec![
+            [0u32; 8],
+            base_params,
+            recursion_layer_verifier_vk().params,
+            recursion_layer_no_delegation_verifier_vk().params,
+            final_recursion_layer_verifier_vk().params,
+        ];
+        BinaryCommitment {
+            end_params: final_recursion_layer_verifier_vk().params,
+            aux_params: execution_utils::compute_chain_encoding(layers),
+        }
+    } else {
+        panic!(
+            "Cannot find a verifier for the proof end parameters: {:?}",
+            expected_end_params
+        );
+    }
+}
+
+pub fn prove(
+    input: String,
+    input_binary: Option<String>,
+    output_dir: String,
+    trusted_setup_file: Option<String>,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let crs_mons = match trusted_setup_file {
+        Some(ref crs_file_str) => get_trusted_setup(crs_file_str),
+        None => Crs::<Bn256, CrsForMonomialForm>::crs_42(
+            1 << L1_VERIFIER_DOMAIN_SIZE_LOG,
+            &BellmanWorker::new(),
+        ),
+    };
+
+    println!("=== Phase 1: Creating the Risc wrapper proof");
+
+    let worker = boojum::worker::Worker::new_with_num_threads(4);
+
+    let program_proof: crate::ProgramProof = deserialize_from_file(&input);
+    let binary_commitment = match input_binary {
+        Some(binary_path) => create_binary_commitment(binary_path, &program_proof.end_params),
+        None => BinaryCommitment::from_default_binary(),
+    };
+    let risc_wrapper_witness =
+        RiscWrapperWitness::from_full_proof(program_proof, &binary_commitment);
+
+    let (
+        finalization_hint,
+        setup_base,
+        setup,
+        risc_wrapper_vk,
+        setup_tree,
+        vars_hint,
+        witness_hints,
+    ) = get_risc_wrapper_setup(&worker, binary_commitment.clone());
+
+    let risc_wrapper_proof = prove_risc_wrapper(
+        risc_wrapper_witness,
+        &finalization_hint,
+        &setup_base,
+        &setup,
+        &risc_wrapper_vk,
+        &setup_tree,
+        &vars_hint,
+        &witness_hints,
+        &worker,
+        binary_commitment,
+    );
+    let is_valid = verify_risc_wrapper_proof(&risc_wrapper_proof, &risc_wrapper_vk);
+
+    assert!(is_valid);
+
+    serialize_to_file(
+        &risc_wrapper_proof,
+        &Path::new(&output_dir.clone()).join("risc_proof.json"),
+    );
+
+    println!("=== Phase 2: Creating compression proof");
+
+    let (
+        finalization_hint,
+        setup_base,
+        setup,
+        compression_vk,
+        setup_tree,
+        vars_hint,
+        witness_hints,
+    ) = get_compression_setup(risc_wrapper_vk.clone(), &worker);
+    let compression_proof = prove_compression(
+        risc_wrapper_proof,
+        risc_wrapper_vk,
+        &finalization_hint,
+        &setup_base,
+        &setup,
+        &compression_vk,
+        &setup_tree,
+        &vars_hint,
+        &witness_hints,
+        &worker,
+    );
+    let is_valid = verify_compression_proof(&compression_proof, &compression_vk);
+
+    assert!(is_valid);
+
+    serialize_to_file(
+        &compression_proof,
+        &Path::new(&output_dir.clone()).join("compression_proof.json"),
+    );
+
+    println!("=== Phase 3: Creating SNARK proof");
+
+    {
+        let worker = BellmanWorker::new_with_cpus(4);
+
+        let (snark_setup, snark_wrapper_vk) =
+            get_snark_wrapper_setup(compression_vk.clone(), &crs_mons, &worker);
+
+        let snark_wrapper_proof = prove_snark_wrapper(
+            compression_proof,
+            compression_vk,
+            &snark_setup,
+            &crs_mons,
+            &worker,
+        );
+
+        let is_valid = verify_snark_wrapper_proof(&snark_wrapper_proof, &snark_wrapper_vk);
+
+        assert!(is_valid);
+
+        serialize_to_file(
+            &snark_wrapper_proof,
+            &Path::new(&output_dir.clone()).join("snark_proof.json"),
+        );
+        serialize_to_file(
+            &snark_wrapper_vk,
+            &Path::new(&output_dir.clone()).join("snark_vk.json"),
+        );
+    }
+
+    Ok(())
+}