feat: Sync from noir

.noir-sync-commit

@@ -1,2 +1 @@
-1252b5fcc7ed56bb55e95745b83be6e556805397
-
+9c99a97ca8f42bee23cf97ebd724fdc51e647c60

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

@@ -354,7 +354,7 @@ impl PrivateContext {
             |n: NoteHash| n.counter == note_hash_counter
         );
         assert(
-            note_exists_index != MAX_NEW_NOTE_HASHES_PER_CALL, "Can only emit a note log for an existing note."
+            note_exists_index as u32 != MAX_NEW_NOTE_HASHES_PER_CALL, "Can only emit a note log for an existing note."
         );
 
         let counter = self.next_counter();

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

@@ -29,15 +29,15 @@ impl PublicContext {
     * @param event_selector The event selector for the log.
     * @param message The message to emit in the log.
     */
-    pub fn emit_unencrypted_log_with_selector<T,N>(
+    pub fn emit_unencrypted_log_with_selector<T, N>(
         &mut self,
         event_selector: Field,
         log: T
     ) where T: Serialize<N> {
         emit_unencrypted_log(event_selector, Serialize::serialize(log).as_slice());
     }
     // For compatibility with the selector-less API. We'll probably rename the above one.
-    pub fn emit_unencrypted_log<T,N>(&mut self, log: T) where T: Serialize<N> {
+    pub fn emit_unencrypted_log<T, N>(&mut self, log: T) where T: Serialize<N> {
         self.emit_unencrypted_log_with_selector(/*event_selector=*/ 5, log);
     }
     pub fn note_hash_exists(self, note_hash: Field, leaf_index: Field) -> bool {
@@ -368,4 +368,4 @@ impl<N> FunctionReturns<N> {
     pub fn deserialize_into<T>(self) -> T where T: Deserialize<N> {
         Deserialize::deserialize(self.raw())
     }
-}
+}

noir-projects/aztec-nr/aztec/src/encrypted_logs.nr

@@ -1,4 +1,4 @@
 mod header;
 mod incoming_body;
 mod outgoing_body;
-mod payload;
+mod payload;

noir-projects/aztec-nr/aztec/src/encrypted_logs/payload.nr

@@ -83,7 +83,6 @@ fn compute_ivpk_app(ivpk: GrumpkinPoint, contract_address: AztecAddress) -> Grum
     // It is useless to compute this, it brings no value to derive fully.
     // Issue(#6955)
     ivpk
-
     /*
     // @todo Just setting infinite to false, but it should be checked.
     // for example user could define ivpk = infinity using the registry

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

@@ -4,7 +4,7 @@ use dep::protocol_types::{
     utils::arr_copy_slice
 };
 
-global LEAF_PREIMAGE_LENGTH: u64 = 4;
+global LEAF_PREIMAGE_LENGTH: u32 = 4;
 global PUBLIC_DATA_WITNESS: Field = 45;
 
 struct PublicDataWitness {
@@ -23,7 +23,7 @@ unconstrained pub fn get_public_data_witness(block_number: u32, leaf_slot: Field
     let fields = get_public_data_witness_oracle(block_number, leaf_slot);
     PublicDataWitness {
         index: fields[0],
-        leaf_preimage: PublicDataTreeLeafPreimage { slot: fields[1], value: fields[2], next_index: fields[3] as u64, next_slot: fields[4] },
+        leaf_preimage: PublicDataTreeLeafPreimage { slot: fields[1], value: fields[2], next_index: fields[3] as u32, next_slot: fields[4] },
         path: arr_copy_slice(fields, [0; PUBLIC_DATA_TREE_HEIGHT], 1 + LEAF_PREIMAGE_LENGTH)
     }
 }

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

@@ -136,14 +136,14 @@ unconstrained pub fn get_notes<Note, N, NB, M, S, NS>(
         status,
         placeholder_fields
     );
-    let num_notes = fields[0] as u64;
+    let num_notes = fields[0] as u32;
     let contract_address = AztecAddress::from_field(fields[1]);
     for i in 0..placeholder_opt_notes.len() {
         if i < num_notes {
             // lengths named as per typescript.
-            let return_header_length: u64 = 2; // num_notes & contract_address.
-            let extra_preimage_length: u64 = 2; // nonce & note_hash_counter.
-            let read_offset: u64 = return_header_length + i * (N + extra_preimage_length);
+            let return_header_length: u32 = 2; // num_notes & contract_address.
+            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.
+            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);
             let nonce = fields[read_offset];
             let note_hash_counter = fields[read_offset + 1] as u32;
             let header = NoteHeader { contract_address, nonce, storage_slot, note_hash_counter };

noir-projects/aztec-nr/aztec/src/state_vars/shared_mutable/scheduled_delay_change/test.nr

@@ -26,7 +26,7 @@ fn test_serde() {
 
 #[test]
 fn test_serde_large_values() {
-    let max_u32 = (1 << 32) - 1;
+    let max_u32: u64 = (1 << 32) - 1;
 
     let pre = max_u32 as u32;
     let post = (max_u32 - 1) as u32;

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

@@ -408,7 +408,7 @@ contract PendingNoteHashes {
     }
 
     #[contract_library_method]
-    fn max_notes_per_call() -> u64 {
+    fn max_notes_per_call() -> u32 {
         if MAX_NEW_NOTE_HASHES_PER_CALL > MAX_NOTE_HASH_READ_REQUESTS_PER_CALL {
             MAX_NOTE_HASH_READ_REQUESTS_PER_CALL
         } else {

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

@@ -32,30 +32,30 @@ struct KernelCircuitPublicInputsComposer {
     previous_kernel: PrivateKernelData,
     // Hints
     sorted_note_hashes: [ScopedNoteHash; MAX_NEW_NOTE_HASHES_PER_TX],
-    sorted_note_hashes_indexes: [u64; MAX_NEW_NOTE_HASHES_PER_TX],
+    sorted_note_hashes_indexes: [u32; MAX_NEW_NOTE_HASHES_PER_TX],
     sorted_nullifiers: [ScopedNullifier; MAX_NEW_NULLIFIERS_PER_TX],
-    sorted_nullifiers_indexes: [u64; MAX_NEW_NULLIFIERS_PER_TX],
+    sorted_nullifiers_indexes: [u32; MAX_NEW_NULLIFIERS_PER_TX],
     sorted_note_encrypted_log_hashes: [NoteLogHash; MAX_NOTE_ENCRYPTED_LOGS_PER_TX],
-    sorted_note_encrypted_log_hashes_indexes: [u64; MAX_NOTE_ENCRYPTED_LOGS_PER_TX],
+    sorted_note_encrypted_log_hashes_indexes: [u32; MAX_NOTE_ENCRYPTED_LOGS_PER_TX],
     sorted_encrypted_log_hashes: [ScopedEncryptedLogHash; MAX_ENCRYPTED_LOGS_PER_TX],
-    sorted_encrypted_log_hashes_indexes: [u64; MAX_ENCRYPTED_LOGS_PER_TX],
+    sorted_encrypted_log_hashes_indexes: [u32; MAX_ENCRYPTED_LOGS_PER_TX],
     sorted_unencrypted_log_hashes: [ScopedLogHash; MAX_UNENCRYPTED_LOGS_PER_TX],
-    sorted_unencrypted_log_hashes_indexes: [u64; MAX_UNENCRYPTED_LOGS_PER_TX],
+    sorted_unencrypted_log_hashes_indexes: [u32; MAX_UNENCRYPTED_LOGS_PER_TX],
 }
 
 impl KernelCircuitPublicInputsComposer {
     pub fn new(
         previous_kernel: PrivateKernelData,
         sorted_note_hashes: [ScopedNoteHash; MAX_NEW_NOTE_HASHES_PER_TX],
-        sorted_note_hashes_indexes: [u64; MAX_NEW_NOTE_HASHES_PER_TX],
+        sorted_note_hashes_indexes: [u32; MAX_NEW_NOTE_HASHES_PER_TX],
         sorted_nullifiers: [ScopedNullifier; MAX_NEW_NULLIFIERS_PER_TX],
-        sorted_nullifiers_indexes: [u64; MAX_NEW_NULLIFIERS_PER_TX],
+        sorted_nullifiers_indexes: [u32; MAX_NEW_NULLIFIERS_PER_TX],
         sorted_note_encrypted_log_hashes: [NoteLogHash; MAX_NOTE_ENCRYPTED_LOGS_PER_TX],
-        sorted_note_encrypted_log_hashes_indexes: [u64; MAX_NOTE_ENCRYPTED_LOGS_PER_TX],
+        sorted_note_encrypted_log_hashes_indexes: [u32; MAX_NOTE_ENCRYPTED_LOGS_PER_TX],
         sorted_encrypted_log_hashes: [ScopedEncryptedLogHash; MAX_ENCRYPTED_LOGS_PER_TX],
-        sorted_encrypted_log_hashes_indexes: [u64; MAX_ENCRYPTED_LOGS_PER_TX],
+        sorted_encrypted_log_hashes_indexes: [u32; MAX_ENCRYPTED_LOGS_PER_TX],
         sorted_unencrypted_log_hashes: [ScopedLogHash; MAX_UNENCRYPTED_LOGS_PER_TX],
-        sorted_unencrypted_log_hashes_indexes: [u64; MAX_UNENCRYPTED_LOGS_PER_TX]
+        sorted_unencrypted_log_hashes_indexes: [u32; MAX_UNENCRYPTED_LOGS_PER_TX]
     ) -> Self {
         let public_inputs = PrivateKernelCircuitPublicInputsBuilder::empty();
 
@@ -92,7 +92,7 @@ impl KernelCircuitPublicInputsComposer {
     pub fn compose_public(
         &mut self,
         sorted_call_requests: [CallRequest; MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX],
-        sorted_call_requests_indexes: [u64; MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX]
+        sorted_call_requests_indexes: [u32; MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX]
     ) -> Self {
         let _ = self.compose();
 
@@ -233,7 +233,7 @@ impl KernelCircuitPublicInputsComposer {
     fn propagate_sorted_public_call_requests(
         &mut self,
         sorted_call_requests: [CallRequest; MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX],
-        sorted_call_requests_indexes: [u64; MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX]
+        sorted_call_requests_indexes: [u32; MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX]
     ) {
         let accumulated_data = self.previous_kernel.public_inputs.end;
         assert_sorted_array(

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

@@ -12,7 +12,7 @@ use dep::types::{
     traits::is_empty, transaction::tx_request::TxRequest, utils::arrays::find_index
 };
 
-unconstrained fn match_log_to_note<N>(note_log: NoteLogHash, accumulated_note_hashes: [ScopedNoteHash; N]) -> u64 {
+unconstrained fn match_log_to_note<N>(note_log: NoteLogHash, accumulated_note_hashes: [ScopedNoteHash; N]) -> u32 {
     find_index(
         accumulated_note_hashes,
         |n: ScopedNoteHash| n.counter() == note_log.note_hash_counter
@@ -42,7 +42,7 @@ fn validate_incrementing_counters_within_range<T, N>(
     counter_start: u32,
     counter_end: u32,
     items: [T; N],
-    num_items: u64
+    num_items: u32
 ) where T: Ordered {
     let mut prev_counter = counter_start;
     let mut should_check = true;
@@ -63,7 +63,7 @@ fn validate_incrementing_counter_ranges_within_range<T, N>(
     counter_start: u32,
     counter_end: u32,
     items: [T; N],
-    num_items: u64
+    num_items: u32
 ) where T: RangeOrdered {
     let mut prev_counter = counter_start;
     let mut should_check = true;
@@ -85,9 +85,9 @@ fn validate_incrementing_counter_ranges_within_range<T, N>(
 
 fn validate_clean_split_ranges<T, N>(
     min_revertible_side_effect_counter: u32,
-    first_revertible_item_index: u64,
+    first_revertible_item_index: u32,
     items: [T; N],
-    num_items: u64
+    num_items: u32
 ) where T: RangeOrdered {
     if first_revertible_item_index != 0 {
         let last_non_revertible_item_index = first_revertible_item_index - 1;
@@ -125,7 +125,7 @@ impl PrivateCallDataValidator {
         self.validate_note_logs(accumulated_note_hashes);
     }
 
-    pub fn validate_as_first_call(self, first_revertible_private_call_request_index: u64) {
+    pub fn validate_as_first_call(self, first_revertible_private_call_request_index: u32) {
         let public_inputs = self.data.call_stack_item.public_inputs;
         let call_context = public_inputs.call_context;
         assert(call_context.is_delegate_call == false, "Users cannot make a delegatecall");

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

@@ -10,7 +10,7 @@ use dep::types::{
     address::AztecAddress, traits::{Empty, is_empty}, transaction::tx_request::TxRequest
 };
 
-fn validate_array_prepended<T, N>(dest: [T; N], source: [T; N], num_source_items: u64) where T: Eq {
+fn validate_array_prepended<T, N>(dest: [T; N], source: [T; N], num_source_items: u32) where T: Eq {
     let mut proceed = true;
     for i in 0..source.len() {
         proceed &= i != num_source_items;
@@ -23,8 +23,8 @@ fn validate_array_prepended<T, N>(dest: [T; N], source: [T; N], num_source_items
 fn validate_array_appended<T, N, M>(
     dest: [T; N],
     source: [T; M],
-    num_source_items: u64,
-    num_prepended_items: u64
+    num_source_items: u32,
+    num_prepended_items: u32
 ) where T: Empty + Eq {
     let items_propagated = num_prepended_items + num_source_items;
     assert(items_propagated <= N, "number of total items exceeds limit");
@@ -47,8 +47,8 @@ fn validate_array_appended<T, N, M>(
 fn validate_array_appended_scoped<ST, T, N, M>(
     dest: [ST; N],
     source: [T; M],
-    num_source_items: u64,
-    num_prepended_items: u64,
+    num_source_items: u32,
+    num_prepended_items: u32,
     contract_address: AztecAddress
 ) where ST: Scoped<T> + Empty + Eq, T: Eq {
     let items_propagated = num_prepended_items + num_source_items;
@@ -77,8 +77,8 @@ fn validate_array_appended_scoped<ST, T, N, M>(
 fn validate_array_appended_reversed_scoped<ST, T, N, M>(
     dest: [ST; N],
     source: [T; M],
-    num_source_items: u64,
-    num_prepended_items: u64,
+    num_source_items: u32,
+    num_prepended_items: u32,
     contract_address: AztecAddress
 ) where ST: Scoped<T> + Empty + Eq, T: Eq {
     let items_propagated = num_prepended_items + num_source_items;
@@ -106,8 +106,8 @@ fn validate_array_appended_reversed_scoped<ST, T, N, M>(
 fn validate_note_hash_nullifier_counters<N, M>(
     dest: [ScopedNoteHash; N],
     note_hash_nullifier_counters: [u32; M],
-    num_source_items: u64,
-    num_prepended_items: u64
+    num_source_items: u32,
+    num_prepended_items: u32
 ) {
     let mut is_non_empty_item = true;
     for i in 0..M {
@@ -341,7 +341,7 @@ impl PrivateKernelCircuitOutputValidator {
         private_call: PrivateCircuitPublicInputs,
         array_lengths: PrivateCircuitPublicInputsArrayLengths,
         offsets: PrivateKernelCircuitPublicInputsArrayLengths,
-        num_popped_call: u64,
+        num_popped_call: u32,
         contract_address: AztecAddress,
         note_hash_nullifier_counters: [u32; NOTE_HASH_NULLIFIER_COUNTERS_LEN],
         public_call_requests: [CallRequest; PUBLIC_CALL_REQUESTS_LEN]

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

@@ -16,7 +16,7 @@ use dep::types::{
 struct PrivateKernelInitHints {
     note_hash_nullifier_counters: [u32; MAX_NEW_NOTE_HASHES_PER_CALL],
     // TODO: Build the following hint in noir.
-    first_revertible_private_call_request_index: u64,
+    first_revertible_private_call_request_index: u32,
 }
 
 // Initialization struct for private inputs to the private kernel

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

@@ -24,9 +24,9 @@ struct PrivateKernelResetOutputs {
 }
 
 struct PrivateKernelResetHints<NH_RR_PENDING, NH_RR_SETTLED, NLL_RR_PENDING, NLL_RR_SETTLED, KEY_VALIDATION_REQUESTS> {
-    transient_nullifier_indexes_for_note_hashes: [u64; MAX_NEW_NOTE_HASHES_PER_TX],
-    transient_note_hash_indexes_for_nullifiers: [u64; MAX_NEW_NULLIFIERS_PER_TX],
-    transient_note_hash_indexes_for_logs: [u64; MAX_NOTE_ENCRYPTED_LOGS_PER_TX],
+    transient_nullifier_indexes_for_note_hashes: [u32; MAX_NEW_NOTE_HASHES_PER_TX],
+    transient_note_hash_indexes_for_nullifiers: [u32; MAX_NEW_NULLIFIERS_PER_TX],
+    transient_note_hash_indexes_for_logs: [u32; MAX_NOTE_ENCRYPTED_LOGS_PER_TX],
     note_hash_read_request_hints: NoteHashReadRequestHints<NH_RR_PENDING, NH_RR_SETTLED>,
     nullifier_read_request_hints: NullifierReadRequestHints<NLL_RR_PENDING, NLL_RR_SETTLED>,
     key_validation_hints: [KeyValidationHint; KEY_VALIDATION_REQUESTS],
@@ -106,9 +106,9 @@ mod tests {
 
     struct PrivateKernelResetInputsBuilder {
         previous_kernel: FixtureBuilder,
-        transient_nullifier_indexes_for_note_hashes: [u64; MAX_NEW_NOTE_HASHES_PER_TX],
-        transient_note_hash_indexes_for_nullifiers: [u64; MAX_NEW_NULLIFIERS_PER_TX],
-        transient_note_hash_indexes_for_logs: [u64; MAX_NOTE_ENCRYPTED_LOGS_PER_TX],
+        transient_nullifier_indexes_for_note_hashes: [u32; MAX_NEW_NOTE_HASHES_PER_TX],
+        transient_note_hash_indexes_for_nullifiers: [u32; MAX_NEW_NULLIFIERS_PER_TX],
+        transient_note_hash_indexes_for_logs: [u32; MAX_NOTE_ENCRYPTED_LOGS_PER_TX],
         note_hash_read_request_hints_builder: NoteHashReadRequestHintsBuilder,
         nullifier_read_request_hints_builder: NullifierReadRequestHintsBuilder,
     }
@@ -128,15 +128,15 @@ mod tests {
             }
         }
 
-        pub fn add_pending_note_hash_read_request(&mut self, note_hash_index: u64) {
+        pub fn add_pending_note_hash_read_request(&mut self, note_hash_index: u32) {
             let read_request_index = self.previous_kernel.add_read_request_for_pending_note_hash(note_hash_index);
             let hint_index = self.note_hash_read_request_hints_builder.pending_read_hints.len();
             let hint = PendingReadHint { read_request_index, pending_value_index: note_hash_index };
             self.note_hash_read_request_hints_builder.pending_read_hints.push(hint);
             self.note_hash_read_request_hints_builder.read_request_statuses[read_request_index] = ReadRequestStatus { state: ReadRequestState.PENDING, hint_index };
         }
 
-        pub fn add_pending_nullifier_read_request(&mut self, nullifier_index_offset_one: u64) {
+        pub fn add_pending_nullifier_read_request(&mut self, nullifier_index_offset_one: u32) {
             let nullifier_index = nullifier_index_offset_one + 1; // + 1 is for the first nullifier
             let read_request_index = self.previous_kernel.add_read_request_for_pending_nullifier(nullifier_index);
             let hint_index = self.nullifier_read_request_hints_builder.pending_read_hints.len();
@@ -145,7 +145,7 @@ mod tests {
             self.nullifier_read_request_hints_builder.read_request_statuses[read_request_index] = ReadRequestStatus { state: ReadRequestState.PENDING, hint_index };
         }
 
-        pub fn nullify_pending_note_hash(&mut self, nullifier_index: u64, note_hash_index: u64) {
+        pub fn nullify_pending_note_hash(&mut self, nullifier_index: u32, note_hash_index: u32) {
             let note_hash = self.previous_kernel.new_note_hashes.get(note_hash_index).note_hash;
             self.previous_kernel.new_note_hashes.storage[note_hash_index].nullifier_counter = self.previous_kernel.new_nullifiers.get(nullifier_index).counter();
             self.previous_kernel.new_nullifiers.storage[nullifier_index].nullifier.note_hash = note_hash.value;

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

@@ -20,15 +20,15 @@ use dep::types::{
 // TODO: Build hints in noir.
 struct PrivateKernelTailHints {
     sorted_new_note_hashes: [ScopedNoteHash; MAX_NEW_NOTE_HASHES_PER_TX],
-    sorted_new_note_hashes_indexes: [u64; MAX_NEW_NOTE_HASHES_PER_TX],
+    sorted_new_note_hashes_indexes: [u32; MAX_NEW_NOTE_HASHES_PER_TX],
     sorted_new_nullifiers: [ScopedNullifier; MAX_NEW_NULLIFIERS_PER_TX],
-    sorted_new_nullifiers_indexes: [u64; MAX_NEW_NULLIFIERS_PER_TX],
+    sorted_new_nullifiers_indexes: [u32; MAX_NEW_NULLIFIERS_PER_TX],
     sorted_note_encrypted_log_hashes: [NoteLogHash; MAX_NOTE_ENCRYPTED_LOGS_PER_TX],
-    sorted_note_encrypted_log_hashes_indexes: [u64; MAX_NOTE_ENCRYPTED_LOGS_PER_TX],
+    sorted_note_encrypted_log_hashes_indexes: [u32; MAX_NOTE_ENCRYPTED_LOGS_PER_TX],
     sorted_encrypted_log_hashes: [ScopedEncryptedLogHash; MAX_ENCRYPTED_LOGS_PER_TX],
-    sorted_encrypted_log_hashes_indexes: [u64; MAX_ENCRYPTED_LOGS_PER_TX],
+    sorted_encrypted_log_hashes_indexes: [u32; MAX_ENCRYPTED_LOGS_PER_TX],
     sorted_unencrypted_log_hashes: [ScopedLogHash; MAX_UNENCRYPTED_LOGS_PER_TX],
-    sorted_unencrypted_log_hashes_indexes: [u64; MAX_UNENCRYPTED_LOGS_PER_TX],
+    sorted_unencrypted_log_hashes_indexes: [u32; MAX_UNENCRYPTED_LOGS_PER_TX],
 }
 
 struct PrivateKernelTailCircuitPrivateInputs {

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

@@ -18,17 +18,17 @@ use dep::types::{
 
 struct PrivateKernelTailToPublicHints {
     sorted_new_note_hashes: [ScopedNoteHash; MAX_NEW_NOTE_HASHES_PER_TX],
-    sorted_new_note_hashes_indexes: [u64; MAX_NEW_NOTE_HASHES_PER_TX],
+    sorted_new_note_hashes_indexes: [u32; MAX_NEW_NOTE_HASHES_PER_TX],
     sorted_new_nullifiers: [ScopedNullifier; MAX_NEW_NULLIFIERS_PER_TX],
-    sorted_new_nullifiers_indexes: [u64; MAX_NEW_NULLIFIERS_PER_TX],
+    sorted_new_nullifiers_indexes: [u32; MAX_NEW_NULLIFIERS_PER_TX],
     sorted_note_encrypted_log_hashes: [NoteLogHash; MAX_NOTE_ENCRYPTED_LOGS_PER_TX],
-    sorted_note_encrypted_log_hashes_indexes: [u64; MAX_NOTE_ENCRYPTED_LOGS_PER_TX],
+    sorted_note_encrypted_log_hashes_indexes: [u32; MAX_NOTE_ENCRYPTED_LOGS_PER_TX],
     sorted_encrypted_log_hashes: [ScopedEncryptedLogHash; MAX_ENCRYPTED_LOGS_PER_TX],
-    sorted_encrypted_log_hashes_indexes: [u64; MAX_ENCRYPTED_LOGS_PER_TX],
+    sorted_encrypted_log_hashes_indexes: [u32; MAX_ENCRYPTED_LOGS_PER_TX],
     sorted_unencrypted_log_hashes: [ScopedLogHash; MAX_UNENCRYPTED_LOGS_PER_TX],
-    sorted_unencrypted_log_hashes_indexes: [u64; MAX_UNENCRYPTED_LOGS_PER_TX],
+    sorted_unencrypted_log_hashes_indexes: [u32; MAX_UNENCRYPTED_LOGS_PER_TX],
     sorted_call_requests: [CallRequest; MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX],
-    sorted_call_requests_indexes: [u64; MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX],
+    sorted_call_requests_indexes: [u32; MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX],
 }
 
 struct PrivateKernelTailToPublicCircuitPrivateInputs {

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

@@ -18,7 +18,7 @@ use dep::types::{
 
 struct PrivateCallDataValidatorBuilder {
     private_call: FixtureBuilder,
-    first_revertible_private_call_request_index: u64,
+    first_revertible_private_call_request_index: u32,
     previous_note_hashes: BoundedVec<ScopedNoteHash, 4>,
 }