github-mig/ZoKrates
github-mig/ZoKrates
1
0
Fork 0
mirror of synced 2025-09-23 12:18:44 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #269 from Zokrates/patch/0.4.2

Browse source 
Release 0.4.2 patch
This commit is contained in:
JacobEberhardt 2019-02-11 18:05:40 +01:00 committed by GitHub
commit 2b3f50105f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
8 changed files with 23 additions and 190 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
Cargo.lock generated
View file

@ -796,7 +796,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "zokrates_cli"
version = "0.4.1"
version = "0.4.2"
dependencies = [
"assert_cli 0.5.4 (registry+https://github.com/rust-lang/crates.io-index)",
"bincode 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
@ -804,14 +804,14 @@ dependencies = [
"glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
"regex 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_json 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",
"zokrates_core 0.3.5",
"zokrates_core 0.3.6",
"zokrates_field 0.3.2",
"zokrates_fs_resolver 0.4.0",
]
[[package]]
name = "zokrates_core"
version = "0.3.5"
version = "0.3.6"
dependencies = [
"assert_cli 0.5.4 (registry+https://github.com/rust-lang/crates.io-index)",
"bimap 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",

2
zokrates_cli/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "zokrates_cli"
version = "0.4.1"
version = "0.4.2"
authors = ["Jacob Eberhardt <jacob.eberhardt@tu-berlin.de>", "Dennis Kuhnert <mail@kyroy.com>", "Thibaut Schaeffer <thibaut@schaeff.fr>"]
repository = "https://github.com/JacobEberhardt/ZoKrates.git"
edition = "2018"

2
zokrates_cli/src/bin.rs
View file

@ -42,7 +42,7 @@ fn cli() -> Result<(), String> {
// cli specification using clap library
let matches = App::new("ZoKrates")
.setting(AppSettings::SubcommandRequiredElseHelp)
.version("0.4.1")
.version("0.4.2")
.author("Jacob Eberhardt, Thibaut Schaeffer, Dennis Kuhnert")
.about("Supports generation of zkSNARKs from high level language code including Smart Contracts for proof verification on the Ethereum Blockchain.\n'I know that I show nothing!'")
.subcommand(SubCommand::with_name("compile")

2
zokrates_core/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "zokrates_core"
version = "0.3.5"
version = "0.3.6"
authors = ["Jacob Eberhardt <jacob.eberhardt@tu-berlin.de>", "Dennis Kuhnert <mail@kyroy.com>"]
repository = "https://github.com/JacobEberhardt/ZoKrates"
readme = "README.md"

1
zokrates_core/src/flatten/mod.rs
View file

@ -49,7 +49,6 @@ impl Flattener {
fn load_corelib<T: Field>(&mut self, functions_flattened: &mut Vec<FlatFunction<T>>) -> () {
// Load type casting functions
functions_flattened.push(cast(&Type::Boolean, &Type::FieldElement));
functions_flattened.push(cast(&Type::FieldElement, &Type::Boolean));
// Load IfElse helper
let ie = TypedFunction {

30
zokrates_core/src/types/constraints.rs
View file

@ -1,30 +0,0 @@
use zokrates_field::field::Field;
#[derive(PartialEq, PartialOrd, Clone, Eq, Ord, Debug)]
pub struct Constraints<T: Field> {
pub constraints: Vec<Constraint<T>>,
}
impl<T: Field> Constraints<T> {
pub fn none() -> Constraints<T> {
Constraints {
constraints: vec![],
}
}
pub fn boolean() -> Constraints<T> {
Constraints {
constraints: vec![Constraint {
a: box [T::from(1)],
b: box [T::from(1)],
c: box [T::from(1)],
}],
}
}
}
#[derive(PartialEq, PartialOrd, Clone, Eq, Ord, Debug)]
pub struct Constraint<T: Field> {
pub a: Box<[T]>,
pub b: Box<[T]>,
pub c: Box<[T]>,
}

149
zokrates_core/src/types/conversions.rs
View file

@ -3,8 +3,6 @@ use flat_absy::flat_parameter::FlatParameter;
use flat_absy::flat_variable::FlatVariable;
use flat_absy::*;
use helpers::{DirectiveStatement, Helper};
use reduce::Reduce;
use types::constraints::Constraint;
use types::signature::Signature;
use types::Type;
use zokrates_field::field::Field;
@ -167,94 +165,24 @@ pub fn cast<T: Field>(from: &Type, to: &Type) -> FlatFunction<T> {
})
.collect();
let directive_inputs = (0..from.get_primitive_count())
let binding_inputs: Vec<_> = (0..from.get_primitive_count())
.map(|index| use_variable(&mut bijection, format!("i{}", index), &mut counter))
.collect();
let directive_outputs: Vec<FlatVariable> = (0..to.get_primitive_count())
let binding_outputs: Vec<FlatVariable> = (0..to.get_primitive_count())
.map(|index| use_variable(&mut bijection, format!("o{}", index), &mut counter))
.collect();
let constraints = to.get_constraints::<T>().constraints;
let intermediate_variables = match constraints.len() {
0 => vec![],
_ => constraints[0]
.a
.iter()
.enumerate()
.map(|(_, index)| use_variable(&mut bijection, format!("inter{}", index), &mut counter))
.collect(),
};
let conditions: Vec<FlatStatement<T>> = to
.get_constraints()
.constraints
let outputs = binding_outputs
.iter()
.map(|constraint: &Constraint<T>| {
let rhs_a = match constraint
.a
.iter()
.enumerate()
.map(|(key, val)| {
FlatExpression::Mult(
box FlatExpression::Number(val.clone()),
box FlatExpression::Identifier(intermediate_variables[key]),
)
})
.reduce(|acc, e| FlatExpression::Add(box acc, box e))
{
Some(e @ FlatExpression::Mult(..)) => {
FlatExpression::Add(box FlatExpression::Number(T::zero()), box e)
} // the R1CS serializer only recognizes Add
Some(e) => e,
None => FlatExpression::Number(T::zero()),
};
let rhs_b = match constraint
.b
.iter()
.enumerate()
.map(|(key, val)| {
FlatExpression::Mult(
box FlatExpression::Number(val.clone()),
box FlatExpression::Identifier(intermediate_variables[key]),
)
})
.reduce(|acc, e| FlatExpression::Add(box acc, box e))
{
Some(e @ FlatExpression::Mult(..)) => {
FlatExpression::Add(box FlatExpression::Number(T::zero()), box e)
} // the R1CS serializer only recognizes Add
Some(e) => e,
None => FlatExpression::Number(T::zero()),
};
let lhs = match constraint
.c
.iter()
.enumerate()
.map(|(key, val)| {
FlatExpression::Mult(
box FlatExpression::Number(val.clone()),
box FlatExpression::Identifier(intermediate_variables[key]),
)
})
.reduce(|acc, e| FlatExpression::Add(box acc, box e))
{
Some(e @ FlatExpression::Mult(..)) => {
FlatExpression::Add(box FlatExpression::Number(T::zero()), box e)
} // the R1CS serializer only recognizes Add
Some(e) => e,
None => FlatExpression::Number(T::zero()),
};
FlatStatement::Condition(lhs, FlatExpression::Mult(box rhs_a, box rhs_b))
})
.map(|o| FlatExpression::Identifier(o.clone()))
.collect();
let helper = match (from, to) {
(Type::Boolean, Type::FieldElement) => Helper::identity(),
(Type::FieldElement, Type::Boolean) => Helper::identity(),
let bindings: Vec<_> = match (from, to) {
(Type::Boolean, Type::FieldElement) => binding_outputs
.into_iter()
.zip(binding_inputs.into_iter())
.map(|(o, i)| FlatStatement::Definition(o, i.into()))
.collect(),
_ => panic!(format!("can't cast {} to {}", from, to)),
};
@ -263,26 +191,13 @@ pub fn cast<T: Field>(from: &Type, to: &Type) -> FlatFunction<T> {
outputs: vec![to.clone()],
};
let outputs = directive_outputs
.iter()
.map(|o| FlatExpression::Identifier(o.clone()))
let statements = bindings
.into_iter()
.chain(std::iter::once(FlatStatement::Return(FlatExpressionList {
expressions: outputs,
})))
.collect();
let mut statements = conditions;
statements.insert(
0,
FlatStatement::Directive(DirectiveStatement::new(
directive_outputs,
helper,
directive_inputs,
)),
);
statements.push(FlatStatement::Return(FlatExpressionList {
expressions: outputs,
}));
FlatFunction {
id: format!("_{}_to_{}", from, to),
arguments,
@ -300,32 +215,6 @@ mod tests {
mod cast {
use super::*;
#[test]
fn field_to_bool() {
let f2b: FlatFunction<FieldPrime> = cast(&Type::FieldElement, &Type::Boolean);
assert_eq!(f2b.id, String::from("_field_to_bool"));
assert_eq!(
f2b.arguments,
vec![FlatParameter::private(FlatVariable::new(0))]
);
assert_eq!(f2b.statements.len(), 3); // 1 directive, 1 constraint, 1 return
assert_eq!(
f2b.statements[0],
FlatStatement::Directive(DirectiveStatement::new(
vec![FlatVariable::new(1)],
Helper::identity(),
vec![FlatVariable::new(0)]
))
);
assert_eq!(
f2b.statements[2],
FlatStatement::Return(FlatExpressionList {
expressions: vec![FlatExpression::Identifier(FlatVariable::new(1))]
})
);
assert_eq!(f2b.signature.outputs.len(), 1);
}
#[test]
fn bool_to_field() {
let b2f: FlatFunction<FieldPrime> = cast(&Type::Boolean, &Type::FieldElement);
@ -334,14 +223,10 @@ mod tests {
b2f.arguments,
vec![FlatParameter::private(FlatVariable::new(0))]
);
assert_eq!(b2f.statements.len(), 2); // 1 directive, 1 return
assert_eq!(b2f.statements.len(), 2); // 1 definition, 1 return
assert_eq!(
b2f.statements[0],
FlatStatement::Directive(DirectiveStatement::new(
vec![FlatVariable::new(1)],
Helper::identity(),
vec![FlatVariable::new(0)]
))
FlatStatement::Definition(FlatVariable::new(1), FlatVariable::new(0).into())
);
assert_eq!(
b2f.statements[1],

21
zokrates_core/src/types/mod.rs
View file

@ -1,9 +1,6 @@
use std::fmt;
use types::constraints::Constraints;
pub use types::signature::Signature;
use zokrates_field::field::Field;
mod constraints;
pub mod conversions;
mod signature;
@ -35,14 +32,6 @@ impl fmt::Debug for Type {
}
impl Type {
fn get_constraints<T: Field>(&self) -> Constraints<T> {
match self {
Type::FieldElement => Constraints::none(),
Type::Boolean => Constraints::boolean(),
Type::FieldElementArray(_) => Type::FieldElement.get_constraints(),
}
}
// the number of field elements the type maps to
pub fn get_primitive_count(&self) -> usize {
match self {
@ -64,21 +53,11 @@ impl Type {
#[cfg(test)]
mod tests {
use super::*;
use zokrates_field::field::FieldPrime;
#[test]
fn array() {
let t = Type::FieldElementArray(42);
assert_eq!(t.get_primitive_count(), 42);
assert_eq!(t.get_constraints::<FieldPrime>(), Constraints::none());
assert_eq!(t.to_slug(), "f[42]");
}
// #[test]
// fn array_of_arrays() {
// let t = Type::FieldElementArray(42, box Type::FieldElementArray(33, box Type::Boolean));
// assert_eq!(t.get_primitive_count(), 1);
// assert_eq!(t.get_constraints::<FieldPrime>(), Constraints::boolean());
// assert_eq!(t.to_slug(), "[]");
// }
}