diff --git a/avm-transpiler/src/transpile_contract.rs b/avm-transpiler/src/transpile_contract.rs index bcf848ab88e..77528a46057 100644 --- a/avm-transpiler/src/transpile_contract.rs +++ b/avm-transpiler/src/transpile_contract.rs @@ -4,7 +4,6 @@ use regex::Regex; use serde::{Deserialize, Serialize}; use acvm::acir::circuit::Circuit; -use noirc_driver::ContractFunctionType; use crate::transpile::brillig_to_avm; use crate::utils::extract_brillig_from_acir; @@ -40,8 +39,8 @@ pub struct CompiledAcirContract { #[derive(Debug, Serialize, Deserialize)] pub struct AvmContractFunction { pub name: String, - pub function_type: ContractFunctionType, - pub is_internal: bool, + pub is_unconstrained: bool, + pub custom_attributes: Vec, pub abi: serde_json::Value, pub bytecode: String, // base64 pub debug_symbols: serde_json::Value, @@ -52,8 +51,8 @@ pub struct AvmContractFunction { #[derive(Debug, Serialize, Deserialize)] pub struct AcirContractFunction { pub name: String, - pub function_type: ContractFunctionType, - pub is_internal: bool, + pub is_unconstrained: bool, + pub custom_attributes: Vec, pub abi: serde_json::Value, #[serde( serialize_with = "Circuit::serialize_circuit_base64", @@ -82,7 +81,9 @@ impl From for TranspiledContract { let re = Regex::new(r"avm_.*$").unwrap(); for function in contract.functions { // TODO(4269): once functions are tagged for transpilation to AVM, check tag - if function.function_type == ContractFunctionType::Open + if function + .custom_attributes + .contains(&"aztec(public-vm)".to_string()) && re.is_match(function.name.as_str()) { info!( @@ -99,8 +100,8 @@ impl From for TranspiledContract { // Push modified function entry to ABI functions.push(AvmOrAcirContractFunction::Avm(AvmContractFunction { name: function.name, - function_type: function.function_type, - is_internal: function.is_internal, + is_unconstrained: function.is_unconstrained, + custom_attributes: function.custom_attributes, abi: function.abi, bytecode: base64::prelude::BASE64_STANDARD.encode(avm_bytecode), debug_symbols: function.debug_symbols, diff --git a/noir/noir-repo/aztec_macros/src/lib.rs b/noir/noir-repo/aztec_macros/src/lib.rs index bf74c911ae8..1f3546cbb6a 100644 --- a/noir/noir-repo/aztec_macros/src/lib.rs +++ b/noir/noir-repo/aztec_macros/src/lib.rs @@ -151,10 +151,7 @@ fn transform_module( transform_vm_function(func, storage_defined) .map_err(|err| (err, crate_graph.root_file_id))?; has_transformed_module = true; - } - - // Add the storage struct to the beginning of the function if it is unconstrained in an aztec contract - if storage_defined && func.def.is_unconstrained { + } else if storage_defined && func.def.is_unconstrained { transform_unconstrained(func); has_transformed_module = true; } diff --git a/noir/noir-repo/aztec_macros/src/transforms/functions.rs b/noir/noir-repo/aztec_macros/src/transforms/functions.rs index 58632effa13..a25152dbbe0 100644 --- a/noir/noir-repo/aztec_macros/src/transforms/functions.rs +++ b/noir/noir-repo/aztec_macros/src/transforms/functions.rs @@ -40,7 +40,6 @@ pub fn transform_function( if is_internal { let is_internal_check = create_internal_check(func.name()); func.def.body.0.insert(0, is_internal_check); - func.def.is_internal = true; } // Add initialization check @@ -87,10 +86,10 @@ pub fn transform_function( func.def.return_visibility = Visibility::Public; // Distinct return types are only required for private functions - // Public functions should have open auto-inferred + // Public functions should have unconstrained auto-inferred match ty { "Private" => func.def.return_distinctness = Distinctness::Distinct, - "Public" => func.def.is_open = true, + "Public" => func.def.is_unconstrained = true, _ => (), } @@ -113,7 +112,7 @@ pub fn transform_vm_function( func.def.body.0.insert(0, create_context); // We want the function to be seen as a public function - func.def.is_open = true; + func.def.is_unconstrained = true; // NOTE: the line below is a temporary hack to trigger external transpilation tools // It will be removed once the transpiler is integrated into the Noir compiler diff --git a/noir/noir-repo/compiler/noirc_driver/src/contract.rs b/noir/noir-repo/compiler/noirc_driver/src/contract.rs index 5f4b66e7dd2..66e8dc0e730 100644 --- a/noir/noir-repo/compiler/noirc_driver/src/contract.rs +++ b/noir/noir-repo/compiler/noirc_driver/src/contract.rs @@ -9,23 +9,6 @@ use noirc_evaluator::errors::SsaReport; use super::debug::DebugFile; -/// Describes the types of smart contract functions that are allowed. -/// Unlike the similar enum in noirc_frontend, 'open' and 'unconstrained' -/// are mutually exclusive here. In the case a function is both, 'unconstrained' -/// takes precedence. -#[derive(Serialize, Deserialize, Debug, Copy, Clone, PartialEq, Eq)] -pub enum ContractFunctionType { - /// This function will be executed in a private - /// context. - Secret, - /// This function will be executed in a public - /// context. - Open, - /// This function cannot constrain any values and can use nondeterministic features - /// like arrays of a dynamic size. - Unconstrained, -} - #[derive(Clone, Debug, Serialize, Deserialize)] pub struct CompiledContract { pub noir_version: String, @@ -55,9 +38,9 @@ pub struct CompiledContract { pub struct ContractFunction { pub name: String, - pub function_type: ContractFunctionType, + pub is_unconstrained: bool, - pub is_internal: bool, + pub custom_attributes: Vec, pub abi: Abi, @@ -69,13 +52,3 @@ pub struct ContractFunction { pub debug: DebugInfo, } - -impl ContractFunctionType { - pub(super) fn new(kind: noirc_frontend::ContractFunctionType, is_unconstrained: bool) -> Self { - match (kind, is_unconstrained) { - (_, true) => Self::Unconstrained, - (noirc_frontend::ContractFunctionType::Secret, false) => Self::Secret, - (noirc_frontend::ContractFunctionType::Open, false) => Self::Open, - } - } -} diff --git a/noir/noir-repo/compiler/noirc_driver/src/lib.rs b/noir/noir-repo/compiler/noirc_driver/src/lib.rs index 425db9b790e..346eb595389 100644 --- a/noir/noir-repo/compiler/noirc_driver/src/lib.rs +++ b/noir/noir-repo/compiler/noirc_driver/src/lib.rs @@ -18,6 +18,7 @@ use noirc_frontend::hir::Context; use noirc_frontend::macros_api::MacroProcessor; use noirc_frontend::monomorphization::{monomorphize, monomorphize_debug, MonomorphizationError}; use noirc_frontend::node_interner::FuncId; +use noirc_frontend::token::SecondaryAttribute; use std::path::Path; use thiserror::Error; use tracing::info; @@ -30,7 +31,7 @@ mod stdlib; use debug::filter_relevant_files; -pub use contract::{CompiledContract, ContractFunction, ContractFunctionType}; +pub use contract::{CompiledContract, ContractFunction}; pub use debug::DebugFile; pub use program::CompiledProgram; @@ -404,19 +405,24 @@ fn compile_contract_inner( }; warnings.extend(function.warnings); let modifiers = context.def_interner.function_modifiers(&function_id); - let func_type = modifiers - .contract_function_type - .expect("Expected contract function to have a contract visibility"); - let function_type = ContractFunctionType::new(func_type, modifiers.is_unconstrained); + let custom_attributes = modifiers + .attributes + .secondary + .iter() + .filter_map( + |attr| if let SecondaryAttribute::Custom(tag) = attr { Some(tag) } else { None }, + ) + .cloned() + .collect(); functions.push(ContractFunction { name, - function_type, - is_internal: modifiers.is_internal.unwrap_or(false), + custom_attributes, abi: function.abi, bytecode: function.circuit, debug: function.debug, + is_unconstrained: modifiers.is_unconstrained, }); } diff --git a/noir/noir-repo/compiler/noirc_frontend/src/ast/expression.rs b/noir/noir-repo/compiler/noirc_frontend/src/ast/expression.rs index 2a252633a29..204b3b1de7f 100644 --- a/noir/noir-repo/compiler/noirc_frontend/src/ast/expression.rs +++ b/noir/noir-repo/compiler/noirc_frontend/src/ast/expression.rs @@ -369,11 +369,6 @@ pub struct FunctionDefinition { // and `secondary` attributes (ones that do not change the function kind) pub attributes: Attributes, - /// True if this function was defined with the 'open' keyword - pub is_open: bool, - - pub is_internal: bool, - /// True if this function was defined with the 'unconstrained' keyword pub is_unconstrained: bool, @@ -406,18 +401,6 @@ pub enum FunctionReturnType { Ty(UnresolvedType), } -/// Describes the types of smart contract functions that are allowed. -/// - All Noir programs in the non-contract context can be seen as `Secret`. -#[derive(Debug, Copy, Clone, PartialEq, Eq)] -pub enum ContractFunctionType { - /// This function will be executed in a private - /// context. - Secret, - /// This function will be executed in a public - /// context. - Open, -} - #[derive(Debug, PartialEq, Eq, Clone)] pub enum ArrayLiteral { Standard(Vec), @@ -674,8 +657,6 @@ impl FunctionDefinition { FunctionDefinition { name: name.clone(), attributes: Attributes::empty(), - is_open: false, - is_internal: false, is_unconstrained: false, visibility: FunctionVisibility::Private, generics: generics.clone(), diff --git a/noir/noir-repo/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/noir/noir-repo/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs index 91d21383962..9189d031934 100644 --- a/noir/noir-repo/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs +++ b/noir/noir-repo/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs @@ -411,8 +411,6 @@ impl<'a> ModCollector<'a> { // TODO(Maddiaa): Investigate trait implementations with attributes see: https://github.com/noir-lang/noir/issues/2629 attributes: crate::token::Attributes::empty(), is_unconstrained: false, - contract_function_type: None, - is_internal: None, }; let location = Location::new(name.span(), self.file_id); diff --git a/noir/noir-repo/compiler/noirc_frontend/src/hir/resolution/errors.rs b/noir/noir-repo/compiler/noirc_frontend/src/hir/resolution/errors.rs index d2fe67da38c..cba26ab329e 100644 --- a/noir/noir-repo/compiler/noirc_frontend/src/hir/resolution/errors.rs +++ b/noir/noir-repo/compiler/noirc_frontend/src/hir/resolution/errors.rs @@ -64,14 +64,10 @@ pub enum ResolverError { IncorrectGenericCount { span: Span, item_name: String, actual: usize, expected: usize }, #[error("{0}")] ParserError(Box), - #[error("Function is not defined in a contract yet sets its contract visibility")] - ContractFunctionTypeInNormalFunction { span: Span }, #[error("Cannot create a mutable reference to {variable}, it was declared to be immutable")] MutableReferenceToImmutableVariable { variable: String, span: Span }, #[error("Mutable references to array indices are unsupported")] MutableReferenceToArrayElement { span: Span }, - #[error("Function is not defined in a contract yet sets is_internal")] - ContractFunctionInternalInNormalFunction { span: Span }, #[error("Numeric constants should be printed without formatting braces")] NumericConstantInFormatString { name: String, span: Span }, #[error("Closure environment must be a tuple or unit type")] @@ -278,22 +274,12 @@ impl From for Diagnostic { ) } ResolverError::ParserError(error) => (*error).into(), - ResolverError::ContractFunctionTypeInNormalFunction { span } => Diagnostic::simple_error( - "Only functions defined within contracts can set their contract function type".into(), - "Non-contract functions cannot be 'open'".into(), - span, - ), ResolverError::MutableReferenceToImmutableVariable { variable, span } => { Diagnostic::simple_error(format!("Cannot mutably reference the immutable variable {variable}"), format!("{variable} is immutable"), span) }, ResolverError::MutableReferenceToArrayElement { span } => { Diagnostic::simple_error("Mutable references to array elements are currently unsupported".into(), "Try storing the element in a fresh variable first".into(), span) }, - ResolverError::ContractFunctionInternalInNormalFunction { span } => Diagnostic::simple_error( - "Only functions defined within contracts can set their functions to be internal".into(), - "Non-contract functions cannot be 'internal'".into(), - span, - ), ResolverError::NumericConstantInFormatString { name, span } => Diagnostic::simple_error( format!("cannot find `{name}` in this scope "), "Numeric constants should be printed without formatting braces".to_string(), diff --git a/noir/noir-repo/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/noir/noir-repo/compiler/noirc_frontend/src/hir/resolution/resolver.rs index 7f9e48353a7..2f6ccffee95 100644 --- a/noir/noir-repo/compiler/noirc_frontend/src/hir/resolution/resolver.rs +++ b/noir/noir-repo/compiler/noirc_frontend/src/hir/resolution/resolver.rs @@ -37,10 +37,10 @@ use crate::{ StatementKind, }; use crate::{ - ArrayLiteral, ContractFunctionType, Distinctness, ForRange, FunctionDefinition, - FunctionReturnType, FunctionVisibility, Generics, LValue, NoirStruct, NoirTypeAlias, Param, - Path, PathKind, Pattern, Shared, StructType, Type, TypeAlias, TypeVariable, TypeVariableKind, - UnaryOp, UnresolvedGenerics, UnresolvedTraitConstraint, UnresolvedType, UnresolvedTypeData, + ArrayLiteral, Distinctness, ForRange, FunctionDefinition, FunctionReturnType, + FunctionVisibility, Generics, LValue, NoirStruct, NoirTypeAlias, Param, Path, PathKind, + Pattern, Shared, StructType, Type, TypeAlias, TypeVariable, TypeVariableKind, UnaryOp, + UnresolvedGenerics, UnresolvedTraitConstraint, UnresolvedType, UnresolvedTypeData, UnresolvedTypeExpression, Visibility, ERROR_IDENT, }; use fm::FileId; @@ -233,8 +233,6 @@ impl<'a> Resolver<'a> { let def = FunctionDefinition { name: name.clone(), attributes: Attributes::empty(), - is_open: false, - is_internal: false, is_unconstrained: false, visibility: FunctionVisibility::Public, // Trait functions are always public generics: Vec::new(), // self.generics should already be set @@ -976,9 +974,6 @@ impl<'a> Resolver<'a> { self.interner.push_definition_type(name_ident.id, typ.clone()); - self.handle_function_type(&func_id); - self.handle_is_function_internal(&func_id); - FuncMeta { name: name_ident, kind: func.kind, @@ -1018,34 +1013,14 @@ impl<'a> Resolver<'a> { /// True if the `distinct` keyword is allowed on a function's return type fn distinct_allowed(&self, func: &NoirFunction) -> bool { if self.in_contract { - // "open" and "unconstrained" functions are compiled to brillig and thus duplication of + // "unconstrained" functions are compiled to brillig and thus duplication of // witness indices in their abis is not a concern. - !func.def.is_unconstrained && !func.def.is_open + !func.def.is_unconstrained } else { func.name() == MAIN_FUNCTION } } - fn handle_function_type(&mut self, function: &FuncId) { - let function_type = self.interner.function_modifiers(function).contract_function_type; - - if !self.in_contract && function_type == Some(ContractFunctionType::Open) { - let span = self.interner.function_ident(function).span(); - self.errors.push(ResolverError::ContractFunctionTypeInNormalFunction { span }); - self.interner.function_modifiers_mut(function).contract_function_type = None; - } - } - - fn handle_is_function_internal(&mut self, function: &FuncId) { - if !self.in_contract { - if self.interner.function_modifiers(function).is_internal == Some(true) { - let span = self.interner.function_ident(function).span(); - self.push_err(ResolverError::ContractFunctionInternalInNormalFunction { span }); - } - self.interner.function_modifiers_mut(function).is_internal = None; - } - } - fn declare_numeric_generics(&mut self, params: &[Type], return_type: &Type) { if self.generics.is_empty() { return; diff --git a/noir/noir-repo/compiler/noirc_frontend/src/lexer/token.rs b/noir/noir-repo/compiler/noirc_frontend/src/lexer/token.rs index f096c220200..3dc9d05b15e 100644 --- a/noir/noir-repo/compiler/noirc_frontend/src/lexer/token.rs +++ b/noir/noir-repo/compiler/noirc_frontend/src/lexer/token.rs @@ -664,7 +664,6 @@ pub enum Keyword { Let, Mod, Mut, - Open, Pub, Return, ReturnData, @@ -706,7 +705,6 @@ impl fmt::Display for Keyword { Keyword::Let => write!(f, "let"), Keyword::Mod => write!(f, "mod"), Keyword::Mut => write!(f, "mut"), - Keyword::Open => write!(f, "open"), Keyword::Pub => write!(f, "pub"), Keyword::Return => write!(f, "return"), Keyword::ReturnData => write!(f, "return_data"), @@ -751,7 +749,6 @@ impl Keyword { "let" => Keyword::Let, "mod" => Keyword::Mod, "mut" => Keyword::Mut, - "open" => Keyword::Open, "pub" => Keyword::Pub, "return" => Keyword::Return, "return_data" => Keyword::ReturnData, diff --git a/noir/noir-repo/compiler/noirc_frontend/src/monomorphization/mod.rs b/noir/noir-repo/compiler/noirc_frontend/src/monomorphization/mod.rs index ce880401d77..10493154521 100644 --- a/noir/noir-repo/compiler/noirc_frontend/src/monomorphization/mod.rs +++ b/noir/noir-repo/compiler/noirc_frontend/src/monomorphization/mod.rs @@ -28,8 +28,8 @@ use crate::{ }, node_interner::{self, DefinitionKind, NodeInterner, StmtId, TraitImplKind, TraitMethodId}, token::FunctionAttribute, - ContractFunctionType, FunctionKind, IntegerBitSize, Signedness, Type, TypeBinding, - TypeBindings, TypeVariable, TypeVariableKind, UnaryOp, Visibility, + FunctionKind, IntegerBitSize, Signedness, Type, TypeBinding, TypeBindings, TypeVariable, + TypeVariableKind, UnaryOp, Visibility, }; use self::ast::{Definition, FuncId, Function, LocalId, Program}; @@ -310,8 +310,7 @@ impl<'interner> Monomorphizer<'interner> { Type::TraitAsType(..) => &body_return_type, _ => meta.return_type(), }); - let unconstrained = modifiers.is_unconstrained - || matches!(modifiers.contract_function_type, Some(ContractFunctionType::Open)); + let unconstrained = modifiers.is_unconstrained; let parameters = self.parameters(&meta.parameters); let body = self.expr(body_expr_id)?; 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 5de43e59254..5aab683aff3 100644 --- a/noir/noir-repo/compiler/noirc_frontend/src/node_interner.rs +++ b/noir/noir-repo/compiler/noirc_frontend/src/node_interner.rs @@ -28,8 +28,8 @@ use crate::hir_def::{ }; use crate::token::{Attributes, SecondaryAttribute}; use crate::{ - BinaryOpKind, ContractFunctionType, FunctionDefinition, FunctionVisibility, Generics, Shared, - TypeAlias, TypeBindings, TypeVariable, TypeVariableId, TypeVariableKind, + BinaryOpKind, FunctionDefinition, FunctionVisibility, Generics, Shared, TypeAlias, + TypeBindings, TypeVariable, TypeVariableId, TypeVariableKind, }; /// An arbitrary number to limit the recursion depth when searching for trait impls. @@ -241,15 +241,6 @@ pub struct FunctionModifiers { pub attributes: Attributes, pub is_unconstrained: bool, - - /// This function's type in its contract. - /// If this function is not in a contract, this is always 'Secret'. - pub contract_function_type: Option, - - /// This function's contract visibility. - /// If this function is internal can only be called by itself. - /// Will be None if not in contract. - pub is_internal: Option, } impl FunctionModifiers { @@ -262,8 +253,6 @@ impl FunctionModifiers { visibility: FunctionVisibility::Public, attributes: Attributes::empty(), is_unconstrained: false, - is_internal: None, - contract_function_type: None, } } } @@ -759,17 +748,11 @@ impl NodeInterner { module: ModuleId, location: Location, ) -> DefinitionId { - use ContractFunctionType::*; - - // We're filling in contract_function_type and is_internal now, but these will be verified - // later during name resolution. let modifiers = FunctionModifiers { name: function.name.0.contents.clone(), visibility: function.visibility, attributes: function.attributes.clone(), is_unconstrained: function.is_unconstrained, - contract_function_type: Some(if function.is_open { Open } else { Secret }), - is_internal: Some(function.is_internal), }; self.push_function_definition(id, modifiers, module, location) } diff --git a/noir/noir-repo/compiler/noirc_frontend/src/parser/parser/function.rs b/noir/noir-repo/compiler/noirc_frontend/src/parser/parser/function.rs index 7448d84cfe1..a26df542076 100644 --- a/noir/noir-repo/compiler/noirc_frontend/src/parser/parser/function.rs +++ b/noir/noir-repo/compiler/noirc_frontend/src/parser/parser/function.rs @@ -36,9 +36,6 @@ pub(super) fn function_definition(allow_self: bool) -> impl NoirParser impl NoirParser { choice((is_pub_crate, is_pub, is_private)) } -/// function_modifiers: 'unconstrained'? (visibility)? 'open'? +/// function_modifiers: 'unconstrained'? (visibility)? /// -/// returns (is_unconstrained, visibility, is_open) for whether each keyword was present -fn function_modifiers() -> impl NoirParser<(bool, FunctionVisibility, bool)> { +/// returns (is_unconstrained, visibility) for whether each keyword was present +fn function_modifiers() -> impl NoirParser<(bool, FunctionVisibility)> { keyword(Keyword::Unconstrained) .or_not() .then(visibility_modifier()) - .then(keyword(Keyword::Open).or_not()) - .map(|((unconstrained, visibility), open)| { - (unconstrained.is_some(), visibility, open.is_some()) - }) + .map(|(unconstrained, visibility)| (unconstrained.is_some(), visibility)) } /// non_empty_ident_list: ident ',' non_empty_ident_list diff --git a/noir/noir-repo/compiler/noirc_frontend/src/parser/parser/traits.rs b/noir/noir-repo/compiler/noirc_frontend/src/parser/parser/traits.rs index 0d72fbd5303..4f46be83b7c 100644 --- a/noir/noir-repo/compiler/noirc_frontend/src/parser/parser/traits.rs +++ b/noir/noir-repo/compiler/noirc_frontend/src/parser/parser/traits.rs @@ -120,11 +120,7 @@ pub(super) fn trait_implementation() -> impl NoirParser { fn trait_implementation_body() -> impl NoirParser> { let function = function::function_definition(true).validate(|mut f, span, emit| { - if f.def().is_internal - || f.def().is_unconstrained - || f.def().is_open - || f.def().visibility != FunctionVisibility::Private - { + if f.def().is_unconstrained || f.def().visibility != FunctionVisibility::Private { emit(ParserError::with_reason(ParserErrorReason::TraitImplFunctionModifiers, span)); } // Trait impl functions are always public diff --git a/noir/noir-repo/compiler/wasm/src/types/noir_artifact.ts b/noir/noir-repo/compiler/wasm/src/types/noir_artifact.ts index 832a6ed9bf9..935c99043da 100644 --- a/noir/noir-repo/compiler/wasm/src/types/noir_artifact.ts +++ b/noir/noir-repo/compiler/wasm/src/types/noir_artifact.ts @@ -32,19 +32,16 @@ export interface EventAbi { fields: ABIVariable[]; } -/** The Noir function types. */ -export type NoirFunctionType = 'Open' | 'Secret' | 'Unconstrained'; - /** * The compilation result of an Noir function. */ export interface NoirFunctionEntry { /** The name of the function. */ name: string; - /** The type of the function. */ - function_type: NoirFunctionType; - /** Whether the function is internal. */ - is_internal: boolean; + /** Whether the function is unconstrained. */ + is_unconstrained: boolean; + /** The custom attributes applied to the function. */ + custom_attributes: string[]; /** The ABI of the function. */ abi: Abi; /** The bytecode of the function in base64. */ diff --git a/noir/noir-repo/compiler/wasm/test/fixtures/noir-contract/src/main.nr b/noir/noir-repo/compiler/wasm/test/fixtures/noir-contract/src/main.nr index 95824d09f4b..fc1dc8a5a17 100644 --- a/noir/noir-repo/compiler/wasm/test/fixtures/noir-contract/src/main.nr +++ b/noir/noir-repo/compiler/wasm/test/fixtures/noir-contract/src/main.nr @@ -5,7 +5,7 @@ contract TestContract { [foo::bar(param), param + pub_param] } - open fn openFunction() -> pub Field { + fn someFunction() -> pub Field { 42 } } diff --git a/noir/noir-repo/test_programs/compile_success_contract/simple_contract/src/main.nr b/noir/noir-repo/test_programs/compile_success_contract/simple_contract/src/main.nr index 4ef12cb890d..7412e1386bf 100644 --- a/noir/noir-repo/test_programs/compile_success_contract/simple_contract/src/main.nr +++ b/noir/noir-repo/test_programs/compile_success_contract/simple_contract/src/main.nr @@ -8,9 +8,6 @@ contract Foo { fn quadruple(x: Field) -> pub Field { x * 4 } - open fn skibbidy(x: Field) -> pub Field { - x * 5 - } // Regression for issue #3344 #[contract_library_method] fn foo(x: u8) -> u8 { diff --git a/noir/noir-repo/tooling/nargo/src/artifacts/contract.rs b/noir/noir-repo/tooling/nargo/src/artifacts/contract.rs index d928b09fcb9..020ce49662f 100644 --- a/noir/noir-repo/tooling/nargo/src/artifacts/contract.rs +++ b/noir/noir-repo/tooling/nargo/src/artifacts/contract.rs @@ -1,6 +1,6 @@ use acvm::acir::circuit::Circuit; use noirc_abi::{Abi, ContractEvent}; -use noirc_driver::{CompiledContract, ContractFunction, ContractFunctionType}; +use noirc_driver::{CompiledContract, ContractFunction}; use serde::{Deserialize, Serialize}; use noirc_driver::DebugFile; @@ -43,9 +43,9 @@ impl From for ContractArtifact { pub struct ContractFunctionArtifact { pub name: String, - pub function_type: ContractFunctionType, + pub is_unconstrained: bool, - pub is_internal: bool, + pub custom_attributes: Vec, pub abi: Abi, @@ -66,8 +66,8 @@ impl From for ContractFunctionArtifact { fn from(func: ContractFunction) -> Self { ContractFunctionArtifact { name: func.name, - function_type: func.function_type, - is_internal: func.is_internal, + is_unconstrained: func.is_unconstrained, + custom_attributes: func.custom_attributes, abi: func.abi, bytecode: func.bytecode, debug_symbols: func.debug, diff --git a/yarn-project/circuits.js/.gitignore b/yarn-project/circuits.js/.gitignore new file mode 100644 index 00000000000..6fc41e1039e --- /dev/null +++ b/yarn-project/circuits.js/.gitignore @@ -0,0 +1 @@ +fixtures/*.json diff --git a/yarn-project/circuits.js/fixtures/Benchmarking.test.json b/yarn-project/circuits.js/fixtures/Benchmarking.test.json deleted file mode 100644 index 5927c4d1224..00000000000 --- a/yarn-project/circuits.js/fixtures/Benchmarking.test.json +++ /dev/null @@ -1,3511 +0,0 @@ -{ - "noir_version": "0.23.0+602f23f4fb698cf6e37071936a2a46593a998d08", - "name": "Benchmarking", - "functions": [ - { - "name": "increment_balance", - "function_type": "Open", - "is_internal": false, - "abi": { - "parameters": [ - { - "name": "inputs", - "type": { - "kind": "struct", - "path": "aztec::abi::PublicContextInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "storage_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "portal_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_delegate_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "is_contract_deployment", - "type": { - "kind": "boolean" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "block_header", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::block_header::BlockHeader", - "fields": [ - { - "name": "note_hash_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "nullifier_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "contract_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "l1_to_l2_message_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "archive_root", - "type": { - "kind": "field" - } - }, - { - "name": "public_data_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "global_variables_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "public_global_variables", - "type": { - "kind": "struct", - "path": "aztec::abi::PublicGlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "field" - } - } - ] - } - } - ] - }, - "visibility": "private" - }, - { - "name": "owner", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - }, - { - "name": "value", - "type": { - "kind": "field" - }, - "visibility": "private" - } - ], - "param_witnesses": { - "inputs": [ - { - "start": 0, - "end": 19 - } - ], - "owner": [ - { - "start": 19, - "end": 20 - } - ], - "value": [ - { - "start": 20, - "end": 21 - } - ] - }, - "return_type": { - "abi_type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::public_circuit_public_inputs::PublicCircuitPublicInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "storage_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "portal_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_delegate_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "is_contract_deployment", - "type": { - "kind": "boolean" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "return_values", - "type": { - "kind": "array", - "length": 4, - "type": { - "kind": "field" - } - } - }, - { - "name": "contract_storage_update_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::contrakt::storage_update_request::StorageUpdateRequest", - "fields": [ - { - "name": "storage_slot", - "type": { - "kind": "field" - } - }, - { - "name": "old_value", - "type": { - "kind": "field" - } - }, - { - "name": "new_value", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "contract_storage_reads", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::contrakt::storage_read::StorageRead", - "fields": [ - { - "name": "storage_slot", - "type": { - "kind": "field" - } - }, - { - "name": "current_value", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "public_call_stack_hashes", - "type": { - "kind": "array", - "length": 4, - "type": { - "kind": "field" - } - } - }, - { - "name": "new_note_hashes", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::side_effect::SideEffect", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "new_nullifiers", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::side_effect::SideEffectLinkedToNoteHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "note_hash", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "new_l2_to_l1_msgs", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "field" - } - } - }, - { - "name": "unencrypted_logs_hash", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "field" - } - } - }, - { - "name": "unencrypted_log_preimages_length", - "type": { - "kind": "field" - } - }, - { - "name": "block_header", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::block_header::BlockHeader", - "fields": [ - { - "name": "note_hash_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "nullifier_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "contract_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "l1_to_l2_message_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "archive_root", - "type": { - "kind": "field" - } - }, - { - "name": "public_data_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "global_variables_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "prover_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - } - ] - }, - "visibility": "public" - }, - "return_witnesses": [ - 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210 - ] - }, - "bytecode": "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", - "debug_symbols": "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" - }, - { - "name": "compute_note_hash_and_nullifier", - "function_type": "Unconstrained", - "is_internal": false, - "abi": { - "parameters": [ - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - }, - { - "name": "nonce", - "type": { - "kind": "field" - }, - "visibility": "private" - }, - { - "name": "storage_slot", - "type": { - "kind": "field" - }, - "visibility": "private" - }, - { - "name": "serialized_note", - "type": { - "kind": "array", - "length": 3, - "type": { - "kind": "field" - } - }, - "visibility": "private" - } - ], - "param_witnesses": { - "contract_address": [ - { - "start": 0, - "end": 1 - } - ], - "nonce": [ - { - "start": 1, - "end": 2 - } - ], - "serialized_note": [ - { - "start": 3, - "end": 6 - } - ], - "storage_slot": [ - { - "start": 2, - "end": 3 - } - ] - }, - "return_type": { - "abi_type": { - "kind": "array", - "length": 4, - "type": { - "kind": "field" - } - }, - "visibility": "public" - }, - "return_witnesses": [6, 7, 8, 9] - }, - "bytecode": "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", - "debug_symbols": "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" - }, - { - "name": "broadcast", - "function_type": "Open", - "is_internal": false, - "abi": { - "parameters": [ - { - "name": "inputs", - "type": { - "kind": "struct", - "path": "aztec::abi::PublicContextInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "storage_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "portal_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_delegate_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "is_contract_deployment", - "type": { - "kind": "boolean" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "block_header", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::block_header::BlockHeader", - "fields": [ - { - "name": "note_hash_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "nullifier_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "contract_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "l1_to_l2_message_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "archive_root", - "type": { - "kind": "field" - } - }, - { - "name": "public_data_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "global_variables_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "public_global_variables", - "type": { - "kind": "struct", - "path": "aztec::abi::PublicGlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "field" - } - } - ] - } - } - ] - }, - "visibility": "private" - }, - { - "name": "owner", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - } - ], - "param_witnesses": { - "inputs": [ - { - "start": 0, - "end": 19 - } - ], - "owner": [ - { - "start": 19, - "end": 20 - } - ] - }, - "return_type": { - "abi_type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::public_circuit_public_inputs::PublicCircuitPublicInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "storage_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "portal_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_delegate_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "is_contract_deployment", - "type": { - "kind": "boolean" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "return_values", - "type": { - "kind": "array", - "length": 4, - "type": { - "kind": "field" - } - } - }, - { - "name": "contract_storage_update_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::contrakt::storage_update_request::StorageUpdateRequest", - "fields": [ - { - "name": "storage_slot", - "type": { - "kind": "field" - } - }, - { - "name": "old_value", - "type": { - "kind": "field" - } - }, - { - "name": "new_value", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "contract_storage_reads", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::contrakt::storage_read::StorageRead", - "fields": [ - { - "name": "storage_slot", - "type": { - "kind": "field" - } - }, - { - "name": "current_value", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "public_call_stack_hashes", - "type": { - "kind": "array", - "length": 4, - "type": { - "kind": "field" - } - } - }, - { - "name": "new_note_hashes", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::side_effect::SideEffect", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "new_nullifiers", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::side_effect::SideEffectLinkedToNoteHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "note_hash", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "new_l2_to_l1_msgs", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "field" - } - } - }, - { - "name": "unencrypted_logs_hash", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "field" - } - } - }, - { - "name": "unencrypted_log_preimages_length", - "type": { - "kind": "field" - } - }, - { - "name": "block_header", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::block_header::BlockHeader", - "fields": [ - { - "name": "note_hash_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "nullifier_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "contract_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "l1_to_l2_message_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "archive_root", - "type": { - "kind": "field" - } - }, - { - "name": "public_data_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "global_variables_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "prover_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - } - ] - }, - "visibility": "public" - }, - "return_witnesses": [ - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, - 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209 - ] - }, - "bytecode": "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", - "debug_symbols": "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" - }, - { - "name": "constructor", - "function_type": "Secret", - "is_internal": false, - "abi": { - "parameters": [ - { - "name": "inputs", - "type": { - "kind": "struct", - "path": "aztec::abi::PrivateContextInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "storage_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "portal_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_delegate_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "is_contract_deployment", - "type": { - "kind": "boolean" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "block_header", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::block_header::BlockHeader", - "fields": [ - { - "name": "note_hash_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "nullifier_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "contract_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "l1_to_l2_message_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "archive_root", - "type": { - "kind": "field" - } - }, - { - "name": "public_data_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "global_variables_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_deployment_data", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::contrakt::deployment_data::ContractDeploymentData", - "fields": [ - { - "name": "deployer_public_key", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::grumpkin_point::GrumpkinPoint", - "fields": [ - { - "name": "x", - "type": { - "kind": "field" - } - }, - { - "name": "y", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "constructor_vk_hash", - "type": { - "kind": "field" - } - }, - { - "name": "function_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "contract_address_salt", - "type": { - "kind": "field" - } - }, - { - "name": "portal_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "private_global_variables", - "type": { - "kind": "struct", - "path": "aztec::abi::PrivateGlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - } - ] - } - } - ] - }, - "visibility": "private" - } - ], - "param_witnesses": { - "inputs": [ - { - "start": 0, - "end": 23 - } - ] - }, - "return_type": { - "abi_type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "storage_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "portal_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_delegate_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "is_contract_deployment", - "type": { - "kind": "boolean" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "return_values", - "type": { - "kind": "array", - "length": 4, - "type": { - "kind": "field" - } - } - }, - { - "name": "read_requests", - "type": { - "kind": "array", - "length": 32, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::side_effect::SideEffect", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "new_note_hashes", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::side_effect::SideEffect", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "new_nullifiers", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::side_effect::SideEffectLinkedToNoteHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "note_hash", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "private_call_stack_hashes", - "type": { - "kind": "array", - "length": 4, - "type": { - "kind": "field" - } - } - }, - { - "name": "public_call_stack_hashes", - "type": { - "kind": "array", - "length": 4, - "type": { - "kind": "field" - } - } - }, - { - "name": "new_l2_to_l1_msgs", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "field" - } - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "encrypted_logs_hash", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "field" - } - } - }, - { - "name": "unencrypted_logs_hash", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "field" - } - } - }, - { - "name": "encrypted_log_preimages_length", - "type": { - "kind": "field" - } - }, - { - "name": "unencrypted_log_preimages_length", - "type": { - "kind": "field" - } - }, - { - "name": "block_header", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::block_header::BlockHeader", - "fields": [ - { - "name": "note_hash_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "nullifier_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "contract_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "l1_to_l2_message_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "archive_root", - "type": { - "kind": "field" - } - }, - { - "name": "public_data_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "global_variables_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_deployment_data", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::contrakt::deployment_data::ContractDeploymentData", - "fields": [ - { - "name": "deployer_public_key", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::grumpkin_point::GrumpkinPoint", - "fields": [ - { - "name": "x", - "type": { - "kind": "field" - } - }, - { - "name": "y", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "constructor_vk_hash", - "type": { - "kind": "field" - } - }, - { - "name": "function_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "contract_address_salt", - "type": { - "kind": "field" - } - }, - { - "name": "portal_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "public" - }, - "return_witnesses": [ - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212 - ] - }, - "bytecode": "H4sIAAAAAAAA/+Xd5XNUVxzG8U2yu6l7CU5wh9XsXdzdqtQLWzb1lir1UupOlXopdaeutLTUvcAfxPMMm5m8gFeczHDme2eeyUxe3NnP3rtXz/n9dqdSqR2pvUuT0qy0KO3d/udlRuNv7sCWfFrrSO9jvcVcR6lUrxTq+WJ+da5QrSXlXKlc60jySb6clNcUkmKxnpSSSrVWreSq+VKxnu8sV4udjRWnw33GXE+4M1pHpgfcmYPcndU6sj3gzgZ0d+33rd32+9R+9v8D/dxtgbdX19IceLuFNPeOxNwU0NwnEnNzQHPfSMwtAc39IjGnA5r7R2LOBDQPiMScDWgeGIm5NaB5UCTmtoDmdqB5MNA8BGgeCjQPA5qHA80jgOaRQPMooHk00DwGaB4LNI8DmscDzROA5olAcw5ozgPNBaC5CDSXgOYy0NwBNFeA5gRorgLNk4DmyUDzFKB5KtA8DWieDjTPAJpnAs2zgObZQPMcoHku0DwPaJ4PNC8AmhcCzYuA5sVA8xKgeSnQvAxoXg40rwCaTwKaTwaaTwGaTwWaTwOaTweaVwLNZwDNZwLNZwHNZwPN5wDN5wLN5wHN5wPNq4Dm1UBzDWi+AGheAzTXgeZOoPlCoPkioPlioPkSoPlSoPkyoPlyoPkKoPlKoHkt0HwV0Hw10HwN0Hwt0Hwd0Hw90LwOaL4BaL4RaL4JaL4ZaL4FaL4VaL4NaL4daF4PNN8BNG8Amu8Emu8Cmu8Gmu8Bmu8Fmu8Dmu8Hmh8Amh8Emh8Cmh8Gmh8Bmh8FmjcCzY8BzY8DzU8AzU8CzU8BzU8DzZuA5meA5meB5ueA5ueB5heA5heB5peA5peB5s1A8ytA8xag+VWg+TWg+XWg+Q2g+U2g+S2g+W2g+R2g+V2g+T2g+X2g+QOg+UOgeSvQ/BHQ/DHQ/AnQ/CnQ/BnQ/DnQ/AXQ/CXQ/BXQ/DXQ/A3Q/C3QvA1o/i4Sc2tA8/fA7bwdaP4BaP4RaN4BNP8ENP8cifmQgOZfIjEfGtD8ayTmwwKaf4vEfHhA8++RmI8IaP4jEvORAc1/RmI+KqD5r0jMRwc0/x2J+ZiA5n8iMR8b0PxvJObjApr/i8R8fEDz/5GYTwho3hmJ+cSA5l2RmHsFNO8OaG7rZm5quFuUtJJRsoqfX/q+0PdJvm/wdbSvK32d5esOn4d9XvJx2sct/469X3s79+q2/m2Nv72VPkpfpZ/SXxmgDFQGKe3KYGWIMlQZpgxXRigjlVHKaGWMMlYZp4xXJigT/Z0oeaXg71opKWWlQ6koiVJVJimTlSnKVGWaMr3x3c5UZimzlTnKXGWeMl9ZoCxUFimLlSXKUmWZslxZobj/vPuxuz+5+3W7f7X7Oa9U3O/X/W/dD9b9Ud0v1P0z3U/S/RVXKe6/V1Pcn839yty/y/2s3N/J/Y7c/8f9cNwfxv1S3D/E/TTcX2Kt4v4Drsfv+vSu1+765a7nvU5xvWfXP3Y9YNfHdb1Y1091PVHX11yvuP7iBsX1+VyvzvXbXM/M9b1c78r1n1wPyfWBXC/H9WNcT8X1RTYqrj/hegyuT+D5+p6/7vncmxTP9/X8V88H9fxIzxf0/DnPJ/P8qs2K599sUTw/w/MVPH7f49k9vtvjnT3+1+NhPT7U4yU9ftDj6Ty+bKvi8Ucej+PxKR6v4fELfp/v99t+3+v3n34f6Pdjfl/kfdPvE/x8fbvi569+Hunnc35e5ec3fp7h+3vf7/r+z/dDvj/w9bKvH3095esLn299/vHx2Mcn/167lj1HMZVAULsAAA==", - "debug_symbols": "q1bKyU9OLMnMzytWsqqurQUA" - }, - { - "name": "recreate_note", - "function_type": "Secret", - "is_internal": false, - "abi": { - "parameters": [ - { - "name": "inputs", - "type": { - "kind": "struct", - "path": "aztec::abi::PrivateContextInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "storage_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "portal_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_delegate_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "is_contract_deployment", - "type": { - "kind": "boolean" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "block_header", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::block_header::BlockHeader", - "fields": [ - { - "name": "note_hash_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "nullifier_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "contract_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "l1_to_l2_message_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "archive_root", - "type": { - "kind": "field" - } - }, - { - "name": "public_data_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "global_variables_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_deployment_data", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::contrakt::deployment_data::ContractDeploymentData", - "fields": [ - { - "name": "deployer_public_key", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::grumpkin_point::GrumpkinPoint", - "fields": [ - { - "name": "x", - "type": { - "kind": "field" - } - }, - { - "name": "y", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "constructor_vk_hash", - "type": { - "kind": "field" - } - }, - { - "name": "function_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "contract_address_salt", - "type": { - "kind": "field" - } - }, - { - "name": "portal_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "private_global_variables", - "type": { - "kind": "struct", - "path": "aztec::abi::PrivateGlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - } - ] - } - } - ] - }, - "visibility": "private" - }, - { - "name": "owner", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - }, - { - "name": "index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - "visibility": "private" - } - ], - "param_witnesses": { - "index": [ - { - "start": 24, - "end": 25 - } - ], - "inputs": [ - { - "start": 0, - "end": 23 - } - ], - "owner": [ - { - "start": 23, - "end": 24 - } - ] - }, - "return_type": { - "abi_type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "storage_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "portal_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_delegate_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "is_contract_deployment", - "type": { - "kind": "boolean" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "return_values", - "type": { - "kind": "array", - "length": 4, - "type": { - "kind": "field" - } - } - }, - { - "name": "read_requests", - "type": { - "kind": "array", - "length": 32, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::side_effect::SideEffect", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "new_note_hashes", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::side_effect::SideEffect", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "new_nullifiers", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::side_effect::SideEffectLinkedToNoteHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "note_hash", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "private_call_stack_hashes", - "type": { - "kind": "array", - "length": 4, - "type": { - "kind": "field" - } - } - }, - { - "name": "public_call_stack_hashes", - "type": { - "kind": "array", - "length": 4, - "type": { - "kind": "field" - } - } - }, - { - "name": "new_l2_to_l1_msgs", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "field" - } - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "encrypted_logs_hash", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "field" - } - } - }, - { - "name": "unencrypted_logs_hash", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "field" - } - } - }, - { - "name": "encrypted_log_preimages_length", - "type": { - "kind": "field" - } - }, - { - "name": "unencrypted_log_preimages_length", - "type": { - "kind": "field" - } - }, - { - "name": "block_header", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::block_header::BlockHeader", - "fields": [ - { - "name": "note_hash_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "nullifier_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "contract_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "l1_to_l2_message_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "archive_root", - "type": { - "kind": "field" - } - }, - { - "name": "public_data_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "global_variables_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_deployment_data", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::contrakt::deployment_data::ContractDeploymentData", - "fields": [ - { - "name": "deployer_public_key", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::grumpkin_point::GrumpkinPoint", - "fields": [ - { - "name": "x", - "type": { - "kind": "field" - } - }, - { - "name": "y", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "constructor_vk_hash", - "type": { - "kind": "field" - } - }, - { - "name": "function_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "contract_address_salt", - "type": { - "kind": "field" - } - }, - { - "name": "portal_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "public" - }, - "return_witnesses": [ - 6072, 6073, 6074, 6075, 6076, 6077, 6078, 6079, 6080, 6081, 6082, 6083, 6084, 6085, 6086, 6087, 6088, 6089, - 6090, 6091, 6092, 6093, 6094, 6095, 6096, 6097, 6098, 6099, 6100, 6101, 6102, 6103, 6104, 6105, 6106, 6107, - 6108, 6109, 6110, 6111, 6112, 6113, 6114, 6115, 6116, 6117, 6118, 6119, 6120, 6121, 6122, 6123, 6124, 6125, - 6126, 6127, 6128, 6129, 6130, 6131, 6132, 6133, 6134, 6135, 6136, 6137, 6138, 6139, 6140, 6141, 6142, 6143, - 6144, 6145, 6146, 6147, 6148, 6149, 6150, 6151, 6152, 6153, 6154, 6155, 6156, 6157, 6158, 6159, 6160, 6161, - 6162, 6163, 6164, 6165, 6166, 6167, 6168, 6169, 6170, 6171, 6172, 6173, 6174, 6175, 6176, 6177, 6178, 6179, - 6180, 6181, 6182, 6183, 6184, 6185, 6186, 6187, 6188, 6189, 6190, 6191, 6192, 6193, 6194, 6195, 6196, 6197, - 6198, 6199, 6200, 6201, 6202, 6203, 6204, 6205, 6206, 6207, 6208, 6209, 6210, 6211, 6212, 6213, 6214, 6215, - 6216, 6217, 6218, 6219, 6220, 6221, 6222, 6223, 6224, 6225, 6226, 6227, 6228, 6229, 6230, 6231, 6232, 6233, - 6234, 6235, 6236, 6237, 6238, 6239, 6240, 6241, 6242, 6243, 6244, 6245, 6246, 6247, 6248, 6249, 6250, 6251, - 6252, 6253, 6254, 6255, 6256, 6257, 6258, 6259, 6260 - ] - }, - "bytecode": "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", - "debug_symbols": "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" - }, - { - "name": "create_note", - "function_type": "Secret", - "is_internal": false, - "abi": { - "parameters": [ - { - "name": "inputs", - "type": { - "kind": "struct", - "path": "aztec::abi::PrivateContextInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "storage_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "portal_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_delegate_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "is_contract_deployment", - "type": { - "kind": "boolean" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "block_header", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::block_header::BlockHeader", - "fields": [ - { - "name": "note_hash_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "nullifier_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "contract_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "l1_to_l2_message_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "archive_root", - "type": { - "kind": "field" - } - }, - { - "name": "public_data_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "global_variables_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_deployment_data", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::contrakt::deployment_data::ContractDeploymentData", - "fields": [ - { - "name": "deployer_public_key", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::grumpkin_point::GrumpkinPoint", - "fields": [ - { - "name": "x", - "type": { - "kind": "field" - } - }, - { - "name": "y", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "constructor_vk_hash", - "type": { - "kind": "field" - } - }, - { - "name": "function_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "contract_address_salt", - "type": { - "kind": "field" - } - }, - { - "name": "portal_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "private_global_variables", - "type": { - "kind": "struct", - "path": "aztec::abi::PrivateGlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - } - ] - } - } - ] - }, - "visibility": "private" - }, - { - "name": "owner", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - }, - { - "name": "value", - "type": { - "kind": "field" - }, - "visibility": "private" - } - ], - "param_witnesses": { - "inputs": [ - { - "start": 0, - "end": 23 - } - ], - "owner": [ - { - "start": 23, - "end": 24 - } - ], - "value": [ - { - "start": 24, - "end": 25 - } - ] - }, - "return_type": { - "abi_type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "storage_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "portal_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_delegate_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "is_contract_deployment", - "type": { - "kind": "boolean" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "return_values", - "type": { - "kind": "array", - "length": 4, - "type": { - "kind": "field" - } - } - }, - { - "name": "read_requests", - "type": { - "kind": "array", - "length": 32, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::side_effect::SideEffect", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "new_note_hashes", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::side_effect::SideEffect", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "new_nullifiers", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::side_effect::SideEffectLinkedToNoteHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "note_hash", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "private_call_stack_hashes", - "type": { - "kind": "array", - "length": 4, - "type": { - "kind": "field" - } - } - }, - { - "name": "public_call_stack_hashes", - "type": { - "kind": "array", - "length": 4, - "type": { - "kind": "field" - } - } - }, - { - "name": "new_l2_to_l1_msgs", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "field" - } - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "encrypted_logs_hash", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "field" - } - } - }, - { - "name": "unencrypted_logs_hash", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "field" - } - } - }, - { - "name": "encrypted_log_preimages_length", - "type": { - "kind": "field" - } - }, - { - "name": "unencrypted_log_preimages_length", - "type": { - "kind": "field" - } - }, - { - "name": "block_header", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::block_header::BlockHeader", - "fields": [ - { - "name": "note_hash_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "nullifier_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "contract_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "l1_to_l2_message_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "archive_root", - "type": { - "kind": "field" - } - }, - { - "name": "public_data_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "global_variables_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_deployment_data", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::contrakt::deployment_data::ContractDeploymentData", - "fields": [ - { - "name": "deployer_public_key", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::grumpkin_point::GrumpkinPoint", - "fields": [ - { - "name": "x", - "type": { - "kind": "field" - } - }, - { - "name": "y", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "constructor_vk_hash", - "type": { - "kind": "field" - } - }, - { - "name": "function_tree_root", - "type": { - "kind": "field" - } - }, - { - "name": "contract_address_salt", - "type": { - "kind": "field" - } - }, - { - "name": "portal_contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "public" - }, - "return_witnesses": [ - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, - 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - 232, 233, 234 - ] - }, - "bytecode": "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", - "debug_symbols": "7ZjdbhoxEIXfxdcIzdjj+eFVqlygNpUiRaQq3CHevQtdex1q4XRXVLsNVwjpjP35eOyZ9dG9vn3dHl7ednu3ObroNl+Obv9juzv/2x+2Pw9uAyv3vPvW/Z5W7vvL67PbBDut/pB5gNgrPXjJYgo1cSBKYgLMYkSsqBFM0tiIcJ6+0D+tHC+UW/4ZN4kmcQw6lVtr3CiS0FEs3KY3n7QmfmC3MTQ2KxqEyTgIJMMU1AAKaEkcuJE0pnlgKAeWCzkultwvljwslpzq5JzJFbQxPiUW0+HYIUtFK5QuMIlUaO3CEiezdNZpdhHtHc15Br77DHL3GXT6DKA+z+ChsWddsmU1FTtM1Q32nDa4uINVK1LO1zXTcDjMV6QdQei1AUneJU4FmGI2kAxb6mYpsP/F8JiIBaBhuE9nOhSj2qg2w8Oc/VNJ/lmRhZ1/Z3JcCrlek/s5k1vM5GaNnFVJrTobFOPCZZnhcyyT5rxMBLGhXunthQbmZEpgi4272XNMHJ5FG+oI2ItjHI4yx4uF8WHhBywUzCUiSmnhzbYSQyjGhVFFgh/785H9yV8UWpTwPsXlYeFUC2fdWy/Dwll3y4uwMMy6Yb6rhZrfNzW2PvMCp4pCxVuC9M8a62rBtwF9WObv1wcP6/ozTrRU6BiLzyZKQTQmqEpHGnMDM1RI6XvAdfV+D9lgQr4+i7TWETE2Iqb+XtoKwr8NCp11VRsoHw4yvUqGc5COCaoaEfMmcfFp3GXr0+n0Cw==" - } - ], - "events": [], - "file_map": { - "18": { - "source": "use crate::grumpkin_scalar::GrumpkinScalar;\nuse crate::scalar_mul::fixed_base_embedded_curve;\n\npub fn grumpkin_fixed_base(scalar: GrumpkinScalar) -> [Field; 2] {\n // TODO: this should use both the low and high limbs to do the scalar multiplication\n fixed_base_embedded_curve(scalar.low, scalar.high)\n}\n", - "path": "std/grumpkin_scalar_mul.nr" - }, - "28": { - "source": "struct Option {\n _is_some: bool,\n _value: T,\n}\n\nimpl Option {\n /// Constructs a None value\n pub fn none() -> Self {\n Self { _is_some: false, _value: crate::unsafe::zeroed() }\n }\n\n /// Constructs a Some wrapper around the given value\n pub fn some(_value: T) -> Self {\n Self { _is_some: true, _value }\n }\n\n /// True if this Option is None\n pub fn is_none(self) -> bool {\n !self._is_some\n }\n\n /// True if this Option is Some\n pub fn is_some(self) -> bool {\n self._is_some\n }\n\n /// Asserts `self.is_some()` and returns the wrapped value.\n pub fn unwrap(self) -> T {\n assert(self._is_some);\n self._value\n }\n\n /// Returns the inner value without asserting `self.is_some()`\n /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n /// only that it will be of type `T`.\n pub fn unwrap_unchecked(self) -> T {\n self._value\n }\n\n /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n pub fn unwrap_or(self, default: T) -> T {\n if self._is_some {\n self._value\n } else {\n default\n }\n }\n\n /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n /// a default value.\n pub fn unwrap_or_else(self, default: fn[Env]() -> T) -> T {\n if self._is_some {\n self._value\n } else {\n default()\n }\n }\n\n /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n pub fn map(self, f: fn[Env](T) -> U) -> Option {\n if self._is_some {\n Option::some(f(self._value))\n } else {\n Option::none()\n }\n }\n\n /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n pub fn map_or(self, default: U, f: fn[Env](T) -> U) -> U {\n if self._is_some {\n f(self._value)\n } else {\n default\n }\n }\n\n /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n pub fn map_or_else(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n if self._is_some {\n f(self._value)\n } else {\n default()\n }\n }\n\n /// Returns None if self is None. Otherwise, this returns `other`.\n pub fn and(self, other: Self) -> Self {\n if self.is_none() {\n Option::none()\n } else {\n other\n }\n }\n\n /// If self is None, this returns None. Otherwise, this calls the given function\n /// with the Some value contained within self, and returns the result of that call.\n ///\n /// In some languages this function is called `flat_map` or `bind`.\n pub fn and_then(self, f: fn[Env](T) -> Option) -> Option {\n if self._is_some {\n f(self._value)\n } else {\n Option::none()\n }\n }\n\n /// If self is Some, return self. Otherwise, return `other`.\n pub fn or(self, other: Self) -> Self {\n if self._is_some {\n self\n } else {\n other\n }\n }\n\n /// If self is Some, return self. Otherwise, return `default()`.\n pub fn or_else(self, default: fn[Env]() -> Self) -> Self {\n if self._is_some {\n self\n } else {\n default()\n }\n }\n\n // If only one of the two Options is Some, return that option.\n // Otherwise, if both options are Some or both are None, None is returned.\n pub fn xor(self, other: Self) -> Self {\n if self._is_some {\n if other._is_some {\n Option::none()\n } else {\n self\n }\n } else if other._is_some {\n other\n } else {\n Option::none()\n }\n }\n\n /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n /// Otherwise, this returns `None`\n pub fn filter(self, predicate: fn[Env](T) -> bool) -> Self {\n if self._is_some {\n if predicate(self._value) {\n self\n } else {\n Option::none()\n }\n } else {\n Option::none()\n }\n }\n\n /// Flattens an Option> into a Option.\n /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n pub fn flatten(option: Option>) -> Option {\n if option._is_some {\n option._value\n } else {\n Option::none()\n }\n }\n}\n", - "path": "std/option.nr" - }, - "39": { - "source": "// A contract used for running benchmarks.\n// We should try to change this contract as little as possible, since any modification\n// would alter the metrics we're capturing in the benchmarks, and we want to keep the\n// subject being tested as unmodified as possible so we can detect metric changes that\n// arise from code changes.\n\ncontract Benchmarking {\n use dep::value_note::{\n utils::{increment, decrement},\n value_note::{VALUE_NOTE_LEN, ValueNote, ValueNoteMethods},\n };\n\n use dep::aztec::{\n protocol_types::{\n abis::function_selector::FunctionSelector,\n address::AztecAddress,\n },\n context::{Context},\n note::{utils as note_utils, note_getter_options::NoteGetterOptions, note_header::NoteHeader},\n log::emit_unencrypted_log,\n state_vars::{map::Map, public_state::PublicState, set::Set},\n types::type_serialization::field_serialization::{FieldSerializationMethods, FIELD_SERIALIZED_LEN},\n };\n\n struct Storage {\n notes: Map>,\n balances: Map>,\n }\n\n impl Storage {\n fn init(context: Context) -> pub Self {\n Storage {\n notes: Map::new(context, 1, |context, slot| { Set::new(context, slot, ValueNoteMethods) }),\n balances: Map::new(context, 2, |context, slot| { PublicState::new(context, slot, FieldSerializationMethods) }),\n }\n }\n }\n\n #[aztec(private)]\n fn constructor() {}\n\n // Creates a new value note for the target owner. Use this method to seed an initial set of notes.\n #[aztec(private)]\n fn create_note(owner: AztecAddress, value: Field) {\n increment(storage.notes.at(owner), value, owner);\n }\n\n // Deletes a note at a specific index in the set and creates a new one with the same value.\n // We explicitly pass in the note index so we can ensure we consume different notes when sending\n // multiple txs that will land on the same block.\n // See https://discourse.aztec.network/t/utxo-concurrency-issues-for-private-state/635\n // by @rahul-kothari for a full explanation on why this is needed.\n #[aztec(private)]\n fn recreate_note(owner: AztecAddress, index: u32) {\n let owner_notes = storage.notes.at(owner);\n let getter_options = NoteGetterOptions::new().set_limit(1).set_offset(index);\n let notes = owner_notes.get_notes(getter_options);\n let note = notes[0].unwrap_unchecked();\n owner_notes.remove(note);\n increment(owner_notes, note.value, owner);\n }\n\n // Reads and writes to public storage and enqueues a call to another public function.\n #[aztec(public)]\n fn increment_balance(owner: AztecAddress, value: Field) {\n let current = storage.balances.at(owner).read();\n storage.balances.at(owner).write(current + value);\n let _callStackItem1 = context.call_public_function(\n context.this_address(),\n FunctionSelector::from_signature(\"broadcast((Field))\"),\n [owner.to_field()]\n );\n }\n\n // Emits a public log.\n #[aztec(public)]\n fn broadcast(owner: AztecAddress) {\n emit_unencrypted_log(&mut context, storage.balances.at(owner).read());\n }\n\n unconstrained fn compute_note_hash_and_nullifier(\n contract_address: AztecAddress,\n nonce: Field,\n storage_slot: Field,\n serialized_note: [Field; VALUE_NOTE_LEN]\n ) -> pub [Field; 4] {\n let note_header = NoteHeader::new(contract_address, nonce, storage_slot);\n note_utils::compute_note_hash_and_nullifier(ValueNoteMethods, note_header, serialized_note)\n }\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/noir-contracts/contracts/benchmarking_contract/src/main.nr" - }, - "40": { - "source": "use crate::{\n abi::{\n PrivateContextInputs,\n PublicContextInputs,\n },\n key::nullifier_key::validate_nullifier_key_against_address,\n messaging::process_l1_to_l2_message,\n oracle::{\n arguments,\n call_private_function::call_private_function_internal,\n public_call::call_public_function_internal,\n enqueue_public_function_call::enqueue_public_function_call_internal,\n context::get_portal_address,\n get_block_header::get_block_header,\n nullifier_key::get_nullifier_key_pair,\n },\n types::vec::BoundedVec,\n utils::Reader,\n};\nuse dep::protocol_types::{\n abis::{\n block_header::BlockHeader,\n call_context::CallContext,\n function_data::FunctionData,\n function_selector::FunctionSelector,\n private_circuit_public_inputs::PrivateCircuitPublicInputs,\n public_circuit_public_inputs::PublicCircuitPublicInputs,\n call_stack_item::PrivateCallStackItem,\n call_stack_item::PublicCallStackItem,\n side_effect::{SideEffect, SideEffectLinkedToNoteHash},\n },\n address::{\n AztecAddress,\n EthAddress,\n },\n constants::{\n MAX_NEW_NOTE_HASHES_PER_CALL,\n MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n MAX_NEW_NULLIFIERS_PER_CALL,\n MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,\n MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n MAX_PUBLIC_DATA_READS_PER_CALL,\n MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,\n MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,\n NUM_FIELDS_PER_SHA256,\n RETURN_VALUES_LENGTH,\n },\n contrakt::{\n deployment_data::ContractDeploymentData,\n storage_read::StorageRead,\n storage_update_request::StorageUpdateRequest,\n },\n hash::hash_args,\n grumpkin_point::GrumpkinPoint,\n};\nuse dep::std::{\n grumpkin_scalar::GrumpkinScalar,\n option::Option,\n};\n\n// TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n// use dep::std::collections::vec::Vec;\n\n// When finished, one can call .finish() to convert back to the abi\nstruct PrivateContext {\n // docs:start:private-context\n inputs: PrivateContextInputs,\n side_effect_counter: u32,\n\n args_hash : Field,\n return_values : BoundedVec,\n\n read_requests: BoundedVec,\n\n new_note_hashes: BoundedVec,\n new_nullifiers: BoundedVec,\n\n private_call_stack_hashes : BoundedVec,\n public_call_stack_hashes : BoundedVec,\n new_l2_to_l1_msgs : BoundedVec,\n // docs:end:private-context\n\n block_header: BlockHeader,\n\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n // encrypted_logs_preimages: Vec,\n // unencrypted_logs_preimages: Vec,\n}\n\nimpl PrivateContext {\n pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n PrivateContext {\n inputs: inputs,\n side_effect_counter: inputs.call_context.start_side_effect_counter,\n\n args_hash: args_hash,\n return_values: BoundedVec::new();\n call_public_function_internal(\n contract_address, \n function_selector, \n args_hash,\n )\n }\n\n pub fn call_public_function_no_args(\n _self: Self,\n contract_address: AztecAddress, \n function_selector: FunctionSelector,\n ) -> [Field; RETURN_VALUES_LENGTH] {\n call_public_function_internal(\n contract_address, \n function_selector, \n 0,\n )\n }\n\n}\n\nstruct Context {\n private: Option<&mut PrivateContext>,\n public: Option<&mut PublicContext>,\n}\n\nimpl Context {\n pub fn private(context: &mut PrivateContext) -> Context {\n Context {\n private: Option::some(context),\n public: Option::none()\n }\n }\n\n pub fn public(context: &mut PublicContext) -> Context {\n Context {\n public: Option::some(context),\n private: Option::none()\n }\n }\n\n pub fn none() -> Context {\n Context {\n public: Option::none(),\n private: Option::none()\n }\n }\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/aztec/src/context.nr" - }, - "43": { - "source": "use dep::protocol_types::{\n abis::{\n block_header::BlockHeader,\n call_context::CallContext,\n private_circuit_public_inputs::PrivateCircuitPublicInputs,\n public_circuit_public_inputs::PublicCircuitPublicInputs,\n },\n contrakt::deployment_data::ContractDeploymentData,\n hash::hash_args,\n};\n\n// docs:start:private-global-variables\nstruct PrivateGlobalVariables {\n chain_id: Field,\n version: Field,\n}\n// docs:end:private-global-variables\n\nimpl PrivateGlobalVariables {\n fn serialize(self) -> [Field; 2] {\n [self.chain_id, self.version]\n }\n}\n\n// docs:start:public-global-variables\nstruct PublicGlobalVariables {\n chain_id: Field,\n version: Field,\n block_number: Field,\n timestamp: Field,\n}\n// docs:end:public-global-variables\n\nimpl PublicGlobalVariables {\n fn serialize(self) -> [Field; 4] {\n [self.chain_id, self.version, self.block_number, self.timestamp]\n }\n}\n\n// PrivateContextInputs are expected to be provided to each private function\n// docs:start:private-context-inputs\nstruct PrivateContextInputs {\n call_context : CallContext,\n block_header: BlockHeader,\n contract_deployment_data: ContractDeploymentData,\n private_global_variables: PrivateGlobalVariables,\n}\n// docs:end:private-context-inputs\n\n// PublicContextInputs are expected to be provided to each public function\n// docs:start:public-context-inputs\nstruct PublicContextInputs {\n call_context: CallContext,\n block_header: BlockHeader,\n\n public_global_variables: PublicGlobalVariables,\n}\n// docs:end:public-context-inputs\n\nstruct Hasher {\n fields: [Field],\n}\n\nimpl Hasher {\n pub fn new()-> Self {\n Self { fields: [] }\n }\n\n pub fn add(&mut self, field: Field) {\n self.fields = self.fields.push_back(field);\n }\n\n pub fn add_multiple(&mut self, fields: [Field; N]) {\n for i in 0..N {\n self.fields = self.fields.push_back(fields[i]);\n }\n }\n\n pub fn hash(self) -> Field {\n hash_args(self.fields)\n }\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/aztec/src/abi.nr" - }, - "47": { - "source": "use dep::std::option::Option;\nuse crate::abi::PublicContextInputs;\nuse dep::protocol_types::{\n constants::{MAX_NOTES_PER_PAGE, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL},\n abis::side_effect::{SideEffect, SideEffectLinkedToNoteHash},\n};\nuse crate::context::{PrivateContext, PublicContext, Context};\nuse crate::note::{\n lifecycle::{create_note, create_note_hash_from_public, destroy_note},\n note_getter::{get_notes, view_notes},\n note_getter_options::NoteGetterOptions,\n note_header::NoteHeader,\n note_interface::NoteInterface,\n note_viewer_options::NoteViewerOptions,\n utils::compute_note_hash_for_read_or_nullify,\n};\n\n// docs:start:struct\nstruct Set {\n context: Context,\n storage_slot: Field,\n note_interface: NoteInterface,\n}\n// docs:end:struct\n\nimpl Set {\n // docs:start:new\n pub fn new(\n context: Context,\n storage_slot: Field,\n note_interface: NoteInterface,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n Set {\n context,\n storage_slot,\n note_interface,\n }\n }\n // docs:end:new\n\n // docs:start:insert\n pub fn insert(self,\n note: &mut Note,\n broadcast: bool,\n ) {\n create_note(\n self.context.private.unwrap(),\n self.storage_slot,\n note,\n self.note_interface,\n broadcast,\n );\n }\n // docs:end:insert\n\n // docs:start:insert_from_public\n pub fn insert_from_public(self, note: &mut Note) {\n create_note_hash_from_public(\n self.context.public.unwrap(),\n self.storage_slot,\n note,\n self.note_interface,\n );\n }\n // docs:end:insert_from_public\n \n // DEPRECATED\n fn assert_contains_and_remove(_self: Self, _note: &mut Note, _nonce: Field) {\n assert(false, \"`assert_contains_and_remove` has been deprecated. Please call PXE.addNote() to add a note to the database. Then use Set.get_notes() and Set.remove() in your contract to verify and remove a note.\");\n }\n\n // DEPRECATED\n fn assert_contains_and_remove_publicly_created(_self: Self, _note: &mut Note) {\n assert(false, \"`assert_contains_and_remove_publicly_created` has been deprecated. Please call PXE.addNote() to add a note to the database. Then use Set.get_notes() and Set.remove() in your contract to verify and remove a note.\");\n }\n\n // docs:start:remove\n pub fn remove(self, note: Note) {\n let context = self.context.private.unwrap();\n let note_hash = compute_note_hash_for_read_or_nullify(self.note_interface, note);\n let has_been_read = context.read_requests.any(|r: SideEffect| r.value == note_hash);\n assert(has_been_read, \"Can only remove a note that has been read from the set.\");\n\n destroy_note(\n context,\n note,\n self.note_interface,\n );\n }\n // docs:end:remove\n\n // docs:start:get_notes\n pub fn get_notes(\n self,\n options: NoteGetterOptions,\n ) -> [Option; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL] {\n let storage_slot = self.storage_slot;\n let opt_notes = get_notes(\n self.context.private.unwrap(),\n storage_slot,\n self.note_interface,\n options,\n );\n opt_notes\n }\n // docs:end:get_notes\n\n // docs:start:view_notes\n unconstrained pub fn view_notes(\n self,\n options: NoteViewerOptions,\n ) -> [Option; MAX_NOTES_PER_PAGE] {\n view_notes(self.storage_slot, self.note_interface, options)\n }\n // docs:end:view_notes\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/aztec/src/state_vars/set.nr" - }, - "49": { - "source": "use crate::context::{PrivateContext, PublicContext, Context};\nuse dep::std::option::Option;\nuse dep::protocol_types::{\n hash::pedersen_hash,\n traits::{ToField}\n};\n\n// docs:start:map\nstruct Map {\n context: Context,\n storage_slot: Field,\n state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\nimpl Map {\n // docs:start:new\n pub fn new(\n context: Context,\n storage_slot: Field,\n state_var_constructor: fn(Context, Field) -> V,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n Map {\n context,\n storage_slot,\n state_var_constructor,\n }\n }\n // docs:end:new\n\n // docs:start:at\n pub fn at(self, key: K) -> V where K: ToField {\n // TODO(#1204): use a generator index for the storage slot\n let derived_storage_slot = pedersen_hash([self.storage_slot, key.to_field()],0);\n\n let state_var_constructor = self.state_var_constructor;\n state_var_constructor(self.context, derived_storage_slot)\n }\n // docs:end:at\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/aztec/src/state_vars/map.nr" - }, - "50": { - "source": "use crate::context::{Context};\nuse crate::oracle::storage::storage_read;\nuse crate::oracle::storage::storage_write;\nuse crate::types::type_serialization::TypeSerializationInterface;\nuse dep::std::option::Option;\n\n// docs:start:public_mutable_struct\nstruct PublicState {\n context: Context,\n storage_slot: Field,\n serialization_methods: TypeSerializationInterface,\n}\n// docs:end:public_mutable_struct\n\nimpl PublicState {\n // docs:start:public_mutable_struct_new\n pub fn new(\n // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n context: Context,\n storage_slot: Field,\n serialization_methods: TypeSerializationInterface,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n PublicState {\n context,\n storage_slot,\n serialization_methods,\n }\n }\n // docs:end:public_mutable_struct_new\n\n // docs:start:public_mutable_struct_read\n pub fn read(self) -> T {\n assert(self.context.private.is_none(), \"Public state reads only supported in public functions\");\n storage_read(self.storage_slot, self.serialization_methods.deserialize)\n }\n // docs:end:public_mutable_struct_read\n\n // docs:start:public_mutable_struct_write\n pub fn write(self, value: T) {\n assert(self.context.private.is_none(), \"Public state writes only supported in public functions\");\n let serialize = self.serialization_methods.serialize;\n let fields = serialize(value);\n storage_write(self.storage_slot, fields);\n }\n // docs:end:public_mutable_struct_write\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/aztec/src/state_vars/public_mutable.nr" - }, - "56": { - "source": "#[oracle(storageRead)]\nfn storage_read_oracle(_storage_slot: Field, _number_of_elements: Field) -> [Field; N] {}\n\nunconstrained fn storage_read_oracle_wrapper(_storage_slot: Field) -> [Field; N] {\n storage_read_oracle(_storage_slot, N)\n}\n\npub fn storage_read(storage_slot: Field, deserialize: fn([Field; N]) -> T) -> T {\n let fields = storage_read_oracle_wrapper(storage_slot);\n deserialize(fields)\n}\n\n#[oracle(storageWrite)]\nfn storage_write_oracle(_storage_slot: Field, _values: [Field; N]) -> [Field; N] {}\n\n// TODO: Remove return value.\nunconstrained pub fn storage_write(storage_slot: Field, fields: [Field; N]) {\n let _hash = storage_write_oracle(storage_slot, fields);\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/aztec/src/oracle/storage.nr" - }, - "57": { - "source": "use dep::protocol_types::{\n address::AztecAddress,\n constants::NUM_FIELDS_PER_SHA256,\n grumpkin_point::GrumpkinPoint,\n};\n\n// TODO: Should take encrypted data.\n#[oracle(emitEncryptedLog)]\nfn emit_encrypted_log_oracle(\n _contract_address: AztecAddress,\n _storage_slot: Field,\n _encryption_pub_key: GrumpkinPoint,\n _preimage: [Field; N]\n) -> Field {}\n\nunconstrained pub fn emit_encrypted_log(\n contract_address: AztecAddress,\n storage_slot: Field,\n encryption_pub_key: GrumpkinPoint,\n preimage: [Field; N]\n) -> [Field; NUM_FIELDS_PER_SHA256] {\n [emit_encrypted_log_oracle(contract_address, storage_slot, encryption_pub_key, preimage), 0]\n}\n\n#[oracle(emitUnencryptedLog)]\nfn emit_unencrypted_log_oracle(_contract_address: AztecAddress, _event_selector: Field, _message: T) -> Field {}\n\nunconstrained pub fn emit_unencrypted_log(\n contract_address: AztecAddress,\n event_selector: Field,\n message: T\n) -> [Field; NUM_FIELDS_PER_SHA256] {\n // https://github.com/AztecProtocol/aztec-packages/issues/885\n [emit_unencrypted_log_oracle(contract_address, event_selector, message), 0]\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/aztec/src/oracle/logs.nr" - }, - "59": { - "source": "#[oracle(packArguments)]\nfn pack_arguments_oracle(_args: [Field; N]) -> Field {}\n\n// TODO: explain what this does.\nunconstrained pub fn pack_arguments(args: [Field; N]) -> Field {\n pack_arguments_oracle(args)\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/aztec/src/oracle/arguments.nr" - }, - "61": { - "source": "use dep::protocol_types::{\n abis::function_selector::FunctionSelector,\n address::AztecAddress,\n constants::RETURN_VALUES_LENGTH,\n};\n\n#[oracle(callPublicFunction)]\nfn call_public_function_oracle(\n _contract_address: AztecAddress,\n _function_selector: FunctionSelector,\n _args_hash: Field\n) -> [Field; RETURN_VALUES_LENGTH] {}\n\nunconstrained pub fn call_public_function_internal(\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field\n) -> [Field; RETURN_VALUES_LENGTH] {\n call_public_function_oracle(contract_address, function_selector, args_hash)\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/aztec/src/oracle/public_call.nr" - }, - "65": { - "source": "use dep::protocol_types::{\n address::{\n AztecAddress,\n PartialAddress,\n },\n grumpkin_point::GrumpkinPoint,\n};\n\n#[oracle(getPublicKeyAndPartialAddress)]\nfn get_public_key_and_partial_address_oracle(_address: AztecAddress) -> [Field; 3] {}\n\nunconstrained fn get_public_key_and_partial_address_internal(address: AztecAddress) -> [Field; 3] {\n get_public_key_and_partial_address_oracle(address)\n}\n\npub fn get_public_key(address: AztecAddress) -> GrumpkinPoint {\n let result = get_public_key_and_partial_address_internal(address);\n let pub_key = GrumpkinPoint::new(result[0], result[1]);\n let partial_address = PartialAddress::from_field(result[2]);\n\n let calculated_address = AztecAddress::compute(pub_key, partial_address);\n assert(calculated_address.eq(address));\n\n pub_key\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/aztec/src/oracle/get_public_key.nr" - }, - "69": { - "source": "#[oracle(getRandomField)]\nfn rand_oracle() -> Field {}\n\nunconstrained pub fn rand() -> Field {\n rand_oracle()\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/aztec/src/oracle/rand.nr" - }, - "70": { - "source": "use dep::std::option::Option;\nuse crate::note::{\n note_header::NoteHeader,\n note_interface::NoteInterface,\n};\nuse crate::utils::arr_copy_slice;\n\nuse dep::protocol_types::address::AztecAddress;\n\n#[oracle(notifyCreatedNote)]\nfn notify_created_note_oracle(_storage_slot: Field, _serialized_note: [Field; N], _inner_note_hash: Field) -> Field {}\n\nunconstrained pub fn notify_created_note(storage_slot: Field, serialized_note: [Field; N], inner_note_hash: Field) -> Field {\n notify_created_note_oracle(storage_slot, serialized_note, inner_note_hash)\n}\n\n#[oracle(notifyNullifiedNote)]\nfn notify_nullified_note_oracle(_nullifier: Field, _inner_note_hash: Field) -> Field {}\n\nunconstrained pub fn notify_nullified_note(nullifier: Field, inner_note_hash: Field) -> Field {\n notify_nullified_note_oracle(nullifier, inner_note_hash)\n}\n\n#[oracle(getNotes)]\nfn get_notes_oracle(\n _storage_slot: Field,\n _num_selects: u8,\n _select_by: [u8; N],\n _select_values: [Field; N],\n _sort_by: [u8; N],\n _sort_order: [u2; N],\n _limit: u32,\n _offset: u32,\n _return_size: u32,\n _placeholder_fields: [Field; S]\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper(\n storage_slot: Field,\n num_selects: u8,\n select_by: [u8; N],\n select_values: [Field; N],\n sort_by: [u8; N],\n sort_order: [u2; N],\n limit: u32,\n offset: u32,\n mut placeholder_fields: [Field; S]\n) -> [Field; S] {\n let return_size = placeholder_fields.len() as u32;\n get_notes_oracle(\n storage_slot,\n num_selects,\n select_by,\n select_values,\n sort_by,\n sort_order,\n limit,\n offset,\n return_size,\n placeholder_fields\n )\n}\n\nunconstrained pub fn get_notes(\n storage_slot: Field,\n note_interface: NoteInterface,\n num_selects: u8,\n select_by: [u8; M],\n select_values: [Field; M],\n sort_by: [u8; M],\n sort_order: [u2; M],\n limit: u32,\n offset: u32,\n mut placeholder_opt_notes: [Option; S], // TODO: Remove it and use `limit` to initialize the note array.\n placeholder_fields: [Field; NS] // TODO: Remove it and use `limit` to initialize the note array.\n) -> [Option; S] {\n let fields = get_notes_oracle_wrapper(\n storage_slot,\n num_selects,\n select_by,\n select_values,\n sort_by,\n sort_order,\n limit,\n offset,\n placeholder_fields\n );\n let num_notes = fields[0] as u32;\n let contract_address = AztecAddress::from_field(fields[1]);\n let deserialize = note_interface.deserialize;\n let set_header = note_interface.set_header;\n for i in 0..placeholder_opt_notes.len() {\n if i as u32 < num_notes {\n // lengths named as per typescript.\n let return_header_length: Field = 2; // num_notes & contract_address.\n let extra_preimage_length: Field = 2; // nonce & is_transient.\n let read_offset: Field = return_header_length + i * (N + extra_preimage_length);\n let nonce = fields[read_offset];\n let is_transient = fields[read_offset + 1] as bool;\n let header = NoteHeader { contract_address, nonce, storage_slot, is_transient };\n let serialized_note = arr_copy_slice(fields, [0; N], read_offset + 2);\n let mut note = deserialize(serialized_note);\n set_header(&mut note, header);\n placeholder_opt_notes[i] = Option::some(note);\n };\n }\n placeholder_opt_notes\n}\n\n#[oracle(checkNullifierExists)]\nfn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\nunconstrained pub fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/aztec/src/oracle/notes.nr" - }, - "73": { - "source": "use dep::protocol_types::{\n address::AztecAddress,\n grumpkin_point::GrumpkinPoint,\n};\nuse dep::std::grumpkin_scalar::GrumpkinScalar;\n\nstruct KeyPair {\n public_key: GrumpkinPoint,\n secret_key: GrumpkinScalar,\n}\n\n#[oracle(getNullifierKeyPair)]\nfn get_nullifier_key_pair_oracle(_account: AztecAddress) -> [Field; 4] {}\n\nunconstrained fn get_nullifier_key_pair_internal(account: AztecAddress) -> KeyPair {\n let result = get_nullifier_key_pair_oracle(account);\n KeyPair {\n public_key: GrumpkinPoint { x: result[0], y: result[1] },\n secret_key: GrumpkinScalar { high: result[2], low: result[3] }\n }\n}\n\npub fn get_nullifier_key_pair(account: AztecAddress) -> KeyPair {\n get_nullifier_key_pair_internal(account)\n}\n\npub fn get_nullifier_secret_key(account: AztecAddress) -> GrumpkinScalar {\n get_nullifier_key_pair_internal(account).secret_key\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/aztec/src/oracle/nullifier_key.nr" - }, - "76": { - "source": "pub fn arr_copy_slice(src: [T; N], mut dst: [T; M], offset: Field) -> [T; M] {\n for i in 0..dst.len() {\n dst[i] = src[i + offset];\n }\n dst\n}\n\n// TODO(#3470): Copied over from https://github.com/AztecProtocol/aztec-packages/blob/a07c4bd47313be6aa604a63f37857eb0136b41ba/noir-protocol-circuits/crates/rollup-lib/src/base/base_rollup_inputs.nr#L599\n// move to a shared place?\n\n// TODO to radix returns u8, so we cannot use bigger radixes. It'd be ideal to use a radix of the maximum range-constrained integer noir supports\npub fn full_field_less_than(lhs: Field, rhs: Field) -> bool {\n lhs.lt(rhs)\n}\n\npub fn full_field_greater_than(lhs: Field, rhs: Field) -> bool {\n rhs.lt(lhs)\n}\n\nstruct Reader {\n data: [Field; N],\n offset: Field,\n}\n\nimpl Reader {\n pub fn new(data: [Field; N]) -> Self {\n Self { data, offset: 0 }\n }\n\n pub fn read(&mut self) -> Field {\n let result = self.data[self.offset];\n self.offset += 1;\n result\n }\n\n pub fn read_array(&mut self, mut result: [Field; K]) -> [Field; K] {\n for i in 0..K {\n result[i] = self.data[self.offset + i];\n }\n self.offset += K;\n result\n }\n\n pub fn read_struct(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n let result = deserialise(self.read_array([0; K]));\n result\n }\n\n pub fn read_struct_array(&mut self, deserialise: fn([Field; K]) -> T, mut result: [T; C]) -> [T; C] {\n for i in 0..C {\n result[i] = self.read_struct(deserialise);\n }\n result\n }\n\n pub fn finish(self) {\n assert(self.offset == self.data.len(), \"Reader did not read all data\");\n } \n}\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/aztec/src/utils.nr" - }, - "77": { - "source": "use crate::context::{PrivateContext, PublicContext};\nuse crate::oracle;\nuse dep::protocol_types::{\n address::AztecAddress,\n grumpkin_point::GrumpkinPoint,\n};\n\npub fn emit_encrypted_log(\n context: &mut PrivateContext,\n contract_address: AztecAddress,\n storage_slot: Field,\n encryption_pub_key: GrumpkinPoint,\n log: [Field; N]\n) {\n let _ = oracle::logs::emit_encrypted_log(contract_address, storage_slot, encryption_pub_key, log);\n context.accumulate_encrypted_logs(log);\n}\n\npub fn emit_unencrypted_log(context: &mut PublicContext, log: T) {\n let contract_address = context.this_address();\n let event_selector = 5; // TODO: compute actual event selector.\n let _ = oracle::logs::emit_unencrypted_log(contract_address, event_selector, log);\n // context.accumulate_unencrypted_logs(log);\n}\n\n// TODO: We might want to remove this since emitting unencrypted logs from private functions is violating privacy.\n// --> might be a better approach to force devs to make a public function call that emits the log if needed then\n// it would be less easy to accidentally leak information.\n// If we decide to keep this function around would make sense to wait for traits and then merge it with emit_unencrypted_log.\npub fn emit_unencrypted_log_from_private(context: &mut PrivateContext, log: T) {\n let contract_address = context.this_address();\n let event_selector = 5; // TODO: compute actual event selector.\n let _ = oracle::logs::emit_unencrypted_log(contract_address, event_selector, log);\n // context.accumulate_unencrypted_logs(log);\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/aztec/src/log.nr" - }, - "78": { - "source": "use crate::oracle::get_public_key::get_public_key;\nuse dep::protocol_types::{\n address::AztecAddress,\n grumpkin_point::GrumpkinPoint,\n};\nuse dep::std::{\n grumpkin_scalar::GrumpkinScalar,\n grumpkin_scalar_mul::grumpkin_fixed_base,\n};\n\npub fn validate_nullifier_key_against_address(\n address: AztecAddress,\n nullifier_public_key: GrumpkinPoint,\n nullifier_secret_key: GrumpkinScalar\n) {\n // TODO: Nullifier public key should be part of the address.\n // Validation of the secret key should happen in the kernel circuit.\n let owner_public_key = get_public_key(address);\n assert(owner_public_key.x == nullifier_public_key.x);\n assert(owner_public_key.y == nullifier_public_key.y);\n let computed_public_key = grumpkin_fixed_base(nullifier_secret_key);\n assert(owner_public_key.x == computed_public_key[0]);\n assert(owner_public_key.y == computed_public_key[1]);\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/aztec/src/key/nullifier_key.nr" - }, - "87": { - "source": "use dep::std::option::Option;\nuse dep::protocol_types::constants::{\n MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,\n GET_NOTE_ORACLE_RETURN_LENGTH,\n GET_NOTES_ORACLE_RETURN_LENGTH,\n MAX_NOTES_PER_PAGE,\n VIEW_NOTE_ORACLE_RETURN_LENGTH,\n};\nuse crate::context::PrivateContext;\nuse crate::note::{\n note_getter_options::{NoteGetterOptions, Select, Sort, SortOrder},\n note_interface::NoteInterface,\n note_viewer_options::NoteViewerOptions,\n utils::compute_note_hash_for_read_or_nullify,\n};\nuse crate::oracle;\nuse crate::types::vec::BoundedVec;\n\nfn check_note_header(\n context: PrivateContext,\n storage_slot: Field,\n note_interface: NoteInterface,\n note: Note\n) {\n let get_header = note_interface.get_header;\n let header = get_header(note);\n let contract_address = context.this_address();\n assert(header.contract_address.eq(contract_address));\n assert(header.storage_slot == storage_slot);\n}\n\nfn check_note_fields(fields: [Field; N], selects: BoundedVec, N>) {\n for i in 0..selects.len {\n let select = selects.get_unchecked(i).unwrap_unchecked();\n assert(fields[select.field_index] == select.value, \"Mismatch return note field.\");\n }\n}\n\nfn check_notes_order(\n fields_0: [Field; N],\n fields_1: [Field; N],\n sorts: BoundedVec, N>\n) {\n for i in 0..sorts.len {\n let sort = sorts.get_unchecked(i).unwrap_unchecked();\n let eq = fields_0[sort.field_index] == fields_1[sort.field_index];\n let lt = fields_0[sort.field_index] as u120 < fields_1[sort.field_index] as u120;\n if sort.order == SortOrder.ASC {\n assert(eq | lt, \"Return notes not sorted in ascending order.\");\n } else if !eq {\n assert(!lt, \"Return notes not sorted in descending order.\");\n }\n }\n}\n\npub fn get_note(\n context: &mut PrivateContext,\n storage_slot: Field,\n note_interface: NoteInterface\n) -> Note {\n let note = get_note_internal(storage_slot, note_interface);\n\n check_note_header(*context, storage_slot, note_interface, note);\n\n let note_hash_for_read_request = compute_note_hash_for_read_or_nullify(note_interface, note);\n\n context.push_read_request(note_hash_for_read_request);\n note\n}\n\npub fn get_notes(\n context: &mut PrivateContext,\n storage_slot: Field,\n note_interface: NoteInterface,\n options: NoteGetterOptions\n) -> [Option; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL] {\n let opt_notes = get_notes_internal(storage_slot, note_interface, options);\n let mut num_notes = 0;\n let mut prev_fields = [0; N];\n for i in 0..opt_notes.len() {\n let opt_note = opt_notes[i];\n if opt_note.is_some() {\n let note = opt_note.unwrap_unchecked();\n let serialize = note_interface.serialize;\n let fields = serialize(note);\n check_note_header(*context, storage_slot, note_interface, note);\n check_note_fields(fields, options.selects);\n if i != 0 {\n check_notes_order(prev_fields, fields, options.sorts);\n }\n prev_fields = fields;\n\n let note_hash_for_read_request = compute_note_hash_for_read_or_nullify(note_interface, note);\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1410): test to ensure\n // failure if malicious oracle injects 0 nonce here for a \"pre-existing\" note.\n context.push_read_request(note_hash_for_read_request);\n\n num_notes += 1;\n };\n }\n if options.limit != 0 {\n assert(num_notes <= options.limit, \"Invalid number of return notes.\");\n }\n opt_notes\n}\n\nunconstrained fn get_note_internal(storage_slot: Field, note_interface: NoteInterface) -> Note {\n let placeholder_note = [Option::none()];\n let placeholder_fields = [0; GET_NOTE_ORACLE_RETURN_LENGTH];\n oracle::notes::get_notes(\n storage_slot,\n note_interface,\n 0,\n [],\n [],\n [],\n [],\n 1, // limit\n 0, // offset\n placeholder_note,\n placeholder_fields\n )[0].unwrap() // Notice: we don't allow dummies to be returned from get_note (singular).\n}\n\nunconstrained fn get_notes_internal(\n storage_slot: Field,\n note_interface: NoteInterface,\n options: NoteGetterOptions\n) -> [Option; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL] {\n let (num_selects, select_by, select_values, sort_by, sort_order) = flatten_options(options.selects, options.sorts);\n let placeholder_opt_notes = [Option::none(); MAX_NOTE_HASH_READ_REQUESTS_PER_CALL];\n let placeholder_fields = [0; GET_NOTES_ORACLE_RETURN_LENGTH];\n let opt_notes = oracle::notes::get_notes(\n storage_slot,\n note_interface,\n num_selects,\n select_by,\n select_values,\n sort_by,\n sort_order,\n options.limit,\n options.offset,\n placeholder_opt_notes,\n placeholder_fields\n );\n\n let filter = options.filter;\n let filter_args = options.filter_args;\n filter(opt_notes, filter_args)\n}\n\nunconstrained pub fn view_notes(\n storage_slot: Field,\n note_interface: NoteInterface,\n options: NoteViewerOptions\n) -> [Option; MAX_NOTES_PER_PAGE] {\n let (num_selects, select_by, select_values, sort_by, sort_order) = flatten_options(options.selects, options.sorts);\n let placeholder_opt_notes = [Option::none(); MAX_NOTES_PER_PAGE];\n let placeholder_fields = [0; VIEW_NOTE_ORACLE_RETURN_LENGTH];\n oracle::notes::get_notes(\n storage_slot,\n note_interface,\n num_selects,\n select_by,\n select_values,\n sort_by,\n sort_order,\n options.limit,\n options.offset,\n placeholder_opt_notes,\n placeholder_fields\n )\n}\n\nunconstrained fn flatten_options(\n selects: BoundedVec, N>,\n sorts: BoundedVec, N>\n) -> (u8, [u8; N], [Field; N], [u8; N], [u2; N]) {\n let mut num_selects = 0;\n let mut select_by = [0; N];\n let mut select_values = [0; N];\n for i in 0..selects.len {\n let select = selects.get(i);\n if select.is_some() {\n select_by[num_selects] = select.unwrap_unchecked().field_index;\n select_values[num_selects] = select.unwrap_unchecked().value;\n num_selects += 1;\n };\n }\n\n let mut sort_by = [0; N];\n let mut sort_order = [0; N];\n for i in 0..sorts.len {\n let sort = sorts.get(i);\n if sort.is_some() {\n sort_by[i] = sort.unwrap_unchecked().field_index;\n sort_order[i] = sort.unwrap_unchecked().order;\n };\n }\n\n (num_selects, select_by, select_values, sort_by, sort_order)\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/aztec/src/note/note_getter.nr" - }, - "88": { - "source": "use crate::abi::PublicContextInputs;\nuse crate::context::{\n PrivateContext,\n PublicContext,\n};\nuse crate::note::{\n note_header::NoteHeader,\n note_interface::NoteInterface,\n utils::compute_inner_note_hash,\n};\nuse crate::oracle::notes::{notify_created_note, notify_nullified_note};\n\npub fn create_note(\n context: &mut PrivateContext,\n storage_slot: Field,\n note: &mut Note,\n note_interface: NoteInterface,\n broadcast: bool\n) {\n let contract_address = (*context).this_address();\n\n let header = NoteHeader { contract_address, storage_slot, nonce: 0, is_transient: true };\n let set_header = note_interface.set_header;\n set_header(note, header);\n let inner_note_hash = compute_inner_note_hash(note_interface, *note);\n\n let serialize = note_interface.serialize;\n let serialized_note = serialize(*note);\n assert(notify_created_note(storage_slot, serialized_note, inner_note_hash) == 0);\n\n context.push_new_note_hash(inner_note_hash);\n\n if broadcast {\n let broadcast = note_interface.broadcast;\n broadcast(context, storage_slot, *note);\n }\n}\n\npub fn create_note_hash_from_public(\n context: &mut PublicContext,\n storage_slot: Field,\n note: &mut Note,\n note_interface: NoteInterface\n) {\n let contract_address = (*context).this_address();\n\n let header = NoteHeader { contract_address, storage_slot, nonce: 0, is_transient: true };\n let set_header = note_interface.set_header;\n set_header(note, header);\n let inner_note_hash = compute_inner_note_hash(note_interface, *note);\n\n context.push_new_note_hash(inner_note_hash);\n}\n\npub fn destroy_note(\n context: &mut PrivateContext,\n note: Note,\n note_interface: NoteInterface\n) {\n let mut nullifier = 0;\n let mut nullified_commitment: Field = 0;\n let compute_nullifier = note_interface.compute_nullifier;\n nullifier = compute_nullifier(note, context);\n\n // We also need the note commitment corresponding to the \"nullifier\"\n let get_header = note_interface.get_header;\n let header = get_header(note);\n // `nullified_commitment` is used to inform the kernel which pending note hash\n // the nullifier corresponds to so they can be matched and both squashed/deleted.\n // nonzero nonce implies \"persistable\" nullifier (nullifies a persistent/in-tree\n // commitment) in which case `nullified_commitment` is not used since the kernel\n // just siloes and forwards the nullifier to its output.\n if (header.is_transient) {\n // TODO(1718): Can we reuse the note commitment computed in `compute_nullifier`?\n nullified_commitment = compute_inner_note_hash(note_interface, note);\n }\n assert(notify_nullified_note(nullifier, nullified_commitment) == 0);\n\n context.push_new_nullifier(nullifier, nullified_commitment)\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/aztec/src/note/lifecycle.nr" - }, - "91": { - "source": "use dep::protocol_types::{\n address::AztecAddress,\n constants::{\n GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n GENERATOR_INDEX__SILOED_NOTE_HASH,\n },\n hash::pedersen_hash,\n};\n\npub fn compute_inner_hash(storage_slot: Field, note_hash: Field) -> Field {\n // TODO(#1205) Do we need a generator index here?\n pedersen_hash([storage_slot, note_hash], 0)\n}\n\npub fn compute_siloed_hash(contract_address: AztecAddress, inner_note_hash: Field) -> Field {\n let inputs = [contract_address.to_field(), inner_note_hash];\n pedersen_hash(inputs, GENERATOR_INDEX__SILOED_NOTE_HASH)\n}\n\npub fn compute_unique_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n let inputs = [nonce, siloed_note_hash];\n pedersen_hash(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/aztec/src/note/note_hash.nr" - }, - "92": { - "source": "use dep::protocol_types::{\n constants::GENERATOR_INDEX__OUTER_NULLIFIER,\n hash::pedersen_hash,\n};\nuse crate::{\n context::PrivateContext,\n note::{\n note_hash::{compute_inner_hash, compute_siloed_hash, compute_unique_hash},\n note_header::NoteHeader,\n note_interface::NoteInterface,\n },\n utils::arr_copy_slice,\n};\n\npub fn compute_inner_note_hash(note_interface: NoteInterface, note: Note) -> Field {\n let get_header = note_interface.get_header;\n let header = get_header(note);\n\n let compute_note_hash = note_interface.compute_note_hash;\n let note_hash = compute_note_hash(note);\n\n compute_inner_hash(header.storage_slot, note_hash)\n}\n\npub fn compute_siloed_note_hash(note_interface: NoteInterface, note_with_header: Note) -> Field {\n let get_header = note_interface.get_header;\n let header = get_header(note_with_header);\n\n let inner_note_hash = compute_inner_note_hash(note_interface, note_with_header);\n\n compute_siloed_hash(header.contract_address, inner_note_hash)\n}\n\npub fn compute_unique_siloed_note_hash(note_interface: NoteInterface, note_with_header: Note) -> Field {\n let get_header = note_interface.get_header;\n let header = get_header(note_with_header);\n\n let siloed_note_hash = compute_siloed_note_hash(note_interface, note_with_header);\n\n compute_unique_hash(header.nonce, siloed_note_hash)\n}\n\npub fn compute_siloed_nullifier(\n note_interface: NoteInterface,\n note_with_header: Note,\n context: &mut PrivateContext\n) -> Field {\n let get_header = note_interface.get_header;\n let header = get_header(note_with_header);\n\n let compute_nullifier = note_interface.compute_nullifier;\n let inner_nullifier = compute_nullifier(note_with_header, context);\n\n let input = [header.contract_address.to_field(), inner_nullifier];\n pedersen_hash(input, GENERATOR_INDEX__OUTER_NULLIFIER)\n}\n\npub fn compute_note_hash_for_read_or_nullify(note_interface: NoteInterface, note_with_header: Note) -> Field {\n let get_header = note_interface.get_header;\n let header = get_header(note_with_header);\n\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386)\n if (header.is_transient) {\n // If a note is transient, we just read the inner_note_hash (kernel will silo by contract address).\n compute_inner_note_hash(note_interface, note_with_header)\n } else if (header.nonce == 0) {\n // If not transient and nonce is zero, that means we are reading a public note.\n compute_siloed_note_hash(note_interface, note_with_header)\n } else {\n // When nonce is nonzero, that means we are reading a settled note (from tree) created in a\n // previous TX. So we need the unique_siloed_note_hash which has already been hashed with\n // contract address and then nonce. This hash will match the existing leaf in the private\n // data tree, so the kernel can just perform a membership check directly on this hash/leaf.\n compute_unique_siloed_note_hash(note_interface, note_with_header)\n }\n}\n\npub fn compute_note_hash_and_nullifier(\n note_interface: NoteInterface,\n note_header: NoteHeader,\n serialized_note: [Field; S]\n) -> [Field; 4] {\n let deserialize = note_interface.deserialize;\n let set_header = note_interface.set_header;\n let mut note = deserialize(arr_copy_slice(serialized_note, [0; N], 0));\n set_header(&mut note, note_header);\n\n let compute_note_hash = note_interface.compute_note_hash;\n let note_hash = compute_note_hash(note);\n let inner_note_hash = compute_inner_hash(note_header.storage_slot, note_hash);\n\n let siloed_note_hash = compute_siloed_hash(note_header.contract_address, inner_note_hash);\n\n let unique_siloed_note_hash = compute_unique_hash(note_header.nonce, siloed_note_hash);\n\n let compute_nullifier_without_context = note_interface.compute_nullifier_without_context;\n let inner_nullifier = compute_nullifier_without_context(note);\n\n [inner_note_hash, siloed_note_hash, unique_siloed_note_hash, inner_nullifier]\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/aztec/src/note/utils.nr" - }, - "94": { - "source": "struct BoundedVec {\n storage: [T; MaxLen],\n len: Field,\n}\n\nimpl BoundedVec {\n pub fn new(initial_value: T) -> Self {\n BoundedVec { storage: [initial_value; MaxLen], len: 0 }\n }\n\n pub fn get(mut self: Self, index: Field) -> T {\n assert(index as u64 < self.len as u64);\n self.storage[index]\n }\n\n pub fn get_unchecked(mut self: Self, index: Field) -> T {\n self.storage[index]\n }\n\n pub fn push(&mut self, elem: T) {\n assert(self.len as u64 < MaxLen as u64);\n\n self.storage[self.len] = elem;\n self.len += 1;\n }\n\n pub fn push_array(&mut self, array: [T; Len]) {\n let newLen = self.len + array.len();\n assert(newLen as u64 <= MaxLen as u64);\n for i in 0..array.len() {\n self.storage[self.len + i] = array[i];\n }\n self.len = newLen;\n }\n\n pub fn pop(&mut self) -> T {\n assert(self.len as u64 > 0);\n\n let elem = self.storage[self.len - 1];\n self.len -= 1;\n elem\n }\n\n pub fn any(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n let mut exceeded_len = false;\n for i in 0..MaxLen {\n exceeded_len |= i == self.len;\n if (!exceeded_len) {\n ret |= predicate(self.storage[i]);\n }\n }\n ret\n }\n}\n\n#[test]\nfn test_vec_push_pop() {\n let mut vec: BoundedVec = BoundedVec::new();\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/aztec/src/types/vec.nr" - }, - "97": { - "source": "use crate::types::type_serialization::TypeSerializationInterface;\n\n// docs:start:field_serialization\nglobal FIELD_SERIALIZED_LEN: Field = 1;\n\nfn deserializeField(fields: [Field; FIELD_SERIALIZED_LEN]) -> Field {\n fields[0]\n}\n\nfn serializeField(value: Field) -> [Field; FIELD_SERIALIZED_LEN] {\n [value]\n}\n\nglobal FieldSerializationMethods = TypeSerializationInterface {\n deserialize: deserializeField,\n serialize: serializeField,\n};\n// docs:end:field_serialization", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/aztec/src/types/type_serialization/field_serialization.nr" - }, - "105": { - "source": "global ARGS_LENGTH: Field = 16;\nglobal RETURN_VALUES_LENGTH: Field = 4;\n\n/**\n * Convention for constant array lengths are mainly divided in 2 classes:\n * - FUNCTION CALL\n * - TRANSACTION\n *\n * Agreed convention is to use MAX_XXX_PER_CALL resp. MAX_XXX_PER_TX, where XXX denotes a type of element such as\n * commitment, or nullifier, e.g.,:\n * - MAX_NEW_NULLIFIERS_PER_CALL\n * - MAX_NEW_NOTE_HASHES_PER_TX\n *\n * In the kernel circuits, we accumulate elements such as commitments and the nullifiers from all functions calls in a\n * transaction. Therefore, we always must have:\n * MAX_XXX_PER_TX ≥ MAX_XXX_PER_CALL\n *\n * For instance:\n * MAX_NEW_NOTE_HASHES_PER_TX ≥ MAX_NEW_NOTE_HASHES_PER_CALL\n * MAX_NEW_NULLIFIERS_PER_TX ≥ MAX_NEW_NULLIFIERS_PER_CALL\n *\n */\n\n// docs:start:constants\n// \"PER CALL\" CONSTANTS\nglobal MAX_NEW_NOTE_HASHES_PER_CALL: Field = 16;\nglobal MAX_NEW_NULLIFIERS_PER_CALL: Field = 16;\nglobal MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL: Field = 4;\nglobal MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL: Field = 4;\nglobal MAX_NEW_L2_TO_L1_MSGS_PER_CALL: Field = 2;\nglobal MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL: Field = 16;\nglobal MAX_PUBLIC_DATA_READS_PER_CALL: Field = 16;\nglobal MAX_NOTE_HASH_READ_REQUESTS_PER_CALL: Field = 32;\n\n// \"PER TRANSACTION\" CONSTANTS\nglobal MAX_NEW_NOTE_HASHES_PER_TX: Field = 64;\nglobal MAX_NEW_NULLIFIERS_PER_TX: Field = 64;\nglobal MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX: Field = 8;\nglobal MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX: Field = 8;\nglobal MAX_NEW_L2_TO_L1_MSGS_PER_TX: Field = 2;\nglobal MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX: Field = 16;\nglobal MAX_PUBLIC_DATA_READS_PER_TX: Field = 16;\nglobal MAX_NEW_CONTRACTS_PER_TX: Field = 1;\nglobal MAX_OPTIONALLY_REVEALED_DATA_LENGTH_PER_TX: Field = 4;\nglobal MAX_NOTE_HASH_READ_REQUESTS_PER_TX: Field = 128;\nglobal NUM_ENCRYPTED_LOGS_HASHES_PER_TX: Field = 1;\nglobal NUM_UNENCRYPTED_LOGS_HASHES_PER_TX: Field = 1;\n// docs:end:constants\n\n// ROLLUP CONTRACT CONSTANTS - constants used only in l1-contracts\nglobal NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP: Field = 16;\n\n// TREES RELATED CONSTANTS\nglobal VK_TREE_HEIGHT: Field = 3;\nglobal FUNCTION_TREE_HEIGHT: Field = 5;\nglobal CONTRACT_TREE_HEIGHT: Field = 16;\nglobal NOTE_HASH_TREE_HEIGHT: Field = 32;\nglobal PUBLIC_DATA_TREE_HEIGHT: Field = 40;\nglobal NULLIFIER_TREE_HEIGHT: Field = 20;\nglobal L1_TO_L2_MSG_TREE_HEIGHT: Field = 16;\nglobal ROLLUP_VK_TREE_HEIGHT: Field = 8;\n\n// SUB-TREES RELATED CONSTANTS\nglobal CONTRACT_SUBTREE_HEIGHT: Field = 0;\nglobal CONTRACT_SUBTREE_SIBLING_PATH_LENGTH: Field = 16;\nglobal NOTE_HASH_SUBTREE_HEIGHT: Field = 6;\nglobal NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH: Field = 26;\nglobal NULLIFIER_SUBTREE_HEIGHT: Field = 6;\nglobal PUBLIC_DATA_SUBTREE_HEIGHT: Field = 4;\nglobal ARCHIVE_HEIGHT: Field = 16;\nglobal NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH: Field = 14;\nglobal PUBLIC_DATA_SUBTREE_SIBLING_PATH_LENGTH: Field = 36;\nglobal L1_TO_L2_MSG_SUBTREE_HEIGHT: Field = 4;\nglobal L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH: Field = 12;\n\n// MISC CONSTANTS\nglobal FUNCTION_SELECTOR_NUM_BYTES: Field = 4;\nglobal MAPPING_SLOT_PEDERSEN_SEPARATOR: Field = 4;\n// sha256 hash is stored in two fields to accommodate all 256-bits of the hash\nglobal NUM_FIELDS_PER_SHA256: Field = 2;\nglobal ARGS_HASH_CHUNK_LENGTH: u32 = 32;\nglobal ARGS_HASH_CHUNK_COUNT: u32 = 16;\n\n// NOIR CONSTANTS - constants used only in yarn-packages/noir-contracts\n// Some are defined here because Noir doesn't yet support globals referencing other globals yet.\n// Move these constants to a noir file once the issue bellow is resolved:\n// https://github.com/noir-lang/noir/issues/1734\nglobal L1_TO_L2_MESSAGE_LENGTH: Field = 8;\nglobal L1_TO_L2_MESSAGE_ORACLE_CALL_LENGTH: Field = 25;\nglobal MAX_NOTE_FIELDS_LENGTH: Field = 20;\n// GET_NOTE_ORACLE_RETURN_LENGT = MAX_NOTE_FIELDS_LENGTH + 1 + 2\n// The plus 1 is 1 extra field for nonce.\n// + 2 for EXTRA_DATA: [number_of_return_notes, contract_address]\nglobal GET_NOTE_ORACLE_RETURN_LENGTH: Field = 23;\nglobal MAX_NOTES_PER_PAGE: Field = 10;\n// VIEW_NOTE_ORACLE_RETURN_LENGTH = MAX_NOTES_PER_PAGE * (MAX_NOTE_FIELDS_LENGTH + 1) + 2;\nglobal VIEW_NOTE_ORACLE_RETURN_LENGTH: Field = 212;\nglobal CALL_CONTEXT_LENGTH: Field = 8;\nglobal BLOCK_HEADER_LENGTH: Field = 7;\nglobal FUNCTION_DATA_LENGTH: Field = 4;\nglobal CONTRACT_DEPLOYMENT_DATA_LENGTH: Field = 6;\n// Change this ONLY if you have changed the PrivateCircuitPublicInputs structure.\n// In other words, if the structure/size of the public inputs of a function call changes then we\n// should change this constant as well as the offsets in private_call_stack_item.nr\nglobal PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH: Field = 189;\nglobal CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH: Field = 3;\nglobal CONTRACT_STORAGE_READ_LENGTH: Field = 2;\n// Change this ONLY if you have changed the PublicCircuitPublicInputs structure.\nglobal PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH: Field = 190;\nglobal GET_NOTES_ORACLE_RETURN_LENGTH: Field = 674;\nglobal CALL_PRIVATE_FUNCTION_RETURN_SIZE: Field = 195;\nglobal PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH: Field = 87;\nglobal PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH: Field = 177;\nglobal NOTE_HASHES_NUM_BYTES_PER_BASE_ROLLUP: Field = 2048;\nglobal NULLIFIERS_NUM_BYTES_PER_BASE_ROLLUP: Field = 2048;\nglobal PUBLIC_DATA_WRITES_NUM_BYTES_PER_BASE_ROLLUP: Field = 1024;\nglobal CONTRACTS_NUM_BYTES_PER_BASE_ROLLUP: Field = 32;\nglobal CONTRACT_DATA_NUM_BYTES_PER_BASE_ROLLUP: Field = 64;\nglobal CONTRACT_DATA_NUM_BYTES_PER_BASE_ROLLUP_UNPADDED: Field = 52;\nglobal L2_TO_L1_MSGS_NUM_BYTES_PER_BASE_ROLLUP: Field = 64;\nglobal LOGS_HASHES_NUM_BYTES_PER_BASE_ROLLUP: Field = 64;\n\n/**\n * Enumerate the hash_indices which are used for pedersen hashing.\n * We start from 1 to avoid the default generators. The generator indices are listed\n * based on the number of elements each index hashes. The following conditions must be met:\n *\n * +-----------+-------------------------------+----------------------+\n * | Hash size | Number of elements hashed (n) | Condition to use |\n * |-----------+-------------------------------+----------------------|\n * | LOW | n ≤ 8 | 0 < hash_index ≤ 32 |\n * | MID | 8 < n ≤ 16 | 32 < hash_index ≤ 40 |\n * | HIGH | 16 < n ≤ 48 | 40 < hash_index ≤ 48 |\n * +-----------+-------------------------------+----------------------+\n *\n * Note: When modifying, modify `GeneratorIndexPacker` in packer.hpp accordingly.\n */\n// Indices with size ≤ 8\nglobal GENERATOR_INDEX__COMMITMENT = 1;\nglobal GENERATOR_INDEX__NOTE_HASH_NONCE = 2;\nglobal GENERATOR_INDEX__UNIQUE_NOTE_HASH = 3;\nglobal GENERATOR_INDEX__SILOED_NOTE_HASH = 4;\nglobal GENERATOR_INDEX__NULLIFIER = 5;\nglobal GENERATOR_INDEX__INITIALIZATION_NULLIFIER = 6;\nglobal GENERATOR_INDEX__OUTER_NULLIFIER = 7;\nglobal GENERATOR_INDEX__PUBLIC_DATA_READ = 8;\nglobal GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST = 9;\nglobal GENERATOR_INDEX__FUNCTION_DATA = 10;\nglobal GENERATOR_INDEX__FUNCTION_LEAF = 11;\nglobal GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA = 12;\nglobal GENERATOR_INDEX__CONSTRUCTOR = 13;\nglobal GENERATOR_INDEX__CONSTRUCTOR_ARGS = 14;\nglobal GENERATOR_INDEX__CONTRACT_ADDRESS = 15;\nglobal GENERATOR_INDEX__CONTRACT_LEAF = 16;\nglobal GENERATOR_INDEX__CALL_CONTEXT = 17;\nglobal GENERATOR_INDEX__CALL_STACK_ITEM = 18;\nglobal GENERATOR_INDEX__CALL_STACK_ITEM_2 = 19;\nglobal GENERATOR_INDEX__L1_TO_L2_MESSAGE_SECRET = 20;\nglobal GENERATOR_INDEX__L2_TO_L1_MSG = 21;\nglobal GENERATOR_INDEX__TX_CONTEXT = 22;\nglobal GENERATOR_INDEX__PUBLIC_LEAF_INDEX = 23;\nglobal GENERATOR_INDEX__PUBLIC_DATA_LEAF = 24;\nglobal GENERATOR_INDEX__SIGNED_TX_REQUEST = 25;\nglobal GENERATOR_INDEX__GLOBAL_VARIABLES = 26;\nglobal GENERATOR_INDEX__PARTIAL_ADDRESS = 27;\nglobal GENERATOR_INDEX__BLOCK_HASH = 28;\nglobal GENERATOR_INDEX__SIDE_EFFECT = 29;\n// Indices with size ≤ 16\nglobal GENERATOR_INDEX__TX_REQUEST = 33;\nglobal GENERATOR_INDEX__SIGNATURE_PAYLOAD = 34;\n// Indices with size ≤ 44\nglobal GENERATOR_INDEX__VK = 41;\nglobal GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS = 42;\nglobal GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS = 43;\nglobal GENERATOR_INDEX__FUNCTION_ARGS = 44;\n", - "path": "/home/santiago/Projects/aztec3-packages/noir-protocol-circuits/crates/types/src/constants.nr" - }, - "111": { - "source": "use crate::address::{AztecAddress, EthAddress};\nuse crate::mocked::VerificationKey;\nuse crate::abis::function_selector::FunctionSelector;\nuse crate::abis::function_leaf_preimage::FunctionLeafPreimage;\nuse crate::abis::new_contract_data::NewContractData as ContractLeafPreimage;\nuse crate::abis::function_data::FunctionData;\nuse crate::abis::side_effect::{SideEffect};\nuse crate::utils::uint256::U256;\nuse crate::utils::bounded_vec::BoundedVec;\nuse crate::constants::{\n ARGS_HASH_CHUNK_COUNT,\n ARGS_HASH_CHUNK_LENGTH,\n CONTRACT_TREE_HEIGHT, \n FUNCTION_TREE_HEIGHT, \n NOTE_HASH_TREE_HEIGHT,\n NUM_FIELDS_PER_SHA256,\n GENERATOR_INDEX__SILOED_NOTE_HASH,\n GENERATOR_INDEX__OUTER_NULLIFIER,\n GENERATOR_INDEX__VK,\n GENERATOR_INDEX__CONSTRUCTOR,\n GENERATOR_INDEX__PARTIAL_ADDRESS,\n GENERATOR_INDEX__CONTRACT_ADDRESS,\n GENERATOR_INDEX__NOTE_HASH_NONCE,\n GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n GENERATOR_INDEX__FUNCTION_ARGS,\n};\n\nuse dep::std::hash::{pedersen_hash_with_separator, sha256};\n\npub fn sha256_to_field(bytes_to_hash: [u8; N]) -> Field {\n let sha256_hashed = sha256(bytes_to_hash);\n\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (sha256_hashed[15 - i] as Field) * v;\n low = low + (sha256_hashed[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n let hash_in_a_field = low + high * v;\n\n hash_in_a_field\n}\n\npub fn hash_args(args: [Field; N]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n let mut chunks_hashes = [0; ARGS_HASH_CHUNK_COUNT];\n for i in 0..ARGS_HASH_CHUNK_COUNT {\n let mut chunk_hash = 0;\n let start_chunk_index = i * ARGS_HASH_CHUNK_LENGTH;\n if start_chunk_index < (args.len() as u32) {\n let mut chunk_args = [0; ARGS_HASH_CHUNK_LENGTH];\n for j in 0..ARGS_HASH_CHUNK_LENGTH {\n let item_index = i * ARGS_HASH_CHUNK_LENGTH + j;\n if item_index < (args.len() as u32) {\n chunk_args[j] = args[item_index];\n }\n }\n chunk_hash = pedersen_hash(chunk_args, GENERATOR_INDEX__FUNCTION_ARGS);\n }\n chunks_hashes[i] = chunk_hash;\n }\n pedersen_hash(chunks_hashes, GENERATOR_INDEX__FUNCTION_ARGS)\n }\n}\n\n// Checks that `value` is a member of a merkle tree with root `root` at position `index`\n// The witness being the `sibling_path`\npub fn assert_check_membership(value: Field, index: Field, sibling_path: [Field; N], root: Field) {\n let calculated_root = root_from_sibling_path(value, index, sibling_path);\n assert(calculated_root == root, \"membership check failed\");\n}\n\n// Calculate the Merkle tree root from the sibling path and leaf.\n//\n// The leaf is hashed with its sibling, and then the result is hashed\n// with the next sibling etc in the path. The last hash is the root.\n//\n// TODO(David/Someone): The cpp code is using a uint256, whereas its\n// TODO a bit simpler in Noir to just have a bit array.\n// TODO: I'd generally like to avoid u256 for algorithms like \n// this because it means we never even need to consider cases where \n// the index is greater than p.\npub fn root_from_sibling_path(leaf: Field, leaf_index: Field, sibling_path: [Field; N]) -> Field {\n let mut node = leaf;\n let indices = leaf_index.to_le_bits(N);\n\n for i in 0..N {\n let (hash_left, hash_right) = if indices[i] == 1 {\n (sibling_path[i], node)\n } else {\n (node, sibling_path[i])\n };\n node = merkle_hash(hash_left, hash_right);\n }\n node\n}\n\n// Calculate the function tree root from the sibling path and leaf preimage.\n//\n// TODO: The cpp code passes in components of the FunctionLeafPreimage and then \n// builds it up. We should build it up and then pass the leaf preimage as a parameter.\n// We can then choose to have a general method that takes in anything hashable\n// and deduplicate the logic in `contract_tree_root_from_siblings`\npub fn function_tree_root_from_siblings(\n selector: FunctionSelector,\n is_internal: bool,\n is_private: bool,\n vk_hash: Field,\n acir_hash: Field,\n function_leaf_index: Field,\n function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT]\n) -> Field {\n let function_leaf_preimage = FunctionLeafPreimage { selector, is_internal, is_private, vk_hash, acir_hash };\n\n let function_leaf = function_leaf_preimage.hash();\n\n let function_tree_root = root_from_sibling_path(function_leaf, function_leaf_index, function_leaf_sibling_path);\n\n function_tree_root\n}\n\n// Calculate the contract tree root from the sibling path and leaf preimage.\npub fn contract_tree_root_from_siblings(\n function_tree_root: Field,\n storage_contract_address: AztecAddress,\n portal_contract_address: EthAddress,\n contract_leaf_index: Field,\n contract_leaf_sibling_path: [Field; CONTRACT_TREE_HEIGHT]\n) -> Field {\n //TODO(Kev): if we use shorthand syntax here, we get an error as expected,\n // since variable name is `storage_contract_address` but the span is incorrect.\n let contract_leaf_preimage = ContractLeafPreimage { contract_address: storage_contract_address, portal_contract_address, function_tree_root };\n\n let contract_leaf = contract_leaf_preimage.hash();\n\n let computed_contract_tree_root = root_from_sibling_path(contract_leaf, contract_leaf_index, contract_leaf_sibling_path);\n\n computed_contract_tree_root\n}\n\npub fn read_request_root_from_siblings(\n read_request: Field,\n leaf_index: Field,\n sibling_path: [Field; NOTE_HASH_TREE_HEIGHT]\n) -> Field {\n root_from_sibling_path(read_request, leaf_index, sibling_path)\n}\n\npub fn silo_note_hash(address: AztecAddress, inner_commitment: Field) -> Field {\n pedersen_hash(\n [\n address.to_field(),\n inner_commitment\n ],\n GENERATOR_INDEX__SILOED_NOTE_HASH\n )\n}\n\npub fn silo_nullifier(address: AztecAddress, nullifier: Field) -> Field {\n pedersen_hash(\n [\n address.to_field(),\n nullifier\n ],\n GENERATOR_INDEX__OUTER_NULLIFIER\n )\n}\n\nfn merkle_hash(left: Field, right: Field) -> Field {\n pedersen_hash([left, right], 0)\n}\n\npub fn stdlib_recursion_verification_key_compress_native_vk(_vk: VerificationKey) -> Field {\n // Original cpp code\n // stdlib::recursion::verification_key::compress_native(private_call.vk, GeneratorIndex::VK);\n // The above cpp method is only ever called on verification key, so it has been special cased here\n let _hash_index = GENERATOR_INDEX__VK;\n 0\n}\n\n// TODO CPP uses blake2s for this\npub fn compute_new_contract_address_hash(new_contract_address: AztecAddress) -> Field {\n dep::std::hash::pedersen_hash([new_contract_address.to_field()])\n}\n\npub fn compute_l2_to_l1_hash(\n contract_address: AztecAddress,\n rollup_version_id: Field,\n portal_contract_address: EthAddress,\n chain_id: Field,\n content: Field\n) -> Field {\n let mut bytes: BoundedVec = BoundedVec::new();\n unique_siloed_note_hashes[i] = SideEffect {\n value: compute_unique_siloed_note_hash(nonce, siloed_note_hash.value),\n counter: siloed_note_hash.counter\n };\n }\n }\n unique_siloed_note_hashes\n}\n\npub fn pedersen_hash(inputs: [Field; N], hash_index: u32) -> Field {\n dep::std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/noir-protocol-circuits/crates/types/src/hash.nr" - }, - "126": { - "source": "pub fn field_from_bytes(bytes: [u8; N], big_endian: bool) -> Field {\n assert(bytes.len() as u32 < 32, \"field_from_bytes: N must be less than 32\");\n let mut as_field = 0;\n let mut offset = 1;\n for i in 0..N {\n let mut index = i;\n if big_endian {\n index = N - i - 1;\n }\n as_field += (bytes[index] as Field) * offset;\n offset *= 256;\n }\n\n as_field\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/noir-protocol-circuits/crates/types/src/utils/field.nr" - }, - "150": { - "source": "use crate::utils::field::field_from_bytes;\nuse dep::std::cmp::Eq;\n\nglobal SELECTOR_SIZE = 4;\n\nstruct FunctionSelector {\n // 1st 4-bytes of abi-encoding of function.\n inner: u32,\n}\n\nimpl Eq for FunctionSelector {\n fn eq(self, function_selector: FunctionSelector) -> bool {\n function_selector.inner == self.inner\n }\n}\n\nimpl FunctionSelector {\n fn to_field(self) -> Field {\n self.inner as Field\n }\n\n pub fn from_u32(value: u32) -> Self {\n Self {\n inner : value,\n }\n }\n\n pub fn from_field(value : Field) -> Self {\n Self {\n inner : value as u32,\n }\n }\n\n pub fn from_signature(signature: str) -> Self {\n let bytes = signature.as_bytes();\n let hash = dep::std::hash::keccak256(bytes, bytes.len() as u32);\n\n let mut selector_be_bytes = [0; SELECTOR_SIZE];\n for i in 0..SELECTOR_SIZE {\n selector_be_bytes[i] = hash[i];\n }\n\n FunctionSelector::from_field(field_from_bytes(selector_be_bytes, true))\n }\n\n pub fn zero() -> Self {\n Self { inner: 0 }\n }\n\n pub fn serialize(self: Self) -> [Field; 1] {\n [self.inner as Field]\n }\n\n pub fn deserialize(fields: [Field; 1]) -> Self {\n Self {\n inner: fields[0] as u32\n }\n }\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/noir-protocol-circuits/crates/types/src/abis/function_selector.nr" - }, - "160": { - "source": "use crate::{\n constants::{\n GENERATOR_INDEX__CONTRACT_ADDRESS,\n GENERATOR_INDEX__PARTIAL_ADDRESS,\n },\n hash::pedersen_hash,\n utils,\n grumpkin_point::GrumpkinPoint,\n};\nuse dep::std::cmp::Eq;\nuse crate::traits::{Empty, ToField};\n\n// Aztec address\nstruct AztecAddress {\n inner : Field\n}\n\nimpl Eq for AztecAddress {\n fn eq(self, other : Self) -> bool {\n self.to_field() == other.to_field()\n }\n}\n\nimpl Empty for AztecAddress {\n fn empty() -> Self {\n Self {\n inner : 0\n }\n }\n}\n\nimpl ToField for AztecAddress {\n fn to_field(self) -> Field {\n self.inner\n }\n}\n\nimpl AztecAddress {\n pub fn zero() -> Self {\n Self {\n inner: 0\n }\n }\n\n pub fn from_field(field : Field) -> Self {\n Self {\n inner : field\n }\n }\n\n pub fn compute(pub_key: GrumpkinPoint, partial_address: PartialAddress) -> AztecAddress {\n AztecAddress::from_field(\n pedersen_hash(\n [pub_key.x, pub_key.y, partial_address.to_field()],\n GENERATOR_INDEX__CONTRACT_ADDRESS\n )\n )\n }\n\n pub fn is_zero(self) -> bool {\n self.inner == 0\n }\n \n pub fn assert_is_zero(self) {\n assert(self.to_field() == 0);\n }\n\n pub fn conditional_assign(predicate: bool, lhs : Self, rhs : Self) -> Self{\n let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n Self {\n inner : result\n }\n }\n\n pub fn serialize(self: Self) -> [Field; 1] {\n [self.inner]\n }\n\n pub fn deserialize(fields: [Field; 1]) -> Self {\n Self {\n inner: fields[0]\n }\n }\n}\n\nstruct EthAddress{\n inner : Field\n}\n\nimpl Eq for EthAddress {\n fn eq(self, other : Self) -> bool {\n self.to_field() == other.to_field()\n }\n}\n\nimpl Empty for EthAddress {\n fn empty() -> Self {\n Self {\n inner : 0\n }\n }\n}\n\nimpl ToField for EthAddress {\n fn to_field(self) -> Field {\n self.inner\n }\n}\n\nimpl EthAddress{\n pub fn zero() -> Self {\n Self {\n inner: 0\n }\n }\n\n pub fn from_field(field : Field) -> Self {\n Self {\n inner : field\n }\n }\n\n pub fn is_zero(self) -> bool {\n self.inner == 0\n }\n\n pub fn assert_is_zero(self) {\n assert(self.to_field() == 0);\n }\n\n pub fn conditional_assign(predicate: bool, lhs : Self, rhs : Self) -> Self{\n let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n Self {\n inner : result\n }\n }\n\n pub fn serialize(self: Self) -> [Field; 1] {\n [self.inner]\n }\n\n pub fn deserialize(fields: [Field; 1]) -> Self {\n Self {\n inner: fields[0]\n }\n }\n}\n\n// Partial address\nstruct PartialAddress {\n inner : Field\n}\n\nimpl ToField for PartialAddress {\n fn to_field(self) -> Field {\n self.inner\n }\n}\n\nimpl PartialAddress {\n pub fn from_field(field : Field) -> Self {\n Self {\n inner : field\n }\n }\n\n pub fn compute(contract_address_salt : Field, function_tree_root : Field, constructor_hash : Field) -> Self {\n PartialAddress::from_field(\n pedersen_hash([\n // TODO why the zeroes?\n 0,\n 0,\n contract_address_salt,\n function_tree_root,\n constructor_hash\n ], GENERATOR_INDEX__PARTIAL_ADDRESS)\n )\n }\n\n pub fn to_field(self) -> Field {\n self.inner\n }\n\n pub fn assert_is_zero(self) {\n assert(self.to_field() == 0);\n }\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/noir-protocol-circuits/crates/types/src/address.nr" - }, - "163": { - "source": "use crate::{\n constants::{\n CONTRACT_STORAGE_READ_LENGTH,\n GENERATOR_INDEX__PUBLIC_DATA_READ,\n },\n hash::pedersen_hash,\n};\nuse crate::traits::Empty;\n\nstruct StorageRead {\n storage_slot: Field,\n current_value: Field,\n}\n\nimpl Empty for StorageRead { \n fn empty() -> Self {\n Self {\n storage_slot: 0,\n current_value: 0,\n }\n }\n}\n\nimpl StorageRead {\n\n pub fn serialize(self) -> [Field; CONTRACT_STORAGE_READ_LENGTH] {\n [self.storage_slot, self.current_value]\n }\n\n pub fn hash(self) -> Field {\n pedersen_hash(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_READ)\n }\n\n pub fn is_empty(self) -> bool {\n self.storage_slot == 0\n }\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/noir-protocol-circuits/crates/types/src/contrakt/storage_read.nr" - }, - "167": { - "source": "use dep::std::option::Option;\nuse dep::aztec::context::PrivateContext;\nuse dep::aztec::note::note_getter_options::{NoteGetterOptions, SortOrder};\nuse dep::aztec::oracle::get_public_key::get_public_key;\nuse dep::aztec::state_vars::set::Set;\nuse crate::{\n filter::filter_notes_min_sum,\n value_note::{ValueNote, VALUE_NOTE_LEN},\n};\nuse dep::aztec::protocol_types::address::AztecAddress;\n\n// Sort the note values (0th field) in descending order.\n// Pick the fewest notes whose sum is equal to or greater than `amount`.\npub fn create_note_getter_options_for_decreasing_balance(amount: Field) -> NoteGetterOptions {\n NoteGetterOptions::with_filter(filter_notes_min_sum, amount).sort(0, SortOrder.DESC)\n}\n\n// Creates a new note for the recipient.\n// Inserts it to the recipient's set of notes.\npub fn increment(balance: Set, amount: Field, recipient: AztecAddress) {\n let mut note = ValueNote::new(amount, recipient);\n // Insert the new note to the owner's set of notes and emit the log if value is non-zero.\n balance.insert(&mut note, amount != 0);\n}\n\n// Find some of the `owner`'s notes whose values add up to the `amount`.\n// Remove those notes.\n// If the value of the removed notes exceeds the requested `amount`, create a new note containing the excess value, so that exactly `amount` is removed.\n// Fail if the sum of the selected notes is less than the amount.\npub fn decrement(balance: Set, amount: Field, owner: AztecAddress) {\n let sum = decrement_by_at_most(balance, amount, owner);\n assert(sum == amount, \"Balance too low\");\n}\n\n// Similar to `decrement`, except that it doesn't fail if the decremented amount is less than max_amount.\n// The motivation behind this function is that there is an upper-bound on the number of notes a function may\n// read and nullify. The requested decrementation `amount` might be spread across too many of the `owner`'s\n// notes to 'fit' within this upper-bound, so we might have to remove an amount less than `amount`. A common\n// pattern is to repeatedly call this function across many function calls, until enough notes have been nullified to\n// equal `amount`.\n//\n// It returns the decremented amount, which should be less than or equal to max_amount.\npub fn decrement_by_at_most(\n balance: Set,\n max_amount: Field,\n owner: AztecAddress\n) -> Field {\n let options = create_note_getter_options_for_decreasing_balance(max_amount);\n let opt_notes = balance.get_notes(options);\n\n let mut decremented = 0;\n for i in 0..opt_notes.len() {\n if opt_notes[i].is_some() {\n decremented += destroy_note(balance, owner, opt_notes[i].unwrap_unchecked());\n }\n }\n\n // Add the change value back to the owner's balance.\n let mut change_value = 0;\n if decremented as u120 > max_amount as u120 {\n change_value = decremented - max_amount;\n decremented -= change_value;\n }\n increment(balance, change_value, owner);\n\n decremented\n}\n\n// Removes the note from the owner's set of notes.\n// Returns the value of the destroyed note.\npub fn destroy_note(\n balance: Set,\n owner: AztecAddress,\n note: ValueNote\n) -> Field {\n // Ensure the note is actually owned by the owner (to prevent user from generating a valid proof while\n // spending someone else's notes).\n assert(note.owner.eq(owner));\n\n balance.remove(note);\n\n note.value\n}\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/value-note/src/utils.nr" - }, - "169": { - "source": "use dep::aztec::{\n protocol_types::address::AztecAddress,\n note::{\n note_header::NoteHeader,\n note_interface::NoteInterface,\n utils::compute_note_hash_for_read_or_nullify,\n },\n oracle::{\n rand::rand,\n nullifier_key::get_nullifier_secret_key,\n get_public_key::get_public_key,\n },\n log::emit_encrypted_log,\n hash::pedersen_hash,\n context::PrivateContext,\n};\n\nglobal VALUE_NOTE_LEN: Field = 3; // 3 plus a header.\n\n// docs:start:value-note-def\nstruct ValueNote {\n value: Field,\n owner: AztecAddress,\n randomness: Field,\n header: NoteHeader,\n}\n// docs:end:value-note-def\n\nimpl ValueNote {\n pub fn new(value: Field, owner: AztecAddress) -> Self {\n let randomness = rand();\n let header = NoteHeader::empty();\n ValueNote {\n value,\n owner,\n randomness,\n header,\n }\n }\n\n pub fn serialize(self) -> [Field; VALUE_NOTE_LEN] {\n [self.value, self.owner.to_field(), self.randomness]\n }\n\n pub fn deserialize(serialized_note: [Field; VALUE_NOTE_LEN]) -> Self {\n ValueNote {\n value: serialized_note[0],\n owner: AztecAddress::from_field(serialized_note[1]),\n randomness: serialized_note[2],\n header: NoteHeader::empty(),\n }\n }\n\n pub fn compute_note_hash(self) -> Field {\n // TODO(#1205) Should use a non-zero generator index.\n pedersen_hash(self.serialize(),0)\n }\n\n // docs:start:nullifier\n\n pub fn compute_nullifier(self, context: &mut PrivateContext) -> Field {\n let note_hash_for_nullify = compute_note_hash_for_read_or_nullify(ValueNoteMethods, self);\n let secret = context.request_nullifier_secret_key(self.owner);\n // TODO(#1205) Should use a non-zero generator index.\n pedersen_hash([\n note_hash_for_nullify,\n secret.low,\n secret.high,\n ],0)\n }\n\n // docs:end:nullifier\n\n pub fn compute_nullifier_without_context(self) -> Field {\n let note_hash_for_nullify = compute_note_hash_for_read_or_nullify(ValueNoteMethods, self);\n let secret = get_nullifier_secret_key(self.owner);\n // TODO(#1205) Should use a non-zero generator index.\n pedersen_hash([\n note_hash_for_nullify,\n secret.low,\n secret.high,\n ],0)\n }\n\n pub fn set_header(&mut self, header: NoteHeader) {\n self.header = header;\n }\n\n // Broadcasts the note as an encrypted log on L1.\n pub fn broadcast(self, context: &mut PrivateContext, slot: Field) {\n let encryption_pub_key = get_public_key(self.owner);\n emit_encrypted_log(\n context,\n (*context).this_address(),\n slot,\n encryption_pub_key,\n self.serialize(),\n );\n }\n}\n\nfn deserialize(serialized_note: [Field; VALUE_NOTE_LEN]) -> ValueNote {\n ValueNote::deserialize(serialized_note)\n}\n\nfn serialize(note: ValueNote) -> [Field; VALUE_NOTE_LEN] {\n note.serialize()\n}\n\nfn compute_note_hash(note: ValueNote) -> Field {\n note.compute_note_hash()\n}\n\nfn compute_nullifier(note: ValueNote, context: &mut PrivateContext) -> Field {\n note.compute_nullifier(context)\n}\n\nfn compute_nullifier_without_context(note: ValueNote) -> Field {\n note.compute_nullifier_without_context()\n}\n\nfn get_header(note: ValueNote) -> NoteHeader {\n note.header\n}\n\nfn set_header(note: &mut ValueNote, header: NoteHeader) {\n note.set_header(header)\n}\n\n// Broadcasts the note as an encrypted log on L1.\nfn broadcast(context: &mut PrivateContext, slot: Field, note: ValueNote) {\n note.broadcast(context, slot);\n}\n\nglobal ValueNoteMethods = NoteInterface {\n deserialize,\n serialize,\n compute_note_hash,\n compute_nullifier,\n compute_nullifier_without_context,\n get_header,\n set_header,\n broadcast,\n};\n", - "path": "/home/santiago/Projects/aztec3-packages/aztec-nr/value-note/src/value_note.nr" - } - } -} diff --git a/yarn-project/circuits.js/package.json b/yarn-project/circuits.js/package.json index 1384c153fc4..f6192beede0 100644 --- a/yarn-project/circuits.js/package.json +++ b/yarn-project/circuits.js/package.json @@ -21,7 +21,8 @@ "tsconfig": "./tsconfig.json" }, "scripts": { - "build": "yarn clean && tsc -b", + "build": "yarn clean && yarn generate && tsc -b", + "generate": "./scripts/copy-contracts.sh", "build:dev": "tsc -b --watch", "clean": "rm -rf ./dest .tsbuildinfo", "formatting": "run -T prettier --check ./src && run -T eslint ./src", diff --git a/yarn-project/circuits.js/scripts/copy-contracts.sh b/yarn-project/circuits.js/scripts/copy-contracts.sh new file mode 100755 index 00000000000..d64da5b967a --- /dev/null +++ b/yarn-project/circuits.js/scripts/copy-contracts.sh @@ -0,0 +1,5 @@ +#! /bin/bash +set -euo pipefail +mkdir -p ./fixtures + +cp "../../noir-projects/noir-contracts/target/benchmarking_contract-Benchmarking.json" ./fixtures/Benchmarking.test.json diff --git a/yarn-project/circuits.js/src/contract/__snapshots__/contract_class.test.ts.snap b/yarn-project/circuits.js/src/contract/__snapshots__/contract_class.test.ts.snap index 72fa7b91f5d..5dc051a1f5f 100644 --- a/yarn-project/circuits.js/src/contract/__snapshots__/contract_class.test.ts.snap +++ b/yarn-project/circuits.js/src/contract/__snapshots__/contract_class.test.ts.snap @@ -9,18 +9,18 @@ exports[`ContractClass creates a contract class from a contract compilation arti "selector": { "value": 2381782501 }, - "bytecode": "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", + "bytecode": "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", "isInternal": false }, { "selector": { "value": 2603445359 }, - "bytecode": "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", + "bytecode": "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", "isInternal": false } ], - "packedBytecode": "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", + "packedBytecode": "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", "privateFunctions": [ { "selector": { @@ -44,8 +44,8 @@ exports[`ContractClass creates a contract class from a contract compilation arti "isInternal": false } ], - "id": "0x09ad0dad993129857629f13ec2f3463d0c15615bd35266d0fb26c8793c6ee050", + "id": "0x14984eeda340fba89c656a26cd74e08be8fc849619982aa26f94077a897f56a6", "privateFunctionsRoot": "0x05fa82a96814b6294d557d507151f7ccc12f70522ec4d9d0395a90e87e8087c6", - "publicBytecodeCommitment": "0x05a06c2ee54a742daa2fa43a111c03335df68ff89fd8e7ba938ca2efb225c885" + "publicBytecodeCommitment": "0x0bf394d6e8a18153fea19434af4dba812bd80872d27c85d18c5e4ec7046172f6" }" `; diff --git a/yarn-project/circuits.js/src/contract/artifact_hash.test.ts b/yarn-project/circuits.js/src/contract/artifact_hash.test.ts index c3b04e7feaa..84c3517fc4b 100644 --- a/yarn-project/circuits.js/src/contract/artifact_hash.test.ts +++ b/yarn-project/circuits.js/src/contract/artifact_hash.test.ts @@ -5,7 +5,7 @@ describe('ArtifactHash', () => { it('calculates the artifact hash', () => { const artifact = getSampleContractArtifact(); expect(computeArtifactHash(artifact).toString()).toMatchInlineSnapshot( - `"0x242a46b1aa0ed341fe71f1068a1289cdbb01fbef14e2250783333cc0607db940"`, + `"0x2136048d7b91f63060c3dc03417c0b2835eac99ab393a87fc6e4ccfb3d65e5bc"`, ); }); }); diff --git a/yarn-project/types/src/abi/contract_artifact.ts b/yarn-project/types/src/abi/contract_artifact.ts index 8faf80a682b..4096888503c 100644 --- a/yarn-project/types/src/abi/contract_artifact.ts +++ b/yarn-project/types/src/abi/contract_artifact.ts @@ -7,7 +7,13 @@ import { FunctionType, } from '@aztec/foundation/abi'; -import { NoirCompiledContract } from '../noir/index.js'; +import { + AZTEC_INTERNAL_ATTRIBUTE, + AZTEC_PRIVATE_ATTRIBUTE, + AZTEC_PUBLIC_ATTRIBUTE, + AZTEC_PUBLIC_VM_ATTRIBUTE, + NoirCompiledContract, +} from '../noir/index.js'; import { mockVerificationKey } from './mocked_keys.js'; /** @@ -98,8 +104,13 @@ type NoirCompiledContractFunction = NoirCompiledContract['functions'][number]; * @returns Function artifact. */ function generateFunctionArtifact(fn: NoirCompiledContractFunction): FunctionArtifact { - const functionType = fn.function_type.toLowerCase() as FunctionType; - const isInternal = fn.is_internal; + if (fn.custom_attributes === undefined) { + throw new Error( + `No custom attributes found for contract function ${fn.name}. Try rebuilding the contract with the latest nargo version.`, + ); + } + const functionType = getFunctionType(fn); + const isInternal = fn.custom_attributes.includes(AZTEC_INTERNAL_ATTRIBUTE); // If the function is not unconstrained, the first item is inputs or CallContext which we should omit let parameters = fn.abi.parameters.map(generateFunctionParameter); @@ -125,6 +136,22 @@ function generateFunctionArtifact(fn: NoirCompiledContractFunction): FunctionArt }; } +function getFunctionType(fn: NoirCompiledContractFunction): FunctionType { + if (fn.custom_attributes.includes(AZTEC_PRIVATE_ATTRIBUTE)) { + return FunctionType.SECRET; + } else if ( + fn.custom_attributes.includes(AZTEC_PUBLIC_ATTRIBUTE) || + fn.custom_attributes.includes(AZTEC_PUBLIC_VM_ATTRIBUTE) + ) { + return FunctionType.OPEN; + } else if (fn.is_unconstrained) { + return FunctionType.UNCONSTRAINED; + } else { + // Default to a private function (see simple_macro_example_expanded for an example of this behavior) + return FunctionType.SECRET; + } +} + /** * Returns true if the first parameter is kernel function inputs. * diff --git a/yarn-project/types/src/noir/index.ts b/yarn-project/types/src/noir/index.ts index 65d7c88cb29..097129d74fb 100644 --- a/yarn-project/types/src/noir/index.ts +++ b/yarn-project/types/src/noir/index.ts @@ -7,8 +7,11 @@ import { EventAbi, } from '@aztec/foundation/abi'; -/** The Aztec.nr function types. */ -type NoirFunctionType = 'Open' | 'Secret' | 'Unconstrained'; +export const AZTEC_PRIVATE_ATTRIBUTE = 'aztec(private)'; +export const AZTEC_PUBLIC_ATTRIBUTE = 'aztec(public)'; +export const AZTEC_PUBLIC_VM_ATTRIBUTE = 'aztec(public-vm)'; +export const AZTEC_INTERNAL_ATTRIBUTE = 'aztec(internal)'; +export const AZTEC_INITIALIZER_ATTRIBUTE = 'aztec(initializer)'; /** The witness indices of the parameters. */ type ParamWitnessIndices = { /** Start */ start: number; /** End */ end: number }; @@ -40,10 +43,10 @@ export interface NoirFunctionAbi { export interface NoirFunctionEntry { /** The name of the function. */ name: string; - /** The type of the function. */ - function_type: NoirFunctionType; - /** Whether the function is internal. */ - is_internal: boolean; + /** Whether the function is unconstrained. */ + is_unconstrained: boolean; + /** Custom attributes attached to function */ + custom_attributes: string[]; /** The ABI of the function. */ abi: NoirFunctionAbi; /** The bytecode of the function in base64. */