Utils/parse proof (#25)

* feat: add utils for proof handling and public input management

* test: integration tests for proof parsing and public input handling

* docs: update README to include utilities for separating proof and public inputs

* fix: update combine_proof_and_public_inputs function to accept separate proof and public inputs

Author: moven0831

README.md

@@ -124,6 +124,33 @@ fn main() {
    bb write_solidity_verifier -k ./target/vk -o ./target/Verifier.sol
    ```
 
+### Proof and Public Inputs Separation
+
+Noir-rs provides utilities to separate public inputs from proof data, which is essential for constructing proper calldata for on-chain verification:
+
+```rs
+use noir::utils::{
+    parse_proof_with_public_inputs,
+    get_num_public_inputs_from_circuit,
+    combine_proof_and_public_inputs,
+};
+
+// Get the number of public inputs from your circuit
+let num_public_inputs = get_num_public_inputs_from_circuit(BYTECODE)?;
+
+// Generate proof (public inputs are concatenated at the beginning)
+let proof = prove_ultra_honk_keccak(BYTECODE, witness, vk, false, false)?;
+
+// Parse the proof into separated components
+let proof_with_public_inputs = parse_proof_with_public_inputs(&proof, num_public_inputs)?;
+
+// Access the separated proof and public inputs
+let pure_proof = &proof_with_public_inputs.proof;
+let public_inputs = &proof_with_public_inputs.public_inputs;
+
+// Use pure_proof and public_inputs for constructing calldata for Solidity verifier
+```
+
 ## Downloading SRS (Structured Reference String)
 
 Noir requires a Structured Reference String (SRS) for its operations. You can download the necessary SRS files using the `srs_downloader` utility included in the `noir` crate.

noir/src/backends/barretenberg/tests/mod.rs

@@ -3,6 +3,7 @@ use bb::barretenberg_api::{acir::{get_circuit_sizes, acir_get_slow_low_memory},
 use crate::backends::barretenberg::{srs::{setup_srs_from_bytecode, setup_srs, netsrs::NetSrs}, verify::{verify_ultra_honk, verify_ultra_honk_keccak, get_ultra_honk_verification_key, get_ultra_honk_keccak_verification_key}, prove::{prove_ultra_honk, prove_ultra_honk_keccak}, utils::compute_subgroup_size};
 use acir::{FieldElement, native_types::{Witness, WitnessMap}};
 use crate::{witness, circuit};
+mod proof_utils;
 use serde_json;
 use std::path::PathBuf;
 use std::env;
@@ -59,6 +60,7 @@ fn get_circuit_path(filename: &str) -> PathBuf {
     PathBuf::from(format!("circuits/target/{}", filename))
 }
 
+
 #[test]
 fn test_acir_get_circuit_size() {
     let (_, constraint_system_buf) = circuit::decode_circuit(BYTECODE).unwrap();

noir/src/backends/barretenberg/tests/proof_utils.rs

@@ -0,0 +1,40 @@
+use crate::utils::proof_utils::*;
+use crate::witness::from_vec_to_witness_map;
+use crate::backends::barretenberg::{
+    srs::setup_srs_from_bytecode,
+    prove::prove_ultra_honk_keccak,
+    verify::{verify_ultra_honk_keccak, get_ultra_honk_keccak_verification_key},
+};
+
+// Multiplier2 circuit bytecode
+// This circuit multiplies x * y == result with result as public input
+const MULTIPLIER2_BYTECODE: &str = "H4sIAAAAAAAA/62QQQqAMAwErfigpEna5OZXLLb/f4KKLZbiTQdCQg7Dsm66mc9x00O717rhG9ico5cgMOfoMxJu4C2pAEsKioqisnslysoaLVkEQ6aMRYxKFc//ZYQr29L10XfhXv4jB52E+OpMAQAA";
+
+#[test]
+fn test_get_num_public_inputs_multiplier2() {
+    let num_public_inputs = get_num_public_inputs_from_circuit(MULTIPLIER2_BYTECODE).unwrap();
+    
+    // Multiplier2 circuit has 1 public input: result
+    assert_eq!(num_public_inputs, 1, "Multiplier2 circuit should have 1 public inputs");
+}
+
+#[test]
+fn test_prove_and_verify_ultra_honk_keccak_multiplier2() {
+    let num_public_inputs = get_num_public_inputs_from_circuit(MULTIPLIER2_BYTECODE).unwrap();
+    assert_eq!(num_public_inputs, 1, "Multiplier2 circuit should have 1 public inputs");
+
+    setup_srs_from_bytecode(MULTIPLIER2_BYTECODE, None, false).unwrap();
+
+    let initial_witness = from_vec_to_witness_map(vec![3 as u128, 5 as u128, 15 as u128]).unwrap();
+    let vk = get_ultra_honk_keccak_verification_key(MULTIPLIER2_BYTECODE, false, false).unwrap();
+    let proof = prove_ultra_honk_keccak(MULTIPLIER2_BYTECODE, initial_witness, vk.clone(), false, false).unwrap();
+
+    // Parse the proof into separated components
+    let proof_with_public_inputs = parse_proof_with_public_inputs(&proof, num_public_inputs).unwrap();
+
+    // Combine the proof and public inputs back into a single byte vector
+    let combined_proof = combine_proof_and_public_inputs(proof_with_public_inputs.proof, proof_with_public_inputs.public_inputs);
+
+    let verdict = verify_ultra_honk_keccak(combined_proof, vk, false).unwrap();
+    assert_eq!(verdict, true, "Multiplier2 circuit should be valid");
+}

noir/src/lib.rs

@@ -3,7 +3,8 @@ pub use acvm::*;
 
 pub mod execute;
 pub mod witness;
-pub mod circuit; 
+pub mod circuit;
+pub mod utils;
 mod backends;
 
 #[cfg(feature = "barretenberg")]

noir/src/utils/mod.rs

@@ -0,0 +1,9 @@
+pub mod proof_utils;
+
+// Re-export commonly used items for convenience
+pub use proof_utils::{
+    ProofWithPublicInputs,
+    get_num_public_inputs_from_circuit,
+    parse_proof_with_public_inputs,
+    combine_proof_and_public_inputs,
+};

noir/src/utils/proof_utils.rs

@@ -0,0 +1,81 @@
+use crate::circuit::get_program;
+
+/// Struct representing a proof with separated public inputs
+#[derive(Debug, Clone)]
+pub struct ProofWithPublicInputs {
+    /// The proof without public inputs
+    pub proof: Vec<u8>,
+    /// The public inputs as an array of 32-byte values
+    pub public_inputs: Vec<Vec<u8>>,
+    /// The number of public inputs
+    pub num_public_inputs: usize,
+}
+
+/// Get the number of public inputs from a circuit's bytecode
+/// This extracts the circuit information to count public parameters
+pub fn get_num_public_inputs_from_circuit(circuit_bytecode: &str) -> Result<usize, String> {
+    let program = get_program(circuit_bytecode)
+        .map_err(|e| format!("Failed to get program: {}", e))?;
+
+    // Get the first function (main function)
+    let main_function = program.functions.first()
+        .ok_or("No functions found in program")?;
+    
+    // Count public parameters directly from the circuit
+    let num_public_inputs = main_function.public_parameters.0.len();
+
+    Ok(num_public_inputs)
+}
+
+/// Parse a combined proof (proof + public inputs) into separated components
+pub fn parse_proof_with_public_inputs(
+    combined_proof: &[u8], 
+    num_public_inputs: usize
+) -> Result<ProofWithPublicInputs, String> {
+    let public_inputs_size = num_public_inputs * 32; // Each field element is 32 bytes
+    
+    if combined_proof.len() < public_inputs_size {
+        return Err(format!(
+            "Combined proof too small: {} bytes, expected at least {} bytes for {} public inputs", 
+            combined_proof.len(), 
+            public_inputs_size,
+            num_public_inputs
+        ));
+    }
+    
+    // Public inputs are at the beginning of the combined proof
+    let public_inputs_bytes = combined_proof[..public_inputs_size].to_vec();
+    let proof_data = combined_proof[public_inputs_size..].to_vec();
+    
+    if proof_data.len() % 32 != 0 {
+        return Err("Proof data must be a multiple of 32 bytes".to_string());
+    }
+
+    let public_inputs: Vec<Vec<u8>> = public_inputs_bytes
+        .chunks(32)
+        .map(|chunk| chunk.to_vec())
+        .collect();
+    
+    Ok(ProofWithPublicInputs {
+        proof: proof_data,
+        public_inputs: public_inputs,
+        num_public_inputs,
+    })
+}
+
+/// Combine proof and public inputs back into a single proof with public inputs
+pub fn combine_proof_and_public_inputs(
+    proof: Vec<u8>,
+    public_inputs: Vec<Vec<u8>>,
+) -> Vec<u8> {
+    let mut combined = Vec::new();
+    
+    // Add public inputs first (32 bytes each)
+    for public_input in &public_inputs {
+        combined.extend_from_slice(public_input);
+    }
+
+    combined.extend_from_slice(&proof);
+    
+    combined
+}