added zn* function definition

Cargo.toml

@@ -37,6 +37,10 @@ failure_derive = "0.1.8"
 
 regex = "1"
 
+lazy_static = "1.4.0"
+itertools = "0.8.0"
+fnv = "1.0.6"
+
 [[bin]]
 name = "sha256"
 path = "src/sha256.rs"

lisp/core.rs

@@ -265,22 +265,6 @@ fn seq(a: MalArgs) -> MalRet {
     }
 }
 
-fn add_one_lc0(a: MalArgs) -> MalRet {
-    Ok(Sym("add-one-lc0".to_string()))
-}
-
-fn enforce(a: MalArgs) -> MalRet {
-    Ok(Sym("enforce".to_string()))
-}
-
-fn double_coeff_lc(a: MalArgs) -> MalRet {
-    Ok(Sym("double-coeff-lc".to_string()))
-}
-
-fn reset_coeff_lc(a: MalArgs) -> MalRet {
-    Ok(Sym("reset-coeff-lc".to_string()))
-}
-
 pub fn ns() -> Vec<(&'static str, MalVal)> {
     vec![
         ("=", func(|a| Ok(Bool(a[0] == a[1])))),
@@ -368,29 +352,5 @@ pub fn ns() -> Vec<(&'static str, MalVal)> {
         ("reset!", func(|a| a[0].reset_bang(&a[1]))),
         ("swap!", func(|a| a[0].swap_bang(&a[1..].to_vec()))),
         ("unpack-bits", func(unpack_bits)),
-        ("add-lc0", 
-            func(|a| {
-                println!("add-lc0 {}", pr_seq(&a, false, "", "", " "));
-                Ok(Nil)
-            })),
-        ("sub-lc0", 
-            func(|a| {
-                println!("sub-lc0 {}", pr_seq(&a, false, "", "", " "));
-                Ok(Nil)
-            })),
-        ("enforce", func(enforce)),
-        ("double-coeff-lc", func(double_coeff_lc)),
-        ("reset-coeff-lc", func(double_coeff_lc)),
-        ("sub-lc0", 
-            func(|a| {
-                println!("sub-lc0 {}", pr_seq(&a, false, "", "", " "));
-                Ok(Nil)
-            })),
-        ("add-one-lc0", func(add_one_lc0)),
-        ("add-lc1", 
-            func(|a| {
-                println!("add-lc1 {}", pr_seq(&a, false, "", "", " "));
-                Ok(Nil)
-            })),
     ]
 }

lisp/lisp.rs

@@ -23,6 +23,11 @@ use crate::env::{env_bind, env_find, env_get, env_new, env_set, env_sets, Env};
 #[macro_use]
 mod core;
 
+// zk circuit
+fn zkcircuit_load(val: &MalVal) -> MalRet {
+    Ok(val.clone())
+}
+
 // read
 fn read(str: &str) -> MalRet {
     reader::read_str(str.to_string())
@@ -258,6 +263,18 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
                             _ => Ok(Nil),
                         }
                     }
+                    Sym(ref a0sym) if a0sym == "zk*" => {
+                        // TODO create zk circuit and evaluate the rest
+                        let (a1, a2) = (l[1].clone(), l[2].clone());
+                        Ok(MalFunc {
+                            eval: eval,
+                            ast: Rc::new(a2),
+                            env: env,
+                            params: Rc::new(a1),
+                            is_macro: false,
+                            meta: Rc::new(Nil),
+                        })
+                    }
                     Sym(ref a0sym) if a0sym == "fn*" => {
                         let (a1, a2) = (l[1].clone(), l[2].clone());
                         Ok(MalFunc {

lisp/new.lisp

@@ -1,10 +1,18 @@
-
+(def! circuit (zk* [x] (
+    (def! bits (unpack-bits x 256))
+    (map (fn* [b] (println 
+                    '(add lc0 one) 
+                    '(sub b)
+                    '(add lc1 x)
+                    'enforce)
+              ) bits)
+    (map (fn* [b] (println '(add lc0 b) 
+                           'double-coeff-lc)
+              ) bits)
+    (println 'reset-coeff-lc
+    '(sub lc0 x)
+    '(add lc1 one)
+    'enforce)
+)))
 (def! dec "73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000000")
-(def! bits (unpack-bits dec 256))
-(println (count bits))
-(map (fn* [b] (println (add-one-lc0))) bits)
-
-;;        (map (fn* [b] ((add-lc0 b) (double-coeff-lc))) bits)
-;;        (reset-coeff-lc)
-;;        (sub-lc0 x)
-;;        (add-one-lc1)
+(circuit dec)

lisp/printer.rs

@@ -1,5 +1,5 @@
 use crate::types::MalVal;
-use crate::types::MalVal::{Atom, Bool, Func, Hash, Int, List, MalFunc, Nil, Str, Sym, Vector};
+use crate::types::MalVal::{Atom, Bool, Func, Hash, Int, List, MalFunc, Nil, Str, Sym, Vector, Zk};
 
 fn escape_str(s: &str) -> String {
     s.chars()
@@ -45,6 +45,7 @@ impl MalVal {
                 ast: a, params: p, ..
             } => format!("(fn* {} {})", p.pr_str(true), a.pr_str(true)),
             Atom(a) => format!("(atom {})", a.borrow().pr_str(true)),
+            Zk(a) => format!("ZKCircuit")
         }
     }
 }

lisp/types.rs

@@ -8,6 +8,17 @@ use crate::env::{env_bind, Env};
 use crate::types::MalErr::{ErrMalVal, ErrString};
 use crate::types::MalVal::{Atom, Bool, Func, Hash, Int, List, MalFunc, Nil, Str, Sym, Vector};
 
+use sapvi::{BlsStringConversion, Decodable, Encodable, ZKContract, ZKProof, ZKVMCircuit, ConstraintInstruction};
+use bls12_381::Scalar;
+
+use bellman::{
+    gadgets::{
+        boolean::{AllocatedBit, Boolean},
+        multipack, num, Assignment,
+    },
+    groth16, Circuit, ConstraintSystem, SynthesisError,
+};
+
 #[derive(Debug, Clone)]
 pub enum MalVal {
     Nil,
@@ -29,6 +40,15 @@ pub enum MalVal {
         meta: Rc<MalVal>,
     },
     Atom(Rc<RefCell<MalVal>>),
+    Zk(ZKCircuit),
+}
+
+#[derive(Debug, Clone)]
+pub struct ZKCircuit {
+    name: String,
+    constraints: Vec<ConstraintInstruction>,
+    private: Vec<Scalar>,
+    public: Vec<Scalar>,
 }
 
 #[derive(Debug)]

src/vm.rs

@@ -55,7 +55,7 @@ pub enum AllocType {
     Public,
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub enum ConstraintInstruction {
     Lc0Add(VariableIndex),
     Lc1Add(VariableIndex),