cargo fmt

Author: mmaker

src/composition.rs

@@ -80,7 +80,12 @@ pub enum ComposedProverState<G: PrimeGroup + ConstantTimeEq> {
 }
 
 struct ComposedOrProverState<G: PrimeGroup + ConstantTimeEq> {
-    prover_states: Vec<(Choice, ComposedProverState<G>, ComposedChallenge<G>, ComposedResponse<G>)>,
+    prover_states: Vec<(
+        Choice,
+        ComposedProverState<G>,
+        ComposedChallenge<G>,
+        ComposedResponse<G>,
+    )>,
 }
 
 // Structure representing the Response type of Protocol as SigmaProtocol
@@ -105,7 +110,6 @@ const fn composed_challenge_size<G: PrimeGroup>() -> usize {
     (G::Scalar::NUM_BITS as usize + 7) / 8
 }
 
-
 impl<G: PrimeGroup + ConstantTimeEq> ComposedRelation<G> {
     fn is_witness_valid(&self, witness: &ComposedWitness<G>) -> Choice {
         let validity_bit = Choice::from(0);
@@ -212,18 +216,24 @@ impl<G: PrimeGroup + ConstantTimeEq> ComposedRelation<G> {
                 instances[i].simulate_transcript(rng)?;
 
             let valid_witness = instances[i].is_witness_valid(&w);
-            commitments.push(if valid_witness.unwrap_u8() == 1 {commitment } else { simulated_commitment.clone()} );
-            prover_states.push((valid_witness, prover_state, simulated_challenge, simulated_response));
+            commitments.push(if valid_witness.unwrap_u8() == 1 {
+                commitment
+            } else {
+                simulated_commitment.clone()
+            });
+            prover_states.push((
+                valid_witness,
+                prover_state,
+                simulated_challenge,
+                simulated_response,
+            ));
         }
         // check that we have only one witness set
         let witnesses_found = prover_states
             .iter()
             .map(|x| x.0.unwrap_u8() as usize)
             .sum::<usize>();
-        let prover_state =
-            ComposedOrProverState {
-                prover_states,
-            };
+        let prover_state = ComposedOrProverState { prover_states };
 
         if witnesses_found > 1 {
             return Err(Error::InvalidInstanceWitnessPair);
@@ -246,17 +256,33 @@ impl<G: PrimeGroup + ConstantTimeEq> ComposedRelation<G> {
         let ComposedOrProverState { prover_states } = prover_state;
 
         let mut witness_challenge = challenge;
-        for (valid_witness, _prover_state, simulated_challenge, _simulated_response) in &prover_states {
-            let c = G::Scalar::conditional_select(&G::Scalar::ZERO, &simulated_challenge, *valid_witness);
+        for (valid_witness, _prover_state, simulated_challenge, _simulated_response) in
+            &prover_states
+        {
+            let c = G::Scalar::conditional_select(
+                &G::Scalar::ZERO,
+                &simulated_challenge,
+                *valid_witness,
+            );
             witness_challenge -= c;
         }
-        for (instance, (valid_witness, prover_state, simulated_challenge, simulated_response)) in instances.iter().zip(prover_states) {
-            let challenge_i = G::Scalar::conditional_select(&witness_challenge, &simulated_challenge, valid_witness);
+        for (instance, (valid_witness, prover_state, simulated_challenge, simulated_response)) in
+            instances.iter().zip(prover_states)
+        {
+            let challenge_i = G::Scalar::conditional_select(
+                &witness_challenge,
+                &simulated_challenge,
+                valid_witness,
+            );
 
             let real_response = instance.prover_response(prover_state, &challenge_i)?;
 
             // let response_i = ComposedResponse::conditional_select(&real_response, &simulated_response, *witness_location);
-            let response_i = if valid_witness.unwrap_u8() == 1 { real_response } else { simulated_response };
+            let response_i = if valid_witness.unwrap_u8() == 1 {
+                real_response
+            } else {
+                simulated_response
+            };
             result_challenges.push(challenge_i);
             result_responses.push(response_i);
         }