added some debug

lisp/core.rs

@@ -15,6 +15,7 @@ use crate::types::{MalArgs, MalRet, MalVal, _assoc, _dissoc, atom, error, func,
 
 use bls12_381;
 use ff::{Field, PrimeField};
+use rand::rngs::OsRng;
 
 use sapvi::bls_extensions::BlsStringConversion;
 
@@ -167,7 +168,7 @@ fn unpack_bits(a: MalArgs) -> MalRet {
     match a[0].clone() {
         Str(ref s) => {
             let value = bls12_381::Scalar::from_string(s);
-            for (_, bit) in value.to_le_bits().into_iter().cloned().enumerate() {
+            for (_, bit) in value.to_le_bits().into_iter().enumerate() {
                 match bit {
                     true => result.push(bls12_381::Scalar::one()),
                     false => result.push(bls12_381::Scalar::zero()),
@@ -179,7 +180,7 @@ fn unpack_bits(a: MalArgs) -> MalRet {
                 .collect::<Vec<MalVal>>()))
         }
         ZKScalar(ref s) => {
-            for (_, bit) in s.to_le_bits().into_iter().cloned().enumerate() {
+            for (_, bit) in s.to_le_bits().into_iter().enumerate() {
                 match bit {
                     true => result.push(bls12_381::Scalar::one()),
                     false => result.push(bls12_381::Scalar::zero()),
@@ -647,6 +648,12 @@ fn gen_rand(a: MalArgs) -> MalRet {
     Ok(MalVal::Int(rng.gen::<i64>()))
 }
 
+fn scalar_rnd(a: MalArgs) -> MalRet {
+    let randomness_value: jubjub::Fr = jubjub::Fr::random(&mut OsRng);
+    let value = bls12_381::Scalar::from_bytes(&randomness_value.to_bytes());
+    Ok(MalVal::ZKScalar(value.unwrap()))
+}
+
 pub fn ns() -> Vec<(&'static str, MalVal)> {
     vec![
         ("=", func(|a| Ok(Bool(a[0] == a[1])))),
@@ -756,5 +763,6 @@ pub fn ns() -> Vec<(&'static str, MalVal)> {
         ("double", func(scalar_double)),
         ("invert", func(scalar_invert)),
         ("zero?", func(scalar_is_zero)),
+        ("rnd-scalar", func(scalar_rnd)),
     ]
 }

lisp/examples/macro-test.lisp

@@ -149,6 +149,8 @@
     (let* [u1 (gensym) v1 (gensym) u2 (gensym) v2 (gensym)
            EDWARDS_D (gensym) U (gensym) A (gensym) B (gensym)
            C (gensym) u3 (gensym) v3 (gensym)] (
+        ;; debug
+        `(println 'jj-add ~param1 ~param2 ~param3 ~param4)
         `(def! ~u1 (alloc ~u1 ~param1))
         `(def! ~v1 (alloc ~v1 ~param2))
         `(def! ~u2 (alloc ~u2 ~param3))
@@ -205,23 +207,32 @@
 (def! jj-mul (fn* [u v b] (
     (def! result (unpack-bits b))
     (eval (map zk-boolean result))
-    (def! val (last (last (zk-double param-u param-v))))
-    (def! acc 1)
-    (dotimes (count result) (            
+    (def! val (last (last (zk-double u v))))
+    (def! acc 0)
+    (dotimes (count result) (                    
+        (def! acc (i+ acc 1))        
         (def! u3 (get val "u3"))
-        (def! v3 (get val "v3"))
-        (def! val (last (last (zk-double u3 v3))))     
-        (def! r (nth result acc))
+        (def! v3 (get val "v3"))            
+        (def! r (nth result acc))        
         (def! cond-result (last (last (conditionally-select u3 v3 r))))
         (def! u-prime (get cond-result "u-prime"))
-        (def! v-prime (get cond-result "v-prime"))
+        (def! v-prime (get cond-result "v-prime"))        
         (def! add-result (last (jj-add u3 v3 u-prime v-prime)))               
-        (def! acc (i+ acc 1))
-        (println acc u3 v3 u-prime v-prime cond-result add-result)        
+        (def! u-add (get add-result "u3"))
+        (def! v-add (get add-result "v3"))        
+        (def! val (last (last (zk-double u-add v-add))))             
+        ;; debug
+        (println 'first-double val)
+        (println 'r r)
+        (println 'cond cond-result)
+        (println 'add cond-result)
+        (println 'double acc val)        
     ))
+    (println 'out val)
 )))
 
-(def! param3 (scalar "0000000000000000000000000000000000000000000000000000000000000000"))
+(def! param3 (rnd-scalar))
+(println param3)
 (def! param-u (scalar "273f910d9ecc1615d8618ed1d15fef4e9472c89ac043042d36183b2cb4d7ef51"))
 (def! param-v (scalar "466a7e3a82f67ab1d32294fd89774ad6bc3332d0fa1ccd18a77a81f50667c8d7"))
 (def! param1 (scalar 42))

proofs/mint2.psm

@@ -271,7 +271,7 @@ constant G_VCV_v 0x466a7e3a82f67ab1d32294fd89774ad6bc3332d0fa1ccd18a77a81f50667c
     # Performs a scalar multiplication of this twisted Edwards
     # point by a scalar represented as a sequence of booleans
     # in little-endian bit order.
-
+    
     {% for i in range(n) %}
         {% if i == 0 %}
             {{ jubjub_conditionally_select(