@aztec-labs/standard-contracts 6.0.0-rc.2 → 6.0.0-rc.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/artifacts/AuthRegistry.json +198 -170
- package/artifacts/HandshakeRegistry.json +592 -475
- package/artifacts/MultiCallEntrypoint.json +157 -129
- package/artifacts/PublicChecks.json +158 -104
- package/dest/handshake-registry/constants.d.ts +1 -1
- package/dest/handshake-registry/constants.d.ts.map +1 -1
- package/dest/handshake-registry/constants.js +1 -0
- package/dest/make_standard_contract.d.ts +1 -1
- package/dest/make_standard_contract.d.ts.map +1 -1
- package/dest/make_standard_contract.js +1 -0
- package/dest/standard_contract_data.js +16 -16
- package/package.json +5 -4
- package/src/handshake-registry/constants.ts +1 -0
- package/src/make_standard_contract.ts +1 -0
- package/src/standard_contract_data.ts +16 -16
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"file_map": {
|
|
3
|
-
"
|
|
3
|
+
"107": {
|
|
4
4
|
"function_locations": [
|
|
5
5
|
{
|
|
6
6
|
"name": "AztecConfig::new",
|
|
@@ -28,17 +28,17 @@
|
|
|
28
28
|
},
|
|
29
29
|
{
|
|
30
30
|
"name": "generate_offchain_receive",
|
|
31
|
-
"start":
|
|
31
|
+
"start": 11363
|
|
32
32
|
},
|
|
33
33
|
{
|
|
34
34
|
"name": "check_each_fn_macroified",
|
|
35
|
-
"start":
|
|
35
|
+
"start": 13024
|
|
36
36
|
}
|
|
37
37
|
],
|
|
38
|
-
"path": "/
|
|
39
|
-
"source": "mod compute_note_hash_and_nullifier;\n\nuse crate::{\n macros::{\n calls_generation::{\n external_functions::{generate_external_function_calls, generate_external_function_self_calls_structs},\n internal_functions::generate_call_internal_struct,\n },\n dispatch::generate_public_dispatch,\n emit_public_init_nullifier::generate_emit_public_init_nullifier,\n internals_functions_generation::{create_fn_abi_exports, process_functions},\n offchain_receive::{\n OFFCHAIN_RECEIVE_FN_NAME, OFFCHAIN_RECEIVE_PARAM_NAME, offchain_receive_param_type,\n OFFCHAIN_RECEIVE_RETURN_TYPE,\n },\n storage::STORAGE_LAYOUT_NAME,\n utils::{is_fn_contract_library_method, is_fn_external, is_fn_internal, is_fn_test, module_has_storage},\n },\n messages::discovery::{CustomMessageHandler, CustomSyncHandler},\n};\n\nuse compute_note_hash_and_nullifier::generate_contract_library_methods_compute_note_hash_and_nullifier;\n\n/// Configuration for the [`aztec`] macro.\n///\n/// This type lets users override different parts of the default aztec-nr contract behavior, such\n/// as message handling and state synchronization. These are advanced features that require careful\n/// understanding of the behavior of these systems.\n///\n/// ## Examples\n///\n/// ```noir\n/// #[aztec(aztec::macros::AztecConfig::new().custom_message_handler(my_handler))]\n/// contract MyContract { ... }\n/// ```\npub struct AztecConfig {\n custom_message_handler: Option<CustomMessageHandler>,\n custom_sync_state: Option<CustomSyncHandler>,\n}\n\nimpl AztecConfig {\n /// Creates a new `AztecConfig` with default values.\n ///\n /// Calling `new` is equivalent to invoking the [`aztec`] macro with no parameters. The different methods\n /// (e.g. [`AztecConfig::custom_message_handler`]) can then be used to change the default behavior.\n pub comptime fn new() -> Self {\n Self { custom_message_handler: Option::none(), custom_sync_state: Option::none() }\n }\n\n /// Sets a handler for custom messages.\n ///\n /// This enables contracts to process non-standard messages (i.e. any with a message type that is not in\n /// [`crate::messages::msg_type`]).\n ///\n /// `handler` must be a function that conforms to the\n /// [`crate::messages::discovery::CustomMessageHandler`] type signature.\n pub comptime fn custom_message_handler(&mut self, handler: CustomMessageHandler) -> Self {\n self.custom_message_handler = Option::some(handler);\n *self\n }\n\n /// Overrides the default state synchronization logic.\n ///\n /// The generated `sync_state` function will call `handler` instead of\n /// [`crate::messages::discovery::do_sync_state`]. The handler receives all of the same parameters, so it can\n /// run custom logic (e.g. fetching and decrypting custom logs) before, after, or instead of calling\n /// `do_sync_state`.\n ///\n /// `handler` must be a function that conforms to the\n /// [`crate::messages::discovery::CustomSyncHandler`] type signature.\n pub comptime fn custom_sync_state(&mut self, handler: CustomSyncHandler) -> Self {\n self.custom_sync_state = Option::some(handler);\n *self\n }\n}\n\n/// Enables aztec-nr features on a `contract`.\n///\n/// All aztec-nr contracts should have this macro invoked on them, as it is the one that processes all contract\n/// functions, notes, storage, generates interfaces for external calls, and creates the message processing\n/// boilerplate.\n///\n/// ## Examples\n///\n/// Most contracts can simply invoke the macro with no parameters, resulting in default aztec-nr behavior:\n/// ```noir\n/// #[aztec]\n/// contract MyContract { ... }\n/// ```\n///\n/// Advanced contracts can use [`AztecConfig`] to customize parts of its behavior, such as message\n/// processing.\n/// ```noir\n/// #[aztec(aztec::macros::AztecConfig::new().custom_message_handler(my_handler))]\n/// contract MyAdvancedContract { ... }\n/// ```\n#[varargs]\npub comptime fn aztec(m: Module, args: [AztecConfig]) -> Quoted {\n let num_args = args.len();\n let config = if num_args == 0 {\n AztecConfig::new()\n } else if num_args == 1 {\n args[0]\n } else {\n panic(f\"#[aztec] expects 0 or 1 arguments, got {num_args}\")\n };\n\n // Functions that don't have #[external(...)], #[contract_library_method], or #[test] are not allowed in contracts.\n check_each_fn_macroified(m);\n\n // We generate new functions prefixed with `__aztec_nr_internals__` and we replace the original functions' bodies\n // with `static_assert(false, ...)` to prevent them from being called directly from within the contract.\n let functions = process_functions(m);\n\n // We generate structs and their implementations necessary for convenient functions calls.\n let interface = generate_contract_interface(m);\n let self_call_structs = generate_external_function_self_calls_structs(m);\n let call_internal_struct = generate_call_internal_struct(m);\n\n // We generate ABI exports for all the external functions in the contract.\n let fn_abi_exports = create_fn_abi_exports(m);\n\n // We generate `_compute_note_hash`, `_compute_note_nullifier` (and the deprecated\n // `_compute_note_hash_and_nullifier` wrapper) only if they are not already implemented.\n // If they are implemented we just insert empty quotes.\n let contract_library_method_compute_note_hash_and_nullifier = if !m.functions().any(|f| {\n // Note that we don't test for `_compute_note_hash` or `_compute_note_nullifier` in order to make this simpler\n // - users must either implement all three or none.\n // Down the line we'll remove this check and use `AztecConfig`.\n f.name() == quote { _compute_note_hash_and_nullifier }\n }) {\n generate_contract_library_methods_compute_note_hash_and_nullifier()\n } else {\n quote {}\n };\n let process_custom_message_option = if config.custom_message_handler.is_some() {\n let handler = config.custom_message_handler.unwrap();\n quote { Option::some($handler) }\n } else {\n quote { Option::<aztec::messages::discovery::CustomMessageHandler>::none() }\n };\n\n let offchain_inbox_sync_option = quote {\n Option::some(aztec::messages::processing::offchain::sync_inbox)\n };\n\n if m.functions().any(|f| f.name() == quote { sync_state }) {\n panic(\n \"User-defined 'sync_state' is not allowed. Use AztecConfig::custom_sync_state() to customize sync behavior.\",\n );\n }\n\n let custom_sync_handler = if config.custom_sync_state.is_some() {\n let handler = config.custom_sync_state.unwrap();\n Option::some(quote { $handler })\n } else {\n Option::none()\n };\n\n let sync_state_fn_and_abi_export = generate_sync_state(\n process_custom_message_option,\n offchain_inbox_sync_option,\n custom_sync_handler,\n );\n\n if m.functions().any(|f| f.name() == quote { offchain_receive }) {\n panic(\n \"User-defined 'offchain_receive' is not allowed. The function is auto-injected by the #[aztec] macro. See https://docs.aztec.network/errors/7\",\n );\n }\n let offchain_receive_fn_and_abi_export = generate_offchain_receive();\n\n let (has_public_init_nullifier_fn, emit_public_init_nullifier_fn_body) = generate_emit_public_init_nullifier(m);\n let public_dispatch = generate_public_dispatch(m, has_public_init_nullifier_fn);\n\n quote {\n $interface\n $self_call_structs\n $call_internal_struct\n $functions\n $fn_abi_exports\n $contract_library_method_compute_note_hash_and_nullifier\n $public_dispatch\n $sync_state_fn_and_abi_export\n $emit_public_init_nullifier_fn_body\n $offchain_receive_fn_and_abi_export\n }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n let calls = generate_external_function_calls(m);\n\n let module_name = m.name();\n\n let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n let storage_layout_getter = if has_storage_layout {\n let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n quote {\n pub fn storage_layout() -> StorageLayoutFields {\n $storage_layout_name.fields\n }\n }\n } else {\n quote {}\n };\n\n let library_storage_layout_getter = if has_storage_layout {\n quote {\n #[contract_library_method]\n $storage_layout_getter\n }\n } else {\n quote {}\n };\n\n quote {\n pub struct $module_name {\n pub target_contract: aztec::protocol::address::AztecAddress\n }\n\n impl $module_name {\n $calls\n\n pub fn at(\n addr: aztec::protocol::address::AztecAddress\n ) -> Self {\n Self { target_contract: addr }\n }\n\n pub fn interface() -> Self {\n Self { target_contract: aztec::protocol::address::AztecAddress::zero() }\n }\n\n $storage_layout_getter\n }\n\n #[contract_library_method]\n pub fn at(\n addr: aztec::protocol::address::AztecAddress\n ) -> $module_name {\n $module_name { target_contract: addr }\n }\n\n #[contract_library_method]\n pub fn interface() -> $module_name {\n $module_name { target_contract: aztec::protocol::address::AztecAddress::zero() }\n }\n\n $library_storage_layout_getter\n\n }\n}\n\n/// Generates the `sync_state` utility function that performs message discovery.\ncomptime fn generate_sync_state(\n process_custom_message_option: Quoted,\n offchain_inbox_sync_option: Quoted,\n custom_sync_handler: Option<Quoted>,\n) -> Quoted {\n let body = if custom_sync_handler.is_some() {\n let handler = custom_sync_handler.unwrap();\n quote {\n $handler(\n address,\n _compute_note_hash,\n _compute_note_nullifier,\n $process_custom_message_option,\n $offchain_inbox_sync_option,\n scope,\n );\n }\n } else {\n quote {\n aztec::messages::discovery::do_sync_state(\n address,\n _compute_note_hash,\n _compute_note_nullifier,\n $process_custom_message_option,\n $offchain_inbox_sync_option,\n scope,\n );\n }\n };\n\n quote {\n pub struct sync_state_parameters {\n pub scope: aztec::protocol::address::AztecAddress,\n }\n\n #[abi(functions)]\n pub struct sync_state_abi {\n parameters: sync_state_parameters,\n }\n\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_utility]\n unconstrained fn sync_state(scope: aztec::protocol::address::AztecAddress) {\n let address = aztec::context::UtilityContext::new().this_address();\n $body\n }\n }\n}\n\n/// Generates an `offchain_receive` utility function that lets callers add messages to the offchain message inbox.\n///\n/// For more details, see `aztec::messages::processing::offchain::receive`.\ncomptime fn generate_offchain_receive() -> Quoted {\n let param_type = offchain_receive_param_type(quote { aztec });\n let parameters_struct_name = f\"{OFFCHAIN_RECEIVE_FN_NAME}_parameters\".quoted_contents();\n let abi_struct_name = f\"{OFFCHAIN_RECEIVE_FN_NAME}_abi\".quoted_contents();\n\n quote {\n pub struct $parameters_struct_name {\n pub $OFFCHAIN_RECEIVE_PARAM_NAME: $param_type,\n }\n\n #[abi(functions)]\n pub struct $abi_struct_name {\n parameters: $parameters_struct_name,\n }\n\n /// Receives offchain messages into this contract's offchain inbox for subsequent processing.\n ///\n /// Each message is routed to the inbox scoped to its `recipient` field.\n ///\n /// For more details, see `aztec::messages::processing::offchain::receive`.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_utility]\n unconstrained fn $OFFCHAIN_RECEIVE_FN_NAME($OFFCHAIN_RECEIVE_PARAM_NAME: $param_type) -> $OFFCHAIN_RECEIVE_RETURN_TYPE {\n let address = aztec::context::UtilityContext::new().this_address();\n aztec::messages::processing::offchain::receive(address, $OFFCHAIN_RECEIVE_PARAM_NAME);\n }\n }\n}\n\n/// Checks that all functions in the module have a context macro applied.\n///\n/// Non-macroified functions are not allowed in contracts. They must all be one of\n/// [`crate::macros::functions::external`], [`crate::macros::functions::internal`] or `test`.\ncomptime fn check_each_fn_macroified(m: Module) {\n for f in m.functions() {\n let name = f.name();\n if !is_fn_external(f) & !is_fn_contract_library_method(f) & !is_fn_internal(f) & !is_fn_test(f) {\n // We don't suggest that #[contract_library_method] is allowed because we don't want to introduce another\n // concept\n panic(\n f\"Function {name} must be marked as either #[external(...)], #[internal(...)], or #[test]\",\n );\n }\n }\n}\n"
|
|
38
|
+
"path": "/mnt/user-data/nicov/node-3/noir-projects/aztec-nr/aztec/src/macros/aztec.nr",
|
|
39
|
+
"source": "mod compute_note_hash_and_nullifier;\n\nuse crate::{\n macros::{\n calls_generation::{\n external_functions::{generate_external_function_calls, generate_external_function_self_calls_structs},\n internal_functions::generate_call_internal_struct,\n },\n dispatch::generate_public_dispatch,\n emit_public_init_nullifier::generate_emit_public_init_nullifier,\n internals_functions_generation::{create_fn_abi_exports, process_functions},\n offchain_receive::{\n OFFCHAIN_RECEIVE_FN_NAME, OFFCHAIN_RECEIVE_PARAM_NAME, offchain_receive_param_type,\n OFFCHAIN_RECEIVE_RETURN_TYPE,\n },\n storage::STORAGE_LAYOUT_NAME,\n utils::{is_fn_contract_library_method, is_fn_external, is_fn_internal, is_fn_test, module_has_storage},\n },\n messages::discovery::{CustomMessageHandler, CustomSyncHandler},\n};\n\nuse compute_note_hash_and_nullifier::generate_contract_library_methods_compute_note_hash_and_nullifier;\n\n/// Configuration for the [`aztec`] macro.\n///\n/// This type lets users override different parts of the default aztec-nr contract behavior, such\n/// as message handling and state synchronization. These are advanced features that require careful\n/// understanding of the behavior of these systems.\n///\n/// ## Examples\n///\n/// ```noir\n/// #[aztec(aztec::macros::AztecConfig::new().custom_message_handler(my_handler))]\n/// contract MyContract { ... }\n/// ```\npub struct AztecConfig {\n custom_message_handler: Option<CustomMessageHandler>,\n custom_sync_state: Option<CustomSyncHandler>,\n}\n\nimpl AztecConfig {\n /// Creates a new `AztecConfig` with default values.\n ///\n /// Calling `new` is equivalent to invoking the [`aztec`] macro with no parameters. The different methods\n /// (e.g. [`AztecConfig::custom_message_handler`]) can then be used to change the default behavior.\n pub comptime fn new() -> Self {\n Self { custom_message_handler: Option::none(), custom_sync_state: Option::none() }\n }\n\n /// Sets a handler for custom messages.\n ///\n /// This enables contracts to process non-standard messages (i.e. any with a message type that is not in\n /// [`crate::messages::msg_type`]).\n ///\n /// `handler` must be a function that conforms to the\n /// [`crate::messages::discovery::CustomMessageHandler`] type signature.\n pub comptime fn custom_message_handler(&mut self, handler: CustomMessageHandler) -> Self {\n self.custom_message_handler = Option::some(handler);\n *self\n }\n\n /// Overrides the default state synchronization logic.\n ///\n /// The generated `sync_state` function will call `handler` instead of\n /// [`crate::messages::discovery::do_sync_state`]. The handler receives all of the same parameters, so it can\n /// run custom logic (e.g. fetching and decrypting custom logs) before, after, or instead of calling\n /// `do_sync_state`.\n ///\n /// `handler` must be a function that conforms to the\n /// [`crate::messages::discovery::CustomSyncHandler`] type signature.\n pub comptime fn custom_sync_state(&mut self, handler: CustomSyncHandler) -> Self {\n self.custom_sync_state = Option::some(handler);\n *self\n }\n}\n\n/// Enables aztec-nr features on a `contract`.\n///\n/// All aztec-nr contracts should have this macro invoked on them, as it is the one that processes all contract\n/// functions, notes, storage, generates interfaces for external calls, and creates the message processing\n/// boilerplate.\n///\n/// ## Examples\n///\n/// Most contracts can simply invoke the macro with no parameters, resulting in default aztec-nr behavior:\n/// ```noir\n/// #[aztec]\n/// contract MyContract { ... }\n/// ```\n///\n/// Advanced contracts can use [`AztecConfig`] to customize parts of its behavior, such as message\n/// processing.\n/// ```noir\n/// #[aztec(aztec::macros::AztecConfig::new().custom_message_handler(my_handler))]\n/// contract MyAdvancedContract { ... }\n/// ```\n#[varargs]\npub comptime fn aztec(m: Module, args: [AztecConfig]) -> Quoted {\n let num_args = args.len();\n let config = if num_args == 0 {\n AztecConfig::new()\n } else if num_args == 1 {\n args[0]\n } else {\n panic(f\"#[aztec] expects 0 or 1 arguments, got {num_args}\")\n };\n\n // Functions that don't have #[external(...)], #[contract_library_method], or #[test] are not allowed in contracts.\n check_each_fn_macroified(m);\n\n // We generate new functions prefixed with `__aztec_nr_internals__` and we replace the original functions' bodies\n // with `static_assert(false, ...)` to prevent them from being called directly from within the contract.\n let functions = process_functions(m);\n\n // We generate structs and their implementations necessary for convenient functions calls.\n let interface = generate_contract_interface(m);\n let self_call_structs = generate_external_function_self_calls_structs(m);\n let call_internal_struct = generate_call_internal_struct(m);\n\n // We generate ABI exports for all the external functions in the contract.\n let fn_abi_exports = create_fn_abi_exports(m);\n\n // We generate `_compute_note_hash`, `_compute_note_nullifier` (and the deprecated\n // `_compute_note_hash_and_nullifier` wrapper) only if they are not already implemented.\n // If they are implemented we just insert empty quotes.\n let contract_library_method_compute_note_hash_and_nullifier = if !m.functions().any(|f| {\n // Note that we don't test for `_compute_note_hash` or `_compute_note_nullifier` in order to make this simpler\n // - users must either implement all three or none.\n // Down the line we'll remove this check and use `AztecConfig`.\n f.name() == quote { _compute_note_hash_and_nullifier }\n }) {\n generate_contract_library_methods_compute_note_hash_and_nullifier()\n } else {\n quote {}\n };\n let process_custom_message_option = if config.custom_message_handler.is_some() {\n let handler = config.custom_message_handler.unwrap();\n quote { Option::some($handler) }\n } else {\n quote { Option::<aztec::messages::discovery::CustomMessageHandler>::none() }\n };\n\n let offchain_inbox_sync_option = quote {\n Option::some(aztec::messages::processing::offchain::sync_inbox)\n };\n\n if m.functions().any(|f| f.name() == quote { sync_state }) {\n panic(\n \"User-defined 'sync_state' is not allowed. Use AztecConfig::custom_sync_state() to customize sync behavior.\",\n );\n }\n\n let custom_sync_handler = if config.custom_sync_state.is_some() {\n let handler = config.custom_sync_state.unwrap();\n Option::some(quote { $handler })\n } else {\n Option::none()\n };\n\n let sync_state_fn_and_abi_export = generate_sync_state(\n process_custom_message_option,\n offchain_inbox_sync_option,\n custom_sync_handler,\n );\n\n if m.functions().any(|f| f.name() == quote { offchain_receive }) {\n panic(\n \"User-defined 'offchain_receive' is not allowed. The function is auto-injected by the #[aztec] macro. See https://docs.aztec.network/errors/7\",\n );\n }\n let offchain_receive_fn_and_abi_export = generate_offchain_receive();\n\n let (has_public_init_nullifier_fn, emit_public_init_nullifier_fn_body) = generate_emit_public_init_nullifier(m);\n let public_dispatch = generate_public_dispatch(m, has_public_init_nullifier_fn);\n\n quote {\n $interface\n $self_call_structs\n $call_internal_struct\n $functions\n $fn_abi_exports\n $contract_library_method_compute_note_hash_and_nullifier\n $public_dispatch\n $sync_state_fn_and_abi_export\n $emit_public_init_nullifier_fn_body\n $offchain_receive_fn_and_abi_export\n }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n let calls = generate_external_function_calls(m);\n\n let module_name = m.name();\n\n let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n let storage_layout_getter = if has_storage_layout {\n let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n quote {\n pub fn storage_layout() -> StorageLayoutFields {\n $storage_layout_name.fields\n }\n }\n } else {\n quote {}\n };\n\n let library_storage_layout_getter = if has_storage_layout {\n quote {\n #[contract_library_method]\n $storage_layout_getter\n }\n } else {\n quote {}\n };\n\n quote {\n pub struct $module_name {\n pub target_contract: aztec::protocol::address::AztecAddress\n }\n\n impl $module_name {\n $calls\n\n pub fn at(\n addr: aztec::protocol::address::AztecAddress\n ) -> Self {\n Self { target_contract: addr }\n }\n\n pub fn interface() -> Self {\n Self { target_contract: aztec::protocol::address::AztecAddress::zero() }\n }\n\n $storage_layout_getter\n }\n\n #[contract_library_method]\n pub fn at(\n addr: aztec::protocol::address::AztecAddress\n ) -> $module_name {\n $module_name { target_contract: addr }\n }\n\n #[contract_library_method]\n pub fn interface() -> $module_name {\n $module_name { target_contract: aztec::protocol::address::AztecAddress::zero() }\n }\n\n $library_storage_layout_getter\n\n }\n}\n\n/// Generates the `sync_state` utility function that performs message discovery.\ncomptime fn generate_sync_state(\n process_custom_message_option: Quoted,\n offchain_inbox_sync_option: Quoted,\n custom_sync_handler: Option<Quoted>,\n) -> Quoted {\n let body = if custom_sync_handler.is_some() {\n let handler = custom_sync_handler.unwrap();\n quote {\n $handler(\n address,\n _compute_note_hash,\n _compute_note_nullifier,\n $process_custom_message_option,\n $offchain_inbox_sync_option,\n scope,\n );\n }\n } else {\n quote {\n aztec::messages::discovery::do_sync_state(\n address,\n _compute_note_hash,\n _compute_note_nullifier,\n $process_custom_message_option,\n $offchain_inbox_sync_option,\n scope,\n );\n }\n };\n\n quote {\n pub struct sync_state_parameters {\n pub scope: aztec::protocol::address::AztecAddress,\n }\n\n #[abi(functions)]\n pub struct sync_state_abi {\n parameters: sync_state_parameters,\n }\n\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_utility]\n unconstrained fn sync_state(scope: aztec::protocol::address::AztecAddress) {\n aztec::oracle::version::assert_compatible_oracle_version();\n let address = aztec::context::UtilityContext::new().this_address();\n $body\n }\n }\n}\n\n/// Generates an `offchain_receive` utility function that lets callers add messages to the offchain message inbox.\n///\n/// For more details, see `aztec::messages::processing::offchain::receive`.\ncomptime fn generate_offchain_receive() -> Quoted {\n let param_type = offchain_receive_param_type(quote { aztec });\n let parameters_struct_name = f\"{OFFCHAIN_RECEIVE_FN_NAME}_parameters\".quoted_contents();\n let abi_struct_name = f\"{OFFCHAIN_RECEIVE_FN_NAME}_abi\".quoted_contents();\n\n quote {\n pub struct $parameters_struct_name {\n pub $OFFCHAIN_RECEIVE_PARAM_NAME: $param_type,\n }\n\n #[abi(functions)]\n pub struct $abi_struct_name {\n parameters: $parameters_struct_name,\n }\n\n /// Receives offchain messages into this contract's offchain inbox for subsequent processing.\n ///\n /// Each message is routed to the inbox scoped to its `recipient` field.\n ///\n /// For more details, see `aztec::messages::processing::offchain::receive`.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_utility]\n unconstrained fn $OFFCHAIN_RECEIVE_FN_NAME($OFFCHAIN_RECEIVE_PARAM_NAME: $param_type) -> $OFFCHAIN_RECEIVE_RETURN_TYPE {\n aztec::oracle::version::assert_compatible_oracle_version();\n let address = aztec::context::UtilityContext::new().this_address();\n aztec::messages::processing::offchain::receive(address, $OFFCHAIN_RECEIVE_PARAM_NAME);\n }\n }\n}\n\n/// Checks that all functions in the module have a context macro applied.\n///\n/// Non-macroified functions are not allowed in contracts. They must all be one of\n/// [`crate::macros::functions::external`], [`crate::macros::functions::internal`] or `test`.\ncomptime fn check_each_fn_macroified(m: Module) {\n for f in m.functions() {\n let name = f.name();\n if !is_fn_external(f) & !is_fn_contract_library_method(f) & !is_fn_internal(f) & !is_fn_test(f) {\n // We don't suggest that #[contract_library_method] is allowed because we don't want to introduce another\n // concept\n panic(\n f\"Function {name} must be marked as either #[external(...)], #[internal(...)], or #[test]\",\n );\n }\n }\n}\n"
|
|
40
40
|
},
|
|
41
|
-
"
|
|
41
|
+
"112": {
|
|
42
42
|
"function_locations": [
|
|
43
43
|
{
|
|
44
44
|
"name": "generate_public_dispatch",
|
|
@@ -65,10 +65,10 @@
|
|
|
65
65
|
"start": 12320
|
|
66
66
|
}
|
|
67
67
|
],
|
|
68
|
-
"path": "/
|
|
68
|
+
"path": "/mnt/user-data/nicov/node-3/noir-projects/aztec-nr/aztec/src/macros/dispatch.nr",
|
|
69
69
|
"source": "use crate::macros::internals_functions_generation::external_functions_registry::get_public_functions;\nuse crate::protocol::meta::utils::get_params_len_quote;\nuse crate::utils::cmap::CHashMap;\nuse super::functions::initialization_utils::EMIT_PUBLIC_INIT_NULLIFIER_FN_NAME;\nuse super::utils::compute_fn_selector;\n\n/// Minimum number of public functions that must share a parameter-type signature before we extract a shared\n/// unpack helper. See [compute_unpack_prelude] for the rationale behind the chosen value.\nglobal EXTRACTION_THRESHOLD: u32 = 4;\n\n/// Generates a `public_dispatch` function for an Aztec contract module `m`.\n///\n/// The generated function dispatches public calls based on selector to the appropriate contract function. If\n/// `generate_emit_public_init_nullifier` is true, it also handles dispatch to the macro-generated\n/// `__emit_public_init_nullifier` function.\n///\n/// Alongside `public_dispatch`, this also emits one `__aztec_nr_internals__unpack_arguments_<N>` helper per\n/// parameter-type signature shared by enough public functions; see [compute_unpack_prelude] for the extraction\n/// criterion.\npub comptime fn generate_public_dispatch(m: Module, generate_emit_public_init_nullifier: bool) -> Quoted {\n let functions = get_public_functions(m);\n\n let unit = get_type::<()>();\n\n // Count how many public functions share each parameter-type signature, so we can decide which signatures are\n // worth extracting into helpers.\n let signature_counts = &mut CHashMap::<Quoted, u32>::new();\n for function in functions {\n let parameters = function.parameters().map(|param| (param.name(), param.typ()));\n if parameters.len() != 0 {\n let key = signature_key(parameters);\n let prior = signature_counts.get(key).unwrap_or(0);\n signature_counts.insert(key, prior + 1);\n }\n }\n\n let seen_selectors = &mut CHashMap::<Field, Quoted>::new();\n let signature_to_helper_idx = &mut CHashMap::<Quoted, u32>::new();\n // The helper function definitions, in the order they were created.\n let unpack_helpers: &mut [Quoted] = &mut @[];\n\n let mut ifs = functions.map(|function: FunctionDefinition| {\n let parameters = function.parameters().map(|param| (param.name(), param.typ()));\n let return_type = function.return_type();\n\n let fn_name = function.name();\n let selector: Field = compute_fn_selector(fn_name, parameters);\n\n // Since function selectors are computed as the first 4 bytes of the hash of the function signature, it's\n // possible to have collisions. With the following check, we ensure it doesn't happen within the same contract.\n let existing_fn = seen_selectors.get(selector);\n if existing_fn.is_some() {\n let existing_fn = existing_fn.unwrap();\n panic(\n f\"Public function selector collision detected between functions '{fn_name}' and '{existing_fn}'\",\n );\n }\n seen_selectors.insert(selector, fn_name);\n\n let (unpack_prelude, call_args) = compute_unpack_prelude(\n parameters,\n signature_counts,\n signature_to_helper_idx,\n unpack_helpers,\n );\n\n // We call a function whose name is prefixed with `__aztec_nr_internals__`. This is necessary because the\n // original function is intentionally made uncallable, preventing direct invocation within the contract.\n // Instead, a new function with the same name, but prefixed by `__aztec_nr_internals__`, has been generated to\n // be called here. For more details see the `process_functions` function.\n let name = f\"__aztec_nr_internals__{fn_name}\".quoted_contents();\n let call = quote { $name($call_args) };\n\n let return_code = if return_type == unit {\n quote {\n $call;\n // Force early return.\n aztec::oracle::avm::avm_return([]);\n }\n } else {\n quote {\n let return_value = aztec::protocol::traits::Serialize::serialize($call);\n aztec::oracle::avm::avm_return(return_value.as_vector());\n }\n };\n\n let if_ = quote {\n if selector == $selector {\n $unpack_prelude\n $return_code\n }\n };\n if_\n });\n\n // If we injected the auto-generated public function to emit the public initialization nullifier, then\n // we'll also need to handle its dispatch.\n if generate_emit_public_init_nullifier {\n let name = EMIT_PUBLIC_INIT_NULLIFIER_FN_NAME;\n let init_nullifier_selector: Field = compute_fn_selector(name, @[]);\n\n ifs = ifs.push_back(\n quote {\n if selector == $init_nullifier_selector {\n $name();\n aztec::oracle::avm::avm_return([]);\n }\n },\n );\n }\n\n if ifs.len() == 0 {\n // No dispatch function if there are no public functions\n quote {}\n } else {\n let ifs = ifs.push_back(quote { panic(f\"Unknown selector {selector}\") });\n let dispatch = ifs.join(quote { });\n\n let helpers = (*unpack_helpers).join(quote { });\n\n let body = quote {\n $helpers\n\n // We mark this as public because our whole system depends on public functions having this attribute.\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n pub unconstrained fn public_dispatch(selector: Field) {\n $dispatch\n }\n };\n\n body\n }\n}\n\n/// Canonical Quoted representation of a parameter list's types, used as the deduplication key for unpack helpers.\ncomptime fn signature_key(parameters: [(Quoted, Type)]) -> Quoted {\n parameters\n .map(|param: (Quoted, Type)| {\n let param_type = param.1;\n quote { $param_type }\n })\n .join(quote { , })\n}\n\n/// Builds the dispatch-arm prelude for a public function and the comma-separated arg list to pass through to the call.\n///\n/// If the function's signature reaches `EXTRACTION_THRESHOLD`, the prelude reuses (or creates) a shared\n/// `__aztec_nr_internals__unpack_arguments_<N>` helper. Otherwise the calldata read is inlined, matching the\n/// pre-extraction shape; this avoids paying the helper-call overhead on signatures that would not benefit from the\n/// shared body.\n///\n/// The real break-even depends on the size of the inlined boilerplate at each call site (which scales with the\n/// parameter types' `stream_deserialize` cost), not just the share count: a signature with one `Field` arg inlines\n/// to a few opcodes per site, while a signature like `(AztecAddress, U128, PartialUintNote)` inlines into many. For\n/// now we approximate that with a single share-count threshold, which is the simplest knob that keeps the macro\n/// readable. If we ever want to be more precise we can size each helper against its per-site savings.\ncomptime fn compute_unpack_prelude(\n parameters: [(Quoted, Type)],\n signature_counts: &mut CHashMap<Quoted, u32>,\n signature_to_helper_idx: &mut CHashMap<Quoted, u32>,\n unpack_helpers: &mut [Quoted],\n) -> (Quoted, Quoted) {\n if parameters.len() == 0 {\n (quote {}, quote {})\n } else {\n let sig_key = signature_key(parameters);\n let count = signature_counts.get(sig_key).unwrap_or(0);\n let shared = count >= EXTRACTION_THRESHOLD;\n\n let mut arg_names: [Quoted] = @[];\n for parameter_index in 0..parameters.len() {\n let arg_name = f\"arg{parameter_index}\".quoted_contents();\n arg_names = arg_names.push_back(arg_name);\n }\n let args = arg_names.join(quote { , });\n\n let prelude = if shared {\n let existing_idx = signature_to_helper_idx.get(sig_key);\n let helper_idx = if existing_idx.is_some() {\n existing_idx.unwrap()\n } else {\n let new_idx = (*unpack_helpers).len();\n signature_to_helper_idx.insert(sig_key, new_idx);\n let helper_def = build_unpack_helper(new_idx, parameters);\n *unpack_helpers = (*unpack_helpers).push_back(helper_def);\n new_idx\n };\n let helper_name = f\"__aztec_nr_internals__unpack_arguments_{helper_idx}\".quoted_contents();\n if parameters.len() == 1 {\n quote { let arg0 = $helper_name(); }\n } else {\n quote { let ($args) = $helper_name(); }\n }\n } else {\n inline_unpack(parameters)\n };\n\n (prelude, args)\n }\n}\n\n/// Inlined calldata read + per-parameter `stream_deserialize` for signatures that are not worth extracting.\ncomptime fn inline_unpack(parameters: [(Quoted, Type)]) -> Quoted {\n let params_len_quote = get_params_len_quote(parameters);\n let initial_read = quote {\n let input_calldata: [Field; $params_len_quote] = aztec::oracle::avm::calldata_copy(1, $params_len_quote);\n let mut reader = aztec::protocol::utils::reader::Reader::new(input_calldata);\n };\n\n let mut read_quotes: [Quoted] = @[];\n for parameter_index in 0..parameters.len() {\n let arg_name = f\"arg{parameter_index}\".quoted_contents();\n let param_type = parameters[parameter_index].1;\n read_quotes = read_quotes.push_back(\n quote {\n let $arg_name: $param_type = aztec::protocol::traits::Deserialize::stream_deserialize(&mut reader);\n },\n );\n }\n let reads = read_quotes.join(quote { });\n\n quote {\n $initial_read\n $reads\n }\n}\n\n/// Emits the `#[inline_never]` helper that reads calldata for one specific parameter-type signature.\n///\n/// Returns a single value when there is only one parameter, and a tuple when there are several. Marked\n/// `#[inline_never]` (and therefore `unconstrained`) so each entry point can call into the same compiled body.\ncomptime fn build_unpack_helper(idx: u32, parameters: [(Quoted, Type)]) -> Quoted {\n let helper_name = f\"__aztec_nr_internals__unpack_arguments_{idx}\".quoted_contents();\n let params_len_quote = get_params_len_quote(parameters);\n\n // The initial calldata_copy offset is 1 to skip the Field selector. The expected calldata is the serialization\n // of:\n // - FunctionSelector: the selector of the function intended to dispatch\n // - Parameters: the parameters of the function intended to dispatch\n // That is, exactly what is expected for a call to the target function, but with a selector added at the\n // beginning.\n let initial_read = quote {\n let input_calldata: [Field; $params_len_quote] = aztec::oracle::avm::calldata_copy(1, $params_len_quote);\n let mut reader = aztec::protocol::utils::reader::Reader::new(input_calldata);\n };\n\n let mut read_quotes: [Quoted] = @[];\n let mut arg_quotes: [Quoted] = @[];\n let mut type_quotes: [Quoted] = @[];\n for parameter_index in 0..parameters.len() {\n let arg_name = f\"arg{parameter_index}\".quoted_contents();\n let param_type = parameters[parameter_index].1;\n read_quotes = read_quotes.push_back(\n quote {\n let $arg_name: $param_type = aztec::protocol::traits::Deserialize::stream_deserialize(&mut reader);\n },\n );\n arg_quotes = arg_quotes.push_back(arg_name);\n type_quotes = type_quotes.push_back(quote { $param_type });\n }\n let reads = read_quotes.join(quote { });\n let return_args = arg_quotes.join(quote { , });\n\n if parameters.len() == 1 {\n let only_type = parameters[0].1;\n quote {\n #[inline_never]\n #[contract_library_method]\n unconstrained fn $helper_name() -> $only_type {\n $initial_read\n $reads\n arg0\n }\n }\n } else {\n let return_types = type_quotes.join(quote { , });\n quote {\n #[inline_never]\n #[contract_library_method]\n unconstrained fn $helper_name() -> ($return_types) {\n $initial_read\n $reads\n ($return_args)\n }\n }\n }\n}\n\ncomptime fn get_type<T>() -> Type {\n let t: T = std::mem::zeroed();\n std::meta::type_of(t)\n}\n"
|
|
70
70
|
},
|
|
71
|
-
"
|
|
71
|
+
"123": {
|
|
72
72
|
"function_locations": [
|
|
73
73
|
{
|
|
74
74
|
"name": "generate_public_self_creator_from_context",
|
|
@@ -83,7 +83,7 @@
|
|
|
83
83
|
"start": 4225
|
|
84
84
|
}
|
|
85
85
|
],
|
|
86
|
-
"path": "/
|
|
86
|
+
"path": "/mnt/user-data/nicov/node-3/noir-projects/aztec-nr/aztec/src/macros/internals_functions_generation/external/public.nr",
|
|
87
87
|
"source": "use crate::macros::{\n internals_functions_generation::external::helpers::{create_authorize_once_check, get_abi_relevant_attributes},\n utils::{\n fn_has_authorize_once, fn_has_noinitcheck, is_fn_initializer, is_fn_only_self, is_fn_view,\n module_has_initializer, module_has_storage,\n },\n};\n\n/// Emits a per-contract helper that creates the `self` value from a `PublicContext` already in scope.\n///\n/// This is the shared helper used by both:\n/// - public external functions, via [`generate_public_self_creator`], which constructs a fresh `PublicContext` from\n/// `calldata_copy` and then delegates to this helper; and\n/// - public internal functions and `#[contract_library_method]` bodies, which already receive `context` as a\n/// parameter and call this helper directly to skip the `calldata_copy` step.\npub(crate) comptime fn generate_public_self_creator_from_context(m: Module) -> Quoted {\n let (storage_type, storage_init) = if module_has_storage(m) {\n (quote { Storage<aztec::context::PublicContext> }, quote { let storage = Storage::init(context); })\n } else {\n // Contract does not have Storage defined, so we set storage to the unit type `()`. ContractSelfPublic requires\n // a storage struct in its constructor. Using an Option type would lead to worse developer experience and\n // higher constraint counts so we use the unit type `()` instead.\n (quote { () }, quote { let storage = (); })\n };\n\n quote {\n #[contract_library_method]\n unconstrained fn __aztec_nr_internals__create_public_self_from_context(context: aztec::context::PublicContext) -> aztec::contract_self::ContractSelfPublic<$storage_type, CallSelf<aztec::context::PublicContext>, CallSelfStatic<aztec::context::PublicContext>, CallInternal<aztec::context::PublicContext>> {\n $storage_init\n let self_address = context.this_address();\n let call_self: CallSelf<aztec::context::PublicContext> = CallSelf { address: self_address, context };\n let call_self_static: CallSelfStatic<aztec::context::PublicContext> = CallSelfStatic { address: self_address, context };\n let internal: CallInternal<aztec::context::PublicContext> = CallInternal { context };\n aztec::contract_self::ContractSelfPublic::new(context, storage, call_self, call_self_static, internal)\n }\n }\n}\n\n/// Generates the per-contract helper that builds public `self`.\n///\n/// Each public external function calls this helper instead of inlining the construction, so the same preamble does not\n/// appear duplicated in every public function body. We let Noir's inliner decide whether to inline the helper at each\n/// call site rather than forcing it via macro expansion.\n///\n/// The helper is generic over the calldata length `N` because `PublicContext::new` takes a closure that reads `N`\n/// fields from calldata. Noir monomorphizes one copy per distinct `N`, so public functions with the same number of\n/// serialized args reuse the same compiled code.\npub(crate) comptime fn generate_public_self_creator(m: Module) -> Quoted {\n let storage_type = if module_has_storage(m) {\n quote { Storage<aztec::context::PublicContext> }\n } else {\n quote { () }\n };\n\n quote {\n #[contract_library_method]\n unconstrained fn __aztec_nr_internals__create_public_self<let N: u32>() -> aztec::contract_self::ContractSelfPublic<$storage_type, CallSelf<aztec::context::PublicContext>, CallSelfStatic<aztec::context::PublicContext>, CallInternal<aztec::context::PublicContext>> {\n // Unlike in the private case, in public the `context` does not need to receive the hash of the original\n // params.\n let context = aztec::context::PublicContext::new(|| {\n // We start from 1 because we skip the selector for the dispatch function.\n let serialized_args : [Field; N] = aztec::oracle::avm::calldata_copy(1, N);\n aztec::hash::hash_args(serialized_args)\n });\n __aztec_nr_internals__create_public_self_from_context(context)\n }\n }\n}\n\npub(crate) comptime fn generate_public_external(f: FunctionDefinition) -> Quoted {\n let module_has_initializer = module_has_initializer(f.module());\n\n // Public functions undergo a lot of transformations from their Aztec.nr form.\n let original_params = f.parameters().map(|param| (param.name(), param.typ()));\n\n let args_len_quote = if original_params.len() == 0 {\n // If the function has no parameters, we set the args_len to 0.\n quote { 0 }\n } else {\n // The following will give us <type_of_struct_member_1 as Serialize>::N + <type_of_struct_member_2 as\n // Serialize>::N + ...\n original_params\n .map(|(_, param_type): (Quoted, Type)| {\n quote {\n <$param_type as $crate::protocol::traits::Serialize>::N\n }\n })\n .join(quote {+})\n };\n\n let contract_self_creation = quote {\n #[allow(unused_variables)]\n let mut self = __aztec_nr_internals__create_public_self::<$args_len_quote>();\n };\n\n let original_function_name = f.name();\n\n // Modifications introduced by the different marker attributes.\n let internal_check = if is_fn_only_self(f) {\n let assertion_message = f\"Function {original_function_name} can only be called by the same contract\";\n quote { assert(self.msg_sender() == self.address, $assertion_message); }\n } else {\n quote {}\n };\n\n let view_check = if is_fn_view(f) {\n let assertion_message = f\"Function {original_function_name} can only be called statically\".as_quoted_str();\n quote { assert(self.context.is_static_call(), $assertion_message); }\n } else {\n quote {}\n };\n\n let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n (\n quote {\n aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_public(self.context);\n },\n quote {\n aztec::macros::functions::initialization_utils::mark_as_initialized_from_public_initializer(self.context);\n },\n )\n } else {\n (quote {}, quote {})\n };\n\n // Initialization checks are not included in contracts that don't have initializers.\n let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n quote { aztec::macros::functions::initialization_utils::assert_is_initialized_public(self.context); }\n } else {\n quote {}\n };\n\n // Inject the authwit check if the function is marked with #[authorize_once].\n let authorize_once_check = if fn_has_authorize_once(f) {\n create_authorize_once_check(f, false)\n } else {\n quote {}\n };\n\n let to_prepend = quote {\n $contract_self_creation\n $assert_initializer\n $init_check\n $internal_check\n $view_check\n $authorize_once_check\n };\n\n // `mark_as_initialized` is placed after the user's function body. If it ran at the beginning, the contract\n // would appear initialized while the initializer is still running, allowing contracts called by the initializer\n // to re-enter into a half-initialized contract.\n let to_append = quote {\n $mark_as_initialized\n };\n\n let fn_name = f\"__aztec_nr_internals__{original_function_name}\".quoted_contents();\n let body = f.body();\n let return_type = f.return_type();\n\n // New function parameters are the same as the original function's ones.\n let params = original_params.map(|(param_name, param_type)| quote { $param_name: $param_type }).join(quote {, });\n\n // Preserve all attributes that are relevant to the function's ABI.\n let abi_relevant_attributes = get_abi_relevant_attributes(f);\n\n // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n // bytecode.\n quote {\n #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n $abi_relevant_attributes\n unconstrained fn $fn_name($params) -> pub $return_type {\n $to_prepend\n $body\n $to_append\n }\n }\n}\n"
|
|
88
88
|
},
|
|
89
89
|
"15": {
|
|
@@ -430,7 +430,7 @@
|
|
|
430
430
|
"path": "std/field/mod.nr",
|
|
431
431
|
"source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n __assert_max_bit_size(self, BIT_SIZE);\n }\n\n /// Decomposes `self` into its little endian bit decomposition as a `[bool; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits<let N: u32>(self: Self) -> [bool; N] {\n // docs:end:to_le_bits\n let bits = __to_le_bits(self);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[bool; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits<let N: u32>(self: Self) -> [bool; N] {\n // docs:end:to_be_bits\n let bits = __to_be_bits(self);\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n __to_le_radix(self, radix)\n }\n\n fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n __to_be_radix(self, radix)\n }\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [bool; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = false if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = true.\n pub fn sgn0(self) -> bool {\n (self as u8) % 2 == 1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n ///\n /// # Failures\n /// `N` must be no greater than the number of bytes required to represent the field modulus\n // docs:start:from_le_bytes\n pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n // docs:end:from_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n ///\n /// # Failures\n /// `N` must be no greater than the number of bytes required to represent the field modulus\n // docs:start:from_be_bytes\n pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n // docs:end:from_be_bytes\n static_assert(\n N <= modulus_be_bytes().len(),\n \"N must be less than or equal to modulus_be_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a little endian byte array to a field element, asserting that the input is a\n /// canonical representation (strictly less than the field modulus).\n ///\n /// # Failures\n /// Causes a constraint failure if `bytes` encodes a value greater than or equal to the\n /// field modulus.\n // docs:start:from_le_bytes_checked\n pub fn from_le_bytes_checked<let N: u32>(bytes: [u8; N]) -> Field {\n // docs:end:from_le_bytes_checked\n let p = modulus_le_bytes();\n let mut ok = N != p.len();\n for i in 0..N {\n if !ok {\n if bytes[N - 1 - i] != p[N - 1 - i] {\n assert(\n bytes[N - 1 - i] < p[N - 1 - i],\n \"input bytes are not a canonical field representation\",\n );\n ok = true;\n }\n }\n }\n assert(ok, \"input bytes are not a canonical field representation\");\n Field::from_le_bytes(bytes)\n }\n\n /// Convert a big endian byte array to a field element, asserting that the input is a\n /// canonical representation (strictly less than the field modulus).\n ///\n /// # Failures\n /// Causes a constraint failure if `bytes` encodes a value greater than or equal to the\n /// field modulus.\n // docs:start:from_be_bytes_checked\n pub fn from_be_bytes_checked<let N: u32>(bytes: [u8; N]) -> Field {\n // docs:end:from_be_bytes_checked\n let p = modulus_be_bytes();\n let mut ok = N != p.len();\n for i in 0..N {\n if !ok {\n if bytes[i] != p[i] {\n assert(bytes[i] < p[i], \"input bytes are not a canonical field representation\");\n ok = true;\n }\n }\n }\n assert(ok, \"input bytes are not a canonical field representation\");\n Field::from_be_bytes(bytes)\n }\n}\n\n#[builtin(apply_range_constraint)]\nfn __assert_max_bit_size(value: Field, bit_size: u32) {}\n\n// `_radix` must be less than 256\n#[builtin(to_le_radix)]\nfn __to_le_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n// `_radix` must be less than 256\n#[builtin(to_be_radix)]\nfn __to_be_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n/// Decomposes `self` into its little endian bit decomposition as a `[bool; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_le_bits)]\nfn __to_le_bits<let N: u32>(value: Field) -> [bool; N] {}\n\n/// Decomposes `self` into its big endian bit decomposition as a `[bool; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_be_bits)]\nfn __to_be_bits<let N: u32>(value: Field) -> [bool; N] {}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [bool] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [bool] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime, static_assert};\n use super::{\n field_less_than, modulus_be_bits, modulus_be_bytes, modulus_le_bits, modulus_le_bytes,\n };\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [bool; 8] = field.to_be_bits();\n assert_eq(bits, [false, false, false, false, false, false, true, false]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [bool; 8] = field.to_le_bits();\n assert_eq(bits, [false, true, false, false, false, false, false, false]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(\"radix must be greater than 1\");\n }\n }\n\n // Updated test to account for Brillig restriction that radix must be greater than 2\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_brillig_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 1;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(\"radix must be greater than 1\");\n }\n }\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(\"radix must be less than or equal to 256\")\n }\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 16 limbs\")]\n unconstrained fn not_enough_limbs_brillig() {\n let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 16 limbs\")]\n fn not_enough_limbs() {\n let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 0 limbs\")]\n unconstrained fn non_zero_field_to_le_bytes_zero_limbs() {\n let _: [u8; 0] = 5.to_le_bytes();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 0 limbs\")]\n unconstrained fn non_zero_field_to_be_bytes_zero_limbs() {\n let _: [u8; 0] = 5.to_be_bytes();\n }\n\n #[test]\n unconstrained fn zero_field_to_bytes_zero_limbs_unconstrained() {\n assert_eq((0 as Field).to_le_bytes::<0>().len(), 0);\n assert_eq((0 as Field).to_be_bytes::<0>().len(), 0);\n assert_eq((0 as Field).to_le_bits::<0>().len(), 0);\n assert_eq((0 as Field).to_be_bits::<0>().len(), 0);\n }\n\n #[test]\n fn zero_field_to_bytes_zero_limbs_constrained() {\n assert_eq((0 as Field).to_le_bytes::<0>().len(), 0);\n assert_eq((0 as Field).to_be_bytes::<0>().len(), 0);\n assert_eq((0 as Field).to_le_bits::<0>().len(), 0);\n assert_eq((0 as Field).to_be_bits::<0>().len(), 0);\n }\n\n #[test]\n fn zero_field_to_bytes_zero_limbs_comptime() {\n let _: [u8; 0] = comptime { (0 as Field).to_le_bytes() };\n let _: [u8; 0] = comptime { (0 as Field).to_be_bytes() };\n let _: [bool; 0] = comptime { (0 as Field).to_le_bits() };\n let _: [bool; 0] = comptime { (0 as Field).to_be_bits() };\n }\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n\n #[test]\n unconstrained fn test_large_field_values_unconstrained() {\n let large_field = 0xffffffffffffffff;\n\n let bits: [bool; 64] = large_field.to_le_bits();\n assert_eq(bits[0], true);\n\n let bytes: [u8; 8] = large_field.to_le_bytes();\n assert_eq(Field::from_le_bytes::<8>(bytes), large_field);\n\n let radix_bytes: [u8; 8] = large_field.to_le_radix(256);\n assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_field);\n }\n\n #[test]\n fn test_large_field_values() {\n let large_val = 0xffffffffffffffff;\n\n let bits: [bool; 64] = large_val.to_le_bits();\n assert_eq(bits[0], true);\n\n let bytes: [u8; 8] = large_val.to_le_bytes();\n assert_eq(Field::from_le_bytes::<8>(bytes), large_val);\n\n let radix_bytes: [u8; 8] = large_val.to_le_radix(256);\n assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_val);\n }\n\n #[test]\n fn test_decomposition_edge_cases() {\n let zero_bits: [bool; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [false; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [bool; 8] = 1.to_le_bits();\n let expected: [bool; 8] = [true, false, false, false, false, false, false, false];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [bool; 8] = 4.to_le_bits();\n let expected: [bool; 8] = [false, false, true, false, false, false, false, false];\n assert_eq(pow2_bits, expected);\n }\n\n #[test]\n fn test_pow_32() {\n assert_eq(2.pow_32(3), 8);\n assert_eq(3.pow_32(2), 9);\n assert_eq(5.pow_32(0), 1);\n assert_eq(7.pow_32(1), 7);\n\n assert_eq(2.pow_32(10), 1024);\n\n assert_eq(0.pow_32(5), 0);\n assert_eq(0.pow_32(0), 1);\n\n assert_eq(1.pow_32(100), 1);\n }\n\n #[test]\n fn test_sgn0() {\n assert_eq(0.sgn0(), false);\n assert_eq(2.sgn0(), false);\n assert_eq(4.sgn0(), false);\n assert_eq(100.sgn0(), false);\n\n assert_eq(1.sgn0(), true);\n assert_eq(3.sgn0(), true);\n assert_eq(5.sgn0(), true);\n assert_eq(101.sgn0(), true);\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 8 limbs\")]\n fn test_bit_decomposition_overflow() {\n // 8 bits can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [bool; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_from_le_bytes_checked_accepts_modulus_minus_one() {\n if crate::compat::is_bn254() {\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n let p_minus_1 = Field::from_le_bytes_checked::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n }\n }\n\n #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n fn test_from_le_bytes_checked_rejects_modulus() {\n if crate::compat::is_bn254() {\n let _ = Field::from_le_bytes_checked::<32>(modulus_le_bytes().as_array());\n } else {\n panic(\"input bytes are not a canonical field representation\");\n }\n }\n\n #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n fn test_from_le_bytes_checked_rejects_modulus_plus_one() {\n if crate::compat::is_bn254() {\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n let _ = Field::from_le_bytes_checked::<32>(p_plus_1_bytes);\n } else {\n panic(\"input bytes are not a canonical field representation\");\n }\n }\n\n #[test]\n fn test_from_be_bytes_checked_accepts_modulus_minus_one() {\n if crate::compat::is_bn254() {\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n let p_minus_1 = Field::from_be_bytes_checked::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n }\n }\n\n #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n fn test_from_be_bytes_checked_rejects_modulus() {\n if crate::compat::is_bn254() {\n let _ = Field::from_be_bytes_checked::<32>(modulus_be_bytes().as_array());\n } else {\n panic(\"input bytes are not a canonical field representation\");\n }\n }\n\n #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n fn test_from_be_bytes_checked_rejects_modulus_plus_one() {\n if crate::compat::is_bn254() {\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n let _ = Field::from_be_bytes_checked::<32>(p_plus_1_bytes);\n } else {\n panic(\"input bytes are not a canonical field representation\");\n }\n }\n\n #[test]\n fn test_from_bytes_checked_small_n() {\n // For N < modulus_bytes().len(), the input cannot overflow the modulus, so the checked\n // variants behave identically to the unchecked ones.\n let le_bytes: [u8; 8] = [3, 1, 0, 0, 0, 0, 0, 0];\n assert_eq(Field::from_le_bytes_checked::<8>(le_bytes), 259);\n let be_bytes: [u8; 8] = [0, 0, 0, 0, 0, 0, 1, 3];\n assert_eq(Field::from_be_bytes_checked::<8>(be_bytes), 259);\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits<let N: u32>(bits: [bool; N]) -> Field {\n static_assert(\n N <= modulus_le_bits().len(),\n \"N must be less than or equal to modulus_le_bits().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bits[i] as Field) * v;\n v = v * 2;\n }\n result\n }\n\n /// Convert a big endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_be_bits<let N: u32>(bits: [bool; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bits[N - 1 - i] as Field) * v;\n v = v * 2;\n }\n result\n }\n\n #[test]\n fn test_to_from_be_bits_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this bit produces the expected 254 BE bits for (modulus - 1)\n let mut p_minus_1_bits: [bool; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1]);\n p_minus_1_bits[254 - 1] = false;\n\n let p_minus_1 = from_be_bits::<254>(p_minus_1_bits);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n let p_minus_1_converted_bits: [bool; 254] = p_minus_1.to_be_bits();\n assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n // checking that incrementing this bit produces 254 BE bits for (modulus + 4)\n let mut p_plus_4_bits: [bool; 254] = modulus_be_bits().as_array();\n assert(!p_plus_4_bits[254 - 3]);\n p_plus_4_bits[254 - 3] = true;\n\n let p_plus_4 = from_be_bits::<254>(p_plus_4_bits);\n assert_eq(p_plus_4, 4);\n\n // checking that converting p_plus_4 to 254 BE bits produces the same\n // bit set to 1 as p_plus_4_bits and otherwise zeroes\n let mut p_plus_4_converted_bits: [bool; 254] = p_plus_4.to_be_bits();\n assert(p_plus_4_converted_bits[254 - 3]);\n p_plus_4_converted_bits[254 - 3] = false;\n assert_eq(p_plus_4_converted_bits, [false; 254]);\n\n // checking that Field::from_be_bits::<254> on the Field modulus produces 0\n assert_eq(modulus_be_bits().len(), 254);\n let p = from_be_bits::<254>(modulus_be_bits().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 254 BE bits produces 254 false values\n let p_bits: [bool; 254] = 0.to_be_bits();\n assert_eq(p_bits, [false; 254]);\n }\n }\n\n #[test]\n fn test_to_from_le_bits_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this bit produces the expected 254 LE bits for (modulus - 1)\n let mut p_minus_1_bits: [bool; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0]);\n p_minus_1_bits[0] = false;\n\n let p_minus_1 = from_le_bits::<254>(p_minus_1_bits);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n let p_minus_1_converted_bits: [bool; 254] = p_minus_1.to_le_bits();\n assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n // checking that incrementing this bit produces 254 LE bits for (modulus + 4)\n let mut p_plus_4_bits: [bool; 254] = modulus_le_bits().as_array();\n assert(!p_plus_4_bits[2]);\n p_plus_4_bits[2] = true;\n\n let p_plus_4 = from_le_bits::<254>(p_plus_4_bits);\n assert_eq(p_plus_4, 4);\n\n // checking that converting p_plus_4 to 254 LE bits produces the same\n // bit set to 1 as p_plus_4_bits and otherwise zeroes\n let mut p_plus_4_converted_bits: [bool; 254] = p_plus_4.to_le_bits();\n assert(p_plus_4_converted_bits[2]);\n p_plus_4_converted_bits[2] = false;\n assert_eq(p_plus_4_converted_bits, [false; 254]);\n\n // checking that Field::from_le_bits::<254> on the Field modulus produces 0\n assert_eq(modulus_le_bits().len(), 254);\n let p = from_le_bits::<254>(modulus_le_bits().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 254 LE bits produces 254 false values\n let p_bits: [bool; 254] = 0.to_le_bits();\n assert_eq(p_bits, [false; 254]);\n }\n }\n\n #[test(should_fail_with = \"call to assert_max_bit_size\")]\n fn max_bit_size_too_large() {\n let x: Field = 0x010000;\n x.assert_max_bit_size::<16>();\n }\n\n}\n"
|
|
432
432
|
},
|
|
433
|
-
"
|
|
433
|
+
"167": {
|
|
434
434
|
"function_locations": [
|
|
435
435
|
{
|
|
436
436
|
"name": "receive",
|
|
@@ -477,98 +477,98 @@
|
|
|
477
477
|
"start": 11760
|
|
478
478
|
}
|
|
479
479
|
],
|
|
480
|
-
"path": "/
|
|
480
|
+
"path": "/mnt/user-data/nicov/node-3/noir-projects/aztec-nr/aztec/src/messages/processing/offchain/mod.nr",
|
|
481
481
|
"source": "use crate::{\n context::UtilityContext,\n ephemeral::EphemeralArray,\n messages::{encoding::MESSAGE_CIPHERTEXT_LEN, processing::OffchainMessageWithTx},\n oracle::{contract_sync::set_contract_sync_cache_invalid, tx_resolution::get_resolved_txs},\n protocol::{address::AztecAddress, traits::{Deserialize, Serialize}},\n};\n\nmod reception;\nuse reception::{MAX_ANCHOR_FUTURE_SKEW, OffchainReception};\n\n/// Maximum number of offchain messages accepted by `offchain_receive` in a single call.\npub global MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL: u32 = 16;\n\n/// A function that manages offchain-delivered messages for processing during sync.\n///\n/// Offchain messages are messages that are not broadcasted via onchain logs. They are instead delivered to the\n/// recipient by calling the `offchain_receive` utility function (injected by the `#[aztec]` macro). Message transport\n/// is the app's responsibility. Typical examples of transport methods are: messaging apps, email, QR codes, etc.\n///\n/// Once offchain messages are delivered to the recipient's private environment via `offchain_receive`, messages are\n/// locally stored in a persistent inbox.\n///\n/// This function determines when each message in said inbox is ready for processing, when it can be safely disposed\n/// of, etc.\n///\n/// The only current implementation of an [`OffchainInboxSync`] is [`sync_inbox`], which manages an inbox with\n/// expiration and finality-based eviction and automatic transaction context resolution.\npub type OffchainInboxSync = unconstrained fn(\n/* contract_address */AztecAddress, /* scope */ AztecAddress) -> EphemeralArray<OffchainMessageWithTx>;\n\n/// Delivers offchain messages to the given contract's offchain inbox for subsequent processing.\n///\n/// Offchain messages are transaction effects that are not broadcasted via onchain logs. Instead, the sender shares the\n/// message to the recipient through an external channel (e.g. a URL accessible by the recipient). The recipient then\n/// calls this function to hand the messages to the contract so they can be processed through the same mechanisms as\n/// onchain messages.\n///\n/// Messages are processed when their originating transaction is found onchain (providing the context needed to\n/// validate resulting notes and events).\n///\n/// Messages are eventually removed from the inbox: an unprocessed message once its TTL (`anchor_block_timestamp +\n/// MAX_MSG_TTL`) elapses, and a processed message once the block its transaction was found in finalizes.\n///\n/// Processing order is not guaranteed.\npub unconstrained fn receive(\n contract_address: AztecAddress,\n messages: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL>,\n) {\n // Offchain reception facts are scoped to the recipient. Note that because offchain messages have no integrity or\n // authenticity checks it is not possible to verify that this is indeed the intended recipient. In this case we're\n // assuming a cooperative environment, which is on par with other offchain delivery expectations.\n //\n // The sender-supplied anchor timestamp is the one field we bound: a message claiming to originate implausibly far\n // in our future (see MAX_ANCHOR_FUTURE_SKEW) cannot be genuine, and accepting it would let a malicious anchor evade\n // the TTL-based inbox eviction. We reject such a batch by panicking instead of silently dropping the message, so\n // the calling wallet can react to it (e.g. surface the error or distrust the sender).\n let now = UtilityContext::new().timestamp();\n messages.for_each(|msg| {\n assert(\n msg.anchor_block_timestamp <= now + MAX_ANCHOR_FUTURE_SKEW,\n \"offchain message anchor timestamp is implausibly far in the future\",\n );\n });\n\n messages.for_each(|msg| OffchainReception::init(contract_address, msg));\n\n // Clear cache for message recipients so the next sync runs.\n set_contract_sync_cache_invalid(contract_address, messages.map(|msg| msg.recipient));\n}\n\n/// Returns offchain-delivered messages to process during sync.\npub unconstrained fn sync_inbox(\n contract_address: AztecAddress,\n scope: AztecAddress,\n) -> EphemeralArray<OffchainMessageWithTx> {\n let active_receptions = OffchainReception::load_all(contract_address, scope);\n\n // Ask PXE to resolve each message's originating tx. We pass the tx hashes in reception order, so the resolved txs\n // come back aligned with the reception indices and can be matched back positionally.\n let resolved_txs = get_resolved_txs(active_receptions.map(|reception: OffchainReception| {\n reception.read_message().tx_hash.unwrap_or(0)\n }));\n\n let processable_messages: EphemeralArray<OffchainMessageWithTx> = EphemeralArray::empty();\n let now = UtilityContext::new().timestamp();\n\n active_receptions.for_each(|i, reception| {\n let maybe_message = reception.step(resolved_txs.get(i), now);\n if maybe_message.is_some() {\n processable_messages.push(maybe_message.unwrap());\n }\n });\n\n processable_messages\n}\n\n/// A message delivered via the `offchain_receive` utility function.\n#[derive(Serialize, Deserialize)]\npub struct OffchainMessage {\n /// The encrypted message payload.\n pub ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n /// The intended recipient of the message.\n pub recipient: AztecAddress,\n /// The hash of the transaction that produced this message. `Option::none` indicates a tx-less message.\n pub tx_hash: Option<Field>,\n /// Anchor block timestamp at message emission.\n pub anchor_block_timestamp: u64,\n}\n\nmod test {\n use crate::{\n oracle::random::random,\n protocol::{address::AztecAddress, constants::MAX_TX_LIFETIME},\n test::helpers::test_environment::TestEnvironment,\n };\n use super::{MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL, OffchainMessage, receive, sync_inbox};\n use super::reception::{MAX_ANCHOR_FUTURE_SKEW, MAX_MSG_TTL, OffchainReception};\n\n unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n let mut env = TestEnvironment::new();\n let scope = env.create_light_account();\n (env, scope)\n }\n\n /// Creates an `OffchainMessage` with dummy ciphertext and the given scope as recipient.\n fn make_msg(recipient: AztecAddress, tx_hash: Option<Field>, anchor_block_timestamp: u64) -> OffchainMessage {\n OffchainMessage { ciphertext: BoundedVec::new(), recipient, tx_hash, anchor_block_timestamp }\n }\n\n /// Advances the TXE block timestamp by `offset` seconds and returns the resulting timestamp.\n unconstrained fn advance_by(env: TestEnvironment, offset: u64) -> u64 {\n env.advance_next_block_timestamp_by(offset);\n env.mine_block();\n env.last_block_timestamp()\n }\n\n #[test]\n unconstrained fn empty_inbox_returns_empty_result() {\n let (env, scope) = setup();\n env.utility_context(|context| {\n let address = context.this_address();\n let result = sync_inbox(address, scope);\n\n assert_eq(result.len(), 0);\n assert_eq(OffchainReception::load_all(address, scope).len(), 0);\n });\n }\n\n #[test]\n unconstrained fn multiple_messages_mixed_expiration() {\n let (env, scope) = setup();\n let anchor_ts = advance_by(env, 10);\n\n let expired_a_tx_hash = random();\n let survivor_tx_hash = random();\n\n let expired_a = make_msg(scope, Option::some(expired_a_tx_hash), 0);\n let survivor = make_msg(scope, Option::some(survivor_tx_hash), anchor_ts);\n let expired_b = make_msg(scope, Option::none(), 0);\n\n env.utility_context(|context| {\n let address = context.this_address();\n let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n // Message 0: tx-bound, anchor=0 so it expires quickly.\n msgs.push(expired_a);\n // Message 1: tx-bound, anchor_ts is recent so it survives.\n msgs.push(survivor);\n // Message 2: tx-less, anchor=0 so it also expires.\n msgs.push(expired_b);\n receive(address, msgs);\n });\n\n // Advance past MAX_MSG_TTL for anchor=0, but not for anchor_ts.\n let _now = advance_by(env, MAX_MSG_TTL);\n\n env.utility_context(|context| {\n let address = context.this_address();\n let result = sync_inbox(address, scope);\n\n assert_eq(result.len(), 0); // all contexts are None\n assert(\n !OffchainReception::is_active(address, scope, expired_a),\n \"expired tx-bound reception should be terminated\",\n );\n assert(\n !OffchainReception::is_active(address, scope, expired_b),\n \"expired tx-less reception should be terminated\",\n );\n assert(OffchainReception::is_active(address, scope, survivor), \"survivor reception should stay active\");\n assert_eq(OffchainReception::load_all(address, scope).len(), 1);\n });\n }\n\n #[test]\n unconstrained fn accepts_messages_within_the_tolerated_future_skew() {\n let (env, scope) = setup();\n let now = advance_by(env, 10);\n\n // A present-dated anchor and a 24h-future one both fall within the tolerated skew. The latter models a genuine\n // message whose sender anchored ahead of our lagging PXE, and must still be accepted.\n let present = make_msg(scope, Option::some(random()), now);\n let lagged = make_msg(scope, Option::some(random()), now + MAX_TX_LIFETIME);\n\n env.utility_context(|context| {\n let address = context.this_address();\n receive(address, BoundedVec::from_array([present, lagged]));\n\n assert(OffchainReception::is_active(address, scope, present));\n assert(OffchainReception::is_active(address, scope, lagged));\n assert_eq(OffchainReception::load_all(address, scope).len(), 2);\n });\n }\n\n #[test(should_fail_with = \"offchain message anchor timestamp is implausibly far in the future\")]\n unconstrained fn rejects_batch_with_implausible_future_anchor() {\n let (env, scope) = setup();\n let now = advance_by(env, 10);\n\n // Beyond `now + MAX_ANCHOR_FUTURE_SKEW`: our view would trail the tip by more than a tx lifetime, so this\n // cannot be genuine. Reception panics so the wallet can react rather than accept it.\n let too_future = make_msg(\n scope,\n Option::some(random()),\n now + MAX_ANCHOR_FUTURE_SKEW + 7200,\n );\n\n env.utility_context(|context| { receive(context.this_address(), BoundedVec::from_array([too_future])); });\n }\n\n // -- Idempotent re-delivery (first-write-wins fact recording) ---------\n\n #[test]\n unconstrained fn redelivery_is_idempotent() {\n let (env, scope) = setup();\n let anchor_ts = advance_by(env, 10);\n let msg = make_msg(scope, Option::some(random()), anchor_ts);\n\n // First delivery, committed as its own job.\n env.utility_context(|context| { receive(context.this_address(), BoundedVec::from_array([msg])); });\n\n // Re-delivering the same content-addressed message must not panic and must not create a second reception.\n env.utility_context(|context| {\n let address = context.this_address();\n receive(address, BoundedVec::from_array([msg]));\n\n assert(OffchainReception::is_active(address, scope, msg), \"reception should be active\");\n assert_eq(OffchainReception::load_all(address, scope).len(), 1);\n });\n }\n\n #[test]\n unconstrained fn redelivery_after_processing_keeps_processed_guard() {\n let (env, scope) = setup();\n let known_tx_hash: Field = 1;\n let anchor_ts = advance_by(env, 10);\n let msg = make_msg(scope, Option::some(known_tx_hash), anchor_ts);\n\n env.utility_context(|context| { receive(context.this_address(), BoundedVec::from_array([msg])); });\n\n let _now = advance_by(env, 100);\n\n // First sync resolves the message and marks it as processed.\n env.utility_context(|context| {\n let address = context.this_address();\n assert_eq(sync_inbox(address, scope).len(), 1);\n assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n });\n\n // Re-deliver the same message. The next sync recognizes it as already processed and does not re-push it.\n env.utility_context(|context| {\n let address = context.this_address();\n receive(address, BoundedVec::from_array([msg]));\n\n assert(\n OffchainReception::is_processed(address, scope, msg),\n \"re-delivery must preserve the processed guard\",\n );\n assert_eq(sync_inbox(address, scope).len(), 0);\n });\n }\n}\n"
|
|
482
482
|
},
|
|
483
|
-
"
|
|
483
|
+
"168": {
|
|
484
484
|
"function_locations": [
|
|
485
485
|
{
|
|
486
486
|
"name": "OffchainReception::init",
|
|
487
|
-
"start":
|
|
487
|
+
"start": 9712
|
|
488
488
|
},
|
|
489
489
|
{
|
|
490
490
|
"name": "OffchainReception::load_all",
|
|
491
|
-
"start":
|
|
491
|
+
"start": 10250
|
|
492
492
|
},
|
|
493
493
|
{
|
|
494
494
|
"name": "OffchainReception::read_message",
|
|
495
|
-
"start":
|
|
495
|
+
"start": 10666
|
|
496
496
|
},
|
|
497
497
|
{
|
|
498
498
|
"name": "OffchainReception::id_for",
|
|
499
|
-
"start":
|
|
499
|
+
"start": 11367
|
|
500
500
|
},
|
|
501
501
|
{
|
|
502
502
|
"name": "OffchainReception::is_active",
|
|
503
|
-
"start":
|
|
503
|
+
"start": 11686
|
|
504
504
|
},
|
|
505
505
|
{
|
|
506
506
|
"name": "OffchainReception::step",
|
|
507
|
-
"start":
|
|
507
|
+
"start": 12361
|
|
508
508
|
},
|
|
509
509
|
{
|
|
510
510
|
"name": "OffchainReception::is_processed",
|
|
511
|
-
"start":
|
|
511
|
+
"start": 13966
|
|
512
512
|
},
|
|
513
513
|
{
|
|
514
514
|
"name": "OffchainReception::mark_processed",
|
|
515
|
-
"start":
|
|
515
|
+
"start": 14554
|
|
516
516
|
},
|
|
517
517
|
{
|
|
518
518
|
"name": "OffchainReception::terminate",
|
|
519
|
-
"start":
|
|
519
|
+
"start": 15125
|
|
520
520
|
},
|
|
521
521
|
{
|
|
522
522
|
"name": "to_payload",
|
|
523
|
-
"start":
|
|
523
|
+
"start": 15499
|
|
524
524
|
},
|
|
525
525
|
{
|
|
526
526
|
"name": "test::setup",
|
|
527
|
-
"start":
|
|
527
|
+
"start": 15922
|
|
528
528
|
},
|
|
529
529
|
{
|
|
530
530
|
"name": "test::make_msg",
|
|
531
|
-
"start":
|
|
531
|
+
"start": 16252
|
|
532
532
|
},
|
|
533
533
|
{
|
|
534
534
|
"name": "test::resolved_tx_at_block",
|
|
535
|
-
"start":
|
|
535
|
+
"start": 16536
|
|
536
536
|
},
|
|
537
537
|
{
|
|
538
538
|
"name": "test::resolved_tx",
|
|
539
|
-
"start":
|
|
539
|
+
"start": 16927
|
|
540
540
|
},
|
|
541
541
|
{
|
|
542
542
|
"name": "test::expired_reception_is_terminated",
|
|
543
|
-
"start":
|
|
543
|
+
"start": 17044
|
|
544
544
|
},
|
|
545
545
|
{
|
|
546
546
|
"name": "test::unresolved_reception_stays_active",
|
|
547
|
-
"start":
|
|
547
|
+
"start": 17726
|
|
548
548
|
},
|
|
549
549
|
{
|
|
550
550
|
"name": "test::resolved_reception_is_ready_to_process",
|
|
551
|
-
"start":
|
|
551
|
+
"start": 18521
|
|
552
552
|
},
|
|
553
553
|
{
|
|
554
554
|
"name": "test::already_processed_reception_is_not_re_pushed",
|
|
555
|
-
"start":
|
|
555
|
+
"start": 19567
|
|
556
556
|
},
|
|
557
557
|
{
|
|
558
558
|
"name": "test::processed_reception_terminates_once_its_origin_block_finalizes",
|
|
559
|
-
"start":
|
|
559
|
+
"start": 20941
|
|
560
560
|
},
|
|
561
561
|
{
|
|
562
562
|
"name": "test::unfinalized_processed_reception_survives_past_the_ttl",
|
|
563
|
-
"start":
|
|
563
|
+
"start": 22166
|
|
564
564
|
},
|
|
565
565
|
{
|
|
566
566
|
"name": "test::expired_reception_is_still_processed_when_its_tx_resolves",
|
|
567
|
-
"start":
|
|
567
|
+
"start": 23556
|
|
568
568
|
}
|
|
569
569
|
],
|
|
570
|
-
"path": "/
|
|
571
|
-
"source": "//! The state machine of a single offchain message reception process.\n//!\n//! Offchain processing needs to handle some complexity, including the possibility of reorgs reverting message effects,\n//! and the need to reprocess messages in that case. The state chart below summarizes the current behavior.\n//!\n//! ```text\n//! offchain_receive() (process starts)\n//! |\n//! v\n//! +-----------+ tx found onchain +-----------+\n//! ---- | | --------------------------> | |\n//! tx not found | | | | | discover notes,\n//! |--> | RECEIVED | | PROCESSED | ~~> events, etc\n//! | | <-------------------------- | |\n//! | | tx block re-orged | |\n//! +-----------+ +-----------+\n//! | |\n//! | TTL expired | tx block finalized\n//! v v\n//! +---------------------------------------------------------+\n//! | TERMINATED (process ends) |\n//! +---------------------------------------------------------+\n//! ```\n//!\n//! ## States\n//!\n//! - **Received**: the message is stored but its originating transaction has not been found onchain yet (or the\n//! message is tx-less; see below). While the reception process is in this state, it keeps looking for the\n// transaction onchain.\n//! - **Processed**: the message has been handed off for processing. If there weren't reorgs, reaching this state would\n//! be equivalent to terminating the reception process. Since reorgs are a possibility, this state is not terminal\n//! until the block the originating transaction was found in finalizes.\n//! - **Terminated**: nothing else can be done with the message, either because its originating transaction never\n//! appeared within the TTL, or because the block it was processed in has finalized. This is the terminal state of\n//! this process.\n//!\n//! ## Transitions (each evaluated by [`OffchainReception::step`])\n//!\n//! - **Received -> Processed**: the originating transaction is found onchain. The message (packaged with its\n//! transaction context) is queued to have its actual contents processed (which can lead for example to the discovery\n//! of notes and events).\n//! - **Processed -> Received**: the block where the message transaction was originally found is re-orged out.\n//! - **Received -> Terminated**: the message TTL has elapsed (see below), so the originating transaction can no longer\n//! appear and the message is no longer processable.\n//! - **Processed -> Terminated**: the block the originating transaction was found in has finalized, so the effects of\n//! its processing are permanent and reorg-proof.\n//!\n//! # Message reception lifecycle and the TTL\n//!\n//! A reception expires once `now > anchor_block_timestamp + MAX_MSG_TTL`, where `MAX_MSG_TTL = MAX_TX_LIFETIME + 2h`.\n//! A transaction anchored at a given block can only be mined within\n//! [`MAX_TX_LIFETIME`](crate::protocol::constants::MAX_TX_LIFETIME) of that block, so once that\n//! window (plus a safety margin of 2 hours) has elapsed the originating transaction can no longer appear, and it is\n//! safe to stop looking for it.\n//!\n//! The TTL only matters for unprocessed messages. Already-processed message receptions complete when the block that\n//! included the originating transaction finalizes, which is exactly when the processing becomes reorg-proof.\n//!\n//! # Current limitations, future plans\n//!\n//! - Tx-less messages never reach `Processed` and are only ever removed by expiry. This will be supported in the\n//! future.\n//!\n//! # Implementation\n//!\n//! [`OffchainReception::init`] creates a [fact collection](crate::facts::FactCollection) of type\n//! `OFFCHAIN_RECEPTION_TYPE_ID`. The fact collection is identified by a hash of the `OffchainMessage` it tracks, which\n//! makes duplicate calls to `init` idempotent.\n//!\n//! Upon reception, an `OFFCHAIN_MESSAGE_RECEIVED` [non-retractable fact](crate::facts::record_non_retractable_fact) is\n//! recorded. The fact's payload is the `OffchainMessage` itself, which persists it to be subsequently processed.\n//! A fact collection with just an `OFFCHAIN_MESSAGE_RECEIVED` fact represents an active reception process in the\n//! RECEIVED state from our state chart above.\n//!\n//! The message reception state machine is driven externally, advancing one step at a time each time\n//! [`OffchainReception::step`] is invoked. [`OffchainReception::step`] implements the rest of the reception state\n//! machine described above.\n//!\n//! When stepping, if the transaction to the message is found onchain, an `OFFCHAIN_MESSAGE_PROCESSED`\n//! [retractable fact](crate::facts::record_retractable_fact) associated to the block where the transaction was found is\n//! recorded.\n//! Note that since this fact is retractable, a reorg dropping said block would result in the fact being automatically\n//! removed by PXE, effectively pushing the reception process back to `RECEIVED` state.\n//!\n//! To determine in which state of the reception process we are we just analyze the recorded facts:\n//!\n//! - If there is an `OFFCHAIN_MESSAGE_PROCESSED` fact we are in PROCESSED state. Once that fact's origin block has\n//! finalized the processing is reorg-proof, so the [fact collection](crate::facts::FactCollection) can (and should)\n//! be deleted; until then there is nothing to do.\n//! - If there is only an `OFFCHAIN_MESSAGE_RECEIVED` fact we are in RECEIVED state, so we check if the message\n//! transaction is now available onchain, and if so, exercise the RECEIVED->PROCESSED transition. Otherwise, once the\n//! TTL has elapsed the originating transaction can no longer appear and the collection can (and should) be deleted.\n//!\n//! The PROCESSED->RECEIVED transition is transparently handled by PXE: if a re-org caused the message transaction to\n//! fall off the chain, the `OFFCHAIN_MESSAGE_PROCESSED` fact disappears, taking us back to the RECEIVED state.\n\nuse crate::{\n ephemeral::EphemeralArray,\n facts::{\n delete_fact_collection, Fact, FactCollection, get_fact_collection, get_fact_collections_by_type,\n record_non_retractable_fact, record_retractable_fact,\n },\n messages::processing::OffchainMessageWithTx,\n oracle::{block_reference::BlockReference, tx_resolution::ResolvedTx},\n protocol::{\n address::AztecAddress,\n constants::MAX_TX_LIFETIME,\n hash::{poseidon2_hash, sha256_to_field},\n traits::{Deserialize, Serialize},\n },\n};\nuse super::OffchainMessage;\n\n/// Maximum time-to-live for a tx-bound offchain message.\n///\n/// After `anchor_block_timestamp + MAX_MSG_TTL`, the message is evicted from the inbox.\n/// (7200 == 2 hours)\npub(crate) global MAX_MSG_TTL: u64 = MAX_TX_LIFETIME + 7200;\n\n/// Maximum amount by which a received message's `anchor_block_timestamp` may exceed our current timestamp.\n///\n/// A message's anchor is the timestamp of the block the sender anchored its originating tx to, so for a genuine\n/// message it is at or before our own anchor timestamp. Our PXE may lag the chain tip though, which can make a\n/// legitimate anchor appear to be in our future, so we tolerate a forward skew of `MAX_TX_LIFETIME` (the longest a tx\n/// can wait to be mined after its anchor) plus a 2h margin. A larger skew would mean our view trails the tip by more\n/// than a tx lifetime -- so far behind that we could not even build a tx that wouldn't be immediately expired -- so\n/// such a message cannot be genuine and is rejected on reception. Bounding the anchor this way also keeps accepted\n/// values near the present, which prevents the `anchor_block_timestamp + MAX_MSG_TTL` eviction check from overflowing.\n/// (7200 == 2 hours)\npub(crate) global MAX_ANCHOR_FUTURE_SKEW: u64 = MAX_TX_LIFETIME + 7200;\n\n/// Fact type id of the fact that stores the offchain message body inside a reception collection.\nglobal OFFCHAIN_MESSAGE_RECEIVED: Field = sha256_to_field(\"AZTEC_NR::OFFCHAIN_MESSAGE_RECEIVED\".as_bytes());\n\n/// Fact type id to mark an offchain message as processed.\n///\n/// A reception is in \"processed state\" exactly when its collection carries a fact of this type.\npub(crate) global OFFCHAIN_MESSAGE_PROCESSED: Field =\n sha256_to_field(\"AZTEC_NR::OFFCHAIN_MESSAGE_PROCESSED\".as_bytes());\n\n/// Fact-collection type id shared by every offchain message reception in the [fact store](crate::facts).\npub(crate) global OFFCHAIN_RECEPTION_TYPE_ID: Field =\n sha256_to_field(\"AZTEC_NR::OFFCHAIN_RECEPTION_TYPE_ID\".as_bytes());\n\n/// A single offchain message reception machine, backed by a [`FactCollection`](crate::facts::FactCollection).\n///\n/// Wraps the fact collection that tracks one message's progress through the reception state machine (see the\n/// [module documentation](super)); the [`OffchainMessage`] it carries is decoded on demand.\n#[derive(Deserialize, Serialize)]\npub(crate) struct OffchainReception {\n collection: FactCollection,\n}\n\nimpl OffchainReception {\n /// Initializes a new reception for a freshly received message, in the `Received` state.\n ///\n /// Re-initializing the same message is a no-op, which makes redelivery idempotent.\n pub(crate) unconstrained fn init(contract_address: AztecAddress, message: OffchainMessage) {\n record_non_retractable_fact(\n contract_address,\n message.recipient,\n OFFCHAIN_RECEPTION_TYPE_ID,\n Self::id_for(message),\n OFFCHAIN_MESSAGE_RECEIVED,\n to_payload(message),\n );\n }\n\n /// Loads every active reception for the given contract and scope, decoding each message body.\n pub(crate) unconstrained fn load_all(\n contract_address: AztecAddress,\n scope: AztecAddress,\n ) -> EphemeralArray<OffchainReception> {\n get_fact_collections_by_type(contract_address, scope, OFFCHAIN_RECEPTION_TYPE_ID)\n .map(|collection: FactCollection| OffchainReception { collection })\n }\n\n /// Reads and returns the message this reception carries, decoding it from its fact collection.\n pub(crate) unconstrained fn read_message(self) -> OffchainMessage {\n let message_fact = self.collection.facts.find(|f: Fact| f.fact_type_id == OFFCHAIN_MESSAGE_RECEIVED).unwrap();\n let n = <OffchainMessage as Deserialize>::N;\n let mut fields = [0; <OffchainMessage as Deserialize>::N];\n for i in 0..n {\n fields[i] = message_fact.payload.get(i);\n }\n Deserialize::deserialize(fields)\n }\n\n /// Computes the fact-collection id that identifies a message's reception machine in the [fact store](crate::facts).\n ///\n /// The id is a hash of the message, which makes duplicate receptions of the same message collapse onto a single\n /// reception.\n pub(crate) fn id_for(message: OffchainMessage) -> Field {\n poseidon2_hash(message.serialize())\n }\n\n /// Returns `true` if a reception for `message` is currently active for the given contract and scope.\n pub(crate) unconstrained fn is_active(\n contract_address: AztecAddress,\n scope: AztecAddress,\n message: OffchainMessage,\n ) -> bool {\n get_fact_collection(\n contract_address,\n scope,\n OFFCHAIN_RECEPTION_TYPE_ID,\n Self::id_for(message),\n )\n .is_some()\n }\n\n /// Advances this reception by one step of its state machine. See the [module documentation](super) for the\n /// states, transitions, and expiry rules.\n ///\n /// Returns `Some` with the message and its resolved context when this step determines the message is ready to be\n /// processed.\n pub(crate) unconstrained fn step(\n self,\n maybe_resolved_tx: Option<ResolvedTx>,\n now: u64,\n ) -> Option<OffchainMessageWithTx> {\n let message = self.read_message();\n let processed_fact = self.collection.facts.find(|f: Fact| f.fact_type_id == OFFCHAIN_MESSAGE_PROCESSED);\n\n if processed_fact.is_none() & maybe_resolved_tx.is_some() {\n // Received -> Processed: the originating tx is onchain.\n let resolved = maybe_resolved_tx.unwrap();\n self.mark_processed(resolved.block_number, resolved.block_hash);\n Option::some(\n OffchainMessageWithTx { message_ciphertext: message.ciphertext, resolved_tx: resolved },\n )\n } else if processed_fact.is_some() {\n if processed_fact.unwrap().origin_block.unwrap().block_state.is_finalized() {\n // Processed -> Terminated: once the marker's origin block finalizes, the processing is reorg-proof and\n // the reception is complete. Until then we wait: a reorg dropping that block removes the retractable\n // marker and PXE pushes us back to Received.\n self.terminate();\n }\n Option::none()\n } else {\n // Received -> Terminated: the TTL caps how long we keep looking for the originating tx.\n if now > message.anchor_block_timestamp + MAX_MSG_TTL {\n self.terminate();\n }\n Option::none()\n }\n }\n\n /// Returns `true` if the reception for `message` has been marked processed.\n pub(crate) unconstrained fn is_processed(\n contract_address: AztecAddress,\n scope: AztecAddress,\n message: OffchainMessage,\n ) -> bool {\n let maybe_collection = get_fact_collection(\n contract_address,\n scope,\n OFFCHAIN_RECEPTION_TYPE_ID,\n Self::id_for(message),\n );\n if maybe_collection.is_some() {\n maybe_collection.unwrap().facts.any(|f: Fact| f.fact_type_id == OFFCHAIN_MESSAGE_PROCESSED)\n } else {\n false\n }\n }\n\n /// Records the retractable processed marker for this reception, originated at the resolved block.\n unconstrained fn mark_processed(self, block_number: u32, block_hash: Field) {\n let empty_payload: EphemeralArray<Field> = EphemeralArray::empty();\n record_retractable_fact(\n self.collection.contract_address,\n self.collection.scope,\n self.collection.fact_collection_type_id,\n self.collection.fact_collection_id,\n OFFCHAIN_MESSAGE_PROCESSED,\n empty_payload,\n BlockReference { block_number, block_hash },\n );\n }\n\n /// Terminates this reception by deleting its [fact collection](crate::facts::FactCollection).\n unconstrained fn terminate(self) {\n delete_fact_collection(\n self.collection.contract_address,\n self.collection.scope,\n self.collection.fact_collection_type_id,\n self.collection.fact_collection_id,\n );\n }\n}\n\n/// Serializes an [`OffchainMessage`] into a fact payload.\nunconstrained fn to_payload(message: OffchainMessage) -> EphemeralArray<Field> {\n EphemeralArray::from_array(message.serialize())\n}\n\nmod test {\n use crate::{\n messages::processing::offchain::OffchainMessage,\n oracle::{random::random, tx_resolution::ResolvedTx},\n protocol::address::AztecAddress,\n test::helpers::test_environment::TestEnvironment,\n };\n use super::{MAX_MSG_TTL, OffchainReception};\n\n unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n let mut env = TestEnvironment::new();\n let scope = env.create_light_account();\n (env, scope)\n }\n\n /// Creates an `OffchainMessage` with dummy ciphertext and the given scope as recipient.\n fn make_msg(recipient: AztecAddress, tx_hash: Option<Field>, anchor_block_timestamp: u64) -> OffchainMessage {\n OffchainMessage { ciphertext: BoundedVec::new(), recipient, tx_hash, anchor_block_timestamp }\n }\n\n /// Builds the resolved-tx context PXE would return for `tx_hash`, found in `block_number`.\n fn resolved_tx_at_block(tx_hash: Field, block_number: u32) -> ResolvedTx {\n ResolvedTx {\n tx_hash,\n unique_note_hashes_in_tx: BoundedVec::new(),\n first_nullifier_in_tx: 0,\n block_number,\n block_hash: 0,\n }\n }\n\n /// Builds a resolved-tx context found in a low block, which TXE (proven == finalized == latest) reports as\n /// `Finalized`.\n fn resolved_tx(tx_hash: Field) -> ResolvedTx {\n resolved_tx_at_block(tx_hash, 1)\n }\n\n #[test]\n unconstrained fn expired_reception_is_terminated() {\n let (env, scope) = setup();\n let msg = make_msg(scope, Option::some(random()), 0);\n\n env.utility_context(|context| {\n let address = context.this_address();\n OffchainReception::init(address, msg);\n let reception = OffchainReception::load_all(address, scope).get(0);\n\n // Past the TTL with no resolved tx: the reception is terminated.\n assert(reception.step(Option::none(), MAX_MSG_TTL + 1).is_none());\n assert(!OffchainReception::is_active(address, scope, msg), \"expired reception should be terminated\");\n });\n }\n\n #[test]\n unconstrained fn unresolved_reception_stays_active() {\n let (env, scope) = setup();\n let msg = make_msg(scope, Option::some(random()), 0);\n\n env.utility_context(|context| {\n let address = context.this_address();\n OffchainReception::init(address, msg);\n let reception = OffchainReception::load_all(address, scope).get(0);\n\n // Within the TTL with no resolved tx: nothing to process, the reception stays.\n assert(reception.step(Option::none(), 100).is_none());\n assert(OffchainReception::is_active(address, scope, msg), \"unresolved reception should stay active\");\n assert(!OffchainReception::is_processed(address, scope, msg), \"should still be unprocessed\");\n });\n }\n\n #[test]\n unconstrained fn resolved_reception_is_ready_to_process() {\n let (env, scope) = setup();\n let tx_hash = random();\n let msg = make_msg(scope, Option::some(tx_hash), 0);\n\n env.utility_context(|context| {\n let address = context.this_address();\n OffchainReception::init(address, msg);\n let reception = OffchainReception::load_all(address, scope).get(0);\n\n // A resolved tx within the TTL: the message is handed off with its tx context attached.\n let processable = reception.step(Option::some(resolved_tx(tx_hash)), 100);\n assert(processable.is_some());\n assert_eq(processable.unwrap().resolved_tx.tx_hash, tx_hash);\n\n // It stays active for reorg safety and is now marked processed.\n assert(OffchainReception::is_active(address, scope, msg), \"processed reception should stay active\");\n assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n });\n }\n\n #[test]\n unconstrained fn already_processed_reception_is_not_re_pushed() {\n let (env, scope) = setup();\n let tx_hash = random();\n let msg = make_msg(scope, Option::some(tx_hash), 0);\n // A future origin block stays unfinalized, so the reception lingers in Processed across steps.\n let future_block = env.last_block_number() + 100;\n\n env.utility_context(|context| {\n let address = context.this_address();\n OffchainReception::init(address, msg);\n\n // First step processes the message.\n let reception = OffchainReception::load_all(address, scope).get(0);\n assert(reception.step(Option::some(resolved_tx_at_block(tx_hash, future_block)), 100).is_some());\n assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n\n // Second step (still resolved, not finalized) recognizes it as processed and does not re-push it.\n let reloaded = OffchainReception::load_all(address, scope).get(0);\n assert(\n reloaded.step(Option::some(resolved_tx_at_block(tx_hash, future_block)), 100).is_none(),\n \"already processed\",\n );\n assert(OffchainReception::is_active(address, scope, msg), \"processed reception should still be active\");\n });\n }\n\n #[test]\n unconstrained fn processed_reception_terminates_once_its_origin_block_finalizes() {\n let (env, scope) = setup();\n let tx_hash = random();\n let msg = make_msg(scope, Option::some(tx_hash), 0);\n\n env.utility_context(|context| {\n let address = context.this_address();\n OffchainReception::init(address, msg);\n\n // Process the message against a finalized block.\n let reception = OffchainReception::load_all(address, scope).get(0);\n assert(reception.step(Option::some(resolved_tx(tx_hash)), 100).is_some());\n assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n\n // Next step, still well within the TTL: a finalized origin block makes the processing reorg-proof, so the\n // reception terminates regardless of the TTL.\n let reloaded = OffchainReception::load_all(address, scope).get(0);\n assert(reloaded.step(Option::some(resolved_tx(tx_hash)), 100).is_none());\n assert(\n !OffchainReception::is_active(address, scope, msg),\n \"finalized processed reception should be terminated\",\n );\n });\n }\n\n #[test]\n unconstrained fn unfinalized_processed_reception_survives_past_the_ttl() {\n let (env, scope) = setup();\n let tx_hash = random();\n let msg = make_msg(scope, Option::some(tx_hash), 0);\n // A future origin block never finalizes here, so the reception must not be terminated by the TTL.\n let future_block = env.last_block_number() + 100;\n\n env.utility_context(|context| {\n let address = context.this_address();\n OffchainReception::init(address, msg);\n\n let reception = OffchainReception::load_all(address, scope).get(0);\n assert(reception.step(Option::some(resolved_tx_at_block(tx_hash, future_block)), 100).is_some());\n assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n\n // Past the TTL, but the origin block has not finalized: the reception stays active. The TTL no longer\n // governs an already-processed reception.\n let reloaded = OffchainReception::load_all(address, scope).get(0);\n assert(reloaded.step(Option::some(resolved_tx_at_block(tx_hash, future_block)), MAX_MSG_TTL + 1).is_none());\n assert(\n OffchainReception::is_active(address, scope, msg),\n \"unfinalized processed reception should survive past the TTL\",\n );\n });\n }\n\n #[test]\n unconstrained fn expired_reception_is_still_processed_when_its_tx_resolves() {\n let (env, scope) = setup();\n let tx_hash = random();\n let msg = make_msg(scope, Option::some(tx_hash), 0);\n\n env.utility_context(|context| {\n let address = context.this_address();\n OffchainReception::init(address, msg);\n\n // Even past the TTL, a freshly resolved tx is still handed off: expiry only caps the search for the\n // originating tx, it does not pre-empt processing once that tx is found.\n let reception = OffchainReception::load_all(address, scope).get(0);\n assert(reception.step(Option::some(resolved_tx(tx_hash)), MAX_MSG_TTL + 1).is_some());\n assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n assert(OffchainReception::is_active(address, scope, msg), \"just-processed reception should stay active\");\n });\n }\n}\n"
|
|
570
|
+
"path": "/mnt/user-data/nicov/node-3/noir-projects/aztec-nr/aztec/src/messages/processing/offchain/reception.nr",
|
|
571
|
+
"source": "//! The state machine of a single offchain message reception process.\n//!\n//! Offchain processing needs to handle some complexity, including the possibility of reorgs reverting message effects,\n//! and the need to reprocess messages in that case. The state chart below summarizes the current behavior.\n//!\n//! ```text\n//! offchain_receive() (process starts)\n//! |\n//! v\n//! +-----------+ tx found onchain +-----------+\n//! ---- | | --------------------------> | |\n//! tx not found | | | | | discover notes,\n//! |--> | RECEIVED | | PROCESSED | ~~> events, etc\n//! | | <-------------------------- | |\n//! | | tx block re-orged | |\n//! +-----------+ +-----------+\n//! | |\n//! | TTL expired | tx block finalized\n//! v v\n//! +---------------------------------------------------------+\n//! | TERMINATED (process ends) |\n//! +---------------------------------------------------------+\n//! ```\n//!\n//! ## States\n//!\n//! - **Received**: the message is stored but its originating transaction has not been found onchain yet (or the\n//! message is tx-less; see below). While the reception process is in this state, it keeps looking for the\n// transaction onchain.\n//! - **Processed**: the message has been handed off for processing. If there weren't reorgs, reaching this state would\n//! be equivalent to terminating the reception process. Since reorgs are a possibility, this state is not terminal\n//! until the block the originating transaction was found in finalizes.\n//! - **Terminated**: nothing else can be done with the message, either because its originating transaction never\n//! appeared within the TTL, or because the block it was processed in has finalized. This is the terminal state of\n//! this process.\n//!\n//! ## Transitions (each evaluated by [`OffchainReception::step`])\n//!\n//! - **Received -> Processed**: the originating transaction is found onchain. The message (packaged with its\n//! transaction context) is queued to have its actual contents processed (which can lead for example to the discovery\n//! of notes and events).\n//! - **Processed -> Received**: the block where the message transaction was originally found is re-orged out.\n//! - **Received -> Terminated**: the message TTL has elapsed (see below), so the originating transaction can no longer\n//! appear and the message is no longer processable.\n//! - **Processed -> Terminated**: the block the originating transaction was found in has finalized, so the effects of\n//! its processing are permanent and reorg-proof.\n//!\n//! # Message reception lifecycle and the TTL\n//!\n//! A reception expires once `now > anchor_block_timestamp + MAX_MSG_TTL`, where `MAX_MSG_TTL = MAX_TX_LIFETIME + 2h`.\n//! A transaction anchored at a given block can only be mined within\n//! [`MAX_TX_LIFETIME`](crate::protocol::constants::MAX_TX_LIFETIME) of that block, so once that\n//! window (plus a safety margin of 2 hours) has elapsed the originating transaction can no longer appear, and it is\n//! safe to stop looking for it.\n//!\n//! The TTL only matters for unprocessed messages. Already-processed message receptions complete when the block that\n//! included the originating transaction finalizes, which is exactly when the processing becomes reorg-proof.\n//!\n//! # Current limitations, future plans\n//!\n//! - Tx-less messages never reach `Processed` and are only ever removed by expiry. This will be supported in the\n//! future.\n//!\n//! # Implementation\n//!\n//! [`OffchainReception::init`] creates a [fact collection](crate::facts::FactCollection) of type\n//! `OFFCHAIN_RECEPTION_TYPE_ID`. The fact collection is identified by a hash of the `OffchainMessage` it tracks, which\n//! makes duplicate calls to `init` idempotent.\n//!\n//! Upon reception, an `OFFCHAIN_MESSAGE_RECEIVED` [non-retractable fact](crate::facts::record_non_retractable_fact) is\n//! recorded. The fact's payload is the `OffchainMessage` itself, which persists it to be subsequently processed.\n//! A fact collection with just an `OFFCHAIN_MESSAGE_RECEIVED` fact represents an active reception process in the\n//! RECEIVED state from our state chart above.\n//!\n//! The message reception state machine is driven externally, advancing one step at a time each time\n//! [`OffchainReception::step`] is invoked. [`OffchainReception::step`] implements the rest of the reception state\n//! machine described above.\n//!\n//! When stepping, if the transaction to the message is found onchain, an `OFFCHAIN_MESSAGE_PROCESSED`\n//! [retractable fact](crate::facts::record_retractable_fact) associated to the block where the transaction was found is\n//! recorded.\n//! Note that since this fact is retractable, a reorg dropping said block would result in the fact being automatically\n//! removed by PXE, effectively pushing the reception process back to `RECEIVED` state.\n//!\n//! To determine in which state of the reception process we are we just analyze the recorded facts:\n//!\n//! - If there is an `OFFCHAIN_MESSAGE_PROCESSED` fact we are in PROCESSED state. Once that fact's origin block has\n//! finalized the processing is reorg-proof, so the [fact collection](crate::facts::FactCollection) can (and should)\n//! be deleted; until then there is nothing to do.\n//! - If there is only an `OFFCHAIN_MESSAGE_RECEIVED` fact we are in RECEIVED state, so we check if the message\n//! transaction is now available onchain, and if so, exercise the RECEIVED->PROCESSED transition. Otherwise, once the\n//! TTL has elapsed the originating transaction can no longer appear and the collection can (and should) be deleted.\n//!\n//! The PROCESSED->RECEIVED transition is transparently handled by PXE: if a re-org caused the message transaction to\n//! fall off the chain, the `OFFCHAIN_MESSAGE_PROCESSED` fact disappears, taking us back to the RECEIVED state.\n\nuse crate::{\n ephemeral::EphemeralArray,\n facts::{\n delete_fact_collection, Fact, FactCollection, FactScope, get_fact_collection, get_fact_collections_by_type,\n record_non_retractable_fact, record_retractable_fact,\n },\n messages::processing::OffchainMessageWithTx,\n oracle::{block_reference::BlockReference, tx_resolution::ResolvedTx},\n protocol::{\n address::AztecAddress,\n constants::MAX_TX_LIFETIME,\n hash::{poseidon2_hash, sha256_to_field},\n traits::{Deserialize, Serialize},\n },\n};\nuse super::OffchainMessage;\n\n/// Maximum time-to-live for a tx-bound offchain message.\n///\n/// After `anchor_block_timestamp + MAX_MSG_TTL`, the message is evicted from the inbox.\n/// (7200 == 2 hours)\npub(crate) global MAX_MSG_TTL: u64 = MAX_TX_LIFETIME + 7200;\n\n/// Maximum amount by which a received message's `anchor_block_timestamp` may exceed our current timestamp.\n///\n/// A message's anchor is the timestamp of the block the sender anchored its originating tx to, so for a genuine\n/// message it is at or before our own anchor timestamp. Our PXE may lag the chain tip though, which can make a\n/// legitimate anchor appear to be in our future, so we tolerate a forward skew of `MAX_TX_LIFETIME` (the longest a tx\n/// can wait to be mined after its anchor) plus a 2h margin. A larger skew would mean our view trails the tip by more\n/// than a tx lifetime -- so far behind that we could not even build a tx that wouldn't be immediately expired -- so\n/// such a message cannot be genuine and is rejected on reception. Bounding the anchor this way also keeps accepted\n/// values near the present, which prevents the `anchor_block_timestamp + MAX_MSG_TTL` eviction check from overflowing.\n/// (7200 == 2 hours)\npub(crate) global MAX_ANCHOR_FUTURE_SKEW: u64 = MAX_TX_LIFETIME + 7200;\n\n/// Fact type id of the fact that stores the offchain message body inside a reception collection.\nglobal OFFCHAIN_MESSAGE_RECEIVED: Field = sha256_to_field(\"AZTEC_NR::OFFCHAIN_MESSAGE_RECEIVED\".as_bytes());\n\n/// Fact type id to mark an offchain message as processed.\n///\n/// A reception is in \"processed state\" exactly when its collection carries a fact of this type.\npub(crate) global OFFCHAIN_MESSAGE_PROCESSED: Field =\n sha256_to_field(\"AZTEC_NR::OFFCHAIN_MESSAGE_PROCESSED\".as_bytes());\n\n/// Fact-collection type id shared by every offchain message reception in the [fact store](crate::facts).\npub(crate) global OFFCHAIN_RECEPTION_TYPE_ID: Field =\n sha256_to_field(\"AZTEC_NR::OFFCHAIN_RECEPTION_TYPE_ID\".as_bytes());\n\n/// A single offchain message reception machine, backed by a [`FactCollection`](crate::facts::FactCollection).\n///\n/// Wraps the fact collection that tracks one message's progress through the reception state machine (see the\n/// [module documentation](super)); the [`OffchainMessage`] it carries is decoded on demand.\n#[derive(Deserialize, Serialize)]\npub(crate) struct OffchainReception {\n collection: FactCollection,\n}\n\nimpl OffchainReception {\n /// Initializes a new reception for a freshly received message, in the `Received` state.\n ///\n /// Re-initializing the same message is a no-op, which makes redelivery idempotent.\n pub(crate) unconstrained fn init(contract_address: AztecAddress, message: OffchainMessage) {\n record_non_retractable_fact(\n contract_address,\n FactScope::account(message.recipient),\n OFFCHAIN_RECEPTION_TYPE_ID,\n Self::id_for(message),\n OFFCHAIN_MESSAGE_RECEIVED,\n to_payload(message),\n );\n }\n\n /// Loads every active reception for the given contract and scope, decoding each message body.\n pub(crate) unconstrained fn load_all(\n contract_address: AztecAddress,\n scope: AztecAddress,\n ) -> EphemeralArray<OffchainReception> {\n get_fact_collections_by_type(\n contract_address,\n FactScope::account(scope),\n OFFCHAIN_RECEPTION_TYPE_ID,\n )\n .map(|collection: FactCollection| OffchainReception { collection })\n }\n\n /// Reads and returns the message this reception carries, decoding it from its fact collection.\n pub(crate) unconstrained fn read_message(self) -> OffchainMessage {\n let message_fact = self.collection.facts.find(|f: Fact| f.fact_type_id == OFFCHAIN_MESSAGE_RECEIVED).unwrap();\n let n = <OffchainMessage as Deserialize>::N;\n let mut fields = [0; <OffchainMessage as Deserialize>::N];\n for i in 0..n {\n fields[i] = message_fact.payload.get(i);\n }\n Deserialize::deserialize(fields)\n }\n\n /// Computes the fact-collection id that identifies a message's reception machine in the [fact store](crate::facts).\n ///\n /// The id is a hash of the message, which makes duplicate receptions of the same message collapse onto a single\n /// reception.\n pub(crate) fn id_for(message: OffchainMessage) -> Field {\n poseidon2_hash(message.serialize())\n }\n\n /// Returns `true` if a reception for `message` is currently active for the given contract and scope.\n pub(crate) unconstrained fn is_active(\n contract_address: AztecAddress,\n scope: AztecAddress,\n message: OffchainMessage,\n ) -> bool {\n get_fact_collection(\n contract_address,\n FactScope::account(scope),\n OFFCHAIN_RECEPTION_TYPE_ID,\n Self::id_for(message),\n )\n .is_some()\n }\n\n /// Advances this reception by one step of its state machine. See the [module documentation](super) for the\n /// states, transitions, and expiry rules.\n ///\n /// Returns `Some` with the message and its resolved context when this step determines the message is ready to be\n /// processed.\n pub(crate) unconstrained fn step(\n self,\n maybe_resolved_tx: Option<ResolvedTx>,\n now: u64,\n ) -> Option<OffchainMessageWithTx> {\n let message = self.read_message();\n let processed_fact = self.collection.facts.find(|f: Fact| f.fact_type_id == OFFCHAIN_MESSAGE_PROCESSED);\n\n if processed_fact.is_none() & maybe_resolved_tx.is_some() {\n // Received -> Processed: the originating tx is onchain.\n let resolved = maybe_resolved_tx.unwrap();\n self.mark_processed(resolved.block_number, resolved.block_hash);\n Option::some(\n OffchainMessageWithTx { message_ciphertext: message.ciphertext, resolved_tx: resolved },\n )\n } else if processed_fact.is_some() {\n if processed_fact.unwrap().origin_block.unwrap().block_state.is_finalized() {\n // Processed -> Terminated: once the marker's origin block finalizes, the processing is reorg-proof and\n // the reception is complete. Until then we wait: a reorg dropping that block removes the retractable\n // marker and PXE pushes us back to Received.\n self.terminate();\n }\n Option::none()\n } else {\n // Received -> Terminated: the TTL caps how long we keep looking for the originating tx.\n if now > message.anchor_block_timestamp + MAX_MSG_TTL {\n self.terminate();\n }\n Option::none()\n }\n }\n\n /// Returns `true` if the reception for `message` has been marked processed.\n pub(crate) unconstrained fn is_processed(\n contract_address: AztecAddress,\n scope: AztecAddress,\n message: OffchainMessage,\n ) -> bool {\n let maybe_collection = get_fact_collection(\n contract_address,\n FactScope::account(scope),\n OFFCHAIN_RECEPTION_TYPE_ID,\n Self::id_for(message),\n );\n if maybe_collection.is_some() {\n maybe_collection.unwrap().facts.any(|f: Fact| f.fact_type_id == OFFCHAIN_MESSAGE_PROCESSED)\n } else {\n false\n }\n }\n\n /// Records the retractable processed marker for this reception, originated at the resolved block.\n unconstrained fn mark_processed(self, block_number: u32, block_hash: Field) {\n let empty_payload: EphemeralArray<Field> = EphemeralArray::empty();\n record_retractable_fact(\n self.collection.contract_address,\n self.collection.scope,\n self.collection.fact_collection_type_id,\n self.collection.fact_collection_id,\n OFFCHAIN_MESSAGE_PROCESSED,\n empty_payload,\n BlockReference { block_number, block_hash },\n );\n }\n\n /// Terminates this reception by deleting its [fact collection](crate::facts::FactCollection).\n unconstrained fn terminate(self) {\n delete_fact_collection(\n self.collection.contract_address,\n self.collection.scope,\n self.collection.fact_collection_type_id,\n self.collection.fact_collection_id,\n );\n }\n}\n\n/// Serializes an [`OffchainMessage`] into a fact payload.\nunconstrained fn to_payload(message: OffchainMessage) -> EphemeralArray<Field> {\n EphemeralArray::from_array(message.serialize())\n}\n\nmod test {\n use crate::{\n messages::processing::offchain::OffchainMessage,\n oracle::{random::random, tx_resolution::ResolvedTx},\n protocol::address::AztecAddress,\n test::helpers::test_environment::TestEnvironment,\n };\n use super::{MAX_MSG_TTL, OffchainReception};\n\n unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n let mut env = TestEnvironment::new();\n let scope = env.create_light_account();\n (env, scope)\n }\n\n /// Creates an `OffchainMessage` with dummy ciphertext and the given scope as recipient.\n fn make_msg(recipient: AztecAddress, tx_hash: Option<Field>, anchor_block_timestamp: u64) -> OffchainMessage {\n OffchainMessage { ciphertext: BoundedVec::new(), recipient, tx_hash, anchor_block_timestamp }\n }\n\n /// Builds the resolved-tx context PXE would return for `tx_hash`, found in `block_number`.\n fn resolved_tx_at_block(tx_hash: Field, block_number: u32) -> ResolvedTx {\n ResolvedTx {\n tx_hash,\n unique_note_hashes_in_tx: BoundedVec::new(),\n first_nullifier_in_tx: 0,\n block_number,\n block_hash: 0,\n }\n }\n\n /// Builds a resolved-tx context found in a low block, which TXE (proven == finalized == latest) reports as\n /// `Finalized`.\n fn resolved_tx(tx_hash: Field) -> ResolvedTx {\n resolved_tx_at_block(tx_hash, 1)\n }\n\n #[test]\n unconstrained fn expired_reception_is_terminated() {\n let (env, scope) = setup();\n let msg = make_msg(scope, Option::some(random()), 0);\n\n env.utility_context(|context| {\n let address = context.this_address();\n OffchainReception::init(address, msg);\n let reception = OffchainReception::load_all(address, scope).get(0);\n\n // Past the TTL with no resolved tx: the reception is terminated.\n assert(reception.step(Option::none(), MAX_MSG_TTL + 1).is_none());\n assert(!OffchainReception::is_active(address, scope, msg), \"expired reception should be terminated\");\n });\n }\n\n #[test]\n unconstrained fn unresolved_reception_stays_active() {\n let (env, scope) = setup();\n let msg = make_msg(scope, Option::some(random()), 0);\n\n env.utility_context(|context| {\n let address = context.this_address();\n OffchainReception::init(address, msg);\n let reception = OffchainReception::load_all(address, scope).get(0);\n\n // Within the TTL with no resolved tx: nothing to process, the reception stays.\n assert(reception.step(Option::none(), 100).is_none());\n assert(OffchainReception::is_active(address, scope, msg), \"unresolved reception should stay active\");\n assert(!OffchainReception::is_processed(address, scope, msg), \"should still be unprocessed\");\n });\n }\n\n #[test]\n unconstrained fn resolved_reception_is_ready_to_process() {\n let (env, scope) = setup();\n let tx_hash = random();\n let msg = make_msg(scope, Option::some(tx_hash), 0);\n\n env.utility_context(|context| {\n let address = context.this_address();\n OffchainReception::init(address, msg);\n let reception = OffchainReception::load_all(address, scope).get(0);\n\n // A resolved tx within the TTL: the message is handed off with its tx context attached.\n let processable = reception.step(Option::some(resolved_tx(tx_hash)), 100);\n assert(processable.is_some());\n assert_eq(processable.unwrap().resolved_tx.tx_hash, tx_hash);\n\n // It stays active for reorg safety and is now marked processed.\n assert(OffchainReception::is_active(address, scope, msg), \"processed reception should stay active\");\n assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n });\n }\n\n #[test]\n unconstrained fn already_processed_reception_is_not_re_pushed() {\n let (env, scope) = setup();\n let tx_hash = random();\n let msg = make_msg(scope, Option::some(tx_hash), 0);\n // A future origin block stays unfinalized, so the reception lingers in Processed across steps.\n let future_block = env.last_block_number() + 100;\n\n env.utility_context(|context| {\n let address = context.this_address();\n OffchainReception::init(address, msg);\n\n // First step processes the message.\n let reception = OffchainReception::load_all(address, scope).get(0);\n assert(reception.step(Option::some(resolved_tx_at_block(tx_hash, future_block)), 100).is_some());\n assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n\n // Second step (still resolved, not finalized) recognizes it as processed and does not re-push it.\n let reloaded = OffchainReception::load_all(address, scope).get(0);\n assert(\n reloaded.step(Option::some(resolved_tx_at_block(tx_hash, future_block)), 100).is_none(),\n \"already processed\",\n );\n assert(OffchainReception::is_active(address, scope, msg), \"processed reception should still be active\");\n });\n }\n\n #[test]\n unconstrained fn processed_reception_terminates_once_its_origin_block_finalizes() {\n let (env, scope) = setup();\n let tx_hash = random();\n let msg = make_msg(scope, Option::some(tx_hash), 0);\n\n env.utility_context(|context| {\n let address = context.this_address();\n OffchainReception::init(address, msg);\n\n // Process the message against a finalized block.\n let reception = OffchainReception::load_all(address, scope).get(0);\n assert(reception.step(Option::some(resolved_tx(tx_hash)), 100).is_some());\n assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n\n // Next step, still well within the TTL: a finalized origin block makes the processing reorg-proof, so the\n // reception terminates regardless of the TTL.\n let reloaded = OffchainReception::load_all(address, scope).get(0);\n assert(reloaded.step(Option::some(resolved_tx(tx_hash)), 100).is_none());\n assert(\n !OffchainReception::is_active(address, scope, msg),\n \"finalized processed reception should be terminated\",\n );\n });\n }\n\n #[test]\n unconstrained fn unfinalized_processed_reception_survives_past_the_ttl() {\n let (env, scope) = setup();\n let tx_hash = random();\n let msg = make_msg(scope, Option::some(tx_hash), 0);\n // A future origin block never finalizes here, so the reception must not be terminated by the TTL.\n let future_block = env.last_block_number() + 100;\n\n env.utility_context(|context| {\n let address = context.this_address();\n OffchainReception::init(address, msg);\n\n let reception = OffchainReception::load_all(address, scope).get(0);\n assert(reception.step(Option::some(resolved_tx_at_block(tx_hash, future_block)), 100).is_some());\n assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n\n // Past the TTL, but the origin block has not finalized: the reception stays active. The TTL no longer\n // governs an already-processed reception.\n let reloaded = OffchainReception::load_all(address, scope).get(0);\n assert(reloaded.step(Option::some(resolved_tx_at_block(tx_hash, future_block)), MAX_MSG_TTL + 1).is_none());\n assert(\n OffchainReception::is_active(address, scope, msg),\n \"unfinalized processed reception should survive past the TTL\",\n );\n });\n }\n\n #[test]\n unconstrained fn expired_reception_is_still_processed_when_its_tx_resolves() {\n let (env, scope) = setup();\n let tx_hash = random();\n let msg = make_msg(scope, Option::some(tx_hash), 0);\n\n env.utility_context(|context| {\n let address = context.this_address();\n OffchainReception::init(address, msg);\n\n // Even past the TTL, a freshly resolved tx is still handed off: expiry only caps the search for the\n // originating tx, it does not pre-empt processing once that tx is found.\n let reception = OffchainReception::load_all(address, scope).get(0);\n assert(reception.step(Option::some(resolved_tx(tx_hash)), MAX_MSG_TTL + 1).is_some());\n assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n assert(OffchainReception::is_active(address, scope, msg), \"just-processed reception should stay active\");\n });\n }\n}\n"
|
|
572
572
|
},
|
|
573
573
|
"17": {
|
|
574
574
|
"function_locations": [
|
|
@@ -756,7 +756,7 @@
|
|
|
756
756
|
"path": "std/hash/mod.nr",
|
|
757
757
|
"source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\nuse crate::static_assert;\n\n/// The size of the state accepted by the backend in `poseidon2_permutation`.\nglobal POSEIDON2_CONFIG_STATE_SIZE: u32 = poseidon2_config_state_size();\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3<let N: u32>(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n points[i] = EmbeddedCurveScalar::from_field(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n crate::assert_constant(separator);\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = EmbeddedCurveScalar::from_field(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars, true)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n crate::assert_constant(starting_index);\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\npub fn poseidon2_permutation<let N: u32>(input: [Field; N]) -> [Field; N] {\n static_assert(\n N == POSEIDON2_CONFIG_STATE_SIZE,\n f\"the input length must equal the state size in the Poseidon2 config; expected {POSEIDON2_CONFIG_STATE_SIZE}, got {N}\",\n );\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal<let N: u32>(input: [Field; N]) -> [Field; N] {}\n\n#[foreign(poseidon2_config_state_size)]\ncomptime fn poseidon2_config_state_size() -> u32 {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n /// Returns the hash value without consuming the hasher.\n /// Override this for more efficient implementations that avoid copying.\n /// TODO: deprecate finish() and replace it\n fn finish_ref(&self) -> Field {\n (*self).finish()\n }\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher for BuildHasherDefault<H>\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u8 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u8 as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u16 as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u32 as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u64 as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash<H>(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl<T> Hash for [T]\nwhere\n T: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl<A> Hash for (A,)\nwhere\n A: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\nimpl<A, B, C, D, E, F> Hash for (A, B, C, D, E, F)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n F: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n self.5.hash(state);\n }\n}\n\nimpl<A, B, C, D, E, F, G> Hash for (A, B, C, D, E, F, G)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n F: Hash,\n G: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n self.5.hash(state);\n self.6.hash(state);\n }\n}\n\nimpl<A, B, C, D, E, F, G, H_> Hash for (A, B, C, D, E, F, G, H_)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n F: Hash,\n G: Hash,\n H_: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n self.5.hash(state);\n self.6.hash(state);\n self.7.hash(state);\n }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I> Hash for (A, B, C, D, E, F, G, H_, I)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n F: Hash,\n G: Hash,\n H_: Hash,\n I: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n self.5.hash(state);\n self.6.hash(state);\n self.7.hash(state);\n self.8.hash(state);\n }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I, J> Hash for (A, B, C, D, E, F, G, H_, I, J)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n F: Hash,\n G: Hash,\n H_: Hash,\n I: Hash,\n J: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n self.5.hash(state);\n self.6.hash(state);\n self.7.hash(state);\n self.8.hash(state);\n self.9.hash(state);\n }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I, J, K> Hash for (A, B, C, D, E, F, G, H_, I, J, K)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n F: Hash,\n G: Hash,\n H_: Hash,\n I: Hash,\n J: Hash,\n K: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n self.5.hash(state);\n self.6.hash(state);\n self.7.hash(state);\n self.8.hash(state);\n self.9.hash(state);\n self.10.hash(state);\n }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I, J, K, L> Hash for (A, B, C, D, E, F, G, H_, I, J, K, L)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n F: Hash,\n G: Hash,\n H_: Hash,\n I: Hash,\n J: Hash,\n K: Hash,\n L: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n self.5.hash(state);\n self.6.hash(state);\n self.7.hash(state);\n self.8.hash(state);\n self.9.hash(state);\n self.10.hash(state);\n self.11.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n },\n );\n}\n"
|
|
758
758
|
},
|
|
759
|
-
"
|
|
759
|
+
"190": {
|
|
760
760
|
"function_locations": [
|
|
761
761
|
{
|
|
762
762
|
"name": "address",
|
|
@@ -991,10 +991,10 @@
|
|
|
991
991
|
"start": 7247
|
|
992
992
|
}
|
|
993
993
|
],
|
|
994
|
-
"path": "/
|
|
994
|
+
"path": "/mnt/user-data/nicov/node-3/noir-projects/aztec-nr/aztec/src/oracle/avm.nr",
|
|
995
995
|
"source": "//! AVM oracles.\n//!\n//! There are only available during public execution. Calling any of them from a private or utility function will\n//! result in runtime errors.\n\nuse crate::protocol::address::{AztecAddress, EthAddress};\n\npub unconstrained fn address() -> AztecAddress {\n address_opcode()\n}\npub unconstrained fn sender() -> AztecAddress {\n sender_opcode()\n}\npub unconstrained fn transaction_fee() -> Field {\n transaction_fee_opcode()\n}\npub unconstrained fn chain_id() -> Field {\n chain_id_opcode()\n}\npub unconstrained fn version() -> Field {\n version_opcode()\n}\npub unconstrained fn block_number() -> u32 {\n block_number_opcode()\n}\npub unconstrained fn timestamp() -> u64 {\n timestamp_opcode()\n}\npub unconstrained fn min_fee_per_l2_gas() -> u128 {\n min_fee_per_l2_gas_opcode()\n}\npub unconstrained fn min_fee_per_da_gas() -> u128 {\n min_fee_per_da_gas_opcode()\n}\npub unconstrained fn l2_gas_left() -> u32 {\n l2_gas_left_opcode()\n}\npub unconstrained fn da_gas_left() -> u32 {\n da_gas_left_opcode()\n}\npub unconstrained fn is_static_call() -> bool {\n is_static_call_opcode()\n}\npub unconstrained fn note_hash_exists(note_hash: Field, leaf_index: u64) -> bool {\n note_hash_exists_opcode(note_hash, leaf_index)\n}\npub unconstrained fn emit_note_hash(note_hash: Field) {\n emit_note_hash_opcode(note_hash)\n}\npub unconstrained fn nullifier_exists(siloed_nullifier: Field) -> bool {\n nullifier_exists_opcode(siloed_nullifier)\n}\npub unconstrained fn emit_nullifier(nullifier: Field) {\n emit_nullifier_opcode(nullifier)\n}\npub unconstrained fn emit_public_log(message: [Field]) {\n emit_public_log_opcode(message)\n}\npub unconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: u64) -> bool {\n l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\npub unconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n send_l2_to_l1_msg_opcode(recipient, content)\n}\n\npub unconstrained fn call<let N: u32>(\n l2_gas_allocation: u32,\n da_gas_allocation: u32,\n address: AztecAddress,\n args: [Field; N],\n) {\n call_opcode(l2_gas_allocation, da_gas_allocation, address, N, args)\n}\n\npub unconstrained fn call_static<let N: u32>(\n l2_gas_allocation: u32,\n da_gas_allocation: u32,\n address: AztecAddress,\n args: [Field; N],\n) {\n call_static_opcode(l2_gas_allocation, da_gas_allocation, address, N, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n calldata_copy_opcode(cdoffset, copy_size)\n}\n\n/// `success_copy` is placed immediately after the CALL opcode to get the success value\npub unconstrained fn success_copy() -> bool {\n success_copy_opcode()\n}\n\npub unconstrained fn returndata_size() -> u32 {\n returndata_size_opcode()\n}\n\npub unconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n returndata_copy_opcode(rdoffset, copy_size)\n}\n\n/// The additional prefix is to avoid clashing with the `return` Noir keyword.\npub unconstrained fn avm_return(returndata: [Field]) {\n return_opcode(returndata)\n}\n\n/// This opcode reverts using the exact data given. In general it should only be used to do rethrows, where the revert\n/// data is the same as the original revert data. For normal reverts, use Noir's `assert` which, on top of reverting,\n/// will also add an error selector to the revert data.\npub unconstrained fn revert(revertdata: [Field]) {\n revert_opcode(revertdata)\n}\n\npub unconstrained fn storage_read(storage_slot: Field, contract_address: Field) -> Field {\n storage_read_opcode(storage_slot, contract_address)\n}\n\npub unconstrained fn storage_write(storage_slot: Field, value: Field) {\n storage_write_opcode(storage_slot, value);\n}\n\n#[oracle(aztec_avm_address)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(aztec_avm_sender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(aztec_avm_transactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(aztec_avm_chainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(aztec_avm_version)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(aztec_avm_blockNumber)]\nunconstrained fn block_number_opcode() -> u32 {}\n\n#[oracle(aztec_avm_timestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(aztec_avm_minFeePerL2Gas)]\nunconstrained fn min_fee_per_l2_gas_opcode() -> u128 {}\n\n#[oracle(aztec_avm_minFeePerDaGas)]\nunconstrained fn min_fee_per_da_gas_opcode() -> u128 {}\n\n#[oracle(aztec_avm_l2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> u32 {}\n\n#[oracle(aztec_avm_daGasLeft)]\nunconstrained fn da_gas_left_opcode() -> u32 {}\n\n#[oracle(aztec_avm_isStaticCall)]\nunconstrained fn is_static_call_opcode() -> bool {}\n\n#[oracle(aztec_avm_noteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: u64) -> bool {}\n\n#[oracle(aztec_avm_emitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(aztec_avm_nullifierExists)]\nunconstrained fn nullifier_exists_opcode(siloed_nullifier: Field) -> bool {}\n\n#[oracle(aztec_avm_emitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n#[oracle(aztec_avm_emitPublicLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(aztec_avm_l1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: u64) -> bool {}\n\n#[oracle(aztec_avm_sendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(aztec_avm_calldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(aztec_avm_returndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(aztec_avm_returndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(aztec_avm_return)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n#[oracle(aztec_avm_revert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n// While the length parameter might seem unnecessary given that we have N we keep it around because at the AVM bytecode\n// level, we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally take\n// that route.\n#[oracle(aztec_avm_call)]\nunconstrained fn call_opcode<let N: u32>(\n l2_gas_allocation: u32,\n da_gas_allocation: u32,\n address: AztecAddress,\n length: u32,\n args: [Field; N],\n) {}\n\n// While the length parameter might seem unnecessary given that we have N we keep it around because at the AVM bytecode\n// level, we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally take\n// that route.\n#[oracle(aztec_avm_staticCall)]\nunconstrained fn call_static_opcode<let N: u32>(\n l2_gas_allocation: u32,\n da_gas_allocation: u32,\n address: AztecAddress,\n length: u32,\n args: [Field; N],\n) {}\n\n#[oracle(aztec_avm_successCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(aztec_avm_storageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field, contract_address: Field) -> Field {}\n\n#[oracle(aztec_avm_storageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
|
|
996
996
|
},
|
|
997
|
-
"
|
|
997
|
+
"196": {
|
|
998
998
|
"function_locations": [
|
|
999
999
|
{
|
|
1000
1000
|
"name": "set_contract_sync_cache_invalid_oracle",
|
|
@@ -1005,10 +1005,10 @@
|
|
|
1005
1005
|
"start": 700
|
|
1006
1006
|
}
|
|
1007
1007
|
],
|
|
1008
|
-
"path": "/
|
|
1008
|
+
"path": "/mnt/user-data/nicov/node-3/noir-projects/aztec-nr/aztec/src/oracle/contract_sync.nr",
|
|
1009
1009
|
"source": "use crate::protocol::address::AztecAddress;\n\n#[oracle(aztec_utl_setContractSyncCacheInvalid)]\nunconstrained fn set_contract_sync_cache_invalid_oracle<let N: u32>(\n contract_address: AztecAddress,\n scopes: BoundedVec<AztecAddress, N>,\n) {}\n\n/// Forces the PXE to re-sync the given contract for a set of scopes on the next query.\n///\n/// Call this after writing data (e.g. offchain messages) that the contract's `sync_state` function needs to discover.\n/// Without invalidation, the sync cache would skip re-running `sync_state` until the next block.\npub unconstrained fn set_contract_sync_cache_invalid<let N: u32>(\n contract_address: AztecAddress,\n scopes: BoundedVec<AztecAddress, N>,\n) {\n set_contract_sync_cache_invalid_oracle(contract_address, scopes);\n}\n"
|
|
1010
1010
|
},
|
|
1011
|
-
"
|
|
1011
|
+
"198": {
|
|
1012
1012
|
"function_locations": [
|
|
1013
1013
|
{
|
|
1014
1014
|
"name": "get_utility_context_oracle",
|
|
@@ -1019,10 +1019,10 @@
|
|
|
1019
1019
|
"start": 786
|
|
1020
1020
|
}
|
|
1021
1021
|
],
|
|
1022
|
-
"path": "/
|
|
1022
|
+
"path": "/mnt/user-data/nicov/node-3/noir-projects/aztec-nr/aztec/src/oracle/execution.nr",
|
|
1023
1023
|
"source": "use crate::context::UtilityContext;\nuse crate::protocol::{abis::block_header::BlockHeader, address::AztecAddress};\n\n/// Wire shape of [`get_utility_context_oracle`]'s response. [`UtilityContext`] is built from it rather than returned\n/// directly so its fields stay private to its module.\n#[derive(Eq)]\npub(crate) struct UtilityContextData {\n pub(crate) block_header: BlockHeader,\n pub(crate) contract_address: AztecAddress,\n pub(crate) msg_sender: AztecAddress,\n}\n\n#[oracle(aztec_utl_getUtilityContext)]\nunconstrained fn get_utility_context_oracle() -> UtilityContextData {}\n\n/// Returns a utility context built from the global variables of anchor block and the contract address of the function\n/// being executed.\npub unconstrained fn get_utility_context() -> UtilityContext {\n UtilityContext::from(get_utility_context_oracle())\n}\n"
|
|
1024
1024
|
},
|
|
1025
|
-
"
|
|
1025
|
+
"215": {
|
|
1026
1026
|
"function_locations": [
|
|
1027
1027
|
{
|
|
1028
1028
|
"name": "random",
|
|
@@ -1033,10 +1033,36 @@
|
|
|
1033
1033
|
"start": 568
|
|
1034
1034
|
}
|
|
1035
1035
|
],
|
|
1036
|
-
"path": "/
|
|
1036
|
+
"path": "/mnt/user-data/nicov/node-3/noir-projects/aztec-nr/aztec/src/oracle/random.nr",
|
|
1037
1037
|
"source": "/// Returns an unconstrained random value. Note that it is not possible to constrain this value to prove that it is\n/// truly random: we assume that the oracle is cooperating and returning random values. In some applications this\n/// behavior might not be acceptable and other techniques might be more suitable, such as producing pseudo-random\n/// values by hashing values outside of user control (like block hashes) or secrets.\npub unconstrained fn random() -> Field {\n rand_oracle()\n}\n\n#[oracle(aztec_misc_getRandomField)]\nunconstrained fn rand_oracle() -> Field {}\n"
|
|
1038
1038
|
},
|
|
1039
|
-
"
|
|
1039
|
+
"223": {
|
|
1040
|
+
"function_locations": [
|
|
1041
|
+
{
|
|
1042
|
+
"name": "assert_compatible_oracle_version",
|
|
1043
|
+
"start": 1192
|
|
1044
|
+
},
|
|
1045
|
+
{
|
|
1046
|
+
"name": "assert_compatible_oracle_version_wrapper",
|
|
1047
|
+
"start": 1501
|
|
1048
|
+
},
|
|
1049
|
+
{
|
|
1050
|
+
"name": "assert_compatible_oracle_version_oracle",
|
|
1051
|
+
"start": 1732
|
|
1052
|
+
},
|
|
1053
|
+
{
|
|
1054
|
+
"name": "test::compatible_oracle_version",
|
|
1055
|
+
"start": 1911
|
|
1056
|
+
},
|
|
1057
|
+
{
|
|
1058
|
+
"name": "test::incompatible_oracle_version_major",
|
|
1059
|
+
"start": 2136
|
|
1060
|
+
}
|
|
1061
|
+
],
|
|
1062
|
+
"path": "/mnt/user-data/nicov/node-3/noir-projects/aztec-nr/aztec/src/oracle/version.nr",
|
|
1063
|
+
"source": "/// The oracle version constants are used to check that the oracle interface is in sync between PXE and Aztec.nr.\n/// We version the oracle interface as `major.minor` where:\n/// - `major` = backward-breaking changes (must match exactly between PXE and Aztec.nr)\n/// - `minor` = oracle additions (non-breaking; PXE minor >= contract minor)\n///\n/// The TypeScript counterparts are in `oracle_version.ts`.\n///\n/// @dev Whenever a contract function or Noir test is run, the `aztec_misc_assertCompatibleOracleVersion` oracle is\n/// called. If the major version is incompatible, an error is thrown immediately. The minor version is recorded by\n/// the PXE and used to provide helpful error messages if a contract calls an oracle that doesn't exist. We don't throw\n/// immediately if AZTEC_NR_MINOR > PXE_MINOR because if a contract is updated to use a newer Aztec.nr dependency\n/// without actually using any of the new oracles then there is no reason to throw.\npub global ORACLE_VERSION_MAJOR: Field = 33;\npub global ORACLE_VERSION_MINOR: Field = 0;\n\n/// Asserts that the version of the oracle is compatible with the version expected by the contract.\npub fn assert_compatible_oracle_version() {\n // Safety: This oracle call returns nothing: we only call it to check Aztec.nr and Oracle interface versions are\n // compatible. It is therefore always safe to call.\n unsafe {\n assert_compatible_oracle_version_wrapper();\n }\n}\n\nunconstrained fn assert_compatible_oracle_version_wrapper() {\n assert_compatible_oracle_version_oracle(ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR);\n}\n\n#[oracle(aztec_misc_assertCompatibleOracleVersion)]\nunconstrained fn assert_compatible_oracle_version_oracle(major: Field, minor: Field) {}\n\nmod test {\n use super::{assert_compatible_oracle_version_oracle, ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR};\n\n #[test]\n unconstrained fn compatible_oracle_version() {\n assert_compatible_oracle_version_oracle(ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR);\n }\n\n #[test(should_fail_with = \"Incompatible aztec cli version:\")]\n unconstrained fn incompatible_oracle_version_major() {\n let arbitrary_incorrect_major = 318183437;\n assert_compatible_oracle_version_oracle(arbitrary_incorrect_major, ORACLE_VERSION_MINOR);\n }\n}\n"
|
|
1064
|
+
},
|
|
1065
|
+
"279": {
|
|
1040
1066
|
"function_locations": [
|
|
1041
1067
|
{
|
|
1042
1068
|
"name": "UnconstrainedArray<T, Oracle>::at",
|
|
@@ -1107,10 +1133,10 @@
|
|
|
1107
1133
|
"start": 8318
|
|
1108
1134
|
}
|
|
1109
1135
|
],
|
|
1110
|
-
"path": "/
|
|
1136
|
+
"path": "/mnt/user-data/nicov/node-3/noir-projects/aztec-nr/aztec/src/unconstrained_array/mod.nr",
|
|
1111
1137
|
"source": "pub(crate) mod test_helpers;\npub(crate) mod test_suite;\n\nuse crate::oracle::random::random;\nuse crate::protocol::traits::{Deserialize, Serialize};\n\n/// Oracle backend for an [`UnconstrainedArray`]: the set of PXE-side operations that implement its storage.\n///\n/// Each implementor routes these operations to a distinct family of oracles, and the oracle family determines the\n/// array's lifetime and visibility (e.g. [`EphemeralArray`](crate::ephemeral::EphemeralArray) arrays live for one\n/// contract call frame, while [`TransientArray`](crate::transient::TransientArray) arrays are shared across all frames\n/// of the same contract within one top-level PXE call).\npub(crate) trait ArrayOracles {\n /// Returns the number of elements in the array at `slot`.\n unconstrained fn len_oracle(slot: Field) -> u32;\n\n /// Appends a serialized element to the array at `slot` and returns the new length.\n unconstrained fn push_oracle<let N: u32>(slot: Field, values: [Field; N]) -> u32;\n\n /// Removes and returns the last serialized element of the array at `slot`. Implementors must panic if the\n /// array is empty.\n unconstrained fn pop_oracle<let N: u32>(slot: Field) -> [Field; N];\n\n /// Returns the serialized element at the given index of the array at `slot`. Implementors must panic if `index`\n /// is out of bounds.\n unconstrained fn get_oracle<let N: u32>(slot: Field, index: u32) -> [Field; N];\n\n /// Overwrites the serialized element at the given index of the array at `slot`. Implementors must panic if\n /// `index` is out of bounds.\n unconstrained fn set_oracle<let N: u32>(slot: Field, index: u32, values: [Field; N]);\n\n /// Removes the element at the given index of the array at `slot`, shifting subsequent elements backward.\n /// Implementors must panic if `index` is out of bounds.\n unconstrained fn remove_oracle(slot: Field, index: u32);\n\n /// Removes all elements from the array at `slot`.\n unconstrained fn clear_oracle(slot: Field);\n}\n\n/// A dynamically sized array backed by PXE-side in-memory storage via an [`ArrayOracles`] backend.\n///\n/// Arrays are identified by a slot, and each logical operation (push, pop, get, etc.) is a single oracle call. The\n/// `Oracle` backend determines the array's lifetime and visibility; contracts should not use this type directly but\n/// rather one of its aliases: [`EphemeralArray`](crate::ephemeral::EphemeralArray) (scoped to a single contract call\n/// frame) or [`TransientArray`](crate::transient::TransientArray) (shared across all frames of the same contract\n/// within one top-level PXE call).\npub struct UnconstrainedArray<T, Oracle> {\n pub(crate) slot: Field,\n}\n\nimpl<T, Oracle> UnconstrainedArray<T, Oracle>\nwhere\n Oracle: ArrayOracles,\n{\n /// Returns a handle to the array at the given slot, which may already contain data (e.g. populated by an oracle\n /// or by an earlier frame, depending on the backend's visibility).\n pub unconstrained fn at(slot: Field) -> Self {\n Self { slot }\n }\n\n /// Returns an empty array at the given slot, clearing any pre-existing data.\n ///\n /// For backends whose arrays are visible beyond a single call frame (e.g. transient arrays), this wipes data\n /// other frames of the same contract may have written at the slot.\n pub unconstrained fn empty_at(slot: Field) -> Self {\n Self::at(slot).clear()\n }\n\n /// Returns an empty array at a fresh, randomly allocated slot.\n ///\n /// Use this when the caller does not need a specific slot: the random slot is isolated from every other array of\n /// the same backend with overwhelming probability. Prefer [`UnconstrainedArray::empty_at`] when the slot must be a\n /// known value (e.g. one shared with an oracle or another call frame).\n pub unconstrained fn empty() -> Self {\n Self::at(random())\n }\n\n /// Returns an array at a fresh, randomly allocated slot holding `values` in order.\n pub unconstrained fn from_array<let N: u32>(values: [T; N]) -> Self\n where\n T: Serialize,\n {\n let array = Self::empty();\n for i in 0..N {\n array.push(values[i]);\n }\n array\n }\n\n /// Returns the number of elements stored in the array.\n pub unconstrained fn len(self) -> u32 {\n Oracle::len_oracle(self.slot)\n }\n\n /// Stores a value at the end of the array.\n pub unconstrained fn push(self, value: T)\n where\n T: Serialize,\n {\n let serialized = value.serialize();\n let _ = Oracle::push_oracle(self.slot, serialized);\n }\n\n /// Removes and returns the last element. Implementors are required to panic if the array is empty.\n pub unconstrained fn pop(self) -> T\n where\n T: Deserialize,\n {\n let serialized = Oracle::pop_oracle(self.slot);\n Deserialize::deserialize(serialized)\n }\n\n /// Retrieves the value stored at `index`. Implementors are required to panic if the index is out of bounds.\n pub unconstrained fn get(self, index: u32) -> T\n where\n T: Deserialize,\n {\n let serialized = Oracle::get_oracle(self.slot, index);\n Deserialize::deserialize(serialized)\n }\n\n /// Overwrites the value stored at `index`. Implementors are required to panic if the index is out of bounds.\n pub unconstrained fn set(self, index: u32, value: T)\n where\n T: Serialize,\n {\n let serialized = value.serialize();\n Oracle::set_oracle(self.slot, index, serialized);\n }\n\n /// Removes the element at `index`, shifting subsequent elements backward. Implementors are required to panic if\n /// the index is out of bounds.\n pub unconstrained fn remove(self, index: u32) {\n Oracle::remove_oracle(self.slot, index);\n }\n\n /// Removes all elements from the array and returns self for chaining.\n pub unconstrained fn clear(self) -> Self {\n Oracle::clear_oracle(self.slot);\n self\n }\n\n /// Calls a function on each element of the array.\n ///\n /// The function `f` is called once with each array value and its corresponding index, in order (from the first\n /// element to the last).\n ///\n /// Structurally mutating the array from inside the callback (e.g. via `push`, `pop`, `remove` or `clear`) is\n /// **not** supported: it can cause elements to be skipped, visited more than once, or read out of bounds.\n pub unconstrained fn for_each<Env>(self, f: unconstrained fn[Env](u32, T) -> ())\n where\n T: Deserialize,\n {\n let n = self.len();\n for i in 0..n {\n f(i, self.get(i));\n }\n }\n\n /// Applies `f` to every element and collects the results into a fresh array.\n pub unconstrained fn map<U, Env>(self, f: unconstrained fn[Env](T) -> U) -> UnconstrainedArray<U, Oracle>\n where\n T: Deserialize,\n U: Serialize,\n {\n let dest: UnconstrainedArray<U, Oracle> = UnconstrainedArray::empty();\n let n = self.len();\n for i in 0..n {\n dest.push(f(self.get(i)));\n }\n dest\n }\n\n /// Collects every element satisfying the predicate `f` into a fresh array.\n pub unconstrained fn filter<Env>(self, f: unconstrained fn[Env](T) -> bool) -> Self\n where\n T: Serialize + Deserialize,\n {\n let dest: Self = UnconstrainedArray::empty();\n let n = self.len();\n for i in 0..n {\n let value = self.get(i);\n if f(value) {\n dest.push(value);\n }\n }\n dest\n }\n\n /// Returns `true` if at least one element satisfies the predicate `f`.\n pub unconstrained fn any<Env>(self, f: unconstrained fn[Env](T) -> bool) -> bool\n where\n T: Serialize + Deserialize,\n {\n self.filter(f).len() != 0\n }\n\n /// Returns `true` if every element satisfies the predicate `f` (vacuously `true` for an empty array).\n pub unconstrained fn all<Env>(self, f: unconstrained fn[Env](T) -> bool) -> bool\n where\n T: Serialize + Deserialize,\n {\n self.filter(f).len() == self.len()\n }\n\n /// Returns the first element satisfying the predicate `f`, or `Option::none` if none do.\n pub unconstrained fn find<Env>(self, f: unconstrained fn[Env](T) -> bool) -> Option<T>\n where\n T: Deserialize,\n {\n let n = self.len();\n let mut result: Option<T> = Option::none();\n let mut i = 0;\n while (i < n) & result.is_none() {\n let value = self.get(i);\n if f(value) {\n result = Option::some(value);\n }\n i += 1;\n }\n result\n }\n}\n"
|
|
1112
1138
|
},
|
|
1113
|
-
"
|
|
1139
|
+
"288": {
|
|
1114
1140
|
"function_locations": [
|
|
1115
1141
|
{
|
|
1116
1142
|
"name": "compare",
|
|
@@ -1121,10 +1147,10 @@
|
|
|
1121
1147
|
"start": 987
|
|
1122
1148
|
}
|
|
1123
1149
|
],
|
|
1124
|
-
"path": "/
|
|
1150
|
+
"path": "/mnt/user-data/nicov/node-3/noir-projects/aztec-nr/aztec/src/utils/comparison.nr",
|
|
1125
1151
|
"source": "struct ComparatorEnum {\n pub EQ: u8,\n pub NEQ: u8,\n pub LT: u8,\n pub LTE: u8,\n pub GT: u8,\n pub GTE: u8,\n}\n\npub global Comparator: ComparatorEnum = ComparatorEnum { EQ: 1, NEQ: 2, LT: 3, LTE: 4, GT: 5, GTE: 6 };\n\npub fn compare(lhs: Field, operation: u8, rhs: Field) -> bool {\n // Values are computed ahead of time because circuits evaluate all branches\n let is_equal = lhs == rhs;\n let is_lt = lhs.lt(rhs);\n\n if (operation == Comparator.EQ) {\n is_equal\n } else if (operation == Comparator.NEQ) {\n !is_equal\n } else if (operation == Comparator.LT) {\n is_lt\n } else if (operation == Comparator.LTE) {\n is_lt | is_equal\n } else if (operation == Comparator.GT) {\n !is_lt & !is_equal\n } else if (operation == Comparator.GTE) {\n !is_lt\n } else {\n panic(f\"Invalid operation\")\n }\n}\n\nmod test {\n use super::Comparator;\n use super::compare;\n\n #[test]\n unconstrained fn test_compare() {\n let lhs = 10;\n let rhs = 10;\n assert(compare(lhs, Comparator.EQ, rhs), \"Expected lhs to be equal to rhs\");\n\n let lhs = 10;\n let rhs = 11;\n assert(compare(lhs, Comparator.NEQ, rhs), \"Expected lhs to be not equal to rhs\");\n\n let lhs = 10;\n let rhs = 11;\n assert(compare(lhs, Comparator.LT, rhs), \"Expected lhs to be less than rhs\");\n\n let lhs = 10;\n let rhs = 10;\n assert(compare(lhs, Comparator.LTE, rhs), \"Expected lhs to be less than or equal to rhs\");\n\n let lhs = 11;\n let rhs = 10;\n assert(compare(lhs, Comparator.GT, rhs), \"Expected lhs to be greater than rhs\");\n\n let lhs = 10;\n let rhs = 10;\n assert(compare(lhs, Comparator.GTE, rhs), \"Expected lhs to be greater than or equal to rhs\");\n\n let lhs = 11;\n let rhs = 10;\n assert(compare(lhs, Comparator.GTE, rhs), \"Expected lhs to be greater than or equal to rhs\");\n\n let lhs = 10;\n let rhs = 11;\n assert(!compare(lhs, Comparator.EQ, rhs), \"Expected lhs to be not equal to rhs\");\n\n let lhs = 10;\n let rhs = 10;\n assert(!compare(lhs, Comparator.NEQ, rhs), \"Expected lhs to not be not equal to rhs\");\n\n let lhs = 11;\n let rhs = 10;\n assert(!compare(lhs, Comparator.LT, rhs), \"Expected lhs to not be less than rhs\");\n\n let lhs = 11;\n let rhs = 10;\n assert(!compare(lhs, Comparator.LTE, rhs), \"Expected lhs to not be less than or equal to rhs\");\n\n let lhs = 10;\n let rhs = 10;\n assert(!compare(lhs, Comparator.GT, rhs), \"Expected lhs to not be greater than rhs\");\n\n let lhs = 10;\n let rhs = 11;\n assert(!compare(lhs, Comparator.GTE, rhs), \"Expected lhs to not be greater than or equal to rhs\");\n\n let lhs = 10;\n let rhs = 11;\n assert(!compare(lhs, Comparator.GTE, rhs), \"Expected lhs to not be greater than or equal to rhs\");\n }\n}\n"
|
|
1126
1152
|
},
|
|
1127
|
-
"
|
|
1153
|
+
"303": {
|
|
1128
1154
|
"function_locations": [
|
|
1129
1155
|
{
|
|
1130
1156
|
"name": "Poseidon2::hash",
|
|
@@ -1163,10 +1189,10 @@
|
|
|
1163
1189
|
"start": 4549
|
|
1164
1190
|
}
|
|
1165
1191
|
],
|
|
1166
|
-
"path": "/
|
|
1192
|
+
"path": "/mnt/user-data/nicov/nargo/github.com/noir-lang/poseidon/v0.3.0/src/poseidon2.nr",
|
|
1167
1193
|
"source": "use std::default::Default;\nuse std::hash::Hasher;\n\nglobal RATE: u32 = 3;\n\npub struct Poseidon2 {\n cache: [Field; 3],\n state: [Field; 4],\n cache_size: u32,\n squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n #[no_predicates]\n pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n Poseidon2::hash_internal(input, message_size)\n }\n\n pub(crate) fn new(iv: Field) -> Poseidon2 {\n let mut result =\n Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n result.state[RATE] = iv;\n result\n }\n\n fn perform_duplex(&mut self) {\n // add the cache into sponge state\n self.state[0] += self.cache[0];\n self.state[1] += self.cache[1];\n self.state[2] += self.cache[2];\n self.state = crate::poseidon2_permutation(self.state);\n }\n\n fn absorb(&mut self, input: Field) {\n assert(!self.squeeze_mode);\n if self.cache_size == RATE {\n // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n self.perform_duplex();\n self.cache[0] = input;\n self.cache_size = 1;\n } else {\n // If we're absorbing, and the cache is not full, add the input into the cache\n self.cache[self.cache_size] = input;\n self.cache_size += 1;\n }\n }\n\n fn squeeze(&mut self) -> Field {\n assert(!self.squeeze_mode);\n // If we're in absorb mode, apply sponge permutation to compress the cache.\n self.perform_duplex();\n self.squeeze_mode = true;\n\n // Pop one item off the top of the permutation and return it.\n self.state[0]\n }\n\n fn hash_internal<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n let two_pow_64 = 18446744073709551616;\n let iv: Field = (in_len as Field) * two_pow_64;\n let mut state = [0; 4];\n state[RATE] = iv;\n\n if std::runtime::is_unconstrained() {\n for i in 0..(in_len / RATE) {\n state[0] += input[i * RATE];\n state[1] += input[i * RATE + 1];\n state[2] += input[i * RATE + 2];\n state = crate::poseidon2_permutation(state);\n }\n\n // handle remaining elements after last full RATE-sized chunk\n let num_extra_fields = in_len % RATE;\n if num_extra_fields != 0 {\n let remainder_start = in_len - num_extra_fields;\n state[0] += input[remainder_start];\n if num_extra_fields > 1 {\n state[1] += input[remainder_start + 1];\n }\n }\n } else {\n let mut states: [[Field; 4]; N / RATE + 1] = [[0; 4]; N / RATE + 1];\n states[0] = state;\n\n // process all full RATE-sized chunks, storing state after each permutation\n for chunk_idx in 0..(N / RATE) {\n for i in 0..RATE {\n state[i] += input[chunk_idx * RATE + i];\n }\n state = crate::poseidon2_permutation(state);\n states[chunk_idx + 1] = state;\n }\n\n // get state at the last full block before in_len\n let first_partially_filled_chunk = in_len / RATE;\n state = states[first_partially_filled_chunk];\n\n // handle remaining elements after last full RATE-sized chunk\n let remainder_start = (in_len / RATE) * RATE;\n for j in 0..RATE {\n let idx = remainder_start + j;\n if idx < in_len {\n state[j] += input[idx];\n }\n }\n }\n\n // always run final permutation unless we just completed a full chunk\n // still need to permute once if in_len is 0\n if (in_len == 0) | (in_len % RATE != 0) {\n state = crate::poseidon2_permutation(state);\n };\n\n state[0]\n }\n}\n\npub struct Poseidon2Hasher {\n _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n fn finish(self) -> Field {\n let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n let mut sponge = Poseidon2::new(iv);\n for i in 0..self._state.len() {\n sponge.absorb(self._state[i]);\n }\n sponge.squeeze()\n }\n\n fn write(&mut self, input: Field) {\n self._state = self._state.push_back(input);\n }\n}\n\nimpl Default for Poseidon2Hasher {\n fn default() -> Self {\n Poseidon2Hasher { _state: @[] }\n }\n}\n"
|
|
1168
1194
|
},
|
|
1169
|
-
"
|
|
1195
|
+
"391": {
|
|
1170
1196
|
"function_locations": [
|
|
1171
1197
|
{
|
|
1172
1198
|
"name": "sha256_to_field",
|
|
@@ -1254,53 +1280,65 @@
|
|
|
1254
1280
|
},
|
|
1255
1281
|
{
|
|
1256
1282
|
"name": "poseidon2_hash_bytes",
|
|
1257
|
-
"start":
|
|
1283
|
+
"start": 12580
|
|
1284
|
+
},
|
|
1285
|
+
{
|
|
1286
|
+
"name": "poseidon2_hash_bytes_matches_hash_of_packed_chunks",
|
|
1287
|
+
"start": 13179
|
|
1288
|
+
},
|
|
1289
|
+
{
|
|
1290
|
+
"name": "poseidon2_hash_bytes_ignores_trailing_zeros_in_last_chunk",
|
|
1291
|
+
"start": 13418
|
|
1292
|
+
},
|
|
1293
|
+
{
|
|
1294
|
+
"name": "poseidon2_hash_bytes_commits_to_chunk_count",
|
|
1295
|
+
"start": 13638
|
|
1258
1296
|
},
|
|
1259
1297
|
{
|
|
1260
1298
|
"name": "subarray_hash_matches_fixed",
|
|
1261
|
-
"start":
|
|
1299
|
+
"start": 13869
|
|
1262
1300
|
},
|
|
1263
1301
|
{
|
|
1264
1302
|
"name": "subarray_hash_matches_variable",
|
|
1265
|
-
"start":
|
|
1303
|
+
"start": 14268
|
|
1266
1304
|
},
|
|
1267
1305
|
{
|
|
1268
1306
|
"name": "subarray_hash_with_separator_matches_fixed_len_with_separator",
|
|
1269
|
-
"start":
|
|
1307
|
+
"start": 14724
|
|
1270
1308
|
},
|
|
1271
1309
|
{
|
|
1272
1310
|
"name": "smoke_sha256_to_field",
|
|
1273
|
-
"start":
|
|
1311
|
+
"start": 15349
|
|
1274
1312
|
},
|
|
1275
1313
|
{
|
|
1276
1314
|
"name": "unique_siloed_note_hash_matches_typescript",
|
|
1277
|
-
"start":
|
|
1315
|
+
"start": 16751
|
|
1278
1316
|
},
|
|
1279
1317
|
{
|
|
1280
1318
|
"name": "siloed_nullifier_matches_typescript",
|
|
1281
|
-
"start":
|
|
1319
|
+
"start": 17973
|
|
1282
1320
|
},
|
|
1283
1321
|
{
|
|
1284
1322
|
"name": "siloed_private_log_first_field_matches_typescript",
|
|
1285
|
-
"start":
|
|
1323
|
+
"start": 18353
|
|
1286
1324
|
},
|
|
1287
1325
|
{
|
|
1288
1326
|
"name": "empty_l2_to_l1_message_hash_matches_typescript",
|
|
1289
|
-
"start":
|
|
1327
|
+
"start": 18763
|
|
1290
1328
|
},
|
|
1291
1329
|
{
|
|
1292
1330
|
"name": "l2_to_l1_message_hash_matches_typescript",
|
|
1293
|
-
"start":
|
|
1331
|
+
"start": 19214
|
|
1294
1332
|
},
|
|
1295
1333
|
{
|
|
1296
1334
|
"name": "poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version",
|
|
1297
|
-
"start":
|
|
1335
|
+
"start": 19830
|
|
1298
1336
|
}
|
|
1299
1337
|
],
|
|
1300
|
-
"path": "/
|
|
1301
|
-
"source": "mod poseidon2_chunks;\n\nuse crate::{\n abis::{\n contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n function_selector::FunctionSelector, nullifier::Nullifier, private_log::PrivateLog,\n transaction::tx_request::TxRequest,\n },\n address::{AztecAddress, EthAddress},\n constants::{\n CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, DOM_SEP__NOTE_HASH_NONCE,\n DOM_SEP__PRIVATE_LOG_FIRST_FIELD, DOM_SEP__SILOED_NOTE_HASH, DOM_SEP__SILOED_NULLIFIER,\n DOM_SEP__UNIQUE_NOTE_HASH, FUNCTION_TREE_HEIGHT, NULL_MSG_SENDER_CONTRACT_ADDRESS,\n TWO_POW_64,\n },\n merkle_tree::root_from_sibling_path,\n messaging::l2_to_l1_message::L2ToL1Message,\n poseidon2::Poseidon2Sponge,\n side_effect::{Counted, Scoped},\n traits::{FromField, Hash, ToField},\n utils::field::{field_from_bytes, field_from_bytes_32_trunc},\n};\n\npub use poseidon2_chunks::poseidon2_absorb_in_chunks_existing_sponge;\nuse poseidon2_chunks::poseidon2_absorb_in_chunks;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\n// TODO: refactor these into their own files: sha256, poseidon2, some protocol-specific hash computations, some merkle computations.\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n let sha256_hashed = sha256::digest(bytes_to_hash);\n let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n selector: FunctionSelector,\n vk_hash: Field,\n function_leaf_index: Field,\n function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n let function_leaf = function_leaf_preimage.hash();\n root_from_sibling_path(\n function_leaf,\n function_leaf_index,\n function_leaf_sibling_path,\n )\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn compute_siloed_note_hash(contract_address: AztecAddress, note_hash: Field) -> Field {\n poseidon2_hash_with_separator(\n [contract_address.to_field(), note_hash],\n DOM_SEP__SILOED_NOTE_HASH,\n )\n}\n\n/// Computes unique, siloed note hashes from siloed note hashes.\n///\n/// The protocol injects uniqueness into every note_hash, so that every single note_hash in the\n/// tree is unique. This prevents faerie gold attacks, where a malicious sender could create\n/// two identical note_hashes for a recipient (meaning only one would be nullifiable in future).\n///\n/// Most privacy protocols will inject the note's leaf_index (its position in the Note Hashes Tree)\n/// into the note, but this requires the creator of a note to wait until their tx is included in\n/// a block to know the note's final note hash (the unique, siloed note hash), because inserting\n/// leaves into trees is the job of a block producer.\n///\n/// We took a different approach so that the creator of a note will know each note's unique, siloed\n/// note hash before broadcasting their tx to the network.\n/// (There was also a historical requirement relating to \"chained transactions\" -- a feature that\n/// Aztec Connect had to enable notes to be spent from distinct txs earlier in the same block,\n/// and hence before an archive block root had been established for that block -- but that feature\n/// was abandoned for the Aztec Network for having too many bad tradeoffs).\n///\n/// (\n/// Edit: it is no longer true that all final note_hashes will be known by the creator of a tx\n/// before they send it to the network. If a tx makes public function calls, then _revertible_\n/// note_hashes that are created in private will not be made unique in private by the Reset circuit,\n/// but will instead be made unique by the AVM, because the `note_index_in_tx` will not be known\n/// until the AVM has executed the public functions of the tx. (See an explanation in\n/// reset_output_composer.nr for why).\n/// For some such txs, the `note_index_in_tx` might still be predictable through simulation, but\n/// for txs whose public functions create a varying number of non-revertible notes (determined at\n/// runtime), the `note_index_in_tx` will not be deterministically derivable before submitting the\n/// tx to the network.\n/// )\n///\n/// We use the `first_nullifier` of a tx as a seed of uniqueness. We have a guarantee that there will\n/// always be at least one nullifier per tx, because the init circuit will create one if one isn't\n/// created naturally by any functions of the tx. (Search \"protocol_nullifier\").\n/// We combine the `first_nullifier` with the note's index (its position within this tx's new\n/// note_hashes array) (`note_index_in_tx`) to get a truly unique value to inject into a note, which\n/// we call a `note_nonce`.\npub fn compute_unique_note_hash(note_nonce: Field, siloed_note_hash: Field) -> Field {\n let inputs = [note_nonce, siloed_note_hash];\n poseidon2_hash_with_separator(inputs, DOM_SEP__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n // unique).\n poseidon2_hash_with_separator(\n [first_nullifier_in_tx, note_index_in_tx as Field],\n DOM_SEP__NOTE_HASH_NONCE,\n )\n}\n\npub fn compute_note_nonce_and_unique_note_hash(\n siloed_note_hash: Field,\n first_nullifier: Field,\n note_index_in_tx: u32,\n) -> Field {\n let note_nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n compute_unique_note_hash(note_nonce, siloed_note_hash)\n}\n\npub fn compute_siloed_nullifier(contract_address: AztecAddress, nullifier: Field) -> Field {\n poseidon2_hash_with_separator(\n [contract_address.to_field(), nullifier],\n DOM_SEP__SILOED_NULLIFIER,\n )\n}\n\npub fn create_protocol_nullifier(tx_request: TxRequest) -> Scoped<Counted<Nullifier>> {\n // The protocol nullifier is ascribed a special side-effect counter of 1. No other side-effect\n // can have counter 1 (see `validate_as_first_call` for that assertion). Its value is the\n // transaction's nonce commitment (origin, chain id, version, salt): see\n // `TxRequest::compute_protocol_nullifier_value`. The reset kernel siloes it under\n // `NULL_MSG_SENDER_CONTRACT_ADDRESS` like every other nullifier.\n Nullifier { value: tx_request.compute_protocol_nullifier_value(), note_hash: 0 }.count(1).scope(\n NULL_MSG_SENDER_CONTRACT_ADDRESS,\n )\n}\n\npub fn compute_log_tag(raw_tag: Field, dom_sep: u32) -> Field {\n poseidon2_hash_with_separator([raw_tag], dom_sep)\n}\n\npub fn compute_siloed_private_log_first_field(\n contract_address: AztecAddress,\n field: Field,\n) -> Field {\n poseidon2_hash_with_separator(\n [contract_address.to_field(), field],\n DOM_SEP__PRIVATE_LOG_FIRST_FIELD,\n )\n}\n\npub fn compute_siloed_private_log(contract_address: AztecAddress, log: PrivateLog) -> PrivateLog {\n let mut fields = log.fields;\n fields[0] = compute_siloed_private_log_first_field(contract_address, fields[0]);\n PrivateLog::new(fields, log.length)\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n poseidon2_hash(log)\n}\n\npub fn compute_app_siloed_secret_key(\n master_secret_key: EmbeddedCurveScalar,\n app_address: AztecAddress,\n key_type_domain_separator: Field,\n) -> Field {\n poseidon2_hash_with_separator(\n [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n key_type_domain_separator,\n )\n}\n\npub fn compute_l2_to_l1_message_hash(\n message: Scoped<L2ToL1Message>,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n let contract_address_bytes: [u8; 32] = message.contract_address.to_field().to_be_bytes();\n let recipient_bytes: [u8; 20] = message.inner.recipient.to_be_bytes();\n let content_bytes: [u8; 32] = message.inner.content.to_be_bytes();\n let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n let mut bytes: [u8; 148] = std::mem::zeroed();\n for i in 0..32 {\n bytes[i] = contract_address_bytes[i];\n bytes[i + 32] = rollup_version_id_bytes[i];\n // 64 - 84 are for recipient.\n bytes[i + 84] = chain_id_bytes[i];\n bytes[i + 116] = content_bytes[i];\n }\n\n for i in 0..20 {\n bytes[64 + i] = recipient_bytes[i];\n }\n\n sha256_to_field(bytes)\n}\n\n/// Computes sha256 hash of 2 input fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256(v0: Field, v1: Field) -> Field {\n // Concatenate two fields into 32 x 2 = 64 bytes\n let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n let hash_input_flattened = v0_as_bytes.concat(v1_as_bytes);\n\n sha256_to_field(hash_input_flattened)\n}\n\n/// Computes sha256 hash of 2 input fields, prefixed by a domain separator, so that the result cannot collide with an\n/// [`accumulate_sha256`] over the same two fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256_with_separator(separator: u32, v0: Field, v1: Field) -> Field {\n // Concatenate the separator and two fields into 4 + 32 x 2 = 68 bytes\n let separator_as_bytes: [u8; 4] = (separator as Field).to_be_bytes();\n let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n let hash_input_flattened = separator_as_bytes.concat(v0_as_bytes).concat(v1_as_bytes);\n\n sha256_to_field(hash_input_flattened)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n T: ToField,\n{\n let inputs_with_separator = [separator.to_field()].concat(inputs);\n poseidon2_hash(inputs_with_separator)\n}\n\n/// Computes a Poseidon2 hash over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// The caller is responsible for ensuring that the input is padded with zeros if required.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n sponge.squeeze()\n}\n\n/// Computes a Poseidon2 hash with a domain separator over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// For `in_len == N` this is equivalent to [`poseidon2_hash_with_separator`].\n#[no_predicates]\npub fn poseidon2_hash_subarray_with_separator<let N: u32, T>(\n input: [Field; N],\n in_len: u32,\n separator: T,\n) -> Field\nwhere\n T: ToField,\n{\n let inputs_with_separator = [separator.to_field()].concat(input);\n poseidon::poseidon2::Poseidon2::hash(inputs_with_separator, in_len + 1)\n}\n\n// This function is unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n inputs: BoundedVec<Field, N>,\n separator: T,\n) -> Field\nwhere\n T: ToField,\n{\n let in_len = inputs.len() + 1;\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n sponge.absorb(separator.to_field());\n\n for i in 0..inputs.len() {\n sponge.absorb(inputs.get(i));\n }\n\n sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n let mut fields = [0; (N + 30) / 31];\n let mut field_index = 0;\n let mut current_field = [0; 31];\n for i in 0..inputs.len() {\n let index = i % 31;\n current_field[index] = inputs[i];\n if index == 30 {\n fields[field_index] = field_from_bytes(current_field, false);\n current_field = [0; 31];\n field_index += 1;\n }\n }\n if field_index != fields.len() {\n fields[field_index] = field_from_bytes(current_field, false);\n }\n poseidon2_hash(fields)\n}\n\n#[test]\nfn subarray_hash_matches_fixed() {\n let values_to_hash = [3; 17];\n let padded = values_to_hash.concat([0; 11]);\n let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n // Hash the entire values_to_hash.\n let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(values_to_hash, values_to_hash.len());\n\n assert_eq(subarray_hash, fixed_len_hash);\n}\n\n#[test]\nfn subarray_hash_matches_variable() {\n let values_to_hash = [3; 17];\n let padded = values_to_hash.concat([0; 11]);\n let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n // Hash up to values_to_hash.len() fields of the padded array.\n let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(padded, values_to_hash.len());\n\n assert_eq(subarray_hash, variable_len_hash);\n}\n\n#[test]\nfn subarray_hash_with_separator_matches_fixed_len_with_separator() {\n let values_to_hash = [3; 17];\n let padded = values_to_hash.concat([0; 11]);\n let separator = 42;\n\n assert_eq(\n poseidon2_hash_subarray_with_separator(padded, values_to_hash.len(), separator),\n poseidon2_hash_with_separator(values_to_hash, separator),\n );\n // Hashing the whole array must differ from hashing a prefix of it, even though the padding is zero.\n assert(\n poseidon2_hash_subarray_with_separator(padded, padded.len(), separator)\n != poseidon2_hash_subarray_with_separator(padded, values_to_hash.len(), separator),\n );\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n let full_buffer = [\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n ];\n let result = sha256_to_field(full_buffer);\n\n assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n let result_bytes = sha256::digest(full_buffer);\n let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n assert(truncated_field == result);\n let mod_res = result + (result_bytes[31] as Field);\n assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn unique_siloed_note_hash_matches_typescript() {\n let inner_note_hash = 1;\n let contract_address = AztecAddress::from_field(2);\n let first_nullifier = 3;\n let note_index_in_tx = 4;\n\n let siloed_note_hash = compute_siloed_note_hash(contract_address, inner_note_hash);\n let siloed_note_hash_from_ts =\n 0x1986a4bea3eddb1fff917d629a13e10f63f514f401bdd61838c6b475db949169;\n assert_eq(siloed_note_hash, siloed_note_hash_from_ts);\n\n let nonce: Field = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n let note_hash_nonce_from_ts =\n 0x28e7799791bf066a57bb51fdd0fbcaf3f0926414314c7db515ea343f44f5d58b;\n assert_eq(nonce, note_hash_nonce_from_ts);\n\n let unique_siloed_note_hash_from_nonce = compute_unique_note_hash(nonce, siloed_note_hash);\n let unique_siloed_note_hash = compute_note_nonce_and_unique_note_hash(\n siloed_note_hash,\n first_nullifier,\n note_index_in_tx,\n );\n assert_eq(unique_siloed_note_hash_from_nonce, unique_siloed_note_hash);\n\n let unique_siloed_note_hash_from_ts =\n 0x29949aef207b715303b24639737c17fbfeb375c1d965ecfa85c7e4f0febb7d16;\n assert_eq(unique_siloed_note_hash, unique_siloed_note_hash_from_ts);\n}\n\n#[test]\nfn siloed_nullifier_matches_typescript() {\n let contract_address = AztecAddress::from_field(123);\n let nullifier = 456;\n\n let res = compute_siloed_nullifier(contract_address, nullifier);\n\n let siloed_nullifier_from_ts =\n 0x169b50336c1f29afdb8a03d955a81e485f5ac7d5f0b8065673d1e407e5877813;\n\n assert_eq(res, siloed_nullifier_from_ts);\n}\n\n#[test]\nfn siloed_private_log_first_field_matches_typescript() {\n let contract_address = AztecAddress::from_field(123);\n let field = 456;\n let res = compute_siloed_private_log_first_field(contract_address, field);\n\n let siloed_private_log_first_field_from_ts =\n 0x29480984f7b9257fded523d50addbcfc8d1d33adcf2db73ef3390a8fd5cdffaa;\n\n assert_eq(res, siloed_private_log_first_field_from_ts);\n}\n\n#[test]\nfn empty_l2_to_l1_message_hash_matches_typescript() {\n // All zeroes\n let res = compute_l2_to_l1_message_hash(\n L2ToL1Message { recipient: EthAddress::zero(), content: 0 }.scope(AztecAddress::from_field(\n 0,\n )),\n 0,\n 0,\n );\n\n let empty_l2_to_l1_msg_hash_from_ts =\n 0x003b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992;\n\n assert_eq(res, empty_l2_to_l1_msg_hash_from_ts);\n}\n\n#[test]\nfn l2_to_l1_message_hash_matches_typescript() {\n let message = L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n AztecAddress::from_field(3),\n );\n let version = 4;\n let chainId = 5;\n\n let hash = compute_l2_to_l1_message_hash(message, version, chainId);\n\n // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n let l2_to_l1_message_hash_from_ts =\n 0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n assert_eq(hash, l2_to_l1_message_hash_from_ts);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n let separator = 42;\n\n // Hash using bounded vec version\n let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n // Hash using regular version\n let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n // Results should match\n assert_eq(bounded_result, regular_result);\n}\n"
|
|
1338
|
+
"path": "/mnt/user-data/nicov/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0-rc.6/noir-projects/fnd/noir-protocol-circuits/crates/types/src/hash.nr",
|
|
1339
|
+
"source": "mod poseidon2_chunks;\n\nuse crate::{\n abis::{\n contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n function_selector::FunctionSelector, nullifier::Nullifier, private_log::PrivateLog,\n transaction::tx_request::TxRequest,\n },\n address::{AztecAddress, EthAddress},\n constants::{\n CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, DOM_SEP__NOTE_HASH_NONCE,\n DOM_SEP__PRIVATE_LOG_FIRST_FIELD, DOM_SEP__SILOED_NOTE_HASH, DOM_SEP__SILOED_NULLIFIER,\n DOM_SEP__UNIQUE_NOTE_HASH, FUNCTION_TREE_HEIGHT, NULL_MSG_SENDER_CONTRACT_ADDRESS,\n TWO_POW_64,\n },\n merkle_tree::root_from_sibling_path,\n messaging::l2_to_l1_message::L2ToL1Message,\n poseidon2::Poseidon2Sponge,\n side_effect::{Counted, Scoped},\n traits::{FromField, Hash, ToField},\n utils::field::{field_from_bytes, field_from_bytes_32_trunc},\n};\n\npub use poseidon2_chunks::poseidon2_absorb_in_chunks_existing_sponge;\nuse poseidon2_chunks::poseidon2_absorb_in_chunks;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\n// TODO: refactor these into their own files: sha256, poseidon2, some protocol-specific hash computations, some merkle computations.\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n let sha256_hashed = sha256::digest(bytes_to_hash);\n let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n selector: FunctionSelector,\n vk_hash: Field,\n function_leaf_index: Field,\n function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n let function_leaf = function_leaf_preimage.hash();\n root_from_sibling_path(\n function_leaf,\n function_leaf_index,\n function_leaf_sibling_path,\n )\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn compute_siloed_note_hash(contract_address: AztecAddress, note_hash: Field) -> Field {\n poseidon2_hash_with_separator(\n [contract_address.to_field(), note_hash],\n DOM_SEP__SILOED_NOTE_HASH,\n )\n}\n\n/// Computes unique, siloed note hashes from siloed note hashes.\n///\n/// The protocol injects uniqueness into every note_hash, so that every single note_hash in the\n/// tree is unique. This prevents faerie gold attacks, where a malicious sender could create\n/// two identical note_hashes for a recipient (meaning only one would be nullifiable in future).\n///\n/// Most privacy protocols will inject the note's leaf_index (its position in the Note Hashes Tree)\n/// into the note, but this requires the creator of a note to wait until their tx is included in\n/// a block to know the note's final note hash (the unique, siloed note hash), because inserting\n/// leaves into trees is the job of a block producer.\n///\n/// We took a different approach so that the creator of a note will know each note's unique, siloed\n/// note hash before broadcasting their tx to the network.\n/// (There was also a historical requirement relating to \"chained transactions\" -- a feature that\n/// Aztec Connect had to enable notes to be spent from distinct txs earlier in the same block,\n/// and hence before an archive block root had been established for that block -- but that feature\n/// was abandoned for the Aztec Network for having too many bad tradeoffs).\n///\n/// (\n/// Edit: it is no longer true that all final note_hashes will be known by the creator of a tx\n/// before they send it to the network. If a tx makes public function calls, then _revertible_\n/// note_hashes that are created in private will not be made unique in private by the Reset circuit,\n/// but will instead be made unique by the AVM, because the `note_index_in_tx` will not be known\n/// until the AVM has executed the public functions of the tx. (See an explanation in\n/// reset_output_composer.nr for why).\n/// For some such txs, the `note_index_in_tx` might still be predictable through simulation, but\n/// for txs whose public functions create a varying number of non-revertible notes (determined at\n/// runtime), the `note_index_in_tx` will not be deterministically derivable before submitting the\n/// tx to the network.\n/// )\n///\n/// We use the `first_nullifier` of a tx as a seed of uniqueness. We have a guarantee that there will\n/// always be at least one nullifier per tx, because the init circuit will create one if one isn't\n/// created naturally by any functions of the tx. (Search \"protocol_nullifier\").\n/// We combine the `first_nullifier` with the note's index (its position within this tx's new\n/// note_hashes array) (`note_index_in_tx`) to get a truly unique value to inject into a note, which\n/// we call a `note_nonce`.\npub fn compute_unique_note_hash(note_nonce: Field, siloed_note_hash: Field) -> Field {\n let inputs = [note_nonce, siloed_note_hash];\n poseidon2_hash_with_separator(inputs, DOM_SEP__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n // unique).\n poseidon2_hash_with_separator(\n [first_nullifier_in_tx, note_index_in_tx as Field],\n DOM_SEP__NOTE_HASH_NONCE,\n )\n}\n\npub fn compute_note_nonce_and_unique_note_hash(\n siloed_note_hash: Field,\n first_nullifier: Field,\n note_index_in_tx: u32,\n) -> Field {\n let note_nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n compute_unique_note_hash(note_nonce, siloed_note_hash)\n}\n\npub fn compute_siloed_nullifier(contract_address: AztecAddress, nullifier: Field) -> Field {\n poseidon2_hash_with_separator(\n [contract_address.to_field(), nullifier],\n DOM_SEP__SILOED_NULLIFIER,\n )\n}\n\npub fn create_protocol_nullifier(tx_request: TxRequest) -> Scoped<Counted<Nullifier>> {\n // The protocol nullifier is ascribed a special side-effect counter of 1. No other side-effect\n // can have counter 1 (see `validate_as_first_call` for that assertion). Its value is the\n // transaction's nonce commitment (origin, chain id, version, salt): see\n // `TxRequest::compute_protocol_nullifier_value`. The reset kernel siloes it under\n // `NULL_MSG_SENDER_CONTRACT_ADDRESS` like every other nullifier.\n Nullifier { value: tx_request.compute_protocol_nullifier_value(), note_hash: 0 }.count(1).scope(\n NULL_MSG_SENDER_CONTRACT_ADDRESS,\n )\n}\n\npub fn compute_log_tag(raw_tag: Field, dom_sep: u32) -> Field {\n poseidon2_hash_with_separator([raw_tag], dom_sep)\n}\n\npub fn compute_siloed_private_log_first_field(\n contract_address: AztecAddress,\n field: Field,\n) -> Field {\n poseidon2_hash_with_separator(\n [contract_address.to_field(), field],\n DOM_SEP__PRIVATE_LOG_FIRST_FIELD,\n )\n}\n\npub fn compute_siloed_private_log(contract_address: AztecAddress, log: PrivateLog) -> PrivateLog {\n let mut fields = log.fields;\n fields[0] = compute_siloed_private_log_first_field(contract_address, fields[0]);\n PrivateLog::new(fields, log.length)\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n poseidon2_hash(log)\n}\n\npub fn compute_app_siloed_secret_key(\n master_secret_key: EmbeddedCurveScalar,\n app_address: AztecAddress,\n key_type_domain_separator: Field,\n) -> Field {\n poseidon2_hash_with_separator(\n [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n key_type_domain_separator,\n )\n}\n\npub fn compute_l2_to_l1_message_hash(\n message: Scoped<L2ToL1Message>,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n let contract_address_bytes: [u8; 32] = message.contract_address.to_field().to_be_bytes();\n let recipient_bytes: [u8; 20] = message.inner.recipient.to_be_bytes();\n let content_bytes: [u8; 32] = message.inner.content.to_be_bytes();\n let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n let mut bytes: [u8; 148] = std::mem::zeroed();\n for i in 0..32 {\n bytes[i] = contract_address_bytes[i];\n bytes[i + 32] = rollup_version_id_bytes[i];\n // 64 - 84 are for recipient.\n bytes[i + 84] = chain_id_bytes[i];\n bytes[i + 116] = content_bytes[i];\n }\n\n for i in 0..20 {\n bytes[64 + i] = recipient_bytes[i];\n }\n\n sha256_to_field(bytes)\n}\n\n/// Computes sha256 hash of 2 input fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256(v0: Field, v1: Field) -> Field {\n // Concatenate two fields into 32 x 2 = 64 bytes\n let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n let hash_input_flattened = v0_as_bytes.concat(v1_as_bytes);\n\n sha256_to_field(hash_input_flattened)\n}\n\n/// Computes sha256 hash of 2 input fields, prefixed by a domain separator, so that the result cannot collide with an\n/// [`accumulate_sha256`] over the same two fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256_with_separator(separator: u32, v0: Field, v1: Field) -> Field {\n // Concatenate the separator and two fields into 4 + 32 x 2 = 68 bytes\n let separator_as_bytes: [u8; 4] = (separator as Field).to_be_bytes();\n let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n let hash_input_flattened = separator_as_bytes.concat(v0_as_bytes).concat(v1_as_bytes);\n\n sha256_to_field(hash_input_flattened)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n T: ToField,\n{\n let inputs_with_separator = [separator.to_field()].concat(inputs);\n poseidon2_hash(inputs_with_separator)\n}\n\n/// Computes a Poseidon2 hash over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// The caller is responsible for ensuring that the input is padded with zeros if required.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n sponge.squeeze()\n}\n\n/// Computes a Poseidon2 hash with a domain separator over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// For `in_len == N` this is equivalent to [`poseidon2_hash_with_separator`].\n#[no_predicates]\npub fn poseidon2_hash_subarray_with_separator<let N: u32, T>(\n input: [Field; N],\n in_len: u32,\n separator: T,\n) -> Field\nwhere\n T: ToField,\n{\n let inputs_with_separator = [separator.to_field()].concat(input);\n poseidon::poseidon2::Poseidon2::hash(inputs_with_separator, in_len + 1)\n}\n\n// This function is unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n inputs: BoundedVec<Field, N>,\n separator: T,\n) -> Field\nwhere\n T: ToField,\n{\n let in_len = inputs.len() + 1;\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n sponge.absorb(separator.to_field());\n\n for i in 0..inputs.len() {\n sponge.absorb(inputs.get(i));\n }\n\n sponge.squeeze()\n}\n\n/// Computes a Poseidon2 hash of a fixed string, such as a function signature or a domain separator name.\n///\n/// The bytes are packed into 31-byte little-endian chunks, one `Field` per chunk, and the result is\n/// [`poseidon2_hash`] of those fields.\n///\n/// The hash commits to the number of chunks but not to the byte length `N`: zero bytes at the end of the last chunk\n/// do not change the result, so `[1]`, `[1, 0]` and `[1, 0, ..., 0]` (31 bytes) all hash to the same value. Do not\n/// use this to commit to variable-length data, e.g. a payload zero-padded to a maximum length, unless the length is\n/// bound separately.\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n let mut fields = [0; (N + 30) / 31];\n let mut field_index = 0;\n let mut current_field = [0; 31];\n for i in 0..inputs.len() {\n let index = i % 31;\n current_field[index] = inputs[i];\n if index == 30 {\n fields[field_index] = field_from_bytes(current_field, false);\n current_field = [0; 31];\n field_index += 1;\n }\n }\n if field_index != fields.len() {\n fields[field_index] = field_from_bytes(current_field, false);\n }\n poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon2_hash_bytes_matches_hash_of_packed_chunks() {\n let mut bytes = [0; 32];\n bytes[0] = 1;\n bytes[1] = 2;\n bytes[31] = 3;\n\n assert_eq(poseidon2_hash_bytes(bytes), poseidon2_hash([1 + 2 * 256, 3]));\n}\n\n#[test]\nfn poseidon2_hash_bytes_ignores_trailing_zeros_in_last_chunk() {\n let hash = poseidon2_hash_bytes([1]);\n\n assert_eq(poseidon2_hash_bytes([1, 0]), hash);\n assert_eq(poseidon2_hash_bytes([1].concat([0; 30])), hash);\n}\n\n#[test]\nfn poseidon2_hash_bytes_commits_to_chunk_count() {\n let one_chunk: [u8; 31] = [1].concat([0; 30]);\n let two_chunks: [u8; 32] = [1].concat([0; 31]);\n\n assert(poseidon2_hash_bytes(one_chunk) != poseidon2_hash_bytes(two_chunks));\n}\n\n#[test]\nfn subarray_hash_matches_fixed() {\n let values_to_hash = [3; 17];\n let padded = values_to_hash.concat([0; 11]);\n let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n // Hash the entire values_to_hash.\n let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(values_to_hash, values_to_hash.len());\n\n assert_eq(subarray_hash, fixed_len_hash);\n}\n\n#[test]\nfn subarray_hash_matches_variable() {\n let values_to_hash = [3; 17];\n let padded = values_to_hash.concat([0; 11]);\n let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n // Hash up to values_to_hash.len() fields of the padded array.\n let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(padded, values_to_hash.len());\n\n assert_eq(subarray_hash, variable_len_hash);\n}\n\n#[test]\nfn subarray_hash_with_separator_matches_fixed_len_with_separator() {\n let values_to_hash = [3; 17];\n let padded = values_to_hash.concat([0; 11]);\n let separator = 42;\n\n assert_eq(\n poseidon2_hash_subarray_with_separator(padded, values_to_hash.len(), separator),\n poseidon2_hash_with_separator(values_to_hash, separator),\n );\n // Hashing the whole array must differ from hashing a prefix of it, even though the padding is zero.\n assert(\n poseidon2_hash_subarray_with_separator(padded, padded.len(), separator)\n != poseidon2_hash_subarray_with_separator(padded, values_to_hash.len(), separator),\n );\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n let full_buffer = [\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n ];\n let result = sha256_to_field(full_buffer);\n\n assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n let result_bytes = sha256::digest(full_buffer);\n let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n assert(truncated_field == result);\n let mod_res = result + (result_bytes[31] as Field);\n assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn unique_siloed_note_hash_matches_typescript() {\n let inner_note_hash = 1;\n let contract_address = AztecAddress::from_field(2);\n let first_nullifier = 3;\n let note_index_in_tx = 4;\n\n let siloed_note_hash = compute_siloed_note_hash(contract_address, inner_note_hash);\n let siloed_note_hash_from_ts =\n 0x1986a4bea3eddb1fff917d629a13e10f63f514f401bdd61838c6b475db949169;\n assert_eq(siloed_note_hash, siloed_note_hash_from_ts);\n\n let nonce: Field = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n let note_hash_nonce_from_ts =\n 0x28e7799791bf066a57bb51fdd0fbcaf3f0926414314c7db515ea343f44f5d58b;\n assert_eq(nonce, note_hash_nonce_from_ts);\n\n let unique_siloed_note_hash_from_nonce = compute_unique_note_hash(nonce, siloed_note_hash);\n let unique_siloed_note_hash = compute_note_nonce_and_unique_note_hash(\n siloed_note_hash,\n first_nullifier,\n note_index_in_tx,\n );\n assert_eq(unique_siloed_note_hash_from_nonce, unique_siloed_note_hash);\n\n let unique_siloed_note_hash_from_ts =\n 0x29949aef207b715303b24639737c17fbfeb375c1d965ecfa85c7e4f0febb7d16;\n assert_eq(unique_siloed_note_hash, unique_siloed_note_hash_from_ts);\n}\n\n#[test]\nfn siloed_nullifier_matches_typescript() {\n let contract_address = AztecAddress::from_field(123);\n let nullifier = 456;\n\n let res = compute_siloed_nullifier(contract_address, nullifier);\n\n let siloed_nullifier_from_ts =\n 0x169b50336c1f29afdb8a03d955a81e485f5ac7d5f0b8065673d1e407e5877813;\n\n assert_eq(res, siloed_nullifier_from_ts);\n}\n\n#[test]\nfn siloed_private_log_first_field_matches_typescript() {\n let contract_address = AztecAddress::from_field(123);\n let field = 456;\n let res = compute_siloed_private_log_first_field(contract_address, field);\n\n let siloed_private_log_first_field_from_ts =\n 0x29480984f7b9257fded523d50addbcfc8d1d33adcf2db73ef3390a8fd5cdffaa;\n\n assert_eq(res, siloed_private_log_first_field_from_ts);\n}\n\n#[test]\nfn empty_l2_to_l1_message_hash_matches_typescript() {\n // All zeroes\n let res = compute_l2_to_l1_message_hash(\n L2ToL1Message { recipient: EthAddress::zero(), content: 0 }.scope(AztecAddress::from_field(\n 0,\n )),\n 0,\n 0,\n );\n\n let empty_l2_to_l1_msg_hash_from_ts =\n 0x003b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992;\n\n assert_eq(res, empty_l2_to_l1_msg_hash_from_ts);\n}\n\n#[test]\nfn l2_to_l1_message_hash_matches_typescript() {\n let message = L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n AztecAddress::from_field(3),\n );\n let version = 4;\n let chainId = 5;\n\n let hash = compute_l2_to_l1_message_hash(message, version, chainId);\n\n // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n let l2_to_l1_message_hash_from_ts =\n 0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n assert_eq(hash, l2_to_l1_message_hash_from_ts);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n let separator = 42;\n\n // Hash using bounded vec version\n let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n // Hash using regular version\n let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n // Results should match\n assert_eq(bounded_result, regular_result);\n}\n"
|
|
1302
1340
|
},
|
|
1303
|
-
"
|
|
1341
|
+
"443": {
|
|
1304
1342
|
"function_locations": [
|
|
1305
1343
|
{
|
|
1306
1344
|
"name": "Reader<N>::new",
|
|
@@ -1347,10 +1385,10 @@
|
|
|
1347
1385
|
"start": 1426
|
|
1348
1386
|
}
|
|
1349
1387
|
],
|
|
1350
|
-
"path": "/
|
|
1388
|
+
"path": "/mnt/user-data/nicov/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0-rc.6/noir-projects/fnd/noir-protocol-circuits/crates/serde/src/reader.nr",
|
|
1351
1389
|
"source": "pub struct Reader<let N: u32> {\n data: [Field; N],\n offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\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_u32(&mut self) -> u32 {\n self.read() as u32\n }\n\n pub fn read_u64(&mut self) -> u64 {\n self.read() as u64\n }\n\n pub fn read_bool(&mut self) -> bool {\n self.read() != 0\n }\n\n pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n let mut result = [0; 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<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n let result = deserialise(self.read_array());\n result\n }\n\n pub fn read_struct_array<T, let K: u32, let C: u32>(\n &mut self,\n deserialise: fn([Field; K]) -> T,\n mut result: [T; C],\n ) -> [T; C] {\n for i in 0..C {\n result[i] = self.read_struct(deserialise);\n }\n result\n }\n\n pub fn peek_offset(&mut self, offset: u32) -> Field {\n self.data[self.offset + offset]\n }\n\n pub fn advance_offset(&mut self, offset: u32) {\n self.offset += offset;\n }\n\n pub fn finish(self) {\n assert_eq(self.offset, self.data.len(), \"Reader did not read all data\");\n }\n}\n"
|
|
1352
1390
|
},
|
|
1353
|
-
"
|
|
1391
|
+
"444": {
|
|
1354
1392
|
"function_locations": [
|
|
1355
1393
|
{
|
|
1356
1394
|
"name": "derive_serialize",
|
|
@@ -1373,10 +1411,10 @@
|
|
|
1373
1411
|
"start": 12587
|
|
1374
1412
|
}
|
|
1375
1413
|
],
|
|
1376
|
-
"path": "/
|
|
1414
|
+
"path": "/mnt/user-data/nicov/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0-rc.6/noir-projects/fnd/noir-protocol-circuits/crates/serde/src/serialization.nr",
|
|
1377
1415
|
"source": "use crate::{reader::Reader, writer::Writer};\nuse std::meta::type_def::StructField;\n\n/// Trait for serializing Noir types into arrays of Fields.\n///\n/// An implementation of the Serialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait (and Deserialize) are\n/// typically used to communicate between Noir and TypeScript (via oracles and function arguments).\n///\n/// # On Following Noir's Intrinsic Serialization\n/// When calling a Noir function from TypeScript (TS), first the function arguments are serialized into an array\n/// of fields. This array is then included in the initial witness. Noir's intrinsic serialization is then used\n/// to deserialize the arguments from the witness. When the same Noir function is called from Noir this Serialize trait\n/// is used instead of the serialization in TS. For this reason we need to have a match between TS serialization,\n/// Noir's intrinsic serialization and the implementation of this trait. If there is a mismatch, the function calls\n/// fail with an arguments hash mismatch error message.\n///\n/// # Associated Constants\n/// * `N` - The length of the output Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl<let N: u32> Serialize for str<N> {\n/// let N: u32 = N;\n///\n/// fn serialize(self) -> [Field; Self::N] {\n/// let mut writer: Writer<Self::N> = Writer::new();\n/// self.stream_serialize(&mut writer);\n/// writer.finish()\n/// }\n///\n/// fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n/// let bytes = self.as_bytes();\n/// for i in 0..bytes.len() {\n/// writer.write(bytes[i] as Field);\n/// }\n/// }\n/// }\n/// ```\n#[derive_via(derive_serialize)]\npub trait Serialize {\n let N: u32;\n\n fn serialize(self) -> [Field; Self::N];\n\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>);\n}\n\n/// Generates a `Serialize` trait implementation for a struct type.\n///\n/// # Parameters\n/// - `s`: The struct type definition to generate the implementation for\n///\n/// # Returns\n/// A quoted code block containing the trait implementation\n///\n/// # Example\n/// For a struct defined as:\n/// ```\n/// struct Log<N> {\n/// fields: [Field; N],\n/// length: u32\n/// }\n/// ```\n///\n/// This function generates code equivalent to:\n/// ```\n/// impl<let N: u32> Serialize for Log<N> {\n/// let N: u32 = <[Field; N] as Serialize>::N + <u32 as Serialize>::N;\n///\n/// fn serialize(self) -> [Field; Self::N] {\n/// let mut writer: Writer<Self::N> = Writer::new();\n/// self.stream_serialize(&mut writer);\n/// writer.finish()\n/// }\n///\n/// #[inline_always]\n/// fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n/// Serialize::stream_serialize(self.fields, writer);\n/// Serialize::stream_serialize(self.length, writer);\n/// }\n/// }\n/// ```\npub comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n let typ = s.as_type();\n let nested_struct = typ.as_data_type().unwrap();\n let params = nested_struct.definition().fields(nested_struct.generics());\n\n // Generates the generic parameter declarations (to be placed after the `impl` keyword) and the `where` clause\n // for the `Serialize` trait.\n let generics_declarations = get_generics_declarations(s);\n let where_serialize_clause = get_where_trait_clause(s, quote { Serialize });\n\n let params_len_quote = get_params_len_quote(params);\n\n let function_body = params\n .map(|field: StructField| {\n let name = field.name();\n quote {\n $crate::serialization::Serialize::stream_serialize(self.$name, writer);\n }\n })\n .join(quote {});\n\n quote {\n impl$generics_declarations $crate::serialization::Serialize for $typ\n $where_serialize_clause\n {\n let N: u32 = $params_len_quote;\n\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: $crate::writer::Writer<Self::N> = $crate::writer::Writer::new();\n $crate::serialization::Serialize::stream_serialize(self, &mut writer);\n writer.finish()\n }\n\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut $crate::writer::Writer<K>) {\n $function_body\n }\n }\n }\n}\n\n/// Trait for deserializing Noir types from arrays of Fields.\n///\n/// An implementation of the Deserialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait is typically used when\n/// deserializing return values from function calls in Noir. Since the same function could be called from TypeScript\n/// (TS), in which case the TS deserialization would get used, we need to have a match between the 2.\n///\n/// # Associated Constants\n/// * `N` - The length of the input Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl<let M: u32> Deserialize for str<M> {\n/// let N: u32 = M;\n///\n/// fn deserialize(fields: [Field; Self::N]) -> Self {\n/// let mut reader = Reader::new(fields);\n/// let result = Self::stream_deserialize(&mut reader);\n/// reader.finish();\n/// result\n/// }\n///\n/// fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n/// let mut bytes = [0 as u8; M];\n/// for i in 0..M {\n/// bytes[i] = reader.read() as u8;\n/// }\n/// str::<M>::from(bytes)\n/// }\n/// }\n/// ```\n#[derive_via(derive_deserialize)]\npub trait Deserialize {\n let N: u32;\n\n fn deserialize(fields: [Field; Self::N]) -> Self;\n\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self;\n}\n\n/// Generates a `Deserialize` trait implementation for a given struct `s`.\n///\n/// # Arguments\n/// * `s` - The struct type definition to generate the implementation for\n///\n/// # Returns\n/// A `Quoted` block containing the generated trait implementation\n///\n/// # Requirements\n/// Each struct member type must implement the `Deserialize` trait (it gets used in the generated code).\n///\n/// # Example\n/// For a struct like:\n/// ```\n/// struct MyStruct {\n/// x: AztecAddress,\n/// y: Field,\n/// }\n/// ```\n///\n/// This generates:\n/// ```\n/// impl Deserialize for MyStruct {\n/// let N: u32 = <AztecAddress as Deserialize>::N + <Field as Deserialize>::N;\n///\n/// fn deserialize(fields: [Field; Self::N]) -> Self {\n/// let mut reader = Reader::new(fields);\n/// let result = Self::stream_deserialize(&mut reader);\n/// reader.finish();\n/// result\n/// }\n///\n/// #[inline_always]\n/// fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n/// let x = <AztecAddress as Deserialize>::stream_deserialize(reader);\n/// let y = <Field as Deserialize>::stream_deserialize(reader);\n/// Self { x, y }\n/// }\n/// }\n/// ```\npub comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n let typ = s.as_type();\n let nested_struct = typ.as_data_type().unwrap();\n let params = nested_struct.definition().fields(nested_struct.generics());\n\n // Generates the generic parameter declarations (to be placed after the `impl` keyword) and the `where` clause\n // for the `Deserialize` trait.\n let generics_declarations = get_generics_declarations(s);\n let where_deserialize_clause = get_where_trait_clause(s, quote { Deserialize });\n\n // The following will give us:\n // <type_of_struct_member_1 as Deserialize>::N + <type_of_struct_member_2 as Deserialize>::N + ...\n // (or 0 if the struct has no members)\n let right_hand_side_of_definition_of_n = if params.len() > 0 {\n params\n .map(|field: StructField| {\n let param_type = field.typ();\n quote {\n <$param_type as $crate::serialization::Deserialize>::N\n }\n })\n .join(quote {+})\n } else {\n quote { 0 }\n };\n\n // For structs containing a single member, we can enhance performance by directly deserializing the input array,\n // bypassing the need for loop-based array construction. While this optimization yields significant benefits in\n // Brillig where the loops are expected to not be optimized, it is not relevant in ACIR where the loops are\n // expected to be optimized away.\n let function_body = if params.len() > 1 {\n // This generates deserialization code for each struct member and concatenates them together.\n let deserialization_of_struct_members = params\n .map(|field: StructField| {\n let param_name = field.name();\n let param_type = field.typ();\n quote {\n let $param_name = <$param_type as Deserialize>::stream_deserialize(reader);\n }\n })\n .join(quote {});\n\n // We join the struct member names with a comma to be used in the `Self { ... }` syntax\n // This will give us e.g. `a, b, c` for a struct with three fields named `a`, `b`, and `c`.\n let struct_members = params\n .map(|field: StructField| {\n let param_name = field.name();\n quote { $param_name }\n })\n .join(quote {,});\n\n quote {\n $deserialization_of_struct_members\n\n Self { $struct_members }\n }\n } else if params.len() == 1 {\n let param_name = params[0].name();\n quote {\n Self { $param_name: $crate::serialization::Deserialize::stream_deserialize(reader) }\n }\n } else {\n quote {\n Self {}\n }\n };\n\n quote {\n impl$generics_declarations $crate::serialization::Deserialize for $typ\n $where_deserialize_clause\n {\n let N: u32 = $right_hand_side_of_definition_of_n;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = $crate::reader::Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut $crate::reader::Reader<K>) -> Self {\n $function_body\n }\n }\n }\n}\n\n/// Generates a quoted expression that computes the total serialized length of function parameters.\n///\n/// # Parameters\n/// * `params` - The struct fields to serialize. Each field's type needs to implement the Serialize trait.\n///\n/// # Returns\n/// A quoted expression that evaluates to:\n/// * `0` if there are no parameters\n/// * `(<type1 as Serialize>::N + <type2 as Serialize>::N + ...)` for one or more parameters\ncomptime fn get_params_len_quote(params: [StructField]) -> Quoted {\n if params.len() == 0 {\n quote { 0 }\n } else {\n let params_quote_without_parentheses = params\n .map(|field: StructField| {\n let param_type = field.typ();\n quote {\n <$param_type as $crate::serialization::Serialize>::N\n }\n })\n .join(quote {+});\n quote { ($params_quote_without_parentheses) }\n }\n}\n\ncomptime fn get_generics_declarations(s: TypeDefinition) -> Quoted {\n let generics = s.generics();\n\n if generics.len() > 0 {\n let generics_declarations_items = generics\n .map(|generic| {\n let name = generic.typ();\n let maybe_integer_typ = generic.numeric_type();\n // numeric_type is Some only when the generic is numeric.\n if maybe_integer_typ.is_some() {\n // The generic is numeric, so we return a quote defined as e.g. \"let N: u32\"\n let integer_type = maybe_integer_typ.unwrap();\n quote {let $name: $integer_type}\n } else {\n // The generic is not numeric, so we return a quote containing the name of the generic (e.g. \"T\")\n quote { $name }\n }\n })\n .join(quote {,});\n quote {<$generics_declarations_items>}\n } else {\n // The struct doesn't have any generics defined, so we just return an empty quote.\n quote {}\n }\n}\n\ncomptime fn get_where_trait_clause(s: TypeDefinition, trait_name: Quoted) -> Quoted {\n let generics = s.generics();\n\n // numeric_type is Some only when the generic is numeric.\n let non_numeric_generics = generics.filter(|generic| generic.numeric_type().is_none());\n\n if non_numeric_generics.len() > 0 {\n let non_numeric_generics_declarations = non_numeric_generics\n .map(|generic| {\n let name = generic.typ();\n quote {$name: $trait_name}\n })\n .join(quote {,});\n quote {where $non_numeric_generics_declarations}\n } else {\n // There are no non-numeric generics, so we return an empty quote.\n quote {}\n }\n}\n"
|
|
1378
1416
|
},
|
|
1379
|
-
"
|
|
1417
|
+
"446": {
|
|
1380
1418
|
"function_locations": [
|
|
1381
1419
|
{
|
|
1382
1420
|
"name": "<impl Serialize for bool>::serialize",
|
|
@@ -1687,10 +1725,10 @@
|
|
|
1687
1725
|
"start": 21246
|
|
1688
1726
|
}
|
|
1689
1727
|
],
|
|
1690
|
-
"path": "/
|
|
1728
|
+
"path": "/mnt/user-data/nicov/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0-rc.6/noir-projects/fnd/noir-protocol-circuits/crates/serde/src/type_impls.nr",
|
|
1691
1729
|
"source": "use crate::{reader::Reader, serialization::{Deserialize, Serialize}, writer::Writer};\nuse std::embedded_curve_ops::EmbeddedCurvePoint;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize for bool {\n let N: u32 = BOOL_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for bool {\n let N: u32 = BOOL_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> bool {\n reader.read() != 0\n }\n}\n\nimpl Serialize for u8 {\n let N: u32 = U8_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u8 {\n let N: u32 = U8_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u8\n }\n}\n\nimpl Serialize for u16 {\n let N: u32 = U16_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u16 {\n let N: u32 = U16_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u16\n }\n}\n\nimpl Serialize for u32 {\n let N: u32 = U32_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u32 {\n let N: u32 = U32_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u32\n }\n}\n\nimpl Serialize for u64 {\n let N: u32 = U64_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u64 {\n let N: u32 = U64_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u64\n }\n}\n\nimpl Serialize for u128 {\n let N: u32 = U128_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u128 {\n let N: u32 = U128_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u128\n }\n}\n\nimpl Serialize for Field {\n let N: u32 = FIELD_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self);\n }\n}\n\nimpl Deserialize for Field {\n let N: u32 = FIELD_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read()\n }\n}\n\nimpl Serialize for i8 {\n let N: u32 = I8_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as u8 as Field);\n }\n}\n\nimpl Deserialize for i8 {\n let N: u32 = I8_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u8 as i8\n }\n}\n\nimpl Serialize for i16 {\n let N: u32 = I16_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as u16 as Field);\n }\n}\n\nimpl Deserialize for i16 {\n let N: u32 = I16_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u16 as i16\n }\n}\n\nimpl Serialize for i32 {\n let N: u32 = I32_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as u32 as Field);\n }\n}\n\nimpl Deserialize for i32 {\n let N: u32 = I32_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u32 as i32\n }\n}\n\nimpl Serialize for i64 {\n let N: u32 = I64_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as u64 as Field);\n }\n}\n\nimpl Deserialize for i64 {\n let N: u32 = I64_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u64 as i64\n }\n}\n\nimpl<T, let M: u32> Serialize for [T; M]\nwhere\n T: Serialize,\n{\n let N: u32 = <T as Serialize>::N * M;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n for i in 0..M {\n self[i].stream_serialize(writer);\n }\n }\n}\n\nimpl<T, let M: u32> Deserialize for [T; M]\nwhere\n T: Deserialize,\n{\n let N: u32 = <T as Deserialize>::N * M;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n let mut result: [T; M] = std::mem::zeroed();\n for i in 0..M {\n result[i] = T::stream_deserialize(reader);\n }\n result\n }\n}\n\nimpl<T> Serialize for Option<T>\nwhere\n T: Serialize,\n{\n let N: u32 = <T as Serialize>::N + 1;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write_bool(self.is_some());\n if self.is_some() {\n self.unwrap_unchecked().stream_serialize(writer);\n } else {\n writer.advance_offset(<T as Serialize>::N);\n }\n }\n}\n\nimpl<T> Deserialize for Option<T>\nwhere\n T: Deserialize,\n{\n let N: u32 = <T as Deserialize>::N + 1;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n if reader.read_bool() {\n Option::some(<T as Deserialize>::stream_deserialize(reader))\n } else {\n reader.advance_offset(<T as Deserialize>::N);\n Option::none()\n }\n }\n}\n\nglobal SCALAR_SIZE: u32 = 2;\n\nimpl Serialize for EmbeddedCurveScalar {\n\n let N: u32 = SCALAR_SIZE;\n\n fn serialize(self) -> [Field; SCALAR_SIZE] {\n [self.lo, self.hi]\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self.lo);\n writer.write(self.hi);\n }\n}\n\nimpl Deserialize for EmbeddedCurveScalar {\n let N: u32 = SCALAR_SIZE;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n Self { lo: fields[0], hi: fields[1] }\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n Self { lo: reader.read(), hi: reader.read() }\n }\n}\n\nglobal POINT_SIZE: u32 = 2;\n\nimpl Serialize for EmbeddedCurvePoint {\n let N: u32 = POINT_SIZE;\n\n fn serialize(self) -> [Field; Self::N] {\n [self.x, self.y]\n }\n\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self.x);\n writer.write(self.y);\n }\n}\n\nimpl Deserialize for EmbeddedCurvePoint {\n let N: u32 = POINT_SIZE;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n Self { x: fields[0], y: fields[1] }\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n Self { x: reader.read(), y: reader.read() }\n }\n}\n\nimpl<let M: u32> Deserialize for str<M> {\n let N: u32 = M;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n let u8_arr = <[u8; Self::N] as Deserialize>::stream_deserialize(reader);\n str::<Self::N>::from(u8_arr)\n }\n}\n\nimpl<let M: u32> Serialize for str<M> {\n let N: u32 = M;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n self.as_bytes().stream_serialize(writer);\n }\n}\n\n// Note: Not deriving this because it's not supported to call derive_serialize on a \"remote\" struct (and it will never\n// be supported).\nimpl<T, let M: u32> Deserialize for BoundedVec<T, M>\nwhere\n T: Deserialize,\n{\n let N: u32 = <T as Deserialize>::N * M + 1;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n let mut new_bounded_vec: BoundedVec<T, M> = BoundedVec::new();\n let payload_len = Self::N - 1;\n\n // Length is stored in the last field as we need to match intrinsic Noir serialization and the `len` struct\n // field is after `storage` struct field (see `bounded_vec.nr` in noir-stdlib)\n let len = reader.peek_offset(payload_len) as u32;\n\n for i in 0..M {\n if i < len {\n new_bounded_vec.push(<T as Deserialize>::stream_deserialize(reader));\n }\n }\n\n // +1 for the length of the BoundedVec\n reader.advance_offset((M - len) * <T as Deserialize>::N + 1);\n\n new_bounded_vec\n }\n}\n\n// This may cause issues if used as program input, because noir disallows empty arrays for program input.\n// I think this is okay because I don't foresee a unit type being used as input. But leaving this comment as a hint\n// if someone does run into this in the future.\nimpl Deserialize for () {\n let N: u32 = 0;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(_reader: &mut Reader<K>) -> Self {\n ()\n }\n}\n\n// Note: Not deriving this because it's not supported to call derive_serialize on a \"remote\" struct (and it will never\n// be supported).\nimpl<T, let M: u32> Serialize for BoundedVec<T, M>\nwhere\n T: Serialize,\n{\n let N: u32 = <T as Serialize>::N * M + 1; // +1 for the length of the BoundedVec\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n self.storage().stream_serialize(writer);\n // Length is stored in the last field as we need to match intrinsic Noir serialization and the `len` struct\n // field is after `storage` struct field (see `bounded_vec.nr` in noir-stdlib)\n writer.write_u32(self.len() as u32);\n }\n}\n\n// Create a slice of the given length with each element made from `f(i)` where `i` is the current index\ncomptime fn make_slice<Env, T>(length: u32, f: fn[Env](u32) -> T) -> [T] {\n let mut slice = @[];\n for i in 0..length {\n slice = slice.push_back(f(i));\n }\n slice\n}\n\n// Implements Serialize and Deserialize for an arbitrary tuple type\ncomptime fn impl_serialize_for_tuple(_m: Module, length: u32) -> Quoted {\n // `T0`, `T1`, `T2`\n let type_names = make_slice(length, |i| f\"T{i}\".quoted_contents());\n\n // `result0`, `result1`, `result2`\n let result_names = make_slice(length, |i| f\"result{i}\".quoted_contents());\n\n // `T0, T1, T2`\n let field_generics = type_names.join(quote [,]);\n\n // `<T0 as Serialize>::N + <T1 as Serialize>::N + <T2 as Serialize>::N`\n let full_size_serialize = type_names\n .map(|type_name| quote {\n <$type_name as Serialize>::N\n })\n .join(quote [+]);\n\n // `<T0 as Deserialize>::N + <T1 as Deserialize>::N + <T2 as Deserialize>::N`\n let full_size_deserialize = type_names\n .map(|type_name| quote {\n <$type_name as Deserialize>::N\n })\n .join(quote [+]);\n\n // `T0: Serialize, T1: Serialize, T2: Serialize,`\n let serialize_constraints = type_names\n .map(|field_name| quote {\n $field_name: Serialize,\n })\n .join(quote []);\n\n // `T0: Deserialize, T1: Deserialize, T2: Deserialize,`\n let deserialize_constraints = type_names\n .map(|field_name| quote {\n $field_name: Deserialize,\n })\n .join(quote []);\n\n // Statements to serialize each field\n let serialized_fields = type_names\n .mapi(|i, _type_name| quote {\n $crate::serialization::Serialize::stream_serialize(self.$i, writer);\n })\n .join(quote []);\n\n // Statements to deserialize each field\n let deserialized_fields = type_names\n .mapi(|i, type_name| {\n let result_name = result_names[i];\n quote {\n let $result_name = <$type_name as $crate::serialization::Deserialize>::stream_deserialize(reader);\n }\n })\n .join(quote []);\n let deserialize_results = result_names.join(quote [,]);\n\n quote {\n impl<$field_generics> Serialize for ($field_generics) where $serialize_constraints {\n let N: u32 = $full_size_serialize;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: $crate::writer::Writer<Self::N> = $crate::writer::Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut $crate::writer::Writer<K>) {\n\n $serialized_fields\n }\n }\n\n impl<$field_generics> Deserialize for ($field_generics) where $deserialize_constraints {\n let N: u32 = $full_size_deserialize;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = $crate::reader::Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n \n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut $crate::reader::Reader<K>) -> Self {\n $deserialized_fields\n ($deserialize_results)\n }\n }\n }\n}\n\n// Keeping these manual impls. They are more efficient since they do not\n// require copying sub-arrays from any serialized arrays.\nimpl<T1> Serialize for (T1,)\nwhere\n T1: Serialize,\n{\n let N: u32 = <T1 as Serialize>::N;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: crate::writer::Writer<Self::N> = crate::writer::Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n self.0.stream_serialize(writer);\n }\n}\n\nimpl<T1> Deserialize for (T1,)\nwhere\n T1: Deserialize,\n{\n let N: u32 = <T1 as Deserialize>::N;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = crate::reader::Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n (<T1 as Deserialize>::stream_deserialize(reader),)\n }\n}\n\n#[impl_serialize_for_tuple(2)]\n#[impl_serialize_for_tuple(3)]\n#[impl_serialize_for_tuple(4)]\n#[impl_serialize_for_tuple(5)]\n#[impl_serialize_for_tuple(6)]\nmod impls {\n use crate::serialization::{Deserialize, Serialize};\n}\n\n#[test]\nunconstrained fn bounded_vec_serialization() {\n // Test empty BoundedVec\n let empty_vec: BoundedVec<Field, 3> = BoundedVec::from_array([]);\n let serialized = empty_vec.serialize();\n let deserialized = BoundedVec::<Field, 3>::deserialize(serialized);\n assert_eq(empty_vec, deserialized);\n assert_eq(deserialized.len(), 0);\n\n // Test partially filled BoundedVec\n let partial_vec: BoundedVec<[u32; 2], 3> = BoundedVec::from_array([[1, 2]]);\n let serialized = partial_vec.serialize();\n let deserialized = BoundedVec::<[u32; 2], 3>::deserialize(serialized);\n assert_eq(partial_vec, deserialized);\n assert_eq(deserialized.len(), 1);\n assert_eq(deserialized.get(0), [1, 2]);\n\n // Test full BoundedVec\n let full_vec: BoundedVec<[u32; 2], 3> = BoundedVec::from_array([[1, 2], [3, 4], [5, 6]]);\n let serialized = full_vec.serialize();\n let deserialized = BoundedVec::<[u32; 2], 3>::deserialize(serialized);\n assert_eq(full_vec, deserialized);\n assert_eq(deserialized.len(), 3);\n assert_eq(deserialized.get(0), [1, 2]);\n assert_eq(deserialized.get(1), [3, 4]);\n assert_eq(deserialized.get(2), [5, 6]);\n}\n"
|
|
1692
1730
|
},
|
|
1693
|
-
"
|
|
1731
|
+
"447": {
|
|
1694
1732
|
"function_locations": [
|
|
1695
1733
|
{
|
|
1696
1734
|
"name": "Writer<N>::new",
|
|
@@ -1733,7 +1771,7 @@
|
|
|
1733
1771
|
"start": 1263
|
|
1734
1772
|
}
|
|
1735
1773
|
],
|
|
1736
|
-
"path": "/
|
|
1774
|
+
"path": "/mnt/user-data/nicov/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0-rc.6/noir-projects/fnd/noir-protocol-circuits/crates/serde/src/writer.nr",
|
|
1737
1775
|
"source": "pub struct Writer<let N: u32> {\n data: [Field; N],\n offset: u32,\n}\n\nimpl<let N: u32> Writer<N> {\n pub fn new() -> Self {\n Self { data: [0; N], offset: 0 }\n }\n\n pub fn write(&mut self, value: Field) {\n self.data[self.offset] = value;\n self.offset += 1;\n }\n\n pub fn write_u32(&mut self, value: u32) {\n self.write(value as Field);\n }\n\n pub fn write_u64(&mut self, value: u64) {\n self.write(value as Field);\n }\n\n pub fn write_bool(&mut self, value: bool) {\n self.write(value as Field);\n }\n\n pub fn write_array<let K: u32>(&mut self, value: [Field; K]) {\n for i in 0..K {\n self.data[i + self.offset] = value[i];\n }\n self.offset += K;\n }\n\n pub fn write_struct<T, let K: u32>(&mut self, value: T, serialize: fn(T) -> [Field; K]) {\n self.write_array(serialize(value));\n }\n\n pub fn write_struct_array<T, let K: u32, let C: u32>(\n &mut self,\n value: [T; C],\n serialize: fn(T) -> [Field; K],\n ) {\n for i in 0..C {\n self.write_struct(value[i], serialize);\n }\n }\n\n pub fn advance_offset(&mut self, offset: u32) {\n self.offset += offset;\n }\n\n pub fn finish(self) -> [Field; N] {\n assert_eq(self.offset, self.data.len(), \"Writer did not write all data\");\n self.data\n }\n}\n"
|
|
1738
1776
|
},
|
|
1739
1777
|
"45": {
|
|
@@ -1761,7 +1799,7 @@
|
|
|
1761
1799
|
"start": 1482
|
|
1762
1800
|
}
|
|
1763
1801
|
],
|
|
1764
|
-
"path": "/
|
|
1802
|
+
"path": "/mnt/user-data/nicov/node-3/noir-projects/noir-contracts/contracts/standard/public_checks_contract/src/main.nr",
|
|
1765
1803
|
"source": "mod test;\n\nuse aztec::{macros::{aztec, AztecConfig}, messages::discovery::do_sync_state_no_op};\n\n/// The purpose of this contract is to perform a check in public without revealing what contract enqueued the public\n/// call. This can be achieved by enqueueing an `incognito` public call.\n///\n/// Note that this contract should not be grouped with protocol contracts as it is not part of the protocol. We keep\n/// it here for now as it allows us to use hardcoded address.\n#[aztec(AztecConfig::new().custom_sync_state(do_sync_state_no_op))]\npub contract PublicChecks {\n use aztec::{macros::functions::{external, view}, utils::comparison::compare};\n\n // docs:start:check_timestamp\n /// Asserts that the current timestamp satisfies the `operation` with respect\n /// to the `value.\n /// NOTE: signature is hardcoded in `aztec-nr/aztec/src/public_checks.nr`; keep in sync.\n #[external(\"public\")]\n #[view]\n fn check_timestamp(operation: u8, value: u64) {\n let lhs_field = self.context.timestamp() as Field;\n let rhs_field = value as Field;\n assert(compare(lhs_field, operation, rhs_field), \"Timestamp mismatch.\");\n }\n // docs:end:check_timestamp\n\n /// Asserts that the current block number satisfies the `operation` with respect\n /// to the `value.\n /// NOTE: signature is hardcoded in `aztec-nr/aztec/src/public_checks.nr`; keep in sync.\n #[external(\"public\")]\n #[view]\n fn check_block_number(operation: u8, value: u32) {\n assert(\n compare(\n self.context.block_number() as Field,\n operation,\n value as Field,\n ),\n \"Block number mismatch.\",\n );\n }\n}\n"
|
|
1766
1804
|
},
|
|
1767
1805
|
"6": {
|
|
@@ -2325,7 +2363,7 @@
|
|
|
2325
2363
|
"start": 34250
|
|
2326
2364
|
}
|
|
2327
2365
|
],
|
|
2328
|
-
"path": "/
|
|
2366
|
+
"path": "/mnt/user-data/nicov/node-3/noir-projects/aztec-nr/aztec/src/context/public_context.nr",
|
|
2329
2367
|
"source": "use crate::{\n context::gas::GasOpts,\n hash::{\n compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n compute_siloed_nullifier,\n },\n oracle::avm,\n};\nuse crate::protocol::{\n abis::function_selector::FunctionSelector,\n address::{AztecAddress, EthAddress},\n constants::{MAX_U32_VALUE, NULL_MSG_SENDER_CONTRACT_ADDRESS},\n traits::{Empty, FromField, Packable, Serialize, ToField},\n utils::writer::Writer,\n};\n\n/// # PublicContext\n///\n/// The **main interface** between an #[external(\"public\")] function and the Aztec blockchain.\n///\n/// An instance of the PublicContext is initialized automatically at the outset of every public function, within the\n/// #[external(\"public\")] macro, so you'll never need to consciously instantiate this yourself.\n///\n/// The instance is always named `context`, and it will always be available within the body of every\n/// #[external(\"public\")] function in your smart contract.\n///\n/// Typical usage for a smart contract developer will be to call getter methods of the PublicContext.\n///\n/// _Pushing_ data and requests to the context is mostly handled within aztec-nr's own functions, so typically a smart\n/// contract developer won't need to call any setter methods directly.\n///\n/// ## Responsibilities\n/// - Exposes contextual data to a public function:\n/// - Data relating to how this public function was called:\n/// - msg_sender, this_address\n/// - Data relating to the current blockchain state:\n/// - timestamp, block_number, chain_id, version\n/// - Gas and fee information\n/// - Provides state access:\n/// - Read/write public storage (key-value mapping)\n/// - Check existence of notes and nullifiers (Some patterns use notes & nullifiers to store public (not private)\n/// information)\n/// - Enables consumption of L1->L2 messages.\n/// - Enables calls to other public smart contract functions:\n/// - Writes data to the blockchain:\n/// - Updates to public state variables\n/// - New public logs (for events)\n/// - New L2->L1 messages\n/// - New notes & nullifiers (E.g. pushing public info to notes/nullifiers, or for completing \"partial notes\")\n///\n/// ## Key Differences from Private Execution\n///\n/// Unlike private functions -- which are executed on the user's device and which can only reference historic state --\n/// public functions are executed by a block proposer and are executed \"live\" on the _current_ tip of the chain. This\n/// means public functions can:\n/// - Read and write _current_ public state\n/// - Immediately see the effects of earlier transactions in the same block\n///\n/// Also, public functions are executed within a zkVM (the \"AVM\"), so that they can _revert_ whilst still ensuring\n/// payment to the proposer and prover. (Private functions cannot revert: they either succeed, or they cannot be\n/// included).\n///\n/// ## Optimising Public Functions\n///\n/// Using the AVM to execute public functions means they compile down to \"AVM bytecode\" instead of the ACIR that\n/// private functions (standalone circuits) compile to. Therefore the approach to optimising a public function is\n/// fundamentally different from optimising a public function.\n///\npub struct PublicContext {\n args_hash: Option<Field>,\n compute_args_hash: fn() -> Field,\n}\n\nimpl Eq for PublicContext {\n fn eq(self, other: Self) -> bool {\n (self.args_hash == other.args_hash)\n // Can't compare the function compute_args_hash\n }\n}\n\nimpl PublicContext {\n /// Creates a new PublicContext instance.\n ///\n /// Low-level function: This is called automatically by the #[external(\"public\")] macro, so you shouldn't need to\n /// be called directly by smart contract developers.\n ///\n /// # Arguments\n /// * `compute_args_hash` - Function to compute the args_hash\n ///\n /// # Returns\n /// * A new PublicContext instance\n ///\n pub fn new(compute_args_hash: fn() -> Field) -> Self {\n PublicContext { args_hash: Option::none(), compute_args_hash }\n }\n\n /// Emits a _public_ log that will be visible onchain to everyone.\n ///\n /// # Arguments\n /// * `tag` - A tag placed at `fields[0]` of the emitted log. Nodes index logs by this value, allowing\n /// clients to efficiently query for matching logs without scanning all of them.\n /// * `log` - The data to log, must implement Serialize trait.\n ///\n /// ## Safety\n ///\n /// The `tag` should be domain-separated (e.g. via [`crate::protocol::hash::compute_log_tag`]) to prevent\n /// collisions between logs from different sources. Without domain separation, two unrelated log types that\n /// happen to share a raw tag value become indistinguishable. Prefer `self.emit(event)` for events, which\n /// handles tagging automatically.\n pub fn emit_public_log_unsafe<T>(_self: Self, tag: Field, log: T)\n where\n T: Serialize,\n {\n // We use a Writer to serialize the log directly after the tag, avoiding an extra O(n) copy that would\n // result from serializing first and then prepending the tag.\n let mut writer: Writer<1 + <T as Serialize>::N> = Writer::new();\n writer.write(tag);\n Serialize::stream_serialize(log, &mut writer);\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { avm::emit_public_log(writer.finish().as_vector()) };\n }\n\n /// Checks if a given note hash exists in the note hash tree at a particular leaf_index.\n ///\n /// # Arguments\n /// * `note_hash` - The note hash to check for existence\n /// * `leaf_index` - The index where the note hash should be located\n ///\n /// # Returns\n /// * `bool` - True if the note hash exists at the specified index\n ///\n pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: u64) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n avm::note_hash_exists(note_hash, leaf_index)\n }\n }\n\n /// Checks if a specific L1-to-L2 message exists in the L1-to-L2 message tree at a particular leaf index.\n ///\n /// Common use cases include token bridging, cross-chain governance, and triggering L2 actions based on L1 events.\n ///\n /// This function should be called before attempting to consume an L1-to-L2 message.\n ///\n /// # Arguments\n /// * `msg_hash` - Hash of the L1-to-L2 message to check\n /// * `msg_leaf_index` - The index where the message should be located\n ///\n /// # Returns\n /// * `bool` - True if the message exists at the specified index\n ///\n /// # Advanced\n /// * Uses the AVM l1_to_l2_msg_exists opcode for tree lookup\n /// * Messages are copied from L1 Inbox to L2 by block proposers\n ///\n pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself TODO(alvaro): Make l1l2msg leaf index a u64 upstream\n unsafe {\n avm::l1_to_l2_msg_exists(msg_hash, msg_leaf_index as u64)\n }\n }\n\n /// Returns `true` if an `unsiloed_nullifier` has been emitted by `contract_address`.\n ///\n /// Note that unsiloed nullifiers are not the actual values stored in the nullifier tree: they are first siloed via\n /// [`crate::hash::compute_siloed_nullifier`] with the emitting contract's address.\n ///\n /// ## Use Cases\n ///\n /// Nullifiers are typically used as a _privacy-preserving_ record of a one-time action, but they can also be used\n /// to efficiently record _public_ one-time actions as well. This is cheaper than using public storage, and has the\n /// added benefit of the nullifier being emittable from a private function.\n ///\n /// An example is to check whether a contract has been published: we emit a nullifier that is deterministic and\n /// which has a _public_ preimage.\n ///\n /// ## Public vs Private\n ///\n /// In general, one should not attempt to prove nullifier non-existence in private, as that will not consider the\n /// possibility of the nullifier having been emitted in any transaction between the anchor block and the inclusion\n /// block. Private functions instead prove existence via\n /// [`crate::context::PrivateContext::assert_nullifier_exists`]\n /// and 'prove' non-existence by _emitting_ the nullifer, which would cause the transaction to fail if the\n /// nullifier existed.\n ///\n /// This is not the case in public functions, which **do** have access to the tip of the blockchain and so can\n /// reliably prove whether a nullifier exists or not.\n ///\n /// ## Safety\n ///\n /// While it is safe to rely on this function's return value to determine if a nullifier exists or not, it is often\n /// **not** safe to infer additional information from that. In particular, it is **unsafe** to infer that the\n /// existence of a nullifier emitted from a private function implies that all other side-effects of said private\n /// execution have been completed, more concretely that any enqueued public calls have been executed.\n ///\n /// For example, if a function in contract `A` privately emits nullifier `X` and then enqueues public function `Y`,\n /// then it is **unsafe** for a contract `B` to infer that `Y` has alredy executed simply because `X` exists.\n ///\n /// This is because **all** private transaction effects are committed _before_ enqueued public functions are run\n /// (in\n /// order to not reveal detailed timing information about the transaction), so it is possible to observe a\n /// nullifier that was emitted alongside the enqueuing of a public call **before** said call has been completed.\n ///\n /// ## Cost\n ///\n /// This emits the `CHECKNULLIFIEREXISTS` opcode, which conceptually performs a merkle inclusion proof on the\n /// nullifier tree (both when the nullifier exists and when it doesn't).\n pub fn nullifier_exists_unsafe(_self: Self, unsiloed_nullifier: Field, contract_address: AztecAddress) -> bool {\n let siloed_nullifier = compute_siloed_nullifier(contract_address, unsiloed_nullifier);\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n avm::nullifier_exists(siloed_nullifier)\n }\n }\n\n /// Consumes a message sent from Ethereum (L1) to Aztec (L2) -- effectively marking it as \"read\".\n ///\n /// Use this function if you only want the message to ever be \"referred to\" once. Once consumed using this method,\n /// the message cannot be consumed again, because a nullifier is emitted. If your use case wants for the message to\n /// be read unlimited times, then you can always read any historic message from the L1-to-L2 messages tree, using\n /// the `l1_to_l2_msg_exists` method. Messages never technically get deleted from that tree.\n ///\n /// The message will first be inserted into an Aztec \"Inbox\" smart contract on L1. It will not be available for\n /// consumption immediately. Messages get copied-over from the L1 Inbox to L2 by the next Proposer in batches. So\n /// you will need to wait until the messages are copied before you can consume them.\n ///\n /// # Arguments\n /// * `content` - The message content that was sent from L1\n /// * `secret` - Secret fields used for message privacy (if needed)\n /// * `sender` - Ethereum address that sent the message\n /// * `leaf_index` - Index of the message in the L1-to-L2 message tree\n ///\n /// # Advanced\n /// * Validates message existence in the L1-to-L2 message tree\n /// * Prevents double-consumption by emitting a nullifier\n /// * Message hash is computed from all parameters + chain context\n /// * Will revert if message doesn't exist or was already consumed\n ///\n pub fn consume_l1_to_l2_message<let N: u32>(\n self: Self,\n content: Field,\n secret: [Field; N],\n sender: EthAddress,\n leaf_index: Field,\n ) {\n let secret_hash = compute_secret_hash(secret);\n let message_hash = compute_l1_to_l2_message_hash(\n sender,\n self.chain_id(),\n /*recipient=*/\n self.this_address(),\n self.version(),\n content,\n secret_hash,\n leaf_index,\n );\n let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n assert(!self.nullifier_exists_unsafe(nullifier, self.this_address()), \"L1-to-L2 message is already nullified\");\n assert(self.l1_to_l2_msg_exists(message_hash, leaf_index), \"Tried to consume nonexistent L1-to-L2 message\");\n\n self.push_nullifier_unsafe(nullifier);\n }\n\n /// Sends an \"L2 -> L1 message\" from this function (Aztec, L2) to a smart contract on Ethereum (L1). L1 contracts\n /// which are designed to send/receive messages to/from Aztec are called \"Portal Contracts\".\n ///\n /// Common use cases include withdrawals, cross-chain asset transfers, and triggering L1 actions based on L2 state\n /// changes.\n ///\n /// The message will be inserted into an Aztec \"Outbox\" contract on L1, when this transaction's block is proposed\n /// to L1. Sending the message will not result in any immediate state changes in the target portal contract. The\n /// message will need to be manually consumed from the Outbox through a separate Ethereum transaction: a user will\n /// need to call a function of the portal contract -- a function specifically designed to make a call to the Outbox\n /// to consume the message. The message will only be available for consumption once the _epoch_ proof has been\n /// submitted. Given that there are multiple Aztec blocks within an epoch, it might take some time for this epoch\n /// proof to be submitted -- especially if the block was near the start of an epoch.\n ///\n /// # Arguments\n /// * `recipient` - Ethereum address that will receive the message\n /// * `content` - Message content (32 bytes as a Field element)\n ///\n pub fn message_portal(_self: Self, recipient: EthAddress, content: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { avm::send_l2_to_l1_msg(recipient, content) };\n }\n\n /// Calls a public function on another contract.\n ///\n /// Will revert if the called function reverts or runs out of gas.\n ///\n /// # Arguments\n /// * `contract_address` - Address of the contract to call\n /// * `function_selector` - Function to call on the target contract\n /// * `args` - Arguments to pass to the function\n /// * `gas_opts` - An optional allocation of gas to the called function.\n ///\n /// # Returns\n /// * `[Field]` - Return data from the called function\n ///\n pub unconstrained fn call_public_function<let N: u32>(\n _self: Self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; N],\n gas_opts: GasOpts,\n ) -> [Field] {\n let calldata = [function_selector.to_field()].concat(args);\n\n avm::call(\n gas_opts.l2_gas.unwrap_or(MAX_U32_VALUE),\n gas_opts.da_gas.unwrap_or(MAX_U32_VALUE),\n contract_address,\n calldata,\n );\n // Use success_copy to determine whether the call succeeded\n let success = avm::success_copy();\n\n let result_data = avm::returndata_copy(0, avm::returndata_size());\n if !success {\n // Rethrow the revert data.\n avm::revert(result_data);\n }\n result_data\n }\n\n /// Makes a read-only call to a public function on another contract.\n ///\n /// This is similar to Solidity's `staticcall`. The called function cannot modify state or emit events. Any nested\n /// calls are constrained to also be staticcalls.\n ///\n /// Useful for querying data from other contracts safely.\n ///\n /// Will revert if the called function reverts or runs out of gas.\n ///\n /// # Arguments\n /// * `contract_address` - Address of the contract to call\n /// * `function_selector` - Function to call on the target contract\n /// * `args` - Array of arguments to pass to the called function\n /// * `gas_opts` - An optional allocation of gas to the called function.\n ///\n /// # Returns\n /// * `[Field]` - Return data from the called function\n ///\n pub unconstrained fn static_call_public_function<let N: u32>(\n _self: Self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; N],\n gas_opts: GasOpts,\n ) -> [Field] {\n let calldata = [function_selector.to_field()].concat(args);\n\n avm::call_static(\n gas_opts.l2_gas.unwrap_or(MAX_U32_VALUE),\n gas_opts.da_gas.unwrap_or(MAX_U32_VALUE),\n contract_address,\n calldata,\n );\n // Use success_copy to determine whether the call succeeded\n let success = avm::success_copy();\n\n let result_data = avm::returndata_copy(0, avm::returndata_size());\n if !success {\n // Rethrow the revert data.\n avm::revert(result_data);\n }\n result_data\n }\n\n /// Adds a new note hash to the Aztec blockchain's global Note Hash Tree.\n ///\n /// Notes are ordinarily constructed and emitted by _private_ functions, to ensure that both the content of the\n /// note, and the contract that emitted the note, stay private.\n ///\n /// There are however some useful patterns whereby a note needs to contain _public_ data. The ability to push a new\n /// note_hash from a _public_ function means that notes can be injected with public data immediately -- as soon as\n /// the public value is known. The slower alternative would be to submit a follow-up transaction so that a private\n /// function can inject the data. Both are possible on Aztec.\n ///\n /// Search \"Partial Note\" for a very common pattern which enables a note to be \"partially\" populated with some data\n /// in a _private_ function, and then later \"completed\" with some data in a public function.\n ///\n /// # Arguments\n /// * `note_hash` - The hash of the note to add to the tree\n ///\n /// # Advanced\n /// * The note hash will be siloed with the contract address by the protocol\n ///\n pub fn push_note_hash(_self: Self, note_hash: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { avm::emit_note_hash(note_hash) };\n }\n\n /// Creates a new [nullifier](crate::nullifier).\n ///\n /// While nullifiers are primarily intended as a _privacy-preserving_ record of a one-time action, they can also\n /// be used to efficiently record _public_ one-time actions. This function allows creating nullifiers from public\n /// contract functions, which behave just like those created from private functions.\n ///\n /// ## Safety\n ///\n /// This is a low-level function that must be used with great care to avoid subtle corruption of contract state.\n ///\n /// In particular, callers must ensure all nullifiers created by a contract are properly domain-separated, so that\n /// unrelated components don't interfere with one another (e.g. a transaction nullifier accidentally marking a\n /// variable as initialized). Note nullifiers should only be created via\n /// [`crate::context::PrivateContext::push_nullifier_for_note_hash`].\n ///\n /// ## Advanced\n ///\n /// The raw `nullifier` is not what is inserted into the Aztec state tree: it will be first siloed by contract\n /// address via [`crate::protocol::hash::compute_siloed_nullifier`] in order to prevent accidental or malicious\n /// interference of nullifiers from different contracts.\n pub fn push_nullifier_unsafe(_self: Self, nullifier: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { avm::emit_nullifier(nullifier) };\n }\n\n /// Returns the address of the current contract being executed.\n ///\n /// This is equivalent to `address(this)` in Solidity (hence the name). Use this to identify the current contract's\n /// address, commonly needed for access control or when interacting with other contracts.\n ///\n /// # Returns\n /// * `AztecAddress` - The contract address of the current function being executed.\n ///\n pub fn this_address(_self: Self) -> AztecAddress {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n avm::address()\n }\n }\n\n /// Returns the contract address that initiated this function call.\n ///\n /// This is similar to `msg.sender` in Solidity (hence the name).\n ///\n /// Important Note: If the calling function is a _private_ function, then it had the option of hiding its address\n /// when enqueuing this public function call. In such cases, this method will return `Option<AztecAddress>::none`.\n /// If the calling function is a _public_ function, it will always return an `Option<AztecAddress>::some` (i.e. a\n /// non-null value).\n ///\n /// # Returns\n /// * `Option<AztecAddress>` - The address of the smart contract that called this function (be it an app contract\n /// or a user's account contract).\n ///\n /// # Advanced\n /// * Value is provided by the AVM sender opcode\n /// * In nested calls, this is the immediate caller, not the original transaction sender\n ///\n pub fn maybe_msg_sender(_self: Self) -> Option<AztecAddress> {\n // Safety: AVM opcodes are constrained by the AVM itself\n let maybe_msg_sender = unsafe { avm::sender() };\n if maybe_msg_sender == NULL_MSG_SENDER_CONTRACT_ADDRESS {\n Option::none()\n } else {\n Option::some(maybe_msg_sender)\n }\n }\n\n /// Returns the function selector of the currently-executing function.\n ///\n /// This is similar to `msg.sig` in Solidity, returning the first 4 bytes of the function signature.\n ///\n /// # Returns\n /// * `FunctionSelector` - The 4-byte function identifier\n ///\n /// # Advanced\n /// * Extracted from the first element of calldata\n /// * Used internally for function dispatch in the AVM\n ///\n pub fn selector(_self: Self) -> FunctionSelector {\n // The selector is the first element of the calldata when calling a public function through dispatch.\n // Safety: AVM opcodes are constrained by the AVM itself.\n let raw_selector: [Field; 1] = unsafe { avm::calldata_copy(0, 1) };\n FunctionSelector::from_field(raw_selector[0])\n }\n\n /// Returns the hash of the arguments passed to the current function.\n ///\n /// Very low-level function: The #[external(\"public\")] macro uses this internally. Smart contract developers\n /// typically won't need to access this directly as arguments are automatically made available.\n ///\n /// # Returns\n /// * `Field` - Hash of the function arguments\n ///\n pub fn get_args_hash(mut self) -> Field {\n if !self.args_hash.is_some() {\n self.args_hash = Option::some((self.compute_args_hash)());\n }\n\n self.args_hash.unwrap_unchecked()\n }\n\n /// Returns the \"transaction fee\" for the current transaction. This is the final tx fee that will be deducted from\n /// the fee_payer's \"fee-juice\" balance (in the protocol's Base Rollup circuit).\n ///\n /// # Returns\n /// * `Field` - The actual, final cost of the transaction, taking into account: the actual gas used during the\n /// setup and app-logic phases, and the fixed amount of gas that's been allocated by the user for the teardown\n /// phase. I.e. effectiveL2FeePerGas * l2GasUsed + effectiveDAFeePerGas * daGasUsed\n ///\n /// This will return `0` during the \"setup\" and \"app-logic\" phases of tx execution (because the final tx fee is not\n /// known at that time). This will only return a nonzero value during the \"teardown\" phase of execution, where the\n /// final tx fee can actually be computed.\n ///\n /// Regardless of _when_ this function is called during the teardown phase, it will always return the same final tx\n /// fee value. The teardown phase does not consume a variable amount of gas: it always consumes a pre-allocated\n /// amount of gas, as specified by the user when they generate their tx.\n ///\n pub fn transaction_fee(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n avm::transaction_fee()\n }\n }\n\n /// Returns the chain ID of the current network.\n ///\n /// This is similar to `block.chainid` in Solidity. Returns the unique identifier for the blockchain network this\n /// transaction is executing on.\n ///\n /// Helps prevent cross-chain replay attacks. Useful if implementing multi-chain contract logic.\n ///\n /// # Returns\n /// * `Field` - The chain ID as a field element\n ///\n pub fn chain_id(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n avm::chain_id()\n }\n }\n\n /// Returns the Aztec protocol version that this transaction is executing under. Different versions may have\n /// different rules, opcodes, or cryptographic primitives.\n ///\n /// This is similar to how Ethereum has different EVM versions.\n ///\n /// Useful for forward/backward compatibility checks\n ///\n /// Not to be confused with contract versions; this is the protocol version.\n ///\n /// # Returns\n /// * `Field` - The protocol version as a field element\n ///\n pub fn version(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n avm::version()\n }\n }\n /// Returns the current block number.\n ///\n /// This is similar to `block.number` in Solidity.\n ///\n /// Note: the current block number is only available within a public function (as opposed to a private function).\n ///\n /// Note: the time intervals between blocks should not be relied upon as being consistent:\n /// - Timestamps of blocks fall within a range, rather than at exact regular intervals.\n /// - Slots can be missed.\n /// - Protocol upgrades can completely change the intervals between blocks (and indeed the current roadmap plans to\n /// reduce the time between blocks, eventually). Use `context.timestamp()` for more-reliable time-based logic.\n ///\n /// # Returns\n /// * `u32` - The current block number\n ///\n pub fn block_number(_self: Self) -> u32 {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n avm::block_number()\n }\n }\n\n /// Returns the timestamp of the current block.\n ///\n /// This is similar to `block.timestamp` in Solidity.\n ///\n /// All functions of all transactions in a block share the exact same timestamp (even though technically each\n /// transaction is executed one-after-the-other).\n ///\n /// Important note: Timestamps of Aztec blocks are not at reliably-fixed intervals. The proposer of the block has\n /// some flexibility to choose a timestamp which is in a valid _range_: Obviously the timestamp of this block must\n /// be strictly greater than that of the previous block, and must must be less than the timestamp of whichever\n /// ethereum block the aztec block is proposed to. Furthermore, if the timestamp is not deemed close enough to the\n /// actual current time, the committee of validators will not attest to the block.\n ///\n /// # Returns\n /// * `u64` - Unix timestamp in seconds\n ///\n pub fn timestamp(_self: Self) -> u64 {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n avm::timestamp()\n }\n }\n\n /// Returns the fee per unit of L2 gas for this transaction (aka the \"L2 gas price\"), as chosen by the user.\n ///\n /// L2 gas covers the cost of executing public functions and handling side-effects within the AVM.\n ///\n /// # Returns\n /// * `u128` - Fee per unit of L2 gas\n ///\n /// Wallet developers should be mindful that the choice of gas price (which is publicly visible) can leak\n /// information about the user, e.g.:\n /// - which wallet software the user is using;\n /// - the amount of time which has elapsed from the time the user's wallet chose a gas price (at the going rate),\n /// to the time of tx submission. This can give clues about the proving time, and hence the nature of the tx.\n /// - the urgency of the transaction (which is kind of unavoidable, if the tx is indeed urgent).\n /// - the wealth of the user.\n /// - the exact user (if the gas price is explicitly chosen by the user to be some unique number like 0.123456789,\n /// or their favorite number). Wallet devs might wish to consider fuzzing the choice of gas price.\n ///\n pub fn min_fee_per_l2_gas(_self: Self) -> u128 {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n avm::min_fee_per_l2_gas()\n }\n }\n\n /// Returns the fee per unit of DA (Data Availability) gas (aka the \"DA gas price\").\n ///\n /// DA gas covers the cost of making transaction data available on L1.\n ///\n /// See the warning in `min_fee_per_l2_gas` for how gas prices can be leaky.\n ///\n /// # Returns\n /// * `u128` - Fee per unit of DA gas\n ///\n pub fn min_fee_per_da_gas(_self: Self) -> u128 {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n avm::min_fee_per_da_gas()\n }\n }\n\n /// Returns the remaining L2 gas available for this transaction.\n ///\n /// Different AVM opcodes consume different amounts of gas.\n ///\n /// # Returns\n /// * `u32` - Remaining L2 gas units\n ///\n pub fn l2_gas_left(_self: Self) -> u32 {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n avm::l2_gas_left()\n }\n }\n\n /// Returns the remaining DA (Data Availability) gas available for this transaction.\n ///\n /// DA gas is consumed when emitting data that needs to be made available on L1, such as public logs or state\n /// updates. All of the side-effects from the private part of the tx also consume DA gas before execution of any\n /// public functions even begins.\n ///\n /// # Returns\n /// * `u32` - Remaining DA gas units\n ///\n pub fn da_gas_left(_self: Self) -> u32 {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n avm::da_gas_left()\n }\n }\n\n /// Checks if the current execution is within a staticcall context, where no state changes or logs are allowed to\n /// be emitted (by this function or any nested function calls).\n ///\n /// # Returns\n /// * `bool` - True if in staticcall context, false otherwise\n ///\n pub fn is_static_call(_self: Self) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n avm::is_static_call()\n }\n }\n\n /// Reads raw field values from public storage. Reads N consecutive storage slots starting from the given slot.\n ///\n /// Very low-level function. Users should typically use the public state variable abstractions to perform reads:\n /// PublicMutable & PublicImmutable.\n ///\n /// # Arguments\n /// * `storage_slot` - The starting storage slot to read from\n ///\n /// # Returns\n /// * `[Field; N]` - Array of N field values from consecutive storage slots\n ///\n /// # Generic Parameters\n /// * `N` - the number of consecutive slots to return, starting from the `storage_slot`.\n ///\n pub fn raw_storage_read<let N: u32>(self: Self, storage_slot: Field) -> [Field; N] {\n let mut out = [0; N];\n for i in 0..N {\n // Safety: AVM opcodes are constrained by the AVM itself\n out[i] = unsafe { avm::storage_read(storage_slot + i as Field, self.this_address().to_field()) };\n }\n out\n }\n\n /// Reads a typed value from public storage.\n ///\n /// Low-level function. Users should typically use the public state variable abstractions to perform reads:\n /// PublicMutable & PublicImmutable.\n ///\n /// # Arguments\n /// * `storage_slot` - The storage slot to read from\n ///\n /// # Returns\n /// * `T` - The deserialized value from storage\n ///\n /// # Generic Parameters\n /// * `T` - The type that the caller expects to read from the `storage_slot`.\n ///\n pub fn storage_read<T>(self, storage_slot: Field) -> T\n where\n T: Packable,\n {\n T::unpack(self.raw_storage_read(storage_slot))\n }\n\n /// Writes raw field values to public storage. Writes to N consecutive storage slots starting from the given slot.\n ///\n /// Very low-level function. Users should typically use the public state variable abstractions to perform writes:\n /// PublicMutable & PublicImmutable.\n ///\n /// Public storage writes take effect immediately.\n ///\n /// # Arguments\n /// * `storage_slot` - The starting storage slot to write to\n /// * `values` - Array of N Fields to write to storage\n ///\n pub fn raw_storage_write<let N: u32>(_self: Self, storage_slot: Field, values: [Field; N]) {\n for i in 0..N {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { avm::storage_write(storage_slot + i as Field, values[i]) };\n }\n }\n\n /// Writes a typed value to public storage.\n ///\n /// Low-level function. Users should typically use the public state variable abstractions to perform writes:\n /// PublicMutable & PublicImmutable.\n ///\n /// # Arguments\n /// * `storage_slot` - The storage slot to write to\n /// * `value` - The typed value to write to storage\n ///\n /// # Generic Parameters\n /// * `T` - The type to write to storage.\n ///\n pub fn storage_write<T>(self, storage_slot: Field, value: T)\n where\n T: Packable,\n {\n self.raw_storage_write(storage_slot, value.pack());\n }\n}\n\nimpl Empty for PublicContext {\n fn empty() -> Self {\n PublicContext::new(|| 0)\n }\n}\n"
|
|
2330
2368
|
},
|
|
2331
2369
|
"74": {
|
|
@@ -2379,7 +2417,7 @@
|
|
|
2379
2417
|
"start": 2891
|
|
2380
2418
|
}
|
|
2381
2419
|
],
|
|
2382
|
-
"path": "/
|
|
2420
|
+
"path": "/mnt/user-data/nicov/node-3/noir-projects/aztec-nr/aztec/src/context/utility_context.nr",
|
|
2383
2421
|
"source": "use crate::oracle::{execution::{get_utility_context, UtilityContextData}, storage::storage_read};\nuse crate::protocol::{\n abis::block_header::BlockHeader, address::AztecAddress, constants::NULL_MSG_SENDER_CONTRACT_ADDRESS,\n traits::Packable,\n};\n\n// If you'll modify this struct don't forget to update utility_context.ts as well.\npub struct UtilityContext {\n block_header: BlockHeader,\n contract_address: AztecAddress,\n msg_sender: AztecAddress,\n}\n\nimpl From<UtilityContextData> for UtilityContext {\n fn from(data: UtilityContextData) -> Self {\n Self { block_header: data.block_header, contract_address: data.contract_address, msg_sender: data.msg_sender }\n }\n}\n\nimpl UtilityContext {\n pub unconstrained fn new() -> Self {\n get_utility_context()\n }\n\n pub unconstrained fn at(contract_address: AztecAddress) -> Self {\n // We get a context with default contract address, and then we construct the final context with the provided\n // contract address.\n let default_context = get_utility_context();\n\n Self { block_header: default_context.block_header, contract_address, msg_sender: default_context.msg_sender }\n }\n\n pub fn block_header(self) -> BlockHeader {\n self.block_header\n }\n\n pub fn block_number(self) -> u32 {\n self.block_header.block_number()\n }\n\n pub fn timestamp(self) -> u64 {\n self.block_header.timestamp()\n }\n\n pub fn this_address(self) -> AztecAddress {\n self.contract_address\n }\n\n /// Returns the address that initiated this utility call.\n ///\n /// This is similar to `msg.sender` in Solidity (hence the name). A utility function called by another contract\n /// (via a nested utility call) sees that contract's address. A utility function invoked directly (e.g. by a wallet\n /// or dApp) has no caller and sees `Option::none`.\n ///\n /// Important Note: utility functions are simulated client-side and never proven, so this value is whatever the\n /// simulator (PXE) set it to: nothing about it is verified onchain. It exists to assist simulation in a\n /// cooperative environment and must not be relied on as a security guarantee.\n pub unconstrained fn maybe_msg_sender(self) -> Option<AztecAddress> {\n if self.msg_sender == NULL_MSG_SENDER_CONTRACT_ADDRESS {\n Option::none()\n } else {\n Option::some(self.msg_sender)\n }\n }\n\n pub fn version(self) -> Field {\n self.block_header.version()\n }\n\n pub fn chain_id(self) -> Field {\n self.block_header.chain_id()\n }\n\n pub unconstrained fn raw_storage_read<let N: u32>(self: Self, storage_slot: Field) -> [Field; N] {\n storage_read(self.block_header, self.this_address(), storage_slot)\n }\n\n pub unconstrained fn storage_read<T>(self, storage_slot: Field) -> T\n where\n T: Packable,\n {\n T::unpack(self.raw_storage_read(storage_slot))\n }\n}\n"
|
|
2384
2422
|
},
|
|
2385
2423
|
"76": {
|
|
@@ -2405,7 +2443,7 @@
|
|
|
2405
2443
|
"start": 6480
|
|
2406
2444
|
}
|
|
2407
2445
|
],
|
|
2408
|
-
"path": "/
|
|
2446
|
+
"path": "/mnt/user-data/nicov/node-3/noir-projects/aztec-nr/aztec/src/contract_self/contract_self_public.nr",
|
|
2409
2447
|
"source": "//! The `self` contract value for public execution contexts.\n\nuse crate::{\n context::{calls::{PublicCall, PublicStaticCall}, PublicContext},\n event::{event_emission::emit_event_in_public, event_interface::EventInterface},\n};\nuse crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Core interface for interacting with aztec-nr contract features in public execution contexts.\n///\n/// This struct is automatically injected into every [`external`](crate::macros::functions::external) and\n/// [`internal`](crate::macros::functions::internal) contract function marked with `\"public\"` by the Aztec macro\n/// system and is accessible through the `self` variable.\n///\n/// ## Type Parameters\n///\n/// - `Storage`: The contract's storage struct (defined with [`storage`](crate::macros::storage::storage), or `()` if\n/// the contract has no storage\n/// - `CallSelf`: Macro-generated type for calling contract's own non-view functions\n/// - `CallSelfStatic`: Macro-generated type for calling contract's own view functions\n/// - `CallInternal`: Macro-generated type for calling internal functions\npub struct ContractSelfPublic<Storage, CallSelf, CallSelfStatic, CallInternal> {\n /// The address of this contract\n pub address: AztecAddress,\n\n /// The contract's storage instance, representing the struct to which the\n /// [`storage`](crate::macros::storage::storage) macro was applied in your contract. If the contract has no\n /// storage, the type of this will be `()`.\n ///\n /// This storage instance is specialized for the current execution context (public) and\n /// provides access to the contract's state variables.\n ///\n /// ## Developer Note\n ///\n /// If you've arrived here while trying to access your contract's storage while the `Storage` generic type is set\n /// to unit type `()`, it means you haven't yet defined a Storage struct using the\n /// [`storage`](crate::macros::storage::storage) macro in your contract. For guidance on setting this up, please\n /// refer to our docs: https://docs.aztec.network/developers/docs/guides/smart_contracts/storage\n pub storage: Storage,\n\n /// The public execution context.\n pub context: PublicContext,\n\n /// Provides type-safe methods for calling this contract's own non-view functions.\n ///\n /// Example API:\n /// ```noir\n /// self.call_self.some_public_function(args)\n /// ```\n pub call_self: CallSelf,\n\n /// Provides type-safe methods for calling this contract's own view functions.\n ///\n /// Example API:\n /// ```noir\n /// self.call_self_static.some_view_function(args)\n /// ```\n pub call_self_static: CallSelfStatic,\n\n /// Provides type-safe methods for calling internal functions.\n ///\n /// Example API:\n /// ```noir\n /// self.internal.some_internal_function(args)\n /// ```\n pub internal: CallInternal,\n}\n\nimpl<Storage, CallSelf, CallSelfStatic, CallInternal> ContractSelfPublic<Storage, CallSelf, CallSelfStatic, CallInternal> {\n /// Creates a new `ContractSelfPublic` instance for a public function.\n ///\n /// This constructor is called automatically by the macro system and should not be called directly.\n pub fn new(\n context: PublicContext,\n storage: Storage,\n call_self: CallSelf,\n call_self_static: CallSelfStatic,\n internal: CallInternal,\n ) -> Self {\n Self { context, storage, address: context.this_address(), call_self, call_self_static, internal }\n }\n\n /// The address of the contract address that made this function call.\n ///\n /// This is similar to Solidity's `msg.sender` value.\n ///\n /// ## Incognito Calls\n ///\n /// Contracts can call public functions from private ones hiding their identity (see\n ///\n /// [`ContractSelfPrivate::enqueue_incognito`](crate::contract_self::ContractSelfPrivate::enqueue_incognito)).\n /// This function reverts when executed in such a context.\n ///\n /// If you need to handle these cases, use [`PublicContext::maybe_msg_sender`].\n pub fn msg_sender(self: Self) -> AztecAddress {\n self.context.maybe_msg_sender().unwrap()\n }\n\n /// Emits an event publicly.\n ///\n /// Public events are emitted as plaintext and are therefore visible to everyone. This is is the same as Solidity\n /// events on EVM chains.\n ///\n /// Unlike private events, they don't require delivery of an event message.\n ///\n /// # Example\n /// ```noir\n /// #[event]\n /// struct Update { value: Field }\n ///\n /// #[external(\"public\")]\n /// fn publish_update(value: Field) {\n /// self.emit(Update { value });\n /// }\n /// ```\n ///\n /// # Cost\n ///\n /// Public event emission is achieved by emitting public transaction logs. A total of `N+1` fields are emitted,\n /// where `N` is the serialization length of the event.\n pub unconstrained fn emit<Event>(&mut self, event: Event)\n where\n Event: EventInterface + Serialize,\n {\n emit_event_in_public(self.context, event);\n }\n\n /// Makes a public contract call.\n ///\n /// Will revert if the called function reverts or runs out of gas.\n ///\n /// # Arguments\n /// * `call` - The object representing the public function to invoke.\n ///\n /// # Returns\n /// * `T` - Whatever data the called function has returned.\n ///\n /// # Example\n /// ```noir\n /// self.call(Token::at(address).transfer_in_public(recipient, amount));\n /// ```\n ///\n pub unconstrained fn call<let M: u32, let N: u32, T>(self, call: PublicCall<M, N, T>) -> T\n where\n T: Deserialize,\n {\n call.call(self.context)\n }\n\n /// Makes a public read-only contract call.\n ///\n /// This is similar to Solidity's `staticcall`. The called function cannot modify state or emit events. Any nested\n /// calls are constrained to also be static calls.\n ///\n /// Will revert if the called function reverts or runs out of gas.\n ///\n /// # Arguments\n /// * `call` - The object representing the read-only public function to invoke.\n ///\n /// # Returns\n /// * `T` - Whatever data the called function has returned.\n ///\n /// # Example\n /// ```noir\n /// self.view(Token::at(address).balance_of_public(recipient));\n /// ```\n ///\n pub unconstrained fn view<let M: u32, let N: u32, T>(self, call: PublicStaticCall<M, N, T>) -> T\n where\n T: Deserialize,\n {\n call.view(self.context)\n }\n}\n"
|
|
2410
2448
|
},
|
|
2411
2449
|
"79": {
|
|
@@ -2455,86 +2493,102 @@
|
|
|
2455
2493
|
"start": 3259
|
|
2456
2494
|
}
|
|
2457
2495
|
],
|
|
2458
|
-
"path": "/
|
|
2496
|
+
"path": "/mnt/user-data/nicov/node-3/noir-projects/aztec-nr/aztec/src/ephemeral/mod.nr",
|
|
2459
2497
|
"source": "use crate::oracle::ephemeral_oracles;\nuse crate::protocol::traits::{Deserialize, Serialize};\nuse crate::protocol::utils::{reader::Reader, writer::Writer};\nuse crate::unconstrained_array::{ArrayOracles, UnconstrainedArray};\n\n/// A dynamically sized array that exists only during a single contract call frame.\n///\n/// Ephemeral arrays are backed by in-memory storage on the PXE side rather than a persistent database. Each contract\n/// call frame gets its own isolated slot space of ephemeral arrays. Child simulations cannot see the parent's\n/// ephemeral arrays, and vice versa.\n///\n/// Each logical array operation (push, pop, get, etc.) is a single oracle call, making ephemeral arrays significantly\n/// cheaper than capsule arrays.\n///\n/// ## Use Cases\n///\n/// Ephemeral arrays are designed for passing data between PXE (TypeScript) and contracts (Noir) during simulation,\n/// for example, note validation requests or event validation responses. This data type is appropriate for data that\n/// is not supposed to be persisted.\n///\n/// For data that needs to persist across simulations, contract calls, etc, use\n/// [`CapsuleArray`](crate::capsules::CapsuleArray) instead.\n///\n/// For data that must be shared across all frames of the same contract (private and utility) within one top-level PXE\n/// call (transaction simulation or utility call) but not persisted, use\n/// [`TransientArray`](crate::transient::TransientArray).\npub type EphemeralArray<T> = UnconstrainedArray<T, EphemeralOracles>;\n\npub struct EphemeralOracles {}\n\nimpl ArrayOracles for EphemeralOracles {\n unconstrained fn len_oracle(slot: Field) -> u32 {\n ephemeral_oracles::len_oracle(slot)\n }\n\n unconstrained fn push_oracle<let N: u32>(slot: Field, values: [Field; N]) -> u32 {\n ephemeral_oracles::push_oracle(slot, values)\n }\n\n unconstrained fn pop_oracle<let N: u32>(slot: Field) -> [Field; N] {\n ephemeral_oracles::pop_oracle(slot)\n }\n\n unconstrained fn get_oracle<let N: u32>(slot: Field, index: u32) -> [Field; N] {\n ephemeral_oracles::get_oracle(slot, index)\n }\n\n unconstrained fn set_oracle<let N: u32>(slot: Field, index: u32, values: [Field; N]) {\n ephemeral_oracles::set_oracle(slot, index, values)\n }\n\n unconstrained fn remove_oracle(slot: Field, index: u32) {\n ephemeral_oracles::remove_oracle(slot, index)\n }\n\n unconstrained fn clear_oracle(slot: Field) {\n ephemeral_oracles::clear_oracle(slot)\n }\n}\n\n/// Serializes an `EphemeralArray` as its slot, allowing oracle function signatures to use ephemeral array types\n/// instead of opaque `Field` slots.\nimpl<T> Serialize for UnconstrainedArray<T, EphemeralOracles> {\n let N: u32 = 1;\n\n fn serialize(self) -> [Field; Self::N] {\n [self.slot]\n }\n\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self.slot);\n }\n}\n\n/// Deserializes a single Field into an `EphemeralArray` handle, treating the field value as the slot identifier.\nimpl<T> Deserialize for UnconstrainedArray<T, EphemeralOracles> {\n let N: u32 = 1;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n Self { slot: fields[0] }\n }\n\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n Self { slot: reader.read() }\n }\n}\n\n#[crate::unconstrained_array::test_suite::unconstrained_array_tests(quote { crate::ephemeral::EphemeralOracles })]\nmod test {}\n"
|
|
2460
2498
|
},
|
|
2461
2499
|
"85": {
|
|
2462
2500
|
"function_locations": [
|
|
2463
2501
|
{
|
|
2464
2502
|
"name": "record_retractable_fact",
|
|
2465
|
-
"start":
|
|
2503
|
+
"start": 2698
|
|
2466
2504
|
},
|
|
2467
2505
|
{
|
|
2468
2506
|
"name": "record_non_retractable_fact",
|
|
2469
|
-
"start":
|
|
2507
|
+
"start": 3331
|
|
2470
2508
|
},
|
|
2471
2509
|
{
|
|
2472
2510
|
"name": "delete_fact_collection",
|
|
2473
|
-
"start":
|
|
2511
|
+
"start": 3965
|
|
2474
2512
|
},
|
|
2475
2513
|
{
|
|
2476
2514
|
"name": "get_fact_collection",
|
|
2477
|
-
"start":
|
|
2515
|
+
"start": 4340
|
|
2478
2516
|
},
|
|
2479
2517
|
{
|
|
2480
2518
|
"name": "get_fact_collections_by_type",
|
|
2481
|
-
"start":
|
|
2519
|
+
"start": 4730
|
|
2482
2520
|
},
|
|
2483
2521
|
{
|
|
2484
2522
|
"name": "test::setup",
|
|
2485
|
-
"start":
|
|
2523
|
+
"start": 5508
|
|
2486
2524
|
},
|
|
2487
2525
|
{
|
|
2488
2526
|
"name": "test::assert_payload",
|
|
2489
|
-
"start":
|
|
2527
|
+
"start": 5720
|
|
2490
2528
|
},
|
|
2491
2529
|
{
|
|
2492
2530
|
"name": "test::record_fact",
|
|
2493
|
-
"start":
|
|
2531
|
+
"start": 5958
|
|
2494
2532
|
},
|
|
2495
2533
|
{
|
|
2496
2534
|
"name": "test::records_and_reads_a_fact",
|
|
2497
|
-
"start":
|
|
2535
|
+
"start": 6247
|
|
2536
|
+
},
|
|
2537
|
+
{
|
|
2538
|
+
"name": "test::records_and_reads_a_public_fact",
|
|
2539
|
+
"start": 7130
|
|
2540
|
+
},
|
|
2541
|
+
{
|
|
2542
|
+
"name": "test::reading_the_public_scope_excludes_account_facts",
|
|
2543
|
+
"start": 8055
|
|
2544
|
+
},
|
|
2545
|
+
{
|
|
2546
|
+
"name": "test::deleting_an_account_collection_keeps_the_public_collection",
|
|
2547
|
+
"start": 8731
|
|
2498
2548
|
},
|
|
2499
2549
|
{
|
|
2500
2550
|
"name": "test::reads_collections_by_type",
|
|
2501
|
-
"start":
|
|
2551
|
+
"start": 9513
|
|
2502
2552
|
},
|
|
2503
2553
|
{
|
|
2504
2554
|
"name": "test::records_a_retractable_fact_finalized_at_latest_block",
|
|
2505
|
-
"start":
|
|
2555
|
+
"start": 10263
|
|
2506
2556
|
},
|
|
2507
2557
|
{
|
|
2508
2558
|
"name": "test::retractable_fact_above_proven_tip_is_pending",
|
|
2509
|
-
"start":
|
|
2559
|
+
"start": 11519
|
|
2510
2560
|
},
|
|
2511
2561
|
{
|
|
2512
2562
|
"name": "test::deletes_a_fact_collection",
|
|
2513
|
-
"start":
|
|
2563
|
+
"start": 12416
|
|
2514
2564
|
},
|
|
2515
2565
|
{
|
|
2516
2566
|
"name": "test::reading_unknown_collection_returns_none",
|
|
2517
|
-
"start":
|
|
2567
|
+
"start": 12922
|
|
2518
2568
|
},
|
|
2519
2569
|
{
|
|
2520
2570
|
"name": "test::cannot_record_for_other_contract",
|
|
2521
|
-
"start":
|
|
2571
|
+
"start": 13331
|
|
2572
|
+
},
|
|
2573
|
+
{
|
|
2574
|
+
"name": "test::cannot_record_for_an_account_outside_the_allowed_scopes",
|
|
2575
|
+
"start": 13700
|
|
2522
2576
|
},
|
|
2523
2577
|
{
|
|
2524
2578
|
"name": "test::re_recording_an_identical_fact_is_a_no_op",
|
|
2525
|
-
"start":
|
|
2579
|
+
"start": 14041
|
|
2526
2580
|
},
|
|
2527
2581
|
{
|
|
2528
2582
|
"name": "test::deleting_a_non_existing_collection_is_a_no_op",
|
|
2529
|
-
"start":
|
|
2583
|
+
"start": 14537
|
|
2530
2584
|
},
|
|
2531
2585
|
{
|
|
2532
2586
|
"name": "test::recording_a_fact_after_delete_recreates_the_collection",
|
|
2533
|
-
"start":
|
|
2587
|
+
"start": 14969
|
|
2534
2588
|
}
|
|
2535
2589
|
],
|
|
2536
|
-
"path": "/
|
|
2537
|
-
"source": "//! Per-contract storage of immutable facts grouped into collections.\n//!\n//! A fact is a contract-defined, typed, immutable datum. Facts are grouped into collections identified by a\n//! `(collection type, collection id)` tuple.\n//!\n//! They are stored in PXE's FactStore, which automatically deals with reorgs by removing any facts\n//! associated with blocks that have been pruned.\nuse crate::ephemeral::EphemeralArray;\nuse crate::oracle::block_reference::BlockReference;\nuse crate::oracle::fact_store::{\n delete_fact_collection_oracle, get_fact_collection_oracle, get_fact_collections_by_type_oracle, record_fact_oracle,\n};\nuse crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\nmod origin_state;\npub use origin_state::OriginBlockState;\n\n/// A retractable fact's origin block.\n#[derive(Deserialize, Eq, Serialize)]\npub struct RetractableFactOrigin {\n pub block_number: u32,\n pub block_hash: Field,\n pub block_state: OriginBlockState,\n}\n\n/// A single immutable fact in a collection.\n#[derive(Deserialize, Serialize)]\npub struct Fact {\n /// A user-defined identifier for fact kinds. Typically used to determine how to deserialize `payload`.\n pub fact_type_id: Field,\n pub payload: EphemeralArray<Field>,\n /// The block the fact is associated to, if any. A fact with an origin block is said to be a 'retractable' fact,\n /// and will be automatically deleted if its origin block gets pruned in a reorg. Typically used by facts\n /// associated with a transaction (e.g. 'processed entry X using data from tx Y in block Z').\n pub origin_block: Option<RetractableFactOrigin>,\n}\n\n/// A fact collection as returned by the store.\n#[derive(Deserialize, Serialize)]\npub struct FactCollection {\n pub contract_address: AztecAddress,\n pub scope: AztecAddress,\n /// The collection's type. A single contract may have facts in collections of different types (e.g. one for the\n /// processing offchain messages, another for partial notes, etc.).\n pub fact_collection_type_id: Field,\n /// The collection's unique identifier among the other collections of this type in this contract and scope.\n pub fact_collection_id: Field,\n pub facts: EphemeralArray<Fact>,\n}\n\n/// Records a retractable fact into a collection: PXE prunes it if `origin_block` is reorg'd away. Re-recording an\n/// identical fact is a no-op.\npub unconstrained fn record_retractable_fact(\n contract_address: AztecAddress,\n scope: AztecAddress,\n fact_collection_type_id: Field,\n fact_collection_id: Field,\n fact_type_id: Field,\n payload: EphemeralArray<Field>,\n origin_block: BlockReference,\n) {\n record_fact_oracle(\n contract_address,\n scope,\n fact_collection_type_id,\n fact_collection_id,\n fact_type_id,\n payload,\n Option::some(origin_block),\n );\n}\n\n/// Records a non-retractable fact into a collection: it survives reorgs and will persist until the fact collection\n/// itself is deleted. Re-recording an identical fact is a no-op.\npub unconstrained fn record_non_retractable_fact(\n contract_address: AztecAddress,\n scope: AztecAddress,\n fact_collection_type_id: Field,\n fact_collection_id: Field,\n fact_type_id: Field,\n payload: EphemeralArray<Field>,\n) {\n record_fact_oracle(\n contract_address,\n scope,\n fact_collection_type_id,\n fact_collection_id,\n fact_type_id,\n payload,\n Option::none(),\n );\n}\n\n/// Deletes a fact collection, removing all its facts from PXE storage.\n///\n/// Collections must be eventually deleted to reclaim storage and to stop reprocessing past the lifespan of the\n/// workflows they enable.\n///\n/// A no-op if no such collection exists.\npub unconstrained fn delete_fact_collection(\n contract_address: AztecAddress,\n scope: AztecAddress,\n fact_collection_type_id: Field,\n fact_collection_id: Field,\n) {\n delete_fact_collection_oracle(\n contract_address,\n scope,\n fact_collection_type_id,\n fact_collection_id,\n );\n}\n\n/// Fetches a fact collection.\npub unconstrained fn get_fact_collection(\n contract_address: AztecAddress,\n scope: AztecAddress,\n fact_collection_type_id: Field,\n fact_collection_id: Field,\n) -> Option<FactCollection> {\n get_fact_collection_oracle(\n contract_address,\n scope,\n fact_collection_type_id,\n fact_collection_id,\n )\n}\n\n/// Returns every fact collection of `fact_collection_type_id`.\npub unconstrained fn get_fact_collections_by_type(\n contract_address: AztecAddress,\n scope: AztecAddress,\n fact_collection_type_id: Field,\n) -> EphemeralArray<FactCollection> {\n get_fact_collections_by_type_oracle(contract_address, scope, fact_collection_type_id)\n}\n\nmod test {\n use crate::ephemeral::EphemeralArray;\n use crate::facts::{\n delete_fact_collection, get_fact_collection, get_fact_collections_by_type, record_non_retractable_fact,\n record_retractable_fact,\n };\n use crate::oracle::block_reference::BlockReference;\n use crate::protocol::address::AztecAddress;\n use crate::protocol::traits::{FromField, ToField};\n use crate::test::helpers::test_environment::TestEnvironment;\n\n global TYPE_ID: Field = 42;\n global COLLECTION_ID: Field = 7;\n global FACT_TYPE_ID: Field = 99;\n global PAYLOAD: [Field; 3] = [123, 456, 789];\n\n unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n let mut env = TestEnvironment::new();\n let scope = env.create_light_account();\n (env, scope)\n }\n\n unconstrained fn assert_payload(payload: EphemeralArray<Field>) {\n assert_eq(payload.len(), PAYLOAD.len());\n for i in 0..PAYLOAD.len() {\n assert_eq(payload.get(i), PAYLOAD[i]);\n }\n }\n\n unconstrained fn record_fact(contract_address: AztecAddress, scope: AztecAddress) {\n record_non_retractable_fact(\n contract_address,\n scope,\n TYPE_ID,\n COLLECTION_ID,\n FACT_TYPE_ID,\n EphemeralArray::from_array(PAYLOAD),\n );\n }\n\n #[test]\n unconstrained fn records_and_reads_a_fact() {\n let (env, scope) = setup();\n env.private_context(|context| {\n let contract_address = context.this_address();\n record_fact(contract_address, scope);\n\n let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n assert_eq(collection.contract_address, contract_address);\n assert_eq(collection.scope, scope);\n assert_eq(collection.fact_collection_type_id, TYPE_ID);\n assert_eq(collection.fact_collection_id, COLLECTION_ID);\n assert_eq(collection.facts.len(), 1);\n\n let fact = collection.facts.get(0);\n assert_eq(fact.fact_type_id, FACT_TYPE_ID);\n assert_payload(fact.payload);\n assert(fact.origin_block.is_none());\n });\n }\n\n #[test]\n unconstrained fn reads_collections_by_type() {\n let (env, scope) = setup();\n env.private_context(|context| {\n let contract_address = context.this_address();\n record_fact(contract_address, scope);\n\n let collections = get_fact_collections_by_type(contract_address, scope, TYPE_ID);\n assert_eq(collections.len(), 1);\n\n let collection = collections.get(0);\n assert_eq(collection.fact_collection_id, COLLECTION_ID);\n assert_eq(collection.facts.len(), 1);\n\n let fact = collection.facts.get(0);\n assert_eq(fact.fact_type_id, FACT_TYPE_ID);\n assert_payload(fact.payload);\n });\n }\n\n #[test]\n unconstrained fn records_a_retractable_fact_finalized_at_latest_block() {\n let (env, scope) = setup();\n let origin_block_number = env.last_block_number();\n env.private_context(|context| {\n let contract_address = context.this_address();\n record_retractable_fact(\n contract_address,\n scope,\n TYPE_ID,\n COLLECTION_ID,\n FACT_TYPE_ID,\n EphemeralArray::from_array(PAYLOAD),\n BlockReference { block_number: origin_block_number, block_hash: 0xabc },\n );\n\n let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n assert_eq(collection.facts.len(), 1);\n\n let fact = collection.facts.get(0);\n assert_eq(fact.fact_type_id, FACT_TYPE_ID);\n assert_payload(fact.payload);\n\n let origin = fact.origin_block.unwrap();\n assert_eq(origin.block_number, origin_block_number);\n assert_eq(origin.block_hash, 0xabc);\n // TXE finalizes every mined block, so an origin at the latest block is Finalized.\n assert(origin.block_state.is_finalized());\n });\n }\n\n #[test]\n unconstrained fn retractable_fact_above_proven_tip_is_pending() {\n let (env, scope) = setup();\n let future_block_number = env.last_block_number() + 100;\n env.private_context(|context| {\n let contract_address = context.this_address();\n record_retractable_fact(\n contract_address,\n scope,\n TYPE_ID,\n COLLECTION_ID,\n FACT_TYPE_ID,\n EphemeralArray::from_array(PAYLOAD),\n BlockReference { block_number: future_block_number, block_hash: 0xabc },\n );\n\n let origin = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID)\n .unwrap()\n .facts\n .get(0)\n .origin_block\n .unwrap();\n assert(origin.block_state.is_pending());\n });\n }\n\n #[test]\n unconstrained fn deletes_a_fact_collection() {\n let (env, scope) = setup();\n env.private_context(|context| {\n let contract_address = context.this_address();\n record_fact(contract_address, scope);\n delete_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n\n let collections = get_fact_collections_by_type(contract_address, scope, TYPE_ID);\n assert_eq(collections.len(), 0);\n });\n }\n\n #[test]\n unconstrained fn reading_unknown_collection_returns_none() {\n let (env, scope) = setup();\n env.private_context(|context| {\n let contract_address = context.this_address();\n let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n assert(collection.is_none());\n });\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_record_for_other_contract() {\n let (env, scope) = setup();\n env.private_context(|context| {\n let other = AztecAddress::from_field(context.this_address().to_field() + 1);\n record_fact(other, scope);\n });\n }\n\n #[test]\n unconstrained fn re_recording_an_identical_fact_is_a_no_op() {\n let (env, scope) = setup();\n env.private_context(|context| {\n let contract_address = context.this_address();\n record_fact(contract_address, scope);\n record_fact(contract_address, scope);\n\n let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n assert_eq(collection.facts.len(), 1);\n });\n }\n\n #[test]\n unconstrained fn deleting_a_non_existing_collection_is_a_no_op() {\n let (env, scope) = setup();\n env.private_context(|context| {\n let contract_address = context.this_address();\n delete_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n\n assert(get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).is_none());\n });\n }\n\n #[test]\n unconstrained fn recording_a_fact_after_delete_recreates_the_collection() {\n let (env, scope) = setup();\n env.private_context(|context| {\n let contract_address = context.this_address();\n\n record_fact(contract_address, scope);\n let collection_before_delete =\n get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n assert_eq(collection_before_delete.facts.len(), 1);\n\n delete_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n assert(get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).is_none());\n\n record_fact(contract_address, scope);\n let collection_after_recreate =\n get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n assert_eq(collection_after_recreate.facts.len(), 1);\n });\n }\n}\n"
|
|
2590
|
+
"path": "/mnt/user-data/nicov/node-3/noir-projects/aztec-nr/aztec/src/facts/mod.nr",
|
|
2591
|
+
"source": "//! Per-contract storage of immutable facts grouped into collections.\n//!\n//! A fact is a contract-defined, typed, immutable datum. Facts are grouped into collections identified by a\n//! `(collection type, collection id)` tuple, within a [`FactScope`].\n//!\n//! They are stored in PXE's FactStore, which automatically deals with reorgs by removing any facts\n//! associated with blocks that have been pruned.\nuse crate::ephemeral::EphemeralArray;\nuse crate::oracle::block_reference::BlockReference;\nuse crate::oracle::fact_store::{\n delete_fact_collection_oracle, get_fact_collection_oracle, get_fact_collections_by_type_oracle, record_fact_oracle,\n};\nuse crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\nmod origin_state;\nmod scope;\npub use origin_state::OriginBlockState;\npub use scope::FactScope;\n\n/// A retractable fact's origin block.\n#[derive(Deserialize, Eq, Serialize)]\npub struct RetractableFactOrigin {\n pub block_number: u32,\n pub block_hash: Field,\n pub block_state: OriginBlockState,\n}\n\n/// A single immutable fact in a collection.\n#[derive(Deserialize, Serialize)]\npub struct Fact {\n /// A user-defined identifier for fact kinds. Typically used to determine how to deserialize `payload`.\n pub fact_type_id: Field,\n pub payload: EphemeralArray<Field>,\n /// The block the fact is associated to, if any. A fact with an origin block is said to be a 'retractable' fact,\n /// and will be automatically deleted if its origin block gets pruned in a reorg. Typically used by facts\n /// associated with a transaction (e.g. 'processed entry X using data from tx Y in block Z').\n pub origin_block: Option<RetractableFactOrigin>,\n}\n\n/// A fact collection as returned by the store.\n#[derive(Deserialize, Serialize)]\npub struct FactCollection {\n pub contract_address: AztecAddress,\n pub scope: FactScope,\n /// The collection's type. A single contract may have facts in collections of different types (e.g. one for the\n /// processing offchain messages, another for partial notes, etc.).\n pub fact_collection_type_id: Field,\n /// The collection's unique identifier among the other collections of this type in this contract and scope.\n pub fact_collection_id: Field,\n pub facts: EphemeralArray<Fact>,\n}\n\n/// Records a retractable fact into a collection: PXE prunes it if `origin_block` is reorg'd away. Re-recording an\n/// identical fact is a no-op.\npub unconstrained fn record_retractable_fact(\n contract_address: AztecAddress,\n scope: FactScope,\n fact_collection_type_id: Field,\n fact_collection_id: Field,\n fact_type_id: Field,\n payload: EphemeralArray<Field>,\n origin_block: BlockReference,\n) {\n record_fact_oracle(\n contract_address,\n scope,\n fact_collection_type_id,\n fact_collection_id,\n fact_type_id,\n payload,\n Option::some(origin_block),\n );\n}\n\n/// Records a non-retractable fact into a collection: it survives reorgs and will persist until the fact collection\n/// itself is deleted. Re-recording an identical fact is a no-op.\npub unconstrained fn record_non_retractable_fact(\n contract_address: AztecAddress,\n scope: FactScope,\n fact_collection_type_id: Field,\n fact_collection_id: Field,\n fact_type_id: Field,\n payload: EphemeralArray<Field>,\n) {\n record_fact_oracle(\n contract_address,\n scope,\n fact_collection_type_id,\n fact_collection_id,\n fact_type_id,\n payload,\n Option::none(),\n );\n}\n\n/// Deletes a fact collection, removing all its facts from PXE storage.\n///\n/// Collections must be eventually deleted to reclaim storage and to stop reprocessing past the lifespan of the\n/// workflows they enable.\n///\n/// A no-op if no such collection exists.\npub unconstrained fn delete_fact_collection(\n contract_address: AztecAddress,\n scope: FactScope,\n fact_collection_type_id: Field,\n fact_collection_id: Field,\n) {\n delete_fact_collection_oracle(\n contract_address,\n scope,\n fact_collection_type_id,\n fact_collection_id,\n );\n}\n\n/// Fetches a fact collection.\npub unconstrained fn get_fact_collection(\n contract_address: AztecAddress,\n scope: FactScope,\n fact_collection_type_id: Field,\n fact_collection_id: Field,\n) -> Option<FactCollection> {\n get_fact_collection_oracle(\n contract_address,\n scope,\n fact_collection_type_id,\n fact_collection_id,\n )\n}\n\n/// Returns every fact collection of `fact_collection_type_id`.\npub unconstrained fn get_fact_collections_by_type(\n contract_address: AztecAddress,\n scope: FactScope,\n fact_collection_type_id: Field,\n) -> EphemeralArray<FactCollection> {\n get_fact_collections_by_type_oracle(contract_address, scope, fact_collection_type_id)\n}\n\nmod test {\n use crate::ephemeral::EphemeralArray;\n use crate::facts::{\n delete_fact_collection, FactScope, get_fact_collection, get_fact_collections_by_type,\n record_non_retractable_fact, record_retractable_fact,\n };\n use crate::oracle::block_reference::BlockReference;\n use crate::protocol::address::AztecAddress;\n use crate::protocol::traits::{FromField, ToField};\n use crate::test::helpers::test_environment::TestEnvironment;\n\n global TYPE_ID: Field = 42;\n global COLLECTION_ID: Field = 7;\n global FACT_TYPE_ID: Field = 99;\n global PAYLOAD: [Field; 3] = [123, 456, 789];\n\n unconstrained fn setup() -> (TestEnvironment, FactScope) {\n let mut env = TestEnvironment::new();\n let scope = FactScope::account(env.create_light_account());\n (env, scope)\n }\n\n unconstrained fn assert_payload(payload: EphemeralArray<Field>) {\n assert_eq(payload.len(), PAYLOAD.len());\n for i in 0..PAYLOAD.len() {\n assert_eq(payload.get(i), PAYLOAD[i]);\n }\n }\n\n unconstrained fn record_fact(contract_address: AztecAddress, scope: FactScope) {\n record_non_retractable_fact(\n contract_address,\n scope,\n TYPE_ID,\n COLLECTION_ID,\n FACT_TYPE_ID,\n EphemeralArray::from_array(PAYLOAD),\n );\n }\n\n #[test]\n unconstrained fn records_and_reads_a_fact() {\n let (env, scope) = setup();\n env.private_context(|context| {\n let contract_address = context.this_address();\n record_fact(contract_address, scope);\n\n let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n assert_eq(collection.contract_address, contract_address);\n assert_eq(collection.scope, scope);\n assert_eq(collection.fact_collection_type_id, TYPE_ID);\n assert_eq(collection.fact_collection_id, COLLECTION_ID);\n assert_eq(collection.facts.len(), 1);\n\n let fact = collection.facts.get(0);\n assert_eq(fact.fact_type_id, FACT_TYPE_ID);\n assert_payload(fact.payload);\n assert(fact.origin_block.is_none());\n });\n }\n\n #[test]\n unconstrained fn records_and_reads_a_public_fact() {\n let env = TestEnvironment::new();\n env.private_context(|context| {\n let contract_address = context.this_address();\n record_fact(contract_address, FactScope::public());\n\n let collection = get_fact_collection(\n contract_address,\n FactScope::public(),\n TYPE_ID,\n COLLECTION_ID,\n )\n .unwrap();\n assert_eq(collection.scope, FactScope::public());\n assert_eq(collection.facts.len(), 1);\n assert_payload(collection.facts.get(0).payload);\n\n let collections = get_fact_collections_by_type(contract_address, FactScope::public(), TYPE_ID);\n assert_eq(collections.len(), 1);\n assert_eq(collections.get(0).scope, FactScope::public());\n });\n }\n\n #[test]\n unconstrained fn reading_the_public_scope_excludes_account_facts() {\n let (env, scope) = setup();\n env.private_context(|context| {\n let contract_address = context.this_address();\n record_fact(contract_address, scope);\n\n assert(\n get_fact_collection(\n contract_address,\n FactScope::public(),\n TYPE_ID,\n COLLECTION_ID,\n )\n .is_none(),\n );\n assert_eq(get_fact_collections_by_type(contract_address, FactScope::public(), TYPE_ID).len(), 0);\n });\n }\n\n #[test]\n unconstrained fn deleting_an_account_collection_keeps_the_public_collection() {\n let (env, scope) = setup();\n env.private_context(|context| {\n let contract_address = context.this_address();\n record_fact(contract_address, scope);\n record_fact(contract_address, FactScope::public());\n\n delete_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n assert(get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).is_none());\n assert(\n get_fact_collection(\n contract_address,\n FactScope::public(),\n TYPE_ID,\n COLLECTION_ID,\n )\n .is_some(),\n );\n });\n }\n\n #[test]\n unconstrained fn reads_collections_by_type() {\n let (env, scope) = setup();\n env.private_context(|context| {\n let contract_address = context.this_address();\n record_fact(contract_address, scope);\n\n let collections = get_fact_collections_by_type(contract_address, scope, TYPE_ID);\n assert_eq(collections.len(), 1);\n\n let collection = collections.get(0);\n assert_eq(collection.fact_collection_id, COLLECTION_ID);\n assert_eq(collection.facts.len(), 1);\n\n let fact = collection.facts.get(0);\n assert_eq(fact.fact_type_id, FACT_TYPE_ID);\n assert_payload(fact.payload);\n });\n }\n\n #[test]\n unconstrained fn records_a_retractable_fact_finalized_at_latest_block() {\n let (env, scope) = setup();\n let origin_block_number = env.last_block_number();\n env.private_context(|context| {\n let contract_address = context.this_address();\n record_retractable_fact(\n contract_address,\n scope,\n TYPE_ID,\n COLLECTION_ID,\n FACT_TYPE_ID,\n EphemeralArray::from_array(PAYLOAD),\n BlockReference { block_number: origin_block_number, block_hash: 0xabc },\n );\n\n let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n assert_eq(collection.facts.len(), 1);\n\n let fact = collection.facts.get(0);\n assert_eq(fact.fact_type_id, FACT_TYPE_ID);\n assert_payload(fact.payload);\n\n let origin = fact.origin_block.unwrap();\n assert_eq(origin.block_number, origin_block_number);\n assert_eq(origin.block_hash, 0xabc);\n // TXE finalizes every mined block, so an origin at the latest block is Finalized.\n assert(origin.block_state.is_finalized());\n });\n }\n\n #[test]\n unconstrained fn retractable_fact_above_proven_tip_is_pending() {\n let (env, scope) = setup();\n let future_block_number = env.last_block_number() + 100;\n env.private_context(|context| {\n let contract_address = context.this_address();\n record_retractable_fact(\n contract_address,\n scope,\n TYPE_ID,\n COLLECTION_ID,\n FACT_TYPE_ID,\n EphemeralArray::from_array(PAYLOAD),\n BlockReference { block_number: future_block_number, block_hash: 0xabc },\n );\n\n let origin = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID)\n .unwrap()\n .facts\n .get(0)\n .origin_block\n .unwrap();\n assert(origin.block_state.is_pending());\n });\n }\n\n #[test]\n unconstrained fn deletes_a_fact_collection() {\n let (env, scope) = setup();\n env.private_context(|context| {\n let contract_address = context.this_address();\n record_fact(contract_address, scope);\n delete_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n\n let collections = get_fact_collections_by_type(contract_address, scope, TYPE_ID);\n assert_eq(collections.len(), 0);\n });\n }\n\n #[test]\n unconstrained fn reading_unknown_collection_returns_none() {\n let (env, scope) = setup();\n env.private_context(|context| {\n let contract_address = context.this_address();\n let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n assert(collection.is_none());\n });\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_record_for_other_contract() {\n let (env, scope) = setup();\n env.private_context(|context| {\n let other = AztecAddress::from_field(context.this_address().to_field() + 1);\n record_fact(other, scope);\n });\n }\n\n #[test(should_fail_with = \"not in the allowed scopes list\")]\n unconstrained fn cannot_record_for_an_account_outside_the_allowed_scopes() {\n let (env, _) = setup();\n env.private_context(|context| {\n let outsider = AztecAddress::from_field(context.this_address().to_field() + 1);\n record_fact(context.this_address(), FactScope::account(outsider));\n });\n }\n\n #[test]\n unconstrained fn re_recording_an_identical_fact_is_a_no_op() {\n let (env, scope) = setup();\n env.private_context(|context| {\n let contract_address = context.this_address();\n record_fact(contract_address, scope);\n record_fact(contract_address, scope);\n\n let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n assert_eq(collection.facts.len(), 1);\n });\n }\n\n #[test]\n unconstrained fn deleting_a_non_existing_collection_is_a_no_op() {\n let (env, scope) = setup();\n env.private_context(|context| {\n let contract_address = context.this_address();\n delete_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n\n assert(get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).is_none());\n });\n }\n\n #[test]\n unconstrained fn recording_a_fact_after_delete_recreates_the_collection() {\n let (env, scope) = setup();\n env.private_context(|context| {\n let contract_address = context.this_address();\n\n record_fact(contract_address, scope);\n let collection_before_delete =\n get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n assert_eq(collection_before_delete.facts.len(), 1);\n\n delete_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n assert(get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).is_none());\n\n record_fact(contract_address, scope);\n let collection_after_recreate =\n get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n assert_eq(collection_after_recreate.facts.len(), 1);\n });\n }\n}\n"
|
|
2538
2592
|
}
|
|
2539
2593
|
},
|
|
2540
2594
|
"functions": [
|
|
@@ -2583,7 +2637,7 @@
|
|
|
2583
2637
|
"abi_public",
|
|
2584
2638
|
"abi_view"
|
|
2585
2639
|
],
|
|
2586
|
-
"debug_symbols": "
|
|
2640
|
+
"debug_symbols": "rVfbbuIwEP0XnnnwjD0eu7+yqipK0woJAUphpVXFv+849QmhkiOU3RdycmKfuXhmSL5Wb93r5eNld3g/fq6efn2tXvvdfr/7eNkft5vz7ngw9mvlyg+RXWRtV1k9Zbuy3RMXYAR5A94BpAqCNxALKIwakMKkAoxhZyAaw0U4FqYszibItpidCbItZo4GzCiX7d52sZIBMpCorkm2xps/3pU1Zt2Tr4zHo0AAYASMgIlgIhgFo2ASmNFoBpMrExwBSAUlg98ADIPhkckVeA+QKggMoBXA+QDnQ4RghGCEoAYACCaYSBDMMIEoBFEIohBEIRQAqglhD1BNiGeAakJwBIIjEIGgwIRAMMJEhKDChBZBKxtJDAAmVyaW+vkGApArGJwfAJjB+QKGailgcHUAYASMQFCwPWL74GoBCkbBwNUIV3WwZTWvofgTr9f1Cq33cu67rnTepBetQ0+bvjucV0+Hy36/Xv3e7C/Dos/T5jBcz5venlqLdIc3u5rg+27fFXRd33a79lZxWetusS4dBYj9nQS1JYKLXCUCcWhKcFuCUkYMlMk1JXxbgp0VZNUw7HUUUb7TCDMamqCQJ3Fk92gcbJMKCl59M47YlvAhSJWwuSW3KOKdgv6HTKR/zcRcXakf60pjuyhoRsMTUUYuiIJrBUIz1UkuRZQWubwwFjfGkrQZy4yE/RMiHSSRRwn5kY254ozKcMOwz81sSFskMhIaxS3JxV0gkwqXx1MRCbVlbwO8REGIR4WgzWTmmdLKASPL3YqTU3pYIfA49Dg1FXimMlUyhoXaP9TtNO47nXluWBCNw4ImxS33EjNz0zuHYeHddHr/kJipTLL3KpSV4cCtUGbzGcYTUbfoRMSh0cX7RQrq0GDKcZkPOk6KvExh2qELFSL6K6Zlta2K2taclyl4+KALo0geeUixreDnBqZDFDyp6yAPjxl7QR7HzOQ0y5h5trvNdtfffTpdi1a/27zuu3r7fjlsJ0/Pf054gk+vU3/cdm+XvitKt+8ve5n8RRLWNt+ey1fYcEtrm77P12L9Lw==",
|
|
2587
2641
|
"is_unconstrained": true,
|
|
2588
2642
|
"name": "check_block_number"
|
|
2589
2643
|
},
|
|
@@ -2632,7 +2686,7 @@
|
|
|
2632
2686
|
"abi_public",
|
|
2633
2687
|
"abi_view"
|
|
2634
2688
|
],
|
|
2635
|
-
"debug_symbols": "
|
|
2689
|
+
"debug_symbols": "rVfbbuIwEP0XnnnwjD0eu79SVRWlaYWEAKWw0qri33ec+oRQyVE3uy/4+MQ+c/F4SD5Xr93L5f15d3g7fqweHj9XL/1uv9+9P++P2815dzwY+7ly5YfIBlnbKKuHbCPbnLgAI8gb8A4gVRC8gVhAYdSAFCYVYAw7A9EYLsKxMGVxNkG2xexMkG0xczRgRrls97aLlQyQgUR1TbI13vzxrqwx6558ZTweBQIAI2AETAQTwSgYBZPAjEYzmFyZ4AhAKigZ/AJgGAyPTK7Ae4BUQWAArQDOBzgfIgQjBCMENQBAMMFEgmCGCUQhiEIQhSAKoQBQTQh7gGpCPANUE4IjEByBCAQFJgSCESYiBBUmtAha2UhiADC5MrHUzxcQgFzB4PwAwAzOFzBUSwGDqwMAI2AEgoLtEdsHVwtQMAoGrka4qoMtq3kNxZ94va5XuHrP577rys2b3EW7oadN3x3Oq4fDZb9fr35t9pdh0cdpcxjG86a3p3ZFusOrjSb4ttt3BV3Xt92uvVVc1rpb7JaOAsT+ToLaEsFFrhKBODQluC1BKSMGyuSaEr4twc4KsmoY9jqKKN9phBkNTVDIkziy+2kcbJ0KCl59M47YlvAhSJWwviW3KOKdgv6HTKR/zcRcXakf60pjuyhoRsMTUUYuiIJrBUIz1UkuRZQWubwwFjfGkrQZy4xEzjhUcnRTkG/JmK9Nj2tmOKRmMqQtEjPyqRMv/iIV0zg4teJwc8chYVSIyxTS6IO9jTRzmWcKK8OH4G6lySn9WCHw2PImafiuwDN1qZLRKtT+n26HcX/PmedaBdHYKmhS2nIvMdM1vXNoFd5Ne/c3iZnCJHurQlUZDtwKZTafYTwRdYtORByuuXi/SEEdbrlyXOaDjn0iL1OIjFRGWagQ0bljWlbbqqhtzXmZgocPujCK5JGHFNsKfq5furFbTuo6yM/bzPgXaH89+a7NPNlss931dx9O16LV7zYv+65O3y6H7eTp+fcJT/DhdeqP2+710ndF6fb1Za+Sj2R9kmJ4Kt9gZRrFpvp0Ldb/AA==",
|
|
2636
2690
|
"is_unconstrained": true,
|
|
2637
2691
|
"name": "check_timestamp"
|
|
2638
2692
|
},
|
|
@@ -2763,11 +2817,11 @@
|
|
|
2763
2817
|
],
|
|
2764
2818
|
"return_type": null
|
|
2765
2819
|
},
|
|
2766
|
-
"bytecode": "H4sIAAAAAAAA/+2deWBcRR3Hk+
|
|
2820
|
+
"bytecode": "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",
|
|
2767
2821
|
"custom_attributes": [
|
|
2768
2822
|
"abi_utility"
|
|
2769
2823
|
],
|
|
2770
|
-
"debug_symbols": "
|
|
2824
|
+
"debug_symbols": "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",
|
|
2771
2825
|
"is_unconstrained": true,
|
|
2772
2826
|
"name": "offchain_receive"
|
|
2773
2827
|
},
|
|
@@ -2821,7 +2875,7 @@
|
|
|
2821
2875
|
"custom_attributes": [
|
|
2822
2876
|
"abi_public"
|
|
2823
2877
|
],
|
|
2824
|
-
"debug_symbols": "
|
|
2878
|
+
"debug_symbols": "tVnbbhs5DP0XP+dBF1KX/EpRFGnqFgGMJHCTBRZF/n3JEQ89DqBBOtu+lEd0dXgRRdHOr8O349fXH18eHr8//Tzcfvp1+Hp+OJ0efnw5Pd3fvTw8PYr21yHoP5Hi4TbeHCIHk3y4TSJLMGnrautKJvuQzdbN1j2bbItMIZmsQ5LwkEoy2YdkW7Oti62r7K8q65BN/G0qy5Dd1l3WMdwccogA4nmUkHIMAKoRkpw0GNUkjU7M5KwaVtAMkAbSFKimC2DRZGXmZqAkgGJA0zQAAXQDDZqG7V23ixsUAsDINoWRTYpkUrdkASkDVAM5AUCjDisZ1yErL6mkOlJLjUzautu6jzWHkWqOyeRINado0tZZ1pkVFAN6uLkoYANLWSnJUlfiDS+FpWaWytJdNQNolJJpbqKhoEA0pLu0rAaoAxQ95wEYoBvQrA0ATcoAul0yWjIboFHYhcjkSH1hy3Rhy30pCcAyXSo06nDWXcvZKujQdNPUkAGgidBEaFICqAYyNBkagoaKAU3yAAzQDeg1GgAmKoxWEDYQNhDqpRrACFsIAARgJhqiaIiiIYqGKFqOAGaiEQgJJgiEDBMMwgITBYQVJioIG0w0EHaY6CDsZqLjLDrOoscEYCZ6igBmoucAwAAgJAIAIcMEg7DARAFhhYkKwgYTyyUlBd1AN00M2lMNVaAYHRWg5DrtcwNpfxtIG5wh17Hr2JmLsxRn0TZnyHXNdc09hfMxdGfusBa1DRMvSFg4KNIcsz5EUT1gfUqiJo6zIr1erHuT9nLWvSkLMxdFGtHy/5JGxFWR+sxNkXo6dB2fZq0DQ66LrouuS65LrtObaagCkevIdew6LkDaBA2xow6kb4cht9bcg+bM3Zk7mEnboiEwUwyOyBGskcdGHht5bOSxETkzuTV2ZnZr7MzFrRVnrm6tOnNza82Zu1vrYOYQHAlzCQvqQNF12n8MVSDtQIYKELlOm9BA2nMG0qZjyHXVddWZm7M0Z9HWYwi6EoIjcrR4//Z2c8Bo9uXlfDzqZLaa1WSCe747Hx9fDrePr6fTzeGfu9Pr8p9+Pt89LvLl7iyfCufx8ZtIIfz+cDoqeru57A7zrZT0NVx2UyrZCeRufpQid72GC4XAtodCGjO8kNZcpxR5TiETJSgS51Ug/cO56BwYXnClqRe84UXUiXN4EVNyCrk7VxRlKxA4kUpdEeRdPuQw9WGDgogqqoJWR/qeov/FMK58uKIoH67MUjMqs9Y4PdCY5hzSaeAGx3V1p+tI4kZtUih+yeSRmnPQnEO+aeGaxx7DnGOrMgInJERwviS1vkvIVn3WBopO02u2FUpK1Qs01zwPpW0cLXl9ZSp8CeS6OGL/A9lI4X9nY6vAZMRHgcncPs1G2uDIcuU70hFlBpiGslGlMrahj0cZ1/YGEzyYdSN/f7QbHL3jZGWovVDwu3Rsl6i/J4KpTdNR5ySlI6N15cXvJGMdSGqzQLYY5EicQoblfRReoVIYfUax+b4nvrzvff44bxVoYNRFlu8O03TyVjMvCET6ep++B5n+4qN05USbP4ybJ8J+4WXGTLMTyRu1Kd6ncIkk91mB540WWhIKvHDYVeBXkawa+e+UJ0fc1Fio7qK4TH6x9LKjwlkuib/xNB/8aGv+DN5xVi888cdvGWFECJf9SWrsw5P8ZZBvUwLaaJvy8xHe5So/pl3ScF3bVLeeZZ89Ba56xXUeaOtlD8GHtrAelt5RbLzs8pXbn0PBlGahhM3xE+msYc95cMBruv468hsENeCK11R2eVD9Le67CNYdYh+Bd8vSdhV1rSjq2vsuggwP6r4QWkYOWpkTcN/TGT7L6u7+4Xz1B5o3ZTo/3H09HW35/fXxfvXpy7/P+AR/4Hk+P90fv72ej8p0+SuP/GrxSX6RuslcP+vPaLqUfGQKn9/U+n8=",
|
|
2825
2879
|
"is_unconstrained": true,
|
|
2826
2880
|
"name": "public_dispatch"
|
|
2827
2881
|
},
|
|
@@ -2849,11 +2903,11 @@
|
|
|
2849
2903
|
],
|
|
2850
2904
|
"return_type": null
|
|
2851
2905
|
},
|
|
2852
|
-
"bytecode": "H4sIAAAAAAAA/
|
|
2906
|
+
"bytecode": "H4sIAAAAAAAA/9WUS07jQBCGm8C8mWGGmeG5gR1bHkJswSESC4QECtvIOCWrpY4ddReIsKJv0HaACxAC4nECtlwCicMQKyg4RhVjWOFd99f111/l6u4Pg5NLVfOckkIbIdBXK5ILwV3LFuKIBbq5xT1XQN0E4d0U6/31sdQjzNSNSRcKmDGtjDFnD2xYn1m+p7Cum3kuwcGcPl/zEFyQp8X5uXTRZHxfpvjDQjKeZctf0I2oqcFgR+diE4SNfA/631pJR2EgmwLT15GXso225VdrnZJW455i4qfr/l74vJF7Pt+uaeilo1zW7ry3K0w3ttCvBl0+Y2KJv2edFTiIcqrsdDIw/8pA1twE3JWevir4ErjrRZ06vp+xDxCcUoUrp2QrBRItv1JtedwRsCFtR8A2SMV9z5hQ36xDxZe15XJZglId68R+Poyua6UqoG0xserycdu2sYui5AIWkQuOtVahCPv4wMaTGWJ9pMgAST6R5DNJvpDkK0m+keQ7SX6QZJAkP0nyiyRDJPlNkj8kGSbJX5L8I8l/koyQZJQkYyShp2qCJJPRMPaa6g+26nrTUo8sLmTSbBRn55Z672b1bczTM/YIlBs6uSoIAAA=",
|
|
2853
2907
|
"custom_attributes": [
|
|
2854
2908
|
"abi_utility"
|
|
2855
2909
|
],
|
|
2856
|
-
"debug_symbols": "
|
|
2910
|
+
"debug_symbols": "fZLBjoQgDIbfpWcPoKjgq2w2BhUnJAQNA5tsDO8+YETHA16g5e//pSXdYBKDe/VSz8sbup8NBiOVkq9eLSO3ctHhdQMUD1xDVxWAG+ga7wtIFb01QsSCL0sArdwIbaHTTqkC/rhye9F75Xq/LTdBRQUIPYU7AGepRIx8cblR3ooRI/iwh5ixE4FRe4PgB0hFaWKQ6uqiLKsbonxA1KhNiJrlEU+jYFSeDIwakh2F5CFtk36jpeUJaMnNX+f9FFeHnxJ8NcCo978h5aM0t63wEWUkH5Q40tnp8Uu1/2tS0latZhnF5IyIpF0L7A8=",
|
|
2857
2911
|
"is_unconstrained": true,
|
|
2858
2912
|
"name": "sync_state"
|
|
2859
2913
|
}
|
|
@@ -3076,5 +3130,5 @@
|
|
|
3076
3130
|
}
|
|
3077
3131
|
},
|
|
3078
3132
|
"transpiled": true,
|
|
3079
|
-
"aztec_version": "6.0.0-rc.
|
|
3133
|
+
"aztec_version": "6.0.0-rc.4"
|
|
3080
3134
|
}
|