Reduce allocations and some general code improvements (#26)

* Remove unnecessary paths

* Remove unnecessary conversion for `G::from_scalar_slice`

* Remove unnecessary allocations

* Return `GenericArray` from `get_context_string`

* Use `zip()` instead instead of indexing

* Changed `compute_composites` input to `Iterator`s

* Changed `generate_proof` input to `Iterator`s

* Changed `verify_proof` input to `Iterator`s

* Reduce allocations in `verifiable_unblind`

* Changed `verifiable_unblind` input to `Iterator`s

* Changed `batch_finalize` input to `Iterator`s
Removed `BatchFinalizeInput`

* Reduce allocations in `VerifiableClient::finalize`

* Changed `finalize_after_unblind` input to `Iterator`s

* Changed `batch_evaluate` input to `Iterator`s

* Reduce allocations in `evaluate`

* Changed `blind` input to `Into<Vec<u8>>`

* Remove note about `BatchFinalizeInput` from documentation

* Remove `Metadata`

* Changed `blind` input to `Vec<u8>`

* General improvements to test code

* Fix rustdoc

* Remove unnecessarily installed components

src/tests/voprf_test_vectors.rs

@@ -10,8 +10,8 @@ use crate::{
     group::Group,
     tests::{mock_rng::CycleRng, parser::*},
     voprf::{
-        BatchFinalizeInput, BlindedElement, EvaluationElement, Metadata, NonVerifiableClient,
-        NonVerifiableServer, Proof, VerifiableClient, VerifiableServer,
+        BlindedElement, EvaluationElement, NonVerifiableClient, NonVerifiableServer, Proof,
+        VerifiableClient, VerifiableServer,
     },
 };
 use alloc::string::ToString;
@@ -174,7 +174,8 @@ fn test_base_blind<G: Group, H: BlockInput + Digest>(
     for parameters in tvs {
         for i in 0..parameters.input.len() {
             let mut rng = CycleRng::new(parameters.blind[i].to_vec());
-            let client_result = NonVerifiableClient::<G, H>::blind(&parameters.input[i], &mut rng)?;
+            let client_result =
+                NonVerifiableClient::<G, H>::blind(parameters.input[i].clone(), &mut rng)?;
 
             assert_eq!(
                 &parameters.blind[i],
@@ -197,7 +198,7 @@ fn test_verifiable_blind<G: Group, H: BlockInput + Digest>(
         for i in 0..parameters.input.len() {
             let mut rng = CycleRng::new(parameters.blind[i].to_vec());
             let client_blind_result =
-                VerifiableClient::<G, H>::blind(&parameters.input[i], &mut rng)?;
+                VerifiableClient::<G, H>::blind(parameters.input[i].clone(), &mut rng)?;
 
             assert_eq!(
                 &parameters.blind[i],
@@ -221,7 +222,7 @@ fn test_base_evaluate<G: Group, H: BlockInput + Digest>(
             let server = NonVerifiableServer::<G, H>::new_with_key(&parameters.sksm)?;
             let server_result = server.evaluate(
                 BlindedElement::deserialize(&parameters.blinded_element[i])?,
-                &Metadata(parameters.info.clone()),
+                Some(&parameters.info),
             )?;
 
             assert_eq!(
@@ -245,11 +246,8 @@ fn test_verifiable_evaluate<G: Group, H: BlockInput + Digest>(
             blinded_elements.push(BlindedElement::deserialize(blinded_element_bytes)?);
         }
 
-        let batch_evaluate_result = server.batch_evaluate(
-            &mut rng,
-            &blinded_elements,
-            &Metadata(parameters.info.clone()),
-        )?;
+        let batch_evaluate_result =
+            server.batch_evaluate(&mut rng, &blinded_elements, Some(&parameters.info))?;
 
         for i in 0..parameters.evaluation_element.len() {
             assert_eq!(
@@ -278,7 +276,7 @@ fn test_base_finalize<G: Group, H: BlockInput + Digest>(
 
             let client_finalize_result = client.finalize(
                 EvaluationElement::deserialize(&parameters.evaluation_element[i])?,
-                &Metadata(parameters.info.clone()),
+                Some(&parameters.info),
             )?;
 
             assert_eq!(&parameters.output[i], &client_finalize_result.to_vec());
@@ -305,20 +303,18 @@ fn test_verifiable_finalize<G: Group, H: BlockInput + Digest>(
             clients.push(client.clone());
         }
 
-        let batch_finalize_input = BatchFinalizeInput::new(
-            clients,
-            parameters
-                .evaluation_element
-                .iter()
-                .map(|x| EvaluationElement::deserialize(x).unwrap())
-                .collect(),
-        );
+        let messages: Vec<_> = parameters
+            .evaluation_element
+            .iter()
+            .map(|x| EvaluationElement::deserialize(x).unwrap())
+            .collect();
 
         let batch_result = VerifiableClient::batch_finalize(
-            batch_finalize_input,
+            &clients,
+            &messages,
             Proof::deserialize(&parameters.proof)?,
             G::from_element_slice(GenericArray::from_slice(&parameters.pksm))?,
-            &Metadata(parameters.info.clone()),
+            Some(&parameters.info),
         )?;
 
         assert_eq!(