feat: nullified note retrieval in get_notes and view_notes

barretenberg/cpp/src/barretenberg/common/fuzzer.hpp

@@ -89,65 +89,64 @@ class FastRandom {
  */
 template <typename T>
 concept SimpleRng = requires(T a) {
-                        {
-                            a.next()
-                            } -> std::convertible_to<uint32_t>;
-                    };
+    {
+        a.next()
+    } -> std::convertible_to<uint32_t>;
+};
 /**
  * @brief Concept for forcing ArgumentSizes to be size_t
  *
  * @tparam T
  */
 template <typename T>
 concept InstructionArgumentSizes = requires {
-                                       {
-                                           std::make_tuple(T::CONSTANT,
-                                                           T::WITNESS,
-                                                           T::CONSTANT_WITNESS,
-                                                           T::ADD,
-                                                           T::SUBTRACT,
-                                                           T::MULTIPLY,
-                                                           T::DIVIDE,
-                                                           T::ADD_TWO,
-                                                           T::MADD,
-                                                           T::MULT_MADD,
-                                                           T::MSUB_DIV,
-                                                           T::SQR,
-                                                           T::SQR_ADD,
-                                                           T::SUBTRACT_WITH_CONSTRAINT,
-                                                           T::DIVIDE_WITH_CONSTRAINTS,
-                                                           T::SLICE,
-                                                           T::ASSERT_ZERO,
-                                                           T::ASSERT_NOT_ZERO)
-                                           } -> std::same_as<std::tuple<size_t>>;
-                                   };
+    {
+        std::make_tuple(T::CONSTANT,
+                        T::WITNESS,
+                        T::CONSTANT_WITNESS,
+                        T::ADD,
+                        T::SUBTRACT,
+                        T::MULTIPLY,
+                        T::DIVIDE,
+                        T::ADD_TWO,
+                        T::MADD,
+                        T::MULT_MADD,
+                        T::MSUB_DIV,
+                        T::SQR,
+                        T::SQR_ADD,
+                        T::SUBTRACT_WITH_CONSTRAINT,
+                        T::DIVIDE_WITH_CONSTRAINTS,
+                        T::SLICE,
+                        T::ASSERT_ZERO,
+                        T::ASSERT_NOT_ZERO)
+    } -> std::same_as<std::tuple<size_t>>;
+};
 
 /**
  * @brief Concept for Havoc Configurations
  *
  * @tparam T
  */
 template <typename T>
-concept HavocConfigConstraint =
-    requires {
-        {
-            std::make_tuple(T::GEN_MUTATION_COUNT_LOG, T::GEN_STRUCTURAL_MUTATION_PROBABILITY)
-            } -> std::same_as<std::tuple<size_t>>;
-        T::GEN_MUTATION_COUNT_LOG <= 7;
-    };
+concept HavocConfigConstraint = requires {
+    {
+        std::make_tuple(T::GEN_MUTATION_COUNT_LOG, T::GEN_STRUCTURAL_MUTATION_PROBABILITY)
+    } -> std::same_as<std::tuple<size_t>>;
+    T::GEN_MUTATION_COUNT_LOG <= 7;
+};
 /**
  * @brief Concept specifying the class used by the fuzzer
  *
  * @tparam T
  */
 template <typename T>
 concept ArithmeticFuzzHelperConstraint = requires {
-                                             typename T::ArgSizes;
-                                             typename T::Instruction;
-                                             typename T::ExecutionState;
-                                             typename T::ExecutionHandler;
-                                             InstructionArgumentSizes<typename T::ArgSizes>;
-                                         };
+    typename T::ArgSizes;
+    typename T::Instruction;
+    typename T::ExecutionState;
+    typename T::ExecutionHandler;
+    InstructionArgumentSizes<typename T::ArgSizes>;
+};
 
 /**
  * @brief Fuzzer uses only composers with check_circuit function
@@ -156,10 +155,10 @@ concept ArithmeticFuzzHelperConstraint = requires {
  */
 template <typename T>
 concept CheckableComposer = requires(T a) {
-                                {
-                                    a.check_circuit()
-                                    } -> std::same_as<bool>;
-                            };
+    {
+        a.check_circuit()
+    } -> std::same_as<bool>;
+};
 
 /**
  * @brief The fuzzer can use a postprocessing function that is specific to the type being fuzzed
@@ -170,10 +169,10 @@ concept CheckableComposer = requires(T a) {
  */
 template <typename T, typename Composer, typename Context>
 concept PostProcessingEnabled = requires(Composer composer, Context context) {
-                                    {
-                                        T::postProcess(&composer, context)
-                                        } -> std::same_as<bool>;
-                                };
+    {
+        T::postProcess(&composer, context)
+    } -> std::same_as<bool>;
+};
 
 /**
  * @brief This concept is used when we want to limit the number of executions of certain instructions (for example,
@@ -183,9 +182,9 @@ concept PostProcessingEnabled = requires(Composer composer, Context context) {
  */
 template <typename T>
 concept InstructionWeightsEnabled = requires {
-                                        typename T::InstructionWeights;
-                                        T::InstructionWeights::_LIMIT;
-                                    };
+    typename T::InstructionWeights;
+    T::InstructionWeights::_LIMIT;
+};
 
 /**
  * @brief Mutate the value of a field element

barretenberg/cpp/src/barretenberg/relations/relation_types.hpp

@@ -23,10 +23,10 @@ using GetParameterView = std::conditional_t<IsField<typename Params::DataType>,
 
 template <typename T, size_t subrelation_idx>
 concept HasSubrelationLinearlyIndependentMember = requires(T) {
-                                                      {
-                                                          std::get<subrelation_idx>(T::SUBRELATION_LINEARLY_INDEPENDENT)
-                                                          } -> std::convertible_to<bool>;
-                                                  };
+    {
+        std::get<subrelation_idx>(T::SUBRELATION_LINEARLY_INDEPENDENT)
+    } -> std::convertible_to<bool>;
+};
 
 template <typename T>
 concept HasParameterLengthAdjustmentsMember = requires { T::TOTAL_LENGTH_ADJUSTMENTS; };

barretenberg/cpp/src/barretenberg/relations/utils.hpp

@@ -113,8 +113,7 @@ template <typename Flavor> class RelationUtils {
     template <typename... T>
     static constexpr void add_tuples(std::tuple<T...>& tuple_1, const std::tuple<T...>& tuple_2)
     {
-        auto add_tuples_helper = [&]<std::size_t... I>(std::index_sequence<I...>)
-        {
+        auto add_tuples_helper = [&]<std::size_t... I>(std::index_sequence<I...>) {
             ((std::get<I>(tuple_1) += std::get<I>(tuple_2)), ...);
         };
 

barretenberg/cpp/src/barretenberg/stdlib/primitives/circuit_builders/circuit_builders.hpp

@@ -13,5 +13,4 @@ concept HasPlookup = bb::IsAnyOf<T, bb::UltraCircuitBuilder, bb::GoblinUltraCirc
 template <typename T>
 concept IsGoblinBuilder = bb::IsAnyOf<T, bb::GoblinUltraCircuitBuilder>;
 template <typename T>
-concept IsNotGoblinBuilder = !
-IsGoblinBuilder<T>;
+concept IsNotGoblinBuilder = !IsGoblinBuilder<T>;

barretenberg/cpp/src/barretenberg/transcript/transcript.hpp

@@ -10,9 +10,9 @@
 namespace bb::honk {
 
 template <typename T, typename... U>
-concept Loggable = (std::same_as<T, bb::fr> || std::same_as<T, grumpkin::fr> ||
-                    std::same_as<T, bb::g1::affine_element> || std::same_as<T, grumpkin::g1::affine_element> ||
-                    std::same_as<T, uint32_t>);
+concept Loggable =
+    (std::same_as<T, bb::fr> || std::same_as<T, grumpkin::fr> || std::same_as<T, bb::g1::affine_element> ||
+     std::same_as<T, grumpkin::g1::affine_element> || std::same_as<T, uint32_t>);
 
 // class TranscriptManifest;
 class TranscriptManifest {

yarn-project/acir-simulator/src/acvm/oracle/oracle.ts

@@ -172,6 +172,7 @@ export class Oracle {
     sortOrder: ACVMField[],
     [limit]: ACVMField[],
     [offset]: ACVMField[],
+    [status]: ACVMField[],
     [returnSize]: ACVMField[],
   ): Promise<ACVMField[]> {
     const noteDatas = await this.typedOracle.getNotes(
@@ -184,6 +185,7 @@ export class Oracle {
       sortOrder.map(s => +s),
       +limit,
       +offset,
+      +status,
     );
 
     const noteLength = noteDatas?.[0]?.note.items.length ?? 0;

yarn-project/acir-simulator/src/acvm/oracle/typed_oracle.ts

@@ -2,6 +2,7 @@ import {
   CompleteAddress,
   MerkleTreeId,
   Note,
+  NoteStatus,
   NullifierMembershipWitness,
   PublicDataWitness,
   PublicKey,
@@ -142,6 +143,7 @@ export abstract class TypedOracle {
     _sortOrder: number[],
     _limit: number,
     _offset: number,
+    _status: NoteStatus,
   ): Promise<NoteData[]> {
     throw new Error('Not available.');
   }

yarn-project/acir-simulator/src/client/client_execution_context.ts

@@ -1,4 +1,4 @@
-import { AuthWitness, FunctionL2Logs, L1NotePayload, Note, UnencryptedL2Log } from '@aztec/circuit-types';
+import { AuthWitness, FunctionL2Logs, L1NotePayload, Note, NoteStatus, UnencryptedL2Log } from '@aztec/circuit-types';
 import {
   BlockHeader,
   CallContext,
@@ -190,6 +190,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param sortOrder - The order of the corresponding index in sortBy. (1: DESC, 2: ASC, 0: Do nothing)
    * @param limit - The number of notes to retrieve per query.
    * @param offset - The starting index for pagination.
+   * @param status - The status of notes to fetch.
    * @returns Array of note data.
    */
   public async getNotes(
@@ -202,12 +203,13 @@ export class ClientExecutionContext extends ViewDataOracle {
     sortOrder: number[],
     limit: number,
     offset: number,
+    status: NoteStatus,
   ): Promise<NoteData[]> {
     // Nullified pending notes are already removed from the list.
     const pendingNotes = this.noteCache.getNotes(this.contractAddress, storageSlot);
 
     const pendingNullifiers = this.noteCache.getNullifiers(this.contractAddress);
-    const dbNotes = await this.db.getNotes(this.contractAddress, storageSlot);
+    const dbNotes = await this.db.getNotes(this.contractAddress, storageSlot, status);
     const dbNotesFiltered = dbNotes.filter(n => !pendingNullifiers.has((n.siloedNullifier as Fr).value));
 
     const notes = pickNotes<NoteData>([...dbNotesFiltered, ...pendingNotes], {

yarn-project/acir-simulator/src/client/db_oracle.ts

@@ -1,4 +1,4 @@
-import { L2Block, MerkleTreeId, NullifierMembershipWitness, PublicDataWitness } from '@aztec/circuit-types';
+import { L2Block, MerkleTreeId, NoteStatus, NullifierMembershipWitness, PublicDataWitness } from '@aztec/circuit-types';
 import { BlockHeader, CompleteAddress } from '@aztec/circuits.js';
 import { FunctionArtifactWithDebugMetadata, FunctionSelector } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
@@ -61,9 +61,10 @@ export interface DBOracle extends CommitmentsDB {
    *
    * @param contractAddress - The AztecAddress instance representing the contract address.
    * @param storageSlot - The Fr instance representing the storage slot of the notes.
+   * @param status - The status of notes to fetch.
    * @returns A Promise that resolves to an array of note data.
    */
-  getNotes(contractAddress: AztecAddress, storageSlot: Fr): Promise<NoteData[]>;
+  getNotes(contractAddress: AztecAddress, storageSlot: Fr, status: NoteStatus): Promise<NoteData[]>;
 
   /**
    * Retrieve the artifact information of a specific function within a contract.

yarn-project/acir-simulator/src/client/view_data_oracle.ts

@@ -4,6 +4,7 @@ import {
   CompleteAddress,
   INITIAL_L2_BLOCK_NUM,
   MerkleTreeId,
+  NoteStatus,
   NullifierMembershipWitness,
   PublicDataWitness,
 } from '@aztec/circuit-types';
@@ -203,6 +204,7 @@ export class ViewDataOracle extends TypedOracle {
    * @param sortOrder - The order of the corresponding index in sortBy. (1: DESC, 2: ASC, 0: Do nothing)
    * @param limit - The number of notes to retrieve per query.
    * @param offset - The starting index for pagination.
+   * @param status - The status of notes to fetch.
    * @returns Array of note data.
    */
   public async getNotes(
@@ -215,8 +217,9 @@ export class ViewDataOracle extends TypedOracle {
     sortOrder: number[],
     limit: number,
     offset: number,
+    status: NoteStatus,
   ): Promise<NoteData[]> {
-    const dbNotes = await this.db.getNotes(this.contractAddress, storageSlot);
+    const dbNotes = await this.db.getNotes(this.contractAddress, storageSlot, status);
     return pickNotes<NoteData>(dbNotes, {
       selects: selectBy
         .slice(0, numSelects)

yarn-project/aztec-nr/aztec/src/note/note_getter.nr

@@ -8,7 +8,7 @@ use dep::protocol_types::constants::{
 };
 use crate::context::PrivateContext;
 use crate::note::{
-    note_getter_options::{NoteGetterOptions, Select, Sort, SortOrder, Comparator},
+    note_getter_options::{NoteGetterOptions, Select, Sort, SortOrder, Comparator, NoteStatus},
     note_interface::NoteInterface,
     note_viewer_options::NoteViewerOptions,
     utils::compute_note_hash_for_read_or_nullify,
@@ -135,6 +135,7 @@ unconstrained fn get_note_internal<Note, N>(storage_slot: Field, note_interface:
         [],
         1, // limit
         0, // offset
+        NoteStatus.ACTIVE,
         placeholder_note,
         placeholder_fields
     )[0].unwrap() // Notice: we don't allow dummies to be returned from get_note (singular).
@@ -159,6 +160,7 @@ unconstrained fn get_notes_internal<Note, N, FILTER_ARGS>(
         sort_order,
         options.limit,
         options.offset,
+        options.status,
         placeholder_opt_notes,
         placeholder_fields
     );
@@ -187,6 +189,7 @@ unconstrained pub fn view_notes<Note, N>(
         sort_order,
         options.limit,
         options.offset,
+        options.status,
         placeholder_opt_notes,
         placeholder_fields
     )

yarn-project/aztec-nr/aztec/src/note/note_getter_options.nr

@@ -53,6 +53,17 @@ impl Sort {
     }
 }
 
+struct NoteStatusEnum {
+    ACTIVE: u2,
+    ACTIVE_OR_NULLIFIED: u2,
+}
+
+global NoteStatus = NoteStatusEnum {
+    ACTIVE: 1,
+    ACTIVE_OR_NULLIFIED: 2,
+    // TODO 4208: add 'NULLIFIED'
+};
+
 fn return_all_notes<Note, N>(
     notes: [Option<Note>; MAX_READ_REQUESTS_PER_CALL],
     _p: Field
@@ -68,6 +79,7 @@ struct NoteGetterOptions<Note, N, FILTER_ARGS> {
     offset: u32,
     filter: fn ([Option<Note>; MAX_READ_REQUESTS_PER_CALL], FILTER_ARGS) -> [Option<Note>; MAX_READ_REQUESTS_PER_CALL],
     filter_args: FILTER_ARGS,
+    status: u2,
 }
 // docs:end:NoteGetterOptions
 
@@ -85,6 +97,7 @@ impl<Note, N, FILTER_ARGS> NoteGetterOptions<Note, N, FILTER_ARGS> {
             offset: 0,
             filter: return_all_notes,
             filter_args: 0,
+            status: NoteStatus.ACTIVE,
         }
     }
 
@@ -101,6 +114,7 @@ impl<Note, N, FILTER_ARGS> NoteGetterOptions<Note, N, FILTER_ARGS> {
             offset: 0,
             filter,
             filter_args,
+            status: NoteStatus.ACTIVE,
         }
     }
 
@@ -120,16 +134,22 @@ impl<Note, N, FILTER_ARGS> NoteGetterOptions<Note, N, FILTER_ARGS> {
         *self
     }
 
-    // This method lets you set a limit for the maximum number of notes to be retrieved in a single query result. 
+    // This method lets you set a limit for the maximum number of notes to be retrieved in a single query result.
     pub fn set_limit(&mut self, limit: u32) -> Self {
         assert(limit <= MAX_READ_REQUESTS_PER_CALL as u32);
         self.limit = limit;
         *self
     }
 
-    // This method sets the offset value, which determines where to start retrieving notes in the query results. 
+    // This method sets the offset value, which determines where to start retrieving notes in the query results.
     pub fn set_offset(&mut self, offset: u32) -> Self {
         self.offset = offset;
         *self
     }
+
+    // This method sets the status value, which determines whether to retrieve active or nullified notes.
+    pub fn set_status(&mut self, status: u2) -> Self {
+        self.status = status;
+        *self
+    }
 }