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

we have mimc proof

Browse Source
This commit is contained in:
plato
2021-03-20 17:57:43 +01:00
parent 2dc9ec4540
commit 9df73eb30e
2 changed files with 39 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
lisp/examples/macro-test.lisp
View File

@@ -232,8 +232,11 @@
(load-file "mimc-constants.lisp")
(defmacro! mimc-macro (fn* [left-value right-value acc] (
(let* [tmp-xl (gensym2 'tmp_xl) xl-new-value (gensym2 'xl_new_value) cur-mimc-const (gensym2 'cur_mimc_const)
xl (gensym2 'xl) xr (gensym2 'xr)] (
(let* [tmp-xl (gensym2 'tmp_xl)
xl-new-value (gensym2 'xl_new_value)
cur-mimc-const (gensym2 'cur_mimc_const)
xl (gensym2 'xl)
xr (gensym2 'xr)] (
`(def! ~xl (alloc ~xl ~left-value))
`(def! ~xr (alloc ~xr ~right-value))
`(def! ~cur-mimc-const (alloc-const ~cur-mimc-const (nth mimc-constants ~acc)))

47
lisp/types.rs
View File

@@ -75,19 +75,19 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
let mut variables: FnvHashMap<String, Variable> = FnvHashMap::default();
let mut params_const = self.params;
println!("Allocations\n");
// println!("Allocations\n");
for (k, v) in &self.allocs {
match v {
MalVal::ZKScalar(val) => {
let var = cs.alloc(|| k, || Ok(*val))?;
variables.insert(k.to_string(), var);
println!("k {:?} v {:?} var {:?}", k, v, var);
// println!("k {:?} v {:?} var {:?}", k, v, var);
}
MalVal::Str(val) => {
let val_scalar = bls12_381::Scalar::from_string(&*val);
let var = cs.alloc(|| k, || Ok(val_scalar))?;
variables.insert(k.to_string(), var);
println!("k {:?} v {:?} var {:?}", k, v, var);
// println!("k {:?} v {:?} var {:?}", k, v, var);
}
_ => {
println!("not allocated k {:?} v {:?}", k, v);
@@ -95,19 +95,19 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
}
}
println!("Allocations Input\n");
// println!("Allocations Input\n");
for (k, v) in &self.alloc_inputs {
match v {
MalVal::ZKScalar(val) => {
let var = cs.alloc_input(|| k, || Ok(*val))?;
variables.insert(k.to_string(), var);
println!("k {:?} v {:?} var {:?}", k, v, var);
// println!("k {:?} v {:?} var {:?}", k, v, var);
}
MalVal::Str(val) => {
let val_scalar = bls12_381::Scalar::from_string(&*val);
let var = cs.alloc_input(|| k, || Ok(val_scalar))?;
variables.insert(k.to_string(), var);
println!("k {:?} v {:?} var {:?}", k, v, var);
// println!("k {:?} v {:?} var {:?}", k, v, var);
}
_ => {
println!("not allocated k {:?} v {:?}", k, v);
@@ -119,7 +119,7 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
let mut enforce_sorted = self.constraints.clone();
enforce_sorted.sort_by(|a, b| a.idx.cmp(&b.idx));
for alloc_value in enforce_sorted.iter() {
println!("Enforce -> {:?}", alloc_value);
// println!("Enforce -> {:?}", alloc_value);
let coeff = bls12_381::Scalar::one();
let mut left = bellman::LinearCombination::<Scalar>::zero();
let mut right = bellman::LinearCombination::<Scalar>::zero();
@@ -136,8 +136,15 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
left = left + (coeff.neg(), val_b);
} else {
if let Some(value) = params_const.get(a) {
if let MalVal::ZKScalar(val) = value {
left = left + (*val, val_b);
match value {
MalVal::ZKScalar(val) => {
left = left + (*val, val_b);
}
MalVal::Str(s) => {
let val = bls12_381::Scalar::from_string(&s.to_string());
left = left + (val, val_b);
}
_ => { println!("not a valid param {:?}", value) }
}
}
}
@@ -156,8 +163,15 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
right = right + (coeff.neg(), val_b);
} else {
if let Some(value) = params_const.get(a) {
if let MalVal::ZKScalar(val) = value {
right = right + (*val, val_b);
match value {
MalVal::ZKScalar(val) => {
right = right + (*val, val_b);
}
MalVal::Str(s) => {
let val = bls12_381::Scalar::from_string(&s.to_string());
right = right + (val, val_b);
}
_ => { println!("not a valid param {:?}", value) }
}
}
}
@@ -177,8 +191,15 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
output = output + (coeff.neg(), val_b);
} else {
if let Some(value) = params_const.get(a) {
if let MalVal::ZKScalar(val) = value {
output = output + (*val, val_b);
match value {
MalVal::ZKScalar(val) => {
output = output + (*val, val_b);
}
MalVal::Str(s) => {
let val = bls12_381::Scalar::from_string(&s.to_string());
output = output + (val, val_b);
}
_ => { println!("not a valid param {:?}", value) }
}
}
}