starknet_transaction_prover: bump stwo - compressed proofs (#13397)

Author: avi-starkware

Cargo.lock

@@ -324,8 +324,8 @@ paste = "1.0.15"
 phf = "0.11"
 pretty_assertions = "1.4.0"
 primitive-types = "0.12.1"
-privacy-circuit-verify = { git = "https://github.com/starkware-libs/proving-utils", rev = "6f12ca27842b3f93078830863b4582d5af8a3339" }
-privacy-prove = { git = "https://github.com/starkware-libs/proving-utils", rev = "6f12ca27842b3f93078830863b4582d5af8a3339" }
+privacy-circuit-verify = { git = "https://github.com/starkware-libs/proving-utils", rev = "dbc39e745d23424f1997ce3505ce5f83805cefde" }
+privacy-prove = { git = "https://github.com/starkware-libs/proving-utils", rev = "dbc39e745d23424f1997ce3505ce5f83805cefde" }
 proc-macro2 = "1.0"
 prometheus-parse = "0.2.4"
 prost = "0.12.1"

Cargo.toml

@@ -3,6 +3,7 @@
 use std::sync::Arc;
 
 use apollo_sizeof::SizeOf;
+use privacy_circuit_verify::{verify_recursive_circuit, PrivacyProofOutput};
 use serde::{Deserialize, Serialize};
 use starknet_api::transaction::fields::{Proof, ProofFacts, PROOF_VERSION};
 use starknet_types_core::felt::Felt;
@@ -18,9 +19,6 @@ pub enum VerifyProofError {
     InvalidProofVersion { expected: Felt, actual: Felt },
     #[error("Proof facts too short: expected at least 3 elements, got {length}.")]
     ProofFactsTooShort { length: usize },
-    // TODO(AvivG): Remove this once PrivacyProofOutput holds u8 proof.
-    #[error("Proof byte length {0} is not a multiple of 4.")]
-    InvalidProofLength(usize),
     #[error("Proof verification failed: {0}")]
     Verification(String),
 }
@@ -34,7 +32,6 @@ impl PartialEq for VerifyProofError {
                 Self::InvalidProofVersion { expected: exp_l, actual: act_l },
                 Self::InvalidProofVersion { expected: exp_r, actual: act_r },
             ) => exp_l == exp_r && act_l == act_r,
-            (Self::InvalidProofLength(lhs), Self::InvalidProofLength(rhs)) => lhs == rhs,
             (Self::Verification(lhs), Self::Verification(rhs)) => lhs == rhs,
             (Self::ProofFactsTooShort { length: l }, Self::ProofFactsTooShort { length: r }) => {
                 l == r
@@ -140,14 +137,9 @@ pub fn verify_proof(proof_facts: ProofFacts, proof: Proof) -> Result<(), VerifyP
 
     // Reconstruct the output preimage from proof facts and verify the proof.
     let output_preimage = reconstruct_output_preimage(&proof_facts)?;
-    // TODO(AvivG): this conversion is temporary until PrivacyProofOutput holds u8 proof.
-    let (chunks, []) = proof.0.as_chunks::<4>() else {
-        return Err(VerifyProofError::InvalidProofLength(proof.0.len()));
-    };
-    let proof_u32s: Vec<u32> = chunks.iter().map(|c| u32::from_be_bytes(*c)).collect();
-    let proof_output =
-        privacy_circuit_verify::PrivacyProofOutput { proof: proof_u32s, output_preimage };
-    privacy_circuit_verify::verify_recursive_circuit(&proof_output)
+    // TODO(Avi): Avoid cloning the proof.
+    let proof_output = PrivacyProofOutput { proof: proof.0.to_vec(), output_preimage };
+    verify_recursive_circuit(&proof_output)
         .map_err(|e| VerifyProofError::Verification(e.to_string()))?;
 
     Ok(())

crates/apollo_transaction_converter/resources/example_proof.bin

@@ -34,9 +34,7 @@ pub(crate) async fn prove(
     .map_err(ProvingError::TaskJoin)?
     .map_err(ProvingError::ProverExecution)?;
 
-    // TODO(AvivG): this conversion is temporary until PrivacyProofOutput holds u8 proof.
-    let proof_bytes: Vec<u8> = proof_output.proof.iter().flat_map(|n| n.to_be_bytes()).collect();
-    let proof = Proof::from(proof_bytes);
+    let proof = Proof::from(proof_output.proof);
     let program_output = ProgramOutput::from(proof_output.output_preimage);
 
     Ok(ProverOutput { proof, program_output })

crates/starknet_proof_verifier/src/proof_verifier.rs

@@ -3,6 +3,7 @@ use std::sync::Arc;
 
 use apollo_infra_utils::path::resolve_project_relative_path;
 use cairo_vm::vm::runners::cairo_pie::CairoPie;
+use privacy_circuit_verify::{verify_recursive_circuit, PrivacyProofOutput};
 use privacy_prove::{prepare_recursive_prover_precomputes, RecursiveProverPrecomputes};
 use starknet_api::transaction::fields::VIRTUAL_SNOS;
 use starknet_proof_verifier::ProgramOutput;
@@ -46,15 +47,8 @@ async fn test_prove_cairo_pie_10_transfers() {
 
     // Verify the proof using the circuit verifier.
     let output_preimage: Vec<starknet_types_core::felt::Felt> = output.program_output.0.to_vec();
-    // TODO(AvivG): this conversion is temporary until PrivacyProofOutput holds u8 proof.
-    let (chunks, []) = output.proof.0.as_chunks::<4>() else {
-        panic!("Proof byte length {} is not a multiple of 4", output.proof.0.len());
-    };
-    let proof_u32s: Vec<u32> = chunks.iter().map(|c| u32::from_be_bytes(*c)).collect();
-    let proof_output =
-        privacy_circuit_verify::PrivacyProofOutput { proof: proof_u32s, output_preimage };
-    privacy_circuit_verify::verify_recursive_circuit(&proof_output)
-        .expect("Failed to verify proof");
+    let proof_output = PrivacyProofOutput { proof: output.proof.0.to_vec(), output_preimage };
+    verify_recursive_circuit(&proof_output).expect("Failed to verify proof");
 
     // Read expected program output.
     let expected_program_output_str = fs::read_to_string(&expected_program_output_path)

crates/starknet_transaction_prover/src/proving/prover.rs

@@ -10,6 +10,8 @@ use std::time::Instant;
 use blockifier::state::contract_class_manager::ContractClassManager;
 use blockifier_reexecution::state_reader::rpc_objects::BlockId;
 use blockifier_reexecution::utils::get_chain_info;
+#[cfg(feature = "stwo_proving")]
+use privacy_prove::{prepare_recursive_prover_precomputes, RecursiveProverPrecomputes};
 use serde::{Deserialize, Serialize};
 use starknet_api::rpc_transaction::{RpcInvokeTransaction, RpcInvokeTransactionV3, RpcTransaction};
 use starknet_api::transaction::fields::{Fee, Proof, ProofFacts, ValidResourceBounds};
@@ -49,7 +51,7 @@ pub(crate) struct VirtualSnosProver<R: VirtualSnosRunner> {
     validate_zero_fee_fields: bool,
     /// Precomputed data for the recursive prover, prepared once at startup.
     #[cfg(feature = "stwo_proving")]
-    precomputes: Arc<privacy_prove::RecursiveProverPrecomputes>,
+    precomputes: Arc<RecursiveProverPrecomputes>,
 }
 
 /// Type alias for the RPC-based virtual SNOS prover.
@@ -73,7 +75,7 @@ impl VirtualSnosProver<RpcRunnerFactory> {
             prover_config.runner_config.clone(),
         );
         #[cfg(feature = "stwo_proving")]
-        let precomputes = privacy_prove::prepare_recursive_prover_precomputes()
+        let precomputes = prepare_recursive_prover_precomputes()
             .expect("Failed to prepare recursive prover precomputes");
         Self {
             runner,
@@ -91,7 +93,7 @@ impl<R: VirtualSnosRunner> VirtualSnosProver<R> {
     #[allow(dead_code)]
     pub(crate) fn from_runner(runner: R) -> Self {
         #[cfg(feature = "stwo_proving")]
-        let precomputes = privacy_prove::prepare_recursive_prover_precomputes()
+        let precomputes = prepare_recursive_prover_precomputes()
             .expect("Failed to prepare recursive prover precomputes");
         Self {
             runner,