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

add tests, add log

Browse source
This commit is contained in:
schaeff 2020-02-24 10:59:11 +01:00
parent fec3e4dbfa
commit ca53a928ee
16 changed files with 107 additions and 30 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
u8.zok
View file

@ -41,7 +41,9 @@ def right_rotate_25(u32 e) -> (u32):
bool[32] b = to_bits(e)
return from_bits([...b[25..], ...b[..25]])
def main(u32[1][16] input) -> (u32[8]):
def main() -> (u32[8]):
u32[1][16] input = [[0x00000000; 16]]
u32 h0 = 0x6a09e667
u32 h1 = 0xbb67ae85
@ -76,7 +78,7 @@ def main(u32[1][16] input) -> (u32[8]):
u32 g = h6
u32 h = h7
for field i in 0..64 do
for field i in 0..0 do
u32 S1 = right_rotate_6(e) ^ right_rotate_11(e) ^ right_rotate_25(e)
u32 ch = (e + f) ^ (!e + g)

6
zokrates_core/src/flat_absy/mod.rs
View file

@ -92,6 +92,7 @@ pub enum FlatStatement<T: Field> {
Condition(FlatExpression<T>, FlatExpression<T>),
Definition(FlatVariable, FlatExpression<T>),
Directive(FlatDirective<T>),
Log(String),
}
impl<T: Field> fmt::Display for FlatStatement<T> {
@ -101,6 +102,7 @@ impl<T: Field> fmt::Display for FlatStatement<T> {
FlatStatement::Return(ref expr) => write!(f, "return {}", expr),
FlatStatement::Condition(ref lhs, ref rhs) => write!(f, "{} == {}", lhs, rhs),
FlatStatement::Directive(ref d) => write!(f, "{}", d),
FlatStatement::Log(ref s) => write!(f, "{}", s),
}
}
}
@ -114,6 +116,7 @@ impl<T: Field> fmt::Debug for FlatStatement<T> {
write!(f, "FlatCondition({:?}, {:?})", lhs, rhs)
}
FlatStatement::Directive(ref d) => write!(f, "{:?}", d),
FlatStatement::Log(ref l) => write!(f, "{:?}", l),
}
}
}
@ -150,7 +153,8 @@ impl<T: Field> FlatStatement<T> {
inputs,
..d
})
}
},
FlatStatement::Log(l) => FlatStatement::Log(l)
}
}
}

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

@ -92,7 +92,7 @@ impl<T: Field> FlatUExpression<T> {
Some(f) => f,
None => match self.bits {
Some(bits) => {
assert_eq!(bits.len(), 32);
//assert_eq!(bits.len(), 32);
bits.into_iter().rev().enumerate().fold(
FlatExpression::Number(T::from(0)),
|acc, (index, bit)| {
@ -692,7 +692,8 @@ impl<'ast, T: Field> Flattener<'ast, T> {
solver: d.solver,
inputs: new_inputs,
})
}
},
FlatStatement::Log(s) => FlatStatement::Log(s),
})
.collect();
@ -748,6 +749,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
statements_flattened: &mut Vec<FlatStatement<T>>,
expr: UExpression<'ast, T>,
) -> FlatUExpression<T> {
let target_bitwidth = expr.bitwidth;
let metadata = expr.metadata.clone().unwrap().clone();
@ -1028,6 +1030,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
let left_flattened =
self.flatten_uint_expression(symbols, statements_flattened, left);
let right_flattened =
self.flatten_uint_expression(symbols, statements_flattened, right);
@ -1112,7 +1115,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
// constants do not require directives!
match e.field.clone() {
Some(FlatExpression::Number(x)) => {
let bits = vec![FlatExpression::Number(T::from(0)); 32];
let bits: Vec<_> = Solver::bits(from).execute(&vec![x]).unwrap().into_iter().map(|x| FlatExpression::Number(x)).collect();
self.bits_cache
.insert(e.field.clone().unwrap(), bits.clone());
return bits;
@ -1428,6 +1431,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
statements_flattened: &mut Vec<FlatStatement<T>>,
stat: ZirStatement<'ast, T>,
) {
statements_flattened.push(FlatStatement::Log(format!("{}", stat)));
match stat {
ZirStatement::Return(exprs) => {
let flat_expressions = exprs

1
zokrates_core/src/ir/folder.rs
View file

@ -52,6 +52,7 @@ pub fn fold_statement<T: Field, F: Folder<T>>(f: &mut F, s: Statement<T>) -> Vec
f.fold_linear_combination(lin),
)],
Statement::Directive(dir) => vec![Statement::Directive(f.fold_directive(dir))],
Statement::Log(s) => vec![Statement::Log(s)],
}
}

1
zokrates_core/src/ir/from_flat.rs
View file

@ -115,6 +115,7 @@ impl<T: Field> From<FlatStatement<T>> for Statement<T> {
e => Statement::Constraint(LinComb::from(e).into(), var.into()),
},
FlatStatement::Directive(ds) => Statement::Directive(ds.into()),
FlatStatement::Log(s) => Statement::Log(s),
_ => panic!("return should be handled at the function level"),
}
}

3
zokrates_core/src/ir/interpreter.rs
View file

@ -49,7 +49,8 @@ impl<T: Field> Prog<T> {
}
Err(_) => return Err(Error::Solver),
};
}
},
_ => {}
}
}

2
zokrates_core/src/ir/mod.rs
View file

@ -20,6 +20,7 @@ pub use self::witness::Witness;
pub enum Statement<T: Field> {
Constraint(QuadComb<T>, LinComb<T>),
Directive(Directive<T>),
Log(String),
}
impl<T: Field> Statement<T> {
@ -64,6 +65,7 @@ impl<T: Field> fmt::Display for Statement<T> {
match *self {
Statement::Constraint(ref quad, ref lin) => write!(f, "{} == {}", quad, lin),
Statement::Directive(ref s) => write!(f, "{}", s),
Statement::Log(ref l) => write!(f, "\n{}\n", l),
}
}
}

5
zokrates_core/src/optimizer/redefinition.rs
View file

@ -33,7 +33,7 @@
// - otherwise return `c_0`
use crate::flat_absy::flat_variable::FlatVariable;
use crate::ir::folder::{fold_function, Folder};
use crate::ir::folder::{fold_function, Folder, fold_statement};
use crate::ir::LinComb;
use crate::ir::*;
use num::Zero;
@ -117,7 +117,8 @@ impl<T: Field> Folder<T> for RedefinitionOptimizer<T> {
self.substitution.insert(o.clone(), o.clone().into());
}
vec![Statement::Directive(d)]
}
},
s => fold_statement(self, s)
}
}

1
zokrates_core/src/static_analysis/flat_propagation.rs
View file

@ -81,6 +81,7 @@ impl<T: Field> FlatStatement<T> {
.collect(),
..d
})),
FlatStatement::Log(s) => Some(FlatStatement::Log(s)),
}
}
}

24
zokrates_core_test/tests/tests/uint/add.json
View file

@ -4,11 +4,31 @@
"tests": [
{
"input": {
"values": ["1", "2"]
"values": ["0xff", "0x01"]
},
"output": {
"Ok": {
"values": ["3"]
"values": ["0x00"]
}
}
},
{
"input": {
"values": ["0x00", "0x01"]
},
"output": {
"Ok": {
"values": ["0x01"]
}
}
},
{
"input": {
"values": ["0xff", "0xff"]
},
"output": {
"Ok": {
"values": ["0xfe"]
}
}
}

12
zokrates_core_test/tests/tests/uint/and.json
View file

@ -4,31 +4,31 @@
"tests": [
{
"input": {
"values": ["255", "255"]
"values": ["0xff", "0xff"]
},
"output": {
"Ok": {
"values": ["255"]
"values": ["0xff"]
}
}
},
{
"input": {
"values": ["255", "0"]
"values": ["0xff", "0x00"]
},
"output": {
"Ok": {
"values": ["0"]
"values": ["0x00"]
}
}
},
{
"input": {
"values": ["123", "234"]
"values": ["0x23", "0x34"]
},
"output": {
"Ok": {
"values": ["106"]
"values": ["0x20"]
}
}
}

16
zokrates_core_test/tests/tests/uint/constant.json Normal file
View file

@ -0,0 +1,16 @@
{
"entry_point": "./tests/tests/uint/constant.zok",
"constraint_count": 1,
"tests": [
{
"input": {
"values": []
},
"output": {
"Ok": {
"values": ["0x01234567"]
}
}
}
]
}

2
zokrates_core_test/tests/tests/uint/constant.zok Normal file
View file

@ -0,0 +1,2 @@
def main() -> (u32):
return 0x01234567

14
zokrates_core_test/tests/tests/uint/maj.json
View file

@ -4,11 +4,21 @@
"tests": [
{
"input": {
"values": ["0", "0"]
"values": ["0x00000000", "0x00000000"]
},
"output": {
"Ok": {
"values": ["0"]
"values": ["0x00000000"]
}
}
},
{
"input": {
"values": ["0x01234567", "0x23456789"]
},
"output": {
"Ok": {
"values": ["0x03254769"]
}
}
}

12
zokrates_core_test/tests/tests/uint/xor.json
View file

@ -4,31 +4,31 @@
"tests": [
{
"input": {
"values": ["255", "255"]
"values": ["0xff", "0xff"]
},
"output": {
"Ok": {
"values": ["0"]
"values": ["0x00"]
}
}
},
{
"input": {
"values": ["255", "0"]
"values": ["0xff", "0x00"]
},
"output": {
"Ok": {
"values": ["255"]
"values": ["0xff"]
}
}
},
{
"input": {
"values": ["123", "234"]
"values": ["0x23", "0x34"]
},
"output": {
"Ok": {
"values": ["145"]
"values": ["0x17"]
}
}
}

22
zokrates_test/src/lib.rs
View file

@ -35,6 +35,16 @@ struct Output {
type Val = String;
fn parse_val<T: Field>(s: String) -> T {
let s = if s.starts_with("0x") {
u32::from_str_radix(s.trim_start_matches("0x"), 16).unwrap().to_string()
} else {
s
};
T::try_from_dec_str(&s).unwrap()
}
impl From<ir::ExecutionResult<FieldPrime>> for ComparableResult {
fn from(r: ir::ExecutionResult<FieldPrime>) -> ComparableResult {
ComparableResult(r.map(|v| v.return_values()))
@ -45,8 +55,8 @@ impl From<TestResult> for ComparableResult {
fn from(r: TestResult) -> ComparableResult {
ComparableResult(r.map(|v| {
v.values
.iter()
.map(|v| FieldPrime::try_from_dec_str(v).unwrap())
.into_iter()
.map(parse_val)
.collect()
}))
}
@ -95,11 +105,13 @@ pub fn test_inner(test_path: &str) {
for test in t.tests.into_iter() {
let input = &test.input.values;
let output = bin.execute(
&input
&dbg!(input
.iter()
.map(|v| FieldPrime::try_from_dec_str(&v.clone()).unwrap())
.collect(),
.cloned()
.map(parse_val)
.collect()),
);
match compare(output, test.output) {