Consumption of prover state in the prover_response function

Author: nougzarm

src/toolbox/sigma/fiat_shamir.rs

@@ -43,7 +43,7 @@ where
             .verifier_challenge();
         println!("Prover's challenge : {:?}", challenge);
         // Prouver's response
-        let response = self.sigmap.prover_response(&prover_state, &challenge);
+        let response = self.sigmap.prover_response(prover_state, &challenge);
         // Local verification of the proof
         assert!(self.sigmap.verifier(&commitment, &challenge, &response) == Ok(()));
         self.sigmap.serialize_batchable(&commitment, &challenge, &response)

src/toolbox/sigma/proof_composition.rs

@@ -46,12 +46,12 @@ where
 
     fn prover_response(
             &self,
-            state: &Self::ProverState,
+            state: Self::ProverState,
             challenge: &Self::Challenge,
         ) -> Self::Response {
             // Compute responses
-            let response0 = self.protocol0.prover_response(&state.0, challenge);
-            let response1 = self.protocol1.prover_response(&state.1, challenge);
+            let response0 = self.protocol0.prover_response(state.0, challenge);
+            let response1 = self.protocol1.prover_response(state.1, challenge);
 
             (response0, response1)
     }
@@ -147,26 +147,27 @@ where
 
     fn prover_response(
         &self,
-        state: &Self::ProverState,
+        state: Self::ProverState,
         challenge: &Self::Challenge,
     ) -> Self::Response {
+        // let state = (real index, real prover state, fakee transcription)
         let (_ , r_pr_st, f_trnsc) = state;
 
         // Compute the real challenge
-        let r_challenge = match *f_trnsc {
+        let r_challenge = match &f_trnsc {
             OrTranscription::Left(OrState(ch, _)) => *challenge - ch,
             OrTranscription::Right(OrState(ch, _)) => *challenge - ch,
         };
 
         match (r_pr_st, f_trnsc) {
-            (OrEnum::Left(ref r_prover_state), OrTranscription::Right(OrState(_, f_response))) => {
+            (OrEnum::Left(r_prover_state), OrTranscription::Right(OrState(_, f_response))) => {
                 let r_response = self.protocol0.prover_response(r_prover_state, &r_challenge);
                 (r_challenge, r_response, f_response.clone())
 
             },
-            (OrEnum::Right(ref r_prover_state), OrTranscription::Left(OrState(f_ch, f_response))) => {
+            (OrEnum::Right(r_prover_state), OrTranscription::Left(OrState(f_ch, f_response))) => {
                 let r_response = self.protocol1.prover_response(r_prover_state, &r_challenge);
-                (*f_ch, f_response.clone(), r_response)
+                (f_ch, f_response.clone(), r_response)
             },
             _ => panic!("Incoherence between real prover state and fake transcription"),
         }

src/toolbox/sigma/schnorr_proof.rs

@@ -41,7 +41,7 @@ where
 
     fn prover_response(
         &self,
-        state: &Self::ProverState,
+        state: Self::ProverState,
         challenge: &Self::Challenge,
     ) -> Self::Response {
         let mut responses = Vec::new();

src/toolbox/sigma/trait.rs

@@ -16,7 +16,7 @@ pub trait SigmaProtocol {
 
     fn prover_response(
         &self,
-        state: &Self::ProverState,
+        state: Self::ProverState,
         challenge: &Self::Challenge,
     ) -> Self::Response;
 

tests/proof_composition_test.rs

@@ -27,10 +27,10 @@ impl SigmaProtocol for SchnorrZkp {
 
     fn prover_response(
             &self,
-            state: &Self::ProverState,
+            state: Self::ProverState,
             challenge: &Self::Challenge,
         ) -> Self::Response {
-        let (r,x) = *state ;
+        let (r,x) = state ;
         challenge * x + r
     }
 
@@ -93,7 +93,7 @@ fn andproof_schnorr_correct() {
     let challenge = Scalar::random(&mut rng);
 
     // Prover computes responses
-    let responses = and_proof.prover_response(&states, &challenge);
+    let responses = and_proof.prover_response(states, &challenge);
 
     // Verifier checks
     let result = and_proof.verifier(&commitments, &challenge, &responses);
@@ -130,7 +130,7 @@ fn andproof_schnorr_incorrect() {
     let challenge = Scalar::random(&mut rng);
 
     // Prover computes responses
-    let responses = and_proof.prover_response(&states, &challenge);
+    let responses = and_proof.prover_response(states, &challenge);
 
     // Verifier checks
     let result = and_proof.verifier(&commitments, &challenge, &responses);
@@ -165,7 +165,7 @@ fn orproof_schnorr_correct() {
     let challenge = Scalar::random(&mut rng);
 
     // Prover computes responses
-    let responses = or_proof.prover_response(&states, &challenge);
+    let responses = or_proof.prover_response(states, &challenge);
 
     // Verifier checks
     let result = or_proof.verifier(&commitments, &challenge, &responses);
@@ -200,7 +200,7 @@ fn orproof_schnorr_incorrect() {
     let challenge = Scalar::random(&mut rng);
 
     // Prover computes responses
-    let responses = or_proof.prover_response(&states, &challenge);
+    let responses = or_proof.prover_response(states, &challenge);
 
     // Verifier checks
     let result = or_proof.verifier(&commitments, &challenge, &responses);