added prove

lisp/jubjub-add.lisp

@@ -1,33 +1,29 @@
 (println "jubjub-add.lisp")
-;; Compute U = (u1 + v1) * (v2 - EDWARDS_A*u2)
-;;           = (u1 + v1) * (u2 + v2)
-( (let* [
+(def! param1 (scalar "15a36d1f0f390d8852a35a8c1908dd87a361ee3fd48fdf77b9819dc82d90607e"))
+(def! param2 (scalar "015d8c7f5b43fe33f7891142c001d9251f3abeeb98fad3e87b0dc53c4ebf1891"))
+(def! param3 (scalar "15a36d1f0f390d8852a35a8c1908dd87a361ee3fd48fdf77b9819dc82d90607e"))
+(def! param4 (scalar "015d8c7f5b43fe33f7891142c001d9251f3abeeb98fad3e87b0dc53c4ebf1891"))
+
+(
+    (let* [
+      u1 (alloc-input "u1" param1)
+      v1 (alloc-input "v1" param2)
+      u2 (alloc-input  "u2" param3)
+      v2 (alloc-input  "v2" param4)
       EDWARDS_D (alloc-const "EDWARDS_D" (scalar "2a9318e74bfa2b48f5fd9207e6bd7fd4292d7f6d37579d2601065fd6d6343eb1"))
-      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)))
-      ;; Compute u3 = (A + B) / (1 + C)
       u3 (alloc "u3" (/ (+ A B) (+ scalar::one C)))
-      ;; Compute v3 = (U - A - B) / (1 - C)
       v3 (alloc "v3" (/ (- (- U A) B) (- scalar::one C)))
       ]
-(prove
- (setup 
+    (prove
+        (setup 
   (
   (enforce  
-    (
-     (scalar::one u1)
-     (scalar::one v1)
-    )
-    (
-     (scalar::one u2)
-     (scalar::one v2)
-    )
+    ((scalar::one u1) (scalar::one v1))
+    ((scalar::one u2) (scalar::one v2))
     (scalar::one U)
   )
   (enforce
@@ -47,7 +43,5 @@
   )
   )
  )
-)
-)
- )
+)))
 ;; (println 'verify  (MyCircuit (scalar 27)))

lisp/lisp.rs

@@ -527,11 +527,11 @@ pub fn setup(_ast: MalVal, env: Env) -> Result<PreparedVerifyingKey<Bls12>, MalE
     let enforce_allocs = get_enforce_allocs(&env);
 
     let c = LispCircuit {
-        params: allocs_const.as_ref().clone(),
-        allocs: allocs.as_ref().clone(),
-        alloc_inputs: allocs_input.as_ref().clone(),
-        constraints: enforce_allocs,
-        env: env.clone(),
+        params: None,
+        allocs: None,
+        alloc_inputs: None,
+        constraints: None,
+        env: None 
     };
     // TODO move to another fn
     let random_parameters =
@@ -548,26 +548,48 @@ pub fn prove(_ast: MalVal, env: Env) -> MalRet {
     let enforce_allocs = get_enforce_allocs(&env);
     let allocs_const = get_allocations(&env, "AllocationsConst");
 
-    let circuit = LispCircuit {
-        params:  allocs_const.as_ref().clone(),
-        allocs: allocs.as_ref().clone(),
-        alloc_inputs: allocs_input.as_ref().clone(),
-        constraints: enforce_allocs,
-        env: env.clone(),
-    };
-    // Create an instance of our circuit (with the preimage as a witness).
-    // todo check if circuit.clone is valid
     let params = {
-        let c = circuit.clone();
+        let c = LispCircuit {
+        params: Some(FnvHashMap::default()), 
+        allocs: Some(FnvHashMap::default()),
+        alloc_inputs: Some(FnvHashMap::default()),
+        constraints: Some(vec![]),
+        env: Some(env.clone()) 
+        };
         groth16::generate_random_parameters::<Bls12, _, _>(c, &mut OsRng).unwrap()
     };
+    let pvk = groth16::prepare_verifying_key(&params.vk);
+
+    let circuit = LispCircuit {
+        params:  Some(allocs_const.as_ref().clone()),
+        allocs: Some(allocs.as_ref().clone()),
+        alloc_inputs:  Some(allocs_input.as_ref().clone()),
+        constraints:  Some(enforce_allocs),
+        env: Some(env.clone())
+    };
     let start = Instant::now();
-    // Create a Groth16 proof with our parameters.
-    let proof = groth16::create_random_proof(circuit, &params, &mut OsRng).unwrap();
-    println!("Prove: [{:?}]", start.elapsed());
-    let mut file = File::create("prove.out").unwrap();
-    proof.write(file);
-    Ok(MalVal::Nil)
+    let proof = groth16::create_random_proof(circuit, &params, &mut OsRng);
+    match proof {
+        _ => {
+            println!("Prove: [{:?}]", start.elapsed());
+            let mut file = File::create("prove.out").unwrap();
+            //proof.write(file);
+
+            let mut vec_input = vec![];
+            for (k, val) in allocs_input.iter() {
+                if let MalVal::ZKScalar(v) = val {
+                    vec_input.push(*v); 
+                }
+            }
+//            let verify_result = groth16::verify_proof(&pvk, &proof, &vec_input.as_slice()).is_ok();
+//            println!("{:?}", verify_result);
+        }
+        Err(e) => {
+            println!("{:?}", e);
+        }
+    };
+    Ok(MalVal::Nil) 
+
 }
 
 pub fn verify(_ast: &MalVal) -> MalRet {

lisp/run.sh

@@ -1,2 +1,2 @@
-#export RUST_BACKTRACE=full
+export RUST_BACKTRACE=full
 cargo run --bin lisp load jubjub-add.lisp

lisp/types.rs

@@ -28,11 +28,11 @@ pub struct EnforceAllocation {
 
 #[derive(Debug, Clone)]
 pub struct LispCircuit {
-    pub params: FnvHashMap<String, MalVal>,
-    pub allocs: FnvHashMap<String, MalVal>,
-    pub alloc_inputs: FnvHashMap<String, MalVal>,
-    pub constraints: Vec<EnforceAllocation>,
-    pub env: Env,
+    pub params: Option<FnvHashMap<String, MalVal>>,
+    pub allocs: Option<FnvHashMap<String, MalVal>>,
+    pub alloc_inputs: Option<FnvHashMap<String, MalVal>>,
+    pub constraints: Option<Vec<EnforceAllocation>>,
+    pub env: Option<Env>,
 }
 
 impl Circuit<bls12_381::Scalar> for LispCircuit {
@@ -41,9 +41,10 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
         cs: &mut CS,
     ) -> Result<(), SynthesisError> {
         let mut variables: FnvHashMap<String, Variable> = FnvHashMap::default();
+        let mut params_const = self.params.unwrap_or(FnvHashMap::default()); 
 
         println!("Allocations\n");
-        for (k, v) in &self.allocs {
+        for (k, v) in &self.allocs.unwrap_or(FnvHashMap::default()) {
             println!("k {:?} v {:?}", k, v);
             match v {
                 MalVal::ZKScalar(val) => {
@@ -62,7 +63,7 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
         }
 
         println!("Allocations Input\n");
-        for (k, v) in &self.alloc_inputs {
+        for (k, v) in &self.alloc_inputs.unwrap_or(FnvHashMap::default()) {
             println!("k {:?} v {:?}", k, v);
             match v {
                 MalVal::ZKScalar(val) => {
@@ -81,7 +82,8 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
         }
 
         println!("Enforce Allocations\n");
-        for alloc_value in &self.constraints {
+        for alloc_value in &self.constraints.unwrap_or(Vec::<EnforceAllocation>::new()) {
+            println!("{:?}", alloc_value);
             let coeff = bls12_381::Scalar::one();
             let mut left = bellman::LinearCombination::<Scalar>::zero();
             let mut right = bellman::LinearCombination::<Scalar>::zero();
@@ -97,7 +99,7 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                 } else if a == "scalar::one::neg" {
                     left = left + (coeff.neg(), val_b);
                 } else {
-                    if let Some(value) = self.params.get(a) {
+                    if let Some(value) = params_const.get(a) {
                         if let MalVal::ZKScalar(val) = value {
                             left = left + (*val, val_b);
                         }