diff --git a/.circleci/config.yml b/.circleci/config.yml index 4953923e..4dec2526 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -130,7 +130,7 @@ jobs: command: cd zokrates_js && npm run build zokrates_js_test: docker: - - image: circleci/node + - image: dark64/rust-wasm-env:latest steps: - checkout - run: diff --git a/zokrates_cli/examples/arrays/update.zok b/zokrates_cli/examples/arrays/update.zok index ef660b33..149f5075 100644 --- a/zokrates_cli/examples/arrays/update.zok +++ b/zokrates_cli/examples/arrays/update.zok @@ -5,5 +5,5 @@ def foo(field[3] a) -> (field): def main() -> (field, field): field[3] a = [0, 0, 0] field res = foo(a) - a[1] == 0 + assert(a[1] == 0) return res, a[1] diff --git a/zokrates_cli/examples/arrays/update_with_call.zok b/zokrates_cli/examples/arrays/update_with_call.zok index fcc3eb1a..a50b7daa 100644 --- a/zokrates_cli/examples/arrays/update_with_call.zok +++ b/zokrates_cli/examples/arrays/update_with_call.zok @@ -5,5 +5,5 @@ def main(field a) -> (field, field): field[2] result = [0, 0] field r = foo(a) result[1] = r - result[1] == r + assert(result[1] == r) return result[1], r \ No newline at end of file diff --git a/zokrates_cli/examples/book/factorize.zok b/zokrates_cli/examples/book/factorize.zok index 1f1a4e9f..c9f6be09 100644 --- a/zokrates_cli/examples/book/factorize.zok +++ b/zokrates_cli/examples/book/factorize.zok @@ -1,3 +1,2 @@ -def main(private field a, field b) -> (field): - field result = if a * a == b then 1 else 0 fi - return result \ No newline at end of file +def main(private field a, field b) -> (bool): + return a * a == b \ No newline at end of file diff --git a/zokrates_cli/examples/book/field_overflow.zok b/zokrates_cli/examples/book/field_overflow.zok index 6bfbc80f..1b208553 100644 --- a/zokrates_cli/examples/book/field_overflow.zok +++ b/zokrates_cli/examples/book/field_overflow.zok @@ -1,4 +1,4 @@ -def main() -> (field): +def main() -> (): field pMinusOne = 21888242871839275222246405745257275088548364400416034343698204186575808495616 - 0 - 1 == pMinusOne - return 1 \ No newline at end of file + assert(0 - 1 == pMinusOne) + return \ No newline at end of file diff --git a/zokrates_cli/examples/book/hashexample_updated.zok b/zokrates_cli/examples/book/hashexample_updated.zok index c231f72e..42ed341c 100644 --- a/zokrates_cli/examples/book/hashexample_updated.zok +++ b/zokrates_cli/examples/book/hashexample_updated.zok @@ -1,7 +1,7 @@ import "hashes/sha256/512bitPacked" as sha256packed -def main(private field a, private field b, private field c, private field d) -> (field): +def main(private field a, private field b, private field c, private field d) -> (): field[2] h = sha256packed([a, b, c, d]) - h[0] == 263561599766550617289250058199814760685 - h[1] == 65303172752238645975888084098459749904 - return 1 \ No newline at end of file + assert(h[0] == 263561599766550617289250058199814760685) + assert(h[1] == 65303172752238645975888084098459749904) + return \ No newline at end of file diff --git a/zokrates_cli/examples/book/side_effects.zok b/zokrates_cli/examples/book/side_effects.zok index 6a3d757f..0941a2d6 100644 --- a/zokrates_cli/examples/book/side_effects.zok +++ b/zokrates_cli/examples/book/side_effects.zok @@ -2,8 +2,8 @@ def incr(field a) -> (field): a = a + 1 return a -def main() -> (field): +def main() -> (): field x = 1 field res = incr(x) - x == 1 // x has not changed - return 1 \ No newline at end of file + assert(x == 1) // x has not changed + return \ No newline at end of file diff --git a/zokrates_cli/examples/book/type_annotations.zok b/zokrates_cli/examples/book/type_annotations.zok index 8cff31e1..e3e1c80d 100644 --- a/zokrates_cli/examples/book/type_annotations.zok +++ b/zokrates_cli/examples/book/type_annotations.zok @@ -4,6 +4,6 @@ def foo() -> (field, field[3]): def foo() -> (field, field): return 1, 2 -def main() -> (field): +def main() -> (): field a, field[3] b = foo() - return 1 \ No newline at end of file + return \ No newline at end of file diff --git a/zokrates_cli/examples/bool_and.zok b/zokrates_cli/examples/bool_and.zok index d7017044..7ed3a460 100644 --- a/zokrates_cli/examples/bool_and.zok +++ b/zokrates_cli/examples/bool_and.zok @@ -3,5 +3,5 @@ def main(field a, field b) -> (field): field y = if a + 2 == 3 && a * 2 == 2 then 1 else 0 fi field z = if y == 1 && 1-y == 0 then y else 1 fi - b == 1 + assert(b == 1) return a \ No newline at end of file diff --git a/zokrates_cli/examples/bool_or.zok b/zokrates_cli/examples/bool_or.zok index 664b7eea..77457eac 100644 --- a/zokrates_cli/examples/bool_or.zok +++ b/zokrates_cli/examples/bool_or.zok @@ -2,6 +2,6 @@ def main(field a, field b) -> (field): field y = if a + 2 == 4 || b * 2 == 2 then 1 else 0 fi field z = if y == 1 || y == 0 then y else 1 fi - z == 1 + assert(z == 1) return z diff --git a/zokrates_cli/examples/comments.zok b/zokrates_cli/examples/comments.zok index 082932df..af9d8070 100644 --- a/zokrates_cli/examples/comments.zok +++ b/zokrates_cli/examples/comments.zok @@ -2,6 +2,6 @@ def main(field a) -> (field): // a needs to be 1 field b = a + 5 // inline comment field c = a + b + a + 4 - a == 1 // another inline comment + assert(a == 1) // another inline comment field d = a + c + a + b return b + c + d diff --git a/zokrates_cli/examples/conditions.zok b/zokrates_cli/examples/conditions.zok index 526239b1..d6f0051b 100644 --- a/zokrates_cli/examples/conditions.zok +++ b/zokrates_cli/examples/conditions.zok @@ -1,6 +1,19 @@ +struct Foo { + field a +} + +struct Bar { + Foo[1] foo +} + +def isEqual(field a, field b) -> (bool): + return a == b + def main(field a) -> (field): field b = (a + 5) * 6 - 2 * b == a * 12 + 60 + assert(2 * b == a * 12 + 60) field c = 7 * (b + a) - c == 7 * b + 7 * a - return b + c + assert(isEqual(c, 7 * b + 7 * a)) + field k = if [1, 2] == [3, 4] then 1 else 3 fi + assert([Bar { foo : [Foo { a: 42 }]}] == [Bar { foo : [Foo { a: 42 }]}]) + return b + c \ No newline at end of file diff --git a/zokrates_cli/examples/error/assert.zok b/zokrates_cli/examples/error/assert.zok new file mode 100644 index 00000000..aa2fb018 --- /dev/null +++ b/zokrates_cli/examples/error/assert.zok @@ -0,0 +1,5 @@ +def assert() -> (): + return + +def main() -> (): + return \ No newline at end of file diff --git a/zokrates_cli/examples/factorization.zok b/zokrates_cli/examples/factorization.zok index 84996cde..31824a9b 100644 --- a/zokrates_cli/examples/factorization.zok +++ b/zokrates_cli/examples/factorization.zok @@ -1,5 +1,5 @@ // a and b are factorization of c -def main(field c, private field a, private field b) -> (field): +def main(field c, private field a, private field b) -> (): field d = a * b - c == d - return 1 + assert(c == d) + return diff --git a/zokrates_cli/examples/functions/lt_comparison.zok b/zokrates_cli/examples/functions/lt_comparison.zok index edeb29d9..8de0ca28 100644 --- a/zokrates_cli/examples/functions/lt_comparison.zok +++ b/zokrates_cli/examples/functions/lt_comparison.zok @@ -1,23 +1,17 @@ -def lt(field a,field b) -> (field): - return if a < b then 1 else 0 fi +def lt(field a,field b) -> (bool): + return a < b def cutoff() -> (field): return 31337 def getThing(field index) -> (field): - field result = 3 - result = if index == 0 then 13 else result fi - result = if index == 1 then 23 else result fi - result = if index == 2 then 43 else result fi - result = if index == 3 then 53 else result fi - result = if index == 4 then 73 else result fi - result = if index == 5 then 83 else result fi - return result + field[6] a = [13, 23, 43, 53, 73, 83] + return a[index] def cubeThing(field thing) -> (field): return thing**3 -def main(field index) -> (field): +def main(field index) -> (bool): field thing = getThing(index) thing = cubeThing(thing) return lt(cutoff(), thing) diff --git a/zokrates_cli/examples/imports/import.zok b/zokrates_cli/examples/imports/import.zok index a40727e1..194b3c50 100644 --- a/zokrates_cli/examples/imports/import.zok +++ b/zokrates_cli/examples/imports/import.zok @@ -7,5 +7,5 @@ import "./bar" def main() -> (field): MyBar my_bar = MyBar {} Bar bar = Bar {} - my_bar == bar + assert(my_bar == bar) return foo() + bar() \ No newline at end of file diff --git a/zokrates_cli/examples/left_side_call.zok b/zokrates_cli/examples/left_side_call.zok index 5b204ec6..43aac4b4 100644 --- a/zokrates_cli/examples/left_side_call.zok +++ b/zokrates_cli/examples/left_side_call.zok @@ -1,6 +1,6 @@ def foo() -> (field): return 1 -def main() -> (field): - foo() + (1 + 44*3) == 1 - return 1 +def main() -> (): + assert(foo() + (1 + 44*3) == 1) + return diff --git a/zokrates_cli/examples/merkleTree/pedersenPathProof3.zok b/zokrates_cli/examples/merkleTree/pedersenPathProof3.zok index 8b238fd9..109fe71d 100644 --- a/zokrates_cli/examples/merkleTree/pedersenPathProof3.zok +++ b/zokrates_cli/examples/merkleTree/pedersenPathProof3.zok @@ -6,7 +6,11 @@ import "hashes/utils/256bitsDirectionHelper" as multiplex // Merke-Tree inclusion proof for tree depth 3 using SNARK efficient pedersen hashes // directionSelector=> 1/true if current digest is on the rhs of the hash +<<<<<<< HEAD def main(u32[8] rootDigest, private u32[8] leafDigest, private bool[3] directionSelector, u32[8] PathDigest0, private u32[8] PathDigest1, private u32[8] PathDigest2) -> (field): +======= +def main(bool[256] rootDigest, private bool[256] leafDigest, private bool[3] directionSelector, bool[256] PathDigest0, private bool[256] PathDigest1, private bool[256] PathDigest2) -> (): +>>>>>>> 26f4d72ee6e0c802823cf145fbd11a372586eb28 BabyJubJubParams context = context() //Setup @@ -22,7 +26,7 @@ def main(u32[8] rootDigest, private u32[8] leafDigest, private bool[3] direction preimage = multiplex(directionSelector[2], currentDigest, PathDigest2) currentDigest = hash(preimage) - rootDigest == currentDigest - - return 1 //return true in success + assert(rootDigest == currentDigest) + + return diff --git a/zokrates_cli/examples/merkleTree/sha256PathProof3.zok b/zokrates_cli/examples/merkleTree/sha256PathProof3.zok index c51f1b1a..3c27c69f 100644 --- a/zokrates_cli/examples/merkleTree/sha256PathProof3.zok +++ b/zokrates_cli/examples/merkleTree/sha256PathProof3.zok @@ -3,7 +3,11 @@ import "utils/multiplexer/256bit" as multiplex // Merkle-Tree inclusion proof for tree depth 3 +<<<<<<< HEAD def main(field treeDepth, u32[8] rootDigest, private u32[8] leafDigest, private bool[2] directionSelector, u32[8] PathDigest0, private u32[8] PathDigest1) -> (field): +======= +def main(field treeDepth, bool[256] rootDigest, private bool[256] leafDigest, private bool[2] directionSelector, bool[256] PathDigest0, private bool[256] PathDigest1) -> (): +>>>>>>> 26f4d72ee6e0c802823cf145fbd11a372586eb28 //Setup u32[8] currentDigest = leafDigest @@ -23,8 +27,7 @@ def main(field treeDepth, u32[8] rootDigest, private u32[8] leafDigest, private currentDigest = sha256(lhs, rhs) counter = counter + 1 - //Asserts - counter == treeDepth - rootDigest == currentDigest + assert(counter == treeDepth) + assert(rootDigest == currentDigest) - return 1 //return true in success \ No newline at end of file + return \ No newline at end of file diff --git a/zokrates_cli/examples/multi_return.zok b/zokrates_cli/examples/multi_return.zok index b779312a..10fcf28c 100644 --- a/zokrates_cli/examples/multi_return.zok +++ b/zokrates_cli/examples/multi_return.zok @@ -2,6 +2,6 @@ def foo(field a) -> (field, field, field, field): field b = 12*a return a, 2*a, 5*b, a*b -def main(field i) -> (field): +def main(field i) -> (): field x, field y, field z, field t = foo(i) - return 1 + return diff --git a/zokrates_cli/examples/multiple_witnesses.zok b/zokrates_cli/examples/multiple_witnesses.zok index 134faf24..3723f107 100644 --- a/zokrates_cli/examples/multiple_witnesses.zok +++ b/zokrates_cli/examples/multiple_witnesses.zok @@ -1,4 +1,4 @@ // this code does not need to be flattened def main(field x, field a, field b) -> (field): - a == b * 7 + assert(a == b * 7) return x + a + b diff --git a/zokrates_cli/examples/no_flatten.zok b/zokrates_cli/examples/no_flatten.zok index 0688c448..3f86e52d 100644 --- a/zokrates_cli/examples/no_flatten.zok +++ b/zokrates_cli/examples/no_flatten.zok @@ -1,6 +1,6 @@ // this code does not need to be flattened def main(field x, field y, field z) -> (field): field a = x + 3*y - z *2 - x * 12 - 3*y - z *2 - x * 12 == a - x - (x + y) - ((z + 3*x) - y) == (x - y) + ((2*x - 4*y) + (4*y - 2*z)) + assert(3*y - z *2 - x * 12 == a - x) + assert((x + y) - ((z + 3*x) - y) == (x - y) + ((2*x - 4*y) + (4*y - 2*z))) return x diff --git a/zokrates_cli/examples/pow.zok b/zokrates_cli/examples/pow.zok index 2fbb98cf..7d157bae 100644 --- a/zokrates_cli/examples/pow.zok +++ b/zokrates_cli/examples/pow.zok @@ -1,16 +1,16 @@ -def main() -> (field): +def main() -> (): field x = 2**4 - x == 16 + assert(x == 16) x = x**2 - x == 256 + assert(x == 256) field y = 3**3 - y == 27 + assert(y == 27) field z = y**2 - z == 729 + assert(z == 729) field a = 5**2 - a == 25 + assert(a == 25) a = a**2 - a == 625 + assert(a == 625) a = 5**5 - a == 3125 - return 1 + assert(a == 3125) + return diff --git a/zokrates_cli/examples/propagate_call.zok b/zokrates_cli/examples/propagate_call.zok index ea3435d4..02518cd0 100644 --- a/zokrates_cli/examples/propagate_call.zok +++ b/zokrates_cli/examples/propagate_call.zok @@ -1,5 +1,5 @@ def foo(field a, field b) -> (field, field): - a == b + 2 + assert(a == b + 2) return a, b def main() -> (field): diff --git a/zokrates_cli/examples/runtime_errors/lt_overflow_max_plus_1.zok b/zokrates_cli/examples/runtime_errors/lt_overflow_max_plus_1.zok index 0c1b91eb..41dc0299 100644 --- a/zokrates_cli/examples/runtime_errors/lt_overflow_max_plus_1.zok +++ b/zokrates_cli/examples/runtime_errors/lt_overflow_max_plus_1.zok @@ -4,9 +4,9 @@ // It should not work for the maxvalue = 2^(pbits - 2) - 1 augmented by one // /!\ should be called with a = 0 -def main(field a) -> (field): +def main(field a) -> (bool): field pbits = 254 // maxvalue = 2**252 - 1 field maxvalue = a + 7237005577332262213973186563042994240829374041602535252466099000494570602496 - 1 // we added a = 0 to prevent the condition to be evaluated at compile time - return if 0 < (maxvalue + 1) then 1 else 0 fi \ No newline at end of file + return 0 < (maxvalue + 1) \ No newline at end of file diff --git a/zokrates_cli/examples/runtime_errors/lt_overflow_p_minus_one.zok b/zokrates_cli/examples/runtime_errors/lt_overflow_p_minus_one.zok index 49700543..5ee8ca0d 100644 --- a/zokrates_cli/examples/runtime_errors/lt_overflow_p_minus_one.zok +++ b/zokrates_cli/examples/runtime_errors/lt_overflow_p_minus_one.zok @@ -1,7 +1,7 @@ // as p - 1 is greater than p/2, comparing to it should fail // /!\ should be called with a = 0 -def main(field a) -> (field): +def main(field a) -> (bool): field p = 21888242871839275222246405745257275088548364400416034343698204186575808495617 + a // we added a = 0 to prevent the condition to be evaluated at compile time - return if 0 < p - 1 then 1 else 0 fi \ No newline at end of file + return 0 < p - 1 \ No newline at end of file diff --git a/zokrates_cli/examples/sudoku/prime_sudoku_checker.zok b/zokrates_cli/examples/sudoku/prime_sudoku_checker.zok new file mode 100644 index 00000000..9ac4a216 --- /dev/null +++ b/zokrates_cli/examples/sudoku/prime_sudoku_checker.zok @@ -0,0 +1,58 @@ +// Sudoku of format + +// | a11 | a12 || b11 | b12 | +// -------------------------- +// | a21 | a22 || b21 | b22 | +// ========================== +// | c11 | c12 || d11 | d12 | +// -------------------------- +// | c21 | c22 || d21 | d22 | + +// We encode values in the following way: +// 1 -> 2 +// 2 -> 3 +// 3 -> 5 +// 4 -> 7 + +// returns true if there are no duplicates +// assumption: `a, b, c, d` are all in `{ 2, 3, 5, 7 }` +def checkNoDuplicates(field a, field b, field c, field d) -> (bool): + // as `{ 2, 3, 5, 7 }` are primes, the set `{ a, b, c, d }` is equal to the set `{ 2, 3, 5, 7}` if and only if the products match + return a * b * c * d == 2 * 3 * 5 * 7 + +// returns `0` if and only if `x` in `{ 2, 3, 5, 7 }` +def validateInput(field x) -> (bool): + return (x-2) * (x-3) * (x-5) * (x-7) == 0 + +// variables naming: box'row''column' +def main(field a21, field b11, field b22, field c11, field c22, field d21, private field a11, private field a12, private field a22, private field b12, private field b21, private field c12, private field c21, private field d11, private field d12, private field d22) -> (bool): + + field[4][4] a = [[a11, a12, b11, b12], [a21, a22, b21, b22], [c11, c12, d11, d12], [c21, c22, d21, d22]] + + bool res = true + + // go through the whole grid and check that all elements are valid + for field i in 0..4 do + for field j in 0..4 do + res = res && validateInput(a[i][j]) + endfor + endfor + + // go through the 4 2x2 boxes and check that they do not contain duplicates + for field i in 0..1 do + for field j in 0..1 do + res = res && checkNoDuplicates(a[2*i][2*i], a[2*i][2*i + 1], a[2*i + 1][2*i], a[2*i + 1][2*i + 1]) + endfor + endfor + + // go through the 4 rows and check that they do not contain duplicates + for field i in 0..4 do + res = res && checkNoDuplicates(a[i][0], a[i][1], a[i][2], a[i][3]) + endfor + + // go through the 4 columns and check that they do not contain duplicates + for field j in 0..4 do + res = res && checkNoDuplicates(a[0][j], a[1][j], a[2][j], a[3][j]) + endfor + + return res diff --git a/zokrates_cli/examples/sudoku/sudoku_checker.zok b/zokrates_cli/examples/sudoku/sudoku_checker.zok new file mode 100644 index 00000000..d86c9e3b --- /dev/null +++ b/zokrates_cli/examples/sudoku/sudoku_checker.zok @@ -0,0 +1,75 @@ +// Sudoku of format + +// | a11 | a12 || b11 | b12 | +// -------------------------- +// | a21 | a22 || b21 | b22 | +// ========================== +// | c11 | c12 || d11 | d12 | +// -------------------------- +// | c21 | c22 || d21 | d22 | + +// We use a naive encoding of the values as `[1, 2, 3, 4]` and rely on if-else statements to detect duplicates + +def countDuplicates(field e11,field e12,field e21,field e22) -> (field): + field duplicates = if e11 == e12 then 1 else 0 fi + duplicates = duplicates + if e11 == e21 then 1 else 0 fi + duplicates = duplicates + if e11 == e22 then 1 else 0 fi + duplicates = duplicates + if e12 == e21 then 1 else 0 fi + duplicates = duplicates + if e12 == e21 then 1 else 0 fi + duplicates = duplicates + if e21 == e22 then 1 else 0 fi + return duplicates + +// returns 0 for x in (1..4) +def validateInput(field x) -> (bool): + return (x-1)*(x-2)*(x-3)*(x-4) == 0 + +// variables naming: box'row''column' +def main(field a21, field b11, field b22, field c11, field c22, field d21, private field a11, private field a12, private field a22, private field b12, private field b21, private field c12, private field c21, private field d11, private field d12, private field d22) -> (bool): + + // validate inputs + assert(validateInput(a11)) + assert(validateInput(a12)) + assert(validateInput(a21)) + assert(validateInput(a22)) + + assert(validateInput(b11)) + assert(validateInput(b12)) + assert(validateInput(b21)) + assert(validateInput(b22)) + + assert(validateInput(c11)) + assert(validateInput(c12)) + assert(validateInput(c21)) + assert(validateInput(c22)) + + assert(validateInput(d11)) + assert(validateInput(d12)) + assert(validateInput(d21)) + assert(validateInput(d22)) + + field duplicates = 0 // globally counts duplicate entries in boxes, rows and columns + + // check box correctness + + // no duplicates + duplicates = duplicates + countDuplicates(a11,a12,a21,a22) + duplicates = duplicates + countDuplicates(b11,b12,b21,b22) + duplicates = duplicates + countDuplicates(c11,c12,c21,c22) + duplicates = duplicates + countDuplicates(d11,d12,d21,d22) + + // check row correctness + + duplicates = duplicates + countDuplicates(a11,a12,b11,b12) + duplicates = duplicates + countDuplicates(a21,a22,b21,b22) + duplicates = duplicates + countDuplicates(c11,c12,d11,d12) + duplicates = duplicates + countDuplicates(c21,c22,d21,d22) + + // check column correctness + + duplicates = duplicates + countDuplicates(a11,a21,c11,c21) + duplicates = duplicates + countDuplicates(a12,a22,c12,c22) + duplicates = duplicates + countDuplicates(b11,b21,d11,d21) + duplicates = duplicates + countDuplicates(b12,b22,d12,d22) + + // the solution is correct if and only if there are no duplicates + return duplicates == 0 diff --git a/zokrates_cli/examples/sudokuchecker.zok b/zokrates_cli/examples/sudokuchecker.zok deleted file mode 100644 index 8e5ae015..00000000 --- a/zokrates_cli/examples/sudokuchecker.zok +++ /dev/null @@ -1,75 +0,0 @@ -// Sudoku of format - -// | a11 | a12 || b11 | b12 | -// -------------------------- -// | a21 | a22 || b21 | b22 | -// ========================== -// | c11 | c12 || d11 | d12 | -// -------------------------- -// | c21 | c22 || d21 | d22 | - -def checkEquality(field e11,field e12,field e21,field e22) -> (field): -field counter = if e11 == e12 then 1 else 0 fi -counter = counter + if e11 == e21 then 1 else 0 fi -counter = counter + if e11 == e22 then 1 else 0 fi -counter = counter + if e12 == e21 then 1 else 0 fi -counter = counter + if e12 == e21 then 1 else 0 fi -counter = counter + if e21 == e22 then 1 else 0 fi -return counter - -// returns 0 for x in (1..4) -def validateInput(field x) -> (field): -return (x-1)*(x-2)*(x-3)*(x-4) - -// variables naming: box'row''column' -def main(field a21, field b11, field b22, field c11, field c22, field d21, private field a11, private field a12, private field a22, private field b12, private field b21, private field c12, private field c21, private field d11, private field d12, private field d22) -> (field): - -// validate inputs -0 == validateInput(a11) -0 == validateInput(a12) -0 == validateInput(a21) -0 == validateInput(a22) - -0 == validateInput(b11) -0 == validateInput(b12) -0 == validateInput(b21) -0 == validateInput(b22) - -0 == validateInput(c11) -0 == validateInput(c12) -0 == validateInput(c21) -0 == validateInput(c22) - -0 == validateInput(d11) -0 == validateInput(d12) -0 == validateInput(d21) -0 == validateInput(d22) - -field counter = 0 // globally counts duplicate entries in boxes, rows and columns - -// check box correctness - - // no duplicates - counter = counter + checkEquality(a11,a12,a21,a22) - counter = counter + checkEquality(b11,b12,b21,b22) - counter = counter + checkEquality(c11,c12,c21,c22) - counter = counter + checkEquality(d11,d12,d21,d22) - -// check row correctness - - counter = counter + checkEquality(a11,a12,b11,b12) - counter = counter + checkEquality(a21,a22,b21,b22) - counter = counter + checkEquality(c11,c12,d11,d12) - counter = counter + checkEquality(c21,c22,d21,d22) - -// check column correctness - - counter = counter + checkEquality(a11,a21,c11,c21) - counter = counter + checkEquality(a12,a22,c12,c22) - counter = counter + checkEquality(b11,b21,d11,d21) - counter = counter + checkEquality(b12,b22,d12,d22) - -// assert counter is 0 -counter == 0 - -return 1 diff --git a/zokrates_cli/examples/test1.zok b/zokrates_cli/examples/test1.zok index 054fe3bc..3429b140 100644 --- a/zokrates_cli/examples/test1.zok +++ b/zokrates_cli/examples/test1.zok @@ -3,11 +3,11 @@ def main(field x) -> (field): field a = 5 field b = 7 field c = if a == b then 4 else 3 fi - c == 3 + assert(c == 3) field d = if a == 5 then 1 else 2 fi - d == 1 + assert(d == 1) field e = if a < b then 5 else 6 fi - e == 5 + assert(e == 5) field f = if b < a then 7 else 8 fi - f == 8 + assert(f == 8) return x diff --git a/zokrates_cli/examples/test_lt_max_value.zok b/zokrates_cli/examples/test_lt_max_value.zok index 20fdbdef..8860cd40 100644 --- a/zokrates_cli/examples/test_lt_max_value.zok +++ b/zokrates_cli/examples/test_lt_max_value.zok @@ -3,8 +3,8 @@ // we can compare numbers up to 2^(pbits - 2) - 1, ie any number which fits in (pbits - 2) bits // lt should work for the maxvalue = 2^(pbits - 2) - 1 -def main(field a) -> (field): +def main(field a) -> (bool): field pbits = 254 // maxvalue = 2**252 - 1 field maxvalue = 7237005577332262213973186563042994240829374041602535252466099000494570602496 - 1 - return if 0 < maxvalue then 1 else 0 fi \ No newline at end of file + return 0 < maxvalue \ No newline at end of file diff --git a/zokrates_cli/examples/waldo.zok b/zokrates_cli/examples/waldo.zok index 20a94e13..38a304d3 100644 --- a/zokrates_cli/examples/waldo.zok +++ b/zokrates_cli/examples/waldo.zok @@ -2,24 +2,14 @@ // In this example, the crowd is a series of numbers, ideally* all prime but one, and Waldo is a non-prime number // * we don't enforce only one number being non-prime, so there could be multiple Waldos -def isWaldo(field a, field p, field q) -> (field): - // make sure that p and q are both non zero - // we can't check inequalities, so let's create binary - // variables - field p1 = if p == 1 then 0 else 1 fi // "p != 1" - field q1 = if q == 1 then 0 else 1 fi // "q != 1" - q1 * p1 == 1 // "p1 and q1" +def isWaldo(field a, field p, field q) -> (bool): + // make sure that p and q are both not one + assert(p != 1 && q != 1) // we know how to factor a - a == p * q - - return 1 + return a == p * q // define all -def main(field a0, field a1, field a2, field a3, private field index, private field p, private field q) -> (field): +def main(field[3] a, private field index, private field p, private field q) -> (bool): // prover provides the index of Waldo - field waldo = if index == 0 then a0 else 0 fi - waldo = waldo + if index == 1 then a1 else 0 fi - waldo = waldo + if index == 2 then a2 else 0 fi - waldo = waldo + if index == 3 then a3 else 0 fi - return isWaldo(waldo, p, q) \ No newline at end of file + return isWaldo(a[index], p, q) \ No newline at end of file diff --git a/zokrates_cli/tests/code/no_return.zok b/zokrates_cli/tests/code/no_return.zok index 2519aa03..1d939baf 100644 --- a/zokrates_cli/tests/code/no_return.zok +++ b/zokrates_cli/tests/code/no_return.zok @@ -1,3 +1,3 @@ def main(field a, field b) -> (): - a==b + assert(a == b) return \ No newline at end of file diff --git a/zokrates_core/Cargo.toml b/zokrates_core/Cargo.toml index edf555b0..ac6baa13 100644 --- a/zokrates_core/Cargo.toml +++ b/zokrates_core/Cargo.toml @@ -7,7 +7,7 @@ readme = "README.md" build = "build.rs" [features] -default = [] +default = ["bellman_ce/nolog"] libsnark = ["cc", "cmake", "git2"] wasm = ["bellman_ce/wasm"] multicore = ["bellman_ce/multicore"] diff --git a/zokrates_core/build.rs b/zokrates_core/build.rs index 151b2a54..4c8e5379 100644 --- a/zokrates_core/build.rs +++ b/zokrates_core/build.rs @@ -44,6 +44,7 @@ fn main() { .define("USE_PT_COMPRESSION", "OFF") .define("MONTGOMERY_OUTPUT", "ON") .define("BINARY_OUTPUT", "ON") + .define("DMULTICORE", "ON") .build(); // build backends diff --git a/zokrates_core/src/absy/from_ast.rs b/zokrates_core/src/absy/from_ast.rs index ecfae3b4..f44dbe49 100644 --- a/zokrates_core/src/absy/from_ast.rs +++ b/zokrates_core/src/absy/from_ast.rs @@ -262,23 +262,8 @@ impl<'ast, T: Field> From> for absy::StatementNod fn from(statement: pest::AssertionStatement<'ast>) -> absy::StatementNode { use absy::NodeValue; - match statement.expression { - pest::Expression::Binary(e) => match e.op { - pest::BinaryOperator::Eq => absy::Statement::Condition( - absy::ExpressionNode::from(*e.left), - absy::ExpressionNode::from(*e.right), - ), - _ => unimplemented!( - "Assertion statements should be an equality check, found {}", - statement.span.as_str() - ), - }, - _ => unimplemented!( - "Assertion statements should be an equality check, found {}", - statement.span.as_str() - ), - } - .span(statement.span) + absy::Statement::Assertion(absy::ExpressionNode::from(statement.expression)) + .span(statement.span) } } @@ -389,7 +374,14 @@ impl<'ast, T: Field> From> for absy::ExpressionNode box absy::ExpressionNode::from(*expression.left), box absy::ExpressionNode::from(*expression.right), ), - o => unimplemented!("Operator {:?} not implemented", o), + // rewrite (a != b)` as `!(a == b)` + pest::BinaryOperator::NotEq => absy::Expression::Not( + box absy::Expression::Eq( + box absy::ExpressionNode::from(*expression.left), + box absy::ExpressionNode::from(*expression.right), + ) + .span(expression.span.clone()), + ), } .span(expression.span) } diff --git a/zokrates_core/src/absy/mod.rs b/zokrates_core/src/absy/mod.rs index 0101e387..86b80582 100644 --- a/zokrates_core/src/absy/mod.rs +++ b/zokrates_core/src/absy/mod.rs @@ -299,7 +299,7 @@ pub enum Statement<'ast, T> { Return(ExpressionListNode<'ast, T>), Declaration(VariableNode<'ast>), Definition(AssigneeNode<'ast, T>, ExpressionNode<'ast, T>), - Condition(ExpressionNode<'ast, T>, ExpressionNode<'ast, T>), + Assertion(ExpressionNode<'ast, T>), For( VariableNode<'ast>, ExpressionNode<'ast, T>, @@ -317,7 +317,7 @@ impl<'ast, T: fmt::Display> fmt::Display for Statement<'ast, T> { Statement::Return(ref expr) => write!(f, "return {}", expr), Statement::Declaration(ref var) => write!(f, "{}", var), Statement::Definition(ref lhs, ref rhs) => write!(f, "{} = {}", lhs, rhs), - Statement::Condition(ref lhs, ref rhs) => write!(f, "{} == {}", lhs, rhs), + Statement::Assertion(ref e) => write!(f, "assert({})", e), Statement::For(ref var, ref start, ref stop, ref list) => { write!(f, "for {} in {}..{} do\n", var, start, stop)?; for l in list { @@ -346,7 +346,7 @@ impl<'ast, T: fmt::Debug> fmt::Debug for Statement<'ast, T> { Statement::Definition(ref lhs, ref rhs) => { write!(f, "Definition({:?}, {:?})", lhs, rhs) } - Statement::Condition(ref lhs, ref rhs) => write!(f, "Condition({:?}, {:?})", lhs, rhs), + Statement::Assertion(ref e) => write!(f, "Assertion({:?})", e), Statement::For(ref var, ref start, ref stop, ref list) => { write!(f, "for {:?} in {:?}..{:?} do\n", var, start, stop)?; for l in list { diff --git a/zokrates_core/src/compile.rs b/zokrates_core/src/compile.rs index d28ae154..e88dee35 100644 --- a/zokrates_core/src/compile.rs +++ b/zokrates_core/src/compile.rs @@ -140,7 +140,7 @@ impl fmt::Display for CompileErrorInner { } } -#[derive(Debug, Default)] +#[derive(Debug, Default, Serialize, Deserialize)] pub struct CompileConfig { is_release: bool, } diff --git a/zokrates_core/src/flatten/mod.rs b/zokrates_core/src/flatten/mod.rs index 50fdd17c..f3b0f0fc 100644 --- a/zokrates_core/src/flatten/mod.rs +++ b/zokrates_core/src/flatten/mod.rs @@ -575,9 +575,6 @@ impl<'ast, T: Field> Flattener<'ast, T> { ) } BooleanExpression::FieldEq(box lhs, box rhs) => { - // We know from semantic checking that lhs and rhs have the same type - // What the expression will flatten to depends on that type - // Wanted: (Y = (X != 0) ? 1 : 0) // X = a - b // # Y = if X == 0 then 0 else 1 fi @@ -616,6 +613,53 @@ impl<'ast, T: Field> Flattener<'ast, T> { res } + BooleanExpression::UintEq(box lhs, box rhs) => { + // We reduce each side into range and apply the same approach as for field elements + + // Wanted: (Y = (X != 0) ? 1 : 0) + // X = a - b + // # Y = if X == 0 then 0 else 1 fi + // # M = if X == 0 then 1 else 1/X fi + // Y == X * M + // 0 == (1-Y) * X + + let name_y = self.use_sym(); + let name_m = self.use_sym(); + + assert!(lhs.metadata.clone().unwrap().should_reduce.to_bool()); + assert!(rhs.metadata.clone().unwrap().should_reduce.to_bool()); + + let lhs = self + .flatten_uint_expression(symbols, statements_flattened, lhs) + .get_field_unchecked(); + let rhs = self + .flatten_uint_expression(symbols, statements_flattened, rhs) + .get_field_unchecked(); + + let x = FlatExpression::Sub(box lhs, box rhs); + + statements_flattened.push(FlatStatement::Directive(FlatDirective::new( + vec![name_y, name_m], + Solver::ConditionEq, + vec![x.clone()], + ))); + statements_flattened.push(FlatStatement::Condition( + FlatExpression::Identifier(name_y), + FlatExpression::Mult(box x.clone(), box FlatExpression::Identifier(name_m)), + )); + + let res = FlatExpression::Sub( + box FlatExpression::Number(T::one()), + box FlatExpression::Identifier(name_y), + ); + + statements_flattened.push(FlatStatement::Condition( + FlatExpression::Number(T::zero()), + FlatExpression::Mult(box res.clone(), box x), + )); + + res + } BooleanExpression::Le(box lhs, box rhs) => { let lt = self.flatten_boolean_expression( symbols, @@ -1851,24 +1895,22 @@ impl<'ast, T: Field> Flattener<'ast, T> { None => {} } } - ZirStatement::Condition(lhs, rhs) => { - // flatten expr1 and expr2 to n flattened expressions with n the number of primitive types for expr1 - // add n conditions to check equality of the n expressions + ZirStatement::Assertion(e) => { + // naive approach: flatten the boolean to a single field element and constrain it to 1 - let lhs = self - .flatten_expression(symbols, statements_flattened, lhs) - .get_field_unchecked(); - let rhs = self - .flatten_expression(symbols, statements_flattened, rhs) - .get_field_unchecked(); + let e = self.flatten_boolean_expression(symbols, statements_flattened, e); - if lhs.is_linear() { - statements_flattened.push(FlatStatement::Condition(lhs, rhs)); - } else if rhs.is_linear() { - // swap so that left side is linear - statements_flattened.push(FlatStatement::Condition(rhs, lhs)); + if e.is_linear() { + statements_flattened.push(FlatStatement::Condition( + e, + FlatExpression::Number(T::from(1)), + )); } else { - unreachable!() + // swap so that left side is linear + statements_flattened.push(FlatStatement::Condition( + FlatExpression::Number(T::from(1)), + e, + )); } } ZirStatement::MultipleDefinition(vars, rhs) => { diff --git a/zokrates_core/src/semantics.rs b/zokrates_core/src/semantics.rs index 3a4c314e..949e72b7 100644 --- a/zokrates_core/src/semantics.rs +++ b/zokrates_core/src/semantics.rs @@ -875,27 +875,21 @@ impl<'ast> Checker<'ast> { } .map_err(|e| vec![e]) } - Statement::Condition(lhs, rhs) => { - let checked_lhs = self - .check_expression(lhs, module_id, &types) - .map_err(|e| vec![e])?; - let checked_rhs = self - .check_expression(rhs, module_id, &types) + Statement::Assertion(e) => { + let e = self + .check_expression(e, module_id, &types) .map_err(|e| vec![e])?; - if checked_lhs.get_type() == checked_rhs.get_type() { - Ok(TypedStatement::Condition(checked_lhs, checked_rhs)) - } else { - Err(ErrorInner { + match e { + TypedExpression::Boolean(e) => Ok(TypedStatement::Assertion(e)), + e => Err(ErrorInner { pos: Some(pos), message: format!( - "Cannot compare {} of type {:?} to {} of type {:?}", - checked_lhs, - checked_lhs.get_type(), - checked_rhs, - checked_rhs.get_type(), + "Expected {} to be of type bool, found {}", + e, + e.get_type(), ), - }) + }), } .map_err(|e| vec![e]) } @@ -1543,6 +1537,54 @@ impl<'ast> Checker<'ast> { (TypedExpression::Boolean(e1), TypedExpression::Boolean(e2)) => { Ok(BooleanExpression::BoolEq(box e1, box e2).into()) } + (TypedExpression::Array(e1), TypedExpression::Array(e2)) => { + if e1.get_type() == e2.get_type() { + Ok(BooleanExpression::ArrayEq(box e1, box e2).into()) + } else { + Err(ErrorInner { + pos: Some(pos), + message: format!( + "Cannot compare {} of type {} to {} of type {}", + e1, + e1.get_type(), + e2, + e2.get_type() + ), + }) + } + } + (TypedExpression::Struct(e1), TypedExpression::Struct(e2)) => { + if e1.get_type() == e2.get_type() { + Ok(BooleanExpression::StructEq(box e1, box e2).into()) + } else { + Err(ErrorInner { + pos: Some(pos), + message: format!( + "Cannot compare {} of type {} to {} of type {}", + e1, + e1.get_type(), + e2, + e2.get_type() + ), + }) + } + } + (TypedExpression::Uint(e1), TypedExpression::Uint(e2)) => { + if e1.get_type() == e2.get_type() { + Ok(BooleanExpression::UintEq(box e1, box e2).into()) + } else { + Err(ErrorInner { + pos: Some(pos), + message: format!( + "Cannot compare {} of type {} to {} of type {}", + e1, + e1.get_type(), + e2, + e2.get_type() + ), + }) + } + } (e1, e2) => Err(ErrorInner { pos: Some(pos), message: format!( @@ -3136,9 +3178,12 @@ mod tests { // def bar(): // 2 == foo() // should fail - let bar_statements: Vec> = vec![Statement::Condition( - Expression::FieldConstant(Bn128Field::from(2)).mock(), - Expression::FunctionCall("foo", vec![]).mock(), + let bar_statements: Vec> = vec![Statement::Assertion( + Expression::Eq( + box Expression::FieldConstant(Bn128Field::from(2)).mock(), + box Expression::FunctionCall("foo", vec![]).mock(), + ) + .mock(), ) .mock()]; @@ -3535,9 +3580,12 @@ mod tests { // def bar(): // 1 == foo() // should fail - let bar_statements: Vec> = vec![Statement::Condition( - Expression::FieldConstant(Bn128Field::from(1)).mock(), - Expression::FunctionCall("foo", vec![]).mock(), + let bar_statements: Vec> = vec![Statement::Assertion( + Expression::Eq( + box Expression::FieldConstant(Bn128Field::from(1)).mock(), + box Expression::FunctionCall("foo", vec![]).mock(), + ) + .mock(), ) .mock()]; diff --git a/zokrates_core/src/static_analysis/flatten_complex_types.rs b/zokrates_core/src/static_analysis/flatten_complex_types.rs index 035cea54..eb2c7b81 100644 --- a/zokrates_core/src/static_analysis/flatten_complex_types.rs +++ b/zokrates_core/src/static_analysis/flatten_complex_types.rs @@ -248,14 +248,9 @@ pub fn fold_statement<'ast, T: Field>( .map(|v| zir::ZirStatement::Declaration(v)) .collect() } - typed_absy::TypedStatement::Condition(left, right) => { - let left = f.fold_expression(left); - let right = f.fold_expression(right); - assert_eq!(left.len(), right.len()); - left.into_iter() - .zip(right.into_iter()) - .map(|(left, right)| zir::ZirStatement::Condition(left, right)) - .collect() + typed_absy::TypedStatement::Assertion(e) => { + let e = f.fold_boolean_expression(e); + vec![zir::ZirStatement::Assertion(e)] } typed_absy::TypedStatement::For(..) => unreachable!(), typed_absy::TypedStatement::MultipleDefinition(variables, elist) => { @@ -555,6 +550,68 @@ pub fn fold_boolean_expression<'ast, T: Field>( let e2 = f.fold_boolean_expression(e2); zir::BooleanExpression::BoolEq(box e1, box e2) } + typed_absy::BooleanExpression::ArrayEq(box e1, box e2) => { + let e1 = f.fold_array_expression(e1); + let e2 = f.fold_array_expression(e2); + + assert_eq!(e1.len(), e2.len()); + + e1.into_iter().zip(e2.into_iter()).fold( + zir::BooleanExpression::Value(true), + |acc, (e1, e2)| { + zir::BooleanExpression::And( + box acc, + box match (e1, e2) { + ( + zir::ZirExpression::FieldElement(e1), + zir::ZirExpression::FieldElement(e2), + ) => zir::BooleanExpression::FieldEq(box e1, box e2), + (zir::ZirExpression::Boolean(e1), zir::ZirExpression::Boolean(e2)) => { + zir::BooleanExpression::BoolEq(box e1, box e2) + } + (zir::ZirExpression::Uint(e1), zir::ZirExpression::Uint(e2)) => { + zir::BooleanExpression::UintEq(box e1, box e2) + } + _ => unreachable!(), + }, + ) + }, + ) + } + typed_absy::BooleanExpression::StructEq(box e1, box e2) => { + let e1 = f.fold_struct_expression(e1); + let e2 = f.fold_struct_expression(e2); + + assert_eq!(e1.len(), e2.len()); + + e1.into_iter().zip(e2.into_iter()).fold( + zir::BooleanExpression::Value(true), + |acc, (e1, e2)| { + zir::BooleanExpression::And( + box acc, + box match (e1, e2) { + ( + zir::ZirExpression::FieldElement(e1), + zir::ZirExpression::FieldElement(e2), + ) => zir::BooleanExpression::FieldEq(box e1, box e2), + (zir::ZirExpression::Boolean(e1), zir::ZirExpression::Boolean(e2)) => { + zir::BooleanExpression::BoolEq(box e1, box e2) + } + (zir::ZirExpression::Uint(e1), zir::ZirExpression::Uint(e2)) => { + zir::BooleanExpression::UintEq(box e1, box e2) + } + _ => unreachable!(), + }, + ) + }, + ) + } + typed_absy::BooleanExpression::UintEq(box e1, box e2) => { + let e1 = f.fold_uint_expression(e1); + let e2 = f.fold_uint_expression(e2); + + zir::BooleanExpression::UintEq(box e1, box e2) + } typed_absy::BooleanExpression::Lt(box e1, box e2) => { let e1 = f.fold_field_expression(e1); let e2 = f.fold_field_expression(e2); diff --git a/zokrates_core/src/static_analysis/mod.rs b/zokrates_core/src/static_analysis/mod.rs index bf163a70..41c67a99 100644 --- a/zokrates_core/src/static_analysis/mod.rs +++ b/zokrates_core/src/static_analysis/mod.rs @@ -55,7 +55,7 @@ impl<'ast, T: Field> TypedProgram<'ast, T> { let r = VariableAccessRemover::apply(r); // convert to zir, removing complex types - let zir = Flattener::flatten(r.clone()); + let zir = Flattener::flatten(r); // optimize uint expressions let zir = UintOptimizer::optimize(zir); diff --git a/zokrates_core/src/static_analysis/propagation.rs b/zokrates_core/src/static_analysis/propagation.rs index 5bc0da6a..15477e7b 100644 --- a/zokrates_core/src/static_analysis/propagation.rs +++ b/zokrates_core/src/static_analysis/propagation.rs @@ -112,13 +112,10 @@ impl<'ast, T: Field> Folder<'ast, T> for Propagator<'ast, T> { TypedStatement::Definition(TypedAssignee::Member(..), _) => { unreachable!("struct update should have been replaced with full struct redef") } - // propagate lhs and rhs for conditions - TypedStatement::Condition(e1, e2) => { + // propagate the boolean + TypedStatement::Assertion(e) => { // could stop execution here if condition is known to fail - Some(TypedStatement::Condition( - self.fold_expression(e1), - self.fold_expression(e2), - )) + Some(TypedStatement::Assertion(self.fold_boolean_expression(e))) } // only loops with variable bounds are expected here // we stop propagation here as constants maybe be modified inside the loop body @@ -957,6 +954,11 @@ impl<'ast, T: Field> Folder<'ast, T> for Propagator<'ast, T> { &mut self, e: BooleanExpression<'ast, T>, ) -> BooleanExpression<'ast, T> { + // Note: we only propagate when we see constants, as comparing of arbitrary expressions would lead to + // a lot of false negatives due to expressions not being in a canonical form + // For example, `2 * a` is equivalent to `a + a`, but our notion of equality would not detect that here + // These kind of reduction rules are easier to apply later in the process, when we have canonical representations + // of expressions, ie `a + a` would always be written `2 * a` match e { BooleanExpression::Identifier(id) => match self .constants diff --git a/zokrates_core/src/static_analysis/uint_optimizer.rs b/zokrates_core/src/static_analysis/uint_optimizer.rs index d0830c31..5b856f05 100644 --- a/zokrates_core/src/static_analysis/uint_optimizer.rs +++ b/zokrates_core/src/static_analysis/uint_optimizer.rs @@ -53,6 +53,24 @@ fn force_no_reduce<'ast, T: Field>(e: UExpression<'ast, T>) -> UExpression<'ast, } impl<'ast, T: Field> Folder<'ast, T> for UintOptimizer<'ast, T> { + fn fold_boolean_expression( + &mut self, + e: BooleanExpression<'ast, T>, + ) -> BooleanExpression<'ast, T> { + match e { + BooleanExpression::UintEq(box left, box right) => { + let left = self.fold_uint_expression(left); + let right = self.fold_uint_expression(right); + + let left = force_reduce(left); + let right = force_reduce(right); + + BooleanExpression::UintEq(box left, box right) + } + e => fold_boolean_expression(self, e), + } + } + fn fold_uint_expression(&mut self, e: UExpression<'ast, T>) -> UExpression<'ast, T> { if e.metadata.is_some() { return e; @@ -287,6 +305,7 @@ impl<'ast, T: Field> Folder<'ast, T> for UintOptimizer<'ast, T> { UExpression::right_shift(force_reduce(e), by).with_max(max) } IfElse(box condition, box consequence, box alternative) => { + let condition = self.fold_boolean_expression(condition); let consequence = self.fold_uint_expression(consequence); let alternative = self.fold_uint_expression(alternative); @@ -397,17 +416,17 @@ impl<'ast, T: Field> Folder<'ast, T> for UintOptimizer<'ast, T> { )], }, }, - // we need to put back in range to assert - ZirStatement::Condition(lhs, rhs) => { - match (self.fold_expression(lhs), self.fold_expression(rhs)) { - (ZirExpression::Uint(lhs), ZirExpression::Uint(rhs)) => { - vec![ZirStatement::Condition( - force_reduce(lhs).into(), - force_reduce(rhs).into(), - )] - } - (lhs, rhs) => vec![ZirStatement::Condition(lhs, rhs)], - } + ZirStatement::Assertion(BooleanExpression::UintEq(box left, box right)) => { + let left = self.fold_uint_expression(left); + let right = self.fold_uint_expression(right); + + // we can only compare two unsigned integers if they are in range + let left = force_reduce(left); + let right = force_reduce(right); + + vec![ZirStatement::Assertion(BooleanExpression::UintEq( + box left, box right, + ))] } s => fold_statement(self, s), } diff --git a/zokrates_core/src/static_analysis/unroll.rs b/zokrates_core/src/static_analysis/unroll.rs index f3dc70c9..00400446 100644 --- a/zokrates_core/src/static_analysis/unroll.rs +++ b/zokrates_core/src/static_analysis/unroll.rs @@ -84,13 +84,12 @@ impl<'ast> Unroller<'ast> { match head { Access::Select(head) => { - statements.insert(TypedStatement::Condition( + statements.insert(TypedStatement::Assertion( BooleanExpression::Lt( box head.clone(), box FieldElementExpression::Number(T::from(size)), ) .into(), - BooleanExpression::Value(true).into(), )); ArrayExpressionInner::Value( @@ -1089,13 +1088,12 @@ mod tests { assert_eq!( u.fold_statement(s), vec![ - TypedStatement::Condition( + TypedStatement::Assertion( BooleanExpression::Lt( box FieldElementExpression::Number(Bn128Field::from(1)), box FieldElementExpression::Number(Bn128Field::from(2)) ) .into(), - BooleanExpression::Value(true).into() ), TypedStatement::Definition( TypedAssignee::Identifier(Variable::field_array( @@ -1227,13 +1225,12 @@ mod tests { assert_eq!( u.fold_statement(s), vec![ - TypedStatement::Condition( + TypedStatement::Assertion( BooleanExpression::Lt( box FieldElementExpression::Number(Bn128Field::from(1)), box FieldElementExpression::Number(Bn128Field::from(2)) ) .into(), - BooleanExpression::Value(true).into() ), TypedStatement::Definition( TypedAssignee::Identifier(Variable::with_id_and_type( diff --git a/zokrates_core/src/static_analysis/variable_access_remover.rs b/zokrates_core/src/static_analysis/variable_access_remover.rs index 79f2ca5b..991740b1 100644 --- a/zokrates_core/src/static_analysis/variable_access_remover.rs +++ b/zokrates_core/src/static_analysis/variable_access_remover.rs @@ -39,7 +39,7 @@ impl<'ast, T: Field> VariableAccessRemover<'ast, T> { _ => unreachable!(), }; - self.statements.push(TypedStatement::Condition( + self.statements.push(TypedStatement::Assertion( (0..size) .map(|index| { BooleanExpression::FieldEq( @@ -53,7 +53,6 @@ impl<'ast, T: Field> VariableAccessRemover<'ast, T> { }) .unwrap() .into(), - BooleanExpression::Value(true).into(), )); (0..size) @@ -170,7 +169,7 @@ mod tests { assert_eq!( VariableAccessRemover::new().fold_statement(access), vec![ - TypedStatement::Condition( + TypedStatement::Assertion( BooleanExpression::Or( box BooleanExpression::FieldEq( box FieldElementExpression::Identifier("i".into()), @@ -182,7 +181,6 @@ mod tests { ) ) .into(), - BooleanExpression::Value(true).into() ), TypedStatement::Definition( TypedAssignee::Identifier(Variable::field_element("b")), diff --git a/zokrates_core/src/typed_absy/folder.rs b/zokrates_core/src/typed_absy/folder.rs index f83244fa..385c4dce 100644 --- a/zokrates_core/src/typed_absy/folder.rs +++ b/zokrates_core/src/typed_absy/folder.rs @@ -165,9 +165,7 @@ pub fn fold_statement<'ast, T: Field, F: Folder<'ast, T>>( TypedStatement::Definition(f.fold_assignee(a), f.fold_expression(e)) } TypedStatement::Declaration(v) => TypedStatement::Declaration(f.fold_variable(v)), - TypedStatement::Condition(left, right) => { - TypedStatement::Condition(f.fold_expression(left), f.fold_expression(right)) - } + TypedStatement::Assertion(e) => TypedStatement::Assertion(f.fold_boolean_expression(e)), TypedStatement::For(v, from, to, statements) => TypedStatement::For( f.fold_variable(v), from, @@ -325,6 +323,21 @@ pub fn fold_boolean_expression<'ast, T: Field, F: Folder<'ast, T>>( let e2 = f.fold_boolean_expression(e2); BooleanExpression::BoolEq(box e1, box e2) } + BooleanExpression::ArrayEq(box e1, box e2) => { + let e1 = f.fold_array_expression(e1); + let e2 = f.fold_array_expression(e2); + BooleanExpression::ArrayEq(box e1, box e2) + } + BooleanExpression::StructEq(box e1, box e2) => { + let e1 = f.fold_struct_expression(e1); + let e2 = f.fold_struct_expression(e2); + BooleanExpression::StructEq(box e1, box e2) + } + BooleanExpression::UintEq(box e1, box e2) => { + let e1 = f.fold_uint_expression(e1); + let e2 = f.fold_uint_expression(e2); + BooleanExpression::UintEq(box e1, box e2) + } BooleanExpression::Lt(box e1, box e2) => { let e1 = f.fold_field_expression(e1); let e2 = f.fold_field_expression(e2); diff --git a/zokrates_core/src/typed_absy/mod.rs b/zokrates_core/src/typed_absy/mod.rs index 08d49340..62eb95e6 100644 --- a/zokrates_core/src/typed_absy/mod.rs +++ b/zokrates_core/src/typed_absy/mod.rs @@ -300,7 +300,7 @@ pub enum TypedStatement<'ast, T> { Return(Vec>), Definition(TypedAssignee<'ast, T>, TypedExpression<'ast, T>), Declaration(Variable<'ast>), - Condition(TypedExpression<'ast, T>, TypedExpression<'ast, T>), + Assertion(BooleanExpression<'ast, T>), For( Variable<'ast>, FieldElementExpression<'ast, T>, @@ -327,9 +327,7 @@ impl<'ast, T: fmt::Debug> fmt::Debug for TypedStatement<'ast, T> { TypedStatement::Definition(ref lhs, ref rhs) => { write!(f, "Definition({:?}, {:?})", lhs, rhs) } - TypedStatement::Condition(ref lhs, ref rhs) => { - write!(f, "Condition({:?}, {:?})", lhs, rhs) - } + TypedStatement::Assertion(ref e) => write!(f, "Assertion({:?})", e), TypedStatement::For(ref var, ref start, ref stop, ref list) => { write!(f, "for {:?} in {:?}..{:?} do\n", var, start, stop)?; for l in list { @@ -376,7 +374,7 @@ impl<'ast, T: fmt::Display> fmt::Display for TypedStatement<'ast, T> { } TypedStatement::Declaration(ref var) => write!(f, "{}", var), TypedStatement::Definition(ref lhs, ref rhs) => write!(f, "{} = {}", lhs, rhs), - TypedStatement::Condition(ref lhs, ref rhs) => write!(f, "{} == {}", lhs, rhs), + TypedStatement::Assertion(ref e) => write!(f, "assert({})", e), TypedStatement::For(ref var, ref start, ref stop, ref list) => { write!(f, "for {} in {}..{} do\n", var, start, stop)?; for l in list { @@ -639,6 +637,12 @@ pub enum BooleanExpression<'ast, T> { Box>, Box>, ), + ArrayEq(Box>, Box>), + StructEq( + Box>, + Box>, + ), + UintEq(Box>, Box>), Ge( Box>, Box>, @@ -906,6 +910,9 @@ impl<'ast, T: fmt::Display> fmt::Display for BooleanExpression<'ast, T> { BooleanExpression::Le(ref lhs, ref rhs) => write!(f, "{} <= {}", lhs, rhs), BooleanExpression::FieldEq(ref lhs, ref rhs) => write!(f, "{} == {}", lhs, rhs), BooleanExpression::BoolEq(ref lhs, ref rhs) => write!(f, "{} == {}", lhs, rhs), + BooleanExpression::ArrayEq(ref lhs, ref rhs) => write!(f, "{} == {}", lhs, rhs), + BooleanExpression::StructEq(ref lhs, ref rhs) => write!(f, "{} == {}", lhs, rhs), + BooleanExpression::UintEq(ref lhs, ref rhs) => write!(f, "{} == {}", lhs, rhs), BooleanExpression::Ge(ref lhs, ref rhs) => write!(f, "{} >= {}", lhs, rhs), BooleanExpression::Gt(ref lhs, ref rhs) => write!(f, "{} > {}", lhs, rhs), BooleanExpression::Or(ref lhs, ref rhs) => write!(f, "{} || {}", lhs, rhs), @@ -985,6 +992,15 @@ impl<'ast, T: fmt::Debug> fmt::Debug for BooleanExpression<'ast, T> { BooleanExpression::BoolEq(ref lhs, ref rhs) => { write!(f, "BoolEq({:?}, {:?})", lhs, rhs) } + BooleanExpression::ArrayEq(ref lhs, ref rhs) => { + write!(f, "ArrayEq({:?}, {:?})", lhs, rhs) + } + BooleanExpression::StructEq(ref lhs, ref rhs) => { + write!(f, "StructEq({:?}, {:?})", lhs, rhs) + } + BooleanExpression::UintEq(ref lhs, ref rhs) => { + write!(f, "UintEq({:?}, {:?})", lhs, rhs) + } BooleanExpression::Ge(ref lhs, ref rhs) => write!(f, "Ge({:?}, {:?})", lhs, rhs), BooleanExpression::Gt(ref lhs, ref rhs) => write!(f, "Gt({:?}, {:?})", lhs, rhs), BooleanExpression::And(ref lhs, ref rhs) => write!(f, "And({:?}, {:?})", lhs, rhs), diff --git a/zokrates_core/src/zir/folder.rs b/zokrates_core/src/zir/folder.rs index af29c188..71039a30 100644 --- a/zokrates_core/src/zir/folder.rs +++ b/zokrates_core/src/zir/folder.rs @@ -130,9 +130,7 @@ pub fn fold_statement<'ast, T: Field, F: Folder<'ast, T>>( ZirStatement::Definition(f.fold_assignee(a), f.fold_expression(e)) } ZirStatement::Declaration(v) => ZirStatement::Declaration(f.fold_variable(v)), - ZirStatement::Condition(left, right) => { - ZirStatement::Condition(f.fold_expression(left), f.fold_expression(right)) - } + ZirStatement::Assertion(e) => ZirStatement::Assertion(f.fold_boolean_expression(e)), ZirStatement::MultipleDefinition(variables, elist) => ZirStatement::MultipleDefinition( variables.into_iter().map(|v| f.fold_variable(v)).collect(), f.fold_expression_list(elist), @@ -201,6 +199,11 @@ pub fn fold_boolean_expression<'ast, T: Field, F: Folder<'ast, T>>( let e2 = f.fold_boolean_expression(e2); BooleanExpression::BoolEq(box e1, box e2) } + BooleanExpression::UintEq(box e1, box e2) => { + let e1 = f.fold_uint_expression(e1); + let e2 = f.fold_uint_expression(e2); + BooleanExpression::UintEq(box e1, box e2) + } BooleanExpression::Lt(box e1, box e2) => { let e1 = f.fold_field_expression(e1); let e2 = f.fold_field_expression(e2); diff --git a/zokrates_core/src/zir/mod.rs b/zokrates_core/src/zir/mod.rs index bd2bbbf2..e95f7687 100644 --- a/zokrates_core/src/zir/mod.rs +++ b/zokrates_core/src/zir/mod.rs @@ -191,7 +191,7 @@ pub enum ZirStatement<'ast, T> { Return(Vec>), Definition(ZirAssignee<'ast>, ZirExpression<'ast, T>), Declaration(Variable<'ast>), - Condition(ZirExpression<'ast, T>, ZirExpression<'ast, T>), + Assertion(BooleanExpression<'ast, T>), MultipleDefinition(Vec>, ZirExpressionList<'ast, T>), } @@ -212,9 +212,7 @@ impl<'ast, T: fmt::Debug> fmt::Debug for ZirStatement<'ast, T> { ZirStatement::Definition(ref lhs, ref rhs) => { write!(f, "Definition({:?}, {:?})", lhs, rhs) } - ZirStatement::Condition(ref lhs, ref rhs) => { - write!(f, "Condition({:?}, {:?})", lhs, rhs) - } + ZirStatement::Assertion(ref e) => write!(f, "Assertion({:?})", e), ZirStatement::MultipleDefinition(ref lhs, ref rhs) => { write!(f, "MultipleDefinition({:?}, {:?})", lhs, rhs) } @@ -235,9 +233,9 @@ impl<'ast, T: fmt::Display> fmt::Display for ZirStatement<'ast, T> { } write!(f, "") } - ZirStatement::Declaration(ref var) => write!(f, "{}", var), + ZirStatement::Declaration(ref var) => write!(f, "assert({})", var), ZirStatement::Definition(ref lhs, ref rhs) => write!(f, "{} = {}", lhs, rhs), - ZirStatement::Condition(ref lhs, ref rhs) => write!(f, "{} == {}", lhs, rhs), + ZirStatement::Assertion(ref e) => write!(f, "{}", e), ZirStatement::MultipleDefinition(ref ids, ref rhs) => { for (i, id) in ids.iter().enumerate() { write!(f, "{}", id)?; @@ -399,6 +397,7 @@ pub enum BooleanExpression<'ast, T> { Box>, Box>, ), + UintEq(Box>, Box>), Ge( Box>, Box>, @@ -511,6 +510,7 @@ impl<'ast, T: fmt::Display> fmt::Display for BooleanExpression<'ast, T> { BooleanExpression::Le(ref lhs, ref rhs) => write!(f, "{} <= {}", lhs, rhs), BooleanExpression::FieldEq(ref lhs, ref rhs) => write!(f, "{} == {}", lhs, rhs), BooleanExpression::BoolEq(ref lhs, ref rhs) => write!(f, "{} == {}", lhs, rhs), + BooleanExpression::UintEq(ref lhs, ref rhs) => write!(f, "{} == {}", lhs, rhs), BooleanExpression::Ge(ref lhs, ref rhs) => write!(f, "{} >= {}", lhs, rhs), BooleanExpression::Gt(ref lhs, ref rhs) => write!(f, "{} > {}", lhs, rhs), BooleanExpression::Or(ref lhs, ref rhs) => write!(f, "{} || {}", lhs, rhs), diff --git a/zokrates_core/tests/out_of_range.rs b/zokrates_core/tests/out_of_range.rs index 571eb571..0f8ab9d8 100644 --- a/zokrates_core/tests/out_of_range.rs +++ b/zokrates_core/tests/out_of_range.rs @@ -15,7 +15,7 @@ fn out_of_range() { let source = r#" def main(private field a) -> (field): field x = if a < 5555 then 3333 else 4444 fi - x == 3333 + assert(x == 3333) return 1 "# .to_string(); diff --git a/zokrates_core_test/tests/tests/assert_one.zok b/zokrates_core_test/tests/tests/assert_one.zok index 03dafa87..1b025194 100644 --- a/zokrates_core_test/tests/tests/assert_one.zok +++ b/zokrates_core_test/tests/tests/assert_one.zok @@ -1,3 +1,3 @@ -def main(field a) -> (field): - a == 1 - return 1 \ No newline at end of file +def main(field a) -> (): + assert(a == 1) + return \ No newline at end of file diff --git a/zokrates_core_test/tests/tests/memoize/memoize.zok b/zokrates_core_test/tests/tests/memoize/memoize.zok index e092c80b..fa3d38b3 100644 --- a/zokrates_core_test/tests/tests/memoize/memoize.zok +++ b/zokrates_core_test/tests/tests/memoize/memoize.zok @@ -6,9 +6,9 @@ def local(field a) -> (field): // this costs 3 constraints per call def main(field a) -> (): // calling a local function many times with the same arg should cost only once - local(a) + local(a) + local(a) + local(a) + local(a) == 5 * (a ** 8) + assert(local(a) + local(a) + local(a) + local(a) + local(a) == 5 * (a ** 8)) // calling an imported function many times with the same arg should cost only once - dep(a) + dep(a) + dep(a) + dep(a) + dep(a) == 5 * (a ** 4) + assert(dep(a) + dep(a) + dep(a) + dep(a) + dep(a) == 5 * (a ** 4)) return diff --git a/zokrates_core_test/tests/tests/precedence.json b/zokrates_core_test/tests/tests/precedence.json index 38faa6e1..5cf9609d 100644 --- a/zokrates_core_test/tests/tests/precedence.json +++ b/zokrates_core_test/tests/tests/precedence.json @@ -4,15 +4,11 @@ "tests": [ { "input": { - "values": [ - "12" - ] + "values": [] }, "output": { "Ok": { - "values": [ - "12" - ] + "values": [] } } } diff --git a/zokrates_core_test/tests/tests/precedence.zok b/zokrates_core_test/tests/tests/precedence.zok index 86404b44..e6120517 100644 --- a/zokrates_core_test/tests/tests/precedence.zok +++ b/zokrates_core_test/tests/tests/precedence.zok @@ -1,8 +1,8 @@ -def main(field g) -> (field): - 9 == 1 + 2 * 2 ** 2 // Checks precedence of arithmetic operators (expecting transitive behaviour) - 9 == 2 ** 2 * 2 + 1 - 7 == 2 ** 2 * 2 - 1 - 3 == 2 ** 2 / 2 + 1 +def main() -> (): + assert(9 == 1 + 2 * 2 ** 2) // Checks precedence of arithmetic operators (expecting transitive behaviour) + assert(9 == 2 ** 2 * 2 + 1) + assert(7 == 2 ** 2 * 2 - 1) + assert(3 == 2 ** 2 / 2 + 1) field a = if 3 == 2 ** 2 / 2 + 1 && true then 1 else 0 fi // combines arithmetic with boolean operators field b = if 3 == 3 && 4 < 5 then 1 else 0 fi // checks precedence of boolean operators @@ -11,6 +11,8 @@ def main(field g) -> (field): field e = if 2 >= 1 && 4 > 5 || 1 == 1 then 1 else 0 fi field f = if 1 < 2 && false || 4 < 5 && 2 >= 1 then 1 else 0 fi + assert(0x00 ^ 0x00 == 0x00) + //check if all statements have evalutated to true - a * b * c * d * e * f == 1 - return g + assert(a * b * c * d * e * f == 1) + return diff --git a/zokrates_core_test/tests/tests/uint/eq.json b/zokrates_core_test/tests/tests/uint/eq.json new file mode 100644 index 00000000..9c1e9c7e --- /dev/null +++ b/zokrates_core_test/tests/tests/uint/eq.json @@ -0,0 +1,4 @@ +{ + "entry_point": "./tests/tests/uint/eq.zok", + "tests": [] +} \ No newline at end of file diff --git a/zokrates_core_test/tests/tests/uint/eq.zok b/zokrates_core_test/tests/tests/uint/eq.zok new file mode 100644 index 00000000..07eadf24 --- /dev/null +++ b/zokrates_core_test/tests/tests/uint/eq.zok @@ -0,0 +1,3 @@ +def main(private u32 a, u32 b) -> (field): + field result = if a * a == b then 1 else 0 fi + return result \ No newline at end of file diff --git a/zokrates_core_test/tests/tests/uint/operations.zok b/zokrates_core_test/tests/tests/uint/operations.zok index 18181b71..4ef034b9 100644 --- a/zokrates_core_test/tests/tests/uint/operations.zok +++ b/zokrates_core_test/tests/tests/uint/operations.zok @@ -60,47 +60,47 @@ def main(u32 e, u32 f, u32[4] terms) -> (): // rotate u32 rotated = right_rotate_4(e) - rotated == 0x81234567 + assert(rotated == 0x81234567) // and - (e & f) == 0x00204460 + assert((e & f) == 0x00204460) // xor - (e ^ f) == 0x1317131f + assert((e ^ f) == 0x1317131f) // shift - e >> 12 == 0x00012345 - e << 12 == 0x45678000 + assert(e >> 12 == 0x00012345) + assert(e << 12 == 0x45678000) // not - !e == 0xedcba987 + assert(!e == 0xedcba987) // add - terms[0] + terms[1] + terms[2] + terms[3] == 0xddddddda + assert(terms[0] + terms[1] + terms[2] + terms[3] == 0xddddddda) // to_bits bool[32] bits1 = to_bits(e) bool[32] expected1 = [false, false, false, true, false, false, true, false, false, false, true, true, false, true, false, false, false, true, false, true, false, true, true, false, false, true, true, true, true, false, false, false] - bits1 == expected1 - e == from_bits(expected1) + assert(bits1 == expected1) + assert(e == from_bits(expected1)) bool[32] bits2 = to_bits(f) bool[32] expected2 = [false, false, false, false, false, false, false, true, false, false, true, false, false, false, true, true, false, true, false, false, false, true, false, true, false, true, true, false, false, true, true, true] - bits2 == expected2 - f == from_bits(expected2) + assert(bits2 == expected2) + assert(f == from_bits(expected2)) // S0 u32 e2 = right_rotate_2(e) u32 e13 = right_rotate_13(e) u32 e22 = right_rotate_22(e) u32 S0 = e2 ^ e13 ^ e22 - S0 == 0x66146474 + assert(S0 == 0x66146474) // S1 u32 e6 = right_rotate_6(e) u32 e11 = right_rotate_11(e) u32 e25 = right_rotate_25(e) u32 S1 = e6 ^ e11 ^ e25 - S1 == 0x3561abda + assert(S1 == 0x3561abda) return \ No newline at end of file diff --git a/zokrates_core_test/tests/tests/uint/propagation/rotate.zok b/zokrates_core_test/tests/tests/uint/propagation/rotate.zok index a3c4f8e6..a501c0db 100644 --- a/zokrates_core_test/tests/tests/uint/propagation/rotate.zok +++ b/zokrates_core_test/tests/tests/uint/propagation/rotate.zok @@ -54,6 +54,7 @@ def right_rotate_22(u32 e) -> (u32): def right_rotate_25(u32 e) -> (u32): bool[32] b = to_bits(e) u32 res = from_bits([...b[7..], ...b[..7]]) + return res def main() -> (): @@ -62,47 +63,47 @@ def main() -> (): // rotate u32 rotated = right_rotate_4(e) - rotated == 0x81234567 + assert(rotated == 0x81234567) // and - (e & f) == 0x00204460 + assert((e & f) == 0x00204460) // xor - (e ^ f) == 0x1317131f + assert((e ^ f) == 0x1317131f) // shift - e >> 12 == 0x00012345 - e << 12 == 0x45678000 + assert(e >> 12 == 0x00012345) + assert(e << 12 == 0x45678000) // not - !e == 0xedcba987 + assert(!e == 0xedcba987) // add - 0xfefefefe + 0xefefefef + 0xffffffff + 0xeeeeeeee == 0xddddddda + assert(0xfefefefe + 0xefefefef + 0xffffffff + 0xeeeeeeee == 0xddddddda) // to_bits bool[32] bits1 = to_bits(e) bool[32] expected1 = [false, false, false, true, false, false, true, false, false, false, true, true, false, true, false, false, false, true, false, true, false, true, true, false, false, true, true, true, true, false, false, false] - bits1 == expected1 - e == from_bits(expected1) + assert(bits1 == expected1) + assert(e == from_bits(expected1)) bool[32] bits2 = to_bits(f) bool[32] expected2 = [false, false, false, false, false, false, false, true, false, false, true, false, false, false, true, true, false, true, false, false, false, true, false, true, false, true, true, false, false, true, true, true] - bits2 == expected2 - f == from_bits(expected2) + assert(bits2 == expected2) + assert(f == from_bits(expected2)) // S0 u32 e2 = right_rotate_2(e) u32 e13 = right_rotate_13(e) u32 e22 = right_rotate_22(e) u32 S0 = e2 ^ e13 ^ e22 - S0 == 0x66146474 + assert(S0 == 0x66146474) // S1 u32 e6 = right_rotate_6(e) u32 e11 = right_rotate_11(e) u32 e25 = right_rotate_25(e) u32 S1 = e6 ^ e11 ^ e25 - S1 == 0x3561abda + assert(S1 == 0x3561abda) return \ No newline at end of file diff --git a/zokrates_js/.gitignore b/zokrates_js/.gitignore index 079a78d9..43a1f54c 100644 --- a/zokrates_js/.gitignore +++ b/zokrates_js/.gitignore @@ -1,7 +1,7 @@ node_modules -/dist -/target -/pkg -/wasm-pack.log -/stdlib +dist +target +pkg +wasm-pack.log +stdlib stdlib.json \ No newline at end of file diff --git a/zokrates_js/Cargo.lock b/zokrates_js/Cargo.lock deleted file mode 100644 index f914d3f8..00000000 --- a/zokrates_js/Cargo.lock +++ /dev/null @@ -1,1172 +0,0 @@ -# This file is automatically @generated by Cargo. -# It is not intended for manual editing. -[[package]] -name = "addr2line" -version = "0.12.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a49806b9dadc843c61e7c97e72490ad7f7220ae249012fbda9ad0609457c0543" -dependencies = [ - "gimli", -] - -[[package]] -name = "aho-corasick" -version = "0.6.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "81ce3d38065e618af2d7b77e10c5ad9a069859b4be3c2250f674af3840d9c8a5" -dependencies = [ - "memchr", -] - -[[package]] -name = "arrayvec" -version = "0.4.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cd9fd44efafa8690358b7408d253adf110036b88f55672a933f01d616ad9b1b9" -dependencies = [ - "nodrop", -] - -[[package]] -name = "autocfg" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8aac770f1885fd7e387acedd76065302551364496e46b3dd00860b2f8359b9d" - -[[package]] -name = "backtrace" -version = "0.3.48" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0df2f85c8a2abbe3b7d7e748052fdd9b76a0458fdeb16ad4223f5eca78c7c130" -dependencies = [ - "addr2line", - "cfg-if", - "libc", - "object", - "rustc-demangle", -] - -[[package]] -name = "bellman_ce" -version = "0.3.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7e1a2edf80a8ed042463f8888946f70fcd901f1615711bb253b7dc32b9c9fe73" -dependencies = [ - "bit-vec", - "byteorder", - "cfg-if", - "futures", - "num_cpus", - "pairing_ce", - "rand", - "web-sys", -] - -[[package]] -name = "bincode" -version = "0.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e103c8b299b28a9c6990458b7013dc4a8356a9b854c51b9883241f5866fac36e" -dependencies = [ - "byteorder", - "num-traits 0.1.43", - "serde", -] - -[[package]] -name = "bincode" -version = "1.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5753e2a71534719bf3f4e57006c3a4f0d2c672a4b676eec84161f763eca87dbf" -dependencies = [ - "byteorder", - "serde", -] - -[[package]] -name = "bit-vec" -version = "0.6.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f0dc55f2d8a1a85650ac47858bb001b4c0dd73d79e3c455a842925e68d29cd3" - -[[package]] -name = "blake2-rfc_bellman_edition" -version = "0.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fdc60350286c7c3db13b98e91dbe5c8b6830a6821bc20af5b0c310ce94d74915" -dependencies = [ - "arrayvec", - "byteorder", - "constant_time_eq", -] - -[[package]] -name = "block-buffer" -version = "0.7.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b" -dependencies = [ - "block-padding", - "byte-tools", - "byteorder", - "generic-array", -] - -[[package]] -name = "block-padding" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5" -dependencies = [ - "byte-tools", -] - -[[package]] -name = "bstr" -version = "0.2.13" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "31accafdb70df7871592c058eca3985b71104e15ac32f64706022c58867da931" -dependencies = [ - "lazy_static", - "memchr", - "regex-automata", - "serde", -] - -[[package]] -name = "bumpalo" -version = "3.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2e8c087f005730276d1096a652e92a8bacee2e2472bcc9715a74d2bec38b5820" - -[[package]] -name = "byte-tools" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7" - -[[package]] -name = "byteorder" -version = "1.3.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de" - -[[package]] -name = "cfg-if" -version = "0.1.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822" - -[[package]] -name = "console_error_panic_hook" -version = "0.1.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b8d976903543e0c48546a91908f21588a680a8c8f984df9a5d69feccb2b2a211" -dependencies = [ - "cfg-if", - "wasm-bindgen", -] - -[[package]] -name = "constant_time_eq" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc" - -[[package]] -name = "crunchy" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7" - -[[package]] -name = "csv" -version = "1.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "00affe7f6ab566df61b4be3ce8cf16bc2576bca0963ceb0955e45d514bf9a279" -dependencies = [ - "bstr", - "csv-core", - "itoa", - "ryu", - "serde", -] - -[[package]] -name = "csv-core" -version = "0.1.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90" -dependencies = [ - "memchr", -] - -[[package]] -name = "digest" -version = "0.8.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5" -dependencies = [ - "generic-array", -] - -[[package]] -name = "either" -version = "1.5.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bb1f6b1ce1c140482ea30ddd3335fc0024ac7ee112895426e0a629a6c20adfe3" - -[[package]] -name = "failure" -version = "0.1.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d32e9bd16cc02eae7db7ef620b392808b89f6a5e16bb3497d159c6b92a0f4f86" -dependencies = [ - "backtrace", - "failure_derive", -] - -[[package]] -name = "failure_derive" -version = "0.1.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aa4da3c766cd7a0db8242e326e9e4e081edd567072893ed320008189715366a4" -dependencies = [ - "proc-macro2 1.0.18", - "quote 1.0.7", - "syn 1.0.31", - "synstructure", -] - -[[package]] -name = "fake-simd" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed" - -[[package]] -name = "ff_ce" -version = "0.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "83c0a6a2c53b0bd6d8cae976816dc8a171e0554c03f304e3dac110473e0219fd" -dependencies = [ - "byteorder", - "hex", - "rand", -] - -[[package]] -name = "ff_ce" -version = "0.10.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "40ced6646e4e98a53da162e38ffe9c865edbd7a2f9ff197067b0a8bf1114bf8a" -dependencies = [ - "byteorder", - "ff_derive_ce", - "hex", - "rand", -] - -[[package]] -name = "ff_derive_ce" -version = "0.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "50c052fa6d4c2f12305ec364bfb8ef884836f3f61ea015b202372ff996d1ac4b" -dependencies = [ - "num-bigint 0.2.6", - "num-integer", - "num-traits 0.2.12", - "proc-macro2 1.0.18", - "quote 1.0.7", - "syn 1.0.31", -] - -[[package]] -name = "from-pest" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aba9389cedcba1fb3a2aa2ed00f584f2606bce8e0106614a17327a24513bc60f" -dependencies = [ - "pest", - "void", -] - -[[package]] -name = "fuchsia-cprng" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba" - -[[package]] -name = "futures" -version = "0.3.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e05b85ec287aac0dc34db7d4a569323df697f9c55b99b15d6b4ef8cde49f613" -dependencies = [ - "futures-channel", - "futures-core", - "futures-executor", - "futures-io", - "futures-sink", - "futures-task", - "futures-util", -] - -[[package]] -name = "futures-channel" -version = "0.3.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f366ad74c28cca6ba456d95e6422883cfb4b252a83bed929c83abfdbbf2967d5" -dependencies = [ - "futures-core", - "futures-sink", -] - -[[package]] -name = "futures-core" -version = "0.3.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "59f5fff90fd5d971f936ad674802482ba441b6f09ba5e15fd8b39145582ca399" - -[[package]] -name = "futures-executor" -version = "0.3.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "10d6bb888be1153d3abeb9006b11b02cf5e9b209fda28693c31ae1e4e012e314" -dependencies = [ - "futures-core", - "futures-task", - "futures-util", -] - -[[package]] -name = "futures-io" -version = "0.3.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "de27142b013a8e869c14957e6d2edeef89e97c289e69d042ee3a49acd8b51789" - -[[package]] -name = "futures-sink" -version = "0.3.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f2032893cb734c7a05d85ce0cc8b8c4075278e93b24b66f9de99d6eb0fa8acc" - -[[package]] -name = "futures-task" -version = "0.3.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bdb66b5f09e22019b1ab0830f7785bcea8e7a42148683f99214f73f8ec21a626" -dependencies = [ - "once_cell", -] - -[[package]] -name = "futures-util" -version = "0.3.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8764574ff08b701a084482c3c7031349104b07ac897393010494beaa18ce32c6" -dependencies = [ - "futures-channel", - "futures-core", - "futures-io", - "futures-sink", - "futures-task", - "memchr", - "pin-project", - "pin-utils", - "slab", -] - -[[package]] -name = "generic-array" -version = "0.12.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c68f0274ae0e023facc3c97b2e00f076be70e254bc851d972503b328db79b2ec" -dependencies = [ - "typenum", -] - -[[package]] -name = "gimli" -version = "0.21.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bcc8e0c9bce37868955864dbecd2b1ab2bdf967e6f28066d65aaac620444b65c" - -[[package]] -name = "hermit-abi" -version = "0.1.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b9586eedd4ce6b3c498bc3b4dd92fc9f11166aa908a914071953768066c67909" -dependencies = [ - "libc", -] - -[[package]] -name = "hex" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "644f9158b2f133fd50f5fb3242878846d9eb792e445c893805ff0e3824006e35" - -[[package]] -name = "itertools" -version = "0.7.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0d47946d458e94a1b7bcabbf6521ea7c037062c81f534615abcad76e84d4970d" -dependencies = [ - "either", -] - -[[package]] -name = "itoa" -version = "0.4.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b8b7a7c0c47db5545ed3fef7468ee7bb5b74691498139e4b3f6a20685dc6dd8e" - -[[package]] -name = "js-sys" -version = "0.3.40" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce10c23ad2ea25ceca0093bd3192229da4c5b3c0f2de499c1ecac0d98d452177" -dependencies = [ - "wasm-bindgen", -] - -[[package]] -name = "lazy_static" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" - -[[package]] -name = "libc" -version = "0.2.71" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9457b06509d27052635f90d6466700c65095fdf75409b3fbdd903e988b886f49" - -[[package]] -name = "log" -version = "0.4.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "14b6052be84e6b71ab17edffc2eeabf5c2c3ae1fdb464aae35ac50c67a44e1f7" -dependencies = [ - "cfg-if", -] - -[[package]] -name = "maplit" -version = "1.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d" - -[[package]] -name = "memchr" -version = "2.3.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400" - -[[package]] -name = "nodrop" -version = "0.1.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72ef4a56884ca558e5ddb05a1d1e7e1bfd9a68d9ed024c21704cc98872dae1bb" - -[[package]] -name = "num" -version = "0.1.42" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4703ad64153382334aa8db57c637364c322d3372e097840c72000dabdcf6156e" -dependencies = [ - "num-integer", - "num-iter", - "num-traits 0.2.12", -] - -[[package]] -name = "num-bigint" -version = "0.1.44" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e63899ad0da84ce718c14936262a41cee2c79c981fc0a0e7c7beb47d5a07e8c1" -dependencies = [ - "num-integer", - "num-traits 0.2.12", -] - -[[package]] -name = "num-bigint" -version = "0.2.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "090c7f9998ee0ff65aa5b723e4009f7b217707f1fb5ea551329cc4d6231fb304" -dependencies = [ - "autocfg", - "num-integer", - "num-traits 0.2.12", - "serde", -] - -[[package]] -name = "num-integer" -version = "0.1.43" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8d59457e662d541ba17869cf51cf177c0b5f0cbf476c66bdc90bf1edac4f875b" -dependencies = [ - "autocfg", - "num-traits 0.2.12", -] - -[[package]] -name = "num-iter" -version = "0.1.41" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a6e6b7c748f995c4c29c5f5ae0248536e04a5739927c74ec0fa564805094b9f" -dependencies = [ - "autocfg", - "num-integer", - "num-traits 0.2.12", -] - -[[package]] -name = "num-traits" -version = "0.1.43" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "92e5113e9fd4cc14ded8e499429f396a20f98c772a47cc8622a736e1ec843c31" -dependencies = [ - "num-traits 0.2.12", -] - -[[package]] -name = "num-traits" -version = "0.2.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac267bcc07f48ee5f8935ab0d24f316fb722d7a1292e2913f0cc196b29ffd611" -dependencies = [ - "autocfg", -] - -[[package]] -name = "num_cpus" -version = "1.13.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3" -dependencies = [ - "hermit-abi", - "libc", -] - -[[package]] -name = "object" -version = "0.19.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9cbca9424c482ee628fa549d9c812e2cd22f1180b9222c9200fdfa6eb31aecb2" - -[[package]] -name = "once_cell" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b631f7e854af39a1739f401cf34a8a013dfe09eac4fa4dba91e9768bd28168d" - -[[package]] -name = "opaque-debug" -version = "0.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c" - -[[package]] -name = "pairing_ce" -version = "0.21.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfc00d65b1d29e0a067a967fcea83d8db261c149f76a557ba73f0304f01cdfde" -dependencies = [ - "byteorder", - "ff_ce 0.10.2", - "rand", -] - -[[package]] -name = "pest" -version = "2.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "10f4872ae94d7b90ae48754df22fd42ad52ce740b8f370b03da4835417403e53" -dependencies = [ - "ucd-trie", -] - -[[package]] -name = "pest-ast" -version = "0.3.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3fbf404899169771dd6a32c84248b83cd67a26cc7cc957aac87661490e1227e4" -dependencies = [ - "itertools", - "proc-macro2 0.4.30", - "quote 0.6.13", - "single", - "syn 0.15.44", -] - -[[package]] -name = "pest_derive" -version = "2.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "833d1ae558dc601e9a60366421196a8d94bc0ac980476d0b67e1d0988d72b2d0" -dependencies = [ - "pest", - "pest_generator", -] - -[[package]] -name = "pest_generator" -version = "2.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "99b8db626e31e5b81787b9783425769681b347011cc59471e33ea46d2ea0cf55" -dependencies = [ - "pest", - "pest_meta", - "proc-macro2 1.0.18", - "quote 1.0.7", - "syn 1.0.31", -] - -[[package]] -name = "pest_meta" -version = "2.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "54be6e404f5317079812fc8f9f5279de376d8856929e21c184ecf6bbd692a11d" -dependencies = [ - "maplit", - "pest", - "sha-1", -] - -[[package]] -name = "pin-project" -version = "0.4.22" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "12e3a6cdbfe94a5e4572812a0201f8c0ed98c1c452c7b8563ce2276988ef9c17" -dependencies = [ - "pin-project-internal", -] - -[[package]] -name = "pin-project-internal" -version = "0.4.22" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6a0ffd45cf79d88737d7cc85bfd5d2894bee1139b356e616fe85dc389c61aaf7" -dependencies = [ - "proc-macro2 1.0.18", - "quote 1.0.7", - "syn 1.0.31", -] - -[[package]] -name = "pin-utils" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" - -[[package]] -name = "proc-macro2" -version = "0.4.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf3d2011ab5c909338f7887f4fc896d35932e29146c12c8d01da6b22a80ba759" -dependencies = [ - "unicode-xid 0.1.0", -] - -[[package]] -name = "proc-macro2" -version = "1.0.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "beae6331a816b1f65d04c45b078fd8e6c93e8071771f41b8163255bbd8d7c8fa" -dependencies = [ - "unicode-xid 0.2.0", -] - -[[package]] -name = "quote" -version = "0.6.13" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6ce23b6b870e8f94f81fb0a363d65d86675884b34a09043c81e5562f11c1f8e1" -dependencies = [ - "proc-macro2 0.4.30", -] - -[[package]] -name = "quote" -version = "1.0.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aa563d17ecb180e500da1cfd2b028310ac758de548efdd203e18f283af693f37" -dependencies = [ - "proc-macro2 1.0.18", -] - -[[package]] -name = "rand" -version = "0.4.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "552840b97013b1a26992c11eac34bdd778e464601a4c2054b5f0bff7c6761293" -dependencies = [ - "fuchsia-cprng", - "libc", - "rand_core 0.3.1", - "rdrand", - "winapi", -] - -[[package]] -name = "rand_core" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b" -dependencies = [ - "rand_core 0.4.2", -] - -[[package]] -name = "rand_core" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc" - -[[package]] -name = "rdrand" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2" -dependencies = [ - "rand_core 0.3.1", -] - -[[package]] -name = "reduce" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "75b1fa5668b02f2a69746bba558f8f98cc087b123a587fd959122872ad9a3f3c" - -[[package]] -name = "regex" -version = "0.2.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9329abc99e39129fcceabd24cf5d85b4671ef7c29c50e972bc5afe32438ec384" -dependencies = [ - "aho-corasick", - "memchr", - "regex-syntax", - "thread_local", - "utf8-ranges", -] - -[[package]] -name = "regex-automata" -version = "0.1.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae1ded71d66a4a97f5e961fd0cb25a5f366a42a41570d16a763a69c092c26ae4" -dependencies = [ - "byteorder", -] - -[[package]] -name = "regex-syntax" -version = "0.5.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7d707a4fa2637f2dca2ef9fd02225ec7661fe01a53623c1e6515b6916511f7a7" -dependencies = [ - "ucd-util", -] - -[[package]] -name = "rustc-demangle" -version = "0.1.16" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c691c0e608126e00913e33f0ccf3727d5fc84573623b8d65b2df340b5201783" - -[[package]] -name = "ryu" -version = "1.0.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e" - -[[package]] -name = "sapling-crypto_ce" -version = "0.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1c4ff5309ec3e4bd800ad4ab3f71e9b76e9ea81c9f0eda6efa16008afbe440b3" -dependencies = [ - "bellman_ce", - "blake2-rfc_bellman_edition", - "byteorder", - "digest", - "rand", - "serde", - "serde_derive", - "sha2", - "tiny-keccak", -] - -[[package]] -name = "serde" -version = "1.0.112" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "736aac72d1eafe8e5962d1d1c3d99b0df526015ba40915cb3c49d042e92ec243" -dependencies = [ - "serde_derive", -] - -[[package]] -name = "serde_bytes" -version = "0.10.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "defbb8a83d7f34cc8380751eeb892b825944222888aff18996ea7901f24aec88" -dependencies = [ - "serde", -] - -[[package]] -name = "serde_derive" -version = "1.0.112" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf0343ce212ac0d3d6afd9391ac8e9c9efe06b533c8d33f660f6390cc4093f57" -dependencies = [ - "proc-macro2 1.0.18", - "quote 1.0.7", - "syn 1.0.31", -] - -[[package]] -name = "serde_json" -version = "1.0.55" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ec2c5d7e739bc07a3e73381a39d61fdb5f671c60c1df26a130690665803d8226" -dependencies = [ - "itoa", - "ryu", - "serde", -] - -[[package]] -name = "sha-1" -version = "0.8.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f7d94d0bede923b3cea61f3f1ff57ff8cdfd77b400fb8f9998949e0cf04163df" -dependencies = [ - "block-buffer", - "digest", - "fake-simd", - "opaque-debug", -] - -[[package]] -name = "sha2" -version = "0.8.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a256f46ea78a0c0d9ff00077504903ac881a1dafdc20da66545699e7776b3e69" -dependencies = [ - "block-buffer", - "digest", - "fake-simd", - "opaque-debug", -] - -[[package]] -name = "single" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bd5add732a1ab689845591a1b50339cf5310b563e08dc5813c65991f30369ea2" -dependencies = [ - "failure", -] - -[[package]] -name = "slab" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8" - -[[package]] -name = "syn" -version = "0.15.44" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9ca4b3b69a77cbe1ffc9e198781b7acb0c7365a883670e8f1c1bc66fba79a5c5" -dependencies = [ - "proc-macro2 0.4.30", - "quote 0.6.13", - "unicode-xid 0.1.0", -] - -[[package]] -name = "syn" -version = "1.0.31" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5304cfdf27365b7585c25d4af91b35016ed21ef88f17ced89c7093b43dba8b6" -dependencies = [ - "proc-macro2 1.0.18", - "quote 1.0.7", - "unicode-xid 0.2.0", -] - -[[package]] -name = "synstructure" -version = "0.12.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b834f2d66f734cb897113e34aaff2f1ab4719ca946f9a7358dba8f8064148701" -dependencies = [ - "proc-macro2 1.0.18", - "quote 1.0.7", - "syn 1.0.31", - "unicode-xid 0.2.0", -] - -[[package]] -name = "thread_local" -version = "0.3.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c6b53e329000edc2b34dbe8545fd20e55a333362d0a321909685a19bd28c3f1b" -dependencies = [ - "lazy_static", -] - -[[package]] -name = "tiny-keccak" -version = "2.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237" -dependencies = [ - "crunchy", -] - -[[package]] -name = "typed-arena" -version = "1.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a9b2228007eba4120145f785df0f6c92ea538f5a3635a612ecf4e334c8c1446d" - -[[package]] -name = "typenum" -version = "1.12.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "373c8a200f9e67a0c95e62a4f52fbf80c23b4381c05a17845531982fa99e6b33" - -[[package]] -name = "ucd-trie" -version = "0.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c" - -[[package]] -name = "ucd-util" -version = "0.1.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c85f514e095d348c279b1e5cd76795082cf15bd59b93207832abe0b1d8fed236" - -[[package]] -name = "unicode-xid" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc" - -[[package]] -name = "unicode-xid" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "826e7639553986605ec5979c7dd957c7895e93eabed50ab2ffa7f6128a75097c" - -[[package]] -name = "utf8-ranges" -version = "1.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b4ae116fef2b7fea257ed6440d3cfcff7f190865f170cdad00bb6465bf18ecba" - -[[package]] -name = "void" -version = "1.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d" - -[[package]] -name = "wasm-bindgen" -version = "0.2.63" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c2dc4aa152834bc334f506c1a06b866416a8b6697d5c9f75b9a689c8486def0" -dependencies = [ - "cfg-if", - "serde", - "serde_json", - "wasm-bindgen-macro", -] - -[[package]] -name = "wasm-bindgen-backend" -version = "0.2.63" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ded84f06e0ed21499f6184df0e0cb3494727b0c5da89534e0fcc55c51d812101" -dependencies = [ - "bumpalo", - "lazy_static", - "log", - "proc-macro2 1.0.18", - "quote 1.0.7", - "syn 1.0.31", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-macro" -version = "0.2.63" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "838e423688dac18d73e31edce74ddfac468e37b1506ad163ffaf0a46f703ffe3" -dependencies = [ - "quote 1.0.7", - "wasm-bindgen-macro-support", -] - -[[package]] -name = "wasm-bindgen-macro-support" -version = "0.2.63" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3156052d8ec77142051a533cdd686cba889537b213f948cd1d20869926e68e92" -dependencies = [ - "proc-macro2 1.0.18", - "quote 1.0.7", - "syn 1.0.31", - "wasm-bindgen-backend", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-shared" -version = "0.2.63" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c9ba19973a58daf4db6f352eda73dc0e289493cd29fb2632eb172085b6521acd" - -[[package]] -name = "web-sys" -version = "0.3.40" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7b72fe77fd39e4bd3eaa4412fd299a0be6b3dfe9d2597e2f1c20beb968f41d17" -dependencies = [ - "js-sys", - "wasm-bindgen", -] - -[[package]] -name = "winapi" -version = "0.3.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8093091eeb260906a183e6ae1abdba2ef5ef2257a21801128899c3fc699229c6" -dependencies = [ - "winapi-i686-pc-windows-gnu", - "winapi-x86_64-pc-windows-gnu", -] - -[[package]] -name = "winapi-i686-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" - -[[package]] -name = "winapi-x86_64-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" - -[[package]] -name = "zokrates_abi" -version = "0.1.1" -dependencies = [ - "serde", - "serde_derive", - "serde_json", - "zokrates_core", - "zokrates_field", -] - -[[package]] -name = "zokrates_common" -version = "0.1.0" - -[[package]] -name = "zokrates_core" -version = "0.4.3" -dependencies = [ - "bellman_ce", - "bincode 0.8.0", - "csv", - "ff_ce 0.9.0", - "hex", - "lazy_static", - "num", - "num-bigint 0.1.44", - "pairing_ce", - "rand", - "reduce", - "regex", - "serde", - "serde_bytes", - "serde_derive", - "serde_json", - "typed-arena", - "zokrates_common", - "zokrates_embed", - "zokrates_field", - "zokrates_pest_ast", -] - -[[package]] -name = "zokrates_embed" -version = "0.1.1" -dependencies = [ - "bellman_ce", - "sapling-crypto_ce", -] - -[[package]] -name = "zokrates_field" -version = "0.3.6" -dependencies = [ - "bellman_ce", - "bincode 0.8.0", - "lazy_static", - "num-bigint 0.2.6", - "num-integer", - "num-traits 0.2.12", - "serde", - "serde_derive", - "serde_json", - "sha2", -] - -[[package]] -name = "zokrates_js" -version = "1.0.22" -dependencies = [ - "bincode 1.2.1", - "console_error_panic_hook", - "js-sys", - "serde", - "serde_json", - "wasm-bindgen", - "zokrates_abi", - "zokrates_common", - "zokrates_core", - "zokrates_field", -] - -[[package]] -name = "zokrates_parser" -version = "0.1.4" -dependencies = [ - "pest", - "pest_derive", -] - -[[package]] -name = "zokrates_pest_ast" -version = "0.1.3" -dependencies = [ - "from-pest", - "lazy_static", - "pest", - "pest-ast", - "zokrates_field", - "zokrates_parser", -] diff --git a/zokrates_js/Cargo.toml b/zokrates_js/Cargo.toml index 25e9c247..43ead206 100644 --- a/zokrates_js/Cargo.toml +++ b/zokrates_js/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "zokrates_js" -version = "1.0.22" +version = "1.0.23" authors = ["Darko Macesic"] edition = "2018" diff --git a/zokrates_js/README.md b/zokrates_js/README.md index f681cef3..12133e33 100644 --- a/zokrates_js/README.md +++ b/zokrates_js/README.md @@ -19,19 +19,42 @@ npm install zokrates-js ## Usage +### Importing + +Bundlers ```js import { initialize } from 'zokrates-js'; +``` -function importResolver(location, path) { +Node +```js +const { initialize } = require('zokrates-js/node'); +``` + +### Example +```js +function importResolver(currentLocation, importLocation) { // implement your resolving logic here - return { - source: "def main() -> (): return", - location: path + return { + source: "def main() -> (): return", + location: importLocation }; } initialize().then((zokratesProvider) => { - // we have to initialize the wasm module before calling api functions - zokratesProvider.compile("def main(private field a) -> (field): return a", "main", importResolver) + // compilation + const artifacts = zokratesProvider.compile("def main(private field a) -> (field): return a * a", "main", importResolver); + + // computation + const { witness, output } = zokratesProvider.computeWitness(artifacts, ["2"]); + + // run setup + const keypair = zokratesProvider.setup(artifacts.program); + + // generate proof + const proof = zokratesProvider.generateProof(artifacts.program, witness, keypair.pk); + + // export solidity verifier + const verifier = zokratesProvider.exportSolidityVerifier(keypair.vk, "v1"); }); -``` +``` \ No newline at end of file diff --git a/zokrates_js/gulpfile.js b/zokrates_js/gulpfile.js index 21275747..4129b607 100644 --- a/zokrates_js/gulpfile.js +++ b/zokrates_js/gulpfile.js @@ -5,7 +5,7 @@ const fs = require('fs'); const path = require('path'); /** stdlib constants */ -const stdlibRoot = '../zokrates_stdlib/stdlib'; +const stdlibRoot = '../zokrates_stdlib/stdlib'; const output = 'stdlib.json'; const options = { @@ -15,7 +15,7 @@ const options = { /** * Serializes standard library directory tree to a json file. */ -gulp.task('stdlib', function (done) { +gulp.task('stdlib', (done) => { var stdlib = {}; dree.scan(stdlibRoot, options, function (file) { const content = fs.readFileSync(file.path).toString(); diff --git a/zokrates_js/index.d.ts b/zokrates_js/index.d.ts index 8728c4bf..263cc255 100644 --- a/zokrates_js/index.d.ts +++ b/zokrates_js/index.d.ts @@ -4,6 +4,10 @@ declare module 'zokrates-js' { export type G2Affine = [G1Affine, G1Affine]; export type ProvingKey = Uint8Array; + export interface CompileConfig { + is_release: boolean + } + export interface VerificationKey { alpha: G1Affine, beta: G2Affine, @@ -49,7 +53,7 @@ declare module 'zokrates-js' { export type ResolveCallback = (location: string, path: string) => ResolverResult; export interface ZoKratesProvider { - compile(source: string, location: string, callback: ResolveCallback): CompilationArtifacts; + compile(source: string, location: string, callback: ResolveCallback, config?: CompileConfig): CompilationArtifacts; setup(program: Uint8Array): SetupKeypair; computeWitness(artifacts: CompilationArtifacts, args: any[]): ComputationResult; exportSolidityVerifier(verifyingKey: VerificationKey, abi: SolidityAbi): string; diff --git a/zokrates_js/index.js b/zokrates_js/index.js index c83a9b5c..4f8b8ba0 100644 --- a/zokrates_js/index.js +++ b/zokrates_js/index.js @@ -1,61 +1,9 @@ -import { appendExtension, getAbsolutePath } from './utils'; +import wrapper from './wrapper'; import stdlib from './stdlib.json'; const initialize = async () => { - - const EXTENSION_ZOK = '.zok'; - const RESERVED_PATHS = [ - 'ecc/', - 'signature/', - 'hashes/', - 'utils/' - ]; - - // load web assembly module const zokrates = await import('./pkg/index.js'); - - const resolveModule = (currentLocation, importLocation, callback) => { - if (isReserved(currentLocation) || isReserved(importLocation)) { - return resolveFromStandardLibrary(currentLocation, importLocation); - } - return callback(currentLocation, importLocation); - } - - const isReserved = (path) => RESERVED_PATHS.some(p => path.startsWith(p)); - - const resolveFromStandardLibrary = (currentLocation, importLocation) => { - let key = appendExtension(getAbsolutePath(currentLocation, importLocation), EXTENSION_ZOK); - let source = stdlib[key]; - return source ? { source, location: key } : null; - } - - return { - compile: (source, location, callback) => { - let result = zokrates.compile(source, location, (currentLocation, importLocation) => - resolveModule(currentLocation, importLocation, callback) - ); - return { - program: Array.from(result.program), - abi: result.abi - } - }, - setup: (program) => { - let result = zokrates.setup(program); - return { - vk: result.vk, - pk: Array.from(result.pk) - }; - }, - computeWitness: (artifacts, args) => { - return zokrates.compute_witness(artifacts, JSON.stringify(Array.from(args))); - }, - exportSolidityVerifier: (verifyingKey, abiVersion) => { - return zokrates.export_solidity_verifier(verifyingKey, abiVersion); - }, - generateProof: (program, witness, provingKey) => { - return zokrates.generate_proof(program, witness, provingKey); - } - } + return wrapper({ zokrates, stdlib }); } export { initialize }; \ No newline at end of file diff --git a/zokrates_js/node/index.js b/zokrates_js/node/index.js new file mode 100644 index 00000000..681e3ade --- /dev/null +++ b/zokrates_js/node/index.js @@ -0,0 +1,11 @@ +const wrapper = require('../wrapper.js'); +const stdlib = require('../stdlib.json'); + +const initialize = async () => { + return wrapper({ + zokrates: require('./pkg/index.js'), + stdlib + }); +} + +module.exports = { initialize }; \ No newline at end of file diff --git a/zokrates_js/package.json b/zokrates_js/package.json index 3f11f7ab..1e0a9152 100644 --- a/zokrates_js/package.json +++ b/zokrates_js/package.json @@ -10,21 +10,25 @@ ], "license": "GPLv3", "files": [ + "node", "pkg", "index.js", "index.d.ts", - "utils.js", + "wrapper.js", "stdlib.json", "README.md" ], "types": "index.d.ts", "scripts": { - "cargo:build": "cargo build --target=wasm32-unknown-unknown", - "wasm-pack:build": "wasm-pack build --out-name index --release --target bundler", + "wasm-pack": "wasm-pack build --out-name index --release", "setup": "npm install && gulp stdlib", "prebuild": "npm run setup", - "build": "rimraf pkg && npm run wasm-pack:build", - "pretest": "npm run setup", + "build": "npm run build:bundler && npm run build:node", + "build:bundler": "rimraf pkg && npm run wasm-pack -- --target bundler && npm run clean-pkg", + "build:node": "rimraf node/pkg && npm run wasm-pack -- --target nodejs -d node/pkg && npm run clean-node-pkg", + "clean-pkg": "find pkg/* | grep -P \"^.*\\.(md|d\\.ts)$\" | xargs rm", + "clean-node-pkg": "find node/pkg/* | grep -P \"^.*\\.(md|d\\.ts)$\" | xargs rm", + "pretest": "npm run setup && npm run build:node", "test": "mocha --require esm --recursive tests" }, "devDependencies": { diff --git a/zokrates_js/src/lib.rs b/zokrates_js/src/lib.rs index 8f1cac67..5b051e31 100644 --- a/zokrates_js/src/lib.rs +++ b/zokrates_js/src/lib.rs @@ -10,8 +10,8 @@ use zokrates_core::compile::{ }; use zokrates_core::imports::Error; use zokrates_core::ir; -use zokrates_core::proof_system::{ProofSystem, SolidityAbi}; use zokrates_core::proof_system::bellman::groth16::G16; +use zokrates_core::proof_system::{ProofSystem, SolidityAbi}; use zokrates_core::typed_absy::abi::Abi; use zokrates_core::typed_absy::types::Signature; use zokrates_field::Bn128Field; @@ -77,7 +77,7 @@ impl<'a> Resolver for JsResolver<'a> { ) .map_err(|_| { Error::new(format!( - "Error thrown in callback: could not resolve {}", + "Error thrown in JS callback: could not resolve {}", import_location.display() )) })?; @@ -99,15 +99,26 @@ pub fn compile( source: JsValue, location: JsValue, resolve: &js_sys::Function, + config: JsValue, ) -> Result { let fmt_error = |e: &CompileError| format!("{}:{}", e.file().display(), e.value()); let resolver = JsResolver::new(resolve); + let config: CompileConfig = { + if config.is_object() { + config + .into_serde() + .map_err(|e| JsValue::from_str(&format!("Invalid config format: {}", e)))? + } else { + CompileConfig::default() + } + }; + let artifacts: CompilationArtifacts = core_compile( source.as_string().unwrap(), PathBuf::from(location.as_string().unwrap()), Some(&resolver), - &CompileConfig::default().with_is_release(true), + &config, ) .map_err(|ce| { JsValue::from_str(&format!( diff --git a/zokrates_js/tests/stdlib.test.js b/zokrates_js/tests/stdlib.test.js deleted file mode 100644 index faa345ae..00000000 --- a/zokrates_js/tests/stdlib.test.js +++ /dev/null @@ -1,30 +0,0 @@ -const assert = require('assert'); -const utils = require('../utils'); -const stdlib = require('../stdlib.json'); - -describe('stdlib', function() { - - it('should resolve module from stdlib (1)', function() { - let basePath = 'hashes/sha256/512bitPacked.zok'; - let relativePath = '../../utils/pack/u32/pack128'; - - let absolutePath = utils.appendExtension(utils.getAbsolutePath(basePath, relativePath), '.zok'); - assert.notEqual(stdlib[absolutePath], undefined); - }); - - it('should resolve module from stdlib (2)', function() { - let basePath = 'hashes/sha256/256bitPadded.zok'; - let relativePath = './512bit'; - - let absolutePath = utils.appendExtension(utils.getAbsolutePath(basePath, relativePath), '.zok'); - assert.notEqual(stdlib[absolutePath], undefined); - }); - - it('should resolve module from stdlib (3)', function() { - let basePath = 'hashes/pedersen/6bit.zok'; - let relativePath = 'ecc/babyjubjubParams'; - - let absolutePath = utils.appendExtension(utils.getAbsolutePath(basePath, relativePath), '.zok'); - assert.notEqual(stdlib[absolutePath], undefined); - }); -}); \ No newline at end of file diff --git a/zokrates_js/tests/tests.js b/zokrates_js/tests/tests.js new file mode 100644 index 00000000..edcfb9fc --- /dev/null +++ b/zokrates_js/tests/tests.js @@ -0,0 +1,123 @@ +const assert = require('assert'); +const { initialize } = require('../node/index.js'); + +describe('tests', function() { + + // initialize once before running tests + before(function (done) { + initialize().then(zokrates => { + this.zokrates = zokrates; + done(); + }); + }); + + describe("compilation", () => { + it('should compile', function() { + assert.doesNotThrow(() => { + const artifacts = this.zokrates.compile("def main() -> (field): return 42", "main"); + assert.ok(artifacts !== undefined); + }) + }); + + it('should throw on invalid code', function() { + assert.throws(() => this.zokrates.compile(":-)", "main")); + }); + + it('should resolve stdlib module', function() { + assert.doesNotThrow(() => { + const code = 'import "hashes/sha256/512bit" as sha256\ndef main() -> (): return'; + this.zokrates.compile(code, "main"); + }) + }); + + it('should resolve user module', function() { + assert.doesNotThrow(() => { + const code = 'import "test" as test\ndef main() -> (field): return test()'; + this.zokrates.compile(code, "main", (_, path) => { + return { + source: "def main() -> (field): return 1", + location: path + } + }); + }) + }); + + it('should throw on invalid module', function() { + assert.throws(() => { + const code = 'import "test" as test\ndef main() -> (field): return test()'; + this.zokrates.compile(code, "main", (_loc, _path) => null); + }) + }); + }) + + describe("computation", () => { + it('should compute with valid inputs', function() { + assert.doesNotThrow(() => { + const code = 'def main(private field a) -> (field): return a * a'; + const artifacts = this.zokrates.compile(code, "main", null); + + const result = this.zokrates.computeWitness(artifacts, ["2"]) + const output = JSON.parse(result.output); + + assert.deepEqual(output, ["4"]); + }) + }); + + it('should throw on invalid input count', function() { + assert.throws(() => { + const code = 'def main(private field a) -> (field): return a * a'; + const artifacts = this.zokrates.compile(code, "main", null); + + this.zokrates.computeWitness(artifacts, ["1", "2"]) + }) + }); + + it('should throw on invalid input type', function() { + assert.throws(() => { + const code = 'def main(private field a) -> (field): return a * a'; + const artifacts = this.zokrates.compile(code, "main", null); + + this.zokrates.computeWitness(artifacts, [true]) + }) + }); + }) + + describe("setup", () => { + it('should run setup', function() { + assert.doesNotThrow(() => { + const code = 'def main(private field a) -> (field): return a * a'; + const artifacts = this.zokrates.compile(code, "main", null); + + this.zokrates.setup(artifacts.program); + }) + }); + }) + + describe("export-verifier", () => { + it('should export solidity verifier', function() { + assert.doesNotThrow(() => { + const code = 'def main(private field a) -> (field): return a * a'; + const artifacts = this.zokrates.compile(code, "main", null); + const keypair = this.zokrates.setup(artifacts.program); + + const verifier = this.zokrates.exportSolidityVerifier(keypair.vk, "v1"); + assert.ok(verifier.length > 0) + }) + }); + }) + + describe("generate-proof", () => { + it('should generate proof', function() { + assert.doesNotThrow(() => { + const code = 'def main(private field a) -> (field): return a * a'; + const artifacts = this.zokrates.compile(code, "main", null); + const computationResult = this.zokrates.computeWitness(artifacts, ["2"]) + const keypair = this.zokrates.setup(artifacts.program); + const proof = this.zokrates.generateProof(artifacts.program, computationResult.witness, keypair.pk); + + assert.ok(proof !== undefined); + assert.deepEqual(proof.inputs, ["0x0000000000000000000000000000000000000000000000000000000000000004"]) + }) + }); + }); +}); \ No newline at end of file diff --git a/zokrates_js/tests/utils.test.js b/zokrates_js/tests/utils.test.js deleted file mode 100644 index c324c23a..00000000 --- a/zokrates_js/tests/utils.test.js +++ /dev/null @@ -1,29 +0,0 @@ -const assert = require('assert') -const utils = require('../utils'); - -describe('absolute path resolving', function() { - - it('should resolve valid absolute path (root)', function() { - let basePath = 'hashes/pedersen/6bit'; - let relativePath = 'ecc/babyjubjubParams'; - - let absolutePath = utils.getAbsolutePath(basePath, relativePath); - assert.equal(absolutePath, 'ecc/babyjubjubParams'); - }); - - it('should resolve valid absolute path (../)', function() { - let basePath = 'hashes/sha256/512bitPacked'; - let relativePath = '../../utils/pack/u32/pack128'; - - let absolutePath = utils.getAbsolutePath(basePath, relativePath); - assert.equal(absolutePath, 'utils/pack/u32/pack128'); - }); - - it('should resolve valid absolute path (./)', function() { - let basePath = 'hashes/sha256/256bitPadded'; - let relativePath = './512bit'; - - let absolutePath = utils.getAbsolutePath(basePath, relativePath); - assert.equal(absolutePath, 'hashes/sha256/512bit'); - }); -}); \ No newline at end of file diff --git a/zokrates_js/utils.js b/zokrates_js/utils.js deleted file mode 100644 index 270d3bfc..00000000 --- a/zokrates_js/utils.js +++ /dev/null @@ -1,26 +0,0 @@ -export function getAbsolutePath(basePath, relativePath) { - if (relativePath[0] !== '.') { - return relativePath; - } - var stack = basePath.split('/'); - var chunks = relativePath.split('/'); - stack.pop(); - - for(var i = 0; i < chunks.length; i++) { - if (chunks[i] == '.') { - continue; - } else if (chunks[i] == '..') { - stack.pop(); - } else { - stack.push(chunks[i]); - } - } - return stack.join('/'); -} - -export function appendExtension(path, extension) { - if (path.endsWith(extension)) { - return path; - } - return path.concat(extension); -} \ No newline at end of file diff --git a/zokrates_js/wrapper.js b/zokrates_js/wrapper.js new file mode 100644 index 00000000..e163c128 --- /dev/null +++ b/zokrates_js/wrapper.js @@ -0,0 +1,62 @@ +const getAbsolutePath = (basePath, relativePath) => { + var stack = basePath.split('/'); + var chunks = relativePath.split('/'); + stack.pop(); + + for (var i = 0; i < chunks.length; i++) { + if (chunks[i] == '.') { + continue; + } else if (chunks[i] == '..') { + stack.pop(); + } else { + stack.push(chunks[i]); + } + } + return stack.join('/'); +} + +const getImportPath = (currentLocation, importLocation) => { + let path = getAbsolutePath(currentLocation, importLocation); + const extension = importLocation.slice((path.lastIndexOf(".") - 1 >>> 0) + 2); + return extension ? path : path.concat('.zok'); +} + +module.exports = (dep) => { + + const { zokrates, stdlib } = dep; + + const resolveFromStdlib = (currentLocation, importLocation) => { + let key = getImportPath(currentLocation, importLocation); + let source = stdlib[key]; + return source ? { source, location: key } : null; + } + + return { + compile: (source, location, callback) => { + let importCallback = (currentLocation, importLocation) => { + return resolveFromStdlib(currentLocation, importLocation) || callback(currentLocation, importLocation); + }; + const { program, abi } = zokrates.compile(source, location, importCallback); + return { + program: Array.from(program), + abi + } + }, + setup: (program) => { + const { vk, pk } = zokrates.setup(program); + return { + vk, + pk: Array.from(pk) + }; + }, + computeWitness: (artifacts, args) => { + return zokrates.compute_witness(artifacts, JSON.stringify(Array.from(args))); + }, + exportSolidityVerifier: (verificationKey, abiVersion) => { + return zokrates.export_solidity_verifier(verificationKey, abiVersion); + }, + generateProof: (program, witness, provingKey) => { + return zokrates.generate_proof(program, witness, provingKey); + } + } +}; \ No newline at end of file diff --git a/zokrates_parser/src/ace_mode/index.js b/zokrates_parser/src/ace_mode/index.js index b4753e6c..21eb6e82 100644 --- a/zokrates_parser/src/ace_mode/index.js +++ b/zokrates_parser/src/ace_mode/index.js @@ -37,7 +37,7 @@ ace.define("ace/mode/zokrates_highlight_rules",["require","exports","module","ac var ZoKratesHighlightRules = function () { var keywords = ( - "endfor|as|return|byte|field|bool|if|then|fi|do|else|export|false|def|for|import|from|uint|in|public|private|struct|true" + "assert|endfor|as|return|byte|field|bool|if|then|fi|do|else|export|false|def|for|import|from|uint|in|public|private|struct|true" ); var keywordMapper = this.createKeywordMapper({ diff --git a/zokrates_parser/src/zokrates.pest b/zokrates_parser/src/zokrates.pest index ba2ea000..a19f915d 100644 --- a/zokrates_parser/src/zokrates.pest +++ b/zokrates_parser/src/zokrates.pest @@ -46,7 +46,7 @@ statement = { (return_statement // does not require subsequent newline iteration_statement = { "for" ~ ty ~ identifier ~ "in" ~ expression ~ ".." ~ expression ~ "do" ~ NEWLINE* ~ statement* ~ "endfor"} return_statement = { "return" ~ expression_list} definition_statement = { optionally_typed_assignee_list ~ "=" ~ expression } // declare and assign, so only identifiers are allowed, unlike `assignment_statement` -expression_statement = {expression} +expression_statement = {"assert" ~ "(" ~ expression ~ ")"} optionally_typed_assignee_list = _{ optionally_typed_assignee ~ ("," ~ optionally_typed_assignee)* } optionally_typed_assignee = { (ty ~ assignee) | (assignee) } // we don't use { ty? ~ identifier } as with a single token, it gets parsed as `ty` but we want `identifier` @@ -124,6 +124,8 @@ op_unary = { op_not } WHITESPACE = _{ " " | "\t" | "\\" ~ NEWLINE} COMMENT = _{ ("/*" ~ (!"*/" ~ ANY)* ~ "*/") | ("//" ~ (!NEWLINE ~ ANY)*) } -keyword = @{"as"|"bool"|"byte"|"def"|"do"|"else"|"endfor"|"export"|"false"|"field"|"for"|"if"|"then"|"fi"|"import"|"from"| +// the ordering of reserved keywords matters: if "as" is before "assert", then "assert" gets parsed as (as)(sert) and incorrectly +// accepted +keyword = @{"assert"|"as"|"bool"|"byte"|"def"|"do"|"else"|"endfor"|"export"|"false"|"field"|"for"|"if"|"then"|"fi"|"import"|"from"| "in"|"private"|"public"|"return"|"struct"|"true"|"u8"|"u16"|"u32" } diff --git a/zokrates_pest_ast/src/lib.rs b/zokrates_pest_ast/src/lib.rs index cba0188a..bdf4e71a 100644 --- a/zokrates_pest_ast/src/lib.rs +++ b/zokrates_pest_ast/src/lib.rs @@ -32,21 +32,22 @@ mod ast { static ref PREC_CLIMBER: PrecClimber = build_precedence_climber(); } + // based on https://docs.python.org/3/reference/expressions.html#operator-precedence fn build_precedence_climber() -> PrecClimber { PrecClimber::new(vec![ Operator::new(Rule::op_or, Assoc::Left), Operator::new(Rule::op_and, Assoc::Left), + Operator::new(Rule::op_lt, Assoc::Left) + | Operator::new(Rule::op_lte, Assoc::Left) + | Operator::new(Rule::op_gt, Assoc::Left) + | Operator::new(Rule::op_gte, Assoc::Left) + | Operator::new(Rule::op_not_equal, Assoc::Left) + | Operator::new(Rule::op_equal, Assoc::Left), Operator::new(Rule::op_bit_or, Assoc::Left), Operator::new(Rule::op_bit_xor, Assoc::Left), Operator::new(Rule::op_bit_and, Assoc::Left), - Operator::new(Rule::op_equal, Assoc::Left) - | Operator::new(Rule::op_not_equal, Assoc::Left), - Operator::new(Rule::op_lte, Assoc::Left) - | Operator::new(Rule::op_gte, Assoc::Left) - | Operator::new(Rule::op_lt, Assoc::Left) - | Operator::new(Rule::op_gt, Assoc::Left), - Operator::new(Rule::op_right_shift, Assoc::Left) - | Operator::new(Rule::op_left_shift, Assoc::Left), + Operator::new(Rule::op_left_shift, Assoc::Left) + | Operator::new(Rule::op_right_shift, Assoc::Left), Operator::new(Rule::op_add, Assoc::Left) | Operator::new(Rule::op_sub, Assoc::Left), Operator::new(Rule::op_mul, Assoc::Left) | Operator::new(Rule::op_div, Assoc::Left), Operator::new(Rule::op_pow, Assoc::Left), @@ -1174,9 +1175,9 @@ mod tests { field a = 1 a[32 + x][55] = y for field i in 0..3 do - a == 1 + 2 + 3+ 4+ 5+ 6+ 6+ 7+ 8 + 4+ 5+ 3+ 4+ 2+ 3 + assert(a == 1 + 2 + 3+ 4+ 5+ 6+ 6+ 7+ 8 + 4+ 5+ 3+ 4+ 2+ 3) endfor - a.member == 1 + assert(a.member == 1) return a "#; let res = generate_ast(&source); diff --git a/zokrates_stdlib/stdlib/ecc/edwardsOnCurve.zok b/zokrates_stdlib/stdlib/ecc/edwardsOnCurve.zok index fa42e1a4..2fc71e66 100644 --- a/zokrates_stdlib/stdlib/ecc/edwardsOnCurve.zok +++ b/zokrates_stdlib/stdlib/ecc/edwardsOnCurve.zok @@ -4,7 +4,7 @@ from "ecc/babyjubjubParams" import BabyJubJubParams // Curve parameters are defined with the last argument // See appendix 3.3.1 of Zcash protocol specification: // https://github.com/zcash/zips/blob/master/protocol/protocol.pdf -def main(field[2] pt, BabyJubJubParams context) -> (field): +def main(field[2] pt, BabyJubJubParams context) -> (bool): field a = context.JUBJUBA field d = context.JUBJUBD @@ -13,6 +13,6 @@ def main(field[2] pt, BabyJubJubParams context) -> (field): field vv = pt[1] * pt[1] field uuvv = uu * vv - a * uu + vv == 1 + d * uuvv + assert(a * uu + vv == 1 + d * uuvv) - return 1 + return true diff --git a/zokrates_stdlib/stdlib/ecc/edwardsOrderCheck.zok b/zokrates_stdlib/stdlib/ecc/edwardsOrderCheck.zok index 9fa4d275..cd92016c 100644 --- a/zokrates_stdlib/stdlib/ecc/edwardsOrderCheck.zok +++ b/zokrates_stdlib/stdlib/ecc/edwardsOrderCheck.zok @@ -6,14 +6,14 @@ from "ecc/babyjubjubParams" import BabyJubJubParams // Verifies that the point is not one of the low-order points. // If any of the points is multiplied by the cofactor, the resulting point // will be infinity. -// Returns 1 if the point is not one of the low-order points, 0 otherwise. +// Returns true if the point is not one of the low-order points, false otherwise. // Curve parameters are defined with the last argument // https://github.com/zcash-hackworks/sapling-crypto/blob/master/src/jubjub/edwards.rs#L166 -def main(field[2] pt, BabyJubJubParams context) -> (field): +def main(field[2] pt, BabyJubJubParams context) -> (bool): field cofactor = context.JUBJUBC - cofactor == 8 + assert(cofactor == 8) // Co-factor currently hard-coded to 8 for efficiency reasons // See discussion here: https://github.com/Zokrates/ZoKrates/pull/301#discussion_r267203391 @@ -24,6 +24,4 @@ def main(field[2] pt, BabyJubJubParams context) -> (field): ptExp = add(ptExp, ptExp, context) // 4*pt ptExp = add(ptExp, ptExp, context) // 8*pt - field out = if ptExp[0] == 0 && ptExp[1] == 1 then 0 else 1 fi - - return out + return !(ptExp[0] == 0 && ptExp[1] == 1) diff --git a/zokrates_stdlib/stdlib/ecc/edwardsScalarMult.zok b/zokrates_stdlib/stdlib/ecc/edwardsScalarMult.zok index 413a7e69..5c6b7a5c 100644 --- a/zokrates_stdlib/stdlib/ecc/edwardsScalarMult.zok +++ b/zokrates_stdlib/stdlib/ecc/edwardsScalarMult.zok @@ -1,5 +1,5 @@ import "ecc/edwardsAdd" as add -import "ecc/edwardsOnCurve" as assertOnCurve +import "ecc/edwardsOnCurve" as onCurve from "ecc/babyjubjubParams" import BabyJubJubParams // Function that implements scalar multiplication for a fixed base point @@ -22,6 +22,6 @@ def main(bool[256] exponent, field[2] pt, BabyJubJubParams context) -> (field[2] doubledP = add(doubledP, doubledP, context) endfor - 1 == assertOnCurve(accumulatedP, context) + assert(onCurve(accumulatedP, context)) return accumulatedP \ No newline at end of file diff --git a/zokrates_stdlib/stdlib/signatures/verifyEddsa.zok b/zokrates_stdlib/stdlib/signatures/verifyEddsa.zok index b1b03c5a..a5367667 100644 --- a/zokrates_stdlib/stdlib/signatures/verifyEddsa.zok +++ b/zokrates_stdlib/stdlib/signatures/verifyEddsa.zok @@ -34,9 +34,8 @@ def main(private field[2] R, private field S, field[2] A, u32[8] M0, u32[8] M1, field[2] G = [context.Gu, context.Gv] // Check if R is on curve and if it is not in a small subgroup. A is public input and can be checked offline - field isOnCurve = onCurve(R, context) // throws if R is not on curve - field isPrimeOrder = orderCheck(R, context) - 1 == isPrimeOrder + assert(onCurve(R, context)) // throws if R is not on curve + assert(orderCheck(R, context)) u32[8] Rx = unpack256u(R[0]) u32[8] Ax = unpack256u(A[0]) diff --git a/zokrates_stdlib/stdlib/utils/pack/bool/unpack128.zok b/zokrates_stdlib/stdlib/utils/pack/bool/unpack128.zok index 7d3a3ce2..6a7eb5b4 100644 --- a/zokrates_stdlib/stdlib/utils/pack/bool/unpack128.zok +++ b/zokrates_stdlib/stdlib/utils/pack/bool/unpack128.zok @@ -6,6 +6,6 @@ def main(field i) -> (bool[128]): bool[254] b = unpack(i) - b[0..126] == [false; 126] + assert(b[0..126] == [false; 126]) return b[126..254] \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/ecc/edwardsAdd.json b/zokrates_stdlib/tests/tests/ecc/edwardsAdd.json index 0075440a..2ff3bf0a 100644 --- a/zokrates_stdlib/tests/tests/ecc/edwardsAdd.json +++ b/zokrates_stdlib/tests/tests/ecc/edwardsAdd.json @@ -8,7 +8,7 @@ }, "output": { "Ok": { - "values": ["1"] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/ecc/edwardsAdd.zok b/zokrates_stdlib/tests/tests/ecc/edwardsAdd.zok index 48866390..9d3fe6b3 100644 --- a/zokrates_stdlib/tests/tests/ecc/edwardsAdd.zok +++ b/zokrates_stdlib/tests/tests/ecc/edwardsAdd.zok @@ -5,34 +5,34 @@ from "ecc/babyjubjubParams" import BabyJubJubParams // Code to create test cases: // https://github.com/Zokrates/pycrypto -def testDoubleViaAdd() -> (field): +def testDoubleViaAdd() -> (bool): BabyJubJubParams context = context() field[2] G = [context.Gu, context.Gv] field[2] out = add(G, G, context) - out[0] == 17324563846726889236817837922625232543153115346355010501047597319863650987830 - out[1] == 20022170825455209233733649024450576091402881793145646502279487074566492066831 + assert(out[0] == 17324563846726889236817837922625232543153115346355010501047597319863650987830) + assert(out[1] == 20022170825455209233733649024450576091402881793145646502279487074566492066831) - return 1 + return true -def testIdentities() -> (field): +def testIdentities() -> (bool): BabyJubJubParams context = context() field[2] G = [context.Gu, context.Gv] field[2] inf = context.INFINITY - G == add(G, inf, context) + assert(G == add(G, inf, context)) field[2] nG = neg(G) field[2] nGaddG = add(G, nG, context) - inf == nGaddG + assert(inf == nGaddG) - return 1 + return true -def main() -> (field): +def main() -> (): - 1 == testDoubleViaAdd() - 1 == testIdentities() + assert(testDoubleViaAdd()) + assert(testIdentities()) -return 1 \ No newline at end of file + return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/ecc/edwardsCompress.json b/zokrates_stdlib/tests/tests/ecc/edwardsCompress.json index f0a5e6e3..53f4fbf6 100644 --- a/zokrates_stdlib/tests/tests/ecc/edwardsCompress.json +++ b/zokrates_stdlib/tests/tests/ecc/edwardsCompress.json @@ -8,7 +8,7 @@ }, "output": { "Ok": { - "values": ["1"] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/ecc/edwardsCompress.zok b/zokrates_stdlib/tests/tests/ecc/edwardsCompress.zok index c13e36d5..be2d054f 100644 --- a/zokrates_stdlib/tests/tests/ecc/edwardsCompress.zok +++ b/zokrates_stdlib/tests/tests/ecc/edwardsCompress.zok @@ -4,7 +4,7 @@ from "ecc/babyjubjubParams" import BabyJubJubParams // Code to create test cases: // https://github.com/Zokrates/pycrypto -def testCompress() -> (field): +def testCompress() -> (bool): BabyJubJubParams context = context() field Gu = context.Gu @@ -12,12 +12,12 @@ def testCompress() -> (field): bool[256] Gcompressed = edwardsCompress([Gu, Gv]) - Gcompressed == [true, false, true, false, true, true, true, false, false, false, false, false, false, true, true, true, false, false, true, false, true, false, false, true, false, true, true, true, true, true, true, true, true, false, false, false, true, true, false, true, false, false, true, true, true, true, false, false, false, false, true, true, true, true, false, true, false, true, true, true, true, false, false, false, false, false, false, true, true, false, false, false, true, true, false, true, true, false, true, true, true, true, false, true, true, true, false, true, true, true, true, true, true, true, false, true, false, false, true, false, false, true, false, false, true, true, false, false, false, false, true, true, false, true, false, true, false, true, false, true, true, false, false, false, false, false, true, true, true, true, true, true, true, false, false, true, true, false, true, false, true, false, false, true, true, true, false, true, false, true, false, false, true, true, true, false, true, true, false, true, false, false, false, false, true, true, false, false, true, false, true, true, false, false, false, false, true, true, false, false, false, false, false, true, true, true, false, true, false, false, false, true, false, false, true, true, false, true, false, false, true, false, false, false, true, true, false, true, true, true, false, true, true, false, false, false, true, true, true, true, false, true, true, true, true, true, true, true, true, false, false, true, true, false, false, true, false, false, false, true, false, true, false, true, false, false, true, false, true, true, false, true, false, true, true, true] + assert(Gcompressed == [true, false, true, false, true, true, true, false, false, false, false, false, false, true, true, true, false, false, true, false, true, false, false, true, false, true, true, true, true, true, true, true, true, false, false, false, true, true, false, true, false, false, true, true, true, true, false, false, false, false, true, true, true, true, false, true, false, true, true, true, true, false, false, false, false, false, false, true, true, false, false, false, true, true, false, true, true, false, true, true, true, true, false, true, true, true, false, true, true, true, true, true, true, true, false, true, false, false, true, false, false, true, false, false, true, true, false, false, false, false, true, true, false, true, false, true, false, true, false, true, true, false, false, false, false, false, true, true, true, true, true, true, true, false, false, true, true, false, true, false, true, false, false, true, true, true, false, true, false, true, false, false, true, true, true, false, true, true, false, true, false, false, false, false, true, true, false, false, true, false, true, true, false, false, false, false, true, true, false, false, false, false, false, true, true, true, false, true, false, false, false, true, false, false, true, true, false, true, false, false, true, false, false, false, true, true, false, true, true, true, false, true, true, false, false, false, true, true, true, true, false, true, true, true, true, true, true, true, true, false, false, true, true, false, false, true, false, false, false, true, false, true, false, true, false, false, true, false, true, true, false, true, false, true, true, true]) - return 1 + return true -def main() -> (field): +def main() -> (): - 1 == testCompress() + assert(testCompress()) - return 1 \ No newline at end of file + return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/ecc/edwardsOnCurve.json b/zokrates_stdlib/tests/tests/ecc/edwardsOnCurve.json index 72f134a3..ec61ed51 100644 --- a/zokrates_stdlib/tests/tests/ecc/edwardsOnCurve.json +++ b/zokrates_stdlib/tests/tests/ecc/edwardsOnCurve.json @@ -8,7 +8,7 @@ }, "output": { "Ok": { - "values": ["1"] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/ecc/edwardsOnCurve.zok b/zokrates_stdlib/tests/tests/ecc/edwardsOnCurve.zok index 8ac5b6ba..e25c0415 100644 --- a/zokrates_stdlib/tests/tests/ecc/edwardsOnCurve.zok +++ b/zokrates_stdlib/tests/tests/ecc/edwardsOnCurve.zok @@ -4,19 +4,19 @@ import "ecc/edwardsOnCurve" as onCurve // Code to create test cases: // https://github.com/Zokrates/pycrypto -def testOnCurveTrue() -> (field): +def testOnCurveTrue() -> (bool): BabyJubJubParams context = context() field testU = 17324563846726889236817837922625232543153115346355010501047597319863650987830 field testV = 20022170825455209233733649024450576091402881793145646502279487074566492066831 - 1 == onCurve([testU, testV], context) + assert(onCurve([testU, testV], context)) - return 1 + return true -def main() -> (field): +def main() -> (): - 1 == testOnCurveTrue() + assert(testOnCurveTrue()) // onCurve throws for false - return 1 + return diff --git a/zokrates_stdlib/tests/tests/ecc/edwardsOrderCheck.json b/zokrates_stdlib/tests/tests/ecc/edwardsOrderCheck.json index bb221950..07768ffc 100644 --- a/zokrates_stdlib/tests/tests/ecc/edwardsOrderCheck.json +++ b/zokrates_stdlib/tests/tests/ecc/edwardsOrderCheck.json @@ -8,7 +8,7 @@ }, "output": { "Ok": { - "values": ["1"] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/ecc/edwardsOrderCheck.zok b/zokrates_stdlib/tests/tests/ecc/edwardsOrderCheck.zok index eb0ca612..aa98d2c6 100644 --- a/zokrates_stdlib/tests/tests/ecc/edwardsOrderCheck.zok +++ b/zokrates_stdlib/tests/tests/ecc/edwardsOrderCheck.zok @@ -4,31 +4,31 @@ from "ecc/babyjubjubParams" import BabyJubJubParams // Code to create test cases: // https://github.com/Zokrates/pycrypto -def testOrderCheckTrue() -> (field): +def testOrderCheckTrue() -> (bool): BabyJubJubParams context = context() field testU = 17324563846726889236817837922625232543153115346355010501047597319863650987830 field testV = 20022170825455209233733649024450576091402881793145646502279487074566492066831 - field out = orderCheck([testU, testV], context) - out == 1 + bool out = orderCheck([testU, testV], context) + assert(out) - return 1 + return true -def testOrderCheckFalse() -> (field): +def testOrderCheckFalse() -> (bool): BabyJubJubParams context = context() field testU = 4342719913949491028786768530115087822524712248835451589697801404893164183326 field testV = 4826523245007015323400664741523384119579596407052839571721035538011798951543 - field out = orderCheck([testU, testV], context) - out == 0 + bool out = orderCheck([testU, testV], context) + assert(!out) - return 1 + return true -def main() -> (field): +def main() -> (): - 1 == testOrderCheckFalse() - 1 == testOrderCheckTrue() + assert(testOrderCheckFalse()) + assert(testOrderCheckTrue()) - return 1 \ No newline at end of file + return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/ecc/edwardsScalarMult.json b/zokrates_stdlib/tests/tests/ecc/edwardsScalarMult.json index a9873c76..f2743f66 100644 --- a/zokrates_stdlib/tests/tests/ecc/edwardsScalarMult.json +++ b/zokrates_stdlib/tests/tests/ecc/edwardsScalarMult.json @@ -8,7 +8,7 @@ }, "output": { "Ok": { - "values": ["1"] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/ecc/edwardsScalarMult.zok b/zokrates_stdlib/tests/tests/ecc/edwardsScalarMult.zok index 8fa9415b..93c42a55 100644 --- a/zokrates_stdlib/tests/tests/ecc/edwardsScalarMult.zok +++ b/zokrates_stdlib/tests/tests/ecc/edwardsScalarMult.zok @@ -4,7 +4,7 @@ import "ecc/edwardsScalarMult" as mul // Code to create test cases: // https://github.com/Zokrates/pycrypto -def testCyclic() -> (field): +def testCyclic() -> (bool): BabyJubJubParams context = context() field[2] G = [context.Gu, context.Gv] @@ -13,11 +13,11 @@ def testCyclic() -> (field): field[2] out = mul(exp, G, context) - G == out + assert(G == out) - return 1 + return true -def testMul2() -> (field): +def testMul2() -> (bool): BabyJubJubParams context = context() field[2] G = [context.Gu, context.Gv] @@ -25,12 +25,12 @@ def testMul2() -> (field): bool[256] exp = [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false] field[2] out = mul(exp, G, context) - out[0] == 17324563846726889236817837922625232543153115346355010501047597319863650987830 - out[1] == 20022170825455209233733649024450576091402881793145646502279487074566492066831 + assert(out[0] == 17324563846726889236817837922625232543153115346355010501047597319863650987830) + assert(out[1] == 20022170825455209233733649024450576091402881793145646502279487074566492066831) - return 1 + return true -def testAssociativity() -> (field): +def testAssociativity() -> (bool): BabyJubJubParams context = context() field[2] G = [context.Gu, context.Gv] @@ -55,13 +55,13 @@ def testAssociativity() -> (field): field[2] Gca = mul(a, Gc, context) field[2] Gcab = mul(b, Gca, context) - Gabc == Gbca - Gbca == Gcab - Gabc == Gcab + assert(Gabc == Gbca) + assert(Gbca == Gcab) + assert(Gabc == Gcab) - return 1 + return true -def testMultiplicative() -> (field): +def testMultiplicative() -> (bool): BabyJubJubParams context = context() field[2] G = [context.Gu, context.Gv] @@ -81,16 +81,16 @@ def testMultiplicative() -> (field): field[2] Gmab = mul(ab, G, context) - Gab == Gba - Gba == Gmab - Gab == Gmab + assert(Gab == Gba) + assert(Gba == Gmab) + assert(Gab == Gmab) - return 1 + return true -def main() -> (field): - 1 == testMul2() - 1 == testCyclic() - 1 == testAssociativity() - 1 == testMultiplicative() +def main() -> (): + assert(testMul2()) + assert(testCyclic()) + assert(testAssociativity()) + assert(testMultiplicative()) - return 1 \ No newline at end of file + return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/ecc/proofOfOwnership.json b/zokrates_stdlib/tests/tests/ecc/proofOfOwnership.json index 0519fc03..779793e5 100644 --- a/zokrates_stdlib/tests/tests/ecc/proofOfOwnership.json +++ b/zokrates_stdlib/tests/tests/ecc/proofOfOwnership.json @@ -8,7 +8,7 @@ }, "output": { "Ok": { - "values": ["1"] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/ecc/proofOfOwnership.zok b/zokrates_stdlib/tests/tests/ecc/proofOfOwnership.zok index 4e99b22d..11f18dc7 100644 --- a/zokrates_stdlib/tests/tests/ecc/proofOfOwnership.zok +++ b/zokrates_stdlib/tests/tests/ecc/proofOfOwnership.zok @@ -5,7 +5,7 @@ import "ecc/edwardsScalarMult" as multiply // Code to create test cases: // https://github.com/Zokrates/pycrypto -def testOwnershipTrue() -> (field): +def testOwnershipTrue() -> (bool): BabyJubJubParams context = context() field[2] G = [context.Gu, context.Gv] @@ -14,22 +14,22 @@ def testOwnershipTrue() -> (field): bool out = proofOfOwnership(Pk, sk, context) - out == true - return 1 + assert(out) + return true -def testtOwnershipFalse() -> (field): +def testtOwnershipFalse() -> (bool): BabyJubJubParams context = context() field[2] Pk = [16328093915569409528980874702678312730273137210288183490878184636452430630129, 9377227749598842756429258362864743065769435972445705966557343775367597326529] field sk = 1997011358982923168928344992199991480689546837621580239342656433234255379025 bool out = proofOfOwnership(Pk, sk, context) - out == false - return 1 + assert(!out) + return true -def main() -> (field): +def main() -> (): - 1 == testOwnershipTrue() - 1 == testtOwnershipFalse() + assert(testOwnershipTrue()) + assert(testtOwnershipFalse()) - return 1 \ No newline at end of file + return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R10.json b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R10.json index dd3d824d..b37df2d6 100644 --- a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R10.json +++ b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R10.json @@ -7,9 +7,7 @@ }, "output": { "Ok": { - "values": [ - "1" - ] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R10.zok b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R10.zok index bd2c2a5e..c1f686b8 100644 --- a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R10.zok +++ b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R10.zok @@ -1,9 +1,9 @@ import "hashes/mimc7/mimc7R10" -def main() -> (field): - mimc7R10(0, 0) == 6004544488495356385698286530147974336054653445122716140990101827963729149289 - mimc7R10(100, 0) == 2977550761518141183167168643824354554080911485709001361112529600968315693145 - mimc7R10(100, 21888242871839275222246405745257275088548364400416034343698204186575808495617) == 2977550761518141183167168643824354554080911485709001361112529600968315693145 - mimc7R10(21888242871839275222246405745257275088548364400416034343698204186575808495618, 1) == 11476724043755138071320043459606423473319855817296339514744600646762741571430 - mimc7R10(21888242871839275222246405745257275088548364400416034343698204186575808495617, 21888242871839275222246405745257275088548364400416034343698204186575808495617) == 6004544488495356385698286530147974336054653445122716140990101827963729149289 - return 1 \ No newline at end of file +def main() -> (): + assert(mimc7R10(0, 0) == 6004544488495356385698286530147974336054653445122716140990101827963729149289) + assert(mimc7R10(100, 0) == 2977550761518141183167168643824354554080911485709001361112529600968315693145) + assert(mimc7R10(100, 21888242871839275222246405745257275088548364400416034343698204186575808495617) == 2977550761518141183167168643824354554080911485709001361112529600968315693145) + assert(mimc7R10(21888242871839275222246405745257275088548364400416034343698204186575808495618, 1) == 11476724043755138071320043459606423473319855817296339514744600646762741571430) + assert(mimc7R10(21888242871839275222246405745257275088548364400416034343698204186575808495617, 21888242871839275222246405745257275088548364400416034343698204186575808495617) == 6004544488495356385698286530147974336054653445122716140990101827963729149289) + return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R20.json b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R20.json index 62eef0bd..d5b121ba 100644 --- a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R20.json +++ b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R20.json @@ -7,9 +7,7 @@ }, "output": { "Ok": { - "values": [ - "1" - ] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R20.zok b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R20.zok index dea4c87d..9e2047d1 100644 --- a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R20.zok +++ b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R20.zok @@ -1,9 +1,9 @@ import "hashes/mimc7/mimc7R20" -def main() -> (field): - mimc7R20(0, 0) == 19139739902058628561064841933381604453445216873412991992755775746150759284829 - mimc7R20(100, 0) == 8623418512398828792274158979964869393034224267928014534933203776818702139758 - mimc7R20(100, 21888242871839275222246405745257275088548364400416034343698204186575808495617) == 8623418512398828792274158979964869393034224267928014534933203776818702139758 - mimc7R20(21888242871839275222246405745257275088548364400416034343698204186575808495618, 1) == 15315177265066649795408805007175121550344555424263995530745989936206840798041 - mimc7R20(21888242871839275222246405745257275088548364400416034343698204186575808495617, 21888242871839275222246405745257275088548364400416034343698204186575808495617) == 19139739902058628561064841933381604453445216873412991992755775746150759284829 - return 1 \ No newline at end of file +def main() -> (): + assert(mimc7R20(0, 0) == 19139739902058628561064841933381604453445216873412991992755775746150759284829) + assert(mimc7R20(100, 0) == 8623418512398828792274158979964869393034224267928014534933203776818702139758) + assert(mimc7R20(100, 21888242871839275222246405745257275088548364400416034343698204186575808495617) == 8623418512398828792274158979964869393034224267928014534933203776818702139758) + assert(mimc7R20(21888242871839275222246405745257275088548364400416034343698204186575808495618, 1) == 15315177265066649795408805007175121550344555424263995530745989936206840798041) + assert(mimc7R20(21888242871839275222246405745257275088548364400416034343698204186575808495617, 21888242871839275222246405745257275088548364400416034343698204186575808495617) == 19139739902058628561064841933381604453445216873412991992755775746150759284829) + return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R50.json b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R50.json index 84919fff..37933e80 100644 --- a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R50.json +++ b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R50.json @@ -7,9 +7,7 @@ }, "output": { "Ok": { - "values": [ - "1" - ] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R50.zok b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R50.zok index b799d34e..6c25fc3a 100644 --- a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R50.zok +++ b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R50.zok @@ -1,9 +1,9 @@ import "hashes/mimc7/mimc7R50" -def main() -> (field): - mimc7R50(0, 0) == 3049953358280347916081509186284461274525472221619157672645224540758481713173 - mimc7R50(100, 0) == 18511388995652647480418174218630545482006454713617579894396683237092568946789 - mimc7R50(100, 21888242871839275222246405745257275088548364400416034343698204186575808495617) == 18511388995652647480418174218630545482006454713617579894396683237092568946789 - mimc7R50(21888242871839275222246405745257275088548364400416034343698204186575808495618, 1) == 9149577627043020462780389988155990926223727917856424056384664564191878439702 - mimc7R50(21888242871839275222246405745257275088548364400416034343698204186575808495617, 21888242871839275222246405745257275088548364400416034343698204186575808495617) == 3049953358280347916081509186284461274525472221619157672645224540758481713173 - return 1 \ No newline at end of file +def main() -> (): + assert(mimc7R50(0, 0) == 3049953358280347916081509186284461274525472221619157672645224540758481713173) + assert(mimc7R50(100, 0) == 18511388995652647480418174218630545482006454713617579894396683237092568946789) + assert(mimc7R50(100, 21888242871839275222246405745257275088548364400416034343698204186575808495617) == 18511388995652647480418174218630545482006454713617579894396683237092568946789) + assert(mimc7R50(21888242871839275222246405745257275088548364400416034343698204186575808495618, 1) == 9149577627043020462780389988155990926223727917856424056384664564191878439702) + assert(mimc7R50(21888242871839275222246405745257275088548364400416034343698204186575808495617, 21888242871839275222246405745257275088548364400416034343698204186575808495617) == 3049953358280347916081509186284461274525472221619157672645224540758481713173) + return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R90.json b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R90.json index b3c2b8a5..b5c304e0 100644 --- a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R90.json +++ b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R90.json @@ -7,9 +7,7 @@ }, "output": { "Ok": { - "values": [ - "1" - ] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R90.zok b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R90.zok index 45d6ea9a..0fcceeb7 100644 --- a/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R90.zok +++ b/zokrates_stdlib/tests/tests/hashes/mimc7/mimc7R90.zok @@ -1,9 +1,9 @@ import "hashes/mimc7/mimc7R90" -def main() -> (field): - mimc7R90(0, 0) == 20281265111705407344053532742843085357648991805359414661661476832595822221514 - mimc7R90(100, 0) == 1010054095264022068840870550831559811104631937745987065544478027572003292636 - mimc7R90(100, 21888242871839275222246405745257275088548364400416034343698204186575808495617) == 1010054095264022068840870550831559811104631937745987065544478027572003292636 - mimc7R90(21888242871839275222246405745257275088548364400416034343698204186575808495618, 1) == 8189519586469873426687580455476035992041353456517724932462363814215190642760 - mimc7R90(21888242871839275222246405745257275088548364400416034343698204186575808495617, 21888242871839275222246405745257275088548364400416034343698204186575808495617) == 20281265111705407344053532742843085357648991805359414661661476832595822221514 - return 1 \ No newline at end of file +def main() -> (): + assert(mimc7R90(0, 0) == 20281265111705407344053532742843085357648991805359414661661476832595822221514) + assert(mimc7R90(100, 0) == 1010054095264022068840870550831559811104631937745987065544478027572003292636) + assert(mimc7R90(100, 21888242871839275222246405745257275088548364400416034343698204186575808495617) == 1010054095264022068840870550831559811104631937745987065544478027572003292636) + assert(mimc7R90(21888242871839275222246405745257275088548364400416034343698204186575808495618, 1) == 8189519586469873426687580455476035992041353456517724932462363814215190642760) + assert(mimc7R90(21888242871839275222246405745257275088548364400416034343698204186575808495617, 21888242871839275222246405745257275088548364400416034343698204186575808495617) == 20281265111705407344053532742843085357648991805359414661661476832595822221514) + return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/hashes/mimcSponge/mimcSponge.json b/zokrates_stdlib/tests/tests/hashes/mimcSponge/mimcSponge.json index dedd1b67..98b62d1d 100644 --- a/zokrates_stdlib/tests/tests/hashes/mimcSponge/mimcSponge.json +++ b/zokrates_stdlib/tests/tests/hashes/mimcSponge/mimcSponge.json @@ -7,9 +7,7 @@ }, "output": { "Ok": { - "values": [ - "1" - ] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/hashes/mimcSponge/mimcSponge.zok b/zokrates_stdlib/tests/tests/hashes/mimcSponge/mimcSponge.zok index 9c24b9a6..5785ecee 100644 --- a/zokrates_stdlib/tests/tests/hashes/mimcSponge/mimcSponge.zok +++ b/zokrates_stdlib/tests/tests/hashes/mimcSponge/mimcSponge.zok @@ -1,7 +1,7 @@ import "hashes/mimcSponge/mimcSponge" as mimcSponge -def main() -> (field): - mimcSponge([1,2], 3) == [20225509322021146255705869525264566735642015554514977326536820959638320229084,13871743498877225461925335509899475799121918157213219438898506786048812913771,21633608428713573518356618235457250173701815120501233429160399974209848779097] - mimcSponge([0,0], 0) == [20636625426020718969131298365984859231982649550971729229988535915544421356929,6046202021237334713296073963481784771443313518730771623154467767602059802325,16227963524034219233279650312501310147918176407385833422019760797222680144279] - mimcSponge([21888242871839275222246405745257275088548364400416034343698204186575808495617, 0], 0) == [20636625426020718969131298365984859231982649550971729229988535915544421356929,6046202021237334713296073963481784771443313518730771623154467767602059802325,16227963524034219233279650312501310147918176407385833422019760797222680144279] - return 1 \ No newline at end of file +def main() -> (): + assert(mimcSponge([1,2], 3) == [20225509322021146255705869525264566735642015554514977326536820959638320229084,13871743498877225461925335509899475799121918157213219438898506786048812913771,21633608428713573518356618235457250173701815120501233429160399974209848779097]) + assert(mimcSponge([0,0], 0) == [20636625426020718969131298365984859231982649550971729229988535915544421356929,6046202021237334713296073963481784771443313518730771623154467767602059802325,16227963524034219233279650312501310147918176407385833422019760797222680144279]) + assert(mimcSponge([21888242871839275222246405745257275088548364400416034343698204186575808495617, 0], 0) == [20636625426020718969131298365984859231982649550971729229988535915544421356929,6046202021237334713296073963481784771443313518730771623154467767602059802325,16227963524034219233279650312501310147918176407385833422019760797222680144279]) + return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/hashes/pedersen/512bit.json b/zokrates_stdlib/tests/tests/hashes/pedersen/512bit.json index 6ae7f7e1..79c4aeb1 100644 --- a/zokrates_stdlib/tests/tests/hashes/pedersen/512bit.json +++ b/zokrates_stdlib/tests/tests/hashes/pedersen/512bit.json @@ -8,7 +8,7 @@ }, "output": { "Ok": { - "values": ["1"] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/hashes/pedersen/512bit.zok b/zokrates_stdlib/tests/tests/hashes/pedersen/512bit.zok index 7d7f7fae..bbc04218 100644 --- a/zokrates_stdlib/tests/tests/hashes/pedersen/512bit.zok +++ b/zokrates_stdlib/tests/tests/hashes/pedersen/512bit.zok @@ -14,12 +14,12 @@ import "hashes/pedersen/512bit" as pedersen -def main() -> (field): +def main() -> (): u32[16] e = [0x17d2e6d9, 0x5c74e97c, 0x4bf60cc0, 0xc6a6b417, 0xbafc54e9, 0x205c8080, 0x261f4244, 0x9634d6df, 0x8e7f5e06, 0x6a296ecf, 0x1dc1838c, 0x791c8f5a, 0xee9eca33, 0x2100f189, 0xc96b0288, 0xc6b1501f] u32[8] d = pedersen(e) - d == [0x06dfaca0, 0xd82c07ae, 0x33787b2f, 0x66531802, 0x9f789f16, 0x89218926, 0x29f14d70, 0x2a28280b] + assert(d == [0x06dfaca0, 0xd82c07ae, 0x33787b2f, 0x66531802, 0x9f789f16, 0x89218926, 0x29f14d70, 0x2a28280b]) - return 1 \ No newline at end of file + return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/hashes/pedersen/6bit.json b/zokrates_stdlib/tests/tests/hashes/pedersen/6bit.json index 41f66e25..9d170267 100644 --- a/zokrates_stdlib/tests/tests/hashes/pedersen/6bit.json +++ b/zokrates_stdlib/tests/tests/hashes/pedersen/6bit.json @@ -8,7 +8,7 @@ }, "output": { "Ok": { - "values": ["1"] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/hashes/pedersen/6bit.zok b/zokrates_stdlib/tests/tests/hashes/pedersen/6bit.zok index d81c875e..80413fa2 100644 --- a/zokrates_stdlib/tests/tests/hashes/pedersen/6bit.zok +++ b/zokrates_stdlib/tests/tests/hashes/pedersen/6bit.zok @@ -8,12 +8,12 @@ import "hashes/pedersen/6bit" as pedersen -def main() -> (field): +def main() -> (): bool[6] e = [true, true, false, false, false, false] field[2] d = pedersen(e) - 5483803361072598088157572477433311028290255512997784196805059543720485966024 == d[0] - 8712718144085345152615259409576985937188455136179509057889474614313734076278 == d[1] + assert(5483803361072598088157572477433311028290255512997784196805059543720485966024 == d[0]) + assert(8712718144085345152615259409576985937188455136179509057889474614313734076278 == d[1]) - return 1 \ No newline at end of file + return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/hashes/sha256/1024bitPadded.json b/zokrates_stdlib/tests/tests/hashes/sha256/1024bitPadded.json index 2798cee6..503a8945 100644 --- a/zokrates_stdlib/tests/tests/hashes/sha256/1024bitPadded.json +++ b/zokrates_stdlib/tests/tests/hashes/sha256/1024bitPadded.json @@ -7,7 +7,7 @@ }, "output": { "Ok": { - "values": ["1"] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/hashes/sha256/1024bitPadded.zok b/zokrates_stdlib/tests/tests/hashes/sha256/1024bitPadded.zok index 6b428be2..ab7e2064 100644 --- a/zokrates_stdlib/tests/tests/hashes/sha256/1024bitPadded.zok +++ b/zokrates_stdlib/tests/tests/hashes/sha256/1024bitPadded.zok @@ -15,7 +15,7 @@ // bin(int(digest, 16)) // # '0b1110111110100100000111001010010010100101110001110110101101001001010111010101010111011111110110111111100100010111010100110010000001000000010010110011110010000000010010001011001110001110101100011000011100111010101001100110001100111010001101100011100010000011' import "hashes/sha256/1024bitPadded" as sha256 -def main() -> (field): +def main() -> (): u32[8] a = [0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000] u32[8] b = [0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000] @@ -24,6 +24,6 @@ def main() -> (field): u32[8] digest = sha256(a, b, c, d) - digest == [0xefa41ca4, 0xa5c76b49, 0x5d55dfdb, 0xf9175320, 0x404b3c80, 0x48b38eb1, 0x873aa663, 0x3a363883] + assert(digest == [0xefa41ca4, 0xa5c76b49, 0x5d55dfdb, 0xf9175320, 0x404b3c80, 0x48b38eb1, 0x873aa663, 0x3a363883]) - return 1 \ No newline at end of file + return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/hashes/sha256/512bit.json b/zokrates_stdlib/tests/tests/hashes/sha256/512bit.json index 3929ee11..64bd9658 100644 --- a/zokrates_stdlib/tests/tests/hashes/sha256/512bit.json +++ b/zokrates_stdlib/tests/tests/hashes/sha256/512bit.json @@ -8,7 +8,7 @@ }, "output": { "Ok": { - "values": ["1"] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/hashes/sha256/512bit.zok b/zokrates_stdlib/tests/tests/hashes/sha256/512bit.zok index 64fdf1f6..d68e2e25 100644 --- a/zokrates_stdlib/tests/tests/hashes/sha256/512bit.zok +++ b/zokrates_stdlib/tests/tests/hashes/sha256/512bit.zok @@ -1,11 +1,11 @@ import "hashes/sha256/512bit" as sha256 -def main() -> (field): +def main() -> (): u32[8] a = [0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89] u32[8] b = [0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c, 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917] u32[8] digest = sha256(a, b) -digest == [0xcf0ae4eb, 0x67d38ffe, 0xb9406898, 0x4b22abde, 0x4e92bc54, 0x8d14585e, 0x48dca888, 0x2d7b09ce] +assert(digest == [0xcf0ae4eb, 0x67d38ffe, 0xb9406898, 0x4b22abde, 0x4e92bc54, 0x8d14585e, 0x48dca888, 0x2d7b09ce]) -return 1 \ No newline at end of file +return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/hashes/sha256/512bitPacked.zok b/zokrates_stdlib/tests/tests/hashes/sha256/512bitPacked.zok index 7387fe09..80ef3436 100644 --- a/zokrates_stdlib/tests/tests/hashes/sha256/512bitPacked.zok +++ b/zokrates_stdlib/tests/tests/hashes/sha256/512bitPacked.zok @@ -16,7 +16,7 @@ // # 65303172752238645975888084098459749904 import "hashes/sha256/512bitPacked" as sha256packed -def main() -> (field): +def main() -> (): field a = 0 field b = 0 @@ -25,7 +25,7 @@ def main() -> (field): field[2] h = sha256packed([a, b, c, d]) - h[0] == 263561599766550617289250058199814760685 - h[1] == 65303172752238645975888084098459749904 + assert(h[0] == 263561599766550617289250058199814760685) + assert(h[1] == 65303172752238645975888084098459749904) - return 1 \ No newline at end of file + return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/hashes/sha256/512bitPacked2.json b/zokrates_stdlib/tests/tests/hashes/sha256/512bitPacked2.json index dfe7af8c..c4d22fc2 100644 --- a/zokrates_stdlib/tests/tests/hashes/sha256/512bitPacked2.json +++ b/zokrates_stdlib/tests/tests/hashes/sha256/512bitPacked2.json @@ -8,7 +8,7 @@ }, "output": { "Ok": { - "values": ["1"] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/hashes/sha256/512bitPadded.json b/zokrates_stdlib/tests/tests/hashes/sha256/512bitPadded.json index d34c5ebb..8345033f 100644 --- a/zokrates_stdlib/tests/tests/hashes/sha256/512bitPadded.json +++ b/zokrates_stdlib/tests/tests/hashes/sha256/512bitPadded.json @@ -8,7 +8,7 @@ }, "output": { "Ok": { - "values": ["1"] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/hashes/sha256/512bitPadded.zok b/zokrates_stdlib/tests/tests/hashes/sha256/512bitPadded.zok index 72bdeb51..46ac6f51 100644 --- a/zokrates_stdlib/tests/tests/hashes/sha256/512bitPadded.zok +++ b/zokrates_stdlib/tests/tests/hashes/sha256/512bitPadded.zok @@ -13,14 +13,13 @@ // bin(int(digest, 16)) // # '0b1100011001001000000111100010001011000101111111110100000101100100101011110110100000001011100011001111101010100101111010001110110100110001001000001110111011111111100010011100010011110011000001111100010010100110111110101010101011100000010110011100111000010000' import "hashes/sha256/512bitPadded" as sha256 -def main() -> (field): +def main() -> (): u32[8] a = [0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000] u32[8] b = [0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000005] u32[8] digest = sha256(a, b) - digest == [0xc6481e22, 0xc5ff4164, 0xaf680b8c, 0xfaa5e8ed, 0x3120eeff, 0x89c4f307, 0xc4a6faaa, 0xe059ce10] + assert(digest == [0xc6481e22, 0xc5ff4164, 0xaf680b8c, 0xfaa5e8ed, 0x3120eeff, 0x89c4f307, 0xc4a6faaa, 0xe059ce10]) - - return 1 \ No newline at end of file + return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/hashes/utils/256bitsDirectionHelper.json b/zokrates_stdlib/tests/tests/hashes/utils/256bitsDirectionHelper.json index 3bb02726..a9475c28 100644 --- a/zokrates_stdlib/tests/tests/hashes/utils/256bitsDirectionHelper.json +++ b/zokrates_stdlib/tests/tests/hashes/utils/256bitsDirectionHelper.json @@ -8,7 +8,7 @@ }, "output": { "Ok": { - "values": ["1"] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/hashes/utils/256bitsDirectionHelper.zok b/zokrates_stdlib/tests/tests/hashes/utils/256bitsDirectionHelper.zok index ec692b88..0e8ab54d 100644 --- a/zokrates_stdlib/tests/tests/hashes/utils/256bitsDirectionHelper.zok +++ b/zokrates_stdlib/tests/tests/hashes/utils/256bitsDirectionHelper.zok @@ -14,27 +14,27 @@ import "hashes/utils/256bitsDirectionHelper" as direction -def left() -> (field): +def left() -> (bool): u32[8] a = [0x1b19dea8, 0xba4e3c16, 0x43eb67a4, 0x2667fd3c, 0xc50a189f, 0x54977e2f, 0x8ab0beee, 0x332b2a38] u32[8] b = [0x03f3f628, 0xe067520d, 0x9a36f714, 0xa5ba86cd, 0x2dbcae1d, 0x37e034b3, 0x84786de3, 0xedb8b557] u32[16] out = direction(false, a, b) out == [0x1b19dea8, 0xba4e3c16, 0x43eb67a4, 0x2667fd3c, 0xc50a189f, 0x54977e2f, 0x8ab0beee, 0x332b2a38, 0x03f3f628, 0xe067520d, 0x9a36f714, 0xa5ba86cd, 0x2dbcae1d, 0x37e034b3, 0x84786de3, 0xedb8b557] - return 1 + return true -def right() -> (field): +def right() -> (bool): u32[8] a = [0x1b19dea8, 0xba4e3c16, 0x43eb67a4, 0x2667fd3c, 0xc50a189f, 0x54977e2f, 0x8ab0beee, 0x332b2a38] u32[8] b = [0x03f3f628, 0xe067520d, 0x9a36f714, 0xa5ba86cd, 0x2dbcae1d, 0x37e034b3, 0x84786de3, 0xedb8b557] u32[16] out = direction(true, a, b) - out == [0x03f3f628, 0xe067520d, 0x9a36f714, 0xa5ba86cd, 0x2dbcae1d, 0x37e034b3, 0x84786de3, 0xedb8b557, 0x1b19dea8, 0xba4e3c16, 0x43eb67a4, 0x2667fd3c, 0xc50a189f, 0x54977e2f, 0x8ab0beee, 0x332b2a38] - return 1 + assert(out == [0x03f3f628, 0xe067520d, 0x9a36f714, 0xa5ba86cd, 0x2dbcae1d, 0x37e034b3, 0x84786de3, 0xedb8b557, 0x1b19dea8, 0xba4e3c16, 0x43eb67a4, 0x2667fd3c, 0xc50a189f, 0x54977e2f, 0x8ab0beee, 0x332b2a38]) + return true -def main() -> (field): +def main() -> (): - left() == 1 - right() == 1 + assert(left()) + assert(right()) - return 1 \ No newline at end of file + return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/signatures/verifyEddsa.json b/zokrates_stdlib/tests/tests/signatures/verifyEddsa.json index 3bb73523..f6b36bc0 100644 --- a/zokrates_stdlib/tests/tests/signatures/verifyEddsa.json +++ b/zokrates_stdlib/tests/tests/signatures/verifyEddsa.json @@ -8,7 +8,7 @@ }, "output": { "Ok": { - "values": ["1"] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/signatures/verifyEddsa.zok b/zokrates_stdlib/tests/tests/signatures/verifyEddsa.zok index 0e01b84f..b67471df 100644 --- a/zokrates_stdlib/tests/tests/signatures/verifyEddsa.zok +++ b/zokrates_stdlib/tests/tests/signatures/verifyEddsa.zok @@ -4,7 +4,7 @@ from "ecc/babyjubjubParams" import BabyJubJubParams // Code to create test case: // https://github.com/Zokrates/pycrypto -def main() -> (field): +def main() -> (): BabyJubJubParams context = context() @@ -18,6 +18,6 @@ def main() -> (field): u32[8] M1 = [0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000005] bool isVerified = verifyEddsa(R, S, A, M0, M1, context) - isVerified == true + assert(isVerified) - return 1 \ No newline at end of file + return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/utils/multiplexer/256bit.json b/zokrates_stdlib/tests/tests/utils/multiplexer/256bit.json index 3a9fb8dd..420e1c27 100644 --- a/zokrates_stdlib/tests/tests/utils/multiplexer/256bit.json +++ b/zokrates_stdlib/tests/tests/utils/multiplexer/256bit.json @@ -8,7 +8,7 @@ }, "output": { "Ok": { - "values": ["1"] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/utils/multiplexer/256bit.zok b/zokrates_stdlib/tests/tests/utils/multiplexer/256bit.zok index 864b059d..a3b90703 100644 --- a/zokrates_stdlib/tests/tests/utils/multiplexer/256bit.zok +++ b/zokrates_stdlib/tests/tests/utils/multiplexer/256bit.zok @@ -1,32 +1,42 @@ import "utils/multiplexer/256bit" as multiplex -def left() -> (field): +def left() -> (bool): bool bit = false //left u32[8] a = [0x1b19dea8, 0xba4e3c16, 0x43eb67a4, 0x2667fd3c, 0xc50a189f, 0x54977e2f, 0x8ab0beee, 0x332b2a38] u32[8] b = [0x03f3f628, 0xe067520d, 0x9a36f714, 0xa5ba86cd, 0x2dbcae1d, 0x37e034b3, 0x84786de3, 0xedb8b557] +<<<<<<< HEAD u32[8] output = [0x1b19dea8, 0xba4e3c16, 0x43eb67a4, 0x2667fd3c, 0xc50a189f, 0x54977e2f, 0x8ab0beee, 0x332b2a38] output == multiplex(bit, a, b) +======= + bool[256] output = [false, false, false, true, true, false, true, true, false, false, false, true, true, false, false, true, true, true, false, true, true, true, true, false, true, false, true, false, true, false, false, false, true, false, true, true, true, false, true, false, false, true, false, false, true, true, true, false, false, false, true, true, true, true, false, false, false, false, false, true, false, true, true, false, false, true, false, false, false, false, true, true, true, true, true, false, true, false, true, true, false, true, true, false, false, true, true, true, true, false, true, false, false, true, false, false, false, false, true, false, false, true, true, false, false, true, true, false, false, true, true, true, true, true, true, true, true, true, false, true, false, false, true, true, true, true, false, false, true, true, false, false, false, true, false, true, false, false, false, false, true, false, true, false, false, false, false, true, true, false, false, false, true, false, false, true, true, true, true, true, false, true, false, true, false, true, false, false, true, false, false, true, false, true, true, true, false, true, true, true, true, true, true, false, false, false, true, false, true, true, true, true, true, false, false, false, true, false, true, false, true, false, true, true, false, false, false, false, true, false, true, true, true, true, true, false, true, true, true, false, true, true, true, false, false, false, true, true, false, false, true, true, false, false, true, false, true, false, true, true, false, false, true, false, true, false, true, false, false, false, true, true, true, false, false, false] + assert(output == multiplex(bit, a, b)) +>>>>>>> 26f4d72ee6e0c802823cf145fbd11a372586eb28 - return 1 + return true -def right() -> (field): +def right() -> (bool): bool bit = true //right u32[8] a = [0x1b19dea8, 0xba4e3c16, 0x43eb67a4, 0x2667fd3c, 0xc50a189f, 0x54977e2f, 0x8ab0beee, 0x332b2a38] u32[8] b = [0x03f3f628, 0xe067520d, 0x9a36f714, 0xa5ba86cd, 0x2dbcae1d, 0x37e034b3, 0x84786de3, 0xedb8b557] +<<<<<<< HEAD u32[8] output = [0x03f3f628, 0xe067520d, 0x9a36f714, 0xa5ba86cd, 0x2dbcae1d, 0x37e034b3, 0x84786de3, 0xedb8b557] output == multiplex(bit, a, b) +======= + bool[256] output = [false, false, false, false, false, false, true, true, true, true, true, true, false, false, true, true, true, true, true, true, false, true, true, false, false, false, true, false, true, false, false, false, true, true, true, false, false, false, false, false, false, true, true, false, false, true, true, true, false, true, false, true, false, false, true, false, false, false, false, false, true, true, false, true, true, false, false, true, true, false, true, false, false, false, true, true, false, true, true, false, true, true, true, true, false, true, true, true, false, false, false, true, false, true, false, false, true, false, true, false, false, true, false, true, true, false, true, true, true, false, true, false, true, false, false, false, false, true, true, false, true, true, false, false, true, true, false, true, false, false, true, false, true, true, false, true, true, false, true, true, true, true, false, false, true, false, true, false, true, true, true, false, false, false, false, true, true, true, false, true, false, false, true, true, false, true, true, true, true, true, true, false, false, false, false, false, false, false, true, true, false, true, false, false, true, false, true, true, false, false, true, true, true, false, false, false, false, true, false, false, false, true, true, true, true, false, false, false, false, true, true, false, true, true, false, true, true, true, true, false, false, false, true, true, true, true, true, false, true, true, false, true, true, false, true, true, true, false, false, false, true, false, true, true, false, true, false, true, false, true, false, true, false, true, true, true] + assert(output == multiplex(bit, a, b)) +>>>>>>> 26f4d72ee6e0c802823cf145fbd11a372586eb28 - return 1 + return true -def main() -> (field): +def main() -> (): - 1 == left() - 1 == right() + assert(left()) + assert(right()) - return 1 \ No newline at end of file + return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/utils/multiplexer/2bit.json b/zokrates_stdlib/tests/tests/utils/multiplexer/2bit.json index e228f142..750472d6 100644 --- a/zokrates_stdlib/tests/tests/utils/multiplexer/2bit.json +++ b/zokrates_stdlib/tests/tests/utils/multiplexer/2bit.json @@ -8,7 +8,7 @@ }, "output": { "Ok": { - "values": ["1"] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/utils/multiplexer/2bit.zok b/zokrates_stdlib/tests/tests/utils/multiplexer/2bit.zok index e7a2748f..2e7b1907 100644 --- a/zokrates_stdlib/tests/tests/utils/multiplexer/2bit.zok +++ b/zokrates_stdlib/tests/tests/utils/multiplexer/2bit.zok @@ -1,28 +1,28 @@ import "utils/multiplexer/2bit" as multiplex -def left() -> (field): +def left() -> (bool): bool bit = false //left bool[2] a = [false, true] bool[2] b = [true, false] bool[2] output = [false, true] - output == multiplex(bit, a, b) + assert(output == multiplex(bit, a, b)) - return 1 + return true -def right() -> (field): +def right() -> (bool): bool bit = true //right bool[2] a = [false, true] bool[2] b = [true, false] bool[2] output = [true, false] - output == multiplex(bit, a, b) + assert(output == multiplex(bit, a, b)) - return 1 + return true -def main() -> (field): +def main() -> (): - 1 == left() - 1 == right() + assert(left()) + assert(right()) - return 1 \ No newline at end of file + return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/utils/multiplexer/lookup1bit.json b/zokrates_stdlib/tests/tests/utils/multiplexer/lookup1bit.json index 18cb968b..3e2cbc25 100644 --- a/zokrates_stdlib/tests/tests/utils/multiplexer/lookup1bit.json +++ b/zokrates_stdlib/tests/tests/utils/multiplexer/lookup1bit.json @@ -8,7 +8,7 @@ }, "output": { "Ok": { - "values": ["1"] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/utils/multiplexer/lookup1bit.zok b/zokrates_stdlib/tests/tests/utils/multiplexer/lookup1bit.zok index b98b0c52..76cd4ef3 100644 --- a/zokrates_stdlib/tests/tests/utils/multiplexer/lookup1bit.zok +++ b/zokrates_stdlib/tests/tests/utils/multiplexer/lookup1bit.zok @@ -1,24 +1,24 @@ import "utils/multiplexer/lookup1bit" as lookup -def left() -> (field): +def left() -> (bool): bool sel = false //left field[2] t = [0, 1] - 0 == lookup(sel, t) + assert(0 == lookup(sel, t)) - return 1 + return true -def right() -> (field): +def right() -> (bool): bool sel = true //right field[2] t = [0, 1] - 1 == lookup(sel, t) + assert(1 == lookup(sel, t)) - return 1 + return true -def main() -> (field): +def main() -> (): - 1 == left() - 1 == right() + assert(left()) + assert(right()) - return 1 \ No newline at end of file + return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/utils/multiplexer/lookup2bit.json b/zokrates_stdlib/tests/tests/utils/multiplexer/lookup2bit.json index c4fd2436..2d2f4fab 100644 --- a/zokrates_stdlib/tests/tests/utils/multiplexer/lookup2bit.json +++ b/zokrates_stdlib/tests/tests/utils/multiplexer/lookup2bit.json @@ -8,7 +8,7 @@ }, "output": { "Ok": { - "values": ["1"] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/utils/multiplexer/lookup2bit.zok b/zokrates_stdlib/tests/tests/utils/multiplexer/lookup2bit.zok index 1022578c..58185aac 100644 --- a/zokrates_stdlib/tests/tests/utils/multiplexer/lookup2bit.zok +++ b/zokrates_stdlib/tests/tests/utils/multiplexer/lookup2bit.zok @@ -1,42 +1,42 @@ import "utils/multiplexer/lookup2bit" as lookup -def first() -> (field): +def first() -> (bool): bool[2] sel = [false, false] field[4] t = [0, 1, 2, 3] - 0 == lookup(sel, t) + assert(0 == lookup(sel, t)) - return 1 + return true -def second() -> (field): +def second() -> (bool): bool[2] sel = [true, false] field[4] t = [0, 1, 2, 3] - 1 == lookup(sel, t) + assert(1 == lookup(sel, t)) - return 1 + return true -def third() -> (field): +def third() -> (bool): bool[2] sel = [false, true] field[4] t = [0, 1, 2 , 3] - 2 == lookup(sel, t) + assert(2 == lookup(sel, t)) - return 1 + return true -def fourth() -> (field): +def fourth() -> (bool): bool[2] sel = [true, true] field[4] t = [0, 1, 2 , 3] - 3 == lookup(sel, t) + assert(3 == lookup(sel, t)) - return 1 + return true -def main() -> (field): +def main() -> (): - 1 == first() - 1 == second() - 1 == third() - 1 == fourth() + assert(first()) + assert(second()) + assert(third()) + assert(fourth()) - return 1 \ No newline at end of file + return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/utils/multiplexer/lookup3bitSigned.json b/zokrates_stdlib/tests/tests/utils/multiplexer/lookup3bitSigned.json index f8817f50..5c77d558 100644 --- a/zokrates_stdlib/tests/tests/utils/multiplexer/lookup3bitSigned.json +++ b/zokrates_stdlib/tests/tests/utils/multiplexer/lookup3bitSigned.json @@ -8,7 +8,7 @@ }, "output": { "Ok": { - "values": ["1"] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/utils/multiplexer/lookup3bitSigned.zok b/zokrates_stdlib/tests/tests/utils/multiplexer/lookup3bitSigned.zok index 14c58019..f42c52bd 100644 --- a/zokrates_stdlib/tests/tests/utils/multiplexer/lookup3bitSigned.zok +++ b/zokrates_stdlib/tests/tests/utils/multiplexer/lookup3bitSigned.zok @@ -1,81 +1,81 @@ import "utils/multiplexer/lookup3bitSigned" as lookup -def first() -> (field): +def first() -> (bool): bool[3] sel = [false,false,false] field[4] t = [0, 1, 2 , 3] - 0 == lookup(sel, t) + assert(0 == lookup(sel, t)) - return 1 + return true -def firstNeg() -> (field): +def firstNeg() -> (bool): bool[3] sel = [false,false,true] field[4] t = [0, 1, 2 , 3] - 0 == lookup(sel, t) + assert(0 == lookup(sel, t)) - return 1 + return true -def second() -> (field): +def second() -> (bool): bool[3] sel = [true,false,false] field[4] t = [0, 1, 2 , 3] - 1 == lookup(sel, t) + assert(1 == lookup(sel, t)) - return 1 + return true -def secondNeg() -> (field): +def secondNeg() -> (bool): bool[3] sel = [true,false,true] field[4] t = [0, 1, 2 , 3] field out = 0 - 1 - out == lookup(sel, t) + assert(out == lookup(sel, t)) - return 1 + return true -def thrid() -> (field): +def thrid() -> (bool): bool[3] sel = [false,true,false] field[4] t = [0, 1, 2 , 3] - 2 == lookup(sel, t) + assert(2 == lookup(sel, t)) - return 1 + return true -def thridNeg() -> (field): +def thridNeg() -> (bool): bool[3] sel = [false,true,true] field[4] t = [0, 1, 2 , 3] field out = 0 - 2 - out == lookup(sel, t) + assert(out == lookup(sel, t)) - return 1 + return true -def fourth() -> (field): +def fourth() -> (bool): bool[3] sel = [true,true,false] field[4] t = [0, 1, 2 , 3] - 3 == lookup(sel, t) + assert(3 == lookup(sel, t)) - return 1 + return true -def fourthNeg() -> (field): +def fourthNeg() -> (bool): bool[3] sel = [true,true,true] field[4] t = [0, 1, 2 , 3] field out = 0 - 3 - out == lookup(sel, t) + assert(out == lookup(sel, t)) - return 1 + return true -def main() -> (field): +def main() -> (): - 1 == first() - 1 == firstNeg() - 1 == second() - 1 == secondNeg() - 1 == thrid() - 1 == thridNeg() - 1 == fourth() - 1 == fourthNeg() + assert(first()) + assert(firstNeg()) + assert(second()) + assert(secondNeg()) + assert(thrid()) + assert(thridNeg()) + assert(fourth()) + assert(fourthNeg()) - return 1 \ No newline at end of file + return \ No newline at end of file diff --git a/zokrates_stdlib/tests/tests/utils/pack/bool/nonStrictUnpack256.zok b/zokrates_stdlib/tests/tests/utils/pack/bool/nonStrictUnpack256.zok index ebbcd4ac..c42b3c54 100644 --- a/zokrates_stdlib/tests/tests/utils/pack/bool/nonStrictUnpack256.zok +++ b/zokrates_stdlib/tests/tests/utils/pack/bool/nonStrictUnpack256.zok @@ -1,41 +1,41 @@ import "utils/pack/bool/nonStrictUnpack256" as unpack256 -def testFive() -> (field): +def testFive() -> (bool): bool[256] b = unpack256(5) - b == [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, true ] + assert(b == [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, true ]) - return 1 + return true -def testZero() -> (field): +def testZero() -> (bool): bool[256] b = unpack256(0) - b == [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false ] + assert(b == [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false ]) - return 1 + return true -def testLarge() -> (field): +def testLarge() -> (bool): bool[256] b = unpack256(14474011154664524427946373126085988481658748083205070504932198000989141204991) - b == [false, false, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true ] + assert(b == [false, false, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true ]) - return 1 + return true -def testMax() -> (field): +def testMax() -> (bool): bool[256] b = unpack256(21888242871839275222246405745257275088548364400416034343698204186575808495616) - b == [false, false, true, true, false, false, false, false, false, true, true, false, false, true, false, false, false, true, false, false, true, true, true, false, false, true, true, true, false, false, true, false, true, true, true, false, false, false, false, true, false, false, true, true, false, false, false, true, true, false, true, false, false, false, false, false, false, false, true, false, true, false, false, true, true, false, true, true, true, false, false, false, false, true, false, true, false, false, false, false, false, true, false, false, false, true, false, true, true, false, true, true, false, true, true, false, true, false, false, false, false, false, false, true, true, false, false, false, false, false, false, true, false, true, false, true, true, false, false, false, false, true, false, true, true, true, false, true, false, false, true, false, true, false, false, false, false, false, true, true, false, false, true, true, true, true, true, false, true, false, false, false, false, true, false, false, true, false, false, false, false, true, true, true, true, false, false, true, true, false, true, true, true, false, false, true, false, true, true, true, false, false, false, false, true, false, false, true, false, false, false, true, false, true, false, false, false, false, true, true, true, true, true, false, false, false, false, true, true, true, true, true, false, true, false, true, true, false, false, true, false, false, true, true, true, true, true, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false ] + assert(b == [false, false, true, true, false, false, false, false, false, true, true, false, false, true, false, false, false, true, false, false, true, true, true, false, false, true, true, true, false, false, true, false, true, true, true, false, false, false, false, true, false, false, true, true, false, false, false, true, true, false, true, false, false, false, false, false, false, false, true, false, true, false, false, true, true, false, true, true, true, false, false, false, false, true, false, true, false, false, false, false, false, true, false, false, false, true, false, true, true, false, true, true, false, true, true, false, true, false, false, false, false, false, false, true, true, false, false, false, false, false, false, true, false, true, false, true, true, false, false, false, false, true, false, true, true, true, false, true, false, false, true, false, true, false, false, false, false, false, true, true, false, false, true, true, true, true, true, false, true, false, false, false, false, true, false, false, true, false, false, false, false, true, true, true, true, false, false, true, true, false, true, true, true, false, false, true, false, true, true, true, false, false, false, false, true, false, false, true, false, false, false, true, false, true, false, false, false, false, true, true, true, true, true, false, false, false, false, true, true, true, true, true, false, true, false, true, true, false, false, true, false, false, true, true, true, true, true, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false ]) - return 1 + return true - def main() -> (field): + def main() -> (): - 1 == testFive() - 1 == testMax() - 1 == testZero() - 1 == testLarge() - return 1 + assert(testFive()) + assert(testMax()) + assert(testZero()) + assert(testLarge()) + return diff --git a/zokrates_stdlib/tests/tests/utils/pack/bool/pack128.json b/zokrates_stdlib/tests/tests/utils/pack/bool/pack128.json index f9fc4dc4..5fcaea64 100644 --- a/zokrates_stdlib/tests/tests/utils/pack/bool/pack128.json +++ b/zokrates_stdlib/tests/tests/utils/pack/bool/pack128.json @@ -8,7 +8,7 @@ }, "output": { "Ok": { - "values": ["1"] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/utils/pack/bool/pack128.zok b/zokrates_stdlib/tests/tests/utils/pack/bool/pack128.zok index 819ed8e1..6a1cec82 100644 --- a/zokrates_stdlib/tests/tests/utils/pack/bool/pack128.zok +++ b/zokrates_stdlib/tests/tests/utils/pack/bool/pack128.zok @@ -1,36 +1,36 @@ import "utils/pack/bool/pack128" as pack128 -def testFive() -> (field): +def testFive() -> (bool): bool[128] b = [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, true] field n = pack128(b) - 5 == n + assert(5 == n) - return 1 + return true -def testZero() -> (field): +def testZero() -> (bool): bool[128] b = [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false] field n = pack128(b) - 0 == n + assert(0 == n) - return 1 + return true -def testMax() -> (field): +def testMax() -> (bool): bool[128] b = [true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true] field n = pack128(b) - 340282366920938463463374607431768211455 == n + assert(340282366920938463463374607431768211455 == n) - return 1 + return true - def main() -> (field): + def main() -> (): - 1 == testFive() - 1 == testMax() - 1 == testZero() + assert(testFive()) + assert(testMax()) + assert(testZero()) - return 1 + return diff --git a/zokrates_stdlib/tests/tests/utils/pack/bool/unpack128.json b/zokrates_stdlib/tests/tests/utils/pack/bool/unpack128.json index d7868da7..daf93ea7 100644 --- a/zokrates_stdlib/tests/tests/utils/pack/bool/unpack128.json +++ b/zokrates_stdlib/tests/tests/utils/pack/bool/unpack128.json @@ -8,7 +8,7 @@ }, "output": { "Ok": { - "values": ["1"] + "values": [] } } } diff --git a/zokrates_stdlib/tests/tests/utils/pack/bool/unpack128.zok b/zokrates_stdlib/tests/tests/utils/pack/bool/unpack128.zok index f86bd856..bb3097a0 100644 --- a/zokrates_stdlib/tests/tests/utils/pack/bool/unpack128.zok +++ b/zokrates_stdlib/tests/tests/utils/pack/bool/unpack128.zok @@ -1,33 +1,33 @@ import "utils/pack/bool/unpack128" as unpack128 -def testFive() -> (field): +def testFive() -> (bool): bool[128] b = unpack128(5) - b == [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, true] + assert(b == [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, true]) - return 1 + return true -def testZero() -> (field): +def testZero() -> (bool): bool[128] b = unpack128(0) - b == [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false] + assert(b == [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false]) - return 1 + return true -def testMax() -> (field): +def testMax() -> (bool): bool[128] b = unpack128(340282366920938463463374607431768211455) - b == [true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true] + assert(b == [true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true]) - return 1 + return true - def main() -> (field): + def main() -> (): - 1 == testFive() - 1 == testMax() - 1 == testZero() + assert(testFive()) + assert(testMax()) + assert(testZero()) - return 1 + return diff --git a/zokrates_stdlib/tests/tests/utils/pack/u32/pack128.json b/zokrates_stdlib/tests/tests/utils/pack/u32/pack128.json index 7e615a3e..c2d11d52 100644 --- a/zokrates_stdlib/tests/tests/utils/pack/u32/pack128.json +++ b/zokrates_stdlib/tests/tests/utils/pack/u32/pack128.json @@ -8,7 +8,7 @@ }, "output": { "Ok": { - "values": ["1"] + "values": [] } } }