github/darkfi
1
1
Fork 0
mirror of https://github.com/darkrenaissance/darkfi.git synced 2026-01-10 07:08:05 -05:00
Code Issues Packages Projects Releases Wiki Activity

changing zkcircuit ref

Browse Source
This commit is contained in:
ada
2020-12-23 16:07:14 +01:00
parent 740ff81901
commit 43e785f086
4 changed files with 116 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
lisp/core.rs
View File

@@ -8,8 +8,7 @@ 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, Str,
Sym, Vector, ZKScalar
Atom, Bool, Func, Hash, Int, List, MalFunc, Nil, Str, Sym, Vector, ZKScalar,
};
use crate::types::{MalArgs, MalRet, MalVal, _assoc, _dissoc, atom, error, func, hash_map};
@@ -20,7 +19,6 @@ use sapvi::bls_extensions::BlsStringConversion;
use std::ops::{AddAssign, MulAssign, SubAssign};
macro_rules! fn_t_int_int {
($ret:ident, $fn:expr) => {{
|a: MalArgs| match (a[0].clone(), a[1].clone()) {
@@ -257,7 +255,10 @@ 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, s1) = (bls12_381::Scalar::from_string(&a0), bls12_381::Scalar::from_string(&a1));
let (mut s0, s1) = (
bls12_381::Scalar::from_string(&a0),
bls12_381::Scalar::from_string(&a1),
);
s0.sub_assign(s1);
Ok(Str(std::string::ToString::to_string(&s0)[2..].to_string()))
}
@@ -279,7 +280,10 @@ fn mul_scalar(a: MalArgs) -> MalRet {
fn div_scalar(a: MalArgs) -> MalRet {
match (a[0].clone(), a[1].clone()) {
(Str(a0), Str(a1)) => {
let (s0, s1) = (bls12_381::Scalar::from_string(&a0), bls12_381::Scalar::from_string(&a1));
let (s0, s1) = (
bls12_381::Scalar::from_string(&a0),
bls12_381::Scalar::from_string(&a1),
);
let ret = s1.invert().map(|other| *&s0 * other);
Ok(Str(
std::string::ToString::to_string(&ret.unwrap())[2..].to_string()
@@ -294,14 +298,11 @@ fn range(a: MalArgs) -> MalRet {
match (a[0].clone(), a[1].clone()) {
(Int(a0), Int(a1)) => {
for n in a0..a1 {
result.push(n);
};
Ok(list!(result
.iter()
.map(|_a| Nil)
.collect::<Vec<MalVal>>()))
},
_ => error("expected int int")
result.push(n);
}
Ok(list!(result.iter().map(|_a| Nil).collect::<Vec<MalVal>>()))
}
_ => error("expected int int"),
}
}
@@ -315,9 +316,7 @@ fn scalar_one(a: MalArgs) -> MalRet {
fn negate_from(a: MalArgs) -> MalRet {
match a[0].apply(vec![])? {
ZKScalar(a0) => {
Ok(ZKScalar(a0.neg()))
},
ZKScalar(a0) => Ok(ZKScalar(a0.neg())),
Nil => error("nil not supported"),
_ => error("negate error, expected (zkscalar)"),
}
@@ -327,12 +326,12 @@ fn scalar_from(a: MalArgs) -> MalRet {
Str(a0) => {
let s0 = bls12_381::Scalar::from_string(&a0.to_string());
Ok(ZKScalar(s0))
},
}
Int(a0) => {
println!("{:?}", a0);
let s0 = bls12_381::Scalar::from(a0 as u64);
Ok(ZKScalar(s0))
},
}
_ => error("expected (string or int)"),
}
}
@@ -349,7 +348,10 @@ fn bellman_one(a: MalArgs) -> MalRet {
fn add_scalar(a: MalArgs) -> MalRet {
match (a[0].clone(), a[1].clone()) {
(Str(a0), Str(a1)) => {
let (mut s0, s1) = (bls12_381::Scalar::from_string(&a0), bls12_381::Scalar::from_string(&a1));
let (mut s0, s1) = (
bls12_381::Scalar::from_string(&a0),
bls12_381::Scalar::from_string(&a1),
);
s0.add_assign(s1);
Ok(Str(std::string::ToString::to_string(&s0)[2..].to_string()))
}

149
lisp/lisp.rs
View File

@@ -1,26 +1,21 @@
#![allow(non_snake_case)]
use crate::MalVal::Zk;
use crate::groth16::VerifyingKey;
use crate::types::LispCircuit;
use sapvi::{ZKVMCircuit, ZKVirtualMachine};
use crate::MalVal::Zk;
use sapvi::bls_extensions::BlsStringConversion;
use sapvi::{ZKVMCircuit, ZKVirtualMachine};
use simplelog::*;
use bellman::{
gadgets::{
Assignment,
},
groth16, Circuit, ConstraintSystem, SynthesisError,
};
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 std::ops::{AddAssign, MulAssign, SubAssign};
use std::time::Instant;
use std::{cell::RefCell, ops::{AddAssign, MulAssign, SubAssign}};
use std::rc::Rc;
use std::time::Instant;
//use std::collections::HashMap;
use fnv::FnvHashMap;
@@ -38,10 +33,7 @@ extern crate regex;
#[macro_use]
mod types;
use crate::types::MalErr::{ErrMalVal, ErrString};
use crate::types::MalVal::{
Bool, Func, Hash, List, MalFunc, Nil, Str,
Sym, Vector,
};
use crate::types::MalVal::{Bool, Func, Hash, List, MalFunc, Nil, Str, Sym, Vector};
use crate::types::{error, format_error, MalArgs, MalErr, MalRet, MalVal};
mod env;
mod printer;
@@ -50,7 +42,7 @@ use crate::env::{env_bind, env_find, env_get, env_new, env_set, env_sets, Env};
#[macro_use]
mod core;
pub const ZK_CIRCUIT_ENV_KEY : &str = "ZKC";
pub const ZK_CIRCUIT_ENV_KEY: &str = "ZKC";
// read
fn read(str: &str) -> MalRet {
@@ -287,38 +279,7 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
_ => Ok(Nil),
}
}
Sym(ref a0sym) if a0sym == "setup" => {
let a1 = l[1].clone();
let circuit = setup(&ast)?;
env_sets(&env, ZK_CIRCUIT_ENV_KEY, circuit);
eval(a1.clone(), env.clone())
}
Sym(ref a0sym) if a0sym == "prove" => {
let a1 = l[0].clone();
println!("prove {:?}", a1);
prove(a1.clone(), env.clone())
}
Sym(ref a0sym) if a0sym == "alloc-input" => {
Ok(MalVal::Nil)
}
Sym(ref a0sym) if a0sym == "alloc" => {
let a1 = l[1].clone();
let a2 = l[2].clone();
let value = eval_ast(&a2, &env)?;
Ok(value)
}
//Sym(ref a0sym) if a0sym == "verify" => {
Sym(ref a0sym) if a0sym == "enforce" => {
let (a1, a2) = (l[0].clone(), l[1].clone());
let value = eval_ast(&a2, &env)?;
match value {
List(ref el, _) => {
println!("{:?}", el.to_vec());
}
_ => println!("invalid format"),
}
Ok(Nil)
}
Sym(ref a0sym) if a0sym == "fn*" => {
let (a1, a2) = (l[1].clone(), l[2].clone());
Ok(MalFunc {
@@ -337,6 +298,37 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
}
continue 'tco;
}
Sym(ref a0sym) if a0sym == "setup" => {
let a1 = l[1].clone();
let circuit = setup(&ast, env.clone())?;
env_sets(&env, ZK_CIRCUIT_ENV_KEY, circuit);
eval(a1.clone(), env.clone())
}
Sym(ref a0sym) if a0sym == "prove" => {
let a1 = l[0].clone();
println!("prove {:?}", a1);
prove(a1.clone(), env.clone())
}
Sym(ref a0sym) if a0sym == "alloc-input" => Ok(MalVal::Nil),
Sym(ref a0sym) if a0sym == "alloc" => {
let a1 = l[1].clone();
let a2 = l[2].clone();
let value = eval_ast(&a2, &env)?;
println!("a1 {:?} \n value {:?}", a1, value);
Ok(value)
}
//Sym(ref a0sym) if a0sym == "verify" => {
Sym(ref a0sym) if a0sym == "enforce" => {
let (a1, a2) = (l[0].clone(), l[1].clone());
let value = eval_ast(&a2, &env)?;
match value {
List(ref el, _) => {
println!("{:?}", el.to_vec());
}
_ => println!("invalid format"),
}
Ok(Nil)
}
_ => match eval_ast(&ast, &env)? {
List(ref el, _) => {
let ref f = el[0].clone();
@@ -373,51 +365,58 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
ret
}
pub fn setup(ast: &MalVal) -> MalRet {
// TODO get params from ast
pub fn setup(ast: &MalVal, mut env: Env) -> MalRet {
println!("{:?}", ast);
// 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 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 mut c = LispCircuit {
params: vec![],
allocs: vec![],
alloc_inputs: vec![],
constraints: vec![],
env: env.clone(),
};
// TODO move to another fn
let random_parameters =
groth16::generate_random_parameters::<Bls12, _, _>(c, &mut OsRng).unwrap();
let pvk = groth16::prepare_verifying_key(&random_parameters.vk);
println!("Setup: [{:?}]", start.elapsed());
Ok(MalVal::Zk(Rc::new(c)))
Ok(MalVal::Nil)
}
pub fn prove(mut ast: MalVal, mut env: Env) -> MalRet {
let c = match env_find(&env, ZK_CIRCUIT_ENV_KEY) {
Some(e) => match env_get(&e, &Sym(ZK_CIRCUIT_ENV_KEY.to_string()))? {
Zk(c) => {
MalVal::Zk(c)
}
_ => { MalVal::Nil }
}
None => { println!("circuit not found."); MalVal::Nil }
};
println!("Circuit {:?}", c);
// TODO remove it
// TODO remove it
let quantity = bls12_381::Scalar::from(3);
// Create an instance of our circuit (with the preimage as a witness).
let c = LispCircuit {
params: Rc::new(vector![vec![
ZKScalar(quantity),
ZKScalar(quantity * quantity),
ZKScalar(quantity * quantity * quantity),
]]),
let params = {
let c = LispCircuit {
params: vec![],
allocs: vec![],
alloc_inputs: vec![],
constraints: vec![],
env: env.clone(),
};
groth16::generate_random_parameters::<Bls12, _, _>(c, &mut OsRng).unwrap()
};
let circuit= LispCircuit {
params: vec![],
allocs: vec![],
alloc_inputs: vec![],
constraints: vec![],
env: env.clone(),
};
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(circuit, &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)];

7
lisp/new-cs.lisp
View File

@@ -23,6 +23,13 @@
(scalar::one cs::one)
(scalar::one x3)
)
;; (enforce
;; (scalar::one tmp)
;; ((scalar::one left_i) (mimc_constant cs::one))
;; ((scalar::one left_i_1) ((neg scalar::one) right))
;; )
))
(prove))
;; (println 'verify (MyCircuit (scalar 27)))

27
lisp/types.rs
View File

@@ -1,26 +1,27 @@
use bellman::SynthesisError;
use bellman::ConstraintSystem;
use bellman::Circuit;
use bellman::ConstraintSystem;
use bellman::SynthesisError;
use std::cell::RefCell;
use std::rc::Rc;
//use std::collections::HashMap;
use fnv::FnvHashMap;
use itertools::Itertools;
use crate::env;
use crate::env::{env_bind, Env};
use crate::types::MalErr::{ErrMalVal, ErrString};
use crate::types::MalVal::{
Atom, Bool, Func, Hash, Int, List, MalFunc, Nil, Str, Sym, Vector,
};
use crate::types::MalVal::{Atom, Bool, Func, Hash, Int, List, MalFunc, Nil, Str, Sym, Vector};
use bls12_381::Scalar;
use sapvi::{
BlsStringConversion, ConstraintInstruction,
};
use sapvi::{BlsStringConversion, ConstraintInstruction};
#[derive(Clone, Debug)]
#[derive(Debug, Clone)]
pub struct LispCircuit {
pub params: Rc<MalVal>,
// TODO refactor to vec
pub params: Vec<Option<Scalar>>,
pub allocs: Vec<Option<Scalar>>,
pub alloc_inputs: Vec<Option<Scalar>>,
pub constraints: Vec<Option<Scalar>>,
pub env: Env,
}
impl Circuit<bls12_381::Scalar> for LispCircuit {
@@ -52,10 +53,10 @@ pub enum MalVal {
meta: Rc<MalVal>,
},
Atom(Rc<RefCell<MalVal>>),
Zk(Rc<LispCircuit>),
Zk(LispCircuit),
Enforce(Rc<Vec<MalVal>>),
// TODO maybe change to bls scalar
ZKScalar(bls12_381::Scalar)
ZKScalar(bls12_381::Scalar),
}
#[derive(Debug)]