From 82b39a81e97e9f5f820c950ae4ce50ea1f60e6b0 Mon Sep 17 00:00:00 2001 From: Collin Chin <16715212+collinc97@users.noreply.github.com> Date: Fri, 22 Sep 2023 08:31:30 -0700 Subject: [PATCH] implement Keccak256 Keccak384 Keccak512 with tests (#2603) --- compiler/ast/src/core/mod.rs | 19 -- compiler/ast/src/functions/core_function.rs | 177 ++++++++++++++++++ .../src/code_generation/visit_expressions.rs | 9 + compiler/passes/src/type_checking/checker.rs | 42 +++++ compiler/span/src/symbol.rs | 3 + .../keccak256/keccak256_hash_to_i128.out | 15 ++ .../keccak256/keccak256_hash_to_i16.out | 15 ++ .../keccak256/keccak256_hash_to_i32.out | 15 ++ .../keccak256/keccak256_hash_to_i64.out | 15 ++ .../keccak256/keccak256_hash_to_i8.out | 15 ++ .../keccak256/keccak256_hash_to_u128.out | 15 ++ .../keccak256/keccak256_hash_to_u16.out | 15 ++ .../keccak256/keccak256_hash_to_u32.out | 15 ++ .../keccak256/keccak256_hash_to_u64.out | 15 ++ .../keccak256/keccak256_hash_to_u8.out | 15 ++ .../keccak384/keccak384_hash_to_i128.out | 15 ++ .../keccak384/keccak384_hash_to_i16.out | 15 ++ .../keccak384/keccak384_hash_to_i32.out | 15 ++ .../keccak384/keccak384_hash_to_i64.out | 15 ++ .../keccak384/keccak384_hash_to_i8.out | 15 ++ .../keccak384/keccak384_hash_to_u128.out | 15 ++ .../keccak384/keccak384_hash_to_u16.out | 15 ++ .../keccak384/keccak384_hash_to_u32.out | 15 ++ .../keccak384/keccak384_hash_to_u64.out | 15 ++ .../keccak384/keccak384_hash_to_u8.out | 15 ++ .../keccak512/keccak512_hash_to_i128.out | 15 ++ .../keccak512/keccak512_hash_to_i16.out | 15 ++ .../keccak512/keccak512_hash_to_i32.out | 15 ++ .../keccak512/keccak512_hash_to_i64.out | 15 ++ .../keccak512/keccak512_hash_to_i8.out | 15 ++ .../keccak512/keccak512_hash_to_u128.out | 15 ++ .../keccak512/keccak512_hash_to_u16.out | 15 ++ .../keccak512/keccak512_hash_to_u32.out | 15 ++ .../keccak512/keccak512_hash_to_u64.out | 15 ++ .../keccak512/keccak512_hash_to_u8.out | 15 ++ .../algorithms/keccak256_hash_to_address.out | 15 ++ .../algorithms/keccak256_hash_to_field.out | 15 ++ .../algorithms/keccak256_hash_to_group.out | 15 ++ .../algorithms/keccak256_hash_to_scalar.out | 15 ++ .../algorithms/keccak384_hash_to_address.out | 15 ++ .../algorithms/keccak384_hash_to_field.out | 15 ++ .../algorithms/keccak384_hash_to_group.out | 15 ++ .../algorithms/keccak384_hash_to_scalar.out | 15 ++ .../algorithms/keccak512_hash_to_address.out | 15 ++ .../algorithms/keccak512_hash_to_field.out | 15 ++ .../algorithms/keccak512_hash_to_group.out | 15 ++ .../algorithms/keccak512_hash_to_scalar.out | 15 ++ .../keccak256/keccak256_hash_to_i128.leo | 52 +++++ .../keccak256/keccak256_hash_to_i16.leo | 52 +++++ .../keccak256/keccak256_hash_to_i32.leo | 52 +++++ .../keccak256/keccak256_hash_to_i64.leo | 52 +++++ .../keccak256/keccak256_hash_to_i8.leo | 52 +++++ .../keccak256/keccak256_hash_to_u128.leo | 52 +++++ .../keccak256/keccak256_hash_to_u16.leo | 52 +++++ .../keccak256/keccak256_hash_to_u32.leo | 52 +++++ .../keccak256/keccak256_hash_to_u64.leo | 52 +++++ .../keccak256/keccak256_hash_to_u8.leo | 52 +++++ .../keccak384/keccak384_hash_to_i128.leo | 52 +++++ .../keccak384/keccak384_hash_to_i16.leo | 52 +++++ .../keccak384/keccak384_hash_to_i32.leo | 52 +++++ .../keccak384/keccak384_hash_to_i64.leo | 52 +++++ .../keccak384/keccak384_hash_to_i8.leo | 52 +++++ .../keccak384/keccak384_hash_to_u128.leo | 52 +++++ .../keccak384/keccak384_hash_to_u16.leo | 52 +++++ .../keccak384/keccak384_hash_to_u32.leo | 52 +++++ .../keccak384/keccak384_hash_to_u64.leo | 52 +++++ .../keccak384/keccak384_hash_to_u8.leo | 52 +++++ .../keccak512/keccak512_hash_to_i128.leo | 52 +++++ .../keccak512/keccak512_hash_to_i16.leo | 52 +++++ .../keccak512/keccak512_hash_to_i32.leo | 52 +++++ .../keccak512/keccak512_hash_to_i64.leo | 52 +++++ .../keccak512/keccak512_hash_to_i8.leo | 52 +++++ .../keccak512/keccak512_hash_to_u128.leo | 52 +++++ .../keccak512/keccak512_hash_to_u16.leo | 52 +++++ .../keccak512/keccak512_hash_to_u32.leo | 52 +++++ .../keccak512/keccak512_hash_to_u64.leo | 52 +++++ .../keccak512/keccak512_hash_to_u8.leo | 52 +++++ .../algorithms/keccak256_hash_to_address.leo | 52 +++++ .../algorithms/keccak256_hash_to_field.leo | 51 +++++ .../algorithms/keccak256_hash_to_group.leo | 51 +++++ .../algorithms/keccak256_hash_to_scalar.leo | 51 +++++ .../algorithms/keccak384_hash_to_address.leo | 52 +++++ .../algorithms/keccak384_hash_to_field.leo | 51 +++++ .../algorithms/keccak384_hash_to_group.leo | 51 +++++ .../algorithms/keccak384_hash_to_scalar.leo | 51 +++++ .../algorithms/keccak512_hash_to_address.leo | 52 +++++ .../algorithms/keccak512_hash_to_field.leo | 51 +++++ .../algorithms/keccak512_hash_to_group.leo | 51 +++++ .../algorithms/keccak512_hash_to_scalar.leo | 51 +++++ 89 files changed, 3036 insertions(+), 19 deletions(-) delete mode 100644 compiler/ast/src/core/mod.rs create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i128.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i16.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i32.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i64.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i8.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u128.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u16.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u32.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u64.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u8.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i128.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i16.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i32.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i64.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i8.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u128.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u16.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u32.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u64.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u8.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i128.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i16.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i32.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i64.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i8.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u128.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u16.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u32.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u64.out create mode 100644 tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u8.out create mode 100644 tests/expectations/compiler/core/algorithms/keccak256_hash_to_address.out create mode 100644 tests/expectations/compiler/core/algorithms/keccak256_hash_to_field.out create mode 100644 tests/expectations/compiler/core/algorithms/keccak256_hash_to_group.out create mode 100644 tests/expectations/compiler/core/algorithms/keccak256_hash_to_scalar.out create mode 100644 tests/expectations/compiler/core/algorithms/keccak384_hash_to_address.out create mode 100644 tests/expectations/compiler/core/algorithms/keccak384_hash_to_field.out create mode 100644 tests/expectations/compiler/core/algorithms/keccak384_hash_to_group.out create mode 100644 tests/expectations/compiler/core/algorithms/keccak384_hash_to_scalar.out create mode 100644 tests/expectations/compiler/core/algorithms/keccak512_hash_to_address.out create mode 100644 tests/expectations/compiler/core/algorithms/keccak512_hash_to_field.out create mode 100644 tests/expectations/compiler/core/algorithms/keccak512_hash_to_group.out create mode 100644 tests/expectations/compiler/core/algorithms/keccak512_hash_to_scalar.out create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i128.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i16.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i32.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i64.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i8.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u128.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u16.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u32.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u64.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u8.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i128.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i16.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i32.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i64.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i8.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u128.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u16.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u32.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u64.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u8.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i128.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i16.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i32.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i64.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i8.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u128.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u16.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u32.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u64.leo create mode 100644 tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u8.leo create mode 100644 tests/tests/compiler/core/algorithms/keccak256_hash_to_address.leo create mode 100644 tests/tests/compiler/core/algorithms/keccak256_hash_to_field.leo create mode 100644 tests/tests/compiler/core/algorithms/keccak256_hash_to_group.leo create mode 100644 tests/tests/compiler/core/algorithms/keccak256_hash_to_scalar.leo create mode 100644 tests/tests/compiler/core/algorithms/keccak384_hash_to_address.leo create mode 100644 tests/tests/compiler/core/algorithms/keccak384_hash_to_field.leo create mode 100644 tests/tests/compiler/core/algorithms/keccak384_hash_to_group.leo create mode 100644 tests/tests/compiler/core/algorithms/keccak384_hash_to_scalar.leo create mode 100644 tests/tests/compiler/core/algorithms/keccak512_hash_to_address.leo create mode 100644 tests/tests/compiler/core/algorithms/keccak512_hash_to_field.leo create mode 100644 tests/tests/compiler/core/algorithms/keccak512_hash_to_group.leo create mode 100644 tests/tests/compiler/core/algorithms/keccak512_hash_to_scalar.leo diff --git a/compiler/ast/src/core/mod.rs b/compiler/ast/src/core/mod.rs deleted file mode 100644 index 27caeebc3b..0000000000 --- a/compiler/ast/src/core/mod.rs +++ /dev/null @@ -1,19 +0,0 @@ -// Copyright (C) 2019-2023 Aleo Systems Inc. -// This file is part of the Leo library. - -// The Leo library is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. - -// The Leo library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License -// along with the Leo library. If not, see . - -//! The core library structures for a Leo program. - -pub struct BHP \ No newline at end of file diff --git a/compiler/ast/src/functions/core_function.rs b/compiler/ast/src/functions/core_function.rs index 4587bf219b..b3e2c59414 100644 --- a/compiler/ast/src/functions/core_function.rs +++ b/compiler/ast/src/functions/core_function.rs @@ -107,6 +107,51 @@ pub enum CoreFunction { ChaChaRandU128, ChaChaRandScalar, + Keccak256HashToAddress, + Keccak256HashToField, + Keccak256HashToGroup, + Keccak256HashToI8, + Keccak256HashToI16, + Keccak256HashToI32, + Keccak256HashToI64, + Keccak256HashToI128, + Keccak256HashToU8, + Keccak256HashToU16, + Keccak256HashToU32, + Keccak256HashToU64, + Keccak256HashToU128, + Keccak256HashToScalar, + + Keccak384HashToAddress, + Keccak384HashToField, + Keccak384HashToGroup, + Keccak384HashToI8, + Keccak384HashToI16, + Keccak384HashToI32, + Keccak384HashToI64, + Keccak384HashToI128, + Keccak384HashToU8, + Keccak384HashToU16, + Keccak384HashToU32, + Keccak384HashToU64, + Keccak384HashToU128, + Keccak384HashToScalar, + + Keccak512HashToAddress, + Keccak512HashToField, + Keccak512HashToGroup, + Keccak512HashToI8, + Keccak512HashToI16, + Keccak512HashToI32, + Keccak512HashToI64, + Keccak512HashToI128, + Keccak512HashToU8, + Keccak512HashToU16, + Keccak512HashToU32, + Keccak512HashToU64, + Keccak512HashToU128, + Keccak512HashToScalar, + Pedersen64CommitToAddress, Pedersen64CommitToField, Pedersen64CommitToGroup, @@ -293,6 +338,51 @@ impl CoreFunction { (sym::ChaCha, sym::rand_u64) => Self::ChaChaRandU64, (sym::ChaCha, sym::rand_u128) => Self::ChaChaRandU128, + (sym::Keccak256, sym::hash_to_address) => Self::Keccak256HashToAddress, + (sym::Keccak256, sym::hash_to_field) => Self::Keccak256HashToField, + (sym::Keccak256, sym::hash_to_group) => Self::Keccak256HashToGroup, + (sym::Keccak256, sym::hash_to_i8) => Self::Keccak256HashToI8, + (sym::Keccak256, sym::hash_to_i16) => Self::Keccak256HashToI16, + (sym::Keccak256, sym::hash_to_i32) => Self::Keccak256HashToI32, + (sym::Keccak256, sym::hash_to_i64) => Self::Keccak256HashToI64, + (sym::Keccak256, sym::hash_to_i128) => Self::Keccak256HashToI128, + (sym::Keccak256, sym::hash_to_u8) => Self::Keccak256HashToU8, + (sym::Keccak256, sym::hash_to_u16) => Self::Keccak256HashToU16, + (sym::Keccak256, sym::hash_to_u32) => Self::Keccak256HashToU32, + (sym::Keccak256, sym::hash_to_u64) => Self::Keccak256HashToU64, + (sym::Keccak256, sym::hash_to_u128) => Self::Keccak256HashToU128, + (sym::Keccak256, sym::hash_to_scalar) => Self::Keccak256HashToScalar, + + (sym::Keccak384, sym::hash_to_address) => Self::Keccak384HashToAddress, + (sym::Keccak384, sym::hash_to_field) => Self::Keccak384HashToField, + (sym::Keccak384, sym::hash_to_group) => Self::Keccak384HashToGroup, + (sym::Keccak384, sym::hash_to_i8) => Self::Keccak384HashToI8, + (sym::Keccak384, sym::hash_to_i16) => Self::Keccak384HashToI16, + (sym::Keccak384, sym::hash_to_i32) => Self::Keccak384HashToI32, + (sym::Keccak384, sym::hash_to_i64) => Self::Keccak384HashToI64, + (sym::Keccak384, sym::hash_to_i128) => Self::Keccak384HashToI128, + (sym::Keccak384, sym::hash_to_u8) => Self::Keccak384HashToU8, + (sym::Keccak384, sym::hash_to_u16) => Self::Keccak384HashToU16, + (sym::Keccak384, sym::hash_to_u32) => Self::Keccak384HashToU32, + (sym::Keccak384, sym::hash_to_u64) => Self::Keccak384HashToU64, + (sym::Keccak384, sym::hash_to_u128) => Self::Keccak384HashToU128, + (sym::Keccak384, sym::hash_to_scalar) => Self::Keccak384HashToScalar, + + (sym::Keccak512, sym::hash_to_address) => Self::Keccak512HashToAddress, + (sym::Keccak512, sym::hash_to_field) => Self::Keccak512HashToField, + (sym::Keccak512, sym::hash_to_group) => Self::Keccak512HashToGroup, + (sym::Keccak512, sym::hash_to_i8) => Self::Keccak512HashToI8, + (sym::Keccak512, sym::hash_to_i16) => Self::Keccak512HashToI16, + (sym::Keccak512, sym::hash_to_i32) => Self::Keccak512HashToI32, + (sym::Keccak512, sym::hash_to_i64) => Self::Keccak512HashToI64, + (sym::Keccak512, sym::hash_to_i128) => Self::Keccak512HashToI128, + (sym::Keccak512, sym::hash_to_u8) => Self::Keccak512HashToU8, + (sym::Keccak512, sym::hash_to_u16) => Self::Keccak512HashToU16, + (sym::Keccak512, sym::hash_to_u32) => Self::Keccak512HashToU32, + (sym::Keccak512, sym::hash_to_u64) => Self::Keccak512HashToU64, + (sym::Keccak512, sym::hash_to_u128) => Self::Keccak512HashToU128, + (sym::Keccak512, sym::hash_to_scalar) => Self::Keccak512HashToScalar, + (sym::Pedersen64, sym::commit_to_address) => Self::Pedersen64CommitToAddress, (sym::Pedersen64, sym::commit_to_field) => Self::Pedersen64CommitToField, (sym::Pedersen64, sym::commit_to_group) => Self::Pedersen64CommitToGroup, @@ -480,6 +570,51 @@ impl CoreFunction { Self::ChaChaRandU128 => 0, Self::ChaChaRandScalar => 0, + Self::Keccak256HashToAddress => 1, + Self::Keccak256HashToField => 1, + Self::Keccak256HashToGroup => 1, + Self::Keccak256HashToI8 => 1, + Self::Keccak256HashToI16 => 1, + Self::Keccak256HashToI32 => 1, + Self::Keccak256HashToI64 => 1, + Self::Keccak256HashToI128 => 1, + Self::Keccak256HashToU8 => 1, + Self::Keccak256HashToU16 => 1, + Self::Keccak256HashToU32 => 1, + Self::Keccak256HashToU64 => 1, + Self::Keccak256HashToU128 => 1, + Self::Keccak256HashToScalar => 1, + + Self::Keccak384HashToAddress => 1, + Self::Keccak384HashToField => 1, + Self::Keccak384HashToGroup => 1, + Self::Keccak384HashToI8 => 1, + Self::Keccak384HashToI16 => 1, + Self::Keccak384HashToI32 => 1, + Self::Keccak384HashToI64 => 1, + Self::Keccak384HashToI128 => 1, + Self::Keccak384HashToU8 => 1, + Self::Keccak384HashToU16 => 1, + Self::Keccak384HashToU32 => 1, + Self::Keccak384HashToU64 => 1, + Self::Keccak384HashToU128 => 1, + Self::Keccak384HashToScalar => 1, + + Self::Keccak512HashToAddress => 1, + Self::Keccak512HashToField => 1, + Self::Keccak512HashToGroup => 1, + Self::Keccak512HashToI8 => 1, + Self::Keccak512HashToI16 => 1, + Self::Keccak512HashToI32 => 1, + Self::Keccak512HashToI64 => 1, + Self::Keccak512HashToI128 => 1, + Self::Keccak512HashToU8 => 1, + Self::Keccak512HashToU16 => 1, + Self::Keccak512HashToU32 => 1, + Self::Keccak512HashToU64 => 1, + Self::Keccak512HashToU128 => 1, + Self::Keccak512HashToScalar => 1, + Self::Pedersen64CommitToAddress => 2, Self::Pedersen64CommitToField => 2, Self::Pedersen64CommitToGroup => 2, @@ -665,6 +800,48 @@ impl CoreFunction { | CoreFunction::BHP1024HashToU64 | CoreFunction::BHP1024HashToU128 | CoreFunction::BHP1024HashToScalar + | CoreFunction::Keccak256HashToAddress + | CoreFunction::Keccak256HashToField + | CoreFunction::Keccak256HashToGroup + | CoreFunction::Keccak256HashToI8 + | CoreFunction::Keccak256HashToI16 + | CoreFunction::Keccak256HashToI32 + | CoreFunction::Keccak256HashToI64 + | CoreFunction::Keccak256HashToI128 + | CoreFunction::Keccak256HashToU8 + | CoreFunction::Keccak256HashToU16 + | CoreFunction::Keccak256HashToU32 + | CoreFunction::Keccak256HashToU64 + | CoreFunction::Keccak256HashToU128 + | CoreFunction::Keccak256HashToScalar + | CoreFunction::Keccak384HashToAddress + | CoreFunction::Keccak384HashToField + | CoreFunction::Keccak384HashToGroup + | CoreFunction::Keccak384HashToI8 + | CoreFunction::Keccak384HashToI16 + | CoreFunction::Keccak384HashToI32 + | CoreFunction::Keccak384HashToI64 + | CoreFunction::Keccak384HashToI128 + | CoreFunction::Keccak384HashToU8 + | CoreFunction::Keccak384HashToU16 + | CoreFunction::Keccak384HashToU32 + | CoreFunction::Keccak384HashToU64 + | CoreFunction::Keccak384HashToU128 + | CoreFunction::Keccak384HashToScalar + | CoreFunction::Keccak512HashToAddress + | CoreFunction::Keccak512HashToField + | CoreFunction::Keccak512HashToGroup + | CoreFunction::Keccak512HashToI8 + | CoreFunction::Keccak512HashToI16 + | CoreFunction::Keccak512HashToI32 + | CoreFunction::Keccak512HashToI64 + | CoreFunction::Keccak512HashToI128 + | CoreFunction::Keccak512HashToU8 + | CoreFunction::Keccak512HashToU16 + | CoreFunction::Keccak512HashToU32 + | CoreFunction::Keccak512HashToU64 + | CoreFunction::Keccak512HashToU128 + | CoreFunction::Keccak512HashToScalar | CoreFunction::Pedersen64CommitToAddress | CoreFunction::Pedersen64CommitToField | CoreFunction::Pedersen64CommitToGroup diff --git a/compiler/passes/src/code_generation/visit_expressions.rs b/compiler/passes/src/code_generation/visit_expressions.rs index 0280aec5d1..7e56444b52 100644 --- a/compiler/passes/src/code_generation/visit_expressions.rs +++ b/compiler/passes/src/code_generation/visit_expressions.rs @@ -315,6 +315,15 @@ impl<'a> CodeGenerator<'a> { Type::Identifier(Identifier { name: sym::BHP1024, .. }) => { construct_simple_function_call(&input.name, "bhp1024", arguments) } + Type::Identifier(Identifier { name: sym::Keccak256, .. }) => { + construct_simple_function_call(&input.name, "keccak256", arguments) + } + Type::Identifier(Identifier { name: sym::Keccak384, .. }) => { + construct_simple_function_call(&input.name, "keccak384", arguments) + } + Type::Identifier(Identifier { name: sym::Keccak512, .. }) => { + construct_simple_function_call(&input.name, "keccak512", arguments) + } Type::Identifier(Identifier { name: sym::Pedersen64, .. }) => { construct_simple_function_call(&input.name, "ped64", arguments) } diff --git a/compiler/passes/src/type_checking/checker.rs b/compiler/passes/src/type_checking/checker.rs index c0692ecbd2..8316a96b5b 100644 --- a/compiler/passes/src/type_checking/checker.rs +++ b/compiler/passes/src/type_checking/checker.rs @@ -480,6 +480,9 @@ impl<'a> TypeChecker<'a> { | CoreFunction::BHP512HashToAddress | CoreFunction::BHP768HashToAddress | CoreFunction::BHP1024HashToAddress + | CoreFunction::Keccak256HashToAddress + | CoreFunction::Keccak384HashToAddress + | CoreFunction::Keccak512HashToAddress | CoreFunction::Poseidon2HashToAddress | CoreFunction::Poseidon4HashToAddress | CoreFunction::Poseidon8HashToAddress => { @@ -491,6 +494,9 @@ impl<'a> TypeChecker<'a> { | CoreFunction::BHP512HashToField | CoreFunction::BHP768HashToField | CoreFunction::BHP1024HashToField + | CoreFunction::Keccak256HashToField + | CoreFunction::Keccak384HashToField + | CoreFunction::Keccak512HashToField | CoreFunction::Poseidon2HashToField | CoreFunction::Poseidon4HashToField | CoreFunction::Poseidon8HashToField => { @@ -502,6 +508,9 @@ impl<'a> TypeChecker<'a> { | CoreFunction::BHP512HashToGroup | CoreFunction::BHP768HashToGroup | CoreFunction::BHP1024HashToGroup + | CoreFunction::Keccak256HashToGroup + | CoreFunction::Keccak384HashToGroup + | CoreFunction::Keccak512HashToGroup | CoreFunction::Poseidon2HashToGroup | CoreFunction::Poseidon4HashToGroup | CoreFunction::Poseidon8HashToGroup => { @@ -513,6 +522,9 @@ impl<'a> TypeChecker<'a> { | CoreFunction::BHP512HashToI8 | CoreFunction::BHP768HashToI8 | CoreFunction::BHP1024HashToI8 + | CoreFunction::Keccak256HashToI8 + | CoreFunction::Keccak384HashToI8 + | CoreFunction::Keccak512HashToI8 | CoreFunction::Poseidon2HashToI8 | CoreFunction::Poseidon4HashToI8 | CoreFunction::Poseidon8HashToI8 => { @@ -524,6 +536,9 @@ impl<'a> TypeChecker<'a> { | CoreFunction::BHP512HashToI16 | CoreFunction::BHP768HashToI16 | CoreFunction::BHP1024HashToI16 + | CoreFunction::Keccak256HashToI16 + | CoreFunction::Keccak384HashToI16 + | CoreFunction::Keccak512HashToI16 | CoreFunction::Poseidon2HashToI16 | CoreFunction::Poseidon4HashToI16 | CoreFunction::Poseidon8HashToI16 => { @@ -535,6 +550,9 @@ impl<'a> TypeChecker<'a> { | CoreFunction::BHP512HashToI32 | CoreFunction::BHP768HashToI32 | CoreFunction::BHP1024HashToI32 + | CoreFunction::Keccak256HashToI32 + | CoreFunction::Keccak384HashToI32 + | CoreFunction::Keccak512HashToI32 | CoreFunction::Poseidon2HashToI32 | CoreFunction::Poseidon4HashToI32 | CoreFunction::Poseidon8HashToI32 => { @@ -546,6 +564,9 @@ impl<'a> TypeChecker<'a> { | CoreFunction::BHP512HashToI64 | CoreFunction::BHP768HashToI64 | CoreFunction::BHP1024HashToI64 + | CoreFunction::Keccak256HashToI64 + | CoreFunction::Keccak384HashToI64 + | CoreFunction::Keccak512HashToI64 | CoreFunction::Poseidon2HashToI64 | CoreFunction::Poseidon4HashToI64 | CoreFunction::Poseidon8HashToI64 => { @@ -557,6 +578,9 @@ impl<'a> TypeChecker<'a> { | CoreFunction::BHP512HashToI128 | CoreFunction::BHP768HashToI128 | CoreFunction::BHP1024HashToI128 + | CoreFunction::Keccak256HashToI128 + | CoreFunction::Keccak384HashToI128 + | CoreFunction::Keccak512HashToI128 | CoreFunction::Poseidon2HashToI128 | CoreFunction::Poseidon4HashToI128 | CoreFunction::Poseidon8HashToI128 => { @@ -568,6 +592,9 @@ impl<'a> TypeChecker<'a> { | CoreFunction::BHP512HashToU8 | CoreFunction::BHP768HashToU8 | CoreFunction::BHP1024HashToU8 + | CoreFunction::Keccak256HashToU8 + | CoreFunction::Keccak384HashToU8 + | CoreFunction::Keccak512HashToU8 | CoreFunction::Poseidon2HashToU8 | CoreFunction::Poseidon4HashToU8 | CoreFunction::Poseidon8HashToU8 => { @@ -579,6 +606,9 @@ impl<'a> TypeChecker<'a> { | CoreFunction::BHP512HashToU16 | CoreFunction::BHP768HashToU16 | CoreFunction::BHP1024HashToU16 + | CoreFunction::Keccak256HashToU16 + | CoreFunction::Keccak384HashToU16 + | CoreFunction::Keccak512HashToU16 | CoreFunction::Poseidon2HashToU16 | CoreFunction::Poseidon4HashToU16 | CoreFunction::Poseidon8HashToU16 => { @@ -590,6 +620,9 @@ impl<'a> TypeChecker<'a> { | CoreFunction::BHP512HashToU32 | CoreFunction::BHP768HashToU32 | CoreFunction::BHP1024HashToU32 + | CoreFunction::Keccak256HashToU32 + | CoreFunction::Keccak384HashToU32 + | CoreFunction::Keccak512HashToU32 | CoreFunction::Poseidon2HashToU32 | CoreFunction::Poseidon4HashToU32 | CoreFunction::Poseidon8HashToU32 => { @@ -601,6 +634,9 @@ impl<'a> TypeChecker<'a> { | CoreFunction::BHP512HashToU64 | CoreFunction::BHP768HashToU64 | CoreFunction::BHP1024HashToU64 + | CoreFunction::Keccak256HashToU64 + | CoreFunction::Keccak384HashToU64 + | CoreFunction::Keccak512HashToU64 | CoreFunction::Poseidon2HashToU64 | CoreFunction::Poseidon4HashToU64 | CoreFunction::Poseidon8HashToU64 => { @@ -612,6 +648,9 @@ impl<'a> TypeChecker<'a> { | CoreFunction::BHP512HashToU128 | CoreFunction::BHP768HashToU128 | CoreFunction::BHP1024HashToU128 + | CoreFunction::Keccak256HashToU128 + | CoreFunction::Keccak384HashToU128 + | CoreFunction::Keccak512HashToU128 | CoreFunction::Poseidon2HashToU128 | CoreFunction::Poseidon4HashToU128 | CoreFunction::Poseidon8HashToU128 => { @@ -623,6 +662,9 @@ impl<'a> TypeChecker<'a> { | CoreFunction::BHP512HashToScalar | CoreFunction::BHP768HashToScalar | CoreFunction::BHP1024HashToScalar + | CoreFunction::Keccak256HashToScalar + | CoreFunction::Keccak384HashToScalar + | CoreFunction::Keccak512HashToScalar | CoreFunction::Poseidon2HashToScalar | CoreFunction::Poseidon4HashToScalar | CoreFunction::Poseidon8HashToScalar => { diff --git a/compiler/span/src/symbol.rs b/compiler/span/src/symbol.rs index 09fad96b58..7d65dd7a3d 100644 --- a/compiler/span/src/symbol.rs +++ b/compiler/span/src/symbol.rs @@ -170,6 +170,9 @@ symbols! { hash_to_u64, hash_to_u128, hash_to_scalar, + Keccak256, + Keccak384, + Keccak512, Mapping, Pedersen64, Pedersen128, diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i128.out b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i128.out new file mode 100644 index 0000000000..205b37f354 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i128.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: d61b6c9a81578cd47a707319541ce1cea3ac5e20020f2a5b8c0b0363df72ceb4 + type_checked_symbol_table: 242199b3378fc1e61068a3091df5fbc413ee879c63a678cc7256ae0562d8e0f4 + unrolled_symbol_table: 242199b3378fc1e61068a3091df5fbc413ee879c63a678cc7256ae0562d8e0f4 + initial_ast: 3f9a76a267efe2dd807cceadf0eb1103ce3bbffe3dcef8e9c634e91409c4e92b + unrolled_ast: 3f9a76a267efe2dd807cceadf0eb1103ce3bbffe3dcef8e9c634e91409c4e92b + ssa_ast: 8b628af19edbff2ff6739329caaaded94bd2ebb42782605be95daf977d202f3d + flattened_ast: 006fec7dfcea9b8edc2c92a4ac8374b34bfa1689fd99603c193e8558eccb85b5 + inlined_ast: 006fec7dfcea9b8edc2c92a4ac8374b34bfa1689fd99603c193e8558eccb85b5 + dce_ast: e65f786ad28fb5cff8cc8c7c93044345ea38adeb483a5e04407c9c53908dbf2b + bytecode: 590389deb5b7da7e5210fcae5fed44bddf2b1a0bd6d2b30817eb650dd5efa343 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i16.out b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i16.out new file mode 100644 index 0000000000..c37a2c30b0 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i16.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 077422b93c97f7cd8a28ff1ba7bbe58e07c4b7887304c46d35eb5ac6bf23c972 + type_checked_symbol_table: 5f860d2de9a0608ecbc70179a65c645cd622701fee49e955c77387fa225b01a1 + unrolled_symbol_table: 5f860d2de9a0608ecbc70179a65c645cd622701fee49e955c77387fa225b01a1 + initial_ast: 5098cf163889f06c306729c4cdbe437adb141c68773ab5d7af6c9db6ce5322c1 + unrolled_ast: 5098cf163889f06c306729c4cdbe437adb141c68773ab5d7af6c9db6ce5322c1 + ssa_ast: fc0281305cba005e642f7ab23c4aed8e297be2c664743437376d117cdbdaff67 + flattened_ast: f3ed75e409db4058dc34f2d1f78aa261bbc7544054b7839e3cdbc3465d0a7534 + inlined_ast: f3ed75e409db4058dc34f2d1f78aa261bbc7544054b7839e3cdbc3465d0a7534 + dce_ast: b4e8cf9e9c30b67e29d24a8e143363d52f6474f80114649a82551346bdaccaa0 + bytecode: 6ae1c5f0b41e9982c661326ee81b26e8c0b6d400f5a8454117984c37ab4e492a + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i32.out b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i32.out new file mode 100644 index 0000000000..c34e83e52b --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i32.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 0b9e361a60499d11d8de9a427cd689b0904e3660092b6ff95a1c07bf09964e11 + type_checked_symbol_table: 58b695183f390fd270d2d7b521591c524ad80192b3c1e04fc7e691ebd5fdf24e + unrolled_symbol_table: 58b695183f390fd270d2d7b521591c524ad80192b3c1e04fc7e691ebd5fdf24e + initial_ast: d4e7c27ccca22155f837e3b6d0833c4de03a6d500fc6deae5f0cac748565ebbe + unrolled_ast: d4e7c27ccca22155f837e3b6d0833c4de03a6d500fc6deae5f0cac748565ebbe + ssa_ast: 400ea50666d5ba3e392f3cb0605f0246b08cf0cef2b971a28e62ba7d793efa59 + flattened_ast: 5ffb39defd930d8cb1972c4dd2f20affe949f5ac34d22c7143f06cf4af64ff98 + inlined_ast: 5ffb39defd930d8cb1972c4dd2f20affe949f5ac34d22c7143f06cf4af64ff98 + dce_ast: e7a3feaa48dc9473e381e20cadb02a67eb394253077f8887112db91c56e3c164 + bytecode: baa423f7d34847421a44a1ccfede64fb02829a7d99c465b0605f85cf20705986 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i64.out b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i64.out new file mode 100644 index 0000000000..eb33cd34c3 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i64.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 85b2afdf445a99fc5beb1bb9b7c98ddce8f4936dbdb5173447e64bfc5c73e96d + type_checked_symbol_table: 37ed5c5410f201880eb2da82ac4ec3d3ebb21756fc697827b30a5853945bfbb7 + unrolled_symbol_table: 37ed5c5410f201880eb2da82ac4ec3d3ebb21756fc697827b30a5853945bfbb7 + initial_ast: 3d1c1d4440c409a19b85c2536fde1301d6f95014df8522bc015a6852d1dca0e2 + unrolled_ast: 3d1c1d4440c409a19b85c2536fde1301d6f95014df8522bc015a6852d1dca0e2 + ssa_ast: 3bd86dc685b4ed91cd92cd8a7e14d4cf059a29c04303d42e4a574f3e0793d134 + flattened_ast: c7b54b2b858b591285d239c682c75cba6844edd7f31b21a7224567d34d0fad3f + inlined_ast: c7b54b2b858b591285d239c682c75cba6844edd7f31b21a7224567d34d0fad3f + dce_ast: 1c558e0da2876caf2126a3fff87bd8e50e0d6462db9c5a3efb76358d331fcc84 + bytecode: 4d5b9ec6fd0830de759b0df4e24136712875ed4bac5aca6ff53d8a6938693f56 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i8.out b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i8.out new file mode 100644 index 0000000000..821e9c46d9 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i8.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: e57034c883f65a0bf8bf21c5948e8e470938929205661f4629331145f96f457a + type_checked_symbol_table: bfa5890e9d7766d453384d93a8a70c7513c88833460ec856a316742105dee2c8 + unrolled_symbol_table: bfa5890e9d7766d453384d93a8a70c7513c88833460ec856a316742105dee2c8 + initial_ast: 92833e47204b59b37788c4ec212343979a18ed7f3a45f15165efb32339072c28 + unrolled_ast: 92833e47204b59b37788c4ec212343979a18ed7f3a45f15165efb32339072c28 + ssa_ast: ea8589847dd428451e47f2816336c901eac188be9f6738fec75a2bf0f1d2cbca + flattened_ast: fbb71c5fc61c07497e4caef27d20396d7cfedd3d60d1321c0c07e659a80ecb16 + inlined_ast: fbb71c5fc61c07497e4caef27d20396d7cfedd3d60d1321c0c07e659a80ecb16 + dce_ast: 04a3de0e312345fc0b85a40019a5c9cbf17838344430de742b122c20aee28045 + bytecode: dae1414959e50ca77ecae476843824b6220aa3ca4e95ab2a98deaa4b78987bc7 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u128.out b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u128.out new file mode 100644 index 0000000000..b3119372b4 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u128.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 30b74ef9405be6a65d0718e893155dfab9c5a27ba6331b46674fbfe804c078c7 + type_checked_symbol_table: df1b9add309c4f16c8fc410cfe1a5e081449f19662d106576ea7934ae2ec016a + unrolled_symbol_table: df1b9add309c4f16c8fc410cfe1a5e081449f19662d106576ea7934ae2ec016a + initial_ast: 2212034158c834667803573faba6667ddd08bc776e4255672eac824585c76ec2 + unrolled_ast: 2212034158c834667803573faba6667ddd08bc776e4255672eac824585c76ec2 + ssa_ast: 0cd336fabd60ae4185f6e37e01db7f79c53bc1a7c60607835ddaac8dea32f060 + flattened_ast: a25846920a22e7ba467e912f414fb0df64a8c9ae33db2508a3a028ab2d726c01 + inlined_ast: a25846920a22e7ba467e912f414fb0df64a8c9ae33db2508a3a028ab2d726c01 + dce_ast: 5e5bb6f4ec146fcc8cef69b6efdf3bb247c2379d1b4ed3a85a39f8fb084bc57e + bytecode: 770f2acaaeeba1f46a6b57a837f4abab295fe19070a150e6f59fc4e8d4cb19fa + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u16.out b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u16.out new file mode 100644 index 0000000000..b67521dea8 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u16.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 5a59bc205eed395ed0a857abe27790d3612aaac26fce76ec8b77b539dd85b4ad + type_checked_symbol_table: eec79e1688bdeb5852327404ba04f4db9b6a914d2b19fc0578a44ac097fa4149 + unrolled_symbol_table: eec79e1688bdeb5852327404ba04f4db9b6a914d2b19fc0578a44ac097fa4149 + initial_ast: a7a56ccb04db7b6764ec0213f484c231c6f9ee3cd68faf8d8b467a76ca07e298 + unrolled_ast: a7a56ccb04db7b6764ec0213f484c231c6f9ee3cd68faf8d8b467a76ca07e298 + ssa_ast: 6134e8a8a0fe6c02950148662b3b7b77425acde70be5630c6d29fab336387da0 + flattened_ast: d046b22ad8006892c4b97209303471eb812083be94245a55b35852636eedcda5 + inlined_ast: d046b22ad8006892c4b97209303471eb812083be94245a55b35852636eedcda5 + dce_ast: b2f239b6cc8c65f455d27893acedfbfd0d8eebb0f2e04af27a0b6b318c0898d8 + bytecode: 2827725e28e621b51cf5a40a1979da7558af0ec1e7e260b1ec255c169efd7948 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u32.out b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u32.out new file mode 100644 index 0000000000..1dac282249 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u32.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 992dd740994079e30efead06f29f9c2df115a70d54f7649eb5fadec3120db120 + type_checked_symbol_table: 2271d0f496fc810a81e3edbd0303d248c348b0a732ee32e9cff64ccf24073daf + unrolled_symbol_table: 2271d0f496fc810a81e3edbd0303d248c348b0a732ee32e9cff64ccf24073daf + initial_ast: 30f1add1461d8f07c9eb7c573d9a9d7289f136855946d5f8ff872b7f87dea438 + unrolled_ast: 30f1add1461d8f07c9eb7c573d9a9d7289f136855946d5f8ff872b7f87dea438 + ssa_ast: 38cbe72eb04fc7f1eabcde8948ca8884eb8913dd56d811cb64bf7978be2ee644 + flattened_ast: 637dfa95104f0f2d2beb8449ae711975b15314ce0f6a5c06b2537703e317c3b9 + inlined_ast: 637dfa95104f0f2d2beb8449ae711975b15314ce0f6a5c06b2537703e317c3b9 + dce_ast: 60306bd1d9b0446c04c1f121089daa7285b7eae22d36f6ccc8e46c3b1d602184 + bytecode: a90328ca973213775dcbfa872950cc8126b172ef1cd4c1a1650277b23b6f6957 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u64.out b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u64.out new file mode 100644 index 0000000000..0fe4ff897d --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u64.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 7c89248ded858c5bc52c59d418ebea9937f41f59e113313a43dce30d21780db9 + type_checked_symbol_table: 0d4884468efa4393f32b1d81aa9f1bd16687853321f65b88703dfa8ec1e9b257 + unrolled_symbol_table: 0d4884468efa4393f32b1d81aa9f1bd16687853321f65b88703dfa8ec1e9b257 + initial_ast: 601b6fdd0f13a4b55f7d136e4e31484dfe8cc727c75b163156fa18449b74268a + unrolled_ast: 601b6fdd0f13a4b55f7d136e4e31484dfe8cc727c75b163156fa18449b74268a + ssa_ast: d3dadc07ab20dc1a14a6676b97c3487d4a081eef9570e3b4d5036bcb5bd103ac + flattened_ast: 805ea6e2cea6778e879509c66287d903fbbe9e558ea243176a4d8fceca9343c7 + inlined_ast: 805ea6e2cea6778e879509c66287d903fbbe9e558ea243176a4d8fceca9343c7 + dce_ast: f28507eae282d4bfba9821407c261ab8e1972197d4171bbfa8967bffcf23ec4b + bytecode: 56496fd935df4646cdd71fb7cee3390df240c99433835d70ef5967a33e6d7de8 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u8.out b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u8.out new file mode 100644 index 0000000000..ce84912cf9 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u8.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 9de9a9614bae9e392c40cbe50c32763866d8facbe3b7b0e618c773c9c1e2452b + type_checked_symbol_table: 0c70472fb21893662b1ec36bd51f9ac064da4731817d99d9c0030cf08799d915 + unrolled_symbol_table: 0c70472fb21893662b1ec36bd51f9ac064da4731817d99d9c0030cf08799d915 + initial_ast: 9543d9a74b1616747f02212f0dee15345bde9a2264ff2074f453e17cb9fbd3b4 + unrolled_ast: 9543d9a74b1616747f02212f0dee15345bde9a2264ff2074f453e17cb9fbd3b4 + ssa_ast: 4a2b682e4a06e4e8b3c38373822e9418d6ec64a2ced7669fc14a16c8e2e26928 + flattened_ast: 36249d7d789728d6dc2d50bbd385e4167d4c046740411d6c992768f28b7cd9b7 + inlined_ast: 36249d7d789728d6dc2d50bbd385e4167d4c046740411d6c992768f28b7cd9b7 + dce_ast: 7134438e310abde6fc3a2b71c9830cd9f403919ddff03733243b0b806c9e5495 + bytecode: db058ed7b34e9c94cb51c9152685548070f56ec9b80abe82b0ae5789a0f81cee + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i128.out b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i128.out new file mode 100644 index 0000000000..3caeddc967 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i128.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: d61b6c9a81578cd47a707319541ce1cea3ac5e20020f2a5b8c0b0363df72ceb4 + type_checked_symbol_table: 242199b3378fc1e61068a3091df5fbc413ee879c63a678cc7256ae0562d8e0f4 + unrolled_symbol_table: 242199b3378fc1e61068a3091df5fbc413ee879c63a678cc7256ae0562d8e0f4 + initial_ast: 8f6d277873a8157f40e8bfefe1767cd1d5a9a1e9e40e4747e3327bfa3cd899ae + unrolled_ast: 8f6d277873a8157f40e8bfefe1767cd1d5a9a1e9e40e4747e3327bfa3cd899ae + ssa_ast: be8663ba9c845e2d2a1065bc45718b9a1ccb758806902ce1248a8206b3e8af33 + flattened_ast: 793e4b7767fe79d05e27976c7047db7bfeee8b6512ac98a663e680b393ca45b4 + inlined_ast: 793e4b7767fe79d05e27976c7047db7bfeee8b6512ac98a663e680b393ca45b4 + dce_ast: d86598503d1c3ca8d8da4f0918349c569e9fc3ad4e806bce9d079386b35c43d5 + bytecode: 3c60fe2ccd72f2fee542194a4a812f65cb74ffe4aa77947d0ef39a626d9175d9 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i16.out b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i16.out new file mode 100644 index 0000000000..90e9a6e67c --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i16.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 077422b93c97f7cd8a28ff1ba7bbe58e07c4b7887304c46d35eb5ac6bf23c972 + type_checked_symbol_table: 5f860d2de9a0608ecbc70179a65c645cd622701fee49e955c77387fa225b01a1 + unrolled_symbol_table: 5f860d2de9a0608ecbc70179a65c645cd622701fee49e955c77387fa225b01a1 + initial_ast: 94fd5ebc2511aba13ed72038eb17dba19af0b95fdbbbbba6897ae386d6ee704c + unrolled_ast: 94fd5ebc2511aba13ed72038eb17dba19af0b95fdbbbbba6897ae386d6ee704c + ssa_ast: 3accc6fc98f83407ae2b37f68e133f5ba422ab777b10e1cee0ee73ca0841b1ea + flattened_ast: 3e5370d4b22b001d889dca2572af06349675eefbcffdc0100dbbf7dabda34c5c + inlined_ast: 3e5370d4b22b001d889dca2572af06349675eefbcffdc0100dbbf7dabda34c5c + dce_ast: 9ffef43b15d41e9a53410cf15da5881cf87f5509084f61a6b1f815e8c139a1a8 + bytecode: f6c112b08c4a5b02002de56b8dfba054dca0fdb49feeda7146384ce5bc4b9e3b + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i32.out b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i32.out new file mode 100644 index 0000000000..d6d9f530bc --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i32.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 0b9e361a60499d11d8de9a427cd689b0904e3660092b6ff95a1c07bf09964e11 + type_checked_symbol_table: 58b695183f390fd270d2d7b521591c524ad80192b3c1e04fc7e691ebd5fdf24e + unrolled_symbol_table: 58b695183f390fd270d2d7b521591c524ad80192b3c1e04fc7e691ebd5fdf24e + initial_ast: 5fa9a43fddef706caba1a3c5bd948906571355fc779a5cc2294c89b95120de70 + unrolled_ast: 5fa9a43fddef706caba1a3c5bd948906571355fc779a5cc2294c89b95120de70 + ssa_ast: 93956cb9322836aaf337ce74f3b80d5045310c07f8fe30147ad0b0fe036e133c + flattened_ast: 5c91b01aeb7f25c3121e70c06fe27f064104108b953483868df9a1851156b90b + inlined_ast: 5c91b01aeb7f25c3121e70c06fe27f064104108b953483868df9a1851156b90b + dce_ast: e1f193572ed4614989d123959d21a6d720f3a5fd28ced15acc05186a0f395561 + bytecode: ff30f43337c830695fd7271014aee19d33c0489de50d3d66db69b3d73da357ce + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i64.out b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i64.out new file mode 100644 index 0000000000..7b54b6bdc3 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i64.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 85b2afdf445a99fc5beb1bb9b7c98ddce8f4936dbdb5173447e64bfc5c73e96d + type_checked_symbol_table: 37ed5c5410f201880eb2da82ac4ec3d3ebb21756fc697827b30a5853945bfbb7 + unrolled_symbol_table: 37ed5c5410f201880eb2da82ac4ec3d3ebb21756fc697827b30a5853945bfbb7 + initial_ast: 701c8072060a09af67e375611ad1959371211be199bdb68511a1ac120972c6ab + unrolled_ast: 701c8072060a09af67e375611ad1959371211be199bdb68511a1ac120972c6ab + ssa_ast: 95749c201dbf4bc09689b8266763bebbf82f1458368b8d4a6166446a0ef6bf52 + flattened_ast: a2f9857fe270b070c4ecaf322d56706ae8522e4b7de27f2b7db6c27e4e82e936 + inlined_ast: a2f9857fe270b070c4ecaf322d56706ae8522e4b7de27f2b7db6c27e4e82e936 + dce_ast: d60742f9b17394137b9c45ec1a7be558a20140003c7ca92c019a126ccc63a9b4 + bytecode: 9613835dc4e36f266d29110dd595208e54ebd4b8dcf371985a38796c15044f38 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i8.out b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i8.out new file mode 100644 index 0000000000..82d2af67ee --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i8.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: e57034c883f65a0bf8bf21c5948e8e470938929205661f4629331145f96f457a + type_checked_symbol_table: bfa5890e9d7766d453384d93a8a70c7513c88833460ec856a316742105dee2c8 + unrolled_symbol_table: bfa5890e9d7766d453384d93a8a70c7513c88833460ec856a316742105dee2c8 + initial_ast: 453c47e6d2ee3a0b424f287af590fd8f20c6e57ab6261a15884a3697aaa4e20a + unrolled_ast: 453c47e6d2ee3a0b424f287af590fd8f20c6e57ab6261a15884a3697aaa4e20a + ssa_ast: ce766ea02dcda49e9f81d380fbe20e84dcd41298862e3966faa4271077f42129 + flattened_ast: b757232d97546241dd31cb445f9cfa3fed4634500de46b4cf8e09ff9e0fb6d91 + inlined_ast: b757232d97546241dd31cb445f9cfa3fed4634500de46b4cf8e09ff9e0fb6d91 + dce_ast: 16f1ce7c51071924096d3b6ac0cde5bc26dd74d786cef9c86e0e7afeed604e3a + bytecode: ca074224fb21da9078cf66f586228b5d09460ff02edf0f84847970c375695b57 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u128.out b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u128.out new file mode 100644 index 0000000000..96c19ef173 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u128.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 30b74ef9405be6a65d0718e893155dfab9c5a27ba6331b46674fbfe804c078c7 + type_checked_symbol_table: df1b9add309c4f16c8fc410cfe1a5e081449f19662d106576ea7934ae2ec016a + unrolled_symbol_table: df1b9add309c4f16c8fc410cfe1a5e081449f19662d106576ea7934ae2ec016a + initial_ast: 5aa347afaa0bcb14a81c5dd188e0c31ebbf2ff69ed93d8298299df9d79b109c4 + unrolled_ast: 5aa347afaa0bcb14a81c5dd188e0c31ebbf2ff69ed93d8298299df9d79b109c4 + ssa_ast: c3189e3839831ae6b86f638711d43318173ff89fe2ccf0dbb1b50294e33b5ba1 + flattened_ast: 14a0c46412e3d26ec040f2e014a9638fa35af85e1b2a336bd2be2e4212a1c752 + inlined_ast: 14a0c46412e3d26ec040f2e014a9638fa35af85e1b2a336bd2be2e4212a1c752 + dce_ast: 6a24415ac8a99f16ef2cb35996935fc4b41eb073afd987d766f142678b62c44c + bytecode: b0c87022d5e30dd47b5a097c7e1c00bd8c487886a84212ce7db0c7b1c5856259 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u16.out b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u16.out new file mode 100644 index 0000000000..08c83b6eb0 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u16.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 5a59bc205eed395ed0a857abe27790d3612aaac26fce76ec8b77b539dd85b4ad + type_checked_symbol_table: eec79e1688bdeb5852327404ba04f4db9b6a914d2b19fc0578a44ac097fa4149 + unrolled_symbol_table: eec79e1688bdeb5852327404ba04f4db9b6a914d2b19fc0578a44ac097fa4149 + initial_ast: 8d5ccfa7a2b81d90c30571e1e8b0e03392ae984d077beb44d270f503b3ae1f03 + unrolled_ast: 8d5ccfa7a2b81d90c30571e1e8b0e03392ae984d077beb44d270f503b3ae1f03 + ssa_ast: eb5b96165c5565ca9f47c52ec872f4f989b2d519f6237b69a78dfc94fac02668 + flattened_ast: 58e7057028e69bec09d15ec26c092442265d0e5882486f0dab128677ed4595ea + inlined_ast: 58e7057028e69bec09d15ec26c092442265d0e5882486f0dab128677ed4595ea + dce_ast: dc3acfedccb7511b5875c0869c9f0b1e3bbdb52f076b908cb756129a414b854c + bytecode: 8b851887789d1b0d14a68de7f393a839940770b54680c74656c872dde5ff20dc + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u32.out b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u32.out new file mode 100644 index 0000000000..e09a5b1987 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u32.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 992dd740994079e30efead06f29f9c2df115a70d54f7649eb5fadec3120db120 + type_checked_symbol_table: 2271d0f496fc810a81e3edbd0303d248c348b0a732ee32e9cff64ccf24073daf + unrolled_symbol_table: 2271d0f496fc810a81e3edbd0303d248c348b0a732ee32e9cff64ccf24073daf + initial_ast: f97cf6822b0b012e424cbf916f060884aee0a781f70c95c6f6c50672eaae8d94 + unrolled_ast: f97cf6822b0b012e424cbf916f060884aee0a781f70c95c6f6c50672eaae8d94 + ssa_ast: b80d4df95ee5316d676399a0b8e0049b465272bb7ed2f67ea8b15b11f2cd01cc + flattened_ast: fff6defafaecbb94471f425c56ded3316fc09669ac96c3f2e860885fcd3f4c6a + inlined_ast: fff6defafaecbb94471f425c56ded3316fc09669ac96c3f2e860885fcd3f4c6a + dce_ast: c302f26c887a819542548c63ec9e5893d50156c9b938c5fdb0e4acb6261e7e81 + bytecode: 8cfc137d9de5f78970ffe8a7fd36cf828d967798364ebb25ed2654f97e993df2 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u64.out b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u64.out new file mode 100644 index 0000000000..c261d56673 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u64.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 7c89248ded858c5bc52c59d418ebea9937f41f59e113313a43dce30d21780db9 + type_checked_symbol_table: 0d4884468efa4393f32b1d81aa9f1bd16687853321f65b88703dfa8ec1e9b257 + unrolled_symbol_table: 0d4884468efa4393f32b1d81aa9f1bd16687853321f65b88703dfa8ec1e9b257 + initial_ast: 0ea3cd238cece2bd3f9e9627751791f8bdb2ccf8d62b2d4c92f08fdc9949d8d5 + unrolled_ast: 0ea3cd238cece2bd3f9e9627751791f8bdb2ccf8d62b2d4c92f08fdc9949d8d5 + ssa_ast: 91d7fe587ea671b61a23af52e63ae1d8f85f43765a4875c72fff5409e437f808 + flattened_ast: 7097a1be09831ae10e89be40923603fc98308c8591feeee4d14cb96c68265c26 + inlined_ast: 7097a1be09831ae10e89be40923603fc98308c8591feeee4d14cb96c68265c26 + dce_ast: b685e8e5212f711fe3d257768182f38e9253f4e8fb7f925c85c95ce634b8654d + bytecode: e21f3d467b66f55e41c864391412af065fcfd0b44bb6697e68693b5c8620e4bc + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u8.out b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u8.out new file mode 100644 index 0000000000..39fa77ed78 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u8.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 9de9a9614bae9e392c40cbe50c32763866d8facbe3b7b0e618c773c9c1e2452b + type_checked_symbol_table: 0c70472fb21893662b1ec36bd51f9ac064da4731817d99d9c0030cf08799d915 + unrolled_symbol_table: 0c70472fb21893662b1ec36bd51f9ac064da4731817d99d9c0030cf08799d915 + initial_ast: 1293ea0a9fd32b3ab0da2f2df8f4f6123aca459e304681f9b2678cc5523bd026 + unrolled_ast: 1293ea0a9fd32b3ab0da2f2df8f4f6123aca459e304681f9b2678cc5523bd026 + ssa_ast: 596408067fa115be60a4c66fce8f2edb079521cc0bb3cb676827f1d81a2fe567 + flattened_ast: d31ff87aed6db6e61f4ea3feb7ff9cfe7a521d69b02572d71bac4f758984f338 + inlined_ast: d31ff87aed6db6e61f4ea3feb7ff9cfe7a521d69b02572d71bac4f758984f338 + dce_ast: 1a5e594f5af0dd258b4d8a88fad977dcb51b50bb6e410422664ad271b227b0bd + bytecode: 999b9d0cdf8e006833a2d8ce94eb8ace714cd08c8df3e0b3531e28f6489e0984 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i128.out b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i128.out new file mode 100644 index 0000000000..29bd7f452a --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i128.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: d61b6c9a81578cd47a707319541ce1cea3ac5e20020f2a5b8c0b0363df72ceb4 + type_checked_symbol_table: 242199b3378fc1e61068a3091df5fbc413ee879c63a678cc7256ae0562d8e0f4 + unrolled_symbol_table: 242199b3378fc1e61068a3091df5fbc413ee879c63a678cc7256ae0562d8e0f4 + initial_ast: 7c3269a344a832f4e6b5b092c3f08f98e784aa3ca7187e16738d10a5bf702c72 + unrolled_ast: 7c3269a344a832f4e6b5b092c3f08f98e784aa3ca7187e16738d10a5bf702c72 + ssa_ast: f48c51473878f28bd896beadefebd2d0e98283d04137c3dab6d68511dd6b5c48 + flattened_ast: 88061d4bdb65f5281592a16a8bc24fc6b83aa59bd4bf617bcd4b080adce464a0 + inlined_ast: 88061d4bdb65f5281592a16a8bc24fc6b83aa59bd4bf617bcd4b080adce464a0 + dce_ast: 3bf1d88752e451f461637005c988ddca8c71669054b4ed5b9a0c6f48a7b34a53 + bytecode: 88e5bed3bec5448667a7407b85018435a99703ea27f2e24c965cee2b37ae5dc3 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i16.out b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i16.out new file mode 100644 index 0000000000..d4ab2c49f4 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i16.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 077422b93c97f7cd8a28ff1ba7bbe58e07c4b7887304c46d35eb5ac6bf23c972 + type_checked_symbol_table: 5f860d2de9a0608ecbc70179a65c645cd622701fee49e955c77387fa225b01a1 + unrolled_symbol_table: 5f860d2de9a0608ecbc70179a65c645cd622701fee49e955c77387fa225b01a1 + initial_ast: ab7d012e02d49ffef0d08b47c95251c3d621054de5176dcdae1a6320691b3d1a + unrolled_ast: ab7d012e02d49ffef0d08b47c95251c3d621054de5176dcdae1a6320691b3d1a + ssa_ast: 20e093c7b4410425ab54f784b8d43bd0bda23803446a089dcbfc99c9af327c63 + flattened_ast: 1a10b58e36bf0e71c6263af2a79ae1181826c5af78cd127f570ea5e578e48530 + inlined_ast: 1a10b58e36bf0e71c6263af2a79ae1181826c5af78cd127f570ea5e578e48530 + dce_ast: d41a624032b738c305931aab7e92f786255c20ce1f4f12b1aaef6d844ac2a91f + bytecode: 9b27d0806063bc598a773122d554a2d3da168e9813e2c2e55c4e0eedc2198f1c + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i32.out b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i32.out new file mode 100644 index 0000000000..02a1a84a58 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i32.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 0b9e361a60499d11d8de9a427cd689b0904e3660092b6ff95a1c07bf09964e11 + type_checked_symbol_table: 58b695183f390fd270d2d7b521591c524ad80192b3c1e04fc7e691ebd5fdf24e + unrolled_symbol_table: 58b695183f390fd270d2d7b521591c524ad80192b3c1e04fc7e691ebd5fdf24e + initial_ast: 93cdbd224664c44377b1ccc6459e28f4ba0650ec615433a7617c077c642ecaa3 + unrolled_ast: 93cdbd224664c44377b1ccc6459e28f4ba0650ec615433a7617c077c642ecaa3 + ssa_ast: 2edc5eee55afb31b5728ad0d2ada8143d8cdbca838cb76921713355e50422bdc + flattened_ast: 89a72dfe8ca7e294566e33fdfb8ba91f9d910b91815800bcae4dc897b4067b54 + inlined_ast: 89a72dfe8ca7e294566e33fdfb8ba91f9d910b91815800bcae4dc897b4067b54 + dce_ast: 85c5305f13ada6e8522b64d2acdfdad55c171f93c4ceed4db798f047481d5495 + bytecode: 6965d0539f26e7885d7fa616d93bb5326315793d3843573135bcda58cbaeb149 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i64.out b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i64.out new file mode 100644 index 0000000000..a1f4b474eb --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i64.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 85b2afdf445a99fc5beb1bb9b7c98ddce8f4936dbdb5173447e64bfc5c73e96d + type_checked_symbol_table: 37ed5c5410f201880eb2da82ac4ec3d3ebb21756fc697827b30a5853945bfbb7 + unrolled_symbol_table: 37ed5c5410f201880eb2da82ac4ec3d3ebb21756fc697827b30a5853945bfbb7 + initial_ast: e77ae4c9d73a0e0ec3125674deb07bac8be5eab932154cbe69d075db4478d8f1 + unrolled_ast: e77ae4c9d73a0e0ec3125674deb07bac8be5eab932154cbe69d075db4478d8f1 + ssa_ast: 53242edad187f8d960912edcf85ee98923a7bc61a0c31f3f3f5fcc1349eb1cf7 + flattened_ast: 05a83f18d37cd0c863957fc2ecd790912cd251608f8d8b663ae53de83e0513e1 + inlined_ast: 05a83f18d37cd0c863957fc2ecd790912cd251608f8d8b663ae53de83e0513e1 + dce_ast: 3896b0f70addb35a89c05cb53f980fafc9d9050c57049298fe47ea72ee6ef89c + bytecode: c497462939dadd3b6fa6a391939d169f8caf2da5064471e177e9dc2ca24af1c0 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i8.out b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i8.out new file mode 100644 index 0000000000..119779e815 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i8.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: e57034c883f65a0bf8bf21c5948e8e470938929205661f4629331145f96f457a + type_checked_symbol_table: bfa5890e9d7766d453384d93a8a70c7513c88833460ec856a316742105dee2c8 + unrolled_symbol_table: bfa5890e9d7766d453384d93a8a70c7513c88833460ec856a316742105dee2c8 + initial_ast: 83f5bc1862345a3f0f9751f3cca5249d479b3f45d14b1a41e19e14ab99a318e0 + unrolled_ast: 83f5bc1862345a3f0f9751f3cca5249d479b3f45d14b1a41e19e14ab99a318e0 + ssa_ast: b6775601268fc31d6958c11294b516b366e68604e748cff6204a091ac0d4e5da + flattened_ast: 475da3a29a106c93fbc55eb2f007687aa3aa967dce2b211e0aadc2743c58f07b + inlined_ast: 475da3a29a106c93fbc55eb2f007687aa3aa967dce2b211e0aadc2743c58f07b + dce_ast: 39fd0a2567410ff9acd7e92988163c1b5a5926f89ed62e862fc2173560abb7fd + bytecode: 26f4c496d5e435d186f9ec58390da76af8848cecaaac30920a4daab0e2523a73 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u128.out b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u128.out new file mode 100644 index 0000000000..703d3d4074 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u128.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 30b74ef9405be6a65d0718e893155dfab9c5a27ba6331b46674fbfe804c078c7 + type_checked_symbol_table: df1b9add309c4f16c8fc410cfe1a5e081449f19662d106576ea7934ae2ec016a + unrolled_symbol_table: df1b9add309c4f16c8fc410cfe1a5e081449f19662d106576ea7934ae2ec016a + initial_ast: f026139202150198f479e35bd573496cc0c6c7b8bc02be9062326e267ed8f917 + unrolled_ast: f026139202150198f479e35bd573496cc0c6c7b8bc02be9062326e267ed8f917 + ssa_ast: f4fd06f27f544ed914d9c37714b0b75f0dc82598336dbd8362a387980f6845f5 + flattened_ast: 4ea4494f16680702cffb88f2ffb5be873127858252ef87bc7ddc5900cb998b33 + inlined_ast: 4ea4494f16680702cffb88f2ffb5be873127858252ef87bc7ddc5900cb998b33 + dce_ast: 250f6a9533ea59fade92d9257b6777cdbf3547c9ac6e3ea3855beddd5af3b13f + bytecode: 9a6698dbd340581ab6a6ab74e6ac3b2b04d107afafb2ef967cf878a68f90e66a + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u16.out b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u16.out new file mode 100644 index 0000000000..b5efad08a9 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u16.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 5a59bc205eed395ed0a857abe27790d3612aaac26fce76ec8b77b539dd85b4ad + type_checked_symbol_table: eec79e1688bdeb5852327404ba04f4db9b6a914d2b19fc0578a44ac097fa4149 + unrolled_symbol_table: eec79e1688bdeb5852327404ba04f4db9b6a914d2b19fc0578a44ac097fa4149 + initial_ast: d6c6e1e9114f2e6e35a27163bb96e8f3559c1a1ce48a53b95eb68c336829d61b + unrolled_ast: d6c6e1e9114f2e6e35a27163bb96e8f3559c1a1ce48a53b95eb68c336829d61b + ssa_ast: 97e9d6c5c2bb1d1a0ae488932c71c058601a7eebfda5d8a30b94735e874821c8 + flattened_ast: c532ab105e2aba5ec04d199f098baf16f895242af400b06f67912ccb8380f662 + inlined_ast: c532ab105e2aba5ec04d199f098baf16f895242af400b06f67912ccb8380f662 + dce_ast: fdde53b7506a6811ceba22fecd33d485181de0f73ae969d4ada64dfcee8098e1 + bytecode: 382d6faca5454efb2c43e692e7ef46168de32044fd4eb589025fb7dabc62d3bb + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u32.out b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u32.out new file mode 100644 index 0000000000..b4721747ce --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u32.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 992dd740994079e30efead06f29f9c2df115a70d54f7649eb5fadec3120db120 + type_checked_symbol_table: 2271d0f496fc810a81e3edbd0303d248c348b0a732ee32e9cff64ccf24073daf + unrolled_symbol_table: 2271d0f496fc810a81e3edbd0303d248c348b0a732ee32e9cff64ccf24073daf + initial_ast: e40d10bf0bbb177d1cbe5f53035b4f4ca5173e28ae7643f054b43a8de3c3f5d0 + unrolled_ast: e40d10bf0bbb177d1cbe5f53035b4f4ca5173e28ae7643f054b43a8de3c3f5d0 + ssa_ast: 4af71aa576bccbdca88413a4326bec924110e06650eef6d32903601bad53fa5a + flattened_ast: b4365715971ce614d4620925a32f8104e5960b7684bc9fe351dbec9b49f0754a + inlined_ast: b4365715971ce614d4620925a32f8104e5960b7684bc9fe351dbec9b49f0754a + dce_ast: 4a2a899efd4a266c18f72938c37d42a4e6a91af5dbe0f9a7ba21a29fd7860b23 + bytecode: cdf35ecca4bd73879647e3f8b20554dc0c6bea1b7064b2e62fe501aaf54469e8 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u64.out b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u64.out new file mode 100644 index 0000000000..13a4fa79f3 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u64.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 7c89248ded858c5bc52c59d418ebea9937f41f59e113313a43dce30d21780db9 + type_checked_symbol_table: 0d4884468efa4393f32b1d81aa9f1bd16687853321f65b88703dfa8ec1e9b257 + unrolled_symbol_table: 0d4884468efa4393f32b1d81aa9f1bd16687853321f65b88703dfa8ec1e9b257 + initial_ast: 1481e2c29419e537e9c8243ee74b10c6de58f5428db1399862784ee9e304b63b + unrolled_ast: 1481e2c29419e537e9c8243ee74b10c6de58f5428db1399862784ee9e304b63b + ssa_ast: 80bd7ec9a3d56da47469c65c3c533a4127665992b167c311dd8164728184ba90 + flattened_ast: 152fb4952598ef6eaf75a5a972a38f00d3d2a43c2b627309fd7b1164f0fa5fee + inlined_ast: 152fb4952598ef6eaf75a5a972a38f00d3d2a43c2b627309fd7b1164f0fa5fee + dce_ast: 57b269b910800a713b821d8f285ed632d274ac0b97277df14f1d1355bf8f404d + bytecode: d7b1e51dba2a0e4e06e66b15ff10ea2c3d799073949f6b155489a46bbae70395 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u8.out b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u8.out new file mode 100644 index 0000000000..14ba6dbdb8 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u8.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 9de9a9614bae9e392c40cbe50c32763866d8facbe3b7b0e618c773c9c1e2452b + type_checked_symbol_table: 0c70472fb21893662b1ec36bd51f9ac064da4731817d99d9c0030cf08799d915 + unrolled_symbol_table: 0c70472fb21893662b1ec36bd51f9ac064da4731817d99d9c0030cf08799d915 + initial_ast: 7ec1dd301960dc49ce741a6cce2fc7cdf6bb63394fe012522d2763ba460fb6d8 + unrolled_ast: 7ec1dd301960dc49ce741a6cce2fc7cdf6bb63394fe012522d2763ba460fb6d8 + ssa_ast: fee00d77a912cb653b2fd33d98334490b832ea4456995ef24b02de8e1791f61e + flattened_ast: cd239b04a842a29071b4bc9bf4164bc4971818a451043d7ea133018b32ad8ede + inlined_ast: cd239b04a842a29071b4bc9bf4164bc4971818a451043d7ea133018b32ad8ede + dce_ast: 8fa60a1f89693094383fc5bdf26cb69a99a6a96d9db00ed54e918e560fc5bc78 + bytecode: 1729c5267f2280cfde27fd1c7806b03bb56e95306b8c269d0c186f05365ccef5 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/keccak256_hash_to_address.out b/tests/expectations/compiler/core/algorithms/keccak256_hash_to_address.out new file mode 100644 index 0000000000..fe9e0b04a7 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/keccak256_hash_to_address.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 1f96df1e414fd96505a23c658692de40614d28804ebeaeafc90835f4087c91cc + type_checked_symbol_table: aaaec423b2c439b4857751e7dec72e29fbe3cf863753d6f21e52c9d0f5e98558 + unrolled_symbol_table: aaaec423b2c439b4857751e7dec72e29fbe3cf863753d6f21e52c9d0f5e98558 + initial_ast: f3fc8cda6ed0473de45f4c599fa6ff48bc6d2cef5a901f9ca5f45a449c19a66a + unrolled_ast: f3fc8cda6ed0473de45f4c599fa6ff48bc6d2cef5a901f9ca5f45a449c19a66a + ssa_ast: 125b5c6e7c9940f58b255d02b7f83ef44de863263a4169cf3df35f3d6935c1fb + flattened_ast: 2b1e7b92b0e1c54cccff73023ca835cc83ec9f0987d6369f130281b4e8a94ad2 + inlined_ast: 2b1e7b92b0e1c54cccff73023ca835cc83ec9f0987d6369f130281b4e8a94ad2 + dce_ast: b18fecc1fb16346a6a66e69b7bd9e65c40f4640f551f6e2f44777a18c8d00178 + bytecode: 03845ec2f54d49f71640659603ead8f68ad067a15fda438e5e13524777d1559b + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/keccak256_hash_to_field.out b/tests/expectations/compiler/core/algorithms/keccak256_hash_to_field.out new file mode 100644 index 0000000000..0564480d63 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/keccak256_hash_to_field.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 1f96df1e414fd96505a23c658692de40614d28804ebeaeafc90835f4087c91cc + type_checked_symbol_table: f51b6c1660b8bb5b45ca5e05c303bf2fb92e47d575ff34c69abec002486452f4 + unrolled_symbol_table: f51b6c1660b8bb5b45ca5e05c303bf2fb92e47d575ff34c69abec002486452f4 + initial_ast: 954eb3c2890226ed99e460fb27372568832f225b9f3ff043cec27d366e77e680 + unrolled_ast: 954eb3c2890226ed99e460fb27372568832f225b9f3ff043cec27d366e77e680 + ssa_ast: e72f4513bcab0b7229e2b1b4ae4c3af7ec02b6e8771c4ffa737f463f48adc144 + flattened_ast: 0556b16318972ed0d5f0fa09a6d6e9bc93071df66c554da2ff3b35c02a22a381 + inlined_ast: 0556b16318972ed0d5f0fa09a6d6e9bc93071df66c554da2ff3b35c02a22a381 + dce_ast: 78b479aca57ab3c141525758af93993561f2bddf765ba4dff76eb29c18c7f941 + bytecode: 21736a09a94367a2bf017cd7dc7dade802a2f064f2343cd3d295eac4e3dca0ae + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/keccak256_hash_to_group.out b/tests/expectations/compiler/core/algorithms/keccak256_hash_to_group.out new file mode 100644 index 0000000000..db66bea880 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/keccak256_hash_to_group.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: fd9620b494239c2b62c2da7b951d51f08a1c0ad366a726e6b108da648ce5fb58 + type_checked_symbol_table: 392b4afe780015c412cfb5e45a1b084b40873e9eda40e05ef94ab54aaadf8a3d + unrolled_symbol_table: 392b4afe780015c412cfb5e45a1b084b40873e9eda40e05ef94ab54aaadf8a3d + initial_ast: df29eb947655e0b15d8816ffd7f1d1c67e4b74824c1180123d5130f6f7aa2281 + unrolled_ast: df29eb947655e0b15d8816ffd7f1d1c67e4b74824c1180123d5130f6f7aa2281 + ssa_ast: 060a8cf08cd57730a0f6d694a2f7810c1ea3a39095a7380893fb5d863139d4b9 + flattened_ast: eee3d32337729dee18fb66fbaf6557c4daf0cdeef0b79870dee42726fa8e5070 + inlined_ast: eee3d32337729dee18fb66fbaf6557c4daf0cdeef0b79870dee42726fa8e5070 + dce_ast: f04596e25887e067da907ed7f037cf21fae4897732ad81964fb428f58f9f0a8c + bytecode: 12b2cee6aa44638371f466d0f9a4b6396e2a466669a11a938b7ac251a5b23eb6 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/keccak256_hash_to_scalar.out b/tests/expectations/compiler/core/algorithms/keccak256_hash_to_scalar.out new file mode 100644 index 0000000000..b3dac6386c --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/keccak256_hash_to_scalar.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 15549a7085ac019c35b881b7ef00f56cbfbf0a21e9ceb4d4599fa4e06359d9e5 + type_checked_symbol_table: 3955df6eabb0bfb8f9df5a34a49c11bf3bf95325f88a0affd038b820e7541266 + unrolled_symbol_table: 3955df6eabb0bfb8f9df5a34a49c11bf3bf95325f88a0affd038b820e7541266 + initial_ast: cc840ffb92a26a2b3e8ca04f93c40944faf213e87a387ee4bda0465e074ea6ce + unrolled_ast: cc840ffb92a26a2b3e8ca04f93c40944faf213e87a387ee4bda0465e074ea6ce + ssa_ast: 1278525717fa5e9b2c22c391edfe10c14804f5d674a358885f38a10185db9ea0 + flattened_ast: d03e19c50971c93b1594b41c94e85e8b0ad2c374c95b7fc87b6e10b5cbbd10fb + inlined_ast: d03e19c50971c93b1594b41c94e85e8b0ad2c374c95b7fc87b6e10b5cbbd10fb + dce_ast: 3c623604b706161adab3235f7a0124ce3be34a32319640ff941c89aade6fa080 + bytecode: 9600a008a2a7ac916f8e19cd292c150bf1474805e87b407c17fc2e079013c356 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/keccak384_hash_to_address.out b/tests/expectations/compiler/core/algorithms/keccak384_hash_to_address.out new file mode 100644 index 0000000000..3ef7680208 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/keccak384_hash_to_address.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 1f96df1e414fd96505a23c658692de40614d28804ebeaeafc90835f4087c91cc + type_checked_symbol_table: aaaec423b2c439b4857751e7dec72e29fbe3cf863753d6f21e52c9d0f5e98558 + unrolled_symbol_table: aaaec423b2c439b4857751e7dec72e29fbe3cf863753d6f21e52c9d0f5e98558 + initial_ast: 1f3f713689a364da7799bed1cb13a41dfddcf0f2b0d6cca10ed05f7d6b30df3b + unrolled_ast: 1f3f713689a364da7799bed1cb13a41dfddcf0f2b0d6cca10ed05f7d6b30df3b + ssa_ast: 1dd688e597454010c9a0822be172e4b8bc47381915b896cd5d8e97fa0914c1c7 + flattened_ast: dc3cf8e9ac7249ffc35d02b8914989d6449b1fb37395577cf3dc96555fc4bd13 + inlined_ast: dc3cf8e9ac7249ffc35d02b8914989d6449b1fb37395577cf3dc96555fc4bd13 + dce_ast: b18fecc1fb16346a6a66e69b7bd9e65c40f4640f551f6e2f44777a18c8d00178 + bytecode: 03845ec2f54d49f71640659603ead8f68ad067a15fda438e5e13524777d1559b + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/keccak384_hash_to_field.out b/tests/expectations/compiler/core/algorithms/keccak384_hash_to_field.out new file mode 100644 index 0000000000..b55e2b1f8a --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/keccak384_hash_to_field.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 1f96df1e414fd96505a23c658692de40614d28804ebeaeafc90835f4087c91cc + type_checked_symbol_table: f51b6c1660b8bb5b45ca5e05c303bf2fb92e47d575ff34c69abec002486452f4 + unrolled_symbol_table: f51b6c1660b8bb5b45ca5e05c303bf2fb92e47d575ff34c69abec002486452f4 + initial_ast: 3a2576b0a93389ed4ec800447c3ffa4920033204b806fb6e6314cae96e6b5c03 + unrolled_ast: 3a2576b0a93389ed4ec800447c3ffa4920033204b806fb6e6314cae96e6b5c03 + ssa_ast: 1c5afbbce420c031f16b291d548ca2231b3dec0316664ce6547abca8f9a0cae2 + flattened_ast: a9a0a4c68f8b7561329bd7a9c7f81aaece939c9df14ff82508e9ddc05aad2bdb + inlined_ast: a9a0a4c68f8b7561329bd7a9c7f81aaece939c9df14ff82508e9ddc05aad2bdb + dce_ast: da75548e69f125b66b292cf4072e83b5fb6c92a6c40531655684f25428b6f08d + bytecode: f5347c70dbb10f7c191f2e29dc9b2e58760207351d34b8e0a5ccb91e360e9f79 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/keccak384_hash_to_group.out b/tests/expectations/compiler/core/algorithms/keccak384_hash_to_group.out new file mode 100644 index 0000000000..8bb291f1ab --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/keccak384_hash_to_group.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: fd9620b494239c2b62c2da7b951d51f08a1c0ad366a726e6b108da648ce5fb58 + type_checked_symbol_table: 392b4afe780015c412cfb5e45a1b084b40873e9eda40e05ef94ab54aaadf8a3d + unrolled_symbol_table: 392b4afe780015c412cfb5e45a1b084b40873e9eda40e05ef94ab54aaadf8a3d + initial_ast: 4247aabbd55a1e6a2cbfa7c299af86a89a7509ed0e13595b0bc46dfd44b595a7 + unrolled_ast: 4247aabbd55a1e6a2cbfa7c299af86a89a7509ed0e13595b0bc46dfd44b595a7 + ssa_ast: 4f62058738e58e69a13f043fb0665877fcba3dc44a97c5883de321264407c720 + flattened_ast: 0d294dddc5fbfa35fa5730199dc2144f186aa93d97b62b6af86a4b6d42d255a9 + inlined_ast: 0d294dddc5fbfa35fa5730199dc2144f186aa93d97b62b6af86a4b6d42d255a9 + dce_ast: d0ad3c52664b7926932d59b17f825bad6f9e4c831b1e0a87f803c3fb041f9a24 + bytecode: 7be24faec6f77c016109224b474ae5e5ef66bc3d02d058ae748d6b992990d165 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/keccak384_hash_to_scalar.out b/tests/expectations/compiler/core/algorithms/keccak384_hash_to_scalar.out new file mode 100644 index 0000000000..ed56b79952 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/keccak384_hash_to_scalar.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 15549a7085ac019c35b881b7ef00f56cbfbf0a21e9ceb4d4599fa4e06359d9e5 + type_checked_symbol_table: 3955df6eabb0bfb8f9df5a34a49c11bf3bf95325f88a0affd038b820e7541266 + unrolled_symbol_table: 3955df6eabb0bfb8f9df5a34a49c11bf3bf95325f88a0affd038b820e7541266 + initial_ast: 74e647eaf625f542b53a0096abd2f97ce17a39ebff80bc8be69efdc92f42359b + unrolled_ast: 74e647eaf625f542b53a0096abd2f97ce17a39ebff80bc8be69efdc92f42359b + ssa_ast: f15e6d14da955177fe5c5809386d7a143dbfe27b84106153c5cce9054630c28e + flattened_ast: 7d565655b040b8d19ba55689d31a72786938c94e095ee0632dc8ac3f3421063f + inlined_ast: 7d565655b040b8d19ba55689d31a72786938c94e095ee0632dc8ac3f3421063f + dce_ast: 5ae10398955c28bfb3174b24653ae0859366395d12bd6e21af267da4d93bde41 + bytecode: b2109894ba866067ec33ab20cdc34620697485b592f6a0d511e922a89bb065e1 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/keccak512_hash_to_address.out b/tests/expectations/compiler/core/algorithms/keccak512_hash_to_address.out new file mode 100644 index 0000000000..91218f4dd7 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/keccak512_hash_to_address.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 1f96df1e414fd96505a23c658692de40614d28804ebeaeafc90835f4087c91cc + type_checked_symbol_table: aaaec423b2c439b4857751e7dec72e29fbe3cf863753d6f21e52c9d0f5e98558 + unrolled_symbol_table: aaaec423b2c439b4857751e7dec72e29fbe3cf863753d6f21e52c9d0f5e98558 + initial_ast: bedd5210c9c85926db1570286d3af26fa455ff15eaa1dd72b648db2009a7edd5 + unrolled_ast: bedd5210c9c85926db1570286d3af26fa455ff15eaa1dd72b648db2009a7edd5 + ssa_ast: ae982eca8c61dc6cec70947d683744e4396757533a89ff574da9879c24d536c6 + flattened_ast: 7cce5d9969b7a7fd5d9837c4bceff3a57b0aff536f9e4f7c420292a7a51854cd + inlined_ast: 7cce5d9969b7a7fd5d9837c4bceff3a57b0aff536f9e4f7c420292a7a51854cd + dce_ast: b18fecc1fb16346a6a66e69b7bd9e65c40f4640f551f6e2f44777a18c8d00178 + bytecode: 03845ec2f54d49f71640659603ead8f68ad067a15fda438e5e13524777d1559b + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/keccak512_hash_to_field.out b/tests/expectations/compiler/core/algorithms/keccak512_hash_to_field.out new file mode 100644 index 0000000000..35fa091a57 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/keccak512_hash_to_field.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 1f96df1e414fd96505a23c658692de40614d28804ebeaeafc90835f4087c91cc + type_checked_symbol_table: f51b6c1660b8bb5b45ca5e05c303bf2fb92e47d575ff34c69abec002486452f4 + unrolled_symbol_table: f51b6c1660b8bb5b45ca5e05c303bf2fb92e47d575ff34c69abec002486452f4 + initial_ast: 41cbb2a60f56fb9e0635f3a11e959e9e75ba6a11541bbd47f7e1321dc7df7cdc + unrolled_ast: 41cbb2a60f56fb9e0635f3a11e959e9e75ba6a11541bbd47f7e1321dc7df7cdc + ssa_ast: e791d20adce2a317c4b36c7b64ffa3896b63ae3e9f386d285d93b26f73d45054 + flattened_ast: 0b89e25715c0ebbf8824c5455ac3baea84b9dc3066b534b4ff381a8e431baff7 + inlined_ast: 0b89e25715c0ebbf8824c5455ac3baea84b9dc3066b534b4ff381a8e431baff7 + dce_ast: 5b2c26b4368627ed2fe0d908b80b654b08093a2503987fe2548735e46dfd81f9 + bytecode: 31250720832dea7675bf097f3ff4a7e878a544854d76a583daeaa8508e5b7165 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/keccak512_hash_to_group.out b/tests/expectations/compiler/core/algorithms/keccak512_hash_to_group.out new file mode 100644 index 0000000000..2e5e6d85db --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/keccak512_hash_to_group.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: fd9620b494239c2b62c2da7b951d51f08a1c0ad366a726e6b108da648ce5fb58 + type_checked_symbol_table: 392b4afe780015c412cfb5e45a1b084b40873e9eda40e05ef94ab54aaadf8a3d + unrolled_symbol_table: 392b4afe780015c412cfb5e45a1b084b40873e9eda40e05ef94ab54aaadf8a3d + initial_ast: dc41c23161a01a00d01faa27e22454daac729a741d39c5c0f03f32388d709149 + unrolled_ast: dc41c23161a01a00d01faa27e22454daac729a741d39c5c0f03f32388d709149 + ssa_ast: 7d08d80254e02abdb4a4a5fee443f7f51bf03fa943086ae68816c93836764a8b + flattened_ast: 3f190fb474f52d158fb91c58481f3e8c188a454af068b0bcb38c85901ff9d1af + inlined_ast: 3f190fb474f52d158fb91c58481f3e8c188a454af068b0bcb38c85901ff9d1af + dce_ast: a324a68d939b144a29573c698e03464d2e2140fdc7f21fcfbe78e13697bf22cd + bytecode: 04dce70893b730595c768593a76510f027b13559817d71dc7b804933692e59a9 + warnings: "" diff --git a/tests/expectations/compiler/core/algorithms/keccak512_hash_to_scalar.out b/tests/expectations/compiler/core/algorithms/keccak512_hash_to_scalar.out new file mode 100644 index 0000000000..eea1416c74 --- /dev/null +++ b/tests/expectations/compiler/core/algorithms/keccak512_hash_to_scalar.out @@ -0,0 +1,15 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - - initial_symbol_table: 15549a7085ac019c35b881b7ef00f56cbfbf0a21e9ceb4d4599fa4e06359d9e5 + type_checked_symbol_table: 3955df6eabb0bfb8f9df5a34a49c11bf3bf95325f88a0affd038b820e7541266 + unrolled_symbol_table: 3955df6eabb0bfb8f9df5a34a49c11bf3bf95325f88a0affd038b820e7541266 + initial_ast: 3c939d7f3076e6edf7f74ddb21ee27196d969bf78c7611677641ffdf0f1322c3 + unrolled_ast: 3c939d7f3076e6edf7f74ddb21ee27196d969bf78c7611677641ffdf0f1322c3 + ssa_ast: c17b9dc607933ace7772f121637ca1eb8e1d9d689e48c0c5297adb25832d5c12 + flattened_ast: e889acf552b1994212ddccdfc230db3bbd42abd2f40720d1481dc5513626f0b1 + inlined_ast: e889acf552b1994212ddccdfc230db3bbd42abd2f40720d1481dc5513626f0b1 + dce_ast: 296741a087aa45358113d04edef2c5f5764da3073cd710132b8d71a91b7abcc1 + bytecode: 48564e67f77504fa5f896b7b8f03dcc3bd690898df96eed9027776e1346b07ad + warnings: "" diff --git a/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i128.leo b/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i128.leo new file mode 100644 index 0000000000..ef3d9a5e02 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i128.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> i128 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak256 hash_to_i128 tests + let a: i128 = Keccak256::hash_to_i128(addr_value); + let b: i128 = Keccak256::hash_to_i128(bool_value); + let c: i128 = Keccak256::hash_to_i128(field_value); + let d: i128 = Keccak256::hash_to_i128(group_value); + let e: i128 = Keccak256::hash_to_i128(i8_value); + let f: i128 = Keccak256::hash_to_i128(i16_value); + let g: i128 = Keccak256::hash_to_i128(i32_value); + let h: i128 = Keccak256::hash_to_i128(i64_value); + let i: i128 = Keccak256::hash_to_i128(i128_value); + let j: i128 = Keccak256::hash_to_i128(u8_value); + let k: i128 = Keccak256::hash_to_i128(u16_value); + let l: i128 = Keccak256::hash_to_i128(u32_value); + let m: i128 = Keccak256::hash_to_i128(u64_value); + let n: i128 = Keccak256::hash_to_i128(u128_value); + let o: i128 = Keccak256::hash_to_i128(scalar_value); + // let p: i128 = Keccak256::hash_to_i128(string_value); + let q: i128 = Keccak256::hash_to_i128(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i16.leo b/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i16.leo new file mode 100644 index 0000000000..a72047cd5b --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i16.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> i16 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak256 hash_to_i16 tests + let a: i16 = Keccak256::hash_to_i16(addr_value); + let b: i16 = Keccak256::hash_to_i16(bool_value); + let c: i16 = Keccak256::hash_to_i16(field_value); + let d: i16 = Keccak256::hash_to_i16(group_value); + let e: i16 = Keccak256::hash_to_i16(i8_value); + let f: i16 = Keccak256::hash_to_i16(i16_value); + let g: i16 = Keccak256::hash_to_i16(i32_value); + let h: i16 = Keccak256::hash_to_i16(i64_value); + let i: i16 = Keccak256::hash_to_i16(i128_value); + let j: i16 = Keccak256::hash_to_i16(u8_value); + let k: i16 = Keccak256::hash_to_i16(u16_value); + let l: i16 = Keccak256::hash_to_i16(u32_value); + let m: i16 = Keccak256::hash_to_i16(u64_value); + let n: i16 = Keccak256::hash_to_i16(u128_value); + let o: i16 = Keccak256::hash_to_i16(scalar_value); + // let p: i16 = Keccak256::hash_to_i16(string_value); + let q: i16 = Keccak256::hash_to_i16(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i32.leo b/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i32.leo new file mode 100644 index 0000000000..4fd72df1d2 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i32.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> i32 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak256 hash_to_i32 tests + let a: i32 = Keccak256::hash_to_i32(addr_value); + let b: i32 = Keccak256::hash_to_i32(bool_value); + let c: i32 = Keccak256::hash_to_i32(field_value); + let d: i32 = Keccak256::hash_to_i32(group_value); + let e: i32 = Keccak256::hash_to_i32(i8_value); + let f: i32 = Keccak256::hash_to_i32(i16_value); + let g: i32 = Keccak256::hash_to_i32(i32_value); + let h: i32 = Keccak256::hash_to_i32(i64_value); + let i: i32 = Keccak256::hash_to_i32(i128_value); + let j: i32 = Keccak256::hash_to_i32(u8_value); + let k: i32 = Keccak256::hash_to_i32(u16_value); + let l: i32 = Keccak256::hash_to_i32(u32_value); + let m: i32 = Keccak256::hash_to_i32(u64_value); + let n: i32 = Keccak256::hash_to_i32(u128_value); + let o: i32 = Keccak256::hash_to_i32(scalar_value); + // let p: i32 = Keccak256::hash_to_i32(string_value); + let q: i32 = Keccak256::hash_to_i32(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i64.leo b/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i64.leo new file mode 100644 index 0000000000..88ed60a9ec --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i64.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> i64 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak256 hash_to_i64 tests + let a: i64 = Keccak256::hash_to_i64(addr_value); + let b: i64 = Keccak256::hash_to_i64(bool_value); + let c: i64 = Keccak256::hash_to_i64(field_value); + let d: i64 = Keccak256::hash_to_i64(group_value); + let e: i64 = Keccak256::hash_to_i64(i8_value); + let f: i64 = Keccak256::hash_to_i64(i16_value); + let g: i64 = Keccak256::hash_to_i64(i32_value); + let h: i64 = Keccak256::hash_to_i64(i64_value); + let i: i64 = Keccak256::hash_to_i64(i128_value); + let j: i64 = Keccak256::hash_to_i64(u8_value); + let k: i64 = Keccak256::hash_to_i64(u16_value); + let l: i64 = Keccak256::hash_to_i64(u32_value); + let m: i64 = Keccak256::hash_to_i64(u64_value); + let n: i64 = Keccak256::hash_to_i64(u128_value); + let o: i64 = Keccak256::hash_to_i64(scalar_value); + // let p: i64 = Keccak256::hash_to_i64(string_value); + let q: i64 = Keccak256::hash_to_i64(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i8.leo b/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i8.leo new file mode 100644 index 0000000000..88fa58877e --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i8.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> i8 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak256 hash_to_i8 tests + let a: i8 = Keccak256::hash_to_i8(addr_value); + let b: i8 = Keccak256::hash_to_i8(bool_value); + let c: i8 = Keccak256::hash_to_i8(field_value); + let d: i8 = Keccak256::hash_to_i8(group_value); + let e: i8 = Keccak256::hash_to_i8(i8_value); + let f: i8 = Keccak256::hash_to_i8(i16_value); + let g: i8 = Keccak256::hash_to_i8(i32_value); + let h: i8 = Keccak256::hash_to_i8(i64_value); + let i: i8 = Keccak256::hash_to_i8(i128_value); + let j: i8 = Keccak256::hash_to_i8(u8_value); + let k: i8 = Keccak256::hash_to_i8(u16_value); + let l: i8 = Keccak256::hash_to_i8(u32_value); + let m: i8 = Keccak256::hash_to_i8(u64_value); + let n: i8 = Keccak256::hash_to_i8(u128_value); + let o: i8 = Keccak256::hash_to_i8(scalar_value); + // let p: i8 = Keccak256::hash_to_i8(string_value); + let q: i8 = Keccak256::hash_to_i8(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u128.leo b/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u128.leo new file mode 100644 index 0000000000..329d90f682 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u128.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> u128 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak256 hash_to_u128 tests + let a: u128 = Keccak256::hash_to_u128(addr_value); + let b: u128 = Keccak256::hash_to_u128(bool_value); + let c: u128 = Keccak256::hash_to_u128(field_value); + let d: u128 = Keccak256::hash_to_u128(group_value); + let e: u128 = Keccak256::hash_to_u128(i8_value); + let f: u128 = Keccak256::hash_to_u128(i16_value); + let g: u128 = Keccak256::hash_to_u128(i32_value); + let h: u128 = Keccak256::hash_to_u128(i64_value); + let i: u128 = Keccak256::hash_to_u128(i128_value); + let j: u128 = Keccak256::hash_to_u128(u8_value); + let k: u128 = Keccak256::hash_to_u128(u16_value); + let l: u128 = Keccak256::hash_to_u128(u32_value); + let m: u128 = Keccak256::hash_to_u128(u64_value); + let n: u128 = Keccak256::hash_to_u128(u128_value); + let o: u128 = Keccak256::hash_to_u128(scalar_value); + // let p: u128 = Keccak256::hash_to_u128(string_value); + let q: u128 = Keccak256::hash_to_u128(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u16.leo b/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u16.leo new file mode 100644 index 0000000000..f6398803b7 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u16.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> u16 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak256 hash_to_u16 tests + let a: u16 = Keccak256::hash_to_u16(addr_value); + let b: u16 = Keccak256::hash_to_u16(bool_value); + let c: u16 = Keccak256::hash_to_u16(field_value); + let d: u16 = Keccak256::hash_to_u16(group_value); + let e: u16 = Keccak256::hash_to_u16(i8_value); + let f: u16 = Keccak256::hash_to_u16(i16_value); + let g: u16 = Keccak256::hash_to_u16(i32_value); + let h: u16 = Keccak256::hash_to_u16(i64_value); + let i: u16 = Keccak256::hash_to_u16(i128_value); + let j: u16 = Keccak256::hash_to_u16(u8_value); + let k: u16 = Keccak256::hash_to_u16(u16_value); + let l: u16 = Keccak256::hash_to_u16(u32_value); + let m: u16 = Keccak256::hash_to_u16(u64_value); + let n: u16 = Keccak256::hash_to_u16(u128_value); + let o: u16 = Keccak256::hash_to_u16(scalar_value); + // let p: u16 = Keccak256::hash_to_u16(string_value); + let q: u16 = Keccak256::hash_to_u16(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u32.leo b/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u32.leo new file mode 100644 index 0000000000..2942b5b8bc --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u32.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> u32 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak256 hash_to_u32 tests + let a: u32 = Keccak256::hash_to_u32(addr_value); + let b: u32 = Keccak256::hash_to_u32(bool_value); + let c: u32 = Keccak256::hash_to_u32(field_value); + let d: u32 = Keccak256::hash_to_u32(group_value); + let e: u32 = Keccak256::hash_to_u32(i8_value); + let f: u32 = Keccak256::hash_to_u32(i16_value); + let g: u32 = Keccak256::hash_to_u32(i32_value); + let h: u32 = Keccak256::hash_to_u32(i64_value); + let i: u32 = Keccak256::hash_to_u32(i128_value); + let j: u32 = Keccak256::hash_to_u32(u8_value); + let k: u32 = Keccak256::hash_to_u32(u16_value); + let l: u32 = Keccak256::hash_to_u32(u32_value); + let m: u32 = Keccak256::hash_to_u32(u64_value); + let n: u32 = Keccak256::hash_to_u32(u128_value); + let o: u32 = Keccak256::hash_to_u32(scalar_value); + // let p: u32 = Keccak256::hash_to_u32(string_value); + let q: u32 = Keccak256::hash_to_u32(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u64.leo b/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u64.leo new file mode 100644 index 0000000000..d1a36f06a2 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u64.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> u64 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak256 hash_to_u64 tests + let a: u64 = Keccak256::hash_to_u64(addr_value); + let b: u64 = Keccak256::hash_to_u64(bool_value); + let c: u64 = Keccak256::hash_to_u64(field_value); + let d: u64 = Keccak256::hash_to_u64(group_value); + let e: u64 = Keccak256::hash_to_u64(i8_value); + let f: u64 = Keccak256::hash_to_u64(i16_value); + let g: u64 = Keccak256::hash_to_u64(i32_value); + let h: u64 = Keccak256::hash_to_u64(i64_value); + let i: u64 = Keccak256::hash_to_u64(i128_value); + let j: u64 = Keccak256::hash_to_u64(u8_value); + let k: u64 = Keccak256::hash_to_u64(u16_value); + let l: u64 = Keccak256::hash_to_u64(u32_value); + let m: u64 = Keccak256::hash_to_u64(u64_value); + let n: u64 = Keccak256::hash_to_u64(u128_value); + let o: u64 = Keccak256::hash_to_u64(scalar_value); + // let p: u64 = Keccak256::hash_to_u64(string_value); + let q: u64 = Keccak256::hash_to_u64(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u8.leo b/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u8.leo new file mode 100644 index 0000000000..1df7e292f2 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u8.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> u8 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak256 hash_to_u8 tests + let a: u8 = Keccak256::hash_to_u8(addr_value); + let b: u8 = Keccak256::hash_to_u8(bool_value); + let c: u8 = Keccak256::hash_to_u8(field_value); + let d: u8 = Keccak256::hash_to_u8(group_value); + let e: u8 = Keccak256::hash_to_u8(i8_value); + let f: u8 = Keccak256::hash_to_u8(i16_value); + let g: u8 = Keccak256::hash_to_u8(i32_value); + let h: u8 = Keccak256::hash_to_u8(i64_value); + let i: u8 = Keccak256::hash_to_u8(i128_value); + let j: u8 = Keccak256::hash_to_u8(u8_value); + let k: u8 = Keccak256::hash_to_u8(u16_value); + let l: u8 = Keccak256::hash_to_u8(u32_value); + let m: u8 = Keccak256::hash_to_u8(u64_value); + let n: u8 = Keccak256::hash_to_u8(u128_value); + let o: u8 = Keccak256::hash_to_u8(scalar_value); + // let p: u8 = Keccak256::hash_to_u8(string_value); + let q: u8 = Keccak256::hash_to_u8(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i128.leo b/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i128.leo new file mode 100644 index 0000000000..180e158b23 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i128.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> i128 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak384 hash_to_i128 tests + let a: i128 = Keccak384::hash_to_i128(addr_value); + let b: i128 = Keccak384::hash_to_i128(bool_value); + let c: i128 = Keccak384::hash_to_i128(field_value); + let d: i128 = Keccak384::hash_to_i128(group_value); + let e: i128 = Keccak384::hash_to_i128(i8_value); + let f: i128 = Keccak384::hash_to_i128(i16_value); + let g: i128 = Keccak384::hash_to_i128(i32_value); + let h: i128 = Keccak384::hash_to_i128(i64_value); + let i: i128 = Keccak384::hash_to_i128(i128_value); + let j: i128 = Keccak384::hash_to_i128(u8_value); + let k: i128 = Keccak384::hash_to_i128(u16_value); + let l: i128 = Keccak384::hash_to_i128(u32_value); + let m: i128 = Keccak384::hash_to_i128(u64_value); + let n: i128 = Keccak384::hash_to_i128(u128_value); + let o: i128 = Keccak384::hash_to_i128(scalar_value); + // let p: i128 = Keccak384::hash_to_i128(string_value); + let q: i128 = Keccak384::hash_to_i128(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i16.leo b/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i16.leo new file mode 100644 index 0000000000..a0d60a327c --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i16.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> i16 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak384 hash_to_i16 tests + let a: i16 = Keccak384::hash_to_i16(addr_value); + let b: i16 = Keccak384::hash_to_i16(bool_value); + let c: i16 = Keccak384::hash_to_i16(field_value); + let d: i16 = Keccak384::hash_to_i16(group_value); + let e: i16 = Keccak384::hash_to_i16(i8_value); + let f: i16 = Keccak384::hash_to_i16(i16_value); + let g: i16 = Keccak384::hash_to_i16(i32_value); + let h: i16 = Keccak384::hash_to_i16(i64_value); + let i: i16 = Keccak384::hash_to_i16(i128_value); + let j: i16 = Keccak384::hash_to_i16(u8_value); + let k: i16 = Keccak384::hash_to_i16(u16_value); + let l: i16 = Keccak384::hash_to_i16(u32_value); + let m: i16 = Keccak384::hash_to_i16(u64_value); + let n: i16 = Keccak384::hash_to_i16(u128_value); + let o: i16 = Keccak384::hash_to_i16(scalar_value); + // let p: i16 = Keccak384::hash_to_i16(string_value); + let q: i16 = Keccak384::hash_to_i16(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i32.leo b/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i32.leo new file mode 100644 index 0000000000..a9fd3deb18 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i32.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> i32 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak384 hash_to_i32 tests + let a: i32 = Keccak384::hash_to_i32(addr_value); + let b: i32 = Keccak384::hash_to_i32(bool_value); + let c: i32 = Keccak384::hash_to_i32(field_value); + let d: i32 = Keccak384::hash_to_i32(group_value); + let e: i32 = Keccak384::hash_to_i32(i8_value); + let f: i32 = Keccak384::hash_to_i32(i16_value); + let g: i32 = Keccak384::hash_to_i32(i32_value); + let h: i32 = Keccak384::hash_to_i32(i64_value); + let i: i32 = Keccak384::hash_to_i32(i128_value); + let j: i32 = Keccak384::hash_to_i32(u8_value); + let k: i32 = Keccak384::hash_to_i32(u16_value); + let l: i32 = Keccak384::hash_to_i32(u32_value); + let m: i32 = Keccak384::hash_to_i32(u64_value); + let n: i32 = Keccak384::hash_to_i32(u128_value); + let o: i32 = Keccak384::hash_to_i32(scalar_value); + // let p: i32 = Keccak384::hash_to_i32(string_value); + let q: i32 = Keccak384::hash_to_i32(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i64.leo b/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i64.leo new file mode 100644 index 0000000000..777bb3d942 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i64.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> i64 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak384 hash_to_i64 tests + let a: i64 = Keccak384::hash_to_i64(addr_value); + let b: i64 = Keccak384::hash_to_i64(bool_value); + let c: i64 = Keccak384::hash_to_i64(field_value); + let d: i64 = Keccak384::hash_to_i64(group_value); + let e: i64 = Keccak384::hash_to_i64(i8_value); + let f: i64 = Keccak384::hash_to_i64(i16_value); + let g: i64 = Keccak384::hash_to_i64(i32_value); + let h: i64 = Keccak384::hash_to_i64(i64_value); + let i: i64 = Keccak384::hash_to_i64(i128_value); + let j: i64 = Keccak384::hash_to_i64(u8_value); + let k: i64 = Keccak384::hash_to_i64(u16_value); + let l: i64 = Keccak384::hash_to_i64(u32_value); + let m: i64 = Keccak384::hash_to_i64(u64_value); + let n: i64 = Keccak384::hash_to_i64(u128_value); + let o: i64 = Keccak384::hash_to_i64(scalar_value); + // let p: i64 = Keccak384::hash_to_i64(string_value); + let q: i64 = Keccak384::hash_to_i64(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i8.leo b/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i8.leo new file mode 100644 index 0000000000..bc3c0a827c --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i8.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> i8 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak384 hash_to_i8 tests + let a: i8 = Keccak384::hash_to_i8(addr_value); + let b: i8 = Keccak384::hash_to_i8(bool_value); + let c: i8 = Keccak384::hash_to_i8(field_value); + let d: i8 = Keccak384::hash_to_i8(group_value); + let e: i8 = Keccak384::hash_to_i8(i8_value); + let f: i8 = Keccak384::hash_to_i8(i16_value); + let g: i8 = Keccak384::hash_to_i8(i32_value); + let h: i8 = Keccak384::hash_to_i8(i64_value); + let i: i8 = Keccak384::hash_to_i8(i128_value); + let j: i8 = Keccak384::hash_to_i8(u8_value); + let k: i8 = Keccak384::hash_to_i8(u16_value); + let l: i8 = Keccak384::hash_to_i8(u32_value); + let m: i8 = Keccak384::hash_to_i8(u64_value); + let n: i8 = Keccak384::hash_to_i8(u128_value); + let o: i8 = Keccak384::hash_to_i8(scalar_value); + // let p: i8 = Keccak384::hash_to_i8(string_value); + let q: i8 = Keccak384::hash_to_i8(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u128.leo b/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u128.leo new file mode 100644 index 0000000000..cb27ac589c --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u128.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> u128 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak384 hash_to_u128 tests + let a: u128 = Keccak384::hash_to_u128(addr_value); + let b: u128 = Keccak384::hash_to_u128(bool_value); + let c: u128 = Keccak384::hash_to_u128(field_value); + let d: u128 = Keccak384::hash_to_u128(group_value); + let e: u128 = Keccak384::hash_to_u128(i8_value); + let f: u128 = Keccak384::hash_to_u128(i16_value); + let g: u128 = Keccak384::hash_to_u128(i32_value); + let h: u128 = Keccak384::hash_to_u128(i64_value); + let i: u128 = Keccak384::hash_to_u128(i128_value); + let j: u128 = Keccak384::hash_to_u128(u8_value); + let k: u128 = Keccak384::hash_to_u128(u16_value); + let l: u128 = Keccak384::hash_to_u128(u32_value); + let m: u128 = Keccak384::hash_to_u128(u64_value); + let n: u128 = Keccak384::hash_to_u128(u128_value); + let o: u128 = Keccak384::hash_to_u128(scalar_value); + // let p: u128 = Keccak384::hash_to_u128(string_value); + let q: u128 = Keccak384::hash_to_u128(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u16.leo b/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u16.leo new file mode 100644 index 0000000000..b20200cd0e --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u16.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> u16 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak384 hash_to_u16 tests + let a: u16 = Keccak384::hash_to_u16(addr_value); + let b: u16 = Keccak384::hash_to_u16(bool_value); + let c: u16 = Keccak384::hash_to_u16(field_value); + let d: u16 = Keccak384::hash_to_u16(group_value); + let e: u16 = Keccak384::hash_to_u16(i8_value); + let f: u16 = Keccak384::hash_to_u16(i16_value); + let g: u16 = Keccak384::hash_to_u16(i32_value); + let h: u16 = Keccak384::hash_to_u16(i64_value); + let i: u16 = Keccak384::hash_to_u16(i128_value); + let j: u16 = Keccak384::hash_to_u16(u8_value); + let k: u16 = Keccak384::hash_to_u16(u16_value); + let l: u16 = Keccak384::hash_to_u16(u32_value); + let m: u16 = Keccak384::hash_to_u16(u64_value); + let n: u16 = Keccak384::hash_to_u16(u128_value); + let o: u16 = Keccak384::hash_to_u16(scalar_value); + // let p: u16 = Keccak384::hash_to_u16(string_value); + let q: u16 = Keccak384::hash_to_u16(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u32.leo b/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u32.leo new file mode 100644 index 0000000000..ee3bc2ad0a --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u32.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> u32 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak384 hash_to_u32 tests + let a: u32 = Keccak384::hash_to_u32(addr_value); + let b: u32 = Keccak384::hash_to_u32(bool_value); + let c: u32 = Keccak384::hash_to_u32(field_value); + let d: u32 = Keccak384::hash_to_u32(group_value); + let e: u32 = Keccak384::hash_to_u32(i8_value); + let f: u32 = Keccak384::hash_to_u32(i16_value); + let g: u32 = Keccak384::hash_to_u32(i32_value); + let h: u32 = Keccak384::hash_to_u32(i64_value); + let i: u32 = Keccak384::hash_to_u32(i128_value); + let j: u32 = Keccak384::hash_to_u32(u8_value); + let k: u32 = Keccak384::hash_to_u32(u16_value); + let l: u32 = Keccak384::hash_to_u32(u32_value); + let m: u32 = Keccak384::hash_to_u32(u64_value); + let n: u32 = Keccak384::hash_to_u32(u128_value); + let o: u32 = Keccak384::hash_to_u32(scalar_value); + // let p: u32 = Keccak384::hash_to_u32(string_value); + let q: u32 = Keccak384::hash_to_u32(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u64.leo b/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u64.leo new file mode 100644 index 0000000000..9905d6635a --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u64.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> u64 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak384 hash_to_u64 tests + let a: u64 = Keccak384::hash_to_u64(addr_value); + let b: u64 = Keccak384::hash_to_u64(bool_value); + let c: u64 = Keccak384::hash_to_u64(field_value); + let d: u64 = Keccak384::hash_to_u64(group_value); + let e: u64 = Keccak384::hash_to_u64(i8_value); + let f: u64 = Keccak384::hash_to_u64(i16_value); + let g: u64 = Keccak384::hash_to_u64(i32_value); + let h: u64 = Keccak384::hash_to_u64(i64_value); + let i: u64 = Keccak384::hash_to_u64(i128_value); + let j: u64 = Keccak384::hash_to_u64(u8_value); + let k: u64 = Keccak384::hash_to_u64(u16_value); + let l: u64 = Keccak384::hash_to_u64(u32_value); + let m: u64 = Keccak384::hash_to_u64(u64_value); + let n: u64 = Keccak384::hash_to_u64(u128_value); + let o: u64 = Keccak384::hash_to_u64(scalar_value); + // let p: u64 = Keccak384::hash_to_u64(string_value); + let q: u64 = Keccak384::hash_to_u64(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u8.leo b/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u8.leo new file mode 100644 index 0000000000..683457f723 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u8.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> u8 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak384 hash_to_u8 tests + let a: u8 = Keccak384::hash_to_u8(addr_value); + let b: u8 = Keccak384::hash_to_u8(bool_value); + let c: u8 = Keccak384::hash_to_u8(field_value); + let d: u8 = Keccak384::hash_to_u8(group_value); + let e: u8 = Keccak384::hash_to_u8(i8_value); + let f: u8 = Keccak384::hash_to_u8(i16_value); + let g: u8 = Keccak384::hash_to_u8(i32_value); + let h: u8 = Keccak384::hash_to_u8(i64_value); + let i: u8 = Keccak384::hash_to_u8(i128_value); + let j: u8 = Keccak384::hash_to_u8(u8_value); + let k: u8 = Keccak384::hash_to_u8(u16_value); + let l: u8 = Keccak384::hash_to_u8(u32_value); + let m: u8 = Keccak384::hash_to_u8(u64_value); + let n: u8 = Keccak384::hash_to_u8(u128_value); + let o: u8 = Keccak384::hash_to_u8(scalar_value); + // let p: u8 = Keccak384::hash_to_u8(string_value); + let q: u8 = Keccak384::hash_to_u8(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i128.leo b/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i128.leo new file mode 100644 index 0000000000..9f95cfdb08 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i128.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> i128 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak512 hash_to_i128 tests + let a: i128 = Keccak512::hash_to_i128(addr_value); + let b: i128 = Keccak512::hash_to_i128(bool_value); + let c: i128 = Keccak512::hash_to_i128(field_value); + let d: i128 = Keccak512::hash_to_i128(group_value); + let e: i128 = Keccak512::hash_to_i128(i8_value); + let f: i128 = Keccak512::hash_to_i128(i16_value); + let g: i128 = Keccak512::hash_to_i128(i32_value); + let h: i128 = Keccak512::hash_to_i128(i64_value); + let i: i128 = Keccak512::hash_to_i128(i128_value); + let j: i128 = Keccak512::hash_to_i128(u8_value); + let k: i128 = Keccak512::hash_to_i128(u16_value); + let l: i128 = Keccak512::hash_to_i128(u32_value); + let m: i128 = Keccak512::hash_to_i128(u64_value); + let n: i128 = Keccak512::hash_to_i128(u128_value); + let o: i128 = Keccak512::hash_to_i128(scalar_value); + // let p: i128 = Keccak512::hash_to_i128(string_value); + let q: i128 = Keccak512::hash_to_i128(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i16.leo b/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i16.leo new file mode 100644 index 0000000000..91764a9b9c --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i16.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> i16 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak512 hash_to_i16 tests + let a: i16 = Keccak512::hash_to_i16(addr_value); + let b: i16 = Keccak512::hash_to_i16(bool_value); + let c: i16 = Keccak512::hash_to_i16(field_value); + let d: i16 = Keccak512::hash_to_i16(group_value); + let e: i16 = Keccak512::hash_to_i16(i8_value); + let f: i16 = Keccak512::hash_to_i16(i16_value); + let g: i16 = Keccak512::hash_to_i16(i32_value); + let h: i16 = Keccak512::hash_to_i16(i64_value); + let i: i16 = Keccak512::hash_to_i16(i128_value); + let j: i16 = Keccak512::hash_to_i16(u8_value); + let k: i16 = Keccak512::hash_to_i16(u16_value); + let l: i16 = Keccak512::hash_to_i16(u32_value); + let m: i16 = Keccak512::hash_to_i16(u64_value); + let n: i16 = Keccak512::hash_to_i16(u128_value); + let o: i16 = Keccak512::hash_to_i16(scalar_value); + // let p: i16 = Keccak512::hash_to_i16(string_value); + let q: i16 = Keccak512::hash_to_i16(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i32.leo b/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i32.leo new file mode 100644 index 0000000000..b54b9b6b84 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i32.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> i32 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak512 hash_to_i32 tests + let a: i32 = Keccak512::hash_to_i32(addr_value); + let b: i32 = Keccak512::hash_to_i32(bool_value); + let c: i32 = Keccak512::hash_to_i32(field_value); + let d: i32 = Keccak512::hash_to_i32(group_value); + let e: i32 = Keccak512::hash_to_i32(i8_value); + let f: i32 = Keccak512::hash_to_i32(i16_value); + let g: i32 = Keccak512::hash_to_i32(i32_value); + let h: i32 = Keccak512::hash_to_i32(i64_value); + let i: i32 = Keccak512::hash_to_i32(i128_value); + let j: i32 = Keccak512::hash_to_i32(u8_value); + let k: i32 = Keccak512::hash_to_i32(u16_value); + let l: i32 = Keccak512::hash_to_i32(u32_value); + let m: i32 = Keccak512::hash_to_i32(u64_value); + let n: i32 = Keccak512::hash_to_i32(u128_value); + let o: i32 = Keccak512::hash_to_i32(scalar_value); + // let p: i32 = Keccak512::hash_to_i32(string_value); + let q: i32 = Keccak512::hash_to_i32(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i64.leo b/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i64.leo new file mode 100644 index 0000000000..f8e8ee73a8 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i64.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> i64 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak512 hash_to_i64 tests + let a: i64 = Keccak512::hash_to_i64(addr_value); + let b: i64 = Keccak512::hash_to_i64(bool_value); + let c: i64 = Keccak512::hash_to_i64(field_value); + let d: i64 = Keccak512::hash_to_i64(group_value); + let e: i64 = Keccak512::hash_to_i64(i8_value); + let f: i64 = Keccak512::hash_to_i64(i16_value); + let g: i64 = Keccak512::hash_to_i64(i32_value); + let h: i64 = Keccak512::hash_to_i64(i64_value); + let i: i64 = Keccak512::hash_to_i64(i128_value); + let j: i64 = Keccak512::hash_to_i64(u8_value); + let k: i64 = Keccak512::hash_to_i64(u16_value); + let l: i64 = Keccak512::hash_to_i64(u32_value); + let m: i64 = Keccak512::hash_to_i64(u64_value); + let n: i64 = Keccak512::hash_to_i64(u128_value); + let o: i64 = Keccak512::hash_to_i64(scalar_value); + // let p: i64 = Keccak512::hash_to_i64(string_value); + let q: i64 = Keccak512::hash_to_i64(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i8.leo b/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i8.leo new file mode 100644 index 0000000000..a7ae5b82fd --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i8.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> i8 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak512 hash_to_i8 tests + let a: i8 = Keccak512::hash_to_i8(addr_value); + let b: i8 = Keccak512::hash_to_i8(bool_value); + let c: i8 = Keccak512::hash_to_i8(field_value); + let d: i8 = Keccak512::hash_to_i8(group_value); + let e: i8 = Keccak512::hash_to_i8(i8_value); + let f: i8 = Keccak512::hash_to_i8(i16_value); + let g: i8 = Keccak512::hash_to_i8(i32_value); + let h: i8 = Keccak512::hash_to_i8(i64_value); + let i: i8 = Keccak512::hash_to_i8(i128_value); + let j: i8 = Keccak512::hash_to_i8(u8_value); + let k: i8 = Keccak512::hash_to_i8(u16_value); + let l: i8 = Keccak512::hash_to_i8(u32_value); + let m: i8 = Keccak512::hash_to_i8(u64_value); + let n: i8 = Keccak512::hash_to_i8(u128_value); + let o: i8 = Keccak512::hash_to_i8(scalar_value); + // let p: i8 = Keccak512::hash_to_i8(string_value); + let q: i8 = Keccak512::hash_to_i8(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u128.leo b/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u128.leo new file mode 100644 index 0000000000..12c666f9dc --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u128.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> u128 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak512 hash_to_u128 tests + let a: u128 = Keccak512::hash_to_u128(addr_value); + let b: u128 = Keccak512::hash_to_u128(bool_value); + let c: u128 = Keccak512::hash_to_u128(field_value); + let d: u128 = Keccak512::hash_to_u128(group_value); + let e: u128 = Keccak512::hash_to_u128(i8_value); + let f: u128 = Keccak512::hash_to_u128(i16_value); + let g: u128 = Keccak512::hash_to_u128(i32_value); + let h: u128 = Keccak512::hash_to_u128(i64_value); + let i: u128 = Keccak512::hash_to_u128(i128_value); + let j: u128 = Keccak512::hash_to_u128(u8_value); + let k: u128 = Keccak512::hash_to_u128(u16_value); + let l: u128 = Keccak512::hash_to_u128(u32_value); + let m: u128 = Keccak512::hash_to_u128(u64_value); + let n: u128 = Keccak512::hash_to_u128(u128_value); + let o: u128 = Keccak512::hash_to_u128(scalar_value); + // let p: u128 = Keccak512::hash_to_u128(string_value); + let q: u128 = Keccak512::hash_to_u128(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u16.leo b/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u16.leo new file mode 100644 index 0000000000..90806acf00 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u16.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> u16 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak512 hash_to_u16 tests + let a: u16 = Keccak512::hash_to_u16(addr_value); + let b: u16 = Keccak512::hash_to_u16(bool_value); + let c: u16 = Keccak512::hash_to_u16(field_value); + let d: u16 = Keccak512::hash_to_u16(group_value); + let e: u16 = Keccak512::hash_to_u16(i8_value); + let f: u16 = Keccak512::hash_to_u16(i16_value); + let g: u16 = Keccak512::hash_to_u16(i32_value); + let h: u16 = Keccak512::hash_to_u16(i64_value); + let i: u16 = Keccak512::hash_to_u16(i128_value); + let j: u16 = Keccak512::hash_to_u16(u8_value); + let k: u16 = Keccak512::hash_to_u16(u16_value); + let l: u16 = Keccak512::hash_to_u16(u32_value); + let m: u16 = Keccak512::hash_to_u16(u64_value); + let n: u16 = Keccak512::hash_to_u16(u128_value); + let o: u16 = Keccak512::hash_to_u16(scalar_value); + // let p: u16 = Keccak512::hash_to_u16(string_value); + let q: u16 = Keccak512::hash_to_u16(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u32.leo b/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u32.leo new file mode 100644 index 0000000000..bd82ce5adf --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u32.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> u32 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak512 hash_to_u32 tests + let a: u32 = Keccak512::hash_to_u32(addr_value); + let b: u32 = Keccak512::hash_to_u32(bool_value); + let c: u32 = Keccak512::hash_to_u32(field_value); + let d: u32 = Keccak512::hash_to_u32(group_value); + let e: u32 = Keccak512::hash_to_u32(i8_value); + let f: u32 = Keccak512::hash_to_u32(i16_value); + let g: u32 = Keccak512::hash_to_u32(i32_value); + let h: u32 = Keccak512::hash_to_u32(i64_value); + let i: u32 = Keccak512::hash_to_u32(i128_value); + let j: u32 = Keccak512::hash_to_u32(u8_value); + let k: u32 = Keccak512::hash_to_u32(u16_value); + let l: u32 = Keccak512::hash_to_u32(u32_value); + let m: u32 = Keccak512::hash_to_u32(u64_value); + let n: u32 = Keccak512::hash_to_u32(u128_value); + let o: u32 = Keccak512::hash_to_u32(scalar_value); + // let p: u32 = Keccak512::hash_to_u32(string_value); + let q: u32 = Keccak512::hash_to_u32(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u64.leo b/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u64.leo new file mode 100644 index 0000000000..e5674d859d --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u64.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> u64 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak512 hash_to_u64 tests + let a: u64 = Keccak512::hash_to_u64(addr_value); + let b: u64 = Keccak512::hash_to_u64(bool_value); + let c: u64 = Keccak512::hash_to_u64(field_value); + let d: u64 = Keccak512::hash_to_u64(group_value); + let e: u64 = Keccak512::hash_to_u64(i8_value); + let f: u64 = Keccak512::hash_to_u64(i16_value); + let g: u64 = Keccak512::hash_to_u64(i32_value); + let h: u64 = Keccak512::hash_to_u64(i64_value); + let i: u64 = Keccak512::hash_to_u64(i128_value); + let j: u64 = Keccak512::hash_to_u64(u8_value); + let k: u64 = Keccak512::hash_to_u64(u16_value); + let l: u64 = Keccak512::hash_to_u64(u32_value); + let m: u64 = Keccak512::hash_to_u64(u64_value); + let n: u64 = Keccak512::hash_to_u64(u128_value); + let o: u64 = Keccak512::hash_to_u64(scalar_value); + // let p: u64 = Keccak512::hash_to_u64(string_value); + let q: u64 = Keccak512::hash_to_u64(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u8.leo b/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u8.leo new file mode 100644 index 0000000000..6c6d5a67e8 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u8.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> u8 { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak512 hash_to_u8 tests + let a: u8 = Keccak512::hash_to_u8(addr_value); + let b: u8 = Keccak512::hash_to_u8(bool_value); + let c: u8 = Keccak512::hash_to_u8(field_value); + let d: u8 = Keccak512::hash_to_u8(group_value); + let e: u8 = Keccak512::hash_to_u8(i8_value); + let f: u8 = Keccak512::hash_to_u8(i16_value); + let g: u8 = Keccak512::hash_to_u8(i32_value); + let h: u8 = Keccak512::hash_to_u8(i64_value); + let i: u8 = Keccak512::hash_to_u8(i128_value); + let j: u8 = Keccak512::hash_to_u8(u8_value); + let k: u8 = Keccak512::hash_to_u8(u16_value); + let l: u8 = Keccak512::hash_to_u8(u32_value); + let m: u8 = Keccak512::hash_to_u8(u64_value); + let n: u8 = Keccak512::hash_to_u8(u128_value); + let o: u8 = Keccak512::hash_to_u8(scalar_value); + // let p: u8 = Keccak512::hash_to_u8(string_value); + let q: u8 = Keccak512::hash_to_u8(Foo { a: 1u128, b: 1u128 }); + + return a; + } +} diff --git a/tests/tests/compiler/core/algorithms/keccak256_hash_to_address.leo b/tests/tests/compiler/core/algorithms/keccak256_hash_to_address.leo new file mode 100644 index 0000000000..b22301c568 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/keccak256_hash_to_address.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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 = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak256 hash_to_address tests + let a: address = Keccak256::hash_to_address(addr_value); + let b: address = Keccak256::hash_to_address(bool_value); + let c: address = Keccak256::hash_to_address(field_value); + let d: address = Keccak256::hash_to_address(group_value); + let e: address = Keccak256::hash_to_address(i8_value); + let f: address = Keccak256::hash_to_address(i16_value); + let g: address = Keccak256::hash_to_address(i32_value); + let h: address = Keccak256::hash_to_address(i64_value); + let i: address = Keccak256::hash_to_address(i128_value); + let j: address = Keccak256::hash_to_address(u8_value); + let k: address = Keccak256::hash_to_address(u16_value); + let l: address = Keccak256::hash_to_address(u32_value); + let m: address = Keccak256::hash_to_address(u64_value); + let n: address = Keccak256::hash_to_address(u128_value); + let o: address = Keccak256::hash_to_address(scalar_value); + // let p: address = Keccak256::hash_to_address(string_value); + let q: address = Keccak256::hash_to_address(Foo { a: 1u128, b: 1u128 }); + + return field_value; + } +} diff --git a/tests/tests/compiler/core/algorithms/keccak256_hash_to_field.leo b/tests/tests/compiler/core/algorithms/keccak256_hash_to_field.leo new file mode 100644 index 0000000000..9c65823c3c --- /dev/null +++ b/tests/tests/compiler/core/algorithms/keccak256_hash_to_field.leo @@ -0,0 +1,51 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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 = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak256 hash_to_field tests + let a: field = Keccak256::hash_to_field(addr_value); + let b: field = Keccak256::hash_to_field(bool_value); + let c: field = Keccak256::hash_to_field(field_value); + let d: field = Keccak256::hash_to_field(group_value); + let e: field = Keccak256::hash_to_field(i8_value); + let f: field = Keccak256::hash_to_field(i16_value); + let g: field = Keccak256::hash_to_field(i32_value); + let h: field = Keccak256::hash_to_field(i64_value); + let i: field = Keccak256::hash_to_field(i128_value); + let j: field = Keccak256::hash_to_field(u8_value); + let k: field = Keccak256::hash_to_field(u16_value); + let l: field = Keccak256::hash_to_field(u32_value); + let m: field = Keccak256::hash_to_field(u64_value); + let n: field = Keccak256::hash_to_field(u128_value); + let o: field = Keccak256::hash_to_field(scalar_value); + // let p: field = Keccak256::hash_to_field(string_value); + let q: field = Keccak256::hash_to_field(Foo { a: 1u128, b: 1u128 }); + + return a + o; + }} diff --git a/tests/tests/compiler/core/algorithms/keccak256_hash_to_group.leo b/tests/tests/compiler/core/algorithms/keccak256_hash_to_group.leo new file mode 100644 index 0000000000..870fff846d --- /dev/null +++ b/tests/tests/compiler/core/algorithms/keccak256_hash_to_group.leo @@ -0,0 +1,51 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> group { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak256 hash_to_group tests + let a: group = Keccak256::hash_to_group(addr_value); + let b: group = Keccak256::hash_to_group(bool_value); + let c: group = Keccak256::hash_to_group(field_value); + let d: group = Keccak256::hash_to_group(group_value); + let e: group = Keccak256::hash_to_group(i8_value); + let f: group = Keccak256::hash_to_group(i16_value); + let g: group = Keccak256::hash_to_group(i32_value); + let h: group = Keccak256::hash_to_group(i64_value); + let i: group = Keccak256::hash_to_group(i128_value); + let j: group = Keccak256::hash_to_group(u8_value); + let k: group = Keccak256::hash_to_group(u16_value); + let l: group = Keccak256::hash_to_group(u32_value); + let m: group = Keccak256::hash_to_group(u64_value); + let n: group = Keccak256::hash_to_group(u128_value); + let o: group = Keccak256::hash_to_group(scalar_value); + // let p: group = Keccak256::hash_to_group(string_value); + let q: group = Keccak256::hash_to_group(Foo { a: 1u128, b: 1u128 }); + + return a + o; + }} diff --git a/tests/tests/compiler/core/algorithms/keccak256_hash_to_scalar.leo b/tests/tests/compiler/core/algorithms/keccak256_hash_to_scalar.leo new file mode 100644 index 0000000000..e2cd515362 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/keccak256_hash_to_scalar.leo @@ -0,0 +1,51 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> scalar { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak256 hash_to_scalar tests + let a: scalar = Keccak256::hash_to_scalar(addr_value); + let b: scalar = Keccak256::hash_to_scalar(bool_value); + let c: scalar = Keccak256::hash_to_scalar(field_value); + let d: scalar = Keccak256::hash_to_scalar(group_value); + let e: scalar = Keccak256::hash_to_scalar(i8_value); + let f: scalar = Keccak256::hash_to_scalar(i16_value); + let g: scalar = Keccak256::hash_to_scalar(i32_value); + let h: scalar = Keccak256::hash_to_scalar(i64_value); + let i: scalar = Keccak256::hash_to_scalar(i128_value); + let j: scalar = Keccak256::hash_to_scalar(u8_value); + let k: scalar = Keccak256::hash_to_scalar(u16_value); + let l: scalar = Keccak256::hash_to_scalar(u32_value); + let m: scalar = Keccak256::hash_to_scalar(u64_value); + let n: scalar = Keccak256::hash_to_scalar(u128_value); + let o: scalar = Keccak256::hash_to_scalar(scalar_value); + // let p: scalar = Keccak256::hash_to_scalar(string_value); + let q: scalar = Keccak256::hash_to_scalar(Foo { a: 1u128, b: 1u128 }); + + return a + o; + }} diff --git a/tests/tests/compiler/core/algorithms/keccak384_hash_to_address.leo b/tests/tests/compiler/core/algorithms/keccak384_hash_to_address.leo new file mode 100644 index 0000000000..0edcadb9d4 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/keccak384_hash_to_address.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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 = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak384 hash_to_address tests + let a: address = Keccak384::hash_to_address(addr_value); + let b: address = Keccak384::hash_to_address(bool_value); + let c: address = Keccak384::hash_to_address(field_value); + let d: address = Keccak384::hash_to_address(group_value); + let e: address = Keccak384::hash_to_address(i8_value); + let f: address = Keccak384::hash_to_address(i16_value); + let g: address = Keccak384::hash_to_address(i32_value); + let h: address = Keccak384::hash_to_address(i64_value); + let i: address = Keccak384::hash_to_address(i128_value); + let j: address = Keccak384::hash_to_address(u8_value); + let k: address = Keccak384::hash_to_address(u16_value); + let l: address = Keccak384::hash_to_address(u32_value); + let m: address = Keccak384::hash_to_address(u64_value); + let n: address = Keccak384::hash_to_address(u128_value); + let o: address = Keccak384::hash_to_address(scalar_value); + // let p: address = Keccak384::hash_to_address(string_value); + let q: address = Keccak384::hash_to_address(Foo { a: 1u128, b: 1u128 }); + + return field_value; + } +} diff --git a/tests/tests/compiler/core/algorithms/keccak384_hash_to_field.leo b/tests/tests/compiler/core/algorithms/keccak384_hash_to_field.leo new file mode 100644 index 0000000000..d4825e23f4 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/keccak384_hash_to_field.leo @@ -0,0 +1,51 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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 = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak384 hash_to_field tests + let a: field = Keccak384::hash_to_field(addr_value); + let b: field = Keccak384::hash_to_field(bool_value); + let c: field = Keccak384::hash_to_field(field_value); + let d: field = Keccak384::hash_to_field(group_value); + let e: field = Keccak384::hash_to_field(i8_value); + let f: field = Keccak384::hash_to_field(i16_value); + let g: field = Keccak384::hash_to_field(i32_value); + let h: field = Keccak384::hash_to_field(i64_value); + let i: field = Keccak384::hash_to_field(i128_value); + let j: field = Keccak384::hash_to_field(u8_value); + let k: field = Keccak384::hash_to_field(u16_value); + let l: field = Keccak384::hash_to_field(u32_value); + let m: field = Keccak384::hash_to_field(u64_value); + let n: field = Keccak384::hash_to_field(u128_value); + let o: field = Keccak384::hash_to_field(scalar_value); + // let p: field = Keccak384::hash_to_field(string_value); + let q: field = Keccak384::hash_to_field(Foo { a: 1u128, b: 1u128 }); + + return a + o; + }} diff --git a/tests/tests/compiler/core/algorithms/keccak384_hash_to_group.leo b/tests/tests/compiler/core/algorithms/keccak384_hash_to_group.leo new file mode 100644 index 0000000000..8890a28252 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/keccak384_hash_to_group.leo @@ -0,0 +1,51 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> group { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak384 hash_to_group tests + let a: group = Keccak384::hash_to_group(addr_value); + let b: group = Keccak384::hash_to_group(bool_value); + let c: group = Keccak384::hash_to_group(field_value); + let d: group = Keccak384::hash_to_group(group_value); + let e: group = Keccak384::hash_to_group(i8_value); + let f: group = Keccak384::hash_to_group(i16_value); + let g: group = Keccak384::hash_to_group(i32_value); + let h: group = Keccak384::hash_to_group(i64_value); + let i: group = Keccak384::hash_to_group(i128_value); + let j: group = Keccak384::hash_to_group(u8_value); + let k: group = Keccak384::hash_to_group(u16_value); + let l: group = Keccak384::hash_to_group(u32_value); + let m: group = Keccak384::hash_to_group(u64_value); + let n: group = Keccak384::hash_to_group(u128_value); + let o: group = Keccak384::hash_to_group(scalar_value); + // let p: group = Keccak384::hash_to_group(string_value); + let q: group = Keccak384::hash_to_group(Foo { a: 1u128, b: 1u128 }); + + return a + o; + }} diff --git a/tests/tests/compiler/core/algorithms/keccak384_hash_to_scalar.leo b/tests/tests/compiler/core/algorithms/keccak384_hash_to_scalar.leo new file mode 100644 index 0000000000..2b487962c6 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/keccak384_hash_to_scalar.leo @@ -0,0 +1,51 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> scalar { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak384 hash_to_scalar tests + let a: scalar = Keccak384::hash_to_scalar(addr_value); + let b: scalar = Keccak384::hash_to_scalar(bool_value); + let c: scalar = Keccak384::hash_to_scalar(field_value); + let d: scalar = Keccak384::hash_to_scalar(group_value); + let e: scalar = Keccak384::hash_to_scalar(i8_value); + let f: scalar = Keccak384::hash_to_scalar(i16_value); + let g: scalar = Keccak384::hash_to_scalar(i32_value); + let h: scalar = Keccak384::hash_to_scalar(i64_value); + let i: scalar = Keccak384::hash_to_scalar(i128_value); + let j: scalar = Keccak384::hash_to_scalar(u8_value); + let k: scalar = Keccak384::hash_to_scalar(u16_value); + let l: scalar = Keccak384::hash_to_scalar(u32_value); + let m: scalar = Keccak384::hash_to_scalar(u64_value); + let n: scalar = Keccak384::hash_to_scalar(u128_value); + let o: scalar = Keccak384::hash_to_scalar(scalar_value); + // let p: scalar = Keccak384::hash_to_scalar(string_value); + let q: scalar = Keccak384::hash_to_scalar(Foo { a: 1u128, b: 1u128 }); + + return a + o; + }} diff --git a/tests/tests/compiler/core/algorithms/keccak512_hash_to_address.leo b/tests/tests/compiler/core/algorithms/keccak512_hash_to_address.leo new file mode 100644 index 0000000000..919c690d04 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/keccak512_hash_to_address.leo @@ -0,0 +1,52 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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 = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak512 hash_to_address tests + let a: address = Keccak512::hash_to_address(addr_value); + let b: address = Keccak512::hash_to_address(bool_value); + let c: address = Keccak512::hash_to_address(field_value); + let d: address = Keccak512::hash_to_address(group_value); + let e: address = Keccak512::hash_to_address(i8_value); + let f: address = Keccak512::hash_to_address(i16_value); + let g: address = Keccak512::hash_to_address(i32_value); + let h: address = Keccak512::hash_to_address(i64_value); + let i: address = Keccak512::hash_to_address(i128_value); + let j: address = Keccak512::hash_to_address(u8_value); + let k: address = Keccak512::hash_to_address(u16_value); + let l: address = Keccak512::hash_to_address(u32_value); + let m: address = Keccak512::hash_to_address(u64_value); + let n: address = Keccak512::hash_to_address(u128_value); + let o: address = Keccak512::hash_to_address(scalar_value); + // let p: address = Keccak512::hash_to_address(string_value); + let q: address = Keccak512::hash_to_address(Foo { a: 1u128, b: 1u128 }); + + return field_value; + } +} diff --git a/tests/tests/compiler/core/algorithms/keccak512_hash_to_field.leo b/tests/tests/compiler/core/algorithms/keccak512_hash_to_field.leo new file mode 100644 index 0000000000..3fa7c16525 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/keccak512_hash_to_field.leo @@ -0,0 +1,51 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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 = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak512 hash_to_field tests + let a: field = Keccak512::hash_to_field(addr_value); + let b: field = Keccak512::hash_to_field(bool_value); + let c: field = Keccak512::hash_to_field(field_value); + let d: field = Keccak512::hash_to_field(group_value); + let e: field = Keccak512::hash_to_field(i8_value); + let f: field = Keccak512::hash_to_field(i16_value); + let g: field = Keccak512::hash_to_field(i32_value); + let h: field = Keccak512::hash_to_field(i64_value); + let i: field = Keccak512::hash_to_field(i128_value); + let j: field = Keccak512::hash_to_field(u8_value); + let k: field = Keccak512::hash_to_field(u16_value); + let l: field = Keccak512::hash_to_field(u32_value); + let m: field = Keccak512::hash_to_field(u64_value); + let n: field = Keccak512::hash_to_field(u128_value); + let o: field = Keccak512::hash_to_field(scalar_value); + // let p: field = Keccak512::hash_to_field(string_value); + let q: field = Keccak512::hash_to_field(Foo { a: 1u128, b: 1u128 }); + + return a + o; + }} diff --git a/tests/tests/compiler/core/algorithms/keccak512_hash_to_group.leo b/tests/tests/compiler/core/algorithms/keccak512_hash_to_group.leo new file mode 100644 index 0000000000..7ed8ff5585 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/keccak512_hash_to_group.leo @@ -0,0 +1,51 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> group { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak512 hash_to_group tests + let a: group = Keccak512::hash_to_group(addr_value); + let b: group = Keccak512::hash_to_group(bool_value); + let c: group = Keccak512::hash_to_group(field_value); + let d: group = Keccak512::hash_to_group(group_value); + let e: group = Keccak512::hash_to_group(i8_value); + let f: group = Keccak512::hash_to_group(i16_value); + let g: group = Keccak512::hash_to_group(i32_value); + let h: group = Keccak512::hash_to_group(i64_value); + let i: group = Keccak512::hash_to_group(i128_value); + let j: group = Keccak512::hash_to_group(u8_value); + let k: group = Keccak512::hash_to_group(u16_value); + let l: group = Keccak512::hash_to_group(u32_value); + let m: group = Keccak512::hash_to_group(u64_value); + let n: group = Keccak512::hash_to_group(u128_value); + let o: group = Keccak512::hash_to_group(scalar_value); + // let p: group = Keccak512::hash_to_group(string_value); + let q: group = Keccak512::hash_to_group(Foo { a: 1u128, b: 1u128 }); + + return a + o; + }} diff --git a/tests/tests/compiler/core/algorithms/keccak512_hash_to_scalar.leo b/tests/tests/compiler/core/algorithms/keccak512_hash_to_scalar.leo new file mode 100644 index 0000000000..4523f822e1 --- /dev/null +++ b/tests/tests/compiler/core/algorithms/keccak512_hash_to_scalar.leo @@ -0,0 +1,51 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Foo { + a: u128, + b: u128, + } + + transition 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, + ) -> scalar { + let addr_value: address = aleo10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta; + let bool_value: bool = true; + let field_value: field = 1field; + let group_value: group = group::GEN; + let i128_value: i128 = 1i128; + let u128_value: u128 = 1u128; + let scalar_value: scalar = 1scalar; + // let string_value: string = "helloworld"; + + // Keccak512 hash_to_scalar tests + let a: scalar = Keccak512::hash_to_scalar(addr_value); + let b: scalar = Keccak512::hash_to_scalar(bool_value); + let c: scalar = Keccak512::hash_to_scalar(field_value); + let d: scalar = Keccak512::hash_to_scalar(group_value); + let e: scalar = Keccak512::hash_to_scalar(i8_value); + let f: scalar = Keccak512::hash_to_scalar(i16_value); + let g: scalar = Keccak512::hash_to_scalar(i32_value); + let h: scalar = Keccak512::hash_to_scalar(i64_value); + let i: scalar = Keccak512::hash_to_scalar(i128_value); + let j: scalar = Keccak512::hash_to_scalar(u8_value); + let k: scalar = Keccak512::hash_to_scalar(u16_value); + let l: scalar = Keccak512::hash_to_scalar(u32_value); + let m: scalar = Keccak512::hash_to_scalar(u64_value); + let n: scalar = Keccak512::hash_to_scalar(u128_value); + let o: scalar = Keccak512::hash_to_scalar(scalar_value); + // let p: scalar = Keccak512::hash_to_scalar(string_value); + let q: scalar = Keccak512::hash_to_scalar(Foo { a: 1u128, b: 1u128 }); + + return a + o; + }}