jubjub-add fixed

lisp/jubjub-add.lisp

@@ -1,8 +1,8 @@
 (println "jubjub-add.lisp")
-(def! param1 (scalar "15a36d1f0f390d8852a35a8c1908dd87a361ee3fd48fdf77b9819dc82d90607e"))
-(def! param2 (scalar "015d8c7f5b43fe33f7891142c001d9251f3abeeb98fad3e87b0dc53c4ebf1891"))
-(def! param3 (scalar "15a36d1f0f390d8852a35a8c1908dd87a361ee3fd48fdf77b9819dc82d90607e"))
 (def! param4 (scalar "015d8c7f5b43fe33f7891142c001d9251f3abeeb98fad3e87b0dc53c4ebf1891"))
+(def! param3 (scalar "15a36d1f0f390d8852a35a8c1908dd87a361ee3fd48fdf77b9819dc82d90607e"))
+(def! param2 (scalar "015d8c7f5b43fe33f7891142c001d9251f3abeeb98fad3e87b0dc53c4ebf1891"))
+(def! param1 (scalar "15a36d1f0f390d8852a35a8c1908dd87a361ee3fd48fdf77b9819dc82d90607e"))
 
 (
     (let* [
@@ -11,7 +11,7 @@
       u2 (alloc-input  "u2" param3)
       v2 (alloc-input  "v2" param4)
       EDWARDS_D (alloc-const "EDWARDS_D" (scalar "2a9318e74bfa2b48f5fd9207e6bd7fd4292d7f6d37579d2601065fd6d6343eb1"))
-      U (alloc "U" (* (+ u1 u2) (+ v1 v2)))
+      U (alloc "U" (* (+ u1 v1) (+ u2 v2)))
       A (alloc "A" (* v2 u1))
       B (alloc "B" (* u2 v1))
       C (alloc "C" (* EDWARDS_D (* A B)))
@@ -32,14 +32,14 @@
     (scalar::one C)
   )
   (enforce
-    (scalar::one C)
+    ((scalar::one cs::one)(scalar::one C))
     (scalar::one u3)
     ((scalar::one A) (scalar::one B))
   )
   (enforce
-    (scalar::one::neg C)
+    ((scalar::one cs::one) (scalar::one::neg C))
     (scalar::one v3)
-    ((scalar::one::neg U) (scalar::one::neg A) (scalar::one::neg B))
+    ((scalar::one U) (scalar::one::neg A) (scalar::one::neg B))
   )
   )
  )

lisp/lisp.rs

@@ -546,10 +546,7 @@ pub fn prove(_ast: MalVal, env: Env) -> MalRet {
     let enforce_allocs = get_enforce_allocs(&env);
     let allocs_const = get_allocations(&env, "AllocationsConst");
 
-    // todo some refactor to improve this 
     let params = Some({
-//        todo check if we do need to pass everything like this, its important to 
-//        remember that this function runs after the evaluation, we have all allocs in memory now with all enfores
     let circuit = LispCircuit {
         params: allocs_const.as_ref().clone(),
         allocs: allocs.as_ref().clone(),

lisp/types.rs

@@ -77,16 +77,17 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
 
         println!("Allocations\n");
         for (k, v) in &self.allocs {
-            println!("k {:?} v {:?}", k, v);
             match v {
                 MalVal::ZKScalar(val) => {
                     let var = cs.alloc(|| k, || Ok(*val))?;
                     variables.insert(k.to_string(), var);
+                    println!("k {:?} v {:?} var {:?}", k, v, var);
                 }
                 MalVal::Str(val) => {
                     let val_scalar = bls12_381::Scalar::from_string(&*val);
                     let var = cs.alloc(|| k, || Ok(val_scalar))?;
                     variables.insert(k.to_string(), var);
+                    println!("k {:?} v {:?} var {:?}", k, v, var);
                 }
                 _ => {
                     println!("not allocated k {:?} v {:?}", k, v);
@@ -101,11 +102,13 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                 MalVal::ZKScalar(val) => {
                     let var = cs.alloc_input(|| k, || Ok(*val))?;
                     variables.insert(k.to_string(), var);
+                    println!("k {:?} v {:?} var {:?}", k, v, var);
                 }
                 MalVal::Str(val) => {
                     let val_scalar = bls12_381::Scalar::from_string(&*val);
                     let var = cs.alloc_input(|| k, || Ok(val_scalar))?;
                     variables.insert(k.to_string(), var);
+                    println!("k {:?} v {:?} var {:?}", k, v, var);
                 }
                 _ => {
                     println!("not allocated k {:?} v {:?}", k, v);