we have mimc proof

lisp/examples/macro-test.lisp

@@ -232,8 +232,11 @@
 
 (load-file "mimc-constants.lisp")
 (defmacro! mimc-macro (fn* [left-value right-value acc] (
-    (let* [tmp-xl (gensym2 'tmp_xl) xl-new-value (gensym2 'xl_new_value) cur-mimc-const (gensym2 'cur_mimc_const)
-        xl (gensym2 'xl) xr (gensym2 'xr)] (
+    (let* [tmp-xl (gensym2 'tmp_xl) 
+        xl-new-value (gensym2 'xl_new_value) 
+        cur-mimc-const (gensym2 'cur_mimc_const)
+        xl (gensym2 'xl) 
+        xr (gensym2 'xr)] (
     `(def! ~xl (alloc ~xl ~left-value))
     `(def! ~xr (alloc ~xr ~right-value))
     `(def! ~cur-mimc-const (alloc-const ~cur-mimc-const (nth mimc-constants ~acc)))

lisp/types.rs

@@ -75,19 +75,19 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
         let mut variables: FnvHashMap<String, Variable> = FnvHashMap::default();
         let mut params_const = self.params;
 
-        println!("Allocations\n");
+        // println!("Allocations\n");
         for (k, v) in &self.allocs {
             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);
+                    // 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!("k {:?} v {:?} var {:?}", k, v, var);
                 }
                 _ => {
                     println!("not allocated k {:?} v {:?}", k, v);
@@ -95,19 +95,19 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
             }
         }
 
-        println!("Allocations Input\n");
+        // println!("Allocations Input\n");
         for (k, v) in &self.alloc_inputs {
             match v {
                 MalVal::ZKScalar(val) => {
                     let var = cs.alloc_input(|| k, || Ok(*val))?;
                     variables.insert(k.to_string(), var);
-                    println!("k {:?} v {:?} var {:?}", k, v, 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!("k {:?} v {:?} var {:?}", k, v, var);
                 }
                 _ => {
                     println!("not allocated k {:?} v {:?}", k, v);
@@ -119,7 +119,7 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
         let mut enforce_sorted = self.constraints.clone();
         enforce_sorted.sort_by(|a, b| a.idx.cmp(&b.idx));
         for alloc_value in enforce_sorted.iter() {
-            println!("Enforce -> {:?}", alloc_value);
+            // println!("Enforce -> {:?}", alloc_value);
             let coeff = bls12_381::Scalar::one();
             let mut left = bellman::LinearCombination::<Scalar>::zero();
             let mut right = bellman::LinearCombination::<Scalar>::zero();
@@ -136,8 +136,15 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                     left = left + (coeff.neg(), val_b);
                 } else {
                     if let Some(value) = params_const.get(a) {
-                        if let MalVal::ZKScalar(val) = value {
-                            left = left + (*val, val_b);
+                        match value {
+                            MalVal::ZKScalar(val) => {
+                                left = left + (*val, val_b);
+                            }
+                            MalVal::Str(s) => {
+                                let val = bls12_381::Scalar::from_string(&s.to_string());
+                                left = left + (val, val_b);
+                            }
+                            _ => { println!("not a valid param {:?}", value) }
                         }
                     }
                 }
@@ -156,8 +163,15 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                     right = right + (coeff.neg(), val_b);
                 } else {
                     if let Some(value) = params_const.get(a) {
-                        if let MalVal::ZKScalar(val) = value {
-                            right = right + (*val, val_b);
+                        match value {
+                            MalVal::ZKScalar(val) => {
+                                right = right + (*val, val_b);
+                            }
+                            MalVal::Str(s) => {
+                                let val = bls12_381::Scalar::from_string(&s.to_string());
+                                right = right + (val, val_b);
+                            }
+                            _ => { println!("not a valid param {:?}", value) }
                         }
                     }
                 }
@@ -177,8 +191,15 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                     output = output + (coeff.neg(), val_b);
                 } else {
                     if let Some(value) = params_const.get(a) {
-                        if let MalVal::ZKScalar(val) = value {
-                            output = output + (*val, val_b);
+                        match value {
+                            MalVal::ZKScalar(val) => {
+                                output = output + (*val, val_b);
+                            }
+                            MalVal::Str(s) => {
+                                let val = bls12_381::Scalar::from_string(&s.to_string());
+                                output = output + (val, val_b);
+                            }
+                            _ => { println!("not a valid param {:?}", value) }
                         }
                     }
                 }