debuging jubjub mul

lisp/core.rs

@@ -383,6 +383,9 @@ fn negate_from(a: MalArgs) -> MalRet {
 
 fn scalar_from(a: MalArgs) -> MalRet {
     match a[0].clone() {
+        ZKScalar(s0) => {
+            Ok(ZKScalar(s0))
+        }
         Str(a0) => {
             let s0 = bls12_381::Scalar::from_string(&a0.to_string());
             Ok(ZKScalar(s0))
@@ -391,7 +394,7 @@ fn scalar_from(a: MalArgs) -> MalRet {
             let s0 = bls12_381::Scalar::from(a0 as u64);
             Ok(ZKScalar(s0))
         }
-        _ => error("expected (string or int)"),
+        _ => error("scalar from expected (string or int)"),
     }
 }
 

lisp/jubjub-mul.lisp

@@ -6,20 +6,7 @@
 
 (setup
     (prove 
-(
-    (zk* [
-      u11 (alloc "u11" (scalar 2))
-      v11 (alloc "v11" (scalar 2))
-      U1 (alloc-input "U1" (* u11 v11))
-      ]
-  (
-    (enforce  
-      (scalar::one u11) 
-      (scalar::one v11)
-      (scalar::one U1)
-    )
-  )
-  )
+      (
     (zk* [
       u1 (alloc "u1" param1)
       v1 (alloc "v1" param2)

lisp/lisp.rs

@@ -593,7 +593,6 @@ pub fn prove(_ast: MalVal, env: Env) -> MalRet {
     let proof = groth16::create_random_proof(circuit, params.as_ref().unwrap(), &mut OsRng)?;
     let mut vec_input = vec![];
     for (k, val) in allocs_input.iter() {
-        println!("{:?}", val);
         match val {
             MalVal::Str(v) => {
                 vec_input.push(bls12_381::Scalar::from_string(&v.to_string()));
@@ -605,8 +604,8 @@ pub fn prove(_ast: MalVal, env: Env) -> MalRet {
         };
     }
     let result = groth16::verify_proof(verifying_key.as_ref().unwrap(), &proof, &vec_input);
-    println!("{:?}", result);
     println!("vec public {:?}", vec_input);
+    println!("result {:?}", result);
 
     Ok(MalVal::Nil)
 }

lisp/types.rs

@@ -142,7 +142,7 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                         }
                     }
                 }
-                println!("left: a {:?} b {:?} val_b: {:?}", a, b, val_b);
+//                println!("left: a {:?} b {:?} val_b: {:?}", a, b, val_b);
             }
 
             for values in alloc_value.right.iter() {
@@ -156,7 +156,7 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                 } else if a == "scalar::one::neg" {
                     right = right + (coeff.neg(), val_b);
                 }
-                println!("right: a {:?} b {:?} val_b: {:?}", a, b, val_b);
+                //println!("right: a {:?} b {:?} val_b: {:?}", a, b, val_b);
             }
 
             for values in alloc_value.output.iter() {
@@ -170,7 +170,7 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                 } else if a == "scalar::one::neg" {
                     output = output + (coeff.neg(), val_b);
                 }
-                println!("output: a {:?} b {:?} val_b: {:?}", a, b, val_b);
+                //println!("output: a {:?} b {:?} val_b: {:?}", a, b, val_b);
             }
 
             println!("Enforcing ...");