changing zkcircuit ref

lisp/core.rs

@@ -8,8 +8,7 @@ use crate::printer::pr_seq;
 use crate::reader::read_str;
 use crate::types::MalErr::ErrMalVal;
 use crate::types::MalVal::{
-    Atom, Bool, Func, Hash, Int, List, MalFunc, Nil, Str,
-    Sym, Vector, ZKScalar
+    Atom, Bool, Func, Hash, Int, List, MalFunc, Nil, Str, Sym, Vector, ZKScalar,
 };
 use crate::types::{MalArgs, MalRet, MalVal, _assoc, _dissoc, atom, error, func, hash_map};
 
@@ -20,7 +19,6 @@ use sapvi::bls_extensions::BlsStringConversion;
 
 use std::ops::{AddAssign, MulAssign, SubAssign};
 
-
 macro_rules! fn_t_int_int {
     ($ret:ident, $fn:expr) => {{
         |a: MalArgs| match (a[0].clone(), a[1].clone()) {
@@ -257,7 +255,10 @@ fn conj(a: MalArgs) -> MalRet {
 fn sub_scalar(a: MalArgs) -> MalRet {
     match (a[0].clone(), a[1].clone()) {
         (Str(a0), Str(a1)) => {
-            let (mut s0, s1) = (bls12_381::Scalar::from_string(&a0), bls12_381::Scalar::from_string(&a1));
+            let (mut s0, s1) = (
+                bls12_381::Scalar::from_string(&a0),
+                bls12_381::Scalar::from_string(&a1),
+            );
             s0.sub_assign(s1);
             Ok(Str(std::string::ToString::to_string(&s0)[2..].to_string()))
         }
@@ -279,7 +280,10 @@ fn mul_scalar(a: MalArgs) -> MalRet {
 fn div_scalar(a: MalArgs) -> MalRet {
     match (a[0].clone(), a[1].clone()) {
         (Str(a0), Str(a1)) => {
-            let (s0, s1) = (bls12_381::Scalar::from_string(&a0), bls12_381::Scalar::from_string(&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()
@@ -294,14 +298,11 @@ fn range(a: MalArgs) -> MalRet {
     match (a[0].clone(), a[1].clone()) {
         (Int(a0), Int(a1)) => {
             for n in a0..a1 {
-               result.push(n);
-            };
-            Ok(list!(result
-                .iter()
-                .map(|_a| Nil) 
-                .collect::<Vec<MalVal>>()))
-        },
-        _ => error("expected int int")
+                result.push(n);
+            }
+            Ok(list!(result.iter().map(|_a| Nil).collect::<Vec<MalVal>>()))
+        }
+        _ => error("expected int int"),
     }
 }
 
@@ -315,9 +316,7 @@ fn scalar_one(a: MalArgs) -> MalRet {
 
 fn negate_from(a: MalArgs) -> MalRet {
     match a[0].apply(vec![])? {
-        ZKScalar(a0) => {
-            Ok(ZKScalar(a0.neg()))
-        },
+        ZKScalar(a0) => Ok(ZKScalar(a0.neg())),
         Nil => error("nil not supported"),
         _ => error("negate error, expected (zkscalar)"),
     }
@@ -327,12 +326,12 @@ fn scalar_from(a: MalArgs) -> MalRet {
         Str(a0) => {
             let s0 = bls12_381::Scalar::from_string(&a0.to_string());
             Ok(ZKScalar(s0))
-        },
+        }
         Int(a0) => {
             println!("{:?}", a0);
             let s0 = bls12_381::Scalar::from(a0 as u64);
             Ok(ZKScalar(s0))
-        },
+        }
         _ => error("expected (string or int)"),
     }
 }
@@ -349,7 +348,10 @@ fn bellman_one(a: MalArgs) -> MalRet {
 fn add_scalar(a: MalArgs) -> MalRet {
     match (a[0].clone(), a[1].clone()) {
         (Str(a0), Str(a1)) => {
-            let (mut s0, s1) = (bls12_381::Scalar::from_string(&a0), bls12_381::Scalar::from_string(&a1));
+            let (mut s0, s1) = (
+                bls12_381::Scalar::from_string(&a0),
+                bls12_381::Scalar::from_string(&a1),
+            );
             s0.add_assign(s1);
             Ok(Str(std::string::ToString::to_string(&s0)[2..].to_string()))
         }

lisp/lisp.rs

@@ -1,26 +1,21 @@
 #![allow(non_snake_case)]
 
-use crate::MalVal::Zk;
 use crate::groth16::VerifyingKey;
 use crate::types::LispCircuit;
-use sapvi::{ZKVMCircuit, ZKVirtualMachine};
+use crate::MalVal::Zk;
 use sapvi::bls_extensions::BlsStringConversion;
+use sapvi::{ZKVMCircuit, ZKVirtualMachine};
 
 use simplelog::*;
 
-use bellman::{
-    gadgets::{
-        Assignment,
-    },
-    groth16, Circuit, ConstraintSystem, SynthesisError,
-};
+use bellman::{gadgets::Assignment, groth16, Circuit, ConstraintSystem, SynthesisError};
 use bls12_381::Bls12;
 use bls12_381::Scalar;
 use ff::{Field, PrimeField};
 use rand::rngs::OsRng;
-use std::ops::{AddAssign, MulAssign, SubAssign};
-use std::time::Instant;
+use std::{cell::RefCell, ops::{AddAssign, MulAssign, SubAssign}};
 use std::rc::Rc;
+use std::time::Instant;
 
 //use std::collections::HashMap;
 use fnv::FnvHashMap;
@@ -38,10 +33,7 @@ extern crate regex;
 #[macro_use]
 mod types;
 use crate::types::MalErr::{ErrMalVal, ErrString};
-use crate::types::MalVal::{
-    Bool, Func, Hash, List, MalFunc, Nil, Str,
-    Sym, Vector,
-};
+use crate::types::MalVal::{Bool, Func, Hash, List, MalFunc, Nil, Str, Sym, Vector};
 use crate::types::{error, format_error, MalArgs, MalErr, MalRet, MalVal};
 mod env;
 mod printer;
@@ -50,7 +42,7 @@ 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";
+pub const ZK_CIRCUIT_ENV_KEY: &str = "ZKC";
 
 // read
 fn read(str: &str) -> MalRet {
@@ -287,9 +279,28 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
                             _ => Ok(Nil),
                         }
                     }
+
+                    Sym(ref a0sym) if a0sym == "fn*" => {
+                        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 == "eval" => {
+                        ast = eval(l[1].clone(), env.clone())?;
+                        while let Some(ref e) = env.clone().outer {
+                            env = e.clone();
+                        }
+                        continue 'tco;
+                    }
                     Sym(ref a0sym) if a0sym == "setup" => {
                         let a1 = l[1].clone();
-                        let circuit = setup(&ast)?;
+                        let circuit = setup(&ast, env.clone())?;
                         env_sets(&env, ZK_CIRCUIT_ENV_KEY, circuit);
                         eval(a1.clone(), env.clone())
                     }
@@ -298,13 +309,12 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
                         println!("prove {:?}", a1);
                         prove(a1.clone(), env.clone())
                     }
-                    Sym(ref a0sym) if a0sym == "alloc-input" => {
-                        Ok(MalVal::Nil)
-                    }
+                    Sym(ref a0sym) if a0sym == "alloc-input" => Ok(MalVal::Nil),
                     Sym(ref a0sym) if a0sym == "alloc" => {
                         let a1 = l[1].clone();
                         let a2 = l[2].clone();
                         let value = eval_ast(&a2, &env)?;
+                        println!("a1 {:?} \n value {:?}", a1, value);
                         Ok(value)
                     }
                     //Sym(ref a0sym) if a0sym == "verify" => {
@@ -319,24 +329,6 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
                         }
                         Ok(Nil)
                     }
-                    Sym(ref a0sym) if a0sym == "fn*" => {
-                        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 == "eval" => {
-                        ast = eval(l[1].clone(), env.clone())?;
-                        while let Some(ref e) = env.clone().outer {
-                            env = e.clone();
-                        }
-                        continue 'tco;
-                    }
                     _ => match eval_ast(&ast, &env)? {
                         List(ref el, _) => {
                             let ref f = el[0].clone();
@@ -373,51 +365,58 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
 
     ret
 }
-
-pub fn setup(ast: &MalVal) -> MalRet {
-    // TODO get params from ast 
+pub fn setup(ast: &MalVal, mut env: Env) -> MalRet {
+    println!("{:?}", ast);
+    // TODO get params from ast
     let start = Instant::now();
     // Create parameters for our circuit. In a production deployment these would
     // be generated securely using a multiparty computation.
-    let c = LispCircuit { params: Rc::new(vector!(vec![])) };
-    // TODO move to another fn    
-    let random_parameters = groth16::generate_random_parameters::<Bls12, _, _>(c.clone(), &mut OsRng).unwrap();
+    let mut c = LispCircuit {
+        params: vec![],
+        allocs: vec![],
+        alloc_inputs: vec![],
+        constraints: vec![],
+        env: env.clone(),
+    };
+    // TODO move to another fn
+    let random_parameters =
+        groth16::generate_random_parameters::<Bls12, _, _>(c, &mut OsRng).unwrap();
     let pvk = groth16::prepare_verifying_key(&random_parameters.vk);
     println!("Setup: [{:?}]", start.elapsed());
 
-    Ok(MalVal::Zk(Rc::new(c)))
+    Ok(MalVal::Nil)
 }
 
 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!("Circuit {:?}", c);
-    
-    // TODO remove it 
+   
+    // TODO remove it
     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![
-            ZKScalar(quantity),
-            ZKScalar(quantity * quantity),
-            ZKScalar(quantity * quantity * quantity),
-        ]]),
+    let params = {
+        let  c = LispCircuit {
+            params: vec![],
+            allocs: vec![],
+            alloc_inputs: vec![],
+            constraints: vec![],
+            env: env.clone(),
+        };
+        groth16::generate_random_parameters::<Bls12, _, _>(c, &mut OsRng).unwrap()
     };
 
+    let  circuit= LispCircuit {
+        params: vec![],
+        allocs: vec![],
+        alloc_inputs: vec![],
+        constraints: vec![],
+        env: env.clone(),
+    };
     let start = Instant::now();
     // Create a Groth16 proof with our parameters.
-    //let proof = groth16::create_random_proof(c, &params, &mut OsRng).unwrap();
+    let proof = groth16::create_random_proof(circuit, &params, &mut OsRng).unwrap();
     println!("Prove: [{:?}]", start.elapsed());
     Ok(MalVal::Nil)
-} 
+}
 
 pub fn verify(ast: &MalVal) -> MalRet {
     let public_input = vec![bls12_381::Scalar::from(27)];

lisp/new-cs.lisp

@@ -23,6 +23,13 @@
     (scalar::one cs::one)
     (scalar::one x3)  
   )
+
+  ;; (enforce 
+  ;;   (scalar::one tmp) 
+  ;;   ((scalar::one left_i) (mimc_constant cs::one)) 
+  ;;   ((scalar::one left_i_1) ((neg scalar::one) right))
+  ;;  )
+
 ))
 (prove))
 ;; (println 'verify  (MyCircuit (scalar 27)))

lisp/types.rs

@@ -1,26 +1,27 @@
-use bellman::SynthesisError;
-use bellman::ConstraintSystem;
 use bellman::Circuit;
+use bellman::ConstraintSystem;
+use bellman::SynthesisError;
 use std::cell::RefCell;
 use std::rc::Rc;
 //use std::collections::HashMap;
 use fnv::FnvHashMap;
 use itertools::Itertools;
 
+use crate::env;
 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 crate::types::MalVal::{Atom, Bool, Func, Hash, Int, List, MalFunc, Nil, Str, Sym, Vector};
 use bls12_381::Scalar;
-use sapvi::{
-    BlsStringConversion, ConstraintInstruction,
-};
+use sapvi::{BlsStringConversion, ConstraintInstruction};
 
-#[derive(Clone, Debug)]
+#[derive(Debug, Clone)]
 pub struct LispCircuit {
-    pub params: Rc<MalVal>,
+    // TODO refactor to vec
+    pub params: Vec<Option<Scalar>>,
+    pub allocs: Vec<Option<Scalar>>,
+    pub alloc_inputs: Vec<Option<Scalar>>,
+    pub constraints: Vec<Option<Scalar>>,
+    pub env: Env,
 }
 
 impl Circuit<bls12_381::Scalar> for LispCircuit {
@@ -52,10 +53,10 @@ pub enum MalVal {
         meta: Rc<MalVal>,
     },
     Atom(Rc<RefCell<MalVal>>),
-    Zk(Rc<LispCircuit>),
+    Zk(LispCircuit),
     Enforce(Rc<Vec<MalVal>>),
     // TODO maybe change to bls scalar
-    ZKScalar(bls12_381::Scalar)
+    ZKScalar(bls12_381::Scalar),
 }
 
 #[derive(Debug)]