added zero? and scalar invert

lisp/core.rs

@@ -14,7 +14,7 @@ use crate::types::MalVal::{
 use crate::types::{MalArgs, MalRet, MalVal, _assoc, _dissoc, atom, error, func, hash_map};
 
 use bls12_381;
-use ff::PrimeField;
+use ff::{Field, PrimeField};
 
 use sapvi::bls_extensions::BlsStringConversion;
 
@@ -359,10 +359,13 @@ fn range(a: MalArgs) -> MalRet {
 }
 
 fn scalar_zero(a: MalArgs) -> MalRet {
-    Ok(vector![vec![
-        ZKScalar(bls12_381::Scalar::zero()),
-        a[0].clone()
-    ]])
+    match a.len() {
+        0 => Ok(vector![vec![ZKScalar(bls12_381::Scalar::zero())]]),
+        _ => Ok(vector![vec![
+            ZKScalar(bls12_381::Scalar::zero()),
+            a[0].clone()
+        ]]),
+    }
 }
 
 fn scalar_one(a: MalArgs) -> MalRet {
@@ -439,6 +442,69 @@ fn scalar_double(a: MalArgs) -> MalRet {
     }
 }
 
+fn scalar_invert(a: MalArgs) -> MalRet {
+    match a[0].clone() {
+        Func(_, _) => {
+            if let Vector(ref values, _) = a[0].apply(vec![]).unwrap() {
+                if let ZKScalar(a0) = values[0] {
+                    if a0.is_zero() {
+                        error(
+                            &format!("scalar invert divizion by zero \n {:?}", a0).to_string())
+                    } else {
+                        Ok(ZKScalar(a0.invert().unwrap()))        
+                    }
+                } else {
+                    error(
+                        &format!("scalar invert expect (zkscalar or string) found \n {:?}", a).to_string())
+                }
+            } else {
+                error(
+                    &format!("scalar invert expect (zkscalar or string) found \n {:?}", a).to_string())
+            }
+        }
+        ZKScalar(a0) => {
+            let z0 = a0.clone();
+            Ok(ZKScalar(z0.invert().unwrap()))
+        }
+        Str(a0) => {
+            let s0 = bls12_381::Scalar::from_string(&a0);
+            Ok(ZKScalar(s0.invert().unwrap()))
+        }
+        _ => error(
+            &format!("scalar invert expect (zkscalar or string) found \n {:?}", a).to_string(),
+        ),
+    }
+}
+
+fn scalar_is_zero(a: MalArgs) -> MalRet {
+    match a[0].clone() {
+        Func(_, _) => {
+            if let Vector(ref values, _) = a[0].apply(vec![]).unwrap() {
+                if let ZKScalar(a0) = values[0] {
+                    Ok(Bool(a0.is_zero()))        
+                } else {
+                    error(
+                        &format!("scalar is zero expect (zkscalar or string) found \n {:?}", a).to_string())
+                }
+            } else {
+                error(
+                    &format!("scalar is zero expect (zkscalar or string) found \n {:?}", a).to_string())
+            }
+        }
+        ZKScalar(a0) => {
+            let z0 = a0.clone();
+            Ok(Bool(z0.is_zero()))
+        }
+        Str(a0) => {
+            let s0 = bls12_381::Scalar::from_string(&a0);
+            Ok(Bool(s0.is_zero()))
+        }
+        _ => error(
+            &format!("scalar is zero expect (zkscalar or string) found \n {:?}", a).to_string(),
+        ),
+    }
+}
+
 fn add_scalar(a: MalArgs) -> MalRet {
     match (a[0].clone(), a[1].clone()) {
         (Func(_, _), ZKScalar(a1)) => {
@@ -455,7 +521,7 @@ fn add_scalar(a: MalArgs) -> MalRet {
         }
         (ZKScalar(a0), ZKScalar(a1)) => {
             let (mut z0, z1) = (a0.clone(), a1.clone());
-            z0.add_assign(z1);
+            z0.add_assign(z1);        
             Ok(ZKScalar(z0))
         }
         (Str(a0), Str(a1)) => {
@@ -595,5 +661,7 @@ pub fn ns() -> Vec<(&'static str, MalVal)> {
         ("second", func(second)),
         ("genrand", func(gen_rand)),
         ("double", func(scalar_double)),
+        ("invert", func(scalar_invert)),
+        ("zero?", func(scalar_is_zero)),
     ]
 }

lisp/examples/macro-test.lisp

@@ -1,5 +1,22 @@
 (load-file "util.lisp")
 
+
+(defmacro! zk-nonzero? (fn* [var] (
+        (let* [inv (gensym)
+               v1 (gensym)] (
+        `(alloc ~inv (invert ~var))
+        `(alloc ~v1 ~var)
+        `(enforce  
+            (scalar::one ~v1) 
+            (scalar::one ~inv) 
+            (scalar::one cs::one) 
+         )
+        { "result" `(zero? ~var) }
+        )
+    ))
+))
+
+
 (defmacro! zk-square (fn* [var] (
         (let* [v1 (gensym)
                v2 (gensym)] (
@@ -67,7 +84,6 @@
         `(def! ~A (alloc ~A (* ~u ~v)))
         `(def! ~C (alloc ~C (* (square ~A) ~EDWARDS_D)))
         `(def! ~u3 (alloc-input ~u3 (/ (double ~A) (+ scalar::one ~C))))
-        ;; double check why t1.invert is needed on ecc.rs code 
         `(def! ~v3 (alloc-input ~v3 (/ (- ~T (double ~A)) (- scalar::one ~C))))
         `(enforce  
             ((scalar::one ~u) (scalar::one ~v))
@@ -96,6 +112,7 @@
 
 (def! param1 (scalar 3))
 (def! param2 (scalar 9))
+(def! param3 scalar::zero)
 (def! param-u (scalar "273f910d9ecc1615d8618ed1d15fef4e9472c89ac043042d36183b2cb4d7ef51"))
 (def! param-v (scalar "466a7e3a82f67ab1d32294fd89774ad6bc3332d0fa1ccd18a77a81f50667c8d7"))
 (prove 
@@ -103,6 +120,7 @@
     ;; (println (zk-square param1))
     ;; (println (zk-mul param1 param2))
     ;; (println 'witness (zk-witness param-u param-v))
-    (println 'double (zk-double param-u param-v))
+    ;; (println 'double (zk-double param-u param-v))
+    (println 'nonzero (zk-nonzero? param3))
   )
 )