AleoHQ/leo
1
1
Fork 0
mirror of https://github.com/AleoHQ/leo.git synced 2024-09-20 11:37:33 +03:00
Code Issues Packages Projects Releases Wiki Activity

core algorithm tests working

Browse Source
This commit is contained in:
collin 2022-07-28 15:27:43 -07:00
parent 66c5deb7e3
commit eaa04a5f7e
37 changed files with 759 additions and 372 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
compiler/compiler/src/test.rs
View File

@ -144,17 +144,6 @@ fn collect_all_inputs(test: &Test) -> Result<Vec<PathBuf>, String> {
Ok(list)
}
<<<<<<< HEAD
=======
fn compile_and_process<'a>(parsed: &'a mut Compiler<'a>) -> Result<SymbolTable, LeoError> {
let st = parsed.symbol_table_pass()?;
let st = parsed.type_checker_pass(st)?;
let st = parsed.loop_unrolling_pass(st)?;
parsed.static_single_assignment_pass()?;
Ok(st)
}
>>>>>>> 8a0e9bc5ccb5cfbe642e51e8e81458e67c596c10
// Errors used in this module.
enum LeoOrString {
Leo(LeoError),
@ -204,6 +193,8 @@ fn compile_and_process<'a>(parsed: &'a mut Compiler<'a>, handler: &Handler) -> R
let st = parsed.symbol_table_pass()?;
let st = parsed.type_checker_pass(st)?;
let _st = parsed.loop_unrolling_pass(st)?;
parsed.static_single_assignment_pass()?;
// Compile Leo program to bytecode.
let bytecode = CodeGenerator::do_pass((&parsed.ast, handler))?;

24
compiler/core/src/algorithms/mod.rs
View File

@ -37,9 +37,9 @@ pub enum CoreInstruction {
BHP1024Commit,
BHP1024Hash,
Pedersen64Commit,
// Pedersen64Commit,
Pedersen64Hash,
Pedersen128Commit,
// Pedersen128Commit,
Pedersen128Hash,
Poseidon2Hash,
@ -60,9 +60,9 @@ impl CoreInstruction {
(sym::BHP1024, sym::commit) => Self::BHP1024Commit,
(sym::BHP1024, sym::hash) => Self::BHP1024Hash,
(sym::Pedersen64, sym::commit) => Self::Pedersen64Commit,
// (sym::Pedersen64, sym::commit) => Self::Pedersen64Commit,
(sym::Pedersen64, sym::hash) => Self::Pedersen64Hash,
(sym::Pedersen128, sym::commit) => Self::Pedersen128Commit,
// (sym::Pedersen128, sym::commit) => Self::Pedersen128Commit,
(sym::Pedersen128, sym::hash) => Self::Pedersen128Hash,
(sym::Poseidon2, sym::hash) => Self::Poseidon2Hash,
@ -84,9 +84,9 @@ impl CoreInstruction {
Self::BHP1024Commit => BHP1024Commit::NUM_ARGS,
Self::BHP1024Hash => BHP1024Hash::NUM_ARGS,
Self::Pedersen64Commit => Pedersen64Commit::NUM_ARGS,
// Self::Pedersen64Commit => Pedersen64Commit::NUM_ARGS,
Self::Pedersen64Hash => Pedersen64Hash::NUM_ARGS,
Self::Pedersen128Commit => Pedersen128Commit::NUM_ARGS,
// Self::Pedersen128Commit => Pedersen128Commit::NUM_ARGS,
Self::Pedersen128Hash => Pedersen128Hash::NUM_ARGS,
Self::Poseidon2Hash => Poseidon2Hash::NUM_ARGS,
@ -107,9 +107,9 @@ impl CoreInstruction {
Self::BHP1024Commit => BHP1024Commit::first_arg_types(),
Self::BHP1024Hash => BHP1024Hash::first_arg_types(),
Self::Pedersen64Commit => Pedersen64Commit::first_arg_types(),
// Self::Pedersen64Commit => Pedersen64Commit::first_arg_types(),
Self::Pedersen64Hash => Pedersen64Hash::first_arg_types(),
Self::Pedersen128Commit => Pedersen128Commit::first_arg_types(),
// Self::Pedersen128Commit => Pedersen128Commit::first_arg_types(),
Self::Pedersen128Hash => Pedersen128Hash::first_arg_types(),
Self::Poseidon2Hash => Poseidon2Hash::first_arg_types(),
@ -130,9 +130,9 @@ impl CoreInstruction {
Self::BHP1024Commit => BHP1024Commit::second_arg_types(),
Self::BHP1024Hash => BHP1024Hash::second_arg_types(),
Self::Pedersen64Commit => Pedersen64Commit::second_arg_types(),
// Self::Pedersen64Commit => Pedersen64Commit::second_arg_types(),
Self::Pedersen64Hash => Pedersen64Hash::second_arg_types(),
Self::Pedersen128Commit => Pedersen128Commit::second_arg_types(),
// Self::Pedersen128Commit => Pedersen128Commit::second_arg_types(),
Self::Pedersen128Hash => Pedersen128Hash::second_arg_types(),
Self::Poseidon2Hash => Poseidon2Hash::second_arg_types(),
@ -153,9 +153,9 @@ impl CoreInstruction {
Self::BHP1024Commit => BHP1024Commit::return_type(),
Self::BHP1024Hash => BHP1024Hash::return_type(),
Self::Pedersen64Commit => Pedersen64Commit::return_type(),
// Self::Pedersen64Commit => Pedersen64Commit::return_type(),
Self::Pedersen64Hash => Pedersen64Hash::return_type(),
Self::Pedersen128Commit => Pedersen128Commit::return_type(),
// Self::Pedersen128Commit => Pedersen128Commit::return_type(),
Self::Pedersen128Hash => Pedersen128Hash::return_type(),
Self::Poseidon2Hash => Poseidon2Hash::return_type(),

72
compiler/core/src/algorithms/pedersen.rs
View File

@ -27,27 +27,27 @@ impl CoreFunction for Pedersen64Hash {
}
fn return_type() -> Type {
Type::Group
Type::Field
}
}
pub struct Pedersen64Commit;
impl CoreFunction for Pedersen64Commit {
const NUM_ARGS: usize = 2;
fn first_arg_types() -> &'static [Type] {
&BOOL_INT64_STRING_TYPES
}
fn second_arg_types() -> &'static [Type] {
&[Type::Scalar]
}
fn return_type() -> Type {
Type::Group
}
}
// pub struct Pedersen64Commit;
//
// impl CoreFunction for Pedersen64Commit {
// const NUM_ARGS: usize = 2;
//
// fn first_arg_types() -> &'static [Type] {
// &BOOL_INT64_STRING_TYPES
// }
//
// fn second_arg_types() -> &'static [Type] {
// &[Type::Scalar]
// }
//
// fn return_type() -> Type {
// Type::Field
// }
// }
pub struct Pedersen128Hash;
@ -59,24 +59,24 @@ impl CoreFunction for Pedersen128Hash {
}
fn return_type() -> Type {
Type::Group
Type::Field
}
}
pub struct Pedersen128Commit;
impl CoreFunction for Pedersen128Commit {
const NUM_ARGS: usize = 2;
fn first_arg_types() -> &'static [Type] {
&BOOL_INT_STRING_TYPES
}
fn second_arg_types() -> &'static [Type] {
&[Type::Scalar]
}
fn return_type() -> Type {
Type::Group
}
}
// pub struct Pedersen128Commit;
//
// impl CoreFunction for Pedersen128Commit {
// const NUM_ARGS: usize = 2;
//
// fn first_arg_types() -> &'static [Type] {
// &BOOL_INT_STRING_TYPES
// }
//
// fn second_arg_types() -> &'static [Type] {
// &[Type::Scalar]
// }
//
// fn return_type() -> Type {
// Type::Field
// }
// }

0
tests/test-framework/src/unused/branch/branch.leo → tests/compiler/address/branch.leo
View File

170
tests/compiler/core/algorithms/bhp.leo
View File

@ -1,170 +0,0 @@
/*
namespace: Compile
expectation: Pass
*/
function main() -> bool {
let owner: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta;
let bool_value: bool = true;
let field_value: field = 1field;
let group_value: group = (0, 1)group;
let i8_value: i8 = 1i8;
let i16_value: i16 = 1i16;
let i32_value: i32 = 1i32;
let i64_value: i64 = 1i64;
let i128_value: i128 = 1i128;
let u8_value: u8 = 1u8;
let u16_value: u16 = 1u16;
let u32_value: u32 = 1u32;
let u64_value: u64 = 1u64;
let u128_value: u128 = 1u128;
let scalar_value: scalar = 1scalar;
let string_value: string = "helloworld";
// BHP256 commit tests
let a1: field = BHP256::commit(owner, 1scalar);
let b1: field = BHP256::commit(bool_value, 1scalar);
let c1: field = BHP256::commit(field_value, 1scalar);
let d1: field = BHP256::commit(group_value, 1scalar);
let e1: field = BHP256::commit(i8_value, 1scalar);
let f1: field = BHP256::commit(i16_value, 1scalar);
let g1: field = BHP256::commit(i32_value, 1scalar);
let h1: field = BHP256::commit(i64_value, 1scalar);
let i1: field = BHP256::commit(i128_value, 1scalar);
let j1: field = BHP256::commit(u8_value, 1scalar);
let k1: field = BHP256::commit(u16_value, 1scalar);
let l1: field = BHP256::commit(u32_value, 1scalar);
let m1: field = BHP256::commit(u64_value, 1scalar);
let n1: field = BHP256::commit(u128_value, 1scalar);
let o1: field = BHP256::commit(scalar_value, 1scalar);
let p1: field = BHP256::commit(string_value, 1scalar);
// BHP256 hash tests
let a11: field = BHP256::hash(owner);
let b11: field = BHP256::hash(bool_value);
let c11: field = BHP256::hash(field_value);
let d11: field = BHP256::hash(group_value);
let e11: field = BHP256::hash(i8_value);
let f11: field = BHP256::hash(i16_value);
let g11: field = BHP256::hash(i32_value);
let h11: field = BHP256::hash(i64_value);
let i11: field = BHP256::hash(i128_value);
let j11: field = BHP256::hash(u8_value);
let k11: field = BHP256::hash(u16_value);
let l11: field = BHP256::hash(u32_value);
let m11: field = BHP256::hash(u64_value);
let n11: field = BHP256::hash(u128_value);
let o11: field = BHP256::hash(scalar_value);
let p11: field = BHP256::hash(string_value);
// BHP512 commit tests
let a2: field = BHP512::commit(owner, 1scalar);
let b2: field = BHP512::commit(bool_value, 1scalar);
let c2: field = BHP512::commit(field_value, 1scalar);
let d2: field = BHP512::commit(group_value, 1scalar);
let e2: field = BHP512::commit(i8_value, 1scalar);
let f2: field = BHP512::commit(i16_value, 1scalar);
let g2: field = BHP512::commit(i32_value, 1scalar);
let h2: field = BHP512::commit(i64_value, 1scalar);
let i2: field = BHP512::commit(i128_value, 1scalar);
let j2: field = BHP512::commit(u8_value, 1scalar);
let k2: field = BHP512::commit(u16_value, 1scalar);
let l2: field = BHP512::commit(u32_value, 1scalar);
let m2: field = BHP512::commit(u64_value, 1scalar);
let n2: field = BHP512::commit(u128_value, 1scalar);
let o2: field = BHP512::commit(scalar_value, 1scalar);
let p2: field = BHP512::commit(string_value, 1scalar);
// BHP512 hash tests
let a22: field = BHP512::hash(owner);
let b22: field = BHP512::hash(bool_value);
let c22: field = BHP512::hash(field_value);
let d22: field = BHP512::hash(group_value);
let e22: field = BHP512::hash(i8_value);
let f22: field = BHP512::hash(i16_value);
let g22: field = BHP512::hash(i32_value);
let h22: field = BHP512::hash(i64_value);
let i22: field = BHP512::hash(i128_value);
let j22: field = BHP512::hash(u8_value);
let k22: field = BHP512::hash(u16_value);
let l22: field = BHP512::hash(u32_value);
let m22: field = BHP512::hash(u64_value);
let n22: field = BHP512::hash(u128_value);
let o22: field = BHP512::hash(scalar_value);
let p22: field = BHP512::hash(string_value);
// BHP768 commit tests
let a3: field = BHP768::commit(owner, 1scalar);
let b3: field = BHP768::commit(bool_value, 1scalar);
let c3: field = BHP768::commit(field_value, 1scalar);
let d3: field = BHP768::commit(group_value, 1scalar);
let e3: field = BHP768::commit(i8_value, 1scalar);
let f3: field = BHP768::commit(i16_value, 1scalar);
let g3: field = BHP768::commit(i32_value, 1scalar);
let h3: field = BHP768::commit(i64_value, 1scalar);
let i3: field = BHP768::commit(i128_value, 1scalar);
let j3: field = BHP768::commit(u8_value, 1scalar);
let k3: field = BHP768::commit(u16_value, 1scalar);
let l3: field = BHP768::commit(u32_value, 1scalar);
let m3: field = BHP768::commit(u64_value, 1scalar);
let n3: field = BHP768::commit(u128_value, 1scalar);
let o3: field = BHP768::commit(scalar_value, 1scalar);
let p3: field = BHP768::commit(string_value, 1scalar);
// BHP768 hash tests
let a33: field = BHP768::hash(owner);
let b33: field = BHP768::hash(bool_value);
let c33: field = BHP768::hash(field_value);
let d33: field = BHP768::hash(group_value);
let e33: field = BHP768::hash(i8_value);
let f33: field = BHP768::hash(i16_value);
let g33: field = BHP768::hash(i32_value);
let h33: field = BHP768::hash(i64_value);
let i33: field = BHP768::hash(i128_value);
let j33: field = BHP768::hash(u8_value);
let k33: field = BHP768::hash(u16_value);
let l33: field = BHP768::hash(u32_value);
let m33: field = BHP768::hash(u64_value);
let n33: field = BHP768::hash(u128_value);
let o33: field = BHP768::hash(scalar_value);
let p33: field = BHP768::hash(string_value);
// BHP1024 commit tests
let a4: field = BHP1024::commit(owner, 1scalar);
let b4: field = BHP1024::commit(bool_value, 1scalar);
let c4: field = BHP1024::commit(field_value, 1scalar);
let d4: field = BHP1024::commit(group_value, 1scalar);
let e4: field = BHP1024::commit(i8_value, 1scalar);
let f4: field = BHP1024::commit(i16_value, 1scalar);
let g4: field = BHP1024::commit(i32_value, 1scalar);
let h4: field = BHP1024::commit(i64_value, 1scalar);
let i4: field = BHP1024::commit(i128_value, 1scalar);
let j4: field = BHP1024::commit(u8_value, 1scalar);
let k4: field = BHP1024::commit(u16_value, 1scalar);
let l4: field = BHP1024::commit(u32_value, 1scalar);
let m4: field = BHP1024::commit(u64_value, 1scalar);
let n4: field = BHP1024::commit(u128_value, 1scalar);
let o4: field = BHP1024::commit(scalar_value, 1scalar);
let p4: field = BHP1024::commit(string_value, 1scalar);
// BHP1024 hash tests
let a44: field = BHP1024::hash(owner);
let b44: field = BHP1024::hash(bool_value);
let c44: field = BHP1024::hash(field_value);
let d44: field = BHP1024::hash(group_value);
let e44: field = BHP1024::hash(i8_value);
let f44: field = BHP1024::hash(i16_value);
let g44: field = BHP1024::hash(i32_value);
let h44: field = BHP1024::hash(i64_value);
let i44: field = BHP1024::hash(i128_value);
let j44: field = BHP1024::hash(u8_value);
let k44: field = BHP1024::hash(u16_value);
let l44: field = BHP1024::hash(u32_value);
let m44: field = BHP1024::hash(u64_value);
let n44: field = BHP1024::hash(u128_value);
let o44: field = BHP1024::hash(scalar_value);
let p44: field = BHP1024::hash(string_value);
return true;
}

45
tests/compiler/core/algorithms/bhp1024_commit.leo Normal file
View File

@ -0,0 +1,45 @@
/*
namespace: Compile
expectation: Pass
input_file: inputs/int64.in
*/
function main(
i8_value: i8,
i16_value: i16,
i32_value: i32,
i64_value: i64,
u8_value: u8,
u16_value: u16,
u32_value: u32,
u64_value: u64,
) -> field {
let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta;
let bool_value: bool = true;
let field_value: field = 1field;
// let group_value: group = (0, 1)group;
let i128_value: i128 = 1i128;
let u128_value: u128 = 1u128;
let scalar_value: scalar = 1scalar;
// let string_value: string = "helloworld";
// BHP1024 commit tests
let a: field = BHP1024::commit(addr_value, 1scalar);
let b: field = BHP1024::commit(bool_value, 1scalar);
let c: field = BHP1024::commit(field_value, 1scalar);
// let d: field = BHP1024::commit(group_value, 1scalar);
let e: field = BHP1024::commit(i8_value, 1scalar);
let f: field = BHP1024::commit(i16_value, 1scalar);
let g: field = BHP1024::commit(i32_value, 1scalar);
let h: field = BHP1024::commit(i64_value, 1scalar);
let i: field = BHP1024::commit(i128_value, 1scalar);
let j: field = BHP1024::commit(u8_value, 1scalar);
let k: field = BHP1024::commit(u16_value, 1scalar);
let l: field = BHP1024::commit(u32_value, 1scalar);
let m: field = BHP1024::commit(u64_value, 1scalar);
let n: field = BHP1024::commit(u128_value, 1scalar);
let o: field = BHP1024::commit(scalar_value, 1scalar);
// let p: field = BHP1024::commit(string_value, 1scalar);
return a + o;
}

45
tests/compiler/core/algorithms/bhp1024_hash.leo Normal file
View File

@ -0,0 +1,45 @@
/*
namespace: Compile
expectation: Pass
input_file: inputs/int64.in
*/
function main(
i8_value: i8,
i16_value: i16,
i32_value: i32,
i64_value: i64,
u8_value: u8,
u16_value: u16,
u32_value: u32,
u64_value: u64,
) -> field {
let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta;
let bool_value: bool = true;
let field_value: field = 1field;
// let group_value: group = (0, 1)group;
let i128_value: i128 = 1i128;
let u128_value: u128 = 1u128;
let scalar_value: scalar = 1scalar;
// let string_value: string = "helloworld";
// BHP1024 hash tests
let a: field = BHP1024::hash(addr_value);
let b: field = BHP1024::hash(bool_value);
let c: field = BHP1024::hash(field_value);
// let d: field = BHP1024::hash(group_value);
let e: field = BHP1024::hash(i8_value);
let f: field = BHP1024::hash(i16_value);
let g: field = BHP1024::hash(i32_value);
let h: field = BHP1024::hash(i64_value);
let i: field = BHP1024::hash(i128_value);
let j: field = BHP1024::hash(u8_value);
let k: field = BHP1024::hash(u16_value);
let l: field = BHP1024::hash(u32_value);
let m: field = BHP1024::hash(u64_value);
let n: field = BHP1024::hash(u128_value);
let o: field = BHP1024::hash(scalar_value);
// let p: field = BHP1024::hash(string_value);
return a + o;
}

45
tests/compiler/core/algorithms/bhp256_commit.leo Normal file
View File

@ -0,0 +1,45 @@
/*
namespace: Compile
expectation: Pass
input_file: inputs/int64.in
*/
function main(
i8_value: i8,
i16_value: i16,
i32_value: i32,
i64_value: i64,
u8_value: u8,
u16_value: u16,
u32_value: u32,
u64_value: u64,
) -> field {
let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta;
let bool_value: bool = true;
let field_value: field = 1field;
// let group_value: group = (0, 1)group;
let i128_value: i128 = 1i128;
let u128_value: u128 = 1u128;
let scalar_value: scalar = 1scalar;
// let string_value: string = "helloworld";
// BHP256 commit tests
let a: field = BHP256::commit(addr_value, 1scalar);
let b: field = BHP256::commit(bool_value, 1scalar);
let c: field = BHP256::commit(field_value, 1scalar);
// let d: field = BHP256::commit(group_value, 1scalar);
let e: field = BHP256::commit(i8_value, 1scalar);
let f: field = BHP256::commit(i16_value, 1scalar);
let g: field = BHP256::commit(i32_value, 1scalar);
let h: field = BHP256::commit(i64_value, 1scalar);
let i: field = BHP256::commit(i128_value, 1scalar);
let j: field = BHP256::commit(u8_value, 1scalar);
let k: field = BHP256::commit(u16_value, 1scalar);
let l: field = BHP256::commit(u32_value, 1scalar);
let m: field = BHP256::commit(u64_value, 1scalar);
let n: field = BHP256::commit(u128_value, 1scalar);
let o: field = BHP256::commit(scalar_value, 1scalar);
// let p: field = BHP256::commit(string_value, 1scalar);
return a + o;
}

45
tests/compiler/core/algorithms/bhp256_hash.leo Normal file
View File

@ -0,0 +1,45 @@
/*
namespace: Compile
expectation: Pass
input_file: inputs/int64.in
*/
function main(
i8_value: i8,
i16_value: i16,
i32_value: i32,
i64_value: i64,
u8_value: u8,
u16_value: u16,
u32_value: u32,
u64_value: u64,
) -> field {
let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta;
let bool_value: bool = true;
let field_value: field = 1field;
// let group_value: group = (0, 1)group;
let i128_value: i128 = 1i128;
let u128_value: u128 = 1u128;
let scalar_value: scalar = 1scalar;
// let string_value: string = "helloworld";
// BHP256 hash tests
let a: field = BHP256::hash(addr_value);
let b: field = BHP256::hash(bool_value);
let c: field = BHP256::hash(field_value);
// let d: field = BHP256::hash(group_value);
let e: field = BHP256::hash(i8_value);
let f: field = BHP256::hash(i16_value);
let g: field = BHP256::hash(i32_value);
let h: field = BHP256::hash(i64_value);
let i: field = BHP256::hash(i128_value);
let j: field = BHP256::hash(u8_value);
let k: field = BHP256::hash(u16_value);
let l: field = BHP256::hash(u32_value);
let m: field = BHP256::hash(u64_value);
let n: field = BHP256::hash(u128_value);
let o: field = BHP256::hash(scalar_value);
// let p: field = BHP256::hash(string_value);
return a + o;
}

45
tests/compiler/core/algorithms/bhp512_commit.leo Normal file
View File

@ -0,0 +1,45 @@
/*
namespace: Compile
expectation: Pass
input_file: inputs/int64.in
*/
function main(
i8_value: i8,
i16_value: i16,
i32_value: i32,
i64_value: i64,
u8_value: u8,
u16_value: u16,
u32_value: u32,
u64_value: u64,
) -> field {
let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta;
let bool_value: bool = true;
let field_value: field = 1field;
// let group_value: group = (0, 1)group;
let i128_value: i128 = 1i128;
let u128_value: u128 = 1u128;
let scalar_value: scalar = 1scalar;
// let string_value: string = "helloworld";
// BHP512 commit tests
let a: field = BHP512::commit(addr_value, 1scalar);
let b: field = BHP512::commit(bool_value, 1scalar);
let c: field = BHP512::commit(field_value, 1scalar);
// let d: field = BHP512::commit(group_value, 1scalar);
let e: field = BHP512::commit(i8_value, 1scalar);
let f: field = BHP512::commit(i16_value, 1scalar);
let g: field = BHP512::commit(i32_value, 1scalar);
let h: field = BHP512::commit(i64_value, 1scalar);
let i: field = BHP512::commit(i128_value, 1scalar);
let j: field = BHP512::commit(u8_value, 1scalar);
let k: field = BHP512::commit(u16_value, 1scalar);
let l: field = BHP512::commit(u32_value, 1scalar);
let m: field = BHP512::commit(u64_value, 1scalar);
let n: field = BHP512::commit(u128_value, 1scalar);
let o: field = BHP512::commit(scalar_value, 1scalar);
// let p: field = BHP512::commit(string_value, 1scalar);
return a + o;
}

45
tests/compiler/core/algorithms/bhp512_hash.leo Normal file
View File

@ -0,0 +1,45 @@
/*
namespace: Compile
expectation: Pass
input_file: inputs/int64.in
*/
function main(
i8_value: i8,
i16_value: i16,
i32_value: i32,
i64_value: i64,
u8_value: u8,
u16_value: u16,
u32_value: u32,
u64_value: u64,
) -> field {
let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta;
let bool_value: bool = true;
let field_value: field = 1field;
// let group_value: group = (0, 1)group;
let i128_value: i128 = 1i128;
let u128_value: u128 = 1u128;
let scalar_value: scalar = 1scalar;
// let string_value: string = "helloworld";
// BHP512 hash tests
let a: field = BHP512::hash(addr_value);
let b: field = BHP512::hash(bool_value);
let c: field = BHP512::hash(field_value);
// let d: field = BHP512::hash(group_value);
let e: field = BHP512::hash(i8_value);
let f: field = BHP512::hash(i16_value);
let g: field = BHP512::hash(i32_value);
let h: field = BHP512::hash(i64_value);
let i: field = BHP512::hash(i128_value);
let j: field = BHP512::hash(u8_value);
let k: field = BHP512::hash(u16_value);
let l: field = BHP512::hash(u32_value);
let m: field = BHP512::hash(u64_value);
let n: field = BHP512::hash(u128_value);
let o: field = BHP512::hash(scalar_value);
// let p: field = BHP512::hash(string_value);
return a + o;
}

45
tests/compiler/core/algorithms/bhp768_commit.leo Normal file
View File

@ -0,0 +1,45 @@
/*
namespace: Compile
expectation: Pass
input_file: inputs/int64.in
*/
function main(
i8_value: i8,
i16_value: i16,
i32_value: i32,
i64_value: i64,
u8_value: u8,
u16_value: u16,
u32_value: u32,
u64_value: u64,
) -> field {
let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta;
let bool_value: bool = true;
let field_value: field = 1field;
// let group_value: group = (0, 1)group;
let i128_value: i128 = 1i128;
let u128_value: u128 = 1u128;
let scalar_value: scalar = 1scalar;
// let string_value: string = "helloworld";
// BHP768 commit tests
let a: field = BHP768::commit(addr_value, 1scalar);
let b: field = BHP768::commit(bool_value, 1scalar);
let c: field = BHP768::commit(field_value, 1scalar);
// let d: field = BHP768::commit(group_value, 1scalar);
let e: field = BHP768::commit(i8_value, 1scalar);
let f: field = BHP768::commit(i16_value, 1scalar);
let g: field = BHP768::commit(i32_value, 1scalar);
let h: field = BHP768::commit(i64_value, 1scalar);
let i: field = BHP768::commit(i128_value, 1scalar);
let j: field = BHP768::commit(u8_value, 1scalar);
let k: field = BHP768::commit(u16_value, 1scalar);
let l: field = BHP768::commit(u32_value, 1scalar);
let m: field = BHP768::commit(u64_value, 1scalar);
let n: field = BHP768::commit(u128_value, 1scalar);
let o: field = BHP768::commit(scalar_value, 1scalar);
// let p: field = BHP768::commit(string_value, 1scalar);
return a + o;
}

45
tests/compiler/core/algorithms/bhp768_hash.leo Normal file
View File

@ -0,0 +1,45 @@
/*
namespace: Compile
expectation: Pass
input_file: inputs/int64.in
*/
function main(
i8_value: i8,
i16_value: i16,
i32_value: i32,
i64_value: i64,
u8_value: u8,
u16_value: u16,
u32_value: u32,
u64_value: u64,
) -> field {
let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta;
let bool_value: bool = true;
let field_value: field = 1field;
// let group_value: group = (0, 1)group;
let i128_value: i128 = 1i128;
let u128_value: u128 = 1u128;
let scalar_value: scalar = 1scalar;
// let string_value: string = "helloworld";
// BHP768 hash tests
let a: field = BHP768::hash(addr_value);
let b: field = BHP768::hash(bool_value);
let c: field = BHP768::hash(field_value);
// let d: field = BHP768::hash(group_value);
let e: field = BHP768::hash(i8_value);
let f: field = BHP768::hash(i16_value);
let g: field = BHP768::hash(i32_value);
let h: field = BHP768::hash(i64_value);
let i: field = BHP768::hash(i128_value);
let j: field = BHP768::hash(u8_value);
let k: field = BHP768::hash(u16_value);
let l: field = BHP768::hash(u32_value);
let m: field = BHP768::hash(u64_value);
let n: field = BHP768::hash(u128_value);
let o: field = BHP768::hash(scalar_value);
// let p: field = BHP768::hash(string_value);
return a + o;
}

10
tests/compiler/core/algorithms/inputs/int64.in Normal file
View File

@ -0,0 +1,10 @@
[main]
i8_value: i8 = 1i8;
i16_value: i16 = 1i16;
i32_value: i32 = 1i32;
i64_value: i64 = 1i64;
u8_value: u8 = 1u8;
u16_value: u16 = 1u16;
u32_value: u32 = 1u32;
u64_value: u64 = 1u64;

73
tests/compiler/core/algorithms/pedersen.leo
View File

@ -1,73 +0,0 @@
/*
namespace: Compile
expectation: Pass
*/
function main() -> bool {
let bool_value: bool = true;
let i8_value: i8 = 1i8;
let i16_value: i16 = 1i16;
let i32_value: i32 = 1i32;
let i64_value: i64 = 1i64;
let i128_value: i128 = 1i128;
let u8_value: u8 = 1u8;
let u16_value: u16 = 1u16;
let u32_value: u32 = 1u32;
let u64_value: u64 = 1u64;
let u128_value: u128 = 1u128;
let string_value: string = "helloworld";
// Pedersen64 commit tests
let a1: group = Pedersen64::commit(bool_value, 1scalar);
let b1: group = Pedersen64::commit(i8_value, 1scalar);
let c1: group = Pedersen64::commit(i16_value, 1scalar);
let d1: group = Pedersen64::commit(i32_value, 1scalar);
let e1: group = Pedersen64::commit(i64_value, 1scalar);
let f1: group = Pedersen64::commit(u8_value, 1scalar);
let g1: group = Pedersen64::commit(u16_value, 1scalar);
let h1: group = Pedersen64::commit(u32_value, 1scalar);
let i1: group = Pedersen64::commit(u64_value, 1scalar);
let j1: group = Pedersen64::commit(string_value, 1scalar);
// Pedersen64 hash tests
let a11: group = Pedersen64::hash(bool_value);
let b11: group = Pedersen64::hash(i8_value);
let c11: group = Pedersen64::hash(i16_value);
let d11: group = Pedersen64::hash(i32_value);
let e11: group = Pedersen64::hash(i64_value);
let f11: group = Pedersen64::hash(u8_value);
let g11: group = Pedersen64::hash(u16_value);
let h11: group = Pedersen64::hash(u32_value);
let i11: group = Pedersen64::hash(u64_value);
let j11: group = Pedersen64::hash(string_value);
// Pedersen128 commit tests
let a2: group = Pedersen128::commit(bool_value, 1scalar);
let b2: group = Pedersen128::commit(i8_value, 1scalar);
let c2: group = Pedersen128::commit(i16_value, 1scalar);
let d2: group = Pedersen128::commit(i32_value, 1scalar);
let e2: group = Pedersen128::commit(i64_value, 1scalar);
let f2: group = Pedersen128::commit(i128_value, 1scalar);
let g2: group = Pedersen128::commit(u8_value, 1scalar);
let h2: group = Pedersen128::commit(u16_value, 1scalar);
let i2: group = Pedersen128::commit(u32_value, 1scalar);
let j2: group = Pedersen128::commit(u64_value, 1scalar);
let k2: group = Pedersen128::commit(u128_value, 1scalar);
let l2: group = Pedersen128::commit(string_value, 1scalar);
// Pedersen128 hash tests
let a22: group = Pedersen128::hash(bool_value);
let b22: group = Pedersen128::hash(i8_value);
let c22: group = Pedersen128::hash(i16_value);
let d22: group = Pedersen128::hash(i32_value);
let e22: group = Pedersen128::hash(i64_value);
let f22: group = Pedersen128::hash(i128_value);
let g22: group = Pedersen128::hash(u8_value);
let h22: group = Pedersen128::hash(u16_value);
let i22: group = Pedersen128::hash(u32_value);
let j22: group = Pedersen128::hash(u64_value);
let k22: group = Pedersen128::hash(u128_value);
let l22: group = Pedersen128::hash(string_value);
return true;
}

37
tests/compiler/core/algorithms/pedersen128_hash.leo Normal file
View File

@ -0,0 +1,37 @@
/*
namespace: Compile
expectation: Pass
input_file: inputs/int64.in
*/
function main(
i8_value: i8,
i16_value: i16,
i32_value: i32,
i64_value: i64,
u8_value: u8,
u16_value: u16,
u32_value: u32,
u64_value: u64,
) -> field {
let bool_value: bool = true;
let i128_value: i128 = 1i128;
let u128_value: u128 = 1u128;
// let string_value: string = "helloworld";
// Pedersen128 hash tests
let a: field = Pedersen128::hash(bool_value);
let b: field = Pedersen128::hash(i8_value);
let c: field = Pedersen128::hash(i16_value);
let d: field = Pedersen128::hash(i32_value);
let e: field = Pedersen128::hash(i64_value);
let f: field = Pedersen128::hash(i128_value);
let g: field = Pedersen128::hash(u8_value);
let h: field = Pedersen128::hash(u16_value);
let i: field = Pedersen128::hash(u32_value);
let j: field = Pedersen128::hash(u64_value);
let k: field = Pedersen128::hash(u128_value);
// let l: field = Pedersen128::hash(string_value);
return a + k;
}

33
tests/compiler/core/algorithms/pedersen64_hash.leo Normal file
View File

@ -0,0 +1,33 @@
/*
namespace: Compile
expectation: Pass
input_file: inputs/int64.in
*/
function main(
i8_value: i8,
i16_value: i16,
i32_value: i32,
i64_value: i64,
u8_value: u8,
u16_value: u16,
u32_value: u32,
u64_value: u64,
) -> field {
let bool_value: bool = true;
// let string_value: string = "helloworld";
// Pedersen64 hash tests
let a: field = Pedersen64::hash(bool_value);
let b: field = Pedersen64::hash(i8_value);
let c: field = Pedersen64::hash(i16_value);
let d: field = Pedersen64::hash(i32_value);
let e: field = Pedersen64::hash(i64_value);
let f: field = Pedersen64::hash(u8_value);
let g: field = Pedersen64::hash(u16_value);
let h: field = Pedersen64::hash(u32_value);
let i: field = Pedersen64::hash(u64_value);
// let j11: field = Pedersen64::hash(string_value);
return a + i;
}

70
tests/compiler/core/algorithms/poseidon.leo
View File

@ -1,70 +0,0 @@
/*
namespace: Compile
expectation: Pass
*/
function main() -> bool {
let owner: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta;
let bool_value: bool = true;
let field_value: field = 1field;
let group_value: group = (0, 1)group;
let i8_value: i8 = 1i8;
let i16_value: i16 = 1i16;
let i32_value: i32 = 1i32;
let i64_value: i64 = 1i64;
let i128_value: i128 = 1i128;
let u8_value: u8 = 1u8;
let u16_value: u16 = 1u16;
let u32_value: u32 = 1u32;
let u64_value: u64 = 1u64;
let u128_value: u128 = 1u128;
let scalar_value: scalar = 1scalar;
let string_value: string = "helloworld";
// Poseidon2 hash tests
let a1: field = Poseidon2::hash(field_value);
let b1: field = Poseidon2::hash(i8_value);
let c1: field = Poseidon2::hash(i16_value);
let d1: field = Poseidon2::hash(i32_value);
let e1: field = Poseidon2::hash(i64_value);
let f1: field = Poseidon2::hash(i128_value);
let g1: field = Poseidon2::hash(u8_value);
let h1: field = Poseidon2::hash(u16_value);
let i1: field = Poseidon2::hash(u32_value);
let j1: field = Poseidon2::hash(u64_value);
let k1: field = Poseidon2::hash(u128_value);
let l1: field = Poseidon2::hash(scalar_value);
let m1: field = Poseidon2::hash(string_value);
// Poseidon4 hash tests
let a2: field = Poseidon4::hash(field_value);
let b2: field = Poseidon4::hash(i8_value);
let c2: field = Poseidon4::hash(i16_value);
let d2: field = Poseidon4::hash(i32_value);
let e2: field = Poseidon4::hash(i64_value);
let f2: field = Poseidon4::hash(i128_value);
let g2: field = Poseidon4::hash(u8_value);
let h2: field = Poseidon4::hash(u16_value);
let i2: field = Poseidon4::hash(u32_value);
let j2: field = Poseidon4::hash(u64_value);
let k2: field = Poseidon4::hash(u128_value);
let l2: field = Poseidon4::hash(scalar_value);
let m2: field = Poseidon4::hash(string_value);
// Poseidon8 hash tests
let a3: field = Poseidon8::hash(field_value);
let b3: field = Poseidon8::hash(i8_value);
let c3: field = Poseidon8::hash(i16_value);
let d3: field = Poseidon8::hash(i32_value);
let e3: field = Poseidon8::hash(i64_value);
let f3: field = Poseidon8::hash(i128_value);
let g3: field = Poseidon8::hash(u8_value);
let h3: field = Poseidon8::hash(u16_value);
let i3: field = Poseidon8::hash(u32_value);
let j3: field = Poseidon8::hash(u64_value);
let k3: field = Poseidon8::hash(u128_value);
let l3: field = Poseidon8::hash(scalar_value);
let m3: field = Poseidon8::hash(string_value);
return true;
}

39
tests/compiler/core/algorithms/poseidon2_hash.leo Normal file
View File

@ -0,0 +1,39 @@
/*
namespace: Compile
expectation: Pass
input_file: inputs/int64.in
*/
function main(
i8_value: i8,
i16_value: i16,
i32_value: i32,
i64_value: i64,
u8_value: u8,
u16_value: u16,
u32_value: u32,
u64_value: u64,
) -> field {
let field_value: field = 1field;
let i128_value: i128 = 1i128;
let u128_value: u128 = 1u128;
let scalar_value: scalar = 1scalar;
// let string_value: string = "helloworld";
// Poseidon2 hash tests
let a: field = Poseidon2::hash(field_value);
let b: field = Poseidon2::hash(i8_value);
let c: field = Poseidon2::hash(i16_value);
let d: field = Poseidon2::hash(i32_value);
let e: field = Poseidon2::hash(i64_value);
let f: field = Poseidon2::hash(i128_value);
let g: field = Poseidon2::hash(u8_value);
let h: field = Poseidon2::hash(u16_value);
let i: field = Poseidon2::hash(u32_value);
let j: field = Poseidon2::hash(u64_value);
let k: field = Poseidon2::hash(u128_value);
let l: field = Poseidon2::hash(scalar_value);
// let m: field = Poseidon2::hash(string_value);
return a + l;
}

39
tests/compiler/core/algorithms/poseidon4_hash.leo Normal file
View File

@ -0,0 +1,39 @@
/*
namespace: Compile
expectation: Pass
input_file: inputs/int64.in
*/
function main(
i8_value: i8,
i16_value: i16,
i32_value: i32,
i64_value: i64,
u8_value: u8,
u16_value: u16,
u32_value: u32,
u64_value: u64,
) -> field {
let field_value: field = 1field;
let i128_value: i128 = 1i128;
let u128_value: u128 = 1u128;
let scalar_value: scalar = 1scalar;
// let string_value: string = "helloworld";
// Poseidon4 hash tests
let a: field = Poseidon4::hash(field_value);
let b: field = Poseidon4::hash(i8_value);
let c: field = Poseidon4::hash(i16_value);
let d: field = Poseidon4::hash(i32_value);
let e: field = Poseidon4::hash(i64_value);
let f: field = Poseidon4::hash(i128_value);
let g: field = Poseidon4::hash(u8_value);
let h: field = Poseidon4::hash(u16_value);
let i: field = Poseidon4::hash(u32_value);
let j: field = Poseidon4::hash(u64_value);
let k: field = Poseidon4::hash(u128_value);
let l: field = Poseidon4::hash(scalar_value);
// let m: field = Poseidon4::hash(string_value);
return a + l;
}

39
tests/compiler/core/algorithms/poseidon8_hash.leo Normal file
View File

@ -0,0 +1,39 @@
/*
namespace: Compile
expectation: Pass
input_file: inputs/int64.in
*/
function main(
i8_value: i8,
i16_value: i16,
i32_value: i32,
i64_value: i64,
u8_value: u8,
u16_value: u16,
u32_value: u32,
u64_value: u64,
) -> field {
let field_value: field = 1field;
let i128_value: i128 = 1i128;
let u128_value: u128 = 1u128;
let scalar_value: scalar = 1scalar;
// let string_value: string = "helloworld";
// Poseidon8 hash tests
let a: field = Poseidon8::hash(field_value);
let b: field = Poseidon8::hash(i8_value);
let c: field = Poseidon8::hash(i16_value);
let d: field = Poseidon8::hash(i32_value);
let e: field = Poseidon8::hash(i64_value);
let f: field = Poseidon8::hash(i128_value);
let g: field = Poseidon8::hash(u8_value);
let h: field = Poseidon8::hash(u16_value);
let i: field = Poseidon8::hash(u32_value);
let j: field = Poseidon8::hash(u64_value);
let k: field = Poseidon8::hash(u128_value);
let l: field = Poseidon8::hash(scalar_value);
// let m: field = Poseidon8::hash(string_value);
return a + l;
}

20
tests/compiler/function/9_inputs_fail.leo Normal file
View File

@ -0,0 +1,20 @@
/*
namespace: Compile
expectation: Fail
input_file: inputs/nine.in
*/
// The maximum number of arguments to a function is 8.
function main(
a: u8,
b: u8,
c: u8,
d: u8,
e: u8,
f: u8,
g: u8,
h: u8,
i: u8,
) -> u8 {
return a + b + c + d + e + f + g + h + i
}

10
tests/compiler/function/inputs/nine.in Normal file
View File

@ -0,0 +1,10 @@
[main]
a: u8 = 1u8;
b: u8 = 2u8;
c: u8 = 3u8;
d: u8 = 4u8;
e: u8 = 5u8;
f: u8 = 6u8;
g: u8 = 7u8;
h: u8 = 8u8;
i: u8 = 9u8;

9
tests/expectations/compiler/core/algorithms/bhp1024_commit.out Normal file
View File

@ -0,0 +1,9 @@
---
namespace: Compile
expectation: Pass
outputs:
- output:
- initial_input_ast: 27bbdd2fe5dc1a75a4bd2aa543e12b7c284ab950028657fc0087dfef631664b9
initial_ast: 679d4f1ad4a54d3821e5f85c64e5e253dbf8ee07aaac7fc7ec2e086f2cbaa909
unrolled_ast: 679d4f1ad4a54d3821e5f85c64e5e253dbf8ee07aaac7fc7ec2e086f2cbaa909
ssa_ast: 6860f1b6b49a9bd0bf1c0f4afa8ad0067036196b5de4b17b26bbae9657f204f9

9
tests/expectations/compiler/core/algorithms/bhp1024_hash.out Normal file
View File

@ -0,0 +1,9 @@
---
namespace: Compile
expectation: Pass
outputs:
- output:
- initial_input_ast: 4a84cbe8cc7ea360153e9da6f2d475dcbb4921c329fe8dd3b4cdca617b6d38a6
initial_ast: 8a961f82417010275495fdcc212292b809a71969396604e49e745fef94b3086f
unrolled_ast: 8a961f82417010275495fdcc212292b809a71969396604e49e745fef94b3086f
ssa_ast: 3d31265bf4923378c3202c852c599fad1dcd196920c23b4596186f1dcff0abe9

9
tests/expectations/compiler/core/algorithms/bhp256_commit.out Normal file
View File

@ -0,0 +1,9 @@
---
namespace: Compile
expectation: Pass
outputs:
- output:
- initial_input_ast: 71055ce4ed5911b2afac14a8719573d4ffb9a72959e060f284122350dbda53df
initial_ast: 46df628c79eeda6fe31fdee9cd1dccb921b45efc9bc203d5d9ce6bda069f6be2
unrolled_ast: 46df628c79eeda6fe31fdee9cd1dccb921b45efc9bc203d5d9ce6bda069f6be2
ssa_ast: b2911915da86b51ed768cd8eb81f6b0c6aeda73de1e76278a75db44c3cc3fd76

9
tests/expectations/compiler/core/algorithms/bhp256_hash.out Normal file
View File

@ -0,0 +1,9 @@
---
namespace: Compile
expectation: Pass
outputs:
- output:
- initial_input_ast: 5fa4b39f9cd209357769110ef49f609e2acce0c38f9def3f2ed7fcb4ce1b2240
initial_ast: 78c14952814d10190e26fa2fa4470e6af854fd6cff96e8c3c768662daa2aa005
unrolled_ast: 78c14952814d10190e26fa2fa4470e6af854fd6cff96e8c3c768662daa2aa005
ssa_ast: 484e4cbfade2151163bc2c09b542c6746fc9fbcf208473454aa08002c1e13c1f

9
tests/expectations/compiler/core/algorithms/bhp512_commit.out Normal file
View File

@ -0,0 +1,9 @@
---
namespace: Compile
expectation: Pass
outputs:
- output:
- initial_input_ast: 71055ce4ed5911b2afac14a8719573d4ffb9a72959e060f284122350dbda53df
initial_ast: 505d1cdcee0dac47f49fea5f7af40c20a2262677aa7d8caf3b7051f4b5c70a6e
unrolled_ast: 505d1cdcee0dac47f49fea5f7af40c20a2262677aa7d8caf3b7051f4b5c70a6e
ssa_ast: cdccc90d8023edcf5e6ef7ab7dc42fe8812889cbbf6bb5bcf74a5628edc7d2eb

9
tests/expectations/compiler/core/algorithms/bhp512_hash.out Normal file
View File

@ -0,0 +1,9 @@
---
namespace: Compile
expectation: Pass
outputs:
- output:
- initial_input_ast: 5fa4b39f9cd209357769110ef49f609e2acce0c38f9def3f2ed7fcb4ce1b2240
initial_ast: 0f72dc8f0fe5a8bf44067f5928a1835d0fc58551cda0280400060ff3519e02e2
unrolled_ast: 0f72dc8f0fe5a8bf44067f5928a1835d0fc58551cda0280400060ff3519e02e2
ssa_ast: 3da7df0dd03e5215a9df1095f875ecaaa2c549810b961b3444a168fe5cccde9a

9
tests/expectations/compiler/core/algorithms/bhp768_commit.out Normal file
View File

@ -0,0 +1,9 @@
---
namespace: Compile
expectation: Pass
outputs:
- output:
- initial_input_ast: 71055ce4ed5911b2afac14a8719573d4ffb9a72959e060f284122350dbda53df
initial_ast: 1697ade1991b3fe9489d04a4b1c9d2f85defceea27455664a8dd6aad9d67c363
unrolled_ast: 1697ade1991b3fe9489d04a4b1c9d2f85defceea27455664a8dd6aad9d67c363
ssa_ast: ebb84c20196355f32d94db47d1b594ffd6c8ae078f47cf5f05986aa32b894185

9
tests/expectations/compiler/core/algorithms/bhp768_hash.out Normal file
View File

@ -0,0 +1,9 @@
---
namespace: Compile
expectation: Pass
outputs:
- output:
- initial_input_ast: 5fa4b39f9cd209357769110ef49f609e2acce0c38f9def3f2ed7fcb4ce1b2240
initial_ast: af795006736c973728c5d91f2ce6a4771dca2b71249e7d2c7d189326918a168f
unrolled_ast: af795006736c973728c5d91f2ce6a4771dca2b71249e7d2c7d189326918a168f
ssa_ast: 60cd32ce055a0a051d8a0894ec014ad4a90b76c27a5ee18463373ec2fb5fc1fe

9
tests/expectations/compiler/core/algorithms/pedersen128_hash.out Normal file
View File

@ -0,0 +1,9 @@
---
namespace: Compile
expectation: Pass
outputs:
- output:
- initial_input_ast: 356dd963e90ec1d3b56f169372c9e9bb2b70d053df96359cfd150679919c758a
initial_ast: 96d1ffc3060c89b3441c0fc5bc8e8b7d9a6982117c6634b0c7c26b1fe0be587a
unrolled_ast: 96d1ffc3060c89b3441c0fc5bc8e8b7d9a6982117c6634b0c7c26b1fe0be587a
ssa_ast: 3788cd3b3b7ffe50fabdaa88d8f61452a14da116622ccdb14a34bdff848e2d17

9
tests/expectations/compiler/core/algorithms/pedersen64_hash.out Normal file
View File

@ -0,0 +1,9 @@
---
namespace: Compile
expectation: Pass
outputs:
- output:
- initial_input_ast: 5395306a6ab6901b3c5df094b3b49dbe5f29fb5886c5f0718097fbe5acd7602e
initial_ast: cf4a7dbbf0e7f4d0518c62104d6e89f4eff178bab8df5417286d9214a2704401
unrolled_ast: cf4a7dbbf0e7f4d0518c62104d6e89f4eff178bab8df5417286d9214a2704401
ssa_ast: 663b8b6703900c217dfef21d2b52162c49eb48f2fffc74d7054db99cd5e6d669

5
tests/expectations/compiler/core/algorithms/pedersen_fail.out Normal file
View File

@ -0,0 +1,5 @@
---
namespace: Compile
expectation: Fail
outputs:
- "Error [ETYC0372007]: Expected one type from `boolean, i8, i16, i32, i64, u8, u16, u32, u64, string`, but got `u128`\n --> compiler-test:4:20\n |\n 4 | let a: group = Pedersen64::hash(1u128);\n | ^^^^^^^^^^^^^^^^^^^^^^^\nError [ETYC0372003]: Expected type `group` but type `field` was found\n --> compiler-test:4:20\n |\n 4 | let a: group = Pedersen64::hash(1u128);\n | ^^^^^^^^^^^^^^^^^^^^^^^\n"

9
tests/expectations/compiler/core/algorithms/poseidon2_hash.out Normal file
View File

@ -0,0 +1,9 @@
---
namespace: Compile
expectation: Pass
outputs:
- output:
- initial_input_ast: 67384917f58c90880ca198b9a636e84c55d97b1068a3c88c1c4734577c798577
initial_ast: 58d78478c0f85a019221ebdc21e79083d80f70774210934a18eee5fce7d588d1
unrolled_ast: 58d78478c0f85a019221ebdc21e79083d80f70774210934a18eee5fce7d588d1
ssa_ast: 4ee97e337b3cf59243e63f1339f4e5a060cc38d45378e6bb1a040ff4ba5320c6

9
tests/expectations/compiler/core/algorithms/poseidon4_hash.out Normal file
View File

@ -0,0 +1,9 @@
---
namespace: Compile
expectation: Pass
outputs:
- output:
- initial_input_ast: 67384917f58c90880ca198b9a636e84c55d97b1068a3c88c1c4734577c798577
initial_ast: 086408c110059f1af409ca0dfbfadf85b8c3ed55f28bc76e133bc57cf832ed21
unrolled_ast: 086408c110059f1af409ca0dfbfadf85b8c3ed55f28bc76e133bc57cf832ed21
ssa_ast: 3681b11adb8495432eb3e13378f5b70030bd7c643d8765ae6251a2f17120139f

9
tests/expectations/compiler/core/algorithms/poseidon8_hash.out Normal file
View File

@ -0,0 +1,9 @@
---
namespace: Compile
expectation: Pass
outputs:
- output:
- initial_input_ast: 67384917f58c90880ca198b9a636e84c55d97b1068a3c88c1c4734577c798577
initial_ast: 632a5144ec2fe401dc832a98bb6c8244272fd08799af229fc6fea179a8788ca3
unrolled_ast: 632a5144ec2fe401dc832a98bb6c8244272fd08799af229fc6fea179a8788ca3
ssa_ast: 6749addd8071f14f367b8af4514b497c9ae2d19780ae7d68a0a4d1dd359458cf