improving circuit integration with lisp

lisp/core.rs

@@ -312,10 +312,29 @@ fn alloc_input(a: MalArgs) -> MalRet {
     println!("{:?}", a);
     Ok(Nil)
 }
+
+fn scalar_zero(a: MalArgs) -> MalRet {
+    println!("{:?}", a);
+    Ok(Nil)
+}
+
 fn scalar_one(a: MalArgs) -> MalRet {
     println!("{:?}", a);
     Ok(Nil)
 }
+
+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()
+            ))
+        }
+        _ => error("expected (string)"),
+    }
+}
 fn scalar_from(a: MalArgs) -> MalRet {
     println!("{:?}", a);
     match (a[0].clone()) {
@@ -466,6 +485,9 @@ pub fn ns() -> Vec<(&'static str, MalVal)> {
         ("alloc", func(alloc)),
         ("alloc-input", func(alloc_input)),
         ("scalar::one", func(scalar_one)),
+        ("negate", func(negate_from)),
+        ("scalar::zero", func(scalar_zero)),
+        // TODO add .neg maybe neg, add and sub
         ("scalar", func(scalar_from)),
         ("cs::one", func(cs_one)),
         ("bellman::one", func(bellman_one)),

lisp/lisp.rs

@@ -1,5 +1,7 @@
 #![allow(non_snake_case)]
 
+use crate::groth16::VerifyingKey;
+use crate::types::LispCircuit;
 use sapvi::ZKVMCircuit;
 use sapvi::bls_extensions::BlsStringConversion;
 
@@ -39,7 +41,6 @@ use crate::types::MalVal::{
     Bool, Func, Hash, List, MalFunc, Nil, Str,
     Sym, Vector,
 };
-use crate::types::ZKCircuit;
 use crate::types::{error, format_error, MalArgs, MalErr, MalRet, MalVal};
 mod env;
 mod printer;
@@ -359,58 +360,47 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
     ret
 }
 
-struct MyCircuit {
-    params: Vec<Option<bls12_381::Scalar>>,
-}
-
-impl Circuit<bls12_381::Scalar> for MyCircuit {
-    fn synthesize<CS: ConstraintSystem<bls12_381::Scalar>>(
-        self,
-        cs: &mut CS,
-    ) -> Result<(), SynthesisError> {
-        Ok(())
-    }
-}
-
 pub fn setup(ast: &MalVal) -> MalRet {
+    // TODO get params from ast 
     let start = Instant::now();
     // Create parameters for our circuit. In a production deployment these would
     // be generated securely using a multiparty computation.
-    let params = {
-        let c = MyCircuit { params: vec![None] };
-        groth16::generate_random_parameters::<Bls12, _, _>(c, &mut OsRng).unwrap()
-    };
+    let c = LispCircuit { params: Rc::new(vector!(vec![])) };
+    // TODO move to another fn    
+    let random_parameters = groth16::generate_random_parameters::<Bls12, _, _>(c.clone(), &mut OsRng).unwrap();
+    let pvk = groth16::prepare_verifying_key(&random_parameters.vk);
     println!("Setup: [{:?}]", start.elapsed());
 
-    // Prepare the verification key (for proof verification).
-    let pvk = groth16::prepare_verifying_key(&params.vk);
+    Ok(MalVal::Zk(Rc::new(c)))
+}
 
-    Ok(MalVal::Str("k".to_string()))
-/*
+pub fn prove(ast: &MalVal) -> MalRet {
     // Pick a preimage and compute its hash.
     let quantity = bls12_381::Scalar::from(3);
 
     // Create an instance of our circuit (with the preimage as a witness).
-    let c = MyCircuit {
-        params: vec![
-            Some(quantity),
-            Some(quantity * quantity),
-            Some(quantity * quantity * quantity),
-        ],
+    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))),
+        ]]),
     };
 
     let start = Instant::now();
     // Create a Groth16 proof with our parameters.
-    let proof = groth16::create_random_proof(c, &params, &mut OsRng).unwrap();
+    //let proof = groth16::create_random_proof(c, &params, &mut OsRng).unwrap();
     println!("Prove: [{:?}]", start.elapsed());
-    
-    
+    Ok(MalVal::Nil)
+} 
+
+pub fn verify(ast: &MalVal) -> MalRet {
     let public_input = vec![bls12_381::Scalar::from(27)];
     let start = Instant::now();
     // Check the proof!
-    assert!(groth16::verify_proof(&pvk, &proof, &public_input).is_ok());
+    //assert!(groth16::verify_proof(&pvk, &proof, &public_input).is_ok());
     println!("Verify: [{:?}]", start.elapsed());
-*/
+    Ok(MalVal::Nil)
 }
 
 // print

lisp/new-cs.lisp

@@ -19,7 +19,7 @@
    ;; Lc0: [(Scalar::one(), CS::one()), (Scalar::one().neg(), C)]
 ;; Lc1: [(Scalar::one(), y)]
 ;; Lc2: [(Scalar::one(), U), (Scalar::one().neg(), A), (Scalar::one().neg(), B)]
-    (enforce (scalar::one ) (zero + cs::one) (zero + x3))
+    (enforce (scalar::one x) ((negate scalar::one) x2) ((negate scalar::one) x3))
 )))
 (def! a (scalar "0000000000000000000000000000000000000000000000000000000000000003"))
 (setup (MyCircuit (a (* a a) (* (* a a) a))))

lisp/types.rs

@@ -1,3 +1,6 @@
+use bellman::SynthesisError;
+use bellman::ConstraintSystem;
+use bellman::Circuit;
 use std::cell::RefCell;
 use std::rc::Rc;
 //use std::collections::HashMap;
@@ -15,7 +18,19 @@ use sapvi::{
     BlsStringConversion, ConstraintInstruction,
 };
 
+#[derive(Clone, Debug)]
+pub struct LispCircuit {
+    pub params: Rc<MalVal>,
+}
 
+impl Circuit<bls12_381::Scalar> for LispCircuit {
+    fn synthesize<CS: ConstraintSystem<bls12_381::Scalar>>(
+        self,
+        cs: &mut CS,
+    ) -> Result<(), SynthesisError> {
+        Ok(())
+    }
+}
 
 #[derive(Debug, Clone)]
 pub enum MalVal {
@@ -37,21 +52,12 @@ pub enum MalVal {
         meta: Rc<MalVal>,
     },
     Atom(Rc<RefCell<MalVal>>),
-    Zk(ZKCircuit),
+    Zk(Rc<LispCircuit>),
     Enforce(Rc<Vec<MalVal>>),
+    // TODO maybe change to bls scalar
     Scalar(String)
 }
 
-#[derive(Debug, Clone)]
-pub struct ZKCircuit {
-    pub name: String,
-    pub constraints: Vec<ConstraintInstruction>,
-    pub private: Vec<Scalar>,
-    pub public: Vec<Scalar>,
-    pub params: Vec<Scalar>,
-    pub verifying_key: Vec<Scalar>,
-}
-
 #[derive(Debug)]
 pub enum MalErr {
     ErrString(String),