Merge pull request #2 from mileschet/feature/lisp

- improve zkcircuit
- added setup 
- set the circuit (CS groth16) on env 
- added prove stub

lisp/core.rs

@@ -310,13 +310,12 @@ fn range(a: MalArgs) -> MalRet {
 }
 
 fn alloc_input(a: MalArgs) -> MalRet {
-    println!("{:?}", a);
-    Ok(Nil)
+    // TODO implement
+    Ok(ZKScalar(bls12_381::Scalar::zero()))
 }
 
 fn scalar_zero(a: MalArgs) -> MalRet {
-    println!("{:?}", a);
-    Ok(Nil)
+    Ok(ZKScalar(bls12_381::Scalar::zero()))
 }
 
 fn scalar_one(a: MalArgs) -> MalRet {

lisp/lisp.rs

@@ -1,8 +1,9 @@
 #![allow(non_snake_case)]
 
+use crate::MalVal::Zk;
 use crate::groth16::VerifyingKey;
 use crate::types::LispCircuit;
-use sapvi::ZKVMCircuit;
+use sapvi::{ZKVMCircuit, ZKVirtualMachine};
 use sapvi::bls_extensions::BlsStringConversion;
 
 use simplelog::*;
@@ -49,6 +50,8 @@ use crate::env::{env_bind, env_find, env_get, env_new, env_set, env_sets, Env};
 #[macro_use]
 mod core;
 
+pub const ZK_CIRCUIT_ENV_KEY : &str = "ZKC";
+
 // read
 fn read(str: &str) -> MalRet {
     reader::read_str(str.to_string())
@@ -286,24 +289,27 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
                     }
                     Sym(ref a0sym) if a0sym == "setup" => {
                         let a1 = l[1].clone();
+                        let circuit = setup(&ast)?;
+                        println!("{:?}", a1); 
+                        env_sets(&env, ZK_CIRCUIT_ENV_KEY, circuit);
                         eval(a1.clone(), env.clone())
                     }
-                    //Sym(ref a0sym) if a0sym == "prove" => {
+                    Sym(ref a0sym) if a0sym == "prove" => {
+                        let a1 = l[1].clone();
+                        println!("{:?}", a1);
+                        prove(a1.clone(), env.clone())
+                    }
                     //Sym(ref a0sym) if a0sym == "verify" => {
                     Sym(ref a0sym) if a0sym == "enforce" => {
-                        let (a1, a2) = (l[1].clone(), l[2].clone());
+                        let (a1, a2) = (l[0].clone(), l[1].clone());
                         let value = eval_ast(&a2, &env)?;
                         match value {
                             List(ref el, _) => {
-                                //let val = zkcons_eval(el.to_vec(), &a1, &env)?;
-                                //val.clone();
                                 println!("{:?}", el.to_vec());
                             }
                             _ => println!("invalid format"),
                         }
-                        //                        println!("3 {:?}", eval(a1.clone(), env.clone()));
-                        env_set(&env, a1.clone(), eval(a1.clone(), env.clone())?);
-                        eval(a1.clone(), env.clone())
+                        Ok(Nil)
                     }
                     Sym(ref a0sym) if a0sym == "fn*" => {
                         let (a1, a2) = (l[1].clone(), l[2].clone());
@@ -374,10 +380,22 @@ pub fn setup(ast: &MalVal) -> MalRet {
     Ok(MalVal::Zk(Rc::new(c)))
 }
 
-pub fn prove(ast: &MalVal) -> MalRet {
+pub fn prove(mut ast: MalVal, mut env: Env) -> MalRet {
+    let c = match env_find(&env, ZK_CIRCUIT_ENV_KEY) {
+        Some(e) => match env_get(&e, &Sym(ZK_CIRCUIT_ENV_KEY.to_string()))? {
+            Zk(c) => {
+                MalVal::Zk(c)
+            }
+            _ => { MalVal::Nil }
+        }
+        None => { println!("circuit not found."); MalVal::Nil }
+    };
+
+    println!("{:?}", c);
+    
     // Pick a preimage and compute its hash.
     let quantity = bls12_381::Scalar::from(3);
-
+    
     // Create an instance of our circuit (with the preimage as a witness).
     let c = LispCircuit {
         params: Rc::new(vector![vec![

lisp/new-cs.lisp

@@ -19,11 +19,13 @@
    ;; Lc0: [(Scalar::one(), CS::one()), (Scalar::one().neg(), C)]
 ;; Lc1: [(Scalar::one(), y)]
 ;; Lc2: [(Scalar::one(), U), (Scalar::one().neg(), A), (Scalar::one().neg(), B)]
-    (enforce (scalar::one x) ((neg scalar::one) x2) ((neg scalar::one) x3))
+(println
+    (enforce ((scalar::one x) ((neg scalar::one) x2) ((neg scalar::one) x3)))
+)
 )))
 (def! a (scalar "0000000000000000000000000000000000000000000000000000000000000003"))
 (setup (MyCircuit (a (* a a) (* (* a a) a))))
-;; (prove MyCircuit)
+(prove MyCircuit)
 ;; (verify (prove MyCircuit) (scalar 27))
 ;; (U - A - B) / (1 - C)
 ;; [(1 - C)] * [y] = [U - A - B]