Initial commit to extract crypto-primitives to new crate

crypto-primitives/src/commitment/injective_map/constraints.rs

@@ -0,0 +1,59 @@
+use algebra::{Field, PrimeField};
+
+use crate::commitment::{
+    injective_map::{InjectiveMap, PedersenCommCompressor},
+    pedersen::PedersenWindow,
+    pedersen::constraints::{
+        PedersenCommitmentGadget, PedersenCommitmentGadgetParameters, PedersenRandomnessGadget,
+    },
+    CommitmentGadget,
+};
+
+pub use crate::crh::injective_map::constraints::InjectiveMapGadget;
+use algebra::groups::Group;
+use r1cs_core::{ConstraintSystem, SynthesisError};
+use r1cs_std::{groups::GroupGadget, uint8::UInt8};
+
+use std::marker::PhantomData;
+
+pub struct PedersenCommitmentCompressorGadget<
+    G: Group,
+    I: InjectiveMap<G>,
+    ConstraintF: Field,
+    GG: GroupGadget<G, ConstraintF>,
+    IG: InjectiveMapGadget<G, I, ConstraintF, GG>,
+> {
+    _compressor:        PhantomData<I>,
+    _compressor_gadget: PhantomData<IG>,
+    _crh:               PedersenCommitmentGadget<G, ConstraintF, GG>,
+}
+
+impl<G, I, ConstraintF, GG, IG, W> CommitmentGadget<PedersenCommCompressor<G, I, W>, ConstraintF>
+    for PedersenCommitmentCompressorGadget<G, I, ConstraintF, GG, IG>
+where
+    G: Group,
+    I: InjectiveMap<G>,
+    ConstraintF: PrimeField,
+    GG: GroupGadget<G, ConstraintF>,
+    IG: InjectiveMapGadget<G, I, ConstraintF, GG>,
+    W: PedersenWindow,
+{
+    type OutputGadget = IG::OutputGadget;
+    type ParametersGadget = PedersenCommitmentGadgetParameters<G, W, ConstraintF>;
+    type RandomnessGadget = PedersenRandomnessGadget;
+
+    fn check_commitment_gadget<CS: ConstraintSystem<ConstraintF>>(
+        mut cs: CS,
+        parameters: &Self::ParametersGadget,
+        input: &[UInt8],
+        r: &Self::RandomnessGadget,
+    ) -> Result<Self::OutputGadget, SynthesisError> {
+        let result = PedersenCommitmentGadget::<G, ConstraintF, GG>::check_commitment_gadget(
+            cs.ns(|| "PedersenComm"),
+            parameters,
+            input,
+            r,
+        )?;
+        IG::evaluate_map(cs.ns(|| "InjectiveMap"), &result)
+    }
+}

crypto-primitives/src/commitment/injective_map/mod.rs

@@ -0,0 +1,47 @@
+use crate::Error;
+use rand::Rng;
+use std::marker::PhantomData;
+
+use super::{
+    pedersen::{PedersenCommitment, PedersenParameters, PedersenRandomness, PedersenWindow},
+    CommitmentScheme,
+};
+pub use crate::crh::injective_map::InjectiveMap;
+use algebra::groups::Group;
+
+#[cfg(feature = "r1cs")]
+pub mod constraints;
+
+pub struct PedersenCommCompressor<G: Group, I: InjectiveMap<G>, W: PedersenWindow> {
+    _group:      PhantomData<G>,
+    _compressor: PhantomData<I>,
+    _comm:       PedersenCommitment<G, W>,
+}
+
+impl<G: Group, I: InjectiveMap<G>, W: PedersenWindow> CommitmentScheme
+    for PedersenCommCompressor<G, I, W>
+{
+    type Output = I::Output;
+    type Parameters = PedersenParameters<G>;
+    type Randomness = PedersenRandomness<G>;
+
+    fn setup<R: Rng>(rng: &mut R) -> Result<Self::Parameters, Error> {
+        let time = start_timer!(|| format!("PedersenCompressor::Setup"));
+        let params = PedersenCommitment::<G, W>::setup(rng);
+        end_timer!(time);
+        params
+    }
+
+    fn commit(
+        parameters: &Self::Parameters,
+        input: &[u8],
+        randomness: &Self::Randomness,
+    ) -> Result<Self::Output, Error> {
+        let eval_time = start_timer!(|| "PedersenCompressor::Eval");
+        let result = I::injective_map(&PedersenCommitment::<G, W>::commit(
+            parameters, input, randomness,
+        )?)?;
+        end_timer!(eval_time);
+        Ok(result)
+    }
+}