cleaning code

lisp/core.rs

@@ -1,31 +1,28 @@
 use std::fs::File;
 use std::io::Read;
 use std::rc::Rc;
-use std::sync::Mutex;
+
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use crate::printer::pr_seq;
 use crate::reader::read_str;
 use crate::types::MalErr::ErrMalVal;
 use crate::types::MalVal::{
-    Atom, Bool, Func, Hash, Int, List, MalFunc, Nil, Private, Public, Str,
-    Sym, Vector, Params
+    Atom, Bool, Func, Hash, Int, List, MalFunc, Nil, Str,
+    Sym, Vector
 };
 use crate::types::{MalArgs, MalRet, MalVal, _assoc, _dissoc, atom, error, func, hash_map};
 use bellman::{gadgets::Assignment, groth16, Circuit, ConstraintSystem, SynthesisError};
-use bls12_381::Bls12;
+
 use bls12_381::Scalar;
 use ff::{Field, PrimeField};
-use rand::rngs::OsRng;
+
 use sapvi::bls_extensions::BlsStringConversion;
-use sapvi::error::{Error, Result};
-use sapvi::serial::{Decodable, Encodable};
-use sapvi::vm::{
-    AllocType, ConstraintInstruction, CryptoOperation, VariableIndex, VariableRef, ZKVMCircuit,
-    ZKVirtualMachine,
-};
+
+
+
 use std::ops::{AddAssign, MulAssign, SubAssign};
-use std::time::Instant;
+
 
 macro_rules! fn_t_int_int {
     ($ret:ident, $fn:expr) => {{
@@ -171,8 +168,8 @@ fn nth(a: MalArgs) -> MalRet {
 
 fn unpack_bits(a: MalArgs) -> MalRet {
     let mut result = vec![];
-    match (a[0].clone()) {
-        (Str(ref s)) => {
+    match a[0].clone() {
+        Str(ref s) => {
             let value = Scalar::from_string(s);
             for (_, bit) in value.to_le_bits().into_iter().cloned().enumerate() {
                 match bit {
@@ -255,7 +252,7 @@ fn conj(a: MalArgs) -> MalRet {
 fn sub_scalar(a: MalArgs) -> MalRet {
     match (a[0].clone(), a[1].clone()) {
         (Str(a0), Str(a1)) => {
-            let (mut s0, mut s1) = (Scalar::from_string(&a0), Scalar::from_string(&a1));
+            let (mut s0, s1) = (Scalar::from_string(&a0), Scalar::from_string(&a1));
             s0.sub_assign(s1);
             Ok(Str(std::string::ToString::to_string(&s0)[2..].to_string()))
         }
@@ -266,7 +263,7 @@ fn sub_scalar(a: MalArgs) -> MalRet {
 fn mul_scalar(a: MalArgs) -> MalRet {
     match (a[0].clone(), a[1].clone()) {
         (Str(a0), Str(a1)) => {
-            let (mut s0, mut s1) = (Scalar::from_string(&a0), Scalar::from_string(&a1));
+            let (mut s0, s1) = (Scalar::from_string(&a0), Scalar::from_string(&a1));
             s0.mul_assign(s1);
             Ok(Str(std::string::ToString::to_string(&s0)[2..].to_string()))
         }
@@ -277,7 +274,7 @@ fn mul_scalar(a: MalArgs) -> MalRet {
 fn div_scalar(a: MalArgs) -> MalRet {
     match (a[0].clone(), a[1].clone()) {
         (Str(a0), Str(a1)) => {
-            let (mut s0, mut s1) = (Scalar::from_string(&a0), Scalar::from_string(&a1));
+            let (s0, s1) = (Scalar::from_string(&a0), Scalar::from_string(&a1));
             let ret = s1.invert().map(|other| *&s0 * other);
             Ok(Str(
                 std::string::ToString::to_string(&ret.unwrap())[2..].to_string()
@@ -287,17 +284,6 @@ fn div_scalar(a: MalArgs) -> MalRet {
     }
 }
 
-fn cs_params(a: MalArgs) -> MalRet {
-    Ok(Params(Rc::new(a[0].clone())))
-}
-
-fn cs_public(a: MalArgs) -> MalRet {
-    Ok(Public(Rc::new(a[0].clone()).clone()))
-}
-
-fn cs_private(a: MalArgs) -> MalRet {
-    Ok(Private(Rc::new(a[0].clone()).clone()))
-}
 fn range(a: MalArgs) -> MalRet {
     let mut result = vec![];
     match (a[0].clone(), a[1].clone()) {
@@ -307,17 +293,38 @@ fn range(a: MalArgs) -> MalRet {
             };
             Ok(list!(result
                 .iter()
-                .map(|a| Nil) 
+                .map(|_a| Nil) 
                 .collect::<Vec<MalVal>>()))
         },
         _ => error("expected int int")
     }
 }
 
+fn alloc_input(a: MalArgs) -> MalRet {
+    println!("{:?}", a);
+    Ok(Nil)
+}
+fn scalar_one(a: MalArgs) -> MalRet {
+    println!("{:?}", a);
+    Ok(Nil)
+}
+fn alloc(a: MalArgs) -> MalRet {
+    println!("{:?}", a);
+    Ok(Nil)
+}
+fn cs_one(a: MalArgs) -> MalRet {
+    println!("{:?}", a);
+    Ok(Nil)
+}
+fn bellman_one(a: MalArgs) -> MalRet {
+    println!("{:?}", a);
+    Ok(Nil)
+}
+
 fn add_scalar(a: MalArgs) -> MalRet {
     match (a[0].clone(), a[1].clone()) {
         (Str(a0), Str(a1)) => {
-            let (mut s0, mut s1) = (Scalar::from_string(&a0), Scalar::from_string(&a1));
+            let (mut s0, s1) = (Scalar::from_string(&a0), Scalar::from_string(&a1));
             s0.add_assign(s1);
             Ok(Str(std::string::ToString::to_string(&s0)[2..].to_string()))
         }
@@ -435,11 +442,11 @@ pub fn ns() -> Vec<(&'static str, MalVal)> {
         ("swap!", func(|a| a[0].swap_bang(&a[1..].to_vec()))),
         ("unpack-bits", func(unpack_bits)),
         ("range", func(range)),
-        ("alloc", func(range)),
-        ("alloc-input", func(range)),
-        ("scalar", func(range)),
-        ("scalar::one", func(range)),
-        ("cs::one", func(range)),
-        ("bellman::one", func(range)),
+        ("alloc", func(alloc)),
+        ("alloc-input", func(alloc_input)),
+        ("scalar::one", func(scalar_one)),
+        ("scalar", func(scalar_one)),
+        ("cs::one", func(cs_one)),
+        ("bellman::one", func(bellman_one)),
     ]
 }

lisp/lisp.rs

@@ -1,18 +1,16 @@
 #![allow(non_snake_case)]
-use bls12_381::Scalar;
+
 use sapvi::bls_extensions::BlsStringConversion;
-use sapvi::serial::{Decodable, Encodable};
+
 use simplelog::*;
-use std::fs;
-use std::fs::File;
+
+
 use std::rc::Rc;
-use std::time::Instant;
+
 //use std::collections::HashMap;
 use fnv::FnvHashMap;
 use itertools::Itertools;
-use sapvi::vm::{
-    AllocType, ConstraintInstruction, CryptoOperation, VariableIndex, VariableRef, ZKVirtualMachine,
-};
+
 
 #[macro_use]
 extern crate clap;
@@ -26,8 +24,8 @@ extern crate regex;
 mod types;
 use crate::types::MalErr::{ErrMalVal, ErrString};
 use crate::types::MalVal::{
-    Bool, Func, Hash, List, MalFunc, Nil, Params, Private, Public, Str,
-    Sym, Vector, Zk,
+    Bool, Func, Hash, List, MalFunc, Nil, Str,
+    Sym, Vector,
 };
 use crate::types::ZKCircuit;
 use crate::types::{error, format_error, MalArgs, MalErr, MalRet, MalVal};
@@ -108,7 +106,7 @@ fn macroexpand(mut ast: MalVal, env: &Env) -> (bool, MalRet) {
         //println!("macroexpand 2: {:?}", ast);
         was_expanded = true;
     }
-    ((was_expanded, Ok(ast)))
+    (was_expanded, Ok(ast))
 }
 
 fn eval_ast(ast: &MalVal, env: &Env) -> MalRet {
@@ -273,7 +271,10 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
                             _ => Ok(Nil),
                         }
                     }
-                    //Sym(ref a0sym) if a0sym == "setup" => {
+                    Sym(ref a0sym) if a0sym == "setup" => {
+                        let (a1, a2) = (l[1].clone(), l[2].clone());
+                        eval(a1.clone(), env.clone())
+                    }
                     //Sym(ref a0sym) if a0sym == "prove" => {
                     //Sym(ref a0sym) if a0sym == "verify" => {
                     Sym(ref a0sym) if a0sym == "enforce" => {
@@ -294,7 +295,7 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
                     Sym(ref a0sym) if a0sym == "defzk!" => {
                         // private, public and constrains
                         //let (a1, a2, a3) = (l[1].clone(), l[2].clone(), l[3].clone());
-                        let (a1) = (l[1].clone());
+                        let a1 = l[1].clone();
                         let circuit = zk_circuit_create(&a1, &env);
                         let val = types::MalVal::Zk(circuit.clone());
                         env_set(&env, a1.clone(), val.clone());
@@ -355,7 +356,7 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
     ret
 }
 
-fn zk_circuit_create(a1: &MalVal, env: &Env) -> ZKCircuit {
+fn zk_circuit_create(a1: &MalVal, _env: &Env) -> ZKCircuit {
     let zk_circuit = ZKCircuit {
         name: a1.pr_str(true),
         constraints: Vec::new(),

lisp/printer.rs

@@ -46,9 +46,9 @@ impl MalVal {
             } => format!("(fn* {} {})", p.pr_str(true), a.pr_str(true)),
             Atom(a) => format!("(atom {})", a.borrow().pr_str(true)),
             Zk(a) => format!("{:?}", a),
-            Add => format!("add"),
-            Sub => format!("sub"),
-            Lc0 => format!("Lc0"),
+            _Add => format!("add"),
+            _Sub => format!("sub"),
+            _Lc0 => format!("Lc0"),
             i => format!("{:?}", i.pr_str(true)),
         }
     }

lisp/types.rs

@@ -12,17 +12,10 @@ use crate::types::MalVal::{
 
 use bls12_381::Scalar;
 use sapvi::{
-    BlsStringConversion, ConstraintInstruction, Decodable, Encodable, ZKContract, ZKProof,
-    ZKVMCircuit,
+    BlsStringConversion, ConstraintInstruction,
 };
 
-use bellman::{
-    gadgets::{
-        boolean::{AllocatedBit, Boolean},
-        multipack, num, Assignment,
-    },
-    groth16, Circuit, ConstraintSystem, SynthesisError,
-};
+
 
 #[derive(Debug, Clone)]
 pub enum MalVal {

src/bin/mimc.rs

@@ -1,6 +1,6 @@
 use bls12_381::Scalar;
-use ff::{Field, PrimeField};
-use sapvi::{BlsStringConversion, Decodable, ZKContract};
+use ff::{Field};
+use sapvi::{Decodable, ZKContract};
 use std::fs::File;
 use std::ops::{Add, AddAssign, MulAssign, Neg, SubAssign};
 use std::time::Instant;

src/bls_extensions.rs

@@ -1,5 +1,5 @@
 use bls12_381 as bls;
-use rand_core::{OsRng, RngCore};
+
 use std::io;
 
 use crate::error::{Error, Result};

src/serial.rs

@@ -1,7 +1,7 @@
 use bls12_381 as bls;
 use std::borrow::Cow;
 use std::io::{Cursor, Read, Write};
-use std::rc::Rc;
+
 use std::{io, mem};
 
 use crate::endian;