Merge pull request #28 from narodnik/feature/lisp

Feature/lisp

Cargo.toml

@@ -83,6 +83,10 @@ path = "src/bin/zkvm.rs"
 name = "dfi"
 path = "src/bin/dfi.rs"
 
+[[bin]]
+name = "mimc"
+path = "src/old/mimc.rs"
+
 [[bin]]
 name = "dfg"
 path = "src/bin/dfg.rs"

lisp/examples/macro-test.lisp

@@ -209,7 +209,6 @@
     (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! r (nth result acc))        
@@ -226,58 +225,80 @@
         (println 'cond cond-result)
         (println 'add add-result)
         (println 'double acc val)        
+        (def! acc (i+ acc 1))        
     ))
     (println 'out val)
 )))
 
 (load-file "mimc-constants.lisp")
-(defmacro! mimc-macro (fn* [xr xl acc] (
-    (let* [tmp-xl (gensym) xl-new-value (gensym) cur-mimc-const (gensym)] (
+(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)] (
+    `(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)))
     `(def! ~tmp-xl (alloc ~tmp-xl (square (+ ~cur-mimc-const ~xl))))        
     `(enforce 
-        ((scalar::one xl) (~cur-mimc-const cs::one))
-        ((scalar::one xl) (~cur-mimc-const cs::one))
+        ((scalar::one ~xl) (~cur-mimc-const cs::one))
+        ((scalar::one ~xl) (~cur-mimc-const cs::one))
         (scalar::one ~tmp-xl)
-    )        
-    (if (= acc 321)
-        `(def! ~xl-new-value (alloc ~xl-new-value (+ (* ~tmp-xl (+ ~cur-mimc-const ~xl)) ~xr)))    
-        `(def! ~xl-new-value (alloc-input ~xl-new-value (+ (* ~tmp-xl (+ ~cur-mimc-const ~xl)) ~xr)))    
+    )   
+    `(def! new-value (+ (* ~tmp-xl (+ ~cur-mimc-const ~xl)) ~xr))
+    `(if (= ~acc 321)        
+        (def! ~xl-new-value (alloc-input ~xl-new-value new-value))
+        (def! ~xl-new-value (alloc ~xl-new-value new-value))
     )
     `(enforce 
         (scalar::one ~tmp-xl)
-        ((scalar::one xl) (~cur-mimc-const cs::one))            
-        ((scalar::one ~xl-new-value) (scalar::one::neg xr))            
+        ((scalar::one ~xl) (~cur-mimc-const cs::one))            
+        ((scalar::one ~xl-new-value) (scalar::one::neg ~xr))            
     )
-)))))
+    `{ "left" new-value }    
+    )    
+))))
+
 (def! mimc (fn* [left right] (
-    (def! xl (alloc "xl" left))
-    (def! xr (alloc "xr" right))
     (def! acc 0)
-    (dotimes 322 (
-        (println (mimc-macro xl xr acc))
-        (def! acc (i+ acc 1))
+    (def! xl left)
+    (def! xr right)
+    (dotimes 322 (        
+        (def! result (mimc-macro xl xr acc))
+        (def! result-value (get (last (last result)) "left"))
         (println acc)
+        (println xl xr)
+        (println result-value)
+        (def! xr xl)
+        (def! xl result-value)
+        (def! acc (i+ acc 1))        
     ))
 )))
 
-(def! param3 (rnd-scalar))
-;; (println 'rnd-scalar param3)
-(def! param-u (scalar "6800f4fa0f001cfc7ff6826ad58004b4d1d8da41af03744e3bce3b7793664337"))
-(def! param-v (scalar "6d81d3a9cb45dedbe6fb2a6e1e22ab50ad46f1b0473b803b3caefab9380b6a8b"))
+(def! left (scalar "15a36d1f0f390d8852a35a8c1908dd87a361ee3fd48fdf77b9819dc82d90607e"))
+(def! right (scalar "015d8c7f5b43fe33f7891142c001d9251f3abeeb98fad3e87b0dc53c4ebf1891"))
 (prove 
-  (
+  (        
+    (mimc left right)
+    ;; (def! param3 (rnd-scalar))
+    ;; (def! param-u (scalar "6800f4fa0f001cfc7ff6826ad58004b4d1d8da41af03744e3bce3b7793664337"))
+    ;; (def! param-v (scalar "6d81d3a9cb45dedbe6fb2a6e1e22ab50ad46f1b0473b803b3caefab9380b6a8b"))
     ;; (jj-mul param-u param-v param3)
-    (mimc param-u param-v)
   )
 )
 
 ;; following some examples 
-;; (def! alloc-u (alloc "alloc-u" param-u))
-;;     (def! alloc-v (alloc "alloc-v" param-v))
-;;     (def! condition (alloc "condition" param3))
-;;     (println 'conditionally_select 
-;;         (conditionally_select alloc-u alloc-v condition))
+;; (def! param3 (rnd-scalar))
+;; (def! param-u (scalar "6800f4fa0f001cfc7ff6826ad58004b4d1d8da41af03744e3bce3b7793664337"))
+;; (def! param-v (scalar "6d81d3a9cb45dedbe6fb2a6e1e22ab50ad46f1b0473b803b3caefab9380b6a8b"))
+;; (jj-mul param-u param-v param3)
+;; (def! param3 (rnd-scalar))
+;; (println 'rnd-scalar param3)
+;; (def! param-u (scalar "6800f4fa0f001cfc7ff6826ad58004b4d1d8da41af03744e3bce3b7793664337"))
+;; (def! param-v (scalar "6d81d3a9cb45dedbe6fb2a6e1e22ab50ad46f1b0473b803b3caefab9380b6a8b"))
+;; (println (zk-mul param1 param2))
+;; (jj-mul param-u param-v param3)
 ;; (println (zk-mul param1 param2))
 ;; (def! param1 (scalar 3))
 ;; (def! param2 (scalar 9))

lisp/examples/util.lisp

@@ -2,9 +2,13 @@
 (def! gensym
   (let* [counter (atom 0)]
     (fn* []
-      ;; (symbol (str "G__" (genrand) (swap! counter inc))))))
       (symbol (str "G__" (swap! counter inc))))))
 
+(def! gensym2
+  (let* [counter (atom 0)]
+    (fn* [name]
+      (symbol (str name "__" (swap! counter inc))))))
+
 ;; Like load-file, but will never load the same path twice.
 
 ;; This file is normally loaded with `load-file`, so it needs a

lisp/lisp.rs

@@ -291,7 +291,7 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
                     Sym(ref a0sym) if a0sym == "dotimes" => {
                         match eval(l[1].clone(), env.clone())? {
                             MalVal::Int(v) => {
-                                for _i in 1..v {
+                                for _i in 0..v {
                                     eval(l[2].clone(), env.clone())?;
                                 }
                                 Ok(Nil)
@@ -517,7 +517,7 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
                         // );
                         // println!("enforce here {:?}", get_enforce_allocs_nested(&env));
 
-                        Ok(MalVal::Nil)
+                        Ok(MalVal::Str("enforce-eof".to_string()))
                     }
                     _ => match eval_ast(&ast, &env)? {
                         List(ref el, _) => {

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) }
                         }
                     }
                 }

run_mimc.sh

@@ -1,5 +1,5 @@
 #!/bin/bash -x
-python scripts/preprocess.py proofs/mimc.psm > /tmp/mimc.psm || exit $?
-python scripts/compile.py --supervisor /tmp/mimc.psm --output mimc.zcd || exit $?
+python3 scripts/preprocess.py proofs/mimc.psm > /tmp/mimc.psm || exit $?
+python3 scripts/compile.py --supervisor /tmp/mimc.psm --output mimc.zcd || exit $?
 cargo run --release --bin mimc
 

run_mimc2.sh

@@ -1,6 +1,6 @@
 #!/bin/bash -x
-python scripts/preprocess.py proofs/mimc.psm > /tmp/mimc.psm || exit $?
-python scripts/compile.py --supervisor /tmp/mimc.psm --output mimc.zcd || exit $?
+python3 scripts/preprocess.py proofs/mimc.psm > /tmp/mimc.psm || exit $?
+python3 scripts/compile.py --supervisor /tmp/mimc.psm --output mimc.zcd || exit $?
 cargo run --release --bin zkvm -- init mimc.zcd mimc.zts
 cargo run --release --bin zkvm -- prove mimc.zcd mimc.zts proofs/mimc.params mimc.prf
 cargo run --release --bin zkvm -- verify mimc.zcd mimc.zts mimc.prf

src/bin/mimc.rs

@@ -94,6 +94,9 @@ fn main() -> Result<()> {
         0x015d_8c7f_5b43_fe33,
     ]);
 
+    println!("----> {:?}", left);
+    println!("----> {:?}", right);
+    
     contract.set_param("left_0", left.clone())?;
     contract.set_param("right", right.clone())?;
 

src/old/mimc.rs

@@ -4,9 +4,16 @@ use rand::thread_rng;
 // For benchmarking
 use std::time::{Duration, Instant};
 
+// from string scalar
+use sapvi::bls_extensions::BlsStringConversion;
+
 // Bring in some tools for using finite fiels
 use ff::{Field, PrimeField};
 
+// mimc constants
+mod mimc_constants;
+use mimc_constants::mimc_constants;
+
 // We're going to use the BLS12-381 pairing-friendly elliptic curve.
 use bls12_381::{Bls12, Scalar};
 
@@ -49,6 +56,20 @@ fn mimc<Scalar: PrimeField>(mut xl: Scalar, mut xr: Scalar, constants: &[Scalar]
     xl
 }
 
+macro_rules! from_slice {
+    ($data:expr, $len:literal) => {{
+        let mut array = [0; $len];
+        // panics if not enough data
+        let bytes = &$data[..array.len()];
+        assert_eq!(bytes.len(), array.len());
+        for (a, b) in array.iter_mut().rev().zip(bytes.iter()) {
+            *a = *b;
+        }
+        //array.copy_from_slice(bytes.iter().rev());
+        array
+    }};
+}
+
 /// This is our demo circuit for proving knowledge of the
 /// preimage of a MiMC hash invocation.
 struct MiMCDemo<'a, Scalar: PrimeField> {
@@ -84,9 +105,13 @@ impl<'a, Scalar: PrimeField> Circuit<Scalar> for MiMCDemo<'a, Scalar> {
 
             // tmp = (xL + Ci)^2
             let tmp_value = xl_value.map(|mut e| {
+                println!("{:?}", e);
                 e.add_assign(&self.constants[i]);
                 e.square()
             });
+            
+            // println!("tmp_value {:?} {:?}", self.constants[i], tmp_value);
+
             let tmp = cs.alloc(
                 || "tmp",
                 || tmp_value.ok_or(SynthesisError::AssignmentMissing),
@@ -130,6 +155,10 @@ impl<'a, Scalar: PrimeField> Circuit<Scalar> for MiMCDemo<'a, Scalar> {
                 |lc| lc + new_xl - xr,
             );
 
+            println!("{:?}", i);
+            println!("{:?} {:?}", xl_value, xr_value);
+            println!("{:?}", new_xl_value);
+
             // xR = xL
             xr = xl;
             xr_value = xl_value;
@@ -146,10 +175,19 @@ impl<'a, Scalar: PrimeField> Circuit<Scalar> for MiMCDemo<'a, Scalar> {
 fn main() {
     use rand::rngs::OsRng;
 
-    // Generate the MiMC round constants
-    let constants = (0..MIMC_ROUNDS)
-        .map(|_| Scalar::random(&mut OsRng))
-        .collect::<Vec<_>>();
+    // // Generate the MiMC round constants
+    // let constants = (0..MIMC_ROUNDS)
+    //     .map(|_| Scalar::random(&mut OsRng))
+    //     .collect::<Vec<_>>();
+
+    let mut constants = Vec::new();
+    for const_str in mimc_constants() {
+        let bytes = from_slice!(&hex::decode(const_str).unwrap(), 32);
+        assert_eq!(bytes.len(), 32);
+        let constant = Scalar::from_bytes(&bytes).unwrap();
+
+        constants.push(constant);
+    }
 
     println!("Creating parameters...");
 
@@ -170,7 +208,7 @@ fn main() {
     println!("Creating proofs...");
 
     // Let's benchmark stuff!
-    const SAMPLES: u32 = 10;
+    const SAMPLES: u32 = 1;
     let mut total_proving = Duration::new(0, 0);
     let mut total_verifying = Duration::new(0, 0);
 
@@ -180,8 +218,10 @@ fn main() {
 
     for _ in 0..SAMPLES {
         // Generate a random preimage and compute the image
-        let xl = Scalar::random(&mut OsRng);
-        let xr = Scalar::random(&mut OsRng);
+        // let xl = Scalar::random(&mut OsRng);
+        // let xr = Scalar::random(&mut OsRng);
+        let xl = bls12_381::Scalar::from_string("15a36d1f0f390d8852a35a8c1908dd87a361ee3fd48fdf77b9819dc82d90607e");
+        let xr = bls12_381::Scalar::from_string("015d8c7f5b43fe33f7891142c001d9251f3abeeb98fad3e87b0dc53c4ebf1891");
         let image = mimc(xl, xr, &constants);
 
         proof_vec.truncate(0);