Merge f435c39 into 9b99126

Author: AztecBot

.noir-sync-commit

@@ -1 +1 @@
-3c488f4b272f460383341c51270b87bfe2b94468
+db28cb9ffb710c286b54dbfcf57292ae3dffb03d

noir-projects/aztec-nr/authwit/src/cheatcodes.nr

@@ -17,15 +17,15 @@ where
     C: CallInterface<M>,
 {
     let target = call_interface.get_contract_address();
-    let inputs = cheatcodes::get_private_context_inputs(get_block_number());
+    let inputs = unsafe { cheatcodes::get_private_context_inputs(get_block_number()) };
     let chain_id = inputs.tx_context.chain_id;
     let version = inputs.tx_context.version;
     let args_hash = hash_args(call_interface.get_args());
     let selector = call_interface.get_selector();
     let inner_hash =
         compute_inner_authwit_hash([caller.to_field(), selector.to_field(), args_hash]);
     let message_hash = compute_authwit_message_hash(target, chain_id, version, inner_hash);
-    cheatcodes::add_authwit(on_behalf_of, message_hash);
+    unsafe { cheatcodes::add_authwit(on_behalf_of, message_hash) };
 }
 
 pub unconstrained fn add_public_authwit_from_call_interface<C, let M: u32>(

noir-projects/aztec-nr/aztec/src/context/private_context.nr

@@ -494,13 +494,15 @@ impl PrivateContext {
         // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.
         // We don't validate or compute it in the circuit because a) it's harder to do with slices, and
         // b) this is only temporary.
-        let args_hash = enqueue_public_function_call_internal(
-            contract_address,
-            function_selector,
-            args_hash,
-            counter,
-            is_static_call,
-        );
+        let args_hash = unsafe {
+            enqueue_public_function_call_internal(
+                contract_address,
+                function_selector,
+                args_hash,
+                counter,
+                is_static_call,
+            )
+        };
 
         // Public calls are rerouted through the dispatch function.
         let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };
@@ -548,13 +550,15 @@ impl PrivateContext {
         // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.
         // We don't validate or compute it in the circuit because a) it's harder to do with slices, and
         // b) this is only temporary.
-        let args_hash = set_public_teardown_function_call_internal(
-            contract_address,
-            function_selector,
-            args_hash,
-            counter,
-            is_static_call,
-        );
+        let args_hash = unsafe {
+            set_public_teardown_function_call_internal(
+                contract_address,
+                function_selector,
+                args_hash,
+                counter,
+                is_static_call,
+            )
+        };
 
         let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };
 

noir-projects/aztec-nr/aztec/src/oracle/get_contract_instance.nr

@@ -59,23 +59,24 @@ pub unconstrained fn get_contract_instance_initialization_hash_internal_avm(
 }
 
 pub fn get_contract_instance_deployer_avm(address: AztecAddress) -> Option<AztecAddress> {
-    let (member, exists) = get_contract_instance_deployer_internal_avm(address);
+    let (member, exists) = unsafe { get_contract_instance_deployer_internal_avm(address) };
     if exists {
         Option::some(AztecAddress::from_field(member))
     } else {
         Option::none()
     }
 }
 pub fn get_contract_instance_class_id_avm(address: AztecAddress) -> Option<ContractClassId> {
-    let (member, exists) = get_contract_instance_class_id_internal_avm(address);
+    let (member, exists) = unsafe { get_contract_instance_class_id_internal_avm(address) };
     if exists {
         Option::some(ContractClassId::from_field(member))
     } else {
         Option::none()
     }
 }
 pub fn get_contract_instance_initialization_hash_avm(address: AztecAddress) -> Option<Field> {
-    let (member, exists) = get_contract_instance_initialization_hash_internal_avm(address);
+    let (member, exists) =
+        unsafe { get_contract_instance_initialization_hash_internal_avm(address) };
     if exists {
         Option::some(member)
     } else {

noir-projects/noir-contracts/contracts/contract_class_registerer_contract/src/main.nr

@@ -48,7 +48,7 @@ contract ContractClassRegisterer {
         // TODO: We should be able to remove public_bytecode_commitment from the input if it's calculated in this function
         // docs:start:pop_capsule
         let packed_public_bytecode: [Field; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS] =
-            pop_capsule();
+            unsafe { pop_capsule() };
         // docs:end:pop_capsule
         // First field element contains the length of the bytecode
         let bytecode_length_in_bytes: u32 = packed_public_bytecode[0] as u32;
@@ -121,7 +121,7 @@ contract ContractClassRegisterer {
         function_data: InnerPrivateFunction,
     ) {
         let private_bytecode: [Field; MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS] =
-            pop_capsule();
+            unsafe { pop_capsule() };
 
         let event = ClassPrivateFunctionBroadcasted {
             contract_class_id,
@@ -162,7 +162,7 @@ contract ContractClassRegisterer {
         function_data: InnerUnconstrainedFunction,
     ) {
         let unconstrained_bytecode: [Field; MAX_PACKED_BYTECODE_SIZE_PER_UNCONSTRAINED_FUNCTION_IN_FIELDS] =
-            pop_capsule();
+            unsafe { pop_capsule() };
         let event = ClassUnconstrainedFunctionBroadcasted {
             contract_class_id,
             artifact_metadata_hash,
@@ -203,7 +203,8 @@ contract ContractClassRegisterer {
         // cannot prove non-registration. Therefore, it is possible that a malicious oracle might prevent sequencers
         // from including transactions with calls to certain badly-broadcasted contracts.
         // TODO(#8978): review correctness
-        let log_hash = emit_contract_class_unencrypted_log_private(contract_address, log, counter);
+        let log_hash =
+            unsafe { emit_contract_class_unencrypted_log_private(contract_address, log, counter) };
 
         // 40 = addr (32) + raw log len (4) + processed log len (4)
         context.contract_class_logs_hashes.push(

noir-projects/noir-contracts/contracts/easy_private_voting_contract/src/test/utils.nr

@@ -1,21 +1,16 @@
-use dep::aztec::{
-    note::{note_getter::{MAX_NOTES_PER_PAGE, view_notes}, note_viewer_options::NoteViewerOptions},
-    prelude::AztecAddress,
-    protocol_types::storage::map::derive_storage_slot_in_map,
-    test::helpers::test_environment::TestEnvironment,
-};
+use dep::aztec::{prelude::AztecAddress, test::helpers::test_environment::TestEnvironment};
 
 use crate::EasyPrivateVoting;
 
 pub fn setup() -> (&mut TestEnvironment, AztecAddress, AztecAddress) {
-    let mut env = TestEnvironment::new();
+    let mut env = unsafe { TestEnvironment::new() };
 
-    let admin = env.create_account();
+    let admin = unsafe { env.create_account() };
 
     let initializer_call_interface = EasyPrivateVoting::interface().constructor(admin);
-    let voting_contract = env.deploy_self("EasyPrivateVoting").with_public_void_initializer(
-        initializer_call_interface,
-    );
+    let voting_contract = unsafe {
+        env.deploy_self("EasyPrivateVoting").with_public_void_initializer(initializer_call_interface)
+    };
     // std::println(voting_contract);
     (&mut env, voting_contract.to_address(), admin)
 }