added div and mul scalar, fix when param is a func

lisp/core.rs

@@ -262,35 +262,61 @@ fn sub_scalar(a: MalArgs) -> MalRet {
             s0.sub_assign(s1);
             Ok(Str(std::string::ToString::to_string(&s0)[2..].to_string()))
         }
-        _ => error("expected (scalar, scalar)"),
+        _ => error("scalar sub expected (scalar, scalar)"),
     }
 }
 
 fn mul_scalar(a: MalArgs) -> MalRet {
     println!("{:?}", a);
     match (a[0].clone(), a[1].clone()) {
+        (Func(_, _), ZKScalar(a1)) => {
+            if let Vector(ref values, _) = a[0].apply(vec![]).unwrap() {
+                if let ZKScalar(mut a0) = values[0] {
+                    a0.mul_assign(a1);
+                    Ok(ZKScalar(a0))
+                } else {
+                    error("scalar mul expect (zkscalar, zkscalar) found (func, zkscalar)")
+                }
+            } else {
+                error("scalar mul expect (zkscalar, zkscalar)")
+            }
+        }
         (ZKScalar(mut a0), ZKScalar(a1)) => {
-            // let (mut s0, s1) = (Scalar::from_string(&a0), Scalar::from_string(&a1));
             a0.mul_assign(a1);
             Ok(ZKScalar(a0))
         }
-        _ => error("expected (zkscalar, zkscalar)"),
+        _ => error("scalar mul expect (zkscalar, zkscalar)"),
     }
 }
 
 fn div_scalar(a: MalArgs) -> MalRet {
+    println!("{:?}", a);
     match (a[0].clone(), a[1].clone()) {
+        (ZKScalar(s0), ZKScalar(s1)) => {
+            let ret = s1.invert().map(|other| *&s0 * other);
+            if bool::from(ret.is_some()) {
+                Ok(Str(
+                    std::string::ToString::to_string(&ret.unwrap())[2..].to_string()
+                ))
+            } else {
+                error("DivisionByZero")
+            }
+        }
         (Str(a0), Str(a1)) => {
             let (s0, s1) = (
                 bls12_381::Scalar::from_string(&a0),
                 bls12_381::Scalar::from_string(&a1),
             );
             let ret = s1.invert().map(|other| *&s0 * other);
-            Ok(Str(
-                std::string::ToString::to_string(&ret.unwrap())[2..].to_string()
-            ))
+            if bool::from(ret.is_some()) {
+                Ok(Str(
+                    std::string::ToString::to_string(&ret.unwrap())[2..].to_string()
+                ))
+            } else {
+                error("DivisionByZero")
+            }
         }
-        _ => error("expected (scalar, scalar)"),
+        _ => error("scalar div expected (scalar, scalar)"),
     }
 }
 
@@ -362,7 +388,7 @@ fn add_scalar(a: MalArgs) -> MalRet {
             let (mut z0, z1) = (a0.clone(), a1.clone());
             z0.add_assign(z1);
             Ok(ZKScalar(z0))
-        },
+        }
         (Str(a0), Str(a1)) => {
             let (mut s0, s1) = (
                 bls12_381::Scalar::from_string(&a0),

lisp/jubjub-add.lisp

@@ -3,14 +3,15 @@
 ;;           = (u1 + v1) * (u2 + v2)
 ( (let* [
       EDWARDS_D (alloc-const "EDWARDS_D" (scalar "2a9318e74bfa2b48f5fd9207e6bd7fd4292d7f6d37579d2601065fd6d6343eb1"))
-      u1 (alloc "u1" (scalar "15a36d1f0f390d8852a35a8c1908dd87a361ee3fd48fdf77b9819dc82d90607e"))
-      v1 (alloc "v1" (scalar "015d8c7f5b43fe33f7891142c001d9251f3abeeb98fad3e87b0dc53c4ebf1891"))
-      u2 (alloc "u2" (scalar "15a36d1f0f390d8852a35a8c1908dd87a361ee3fd48fdf77b9819dc82d90607e"))
-      v2 (alloc "v2" (scalar "015d8c7f5b43fe33f7891142c001d9251f3abeeb98fad3e87b0dc53c4ebf1891"))
-      U (alloc-input "U" (* (+ u1 u2) (+ v1 v2)))
-      A (alloc-input "A" (* v2 u1))
-      B (alloc-input "B" (* u2 v1))
-      C (alloc-input "C" (* EDWARDS_D (* A B)))
+      u1 (alloc-input "u1" (scalar "15a36d1f0f390d8852a35a8c1908dd87a361ee3fd48fdf77b9819dc82d90607e"))
+      v1 (alloc-input "v1" (scalar "015d8c7f5b43fe33f7891142c001d9251f3abeeb98fad3e87b0dc53c4ebf1891"))
+      u2 (alloc-input  "u2" (scalar "15a36d1f0f390d8852a35a8c1908dd87a361ee3fd48fdf77b9819dc82d90607e"))
+      v2 (alloc-input  "v2" (scalar "015d8c7f5b43fe33f7891142c001d9251f3abeeb98fad3e87b0dc53c4ebf1891"))
+      U (alloc "U" (* (+ u1 u2) (+ v1 v2)))
+      A (alloc "A" (* v2 u1))
+      B (alloc "B" (* u2 v1))
+      C (alloc "C" (* EDWARDS_D (* A B)))
+      u3 (alloc "u3" (/ (* A A) (* scalar::one C)))
       ]
 (prove
  (setup