not small order

lisp/core.rs

@@ -311,6 +311,14 @@ fn mul_scalar(a: MalArgs) -> MalRet {
             a0.mul_assign(a1);
             Ok(ZKScalar(a0))
         }
+        (Str(a0), Str(a1)) => {
+            let (mut s0, s1) = (
+                bls12_381::Scalar::from_string(&a0),
+                bls12_381::Scalar::from_string(&a1),
+            );
+            s0.mul_assign(s1);
+            Ok(Str(std::string::ToString::to_string(&s0)[2..].to_string()))
+        }
         _ => error("scalar mul expect (zkscalar, zkscalar)"),
     }
 }

lisp/examples/macro-test.lisp

@@ -1,6 +1,5 @@
 (load-file "util.lisp")
 
-
 (defmacro! zk-nonzero? (fn* [var] (
         (let* [inv (gensym)
                v1 (gensym)] (
@@ -11,12 +10,11 @@
             (scalar::one ~inv) 
             (scalar::one cs::one) 
          )
-        { "result" `(zero? ~var) }
+        ;; { "result" `(zero? ~var) }
         )
     ))
 ))
 
-
 (defmacro! zk-square (fn* [var] (
         (let* [v1 (gensym)
                v2 (gensym)] (
@@ -68,6 +66,19 @@
     ))
 ))
 
+
+(def! zk-not-small-order? (fn* [u v] (
+        (def! first-doubling (last (last (zk-double u v))))
+        (def! second-doubling (last (last 
+            (zk-double (get first-doubling "u3") (get first-doubling "v3")))))
+        (def! third-doubling (last (last 
+            (zk-double (get second-doubling "u3") (get second-doubling "v3")))))
+        (zk-nonzero? (get third-doubling "u3"))
+        )
+    )
+)
+
+
 (defmacro! zk-double (fn* [val1 val2] (
         (let* [u (gensym)
                v (gensym)
@@ -105,7 +116,7 @@
             (scalar::one ~v3)
             ((scalar::one ~T) (scalar::one::neg ~A) (scalar::one::neg ~A))    
          )    
-        ;; `{ "u3" ~u3, "v3" ~v3 }
+        { "u3" u3, "v3" v3 }
         )
     ))
 ))
@@ -120,7 +131,8 @@
     ;; (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 'nonzero (zk-nonzero? param3))
+    ;; (println 'double (last (last (zk-double param-u param-v))))
+    ;; (println 'nonzero (zk-nonzero? param3))    
+    (println 'not-small-order? (zk-not-small-order? param-u param-v))
   )
 )

lisp/lisp.rs

@@ -343,12 +343,20 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
                         for (k, v) in allocs.iter() {
                             new_hm.insert(k.to_string(), eval(v.clone(), env.clone())?);
                         }
-                        new_hm.insert(a1.pr_str(false), result.clone());
-                        env_set(
-                            &env,
-                            Sym("AllocationsConst".to_string()),
-                            Hash(Rc::new(new_hm), Rc::new(Nil)),
-                        )?;
+                        new_hm.insert(a1.pr_str(false), result.clone());      
+                        if let Some(e) = &env.outer {
+                            env_set(
+                                &e,
+                                Sym("AllocationsConst".to_string()),
+                                Hash(Rc::new(new_hm), Rc::new(Nil)),
+                            )?;
+                        } else {
+                            env_set(
+                                &env,
+                                Sym("AllocationsConst".to_string()),
+                                Hash(Rc::new(new_hm), Rc::new(Nil)),
+                            )?;
+                        }
                         Ok(result.clone())
                     }
                     Sym(ref a0sym) if a0sym == "alloc-input" => {
@@ -361,11 +369,19 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
                             new_hm.insert(k.to_string(), eval(v.clone(), env.clone())?);
                         }
                         new_hm.insert(a1.pr_str(false), result.clone());
-                        env_set(
-                            &env,
-                            Sym("AllocationsInput".to_string()),
-                            Hash(Rc::new(new_hm), Rc::new(Nil)),
-                        )?;
+                        if let Some(e) = &env.outer {
+                            env_set(
+                                &e,
+                                Sym("AllocationsInput".to_string()),
+                                Hash(Rc::new(new_hm), Rc::new(Nil)),
+                            )?;
+                        } else {
+                            env_set(
+                                &env,
+                                Sym("AllocationsInput".to_string()),
+                                Hash(Rc::new(new_hm), Rc::new(Nil)),
+                            )?;
+                        }
                         Ok(result.clone())
                     }
                     Sym(ref a0sym) if a0sym == "alloc" => {
@@ -379,7 +395,6 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
                             new_hm.insert(k.to_string(), eval(v.clone(), env.clone())?);
                         }
                         new_hm.insert(a1.pr_str(false), result.clone());
-                        // TODO change it
                         if let Some(e) = &env.outer {
                             env_set(
                                 &e,

lisp/types.rs

@@ -148,6 +148,7 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                 let (a, b) = values;
                 let mut val_b = CS::one();
                 if b != "cs::one" {
+                    println!("{:?}", b);
                     val_b = *variables.get(b).unwrap();
                 }
                 if a == "scalar::one" {