improving zklisp. adding zkscalar

lisp/core.rs

@@ -12,6 +12,7 @@ use crate::types::MalVal::{
     Sym, Vector
 };
 use crate::types::{MalArgs, MalRet, MalVal, _assoc, _dissoc, atom, error, func, hash_map};
+use MalVal::ZKScalar;
 use bellman::{gadgets::Assignment, groth16, Circuit, ConstraintSystem, SynthesisError};
 
 use bls12_381::Scalar;
@@ -270,12 +271,12 @@ fn sub_scalar(a: MalArgs) -> MalRet {
 
 fn mul_scalar(a: MalArgs) -> MalRet {
     match (a[0].clone(), a[1].clone()) {
-        (MalVal::Scalar(a0), MalVal::Scalar(a1)) => {
-            let (mut s0, s1) = (Scalar::from_string(&a0), Scalar::from_string(&a1));
-            s0.mul_assign(s1);
-            Ok(MalVal::Scalar(std::string::ToString::to_string(&s0)[2..].to_string()))
+        (ZKScalar(mut a0), ZKScalar(a1)) => {
+            // let (mut s0, s1) = (Scalar::from_string(&a0), Scalar::from_string(&a1));
+            a0.mul_assign(a1);
+            Ok(ZKScalar(a0))
         }
-        _ => error("expected (scalar, scalar)"),
+        _ => error("expected (zkscalar, zkscalar)"),
     }
 }
 
@@ -325,25 +326,20 @@ fn scalar_one(a: MalArgs) -> MalRet {
 
 fn negate_from(a: MalArgs) -> MalRet {
     println!("{:?}", a);
-    match (a[0].clone()) {
-        (Str(a0)) => {
-            let s0 = Scalar::from_string(&a0.to_string()).neg();
-            Ok(MalVal::Scalar(
-                std::string::ToString::to_string(&s0)[2..].to_string()
-            ))
-        }
+    match a[0].clone() {
+        ZKScalar(a0) => {
+            Ok(ZKScalar(a0.neg()))
+        },
         _ => error("expected (string)"),
     }
 }
 fn scalar_from(a: MalArgs) -> MalRet {
     println!("{:?}", a);
-    match (a[0].clone()) {
-        (Str(a0)) => {
-            let (s0) = (Scalar::from_string(&a0.to_string()));
-            Ok(MalVal::Scalar(
-                std::string::ToString::to_string(&s0)[2..].to_string()
-            ))
-        }
+    match a[0].clone() {
+        Str(a0) => {
+            let s0 = Scalar::from_string(&a0.to_string());
+            Ok(ZKScalar(s0))
+        },
         _ => error("expected (string)"),
     }
 }

lisp/lisp.rs

@@ -24,7 +24,7 @@ use std::rc::Rc;
 //use std::collections::HashMap;
 use fnv::FnvHashMap;
 use itertools::Itertools;
-
+use MalVal::ZKScalar;
 
 #[macro_use]
 extern crate clap;
@@ -381,9 +381,9 @@ pub fn prove(ast: &MalVal) -> MalRet {
     // Create an instance of our circuit (with the preimage as a witness).
     let c = LispCircuit {
         params: Rc::new(vector![vec![
-            MalVal::Scalar(std::string::ToString::to_string(&quantity)),
-            MalVal::Scalar(std::string::ToString::to_string(&(quantity * quantity))),
-            MalVal::Scalar(std::string::ToString::to_string(&(quantity * quantity * quantity))),
+            ZKScalar(quantity),
+            ZKScalar(quantity * quantity),
+            ZKScalar(quantity * quantity * quantity),
         ]]),
     };
 

lisp/printer.rs

@@ -45,7 +45,7 @@ impl MalVal {
                 ast: a, params: p, ..
             } => format!("(fn* {} {})", p.pr_str(true), a.pr_str(true)),
             Atom(a) => format!("(atom {})", a.borrow().pr_str(true)),
-            MalVal::Scalar(a) => format!("{:?}", a),
+            MalVal::ZKScalar(a) => format!("{:?}", a),
             i => format!("{:?}", i.pr_str(true)),
         }
     }

lisp/types.rs

@@ -55,7 +55,7 @@ pub enum MalVal {
     Zk(Rc<LispCircuit>),
     Enforce(Rc<Vec<MalVal>>),
     // TODO maybe change to bls scalar
-    Scalar(String)
+    ZKScalar(bls12_381::Scalar)
 }
 
 #[derive(Debug)]