From 6383a09ce5d9ab581af5d458bdcb65f92d9011fb Mon Sep 17 00:00:00 2001 From: ludamad Date: Thu, 25 Apr 2024 17:54:17 -0500 Subject: [PATCH] fix: revert "feat: Sync from noir" (#6034) Reverts AztecProtocol/aztec-packages#6023 @TomAFrench this was failing, not sure how it got merged? --- .noir-sync-commit | 2 +- avm-transpiler/Cargo.lock | 10 +- noir/noir-repo/Cargo.lock | 10 +- noir/noir-repo/Cargo.toml | 14 +- noir/noir-repo/acvm-repo/acvm_js/build.sh | 2 +- .../compiler/noirc_evaluator/src/ssa.rs | 9 +- .../ssa/acir_gen/acir_ir/generated_acir.rs | 49 ++++ .../noirc_evaluator/src/ssa/acir_gen/mod.rs | 19 +- .../src/ssa/ssa_gen/context.rs | 67 ++++++ .../compiler/noirc_frontend/Cargo.toml | 2 +- .../noirc_frontend/src/hir/comptime/errors.rs | 226 +----------------- .../src/hir/comptime/interpreter.rs | 9 +- .../noirc_frontend/src/hir/comptime/mod.rs | 1 - .../src/hir/def_collector/dc_crate.rs | 14 +- .../noirc_frontend/src/hir/def_map/mod.rs | 2 +- .../noirc_frontend/src/hir/type_check/mod.rs | 4 +- .../noirc_frontend/src/node_interner.rs | 2 +- .../noirc_frontend/src/resolve_locations.rs | 2 +- .../compiler/noirc_frontend/src/tests.rs | 2 +- .../{noirc_arena => utils/arena}/Cargo.toml | 2 +- .../{noirc_arena => utils/arena}/src/lib.rs | 0 .../utils/iter-extended/Cargo.toml | 0 .../utils/iter-extended/src/lib.rs | 0 .../cryptographic_primitives/hashes.mdx | 5 +- noir/noir-repo/flake.lock | 170 +++++++++++++ noir/noir-repo/noir_stdlib/src/hash.nr | 1 - noir/noir-repo/noir_stdlib/src/sha256.nr | 54 ++--- .../execution_success/sha256/src/main.nr | 4 +- .../noir_js_backend_barretenberg/package.json | 2 +- .../noir-repo/tooling/noirc_abi_wasm/build.sh | 2 +- 30 files changed, 371 insertions(+), 315 deletions(-) rename noir/noir-repo/compiler/{noirc_arena => utils/arena}/Cargo.toml (86%) rename noir/noir-repo/compiler/{noirc_arena => utils/arena}/src/lib.rs (100%) rename noir/noir-repo/{ => compiler}/utils/iter-extended/Cargo.toml (100%) rename noir/noir-repo/{ => compiler}/utils/iter-extended/src/lib.rs (100%) create mode 100644 noir/noir-repo/flake.lock diff --git a/.noir-sync-commit b/.noir-sync-commit index bf36994bc1b..19e9a0d3012 100644 --- a/.noir-sync-commit +++ b/.noir-sync-commit @@ -1 +1 @@ -7ea0e914625789e65b0d5908f7f0b76a9fd32652 +0cf2e2a1b8d247bed03ba5b7b1be5cd30f0d51b2 diff --git a/avm-transpiler/Cargo.lock b/avm-transpiler/Cargo.lock index 6959e781579..e145398e26e 100644 --- a/avm-transpiler/Cargo.lock +++ b/avm-transpiler/Cargo.lock @@ -159,6 +159,10 @@ dependencies = [ "windows-sys", ] +[[package]] +name = "arena" +version = "0.28.0" + [[package]] name = "ark-bn254" version = "0.4.0" @@ -1206,10 +1210,6 @@ dependencies = [ "toml", ] -[[package]] -name = "noirc_arena" -version = "0.28.0" - [[package]] name = "noirc_driver" version = "0.28.0" @@ -1271,13 +1271,13 @@ name = "noirc_frontend" version = "0.28.0" dependencies = [ "acvm", + "arena", "chumsky", "fm", "im", "iter-extended", "lalrpop", "lalrpop-util", - "noirc_arena", "noirc_errors", "noirc_printable_type", "petgraph", diff --git a/noir/noir-repo/Cargo.lock b/noir/noir-repo/Cargo.lock index eaed1c08bec..8a8ccfdbf8a 100644 --- a/noir/noir-repo/Cargo.lock +++ b/noir/noir-repo/Cargo.lock @@ -233,6 +233,10 @@ version = "1.0.75" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6" +[[package]] +name = "arena" +version = "0.28.0" + [[package]] name = "ark-bls12-381" version = "0.4.0" @@ -3095,10 +3099,6 @@ dependencies = [ "wasm-bindgen-test", ] -[[package]] -name = "noirc_arena" -version = "0.28.0" - [[package]] name = "noirc_driver" version = "0.28.0" @@ -3160,6 +3160,7 @@ name = "noirc_frontend" version = "0.28.0" dependencies = [ "acvm", + "arena", "base64 0.21.2", "chumsky", "fm", @@ -3167,7 +3168,6 @@ dependencies = [ "iter-extended", "lalrpop", "lalrpop-util", - "noirc_arena", "noirc_errors", "noirc_printable_type", "petgraph", diff --git a/noir/noir-repo/Cargo.toml b/noir/noir-repo/Cargo.toml index ed0aef0d35b..108d179b9ca 100644 --- a/noir/noir-repo/Cargo.toml +++ b/noir/noir-repo/Cargo.toml @@ -4,7 +4,6 @@ members = [ # Aztec Macro crate for metaprogramming "aztec_macros", # Compiler crates - "compiler/noirc_arena", "compiler/noirc_evaluator", "compiler/noirc_frontend", "compiler/noirc_errors", @@ -12,7 +11,10 @@ members = [ "compiler/noirc_printable_type", "compiler/fm", "compiler/wasm", - # Crates related to tooling built on top of the Noir compiler + # Utility crates used by the Noir compiler + "compiler/utils/arena", + "compiler/utils/iter-extended", + # Crates related to tooling built ontop of the Noir compiler "tooling/backend_interface", "tooling/bb_abstraction_leaks", "tooling/lsp", @@ -33,8 +35,6 @@ members = [ "acvm-repo/brillig_vm", "acvm-repo/blackbox_solver", "acvm-repo/bn254_blackbox_solver", - # Utility crates - "utils/iter-extended", ] default-members = ["tooling/nargo_cli", "tooling/acvm_cli"] resolver = "2" @@ -61,8 +61,9 @@ acvm_blackbox_solver = { version = "0.44.0", path = "acvm-repo/blackbox_solver", bn254_blackbox_solver = { version = "0.44.0", path = "acvm-repo/bn254_blackbox_solver", default-features = false } # Noir compiler workspace dependencies +arena = { path = "compiler/utils/arena" } fm = { path = "compiler/fm" } -noirc_arena = { path = "compiler/noirc_arena" } +iter-extended = { path = "compiler/utils/iter-extended" } noirc_driver = { path = "compiler/noirc_driver" } noirc_errors = { path = "compiler/noirc_errors" } noirc_evaluator = { path = "compiler/noirc_evaluator" } @@ -79,9 +80,6 @@ noirc_abi = { path = "tooling/noirc_abi" } bb_abstraction_leaks = { path = "tooling/bb_abstraction_leaks" } acvm_cli = { path = "tooling/acvm_cli" } -# Misc utils crates -iter-extended = { path = "utils/iter-extended" } - # LSP async-lsp = { version = "0.1.0", default-features = false } lsp-types = "0.94.1" diff --git a/noir/noir-repo/acvm-repo/acvm_js/build.sh b/noir/noir-repo/acvm-repo/acvm_js/build.sh index c07d2d8a4c1..ee93413ab85 100755 --- a/noir/noir-repo/acvm-repo/acvm_js/build.sh +++ b/noir/noir-repo/acvm-repo/acvm_js/build.sh @@ -25,7 +25,7 @@ function run_if_available { require_command jq require_command cargo require_command wasm-bindgen -#require_command wasm-opt +# require_command wasm-opt self_path=$(dirname "$(readlink -f "$0")") pname=$(cargo read-manifest | jq -r '.name') diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa.rs index f9fd5f41f77..3482a8c25c7 100644 --- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa.rs +++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa.rs @@ -9,7 +9,10 @@ use std::collections::BTreeSet; -use crate::errors::{RuntimeError, SsaReport}; +use crate::{ + brillig::Brillig, + errors::{RuntimeError, SsaReport}, +}; use acvm::acir::{ circuit::{ brillig::BrilligBytecode, Circuit, ExpressionWidth, Program as AcirProgram, PublicInputs, @@ -315,6 +318,10 @@ impl SsaBuilder { Ok(self.print(msg)) } + fn to_brillig(&self, print_brillig_trace: bool) -> Brillig { + self.ssa.to_brillig(print_brillig_trace) + } + fn print(self, msg: &str) -> Self { if self.print_ssa_passes { println!("{msg}\n{}", self.ssa); diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs index 9f305a28c25..0b04d1b63ab 100644 --- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs +++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs @@ -420,6 +420,55 @@ impl GeneratedAcir { Ok(limb_witnesses) } + /// Returns an expression which represents `lhs * rhs` + /// + /// If one has multiplicative term and the other is of degree one or more, + /// the function creates [intermediate variables][`Witness`] accordingly. + /// There are two cases where we can optimize the multiplication between two expressions: + /// 1. If the sum of the degrees of both expressions is at most 2, then we can just multiply them + /// as each term in the result will be degree-2. + /// 2. If one expression is a constant, then we can just multiply the constant with the other expression + /// + /// (1) is because an [`Expression`] can hold at most a degree-2 univariate polynomial + /// which is what you get when you multiply two degree-1 univariate polynomials. + pub(crate) fn mul_with_witness(&mut self, lhs: &Expression, rhs: &Expression) -> Expression { + use std::borrow::Cow; + let lhs_is_linear = lhs.is_linear(); + let rhs_is_linear = rhs.is_linear(); + + // Case 1: The sum of the degrees of both expressions is at most 2. + // + // If one of the expressions is constant then it does not increase the degree when multiplying by another expression. + // If both of the expressions are linear (degree <=1) then the product will be at most degree 2. + let both_are_linear = lhs_is_linear && rhs_is_linear; + let either_is_const = lhs.is_const() || rhs.is_const(); + if both_are_linear || either_is_const { + return (lhs * rhs).expect("Both expressions are degree <= 1"); + } + + // Case 2: One or both of the sides needs to be reduced to a degree-1 univariate polynomial + let lhs_reduced = if lhs_is_linear { + Cow::Borrowed(lhs) + } else { + Cow::Owned(self.get_or_create_witness(lhs).into()) + }; + + // If the lhs and rhs are the same, then we do not need to reduce + // rhs, we only need to square the lhs. + if lhs == rhs { + return (&*lhs_reduced * &*lhs_reduced) + .expect("Both expressions are reduced to be degree <= 1"); + }; + + let rhs_reduced = if rhs_is_linear { + Cow::Borrowed(rhs) + } else { + Cow::Owned(self.get_or_create_witness(rhs).into()) + }; + + (&*lhs_reduced * &*rhs_reduced).expect("Both expressions are reduced to be degree <= 1") + } + /// Adds an inversion brillig opcode. /// /// This code will invert `expr` without applying constraints diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs index 6c7d78acdea..ee236df8eac 100644 --- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs +++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs @@ -3277,15 +3277,18 @@ mod test { // This check right now expects to only call one Brillig function. let mut num_normal_brillig_calls = 0; for (i, opcode) in opcodes.iter().enumerate() { - if let Opcode::BrilligCall { id, .. } = opcode { - if brillig_stdlib_function_locations.get(&OpcodeLocation::Acir(i)).is_some() { - // We should have already checked Brillig stdlib functions and only want to check normal Brillig calls here - continue; + match opcode { + Opcode::BrilligCall { id, .. } => { + if brillig_stdlib_function_locations.get(&OpcodeLocation::Acir(i)).is_some() { + // We should have already checked Brillig stdlib functions and only want to check normal Brillig calls here + continue; + } + // We only generate one normal Brillig call so we should expect a function ID of `0` + let expected_id = 0u32; + assert_eq!(*id, expected_id, "Expected an id of {expected_id} but got {id}"); + num_normal_brillig_calls += 1; } - // We only generate one normal Brillig call so we should expect a function ID of `0` - let expected_id = 0u32; - assert_eq!(*id, expected_id, "Expected an id of {expected_id} but got {id}"); - num_normal_brillig_calls += 1; + _ => {} } } diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs index fdd17097d19..276a8247cea 100644 --- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs +++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs @@ -11,6 +11,7 @@ use noirc_frontend::monomorphization::ast::{FuncId, Program}; use crate::errors::RuntimeError; use crate::ssa::function_builder::FunctionBuilder; use crate::ssa::ir::basic_block::BasicBlockId; +use crate::ssa::ir::dfg::DataFlowGraph; use crate::ssa::ir::function::{Function, RuntimeType}; use crate::ssa::ir::function::{FunctionId as IrFunctionId, InlineType}; use crate::ssa::ir::instruction::BinaryOp; @@ -1004,6 +1005,72 @@ fn operator_requires_swapped_operands(op: BinaryOpKind) -> bool { matches!(op, Greater | LessEqual) } +/// If the operation requires its result to be truncated because it is an integer, the maximum +/// number of bits that result may occupy is returned. +fn operator_result_max_bit_size_to_truncate( + op: BinaryOpKind, + lhs: ValueId, + rhs: ValueId, + dfg: &DataFlowGraph, +) -> Option { + let lhs_type = dfg.type_of_value(lhs); + let rhs_type = dfg.type_of_value(rhs); + + let get_bit_size = |typ| match typ { + Type::Numeric(NumericType::Signed { bit_size } | NumericType::Unsigned { bit_size }) => { + Some(bit_size) + } + _ => None, + }; + + let lhs_bit_size = get_bit_size(lhs_type)?; + let rhs_bit_size = get_bit_size(rhs_type)?; + use BinaryOpKind::*; + match op { + Add => Some(std::cmp::max(lhs_bit_size, rhs_bit_size) + 1), + Subtract => Some(std::cmp::max(lhs_bit_size, rhs_bit_size) + 1), + Multiply => { + if lhs_bit_size == 1 || rhs_bit_size == 1 { + // Truncation is unnecessary as multiplication by a boolean value cannot cause an overflow. + None + } else { + Some(lhs_bit_size + rhs_bit_size) + } + } + + ShiftLeft => { + if let Some(rhs_constant) = dfg.get_numeric_constant(rhs) { + // Happy case is that we know precisely by how many bits the the integer will + // increase: lhs_bit_size + rhs + return Some(lhs_bit_size + (rhs_constant.to_u128() as u32)); + } + // Unhappy case is that we don't yet know the rhs value, (even though it will + // eventually have to resolve to a constant). The best we can is assume the value of + // rhs to be the maximum value of it's numeric type. If that turns out to be larger + // than the native field's bit size, we full back to using that. + + // The formula for calculating the max bit size of a left shift is: + // lhs_bit_size + 2^{rhs_bit_size} - 1 + // Inferring the max bit size of left shift from its operands can result in huge + // number, that might not only be larger than the native field's max bit size, but + // furthermore might not be representable as a u32. Hence we use overflow checks and + // fallback to the native field's max bits. + let field_max_bits = FieldElement::max_num_bits(); + let (rhs_bit_size_pow_2, overflows) = 2_u32.overflowing_pow(rhs_bit_size); + if overflows { + return Some(field_max_bits); + } + let (max_bits_plus_1, overflows) = rhs_bit_size_pow_2.overflowing_add(lhs_bit_size); + if overflows { + return Some(field_max_bits); + } + let max_bit_size = std::cmp::min(max_bits_plus_1 - 1, field_max_bits); + Some(max_bit_size) + } + _ => None, + } +} + /// Converts the given operator to the appropriate BinaryOp. /// Take care when using this to insert a binary instruction: this requires /// checking operator_requires_not and operator_requires_swapped_operands diff --git a/noir/noir-repo/compiler/noirc_frontend/Cargo.toml b/noir/noir-repo/compiler/noirc_frontend/Cargo.toml index 0430d214d53..84c9393fa37 100644 --- a/noir/noir-repo/compiler/noirc_frontend/Cargo.toml +++ b/noir/noir-repo/compiler/noirc_frontend/Cargo.toml @@ -10,10 +10,10 @@ license.workspace = true [dependencies] acvm.workspace = true -noirc_arena.workspace = true noirc_errors.workspace = true noirc_printable_type.workspace = true fm.workspace = true +arena.workspace = true iter-extended.workspace = true chumsky.workspace = true thiserror.workspace = true diff --git a/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/errors.rs b/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/errors.rs index 8de444252ab..67d9a006b22 100644 --- a/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/errors.rs +++ b/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/errors.rs @@ -1,11 +1,11 @@ -use crate::{hir::def_collector::dc_crate::CompilationError, Type}; +use crate::Type; use acvm::FieldElement; -use noirc_errors::{CustomDiagnostic, Location}; +use noirc_errors::Location; use super::value::Value; /// The possible errors that can halt the interpreter. -#[derive(Debug, Clone)] +#[derive(Debug)] pub enum InterpreterError { ArgumentCountMismatch { expected: usize, actual: usize, call_location: Location }, TypeMismatch { expected: Type, value: Value, location: Location }, @@ -16,7 +16,7 @@ pub enum InterpreterError { NonBoolUsedInIf { value: Value, location: Location }, NonBoolUsedInConstrain { value: Value, location: Location }, FailingConstraint { message: Option, location: Location }, - NoMethodFound { name: String, typ: Type, location: Location }, + NoMethodFound { object: Value, typ: Type, location: Location }, NonIntegerUsedInLoop { value: Value, location: Location }, NonPointerDereferenced { value: Value, location: Location }, NonTupleOrStructInMemberAccess { value: Value, location: Location }, @@ -51,221 +51,3 @@ pub enum InterpreterError { #[allow(unused)] pub(super) type IResult = std::result::Result; - -impl InterpreterError { - pub fn into_compilation_error_pair(self) -> (CompilationError, fm::FileId) { - let location = self.get_location(); - (CompilationError::InterpreterError(self), location.file) - } - - pub fn get_location(&self) -> Location { - match self { - InterpreterError::ArgumentCountMismatch { call_location: location, .. } - | InterpreterError::TypeMismatch { location, .. } - | InterpreterError::NonComptimeVarReferenced { location, .. } - | InterpreterError::IntegerOutOfRangeForType { location, .. } - | InterpreterError::ErrorNodeEncountered { location, .. } - | InterpreterError::NonFunctionCalled { location, .. } - | InterpreterError::NonBoolUsedInIf { location, .. } - | InterpreterError::NonBoolUsedInConstrain { location, .. } - | InterpreterError::FailingConstraint { location, .. } - | InterpreterError::NoMethodFound { location, .. } - | InterpreterError::NonIntegerUsedInLoop { location, .. } - | InterpreterError::NonPointerDereferenced { location, .. } - | InterpreterError::NonTupleOrStructInMemberAccess { location, .. } - | InterpreterError::NonArrayIndexed { location, .. } - | InterpreterError::NonIntegerUsedAsIndex { location, .. } - | InterpreterError::NonIntegerIntegerLiteral { location, .. } - | InterpreterError::NonIntegerArrayLength { location, .. } - | InterpreterError::NonNumericCasted { location, .. } - | InterpreterError::IndexOutOfBounds { location, .. } - | InterpreterError::ExpectedStructToHaveField { location, .. } - | InterpreterError::TypeUnsupported { location, .. } - | InterpreterError::InvalidValueForUnary { location, .. } - | InterpreterError::InvalidValuesForBinary { location, .. } - | InterpreterError::CastToNonNumericType { location, .. } - | InterpreterError::QuoteInRuntimeCode { location, .. } - | InterpreterError::NonStructInConstructor { location, .. } - | InterpreterError::CannotInlineMacro { location, .. } - | InterpreterError::UnquoteFoundDuringEvaluation { location, .. } - | InterpreterError::Unimplemented { location, .. } - | InterpreterError::BreakNotInLoop { location, .. } - | InterpreterError::ContinueNotInLoop { location, .. } => *location, - InterpreterError::Break | InterpreterError::Continue => { - panic!("Tried to get the location of Break/Continue error!") - } - } - } -} - -impl From for CustomDiagnostic { - fn from(error: InterpreterError) -> Self { - match error { - InterpreterError::ArgumentCountMismatch { expected, actual, call_location } => { - let only = if expected > actual { "only " } else { "" }; - let plural = if expected == 1 { "" } else { "s" }; - let was_were = if actual == 1 { "was" } else { "were" }; - let msg = format!( - "Expected {expected} argument{plural}, but {only}{actual} {was_were} provided" - ); - - let few_many = if actual < expected { "few" } else { "many" }; - let secondary = format!("Too {few_many} arguments"); - CustomDiagnostic::simple_error(msg, secondary, call_location.span) - } - InterpreterError::TypeMismatch { expected, value, location } => { - let typ = value.get_type(); - let msg = format!("Expected `{expected}` but a value of type `{typ}` was given"); - CustomDiagnostic::simple_error(msg, String::new(), location.span) - } - InterpreterError::NonComptimeVarReferenced { name, location } => { - let msg = format!("Non-comptime variable `{name}` referenced in comptime code"); - let secondary = "Non-comptime variables can't be used in comptime code".to_string(); - CustomDiagnostic::simple_error(msg, secondary, location.span) - } - InterpreterError::IntegerOutOfRangeForType { value, typ, location } => { - let int = match value.try_into_u128() { - Some(int) => int.to_string(), - None => value.to_string(), - }; - let msg = format!("{int} is outside the range of the {typ} type"); - CustomDiagnostic::simple_error(msg, String::new(), location.span) - } - InterpreterError::ErrorNodeEncountered { location } => { - let msg = "Internal Compiler Error: Error node encountered".to_string(); - let secondary = "This is a bug, please report this if found!".to_string(); - CustomDiagnostic::simple_error(msg, secondary, location.span) - } - InterpreterError::NonFunctionCalled { value, location } => { - let msg = "Only functions may be called".to_string(); - let secondary = format!("Expression has type {}", value.get_type()); - CustomDiagnostic::simple_error(msg, secondary, location.span) - } - InterpreterError::NonBoolUsedInIf { value, location } => { - let msg = format!("Expected a `bool` but found `{}`", value.get_type()); - let secondary = "If conditions must be a boolean value".to_string(); - CustomDiagnostic::simple_error(msg, secondary, location.span) - } - InterpreterError::NonBoolUsedInConstrain { value, location } => { - let msg = format!("Expected a `bool` but found `{}`", value.get_type()); - CustomDiagnostic::simple_error(msg, String::new(), location.span) - } - InterpreterError::FailingConstraint { message, location } => { - let (primary, secondary) = match message { - Some(msg) => (format!("{msg:?}"), "Assertion failed".into()), - None => ("Assertion failed".into(), String::new()), - }; - CustomDiagnostic::simple_error(primary, secondary, location.span) - } - InterpreterError::NoMethodFound { name, typ, location } => { - let msg = format!("No method named `{name}` found for type `{typ}`"); - CustomDiagnostic::simple_error(msg, String::new(), location.span) - } - InterpreterError::NonIntegerUsedInLoop { value, location } => { - let typ = value.get_type(); - let msg = format!("Non-integer type `{typ}` used in for loop"); - let secondary = if matches!(typ.as_ref(), &Type::FieldElement) { - "`field` is not an integer type, try `u64` instead".to_string() - } else { - String::new() - }; - CustomDiagnostic::simple_error(msg, secondary, location.span) - } - InterpreterError::NonPointerDereferenced { value, location } => { - let typ = value.get_type(); - let msg = format!("Only references may be dereferenced, but found `{typ}`"); - CustomDiagnostic::simple_error(msg, String::new(), location.span) - } - InterpreterError::NonTupleOrStructInMemberAccess { value, location } => { - let msg = format!("The type `{}` has no fields to access", value.get_type()); - CustomDiagnostic::simple_error(msg, String::new(), location.span) - } - InterpreterError::NonArrayIndexed { value, location } => { - let msg = format!("Expected an array or slice but found a(n) {}", value.get_type()); - let secondary = "Only arrays or slices may be indexed".into(); - CustomDiagnostic::simple_error(msg, secondary, location.span) - } - InterpreterError::NonIntegerUsedAsIndex { value, location } => { - let msg = format!("Expected an integer but found a(n) {}", value.get_type()); - let secondary = - "Only integers may be indexed. Note that this excludes `field`s".into(); - CustomDiagnostic::simple_error(msg, secondary, location.span) - } - InterpreterError::NonIntegerIntegerLiteral { typ, location } => { - let msg = format!("This integer literal somehow has the type `{typ}`"); - let secondary = "This is likely a bug".into(); - CustomDiagnostic::simple_error(msg, secondary, location.span) - } - InterpreterError::NonIntegerArrayLength { typ, location } => { - let msg = format!("Non-integer array length: `{typ}`"); - let secondary = "Array lengths must be integers".into(); - CustomDiagnostic::simple_error(msg, secondary, location.span) - } - InterpreterError::NonNumericCasted { value, location } => { - let msg = "Only numeric types may be casted".into(); - let secondary = format!("`{}` is non-numeric", value.get_type()); - CustomDiagnostic::simple_error(msg, secondary, location.span) - } - InterpreterError::IndexOutOfBounds { index, length, location } => { - let msg = format!("{index} is out of bounds for the array of length {length}"); - CustomDiagnostic::simple_error(msg, String::new(), location.span) - } - InterpreterError::ExpectedStructToHaveField { value, field_name, location } => { - let typ = value.get_type(); - let msg = format!("The type `{typ}` has no field named `{field_name}`"); - CustomDiagnostic::simple_error(msg, String::new(), location.span) - } - InterpreterError::TypeUnsupported { typ, location } => { - let msg = - format!("The type `{typ}` is currently unsupported in comptime expressions"); - CustomDiagnostic::simple_error(msg, String::new(), location.span) - } - InterpreterError::InvalidValueForUnary { value, operator, location } => { - let msg = format!("`{}` cannot be used with unary {operator}", value.get_type()); - CustomDiagnostic::simple_error(msg, String::new(), location.span) - } - InterpreterError::InvalidValuesForBinary { lhs, rhs, operator, location } => { - let lhs = lhs.get_type(); - let rhs = rhs.get_type(); - let msg = format!("No implementation for `{lhs}` {operator} `{rhs}`",); - CustomDiagnostic::simple_error(msg, String::new(), location.span) - } - InterpreterError::CastToNonNumericType { typ, location } => { - let msg = format!("Cannot cast to non-numeric type `{typ}`"); - CustomDiagnostic::simple_error(msg, String::new(), location.span) - } - InterpreterError::QuoteInRuntimeCode { location } => { - let msg = "`quote` may only be used in comptime code".into(); - CustomDiagnostic::simple_error(msg, String::new(), location.span) - } - InterpreterError::NonStructInConstructor { typ, location } => { - let msg = format!("`{typ}` is not a struct type"); - CustomDiagnostic::simple_error(msg, String::new(), location.span) - } - InterpreterError::CannotInlineMacro { value, location } => { - let msg = "Cannot inline value into runtime code if it contains references".into(); - let secondary = format!("Cannot inline value {value:?}"); - CustomDiagnostic::simple_error(msg, secondary, location.span) - } - InterpreterError::UnquoteFoundDuringEvaluation { location } => { - let msg = "Unquote found during comptime evaluation".into(); - let secondary = "This is a bug".into(); - CustomDiagnostic::simple_error(msg, secondary, location.span) - } - InterpreterError::Unimplemented { item, location } => { - let msg = format!("{item} is currently unimplemented"); - CustomDiagnostic::simple_error(msg, String::new(), location.span) - } - InterpreterError::BreakNotInLoop { location } => { - let msg = "There is no loop to break out of!".into(); - CustomDiagnostic::simple_error(msg, String::new(), location.span) - } - InterpreterError::ContinueNotInLoop { location } => { - let msg = "There is no loop to continue!".into(); - CustomDiagnostic::simple_error(msg, String::new(), location.span) - } - InterpreterError::Break => unreachable!("Uncaught InterpreterError::Break"), - InterpreterError::Continue => unreachable!("Uncaught InterpreterError::Continue"), - } - } -} diff --git a/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/interpreter.rs index 4bdd4eaec9a..c01c985a40c 100644 --- a/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/interpreter.rs +++ b/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/interpreter.rs @@ -506,8 +506,11 @@ impl<'a> Interpreter<'a> { Value::U64(value) => Ok(Value::U64(0 - value)), value => { let location = self.interner.expr_location(&id); - let operator = "minus"; - Err(InterpreterError::InvalidValueForUnary { value, location, operator }) + Err(InterpreterError::InvalidValueForUnary { + value, + location, + operator: "minus", + }) } }, crate::ast::UnaryOp::Not => match rhs { @@ -877,7 +880,7 @@ impl<'a> Interpreter<'a> { if let Some(method) = method { self.call_function(method, arguments, location) } else { - Err(InterpreterError::NoMethodFound { name: method_name.clone(), typ, location }) + Err(InterpreterError::NoMethodFound { object, typ, location }) } } diff --git a/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/mod.rs b/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/mod.rs index 148fa56b4cb..26e05d675b3 100644 --- a/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/mod.rs +++ b/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/mod.rs @@ -5,5 +5,4 @@ mod scan; mod tests; mod value; -pub use errors::InterpreterError; pub use interpreter::Interpreter; diff --git a/noir/noir-repo/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/noir/noir-repo/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs index d8839b33ff4..7805f36cdb2 100644 --- a/noir/noir-repo/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs +++ b/noir/noir-repo/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs @@ -1,7 +1,7 @@ use super::dc_mod::collect_defs; use super::errors::{DefCollectorErrorKind, DuplicateType}; use crate::graph::CrateId; -use crate::hir::comptime::{Interpreter, InterpreterError}; +use crate::hir::comptime::Interpreter; use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleId}; use crate::hir::resolution::errors::ResolverError; @@ -155,7 +155,6 @@ pub enum CompilationError { DefinitionError(DefCollectorErrorKind), ResolverError(ResolverError), TypeError(TypeCheckError), - InterpreterError(InterpreterError), } impl From for CustomDiagnostic { @@ -165,7 +164,6 @@ impl From for CustomDiagnostic { CompilationError::DefinitionError(error) => error.into(), CompilationError::ResolverError(error) => error.into(), CompilationError::TypeError(error) => error.into(), - CompilationError::InterpreterError(error) => error.into(), } } } @@ -502,15 +500,13 @@ impl ResolvedModule { } /// Evaluate all `comptime` expressions in this module - fn evaluate_comptime(&mut self, interner: &mut NodeInterner) { + fn evaluate_comptime(&self, interner: &mut NodeInterner) { let mut interpreter = Interpreter::new(interner); for (_file, function) in &self.functions { - // The file returned by the error may be different than the file the - // function is in so only use the error's file id. - if let Err(error) = interpreter.scan_function(*function) { - self.errors.push(error.into_compilation_error_pair()); - } + // .unwrap() is temporary here until we can convert + // from InterpreterError to (CompilationError, FileId) + interpreter.scan_function(*function).unwrap(); } } diff --git a/noir/noir-repo/compiler/noirc_frontend/src/hir/def_map/mod.rs b/noir/noir-repo/compiler/noirc_frontend/src/hir/def_map/mod.rs index 590c2e3d6b6..7c0090ff95b 100644 --- a/noir/noir-repo/compiler/noirc_frontend/src/hir/def_map/mod.rs +++ b/noir/noir-repo/compiler/noirc_frontend/src/hir/def_map/mod.rs @@ -5,8 +5,8 @@ use crate::macros_api::MacroProcessor; use crate::node_interner::{FuncId, GlobalId, NodeInterner, StructId}; use crate::parser::{parse_program, ParsedModule, ParserError}; use crate::token::{FunctionAttribute, SecondaryAttribute, TestScope}; +use arena::{Arena, Index}; use fm::{FileId, FileManager}; -use noirc_arena::{Arena, Index}; use noirc_errors::Location; use std::collections::{BTreeMap, HashMap}; mod module_def; diff --git a/noir/noir-repo/compiler/noirc_frontend/src/hir/type_check/mod.rs b/noir/noir-repo/compiler/noirc_frontend/src/hir/type_check/mod.rs index 2a1ff1dd42c..44dab6dee3d 100644 --- a/noir/noir-repo/compiler/noirc_frontend/src/hir/type_check/mod.rs +++ b/noir/noir-repo/compiler/noirc_frontend/src/hir/type_check/mod.rs @@ -672,7 +672,7 @@ pub mod test { } fn local_module_id(&self) -> LocalModuleId { - LocalModuleId(noirc_arena::Index::unsafe_zeroed()) + LocalModuleId(arena::Index::unsafe_zeroed()) } fn module_id(&self) -> ModuleId { @@ -724,7 +724,7 @@ pub mod test { let mut def_maps = BTreeMap::new(); let file = FileId::default(); - let mut modules = noirc_arena::Arena::default(); + let mut modules = arena::Arena::default(); let location = Location::new(Default::default(), file); modules.insert(ModuleData::new(None, location, false)); diff --git a/noir/noir-repo/compiler/noirc_frontend/src/node_interner.rs b/noir/noir-repo/compiler/noirc_frontend/src/node_interner.rs index 5e4fa3df6c5..9d3a79820dc 100644 --- a/noir/noir-repo/compiler/noirc_frontend/src/node_interner.rs +++ b/noir/noir-repo/compiler/noirc_frontend/src/node_interner.rs @@ -2,9 +2,9 @@ use std::borrow::Cow; use std::collections::HashMap; use std::ops::Deref; +use arena::{Arena, Index}; use fm::FileId; use iter_extended::vecmap; -use noirc_arena::{Arena, Index}; use noirc_errors::{Location, Span, Spanned}; use petgraph::algo::tarjan_scc; use petgraph::prelude::DiGraph; diff --git a/noir/noir-repo/compiler/noirc_frontend/src/resolve_locations.rs b/noir/noir-repo/compiler/noirc_frontend/src/resolve_locations.rs index ac8c96a092e..b5f1b1d0c64 100644 --- a/noir/noir-repo/compiler/noirc_frontend/src/resolve_locations.rs +++ b/noir/noir-repo/compiler/noirc_frontend/src/resolve_locations.rs @@ -1,4 +1,4 @@ -use noirc_arena::Index; +use arena::Index; use noirc_errors::Location; use crate::hir_def::expr::HirExpression; diff --git a/noir/noir-repo/compiler/noirc_frontend/src/tests.rs b/noir/noir-repo/compiler/noirc_frontend/src/tests.rs index c6cef568ed8..31bf2245b1f 100644 --- a/noir/noir-repo/compiler/noirc_frontend/src/tests.rs +++ b/noir/noir-repo/compiler/noirc_frontend/src/tests.rs @@ -31,8 +31,8 @@ mod test { hir::def_map::{CrateDefMap, LocalModuleId}, parse_program, }; + use arena::Arena; use fm::FileManager; - use noirc_arena::Arena; pub(crate) fn has_parser_error(errors: &[(CompilationError, FileId)]) -> bool { errors.iter().any(|(e, _f)| matches!(e, CompilationError::ParseError(_))) diff --git a/noir/noir-repo/compiler/noirc_arena/Cargo.toml b/noir/noir-repo/compiler/utils/arena/Cargo.toml similarity index 86% rename from noir/noir-repo/compiler/noirc_arena/Cargo.toml rename to noir/noir-repo/compiler/utils/arena/Cargo.toml index b94f997b7b9..f6bd764ee62 100644 --- a/noir/noir-repo/compiler/noirc_arena/Cargo.toml +++ b/noir/noir-repo/compiler/utils/arena/Cargo.toml @@ -1,5 +1,5 @@ [package] -name = "noirc_arena" +name = "arena" version.workspace = true authors.workspace = true edition.workspace = true diff --git a/noir/noir-repo/compiler/noirc_arena/src/lib.rs b/noir/noir-repo/compiler/utils/arena/src/lib.rs similarity index 100% rename from noir/noir-repo/compiler/noirc_arena/src/lib.rs rename to noir/noir-repo/compiler/utils/arena/src/lib.rs diff --git a/noir/noir-repo/utils/iter-extended/Cargo.toml b/noir/noir-repo/compiler/utils/iter-extended/Cargo.toml similarity index 100% rename from noir/noir-repo/utils/iter-extended/Cargo.toml rename to noir/noir-repo/compiler/utils/iter-extended/Cargo.toml diff --git a/noir/noir-repo/utils/iter-extended/src/lib.rs b/noir/noir-repo/compiler/utils/iter-extended/src/lib.rs similarity index 100% rename from noir/noir-repo/utils/iter-extended/src/lib.rs rename to noir/noir-repo/compiler/utils/iter-extended/src/lib.rs diff --git a/noir/noir-repo/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx b/noir/noir-repo/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx index efa52b2c3f2..7329880c7a7 100644 --- a/noir/noir-repo/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx +++ b/noir/noir-repo/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx @@ -13,21 +13,18 @@ import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx'; ## sha256 Given an array of bytes, returns the resulting sha256 hash. -Specify a message_size to hash only the first `message_size` bytes of the input. #include_code sha256 noir_stdlib/src/hash.nr rust example: -#include_code sha256_var test_programs/execution_success/sha256/src/main.nr rust ```rust fn main() { let x = [163, 117, 178, 149]; // some random bytes - let hash = std::sha256::sha256_var(x, 4); + let hash = std::hash::sha256(x); } ``` - ## blake2s diff --git a/noir/noir-repo/flake.lock b/noir/noir-repo/flake.lock new file mode 100644 index 00000000000..5a9f9470a1f --- /dev/null +++ b/noir/noir-repo/flake.lock @@ -0,0 +1,170 @@ +{ + "nodes": { + "crane": { + "inputs": { + "flake-compat": [ + "flake-compat" + ], + "flake-utils": [ + "flake-utils" + ], + "nixpkgs": [ + "nixpkgs" + ], + "rust-overlay": "rust-overlay" + }, + "locked": { + "lastModified": 1681177078, + "narHash": "sha256-ZNIjBDou2GOabcpctiQykEQVkI8BDwk7TyvlWlI4myE=", + "owner": "ipetkov", + "repo": "crane", + "rev": "0c9f468ff00576577d83f5019a66c557ede5acf6", + "type": "github" + }, + "original": { + "owner": "ipetkov", + "repo": "crane", + "type": "github" + } + }, + "fenix": { + "inputs": { + "nixpkgs": [ + "nixpkgs" + ], + "rust-analyzer-src": "rust-analyzer-src" + }, + "locked": { + "lastModified": 1694499657, + "narHash": "sha256-u/fZtLtN7VcDrMMVrdsFy93PEkaiK+tNpJT9on4SGdU=", + "owner": "nix-community", + "repo": "fenix", + "rev": "2895ff377cbb3cb6f5dd92066734b0447cb04e20", + "type": "github" + }, + "original": { + "owner": "nix-community", + "repo": "fenix", + "type": "github" + } + }, + "flake-compat": { + "flake": false, + "locked": { + "lastModified": 1673956053, + "narHash": "sha256-4gtG9iQuiKITOjNQQeQIpoIB6b16fm+504Ch3sNKLd8=", + "owner": "edolstra", + "repo": "flake-compat", + "rev": "35bb57c0c8d8b62bbfd284272c928ceb64ddbde9", + "type": "github" + }, + "original": { + "owner": "edolstra", + "repo": "flake-compat", + "type": "github" + } + }, + "flake-utils": { + "inputs": { + "systems": "systems" + }, + "locked": { + "lastModified": 1681202837, + "narHash": "sha256-H+Rh19JDwRtpVPAWp64F+rlEtxUWBAQW28eAi3SRSzg=", + "owner": "numtide", + "repo": "flake-utils", + "rev": "cfacdce06f30d2b68473a46042957675eebb3401", + "type": "github" + }, + "original": { + "owner": "numtide", + "repo": "flake-utils", + "type": "github" + } + }, + "nixpkgs": { + "locked": { + "lastModified": 1695559356, + "narHash": "sha256-kXZ1pUoImD9OEbPCwpTz4tHsNTr4CIyIfXb3ocuR8sI=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "261abe8a44a7e8392598d038d2e01f7b33cf26d0", + "type": "github" + }, + "original": { + "owner": "NixOS", + "ref": "nixos-23.05", + "repo": "nixpkgs", + "type": "github" + } + }, + "root": { + "inputs": { + "crane": "crane", + "fenix": "fenix", + "flake-compat": "flake-compat", + "flake-utils": "flake-utils", + "nixpkgs": "nixpkgs" + } + }, + "rust-analyzer-src": { + "flake": false, + "locked": { + "lastModified": 1694421477, + "narHash": "sha256-df6YZzR57VFzkOPwIohJfC0fRwgq6yUPbMJkKAtQyAE=", + "owner": "rust-lang", + "repo": "rust-analyzer", + "rev": "cc6c8209cbaf7df55013977cf5cc8488d6b7ff1c", + "type": "github" + }, + "original": { + "owner": "rust-lang", + "ref": "nightly", + "repo": "rust-analyzer", + "type": "github" + } + }, + "rust-overlay": { + "inputs": { + "flake-utils": [ + "crane", + "flake-utils" + ], + "nixpkgs": [ + "crane", + "nixpkgs" + ] + }, + "locked": { + "lastModified": 1694484610, + "narHash": "sha256-aeSDkp7fkAqtVjW3QUn7vq7BKNlFul/BiGgdv7rK+mA=", + "owner": "oxalica", + "repo": "rust-overlay", + "rev": "c5b977a7e6a295697fa1f9c42174fd6313b38df4", + "type": "github" + }, + "original": { + "owner": "oxalica", + "repo": "rust-overlay", + "type": "github" + } + }, + "systems": { + "locked": { + "lastModified": 1681028828, + "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=", + "owner": "nix-systems", + "repo": "default", + "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e", + "type": "github" + }, + "original": { + "owner": "nix-systems", + "repo": "default", + "type": "github" + } + } + }, + "root": "root", + "version": 7 +} diff --git a/noir/noir-repo/noir_stdlib/src/hash.nr b/noir/noir-repo/noir_stdlib/src/hash.nr index ef1cb0889d7..26a9fa6c2c0 100644 --- a/noir/noir-repo/noir_stdlib/src/hash.nr +++ b/noir/noir-repo/noir_stdlib/src/hash.nr @@ -4,7 +4,6 @@ mod poseidon2; use crate::default::Default; use crate::uint128::U128; -use crate::sha256::{digest, sha256_var}; #[foreign(sha256)] // docs:start:sha256 diff --git a/noir/noir-repo/noir_stdlib/src/sha256.nr b/noir/noir-repo/noir_stdlib/src/sha256.nr index d856043fcfa..8ca6808568d 100644 --- a/noir/noir-repo/noir_stdlib/src/sha256.nr +++ b/noir/noir-repo/noir_stdlib/src/sha256.nr @@ -17,42 +17,19 @@ fn msg_u8_to_u32(msg: [u8; 64]) -> [u32; 16] { } // SHA-256 hash function pub fn digest(msg: [u8; N]) -> [u8; 32] { - sha256_var(msg, N) -} - -fn hash_final_block(msg_block: [u8; 64], mut state: [u32; 8]) -> [u8; 32] { - let mut out_h: [u8; 32] = [0; 32]; // Digest as sequence of bytes - - // Hash final padded block - state = crate::hash::sha256_compression(msg_u8_to_u32(msg_block), state); - - // Return final hash as byte array - for j in 0..8 { - let h_bytes = (state[7 - j] as Field).to_le_bytes(4); - for k in 0..4 { - out_h[31 - 4*j - k] = h_bytes[k]; - } - } - - out_h -} - -// Variable size SHA-256 hash -pub fn sha256_var(msg: [u8; N], message_size: u64) -> [u8; 32] { let mut msg_block: [u8; 64] = [0; 64]; let mut h: [u32; 8] = [1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225]; // Intermediate hash, starting with the canonical initial value + let mut out_h: [u8; 32] = [0; 32]; // Digest as sequence of bytes let mut i: u64 = 0; // Message byte pointer for k in 0..N { - if k < message_size { - // Populate msg_block - msg_block[i] = msg[k]; - i = i + 1; - if i == 64 { - // Enough to hash block - h = crate::hash::sha256_compression(msg_u8_to_u32(msg_block), h); + // Populate msg_block + msg_block[i] = msg[k]; + i = i + 1; + if i == 64 { + // Enough to hash block + h = crate::hash::sha256_compression(msg_u8_to_u32(msg_block), h); - i = 0; - } + i = 0; } } // Pad the rest such that we have a [u32; 2] block at the end representing the length @@ -76,7 +53,7 @@ pub fn sha256_var(msg: [u8; N], message_size: u64) -> [u8; 32] { i = 0; } - let len = 8 * message_size; + let len = 8 * msg.len(); let len_bytes = (len as Field).to_le_bytes(8); for _i in 0..64 { // In any case, fill blocks up with zeros until the last 64 (i.e. until i = 56). @@ -90,5 +67,16 @@ pub fn sha256_var(msg: [u8; N], message_size: u64) -> [u8; 32] { i += 8; } } - hash_final_block(msg_block, h) + // Hash final padded block + h = crate::hash::sha256_compression(msg_u8_to_u32(msg_block), h); + + // Return final hash as byte array + for j in 0..8 { + let h_bytes = (h[7 - j] as Field).to_le_bytes(4); + for k in 0..4 { + out_h[31 - 4*j - k] = h_bytes[k]; + } + } + + out_h } diff --git a/noir/noir-repo/test_programs/execution_success/sha256/src/main.nr b/noir/noir-repo/test_programs/execution_success/sha256/src/main.nr index d4240ded8b3..fd5340e2384 100644 --- a/noir/noir-repo/test_programs/execution_success/sha256/src/main.nr +++ b/noir/noir-repo/test_programs/execution_success/sha256/src/main.nr @@ -14,8 +14,6 @@ use dep::std; fn main(x: Field, result: [u8; 32]) { // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field // The padding is taken care of by the program - // docs:start:sha256_var - let digest = std::hash::sha256_var([x as u8], 1); - // docs:end:sha256_var + let digest = std::hash::sha256([x as u8]); assert(digest == result); } diff --git a/noir/noir-repo/tooling/noir_js_backend_barretenberg/package.json b/noir/noir-repo/tooling/noir_js_backend_barretenberg/package.json index b5782269674..438e91ff302 100644 --- a/noir/noir-repo/tooling/noir_js_backend_barretenberg/package.json +++ b/noir/noir-repo/tooling/noir_js_backend_barretenberg/package.json @@ -3,7 +3,7 @@ "contributors": [ "The Noir Team " ], - "version": "0.28.0", + "version": "0.27.0", "packageManager": "yarn@3.5.1", "license": "(MIT OR Apache-2.0)", "type": "module", diff --git a/noir/noir-repo/tooling/noirc_abi_wasm/build.sh b/noir/noir-repo/tooling/noirc_abi_wasm/build.sh index c07d2d8a4c1..ee93413ab85 100755 --- a/noir/noir-repo/tooling/noirc_abi_wasm/build.sh +++ b/noir/noir-repo/tooling/noirc_abi_wasm/build.sh @@ -25,7 +25,7 @@ function run_if_available { require_command jq require_command cargo require_command wasm-bindgen -#require_command wasm-opt +# require_command wasm-opt self_path=$(dirname "$(readlink -f "$0")") pname=$(cargo read-manifest | jq -r '.name')