github/darkfi
1
1
Fork 0
mirror of https://github.com/darkrenaissance/darkfi.git synced 2026-04-28 03:00:18 -04:00
Code Issues Packages Projects Releases Wiki Activity

enforce and return types not malval

Browse Source
This commit is contained in:
ada
2021-01-31 22:41:12 +01:00
parent f72b5ea131
commit f1807fa742
2 changed files with 66 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

130
lisp/lisp.rs
View File

@@ -34,7 +34,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, Enforce};
use crate::types::MalVal::{Bool, Enforce, Func, Hash, List, MalFunc, Nil, Str, Sym, Vector};
use crate::types::{error, format_error, MalArgs, MalErr, MalRet, MalVal};
mod env;
mod printer;
@@ -302,8 +302,8 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
Sym(ref a0sym) if a0sym == "setup" => {
let a1 = l[1].clone();
// todo
let _pvk = setup(a1.clone(), env.clone())?;
ast = eval(a1.clone(), env.clone())?;
let _pvk = setup(a1.clone(), env.clone())?;
continue 'tco;
}
Sym(ref a0sym) if a0sym == "prove" => {
@@ -315,38 +315,34 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
let a1 = l[1].clone();
let value = eval(l[2].clone(), env.clone())?;
let result = eval(value.clone(), env.clone())?;
// let symbol = MalVal::Sym(a1.pr_str(false));
// env_set(&env, Sym(a1.pr_str(false)), result.clone());
if let Hash(allocs, _) = get_allocations(&env, "AllocationsInput")? {
let mut new_hm: FnvHashMap<String, MalVal> = FnvHashMap::default();
for (k, v) in allocs.iter() {
new_hm.insert(k.to_string(), eval(v.clone(), env.clone())?);
}
new_hm.insert(a1.pr_str(false), result);
env_set(
&env,
Sym("AllocationsInput".to_string()),
Hash(Rc::new(new_hm), Rc::new(Nil)),
)?;
};
let allocs = get_allocations(&env, "AllocationsInput");
let mut new_hm: FnvHashMap<String, MalVal> = FnvHashMap::default();
for (k, v) in allocs.iter() {
new_hm.insert(k.to_string(), eval(v.clone(), env.clone())?);
}
new_hm.insert(a1.pr_str(false), result);
env_set(
&env,
Sym("AllocationsInput".to_string()),
Hash(Rc::new(new_hm), Rc::new(Nil)),
)?;
Ok(Nil)
}
Sym(ref a0sym) if a0sym == "alloc" => {
let a1 = l[1].clone();
let value = eval(l[2].clone(), env.clone())?;
let result = eval(value.clone(), env.clone())?;
if let Hash(allocs, _) = get_allocations(&env, "Allocations")? {
let mut new_hm: FnvHashMap<String, MalVal> = FnvHashMap::default();
for (k, v) in allocs.iter() {
new_hm.insert(k.to_string(), eval(v.clone(), env.clone())?);
}
new_hm.insert(a1.pr_str(false), result);
env_set(
&env,
Sym("Allocations".to_string()),
Hash(Rc::new(new_hm), Rc::new(Nil)),
)?;
};
let allocs = get_allocations(&env, "Allocations");
let mut new_hm: FnvHashMap<String, MalVal> = FnvHashMap::default();
for (k, v) in allocs.iter() {
new_hm.insert(k.to_string(), eval(v.clone(), env.clone())?);
}
new_hm.insert(a1.pr_str(false), result);
env_set(
&env,
Sym("Allocations".to_string()),
Hash(Rc::new(new_hm), Rc::new(Nil)),
)?;
Ok(Nil)
}
//Sym(ref a0sym) if a0sym == "verify" => {
@@ -417,34 +413,22 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
output: out_vec,
};
let mut new_vec: Vec<EnforceAllocation> = vec![enforce];
match get_enforce_allocs(&env)? {
Vector(v, _) => {
for value in v.iter() {
println!("VALUES {:?} \n", value);
match value {
Enforce(v) => {
println!("{:?}", v);
}
_ => {}
};
}
}
v => {
println!("something wrong. {:?}", v)
}
};
for value in get_enforce_allocs(&env).iter() {
println!("found {:?}", value);
}
env_set(
&env,
Sym("AllocationsEnforce".to_string()),
vector![vec![Enforce(Rc::new(new_vec))]],
);
println!("\n\nallocations {:?}", get_allocations(&env, "Allocations"));
println!(
"\n\nallocations input {:?}",
get_allocations(&env, "AllocationsInput")
);
println!("\n\nallocations enforce {:?}", get_enforce_allocs(&env));
/*
println!("\n\nallocations {:?}", get_allocations(&env, "Allocations"));
println!(
"\n\nallocations input {:?}",
get_allocations(&env, "AllocationsInput")
);
println!("\n\nallocations enforce {:?}", get_enforce_allocs(&env));
*/
Ok(vector![vec![]])
}
_ => match eval_ast(&ast, &env)? {
@@ -485,27 +469,40 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
ret
}
pub fn get_enforce_allocs(env: &Env) -> MalRet {
let found = match env_find(env, "AllocationsEnforce") {
pub fn get_enforce_allocs(env: &Env) -> Vec<EnforceAllocation> {
// todo need some cleanup
match env_find(env, "AllocationsEnforce") {
Some(e) => match env_get(&e, &Sym("AllocationsEnforce".to_string())) {
Ok(f) => {
println!("Found {:?}", f);
Ok(f)
if let Vector(val, _) = f {
if let Enforce(ret) = &val[0] {
ret.to_vec()
} else {
vec![]
}
} else {
vec![]
}
}
_ => Ok(vector![vec![]]),
_ => vec![],
},
_ => Ok(vector![vec![]]),
};
found
_ => vec![],
}
}
pub fn get_allocations(env: &Env, key: &str) -> MalRet {
let alloc_hm: FnvHashMap<String, MalVal> = FnvHashMap::default();
pub fn get_allocations(env: &Env, key: &str) -> Rc<FnvHashMap<String, MalVal>> {
let alloc_hm: Rc<FnvHashMap<String, MalVal>> = Rc::new(FnvHashMap::default());
match env_find(env, key) {
Some(e) => match env_get(&e, &Sym(key.to_string())) {
Ok(f) => Ok(f),
_ => Ok(Hash(Rc::new(alloc_hm), Rc::new(Nil))),
Ok(f) => {
if let Hash(allocs, _) = f {
allocs
} else {
alloc_hm
}
}
_ => alloc_hm,
},
_ => Ok(Hash(Rc::new(alloc_hm), Rc::new(Nil))),
_ => alloc_hm,
}
}
@@ -513,8 +510,9 @@ pub fn setup(_ast: MalVal, env: Env) -> Result<PreparedVerifyingKey<Bls12>, MalE
let start = Instant::now();
// Create parameters for our circuit. In a production deployment these would
// be generated securely using a multiparty computation.
// get all allocs from env
// let allocs_input = get_allocations(&env, "AllocationsInput").to_vec();
// let allocs = get_allocations(&env, "Allocations").to_vec();
// let enforce_allocs = get_enforce_allocs(&env).unwrap().to_vec();
let c = LispCircuit {
params: vec![],

3
lisp/types.rs
View File

@@ -30,7 +30,7 @@ pub struct LispCircuit {
pub params: Vec<Option<Scalar>>,
pub allocs: Vec<Option<Allocation>>,
pub alloc_inputs: Vec<Option<Allocation>>,
pub constraints: Vec<Option<Scalar>>,
pub constraints: Vec<Option<EnforceAllocation>>,
pub env: Env,
}
@@ -39,6 +39,7 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
self,
_cs: &mut CS,
) -> Result<(), SynthesisError> {
println!("something called this");
for alloc_value in &self.allocs {
println!("{:?}", alloc_value);
}