Endo

r1cs/gadgets/std/src/groups/mod.rs

@@ -445,11 +445,12 @@ pub(crate) fn scalar_bits_to_constant_length<
 
 #[cfg(test)]
 pub(crate) mod test {
-    use algebra::{Field, PrimeField, FpParameters, BigInteger, Group, UniformRand, ToBits};
+    use algebra::{Field, PrimeField, FpParameters, BigInteger, Group, UniformRand, ToBits, EndoMulCurve, ProjectiveCurve};
     use r1cs_core::ConstraintSystem;
 
     use crate::{prelude::*, test_constraint_system::TestConstraintSystem};
     use rand::thread_rng;
+    use crate::groups::EndoMulCurveGadget;
 
     #[allow(dead_code)]
     pub(crate) fn group_test<
@@ -731,4 +732,32 @@ pub(crate) mod test {
             mul_bits_additivity_test::<ConstraintF, G, GG>();
         }
     }
+
+    #[allow(dead_code)]
+    pub(crate) fn endo_mul_test<
+        ConstraintF: Field + PrimeField,
+        G: ProjectiveCurve<Affine = GE>,
+        GG: EndoMulCurveGadget<G, ConstraintF, Value = G>,
+        GE: EndoMulCurve<Projective = G>,
+    >()
+    {
+        let mut cs = TestConstraintSystem::<ConstraintF>::new();
+
+        let a_native_proj = G::rand(&mut thread_rng());
+        let a_native: GE = a_native_proj.into_affine();
+        let a = GG::alloc(&mut cs.ns(|| "generate_a"), || Ok(a_native_proj)).unwrap();
+
+        let scalar: G::ScalarField = u128::rand(&mut thread_rng()).into();
+
+        let b_native = scalar.into_repr().to_bits().as_slice()[0..128].to_vec();
+        let b = b_native
+            .iter()
+            .map(|&bit| Boolean::constant(bit))
+            .collect::<Vec<_>>();
+
+        let r_native = a_native.endo_mul(b_native).unwrap();
+        let r = a.endo_mul(cs.ns(|| "endo mul"), &b).unwrap().get_value().unwrap();
+
+        assert_eq!(r_native, r);
+    }
 }

r1cs/gadgets/std/src/instantiated/tweedle/curves.rs

@@ -10,91 +10,28 @@ use crate::{
 pub type TweedleDeeGadget = AffineGadget<TweedledeeParameters, Fq, FqGadget>;
 pub type TweedleDumGadget = AffineGadget<TweedledumParameters, Fr, FrGadget>;
 
-#[cfg(test)]
-mod test {
-    use r1cs_core::ConstraintSystem;
-    use crate::{
-        prelude::*,
-        test_constraint_system::TestConstraintSystem,
-        instantiated::tweedle::{
-            TweedleDeeGadget,
-            TweedleDumGadget,
-        },
-        groups::EndoMulCurveGadget,
-    };
-    use algebra::{UniformRand, AffineCurve, ProjectiveCurve, EndoMulCurve, fields::tweedle::{
-        Fq, Fr,
-    }, curves::tweedle::{
-        dee::Projective as DeeProjective,
-        dum::Projective as DumProjective,
-    }, PrimeField, BigInteger};
-    use rand::thread_rng;
-
-    #[test]
-    fn test_dee() {
-        crate::groups::test::group_test_with_incomplete_add::<
-            _, _, TweedleDeeGadget
-        >();
-        crate::groups::test::mul_bits_test::<
-            _, _, TweedleDeeGadget
-        >();
-    }
-
-    #[test]
-    fn test_dum() {
-        crate::groups::test::group_test_with_incomplete_add::<
-            _, _, TweedleDumGadget
-        >();
-        crate::groups::test::mul_bits_test::<
-            _, _, TweedleDumGadget
-        >();
-    }
-
-    #[test]
-    /// Tests equality of the result enforced by `endo_mul()` 
-    /// with the corresponding scalar multiple. 
-    fn test_endo_dee()
-    {
-        let mut cs = TestConstraintSystem::<Fq>::new();
-
-        let a_native = DeeProjective::rand(&mut thread_rng()).into_affine();
-        let a = TweedleDeeGadget::alloc(&mut cs.ns(|| "generate_a"), || Ok(a_native.into_projective())).unwrap();
-
-        let scalar: Fr = u128::rand(&mut thread_rng()).into();
-
-        let b_native = scalar.into_repr().to_bits().as_slice()[0..128].to_vec();
-        let b = b_native
-            .iter()
-            .map(|&bit| Boolean::constant(bit))
-            .collect::<Vec<_>>();
-
-        let r_native = a_native.endo_mul(b_native).unwrap().into_affine();
-        let r = a.endo_mul(cs.ns(|| "endo mul"), &b).unwrap().get_value().unwrap().into_affine();
-
-        assert_eq!(r_native, r);
-    }
-
-    #[test]
-    /// Tests equality of the result enforced by `endo_mul()` 
-    /// with the corresponding scalar multiple. 
-    fn test_endo_dum()
-    {
-        let mut cs = TestConstraintSystem::<Fr>::new();
-
-        let a_native = DumProjective::rand(&mut thread_rng()).into_affine();
-        let a = TweedleDumGadget::alloc(&mut cs.ns(|| "generate_a"), || Ok(a_native.into_projective())).unwrap();
-
-        let scalar: Fq = u128::rand(&mut thread_rng()).into();
-
-        let b_native = scalar.into_repr().to_bits().as_slice()[0..128].to_vec();
-        let b = b_native
-            .iter()
-            .map(|&bit| Boolean::constant(bit))
-            .collect::<Vec<_>>();
-
-        let r_native = a_native.endo_mul(b_native).unwrap().into_affine();
-        let r = a.endo_mul(cs.ns(|| "endo mul"), &b).unwrap().get_value().unwrap().into_affine();
+#[test]
+fn test_dee() {
+    crate::groups::test::group_test_with_incomplete_add::<
+        _, _, TweedleDeeGadget
+    >();
+    crate::groups::test::mul_bits_test::<
+        _, _, TweedleDeeGadget
+    >();
+    crate::groups::test::endo_mul_test::<
+        _, _, TweedleDeeGadget, _
+    >();
+}
 
-        assert_eq!(r_native, r);
-    }
+#[test]
+fn test_dum() {
+    crate::groups::test::group_test_with_incomplete_add::<
+        _, _, TweedleDumGadget
+    >();
+    crate::groups::test::mul_bits_test::<
+        _, _, TweedleDumGadget
+    >();
+    crate::groups::test::endo_mul_test::<
+        _, _, TweedleDumGadget, _
+    >();
 }