More possible libsnark interactions (exponentiation of Fr, zero/one) and changes to `const` in interface.

snark/src/fr.rs

@@ -9,7 +9,10 @@ pub struct Fr([u64; 4]);
 
 extern "C" {
     fn libsnarkwrap_Fr_random() -> Fr;
+    fn libsnarkwrap_Fr_zero() -> Fr;
+    fn libsnarkwrap_Fr_one() -> Fr;
     fn libsnarkwrap_Fr_from(s: *const c_char) -> Fr;
+    fn libsnarkwrap_Fr_exp(a: *const Fr, b: u32) -> Fr;
     fn libsnarkwrap_Fr_add(a: *const Fr, b: *const Fr) -> Fr;
     fn libsnarkwrap_Fr_mul(a: *const Fr, b: *const Fr) -> Fr;
     fn libsnarkwrap_Fr_sub(a: *const Fr, b: *const Fr) -> Fr;
@@ -18,6 +21,14 @@ extern "C" {
 }
 
 impl Fr {
+    pub fn zero() -> Self {
+        unsafe { libsnarkwrap_Fr_zero() }
+    }
+
+    pub fn one() -> Self {
+        unsafe { libsnarkwrap_Fr_one() }
+    }
+
     pub fn random() -> Self {
         unsafe { libsnarkwrap_Fr_random() }
     }
@@ -26,6 +37,10 @@ impl Fr {
         unsafe { libsnarkwrap_Fr_is_zero(self) }
     }
 
+    pub fn exp(&self, e: u32) -> Self {
+        unsafe { libsnarkwrap_Fr_exp(self, e) }
+    }
+
     pub fn random_nonzero() -> Self {
         let mut tmp = Self::random();
 
@@ -100,11 +115,13 @@ fn test_basic_arith() {
     let aplusb = Fr::from_str("58026983333001444");
     let aminusb = Fr::from_str("11099269581669482");
     let aneg = Fr::from_str("21888242871839275222246405745257275088548364400416034343698169623449351160154");
+    let a50 = Fr::from_str("18657215030604597165059661904200246872501020503322948614804364624353607925980");
 
     assert!(ab == (a * b));
     assert!(aplusb == (a + b));
     assert!(aminusb == (a - b));
     assert!(aneg == (-a));
+    assert!(a50 == a.exp(50));
 }
 
 #[test]
@@ -115,4 +132,9 @@ fn test_primitives() {
     assert!(a.is_zero());
     let a = Fr::from_str("1");
     assert!(!a.is_zero());
+
+    let a = Fr::zero();
+    assert!(a.is_zero());
+    let a = Fr::one();
+    assert!(!a.is_zero());
 }

snark/src/libsnarkwrap.cpp

@@ -43,27 +43,39 @@ extern "C" curve_Fr libsnarkwrap_Fr_random() {
     return curve_Fr::random_element();
 }
 
+extern "C" curve_Fr libsnarkwrap_Fr_zero() {
+    return curve_Fr::zero();
+}
+
+extern "C" curve_Fr libsnarkwrap_Fr_one() {
+    return curve_Fr::one();
+}
+
 extern "C" curve_Fr libsnarkwrap_Fr_from(const char *a) {
     return curve_Fr(a);
 }
 
-extern "C" curve_Fr libsnarkwrap_Fr_add(curve_Fr *a, curve_Fr *b) {
+extern "C" curve_Fr libsnarkwrap_Fr_exp(const curve_Fr *a, uint32_t b) {
+    return (*a) ^ b;
+}
+
+extern "C" curve_Fr libsnarkwrap_Fr_add(const curve_Fr *a, const curve_Fr *b) {
     return *a + *b;
 }
 
-extern "C" curve_Fr libsnarkwrap_Fr_sub(curve_Fr *a, curve_Fr *b) {
+extern "C" curve_Fr libsnarkwrap_Fr_sub(const curve_Fr *a, const curve_Fr *b) {
     return *a - *b;
 }
 
-extern "C" curve_Fr libsnarkwrap_Fr_mul(curve_Fr *a, curve_Fr *b) {
+extern "C" curve_Fr libsnarkwrap_Fr_mul(const curve_Fr *a, const curve_Fr *b) {
     return *a * *b;
 }
 
-extern "C" curve_Fr libsnarkwrap_Fr_neg(curve_Fr *a) {
+extern "C" curve_Fr libsnarkwrap_Fr_neg(const curve_Fr *a) {
     return -(*a);
 }
 
-extern "C" bool libsnarkwrap_Fr_is_zero(curve_Fr *a) {
+extern "C" bool libsnarkwrap_Fr_is_zero(const curve_Fr *a) {
     return a->is_zero();
 }
 
@@ -81,27 +93,27 @@ extern "C" curve_G1 libsnarkwrap_G1_random() {
     return curve_G1::random_element();
 }
 
-extern "C" bool libsnarkwrap_G1_is_zero(curve_G1 *p) {
+extern "C" bool libsnarkwrap_G1_is_zero(const curve_G1 *p) {
     return p->is_zero();
 }
 
-extern "C" bool libsnarkwrap_G1_is_equal(curve_G1 *p, curve_G1 *q) {
+extern "C" bool libsnarkwrap_G1_is_equal(const curve_G1 *p, const curve_G1 *q) {
     return *p == *q;
 }
 
-extern "C" curve_G1 libsnarkwrap_G1_add(curve_G1 *p, curve_G1 *q) {
+extern "C" curve_G1 libsnarkwrap_G1_add(const curve_G1 *p, const curve_G1 *q) {
     return *p + *q;
 }
 
-extern "C" curve_G1 libsnarkwrap_G1_sub(curve_G1 *p, curve_G1 *q) {
+extern "C" curve_G1 libsnarkwrap_G1_sub(const curve_G1 *p, const curve_G1 *q) {
     return *p - *q;
 }
 
-extern "C" curve_G1 libsnarkwrap_G1_neg(curve_G1 *p) {
+extern "C" curve_G1 libsnarkwrap_G1_neg(const curve_G1 *p) {
     return -(*p);
 }
 
-extern "C" curve_G1 libsnarkwrap_G1_scalarmul(curve_G1 *p, curve_Fr *q) {
+extern "C" curve_G1 libsnarkwrap_G1_scalarmul(const curve_G1 *p, const curve_Fr *q) {
     return (*q) * (*p);
 }
 
@@ -119,36 +131,36 @@ extern "C" curve_G2 libsnarkwrap_G2_random() {
     return curve_G2::random_element();
 }
 
-extern "C" bool libsnarkwrap_G2_is_zero(curve_G2 *p) {
+extern "C" bool libsnarkwrap_G2_is_zero(const curve_G2 *p) {
     return p->is_zero();
 }
 
-extern "C" bool libsnarkwrap_G2_is_equal(curve_G2 *p, curve_G2 *q) {
+extern "C" bool libsnarkwrap_G2_is_equal(const curve_G2 *p, const curve_G2 *q) {
     return *p == *q;
 }
 
-extern "C" curve_G2 libsnarkwrap_G2_add(curve_G2 *p, curve_G2 *q) {
+extern "C" curve_G2 libsnarkwrap_G2_add(const curve_G2 *p, const curve_G2 *q) {
     return *p + *q;
 }
 
-extern "C" curve_G2 libsnarkwrap_G2_sub(curve_G2 *p, curve_G2 *q) {
+extern "C" curve_G2 libsnarkwrap_G2_sub(const curve_G2 *p, const curve_G2 *q) {
     return *p - *q;
 }
 
-extern "C" curve_G2 libsnarkwrap_G2_neg(curve_G2 *p) {
+extern "C" curve_G2 libsnarkwrap_G2_neg(const curve_G2 *p) {
     return -(*p);
 }
 
-extern "C" curve_G2 libsnarkwrap_G2_scalarmul(curve_G2 *p, curve_Fr *q) {
+extern "C" curve_G2 libsnarkwrap_G2_scalarmul(const curve_G2 *p, const curve_Fr *q) {
     return (*q) * (*p);
 }
 
 // Pairing
 
-extern "C" curve_GT libsnarkwrap_gt_exp(curve_GT *p, curve_Fr *s) {
+extern "C" curve_GT libsnarkwrap_gt_exp(const curve_GT *p, const curve_Fr *s) {
     return (*p) ^ (*s);
 }
 
-extern "C" curve_GT libsnarkwrap_pairing(curve_G1 *p, curve_G2 *q) {
+extern "C" curve_GT libsnarkwrap_pairing(const curve_G1 *p, const curve_G2 *q) {
     return curve_pp::reduced_pairing(*p, *q);
 }

src/randompowers.rs

@@ -87,7 +87,7 @@ struct TauPowers {
 
 impl TauPowers {
     fn new(tau: Fr) -> TauPowers {
-        TauPowers { acc: Fr::from_str("1"), tau: tau }
+        TauPowers { acc: Fr::one(), tau: tau }
     }
 }