tmp

Author: tizoc

ledger/src/proofs/accumulator_check.rs

@@ -7,40 +7,77 @@ use poly_commitment::{commitment::CommitmentCurve, srs::SRS};
 use super::public_input::scalar_challenge::ScalarChallenge;
 use super::urs_utils;
 
+/*
+  let%bind accumulator_check =
+    Ipa.Step.accumulator_check
+      (List.map ts ~f:(fun (T (_, _, _, _, _, T t)) ->
+           ( t.statement.proof_state.messages_for_next_wrap_proof
+               .challenge_polynomial_commitment
+           , Ipa.Step.compute_challenges
+               t.statement.proof_state.deferred_values.bulletproof_challenges ) )
+      )
+
+
+  let accumulator_check comm_chals =
+      let chals =
+        Array.concat
+        @@ List.map comm_chals ~f:(fun (_, chals) -> Vector.to_array chals)
+      in
+      let comms =
+        Array.of_list_map comm_chals ~f:(fun (comm, _) ->
+            Or_infinity.Finite comm )
+      in
+      let urs = Backend.Tick.Keypair.load_urs () in
+      Promise.run_in_thread (fun () ->
+          Kimchi_bindings.Protocol.SRS.Fp.batch_accumulator_check urs
+            (Array.map comms ~f:or_infinite_conv)
+            chals )
+*/
+
 pub fn accumulator_check(
     urs: &SRS<Vesta>,
-    proof: &PicklesProofProofsVerified2ReprStableV2,
+    proofs: &[&PicklesProofProofsVerified2ReprStableV2],
 ) -> Result<bool, InvalidBigInt> {
     // accumulator check
     // Note:
     // comms: statement.proof_state.messages_for_next_wrap_proof.challenge_polynomial_commitment
     // chals: statement.proof_state.deferred_values.bulletproof_challenges
 
-    let deferred_values = &proof.statement.proof_state.deferred_values;
-    let bulletproof_challenges = &deferred_values.bulletproof_challenges;
-    let bulletproof_challenges: Vec<Fp> = bulletproof_challenges
-        .iter()
-        .map(|chal| {
-            let prechallenge = &chal.prechallenge.inner;
-            let prechallenge: [u64; 2] = prechallenge.each_ref().map(|c| c.as_u64());
-
-            ScalarChallenge::limbs_to_field(&prechallenge)
-        })
-        .collect();
-
-    let of_coord =
-        |(x, y): &(BigInt, BigInt)| Ok(Vesta::of_coordinates(x.to_field()?, y.to_field()?));
-
-    // statement.proof_state.messages_for_next_wrap_proof.challenge_polynomial_commitment
-    let acc_comm = &proof
-        .statement
-        .proof_state
-        .messages_for_next_wrap_proof
-        .challenge_polynomial_commitment;
-    let acc_comm: Vesta = of_coord(acc_comm)?;
-
-    let acc_check =
-        urs_utils::batch_dlog_accumulator_check(urs, &[acc_comm], &bulletproof_challenges);
+    let mut comms = Vec::with_capacity(proofs.len());
+    let mut bulletproof_challenges = vec![];
+
+    for proof in proofs {
+        let bp_chals = &proof
+            .statement
+            .proof_state
+            .deferred_values
+            .bulletproof_challenges;
+        let mut bp_chals: Vec<Fp> = bp_chals
+            .iter()
+            .map(|chal| {
+                let prechallenge = &chal.prechallenge.inner;
+                let prechallenge: [u64; 2] = prechallenge.each_ref().map(|c| c.as_u64());
+
+                ScalarChallenge::limbs_to_field(&prechallenge)
+            })
+            .collect();
+        bulletproof_challenges.append(&mut bp_chals);
+
+        let of_coord =
+            |(x, y): &(BigInt, BigInt)| Ok(Vesta::of_coordinates(x.to_field()?, y.to_field()?));
+
+        // statement.proof_state.messages_for_next_wrap_proof.challenge_polynomial_commitment
+        let acc_comm = &proof
+            .statement
+            .proof_state
+            .messages_for_next_wrap_proof
+            .challenge_polynomial_commitment;
+        let acc_comm: Vesta = of_coord(acc_comm)?;
+
+        comms.push(acc_comm);
+    }
+
+    let acc_check = urs_utils::batch_dlog_accumulator_check(urs, &comms, &bulletproof_challenges);
 
     if !acc_check {
         println!("accumulator_check failed");

ledger/src/proofs/verification.rs

@@ -746,7 +746,7 @@ pub fn verify_block(
     let protocol_state_hash = MinaHash::hash(&protocol_state);
 
     let accum_check =
-        accumulator_check::accumulator_check(srs, protocol_state_proof).unwrap_or(false);
+        accumulator_check::accumulator_check(srs, &[protocol_state_proof]).unwrap_or(false);
     let verified = verify_impl(&protocol_state_hash, protocol_state_proof, &vk).unwrap_or(false);
 
     accum_check && verified
@@ -768,16 +768,20 @@ pub fn verify_transaction<'a>(
         &PicklesProofProofsVerified2ReprStableV2,
         &VK,
     )> = Vec::with_capacity(128);
-    let mut accum_check = true;
+
+    let mut accum_check_proofs: Vec<&PicklesProofProofsVerified2ReprStableV2> =
+        Vec::with_capacity(128);
 
     proofs
         .into_iter()
         .for_each(|(statement, transaction_proof)| {
-            accum_check = accum_check
-                && accumulator_check::accumulator_check(srs, transaction_proof).unwrap_or(false);
+            accum_check_proofs.push(transaction_proof);
             inputs.push((statement, transaction_proof, &vk));
         });
 
+    let accum_check =
+        accumulator_check::accumulator_check(srs, &accum_check_proofs).unwrap_or(false);
+
     let verified = batch_verify_impl(inputs.as_slice()).unwrap_or(false);
     accum_check && verified
 }
@@ -797,7 +801,8 @@ pub fn verify_zkapp(
         data: (),
     };
 
-    let accum_check = accumulator_check::accumulator_check(srs, sideloaded_proof).unwrap_or(false);
+    let accum_check =
+        accumulator_check::accumulator_check(srs, &[sideloaded_proof]).unwrap_or(false);
     let verified = verify_impl(&zkapp_statement, sideloaded_proof, &vk).unwrap_or(false);
 
     let ok = accum_check && verified;