1use crate::groups::bls12::{
  2    G1Gadget as Bls12G1Gadget, G1PreparedGadget as Bls12G1PreparedGadget,
  3    G2Gadget as Bls12G2Gadget, G2PreparedGadget as Bls12G2PreparedGadget,
  4};
  5use algebra::curves::bls12_377::Bls12_377Parameters;
  6
  7pub type G1Gadget = Bls12G1Gadget<Bls12_377Parameters>;
  8pub type G2Gadget = Bls12G2Gadget<Bls12_377Parameters>;
  9
 10pub type G1PreparedGadget = Bls12G1PreparedGadget<Bls12_377Parameters>;
 11pub type G2PreparedGadget = Bls12G2PreparedGadget<Bls12_377Parameters>;
 12
 13#[cfg(test)]
 14mod test {
 15    use rand;
 16
 17    use super::{G1Gadget, G2Gadget};
 18    use crate::{prelude::*, test_constraint_system::TestConstraintSystem};
 19    use algebra::{
 20        curves::bls12_377::{G1Projective as G1, G2Projective as G2},
 21        fields::bls12_377::{Fq, Fr},
 22        AffineCurve, BitIterator, PrimeField, ProjectiveCurve,
 23    };
 24    use r1cs_core::ConstraintSystem;
 25
 26    #[test]
 27    fn bls12_g1_constraint_costs() {
 28        use crate::boolean::AllocatedBit;
 29
 30        let mut cs = TestConstraintSystem::<Fq>::new();
 31
 32        let bit = AllocatedBit::alloc(&mut cs.ns(|| "bool"), || Ok(true))
 33            .unwrap()
 34            .into();
 35
 36        let a: G1 = rand::random();
 37        let b: G1 = rand::random();
 38        let gadget_a = G1Gadget::alloc(&mut cs.ns(|| "a"), || Ok(a)).unwrap();
 39        let gadget_b = G1Gadget::alloc(&mut cs.ns(|| "b"), || Ok(b)).unwrap();
 40        let alloc_cost = cs.num_constraints();
 41        let _ = G1Gadget::conditionally_select(
 42            &mut cs.ns(|| "cond_select"),
 43            &bit,
 44            &gadget_a,
 45            &gadget_b,
 46        )
 47        .unwrap();
 48        let cond_select_cost = cs.num_constraints() - alloc_cost;
 49
 50        let _ = gadget_a.add(&mut cs.ns(|| "ab"), &gadget_b).unwrap();
 51        let add_cost = cs.num_constraints() - cond_select_cost - alloc_cost;
 52
 53        assert!(cs.is_satisfied());
 54        assert_eq!(cond_select_cost, <G1Gadget as CondSelectGadget<Fq>>::cost());
 55        assert_eq!(add_cost, G1Gadget::cost_of_add());
 56    }
 57
 58    #[test]
 59    fn bls12_g2_constraint_costs() {
 60        use crate::boolean::AllocatedBit;
 61
 62        let mut cs = TestConstraintSystem::<Fq>::new();
 63
 64        let bit = AllocatedBit::alloc(&mut cs.ns(|| "bool"), || Ok(true))
 65            .unwrap()
 66            .into();
 67
 68        let a: G2 = rand::random();
 69        let b: G2 = rand::random();
 70        let gadget_a = G2Gadget::alloc(&mut cs.ns(|| "a"), || Ok(a)).unwrap();
 71        let gadget_b = G2Gadget::alloc(&mut cs.ns(|| "b"), || Ok(b)).unwrap();
 72        let alloc_cost = cs.num_constraints();
 73        let _ = G2Gadget::conditionally_select(
 74            &mut cs.ns(|| "cond_select"),
 75            &bit,
 76            &gadget_a,
 77            &gadget_b,
 78        )
 79        .unwrap();
 80        let cond_select_cost = cs.num_constraints() - alloc_cost;
 81
 82        let _ = gadget_a.add(&mut cs.ns(|| "ab"), &gadget_b).unwrap();
 83        let add_cost = cs.num_constraints() - cond_select_cost - alloc_cost;
 84
 85        assert!(cs.is_satisfied());
 86        assert_eq!(cond_select_cost, <G2Gadget as CondSelectGadget<Fq>>::cost());
 87        assert_eq!(add_cost, G2Gadget::cost_of_add());
 88    }
 89
 90    #[test]
 91    fn bls12_g1_gadget_test() {
 92        use algebra::UniformRand;
 93        use rand::SeedableRng;
 94        use rand_xorshift::XorShiftRng;
 95        let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
 96
 97        let mut cs = TestConstraintSystem::<Fq>::new();
 98
 99        let a = G1::rand(&mut rng);
100        let b = G1::rand(&mut rng);
101        let a_affine = a.into_affine();
102        let b_affine = b.into_affine();
103        let mut gadget_a = G1Gadget::alloc(&mut cs.ns(|| "a"), || Ok(a)).unwrap();
104        let gadget_b = G1Gadget::alloc(&mut cs.ns(|| "b"), || Ok(b)).unwrap();
105        assert_eq!(gadget_a.x.value.unwrap(), a_affine.x);
106        assert_eq!(gadget_a.y.value.unwrap(), a_affine.y);
107        assert_eq!(gadget_b.x.value.unwrap(), b_affine.x);
108        assert_eq!(gadget_b.y.value.unwrap(), b_affine.y);
109
110        // Check addition
111        let ab = a + &b;
112        let ab_affine = ab.into_affine();
113        let gadget_ab = gadget_a.add(&mut cs.ns(|| "ab"), &gadget_b).unwrap();
114        let gadget_ba = gadget_b.add(&mut cs.ns(|| "ba"), &gadget_a).unwrap();
115        gadget_ba
116            .enforce_equal(&mut cs.ns(|| "b + a == a + b?"), &gadget_ab)
117            .unwrap();
118
119        let ab_val = gadget_ab
120            .get_value()
121            .expect("Doubling should be successful")
122            .into_affine();
123        assert_eq!(ab_val, ab_affine, "Result of addition is unequal");
124
125        // Check doubling
126        let aa = a.double();
127        let aa_affine = aa.into_affine();
128        gadget_a.double_in_place(&mut cs.ns(|| "2a")).unwrap();
129        let aa_val = gadget_a
130            .get_value()
131            .expect("Doubling should be successful")
132            .into_affine();
133        assert_eq!(
134            aa_val, aa_affine,
135            "Gadget and native values are unequal after double."
136        );
137
138        // Check mul_bits
139        let scalar = Fr::rand(&mut rng);
140        let native_result = aa.into_affine().mul(scalar) + &b;
141        let native_result = native_result.into_affine();
142
143        let mut scalar: Vec<bool> = BitIterator::new(scalar.into_repr()).collect();
144        // Get the scalar bits into little-endian form.
145        scalar.reverse();
146        let input = Vec::<Boolean>::alloc(cs.ns(|| "Input"), || Ok(scalar)).unwrap();
147        let result = gadget_a
148            .mul_bits(cs.ns(|| "mul_bits"), &gadget_b, input.iter())
149            .unwrap();
150        let result_val = result.get_value().unwrap().into_affine();
151        assert_eq!(
152            result_val, native_result,
153            "gadget & native values are diff. after scalar mul"
154        );
155
156        if !cs.is_satisfied() {
157            println!("{:?}", cs.which_is_unsatisfied().unwrap());
158        }
159
160        assert!(cs.is_satisfied());
161    }
162
163    #[test]
164    fn bls12_g2_gadget_test() {
165        let mut cs = TestConstraintSystem::<Fq>::new();
166
167        let a: G2 = rand::random();
168        let b: G2 = rand::random();
169        let a_affine = a.into_affine();
170        let b_affine = b.into_affine();
171
172        let mut gadget_a = G2Gadget::alloc(&mut cs.ns(|| "a"), || Ok(a)).unwrap();
173        let gadget_b = G2Gadget::alloc(&mut cs.ns(|| "b"), || Ok(b)).unwrap();
174        assert_eq!(gadget_a.x.get_value().unwrap(), a_affine.x);
175        assert_eq!(gadget_a.y.get_value().unwrap(), a_affine.y);
176        assert_eq!(gadget_b.x.get_value().unwrap(), b_affine.x);
177        assert_eq!(gadget_b.y.get_value().unwrap(), b_affine.y);
178
179        let ab = a + &b;
180        let ab_affine = ab.into_affine();
181        let gadget_ab = gadget_a.add(&mut cs.ns(|| "ab"), &gadget_b).unwrap();
182        let gadget_ba = gadget_b.add(&mut cs.ns(|| "ba"), &gadget_a).unwrap();
183        gadget_ba
184            .enforce_equal(&mut cs.ns(|| "b + a == a + b?"), &gadget_ab)
185            .unwrap();
186        assert_eq!(gadget_ab.x.get_value().unwrap(), ab_affine.x);
187        assert_eq!(gadget_ab.y.get_value().unwrap(), ab_affine.y);
188
189        let aa = a.double();
190        let aa_affine = aa.into_affine();
191        gadget_a.double_in_place(&mut cs.ns(|| "2a")).unwrap();
192
193        assert_eq!(gadget_a.x.get_value().unwrap(), aa_affine.x);
194        assert_eq!(gadget_a.y.get_value().unwrap(), aa_affine.y);
195
196        if !cs.is_satisfied() {
197            println!("{:?}", cs.which_is_unsatisfied().unwrap());
198        }
199
200        assert!(cs.is_satisfied());
201    }
202}