triple programming fix

lisp/examples/mint2.lisp

@@ -272,7 +272,7 @@
     `(def! ~digit (alloc-const ~digit ~value-digit))
     `(enforce 
         (scalar::one ~bit) 
-        (scalar::one::neg ~bit) 
+        ((scalar::one cs::one) (scalar::one::neg ~bit))
         () 
     )    
     { "lc" ((str digit) (str bit)) }
@@ -280,16 +280,20 @@
 
 (def! rangeproof (fn* [value] (    
     (def! values-bit (unpack-bits value))
-    (def! acc 0)
-    (def! digit scalar::one)    
+    (def! idx 0)
+    (def! digit (scalar 1))
     (def! value-result ())
     (dotimes 64 (
-        (def! bit (nth values-bit acc))    
+        (def! bit (nth values-bit idx))    
         (def! value-result 
-            (conj value-result (get (last (last (rangeproof-alloc bit digit))) "lc")))
+            (conj value-result 
+            (get (last (last 
+                (rangeproof-alloc bit digit))) "lc")))
+        (println 'digit digit 'bit bit)
         (def! digit (double digit))
-        (def! acc (i+ acc 1))
+        (def! idx (i+ idx 1))
     ))
+    (println 'value-result value-result)
     (def! value-alloc (alloc-input "value-alloc" value))
     (enforce 
         (value-result)
@@ -302,6 +306,7 @@
   (            
     (def! param-u (scalar "6800f4fa0f001cfc7ff6826ad58004b4d1d8da41af03744e3bce3b7793664337"))
     (def! param-v (scalar "6d81d3a9cb45dedbe6fb2a6e1e22ab50ad46f1b0473b803b3caefab9380b6a8b"))
+    (def! param-a (scalar 110))
     (rangeproof param-u)
     ;; (def! param3 (rnd-scalar))
     ;; (jj-mul param-u param-v param3)

lisp/types.rs

@@ -147,6 +147,13 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                                 let val = bls12_381::Scalar::from_string(&s.to_string());
                                 left = left + (val, val_b);
                             }
+                            MalVal::Func(_, _) => {
+                                if let MalVal::Vector(val, _) = value.apply(vec![]).unwrap() {
+                                    if let MalVal::ZKScalar(res) = val.to_vec()[0] {
+                                        left = left + (res, val_b);
+                                    }
+                                }
+                            }
                             _ => {
                                 println!("not a valid param {:?}", value)
                             }
@@ -176,6 +183,13 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                                 let val = bls12_381::Scalar::from_string(&s.to_string());
                                 right = right + (val, val_b);
                             }
+                            MalVal::Func(_, _) => {
+                                if let MalVal::Vector(val, _) = value.apply(vec![]).unwrap() {
+                                    if let MalVal::ZKScalar(res) = val.to_vec()[0] {
+                                        right = right + (res, val_b);
+                                    }
+                                }
+                            }
                             _ => {
                                 println!("not a valid param {:?}", value)
                             }
@@ -206,6 +220,13 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                                 let val = bls12_381::Scalar::from_string(&s.to_string());
                                 output = output + (val, val_b);
                             }
+                            MalVal::Func(_, _) => {
+                                if let MalVal::Vector(val, _) = value.apply(vec![]).unwrap() {
+                                    if let MalVal::ZKScalar(res) = val.to_vec()[0] {
+                                        output = output + (res, val_b);
+                                    }
+                                }
+                            }
                             _ => {
                                 println!("not a valid param {:?}", value)
                             }