feat: prepare circuit output for validation

noir-projects/noir-protocol-circuits/crates/private-kernel-init-simulated/src/main.nr

@@ -2,5 +2,5 @@ use dep::private_kernel_lib::PrivateKernelInitCircuitPrivateInputs;
 use dep::types::PrivateKernelCircuitPublicInputs;
 
 unconstrained fn main(input: PrivateKernelInitCircuitPrivateInputs) -> pub PrivateKernelCircuitPublicInputs {
-    input.native_private_kernel_circuit_initial()
+    input.simulate()
 }

noir-projects/noir-protocol-circuits/crates/private-kernel-init/src/main.nr

@@ -3,5 +3,5 @@ use dep::types::PrivateKernelCircuitPublicInputs;
 
 #[recursive]
 fn main(input: PrivateKernelInitCircuitPrivateInputs) -> pub PrivateKernelCircuitPublicInputs {
-    input.native_private_kernel_circuit_initial()
+    input.execute()
 }

noir-projects/noir-protocol-circuits/crates/private-kernel-inner-simulated/src/main.nr

@@ -2,5 +2,5 @@ use dep::private_kernel_lib::PrivateKernelInnerCircuitPrivateInputs;
 use dep::types::PrivateKernelCircuitPublicInputs;
 
 unconstrained fn main(input: PrivateKernelInnerCircuitPrivateInputs) -> pub PrivateKernelCircuitPublicInputs {
-    input.native_private_kernel_circuit_inner()
+    input.simulate()
 }

noir-projects/noir-protocol-circuits/crates/private-kernel-inner/src/main.nr

@@ -3,5 +3,5 @@ use dep::types::PrivateKernelCircuitPublicInputs;
 
 #[recursive]
 fn main(input: PrivateKernelInnerCircuitPrivateInputs) -> pub PrivateKernelCircuitPublicInputs {
-    input.native_private_kernel_circuit_inner()
+    input.execute()
 }

noir-projects/noir-protocol-circuits/crates/private-kernel-lib/src/components.nr

@@ -0,0 +1 @@
+mod private_kernel_circuit_output_validator;

noir-projects/noir-protocol-circuits/crates/private-kernel-lib/src/lib.nr

@@ -1,3 +1,4 @@
+mod components;
 mod kernel_circuit_public_inputs_composer;
 mod private_call_data_validator;
 mod private_kernel_circuit_public_inputs_composer;

noir-projects/noir-protocol-circuits/crates/private-kernel-lib/src/private_call_data_validator.nr

@@ -252,6 +252,9 @@ impl PrivateCallDataValidator {
             assert_eq(
                 self.array_lengths.new_l2_to_l1_msgs, 0, "new_l2_to_l1_msgs must be empty for static calls"
             );
+            assert_eq(
+                self.array_lengths.note_encrypted_logs_hashes, 0, "note_encrypted_logs_hashes must be empty for static calls"
+            );
             assert_eq(
                 self.array_lengths.encrypted_logs_hashes, 0, "encrypted_logs_hashes must be empty for static calls"
             );

noir-projects/noir-protocol-circuits/crates/private-kernel-lib/src/private_kernel_circuit_public_inputs_composer.nr

@@ -2,8 +2,8 @@ use dep::types::{
     abis::{
     call_request::CallRequest, combined_constant_data::CombinedConstantData,
     kernel_circuit_public_inputs::{PrivateKernelCircuitPublicInputs, PrivateKernelCircuitPublicInputsBuilder},
-    max_block_number::MaxBlockNumber, nullifier::Nullifier, note_hash::ScopedNoteHash,
-    log_hash::NoteLogHash,
+    max_block_number::MaxBlockNumber, nullifier::{Nullifier, ScopedNullifier},
+    note_hash::ScopedNoteHash, log_hash::NoteLogHash,
     private_circuit_public_inputs::{PrivateCircuitPublicInputs, PrivateCircuitPublicInputsArrayLengths}
 },
     address::AztecAddress,
@@ -25,6 +25,10 @@ struct DataSource {
     public_teardown_call_request: CallRequest,
 }
 
+pub fn create_first_nullifier(tx_request: TxRequest) -> ScopedNullifier {
+    Nullifier { value: tx_request.hash(), note_hash: 0, counter: 0 }.scope(AztecAddress::zero())
+}
+
 struct PrivateKernelCircuitPublicInputsComposer {
     public_inputs: PrivateKernelCircuitPublicInputsBuilder,
 }
@@ -38,10 +42,8 @@ impl PrivateKernelCircuitPublicInputsComposer {
             tx_request.tx_context,
         );
 
-        public_inputs.min_revertible_side_effect_counter = private_call_public_inputs.min_revertible_side_effect_counter;
-
-        // Since it's the first iteration, we need to push the the tx hash nullifier into the `new_nullifiers` array
-        public_inputs.end.new_nullifiers.push(Nullifier { value: tx_request.hash(), note_hash: 0, counter: 0 }.scope(AztecAddress::zero()));
+        // Since it's the first iteration, we need to push the tx hash nullifier into the `new_nullifiers` array
+        public_inputs.end.new_nullifiers.push(create_first_nullifier(tx_request));
         // Note that we do not need to nullify the transaction request nonce anymore.
         // Should an account want to additionally use nonces for replay protection or handling cancellations,
         // they will be able to do so in the account contract logic:
@@ -97,7 +99,16 @@ impl PrivateKernelCircuitPublicInputsComposer {
             public_call_requests,
             public_teardown_call_request
         };
+        self.propagate_from_private_call(source);
+
+        *self
+    }
 
+    pub fn finish(self) -> PrivateKernelCircuitPublicInputs {
+        self.public_inputs.finish()
+    }
+
+    fn propagate_from_private_call(&mut self, source: DataSource) {
         self.propagate_max_block_number(source);
         self.propagate_note_hash_read_requests(source);
         self.propagate_nullifier_read_requests(source);
@@ -111,19 +122,15 @@ impl PrivateKernelCircuitPublicInputsComposer {
         self.propagate_public_teardown_call_request(source);
         self.propagate_fee_payer(source);
         self.propagate_min_revertible_side_effect_counter(source);
-
-        *self
-    }
-
-    pub fn finish(self) -> PrivateKernelCircuitPublicInputs {
-        self.public_inputs.finish()
     }
 
     fn propagate_min_revertible_side_effect_counter(&mut self, source: DataSource) {
-        self.public_inputs.min_revertible_side_effect_counter = if self.public_inputs.min_revertible_side_effect_counter > 0 {
-            self.public_inputs.min_revertible_side_effect_counter
+        if self.public_inputs.min_revertible_side_effect_counter != 0 {
+            assert(
+                source.private_call_public_inputs.min_revertible_side_effect_counter == 0, "cannot overwrite non-zero min_revertible_side_effect_counter"
+            );
         } else {
-            source.private_call_public_inputs.min_revertible_side_effect_counter
+            self.public_inputs.min_revertible_side_effect_counter = source.private_call_public_inputs.min_revertible_side_effect_counter;
         };
     }
 
@@ -204,6 +211,7 @@ impl PrivateKernelCircuitPublicInputsComposer {
                 self.public_inputs.end.encrypted_logs_hashes.push(log.scope(source.storage_contract_address));
             }
         }
+
         let unencrypted_logs = source.private_call_public_inputs.unencrypted_logs_hashes;
         for i in 0..unencrypted_logs.len() {
             let log = unencrypted_logs[i];
@@ -213,15 +221,13 @@ impl PrivateKernelCircuitPublicInputsComposer {
         }
 
         let note_logs = source.private_call_public_inputs.note_encrypted_logs_hashes;
+        let new_note_hashes = self.public_inputs.end.new_note_hashes;
         for i in 0..note_logs.len() {
             if !is_empty(note_logs[i]) {
                 let note_index = self.match_log_to_note(note_logs[i]);
-                assert(
-                    note_index < MAX_NEW_NOTE_HASHES_PER_TX, "Could not find note hash linked to note log."
-                );
-                assert(
-                    note_logs[i].note_hash_counter
-                    == self.public_inputs.end.new_note_hashes.get_unchecked(note_index).counter(), "Could not find note hash linked to note log."
+                assert(note_index < new_note_hashes.len(), "Could not find note hash linked to note log");
+                assert_eq(
+                    note_logs[i].note_hash_counter, new_note_hashes.get_unchecked(note_index).counter(), "Could not find note hash linked to note log"
                 );
                 self.public_inputs.end.note_encrypted_logs_hashes.push(note_logs[i]);
             }