@aztec/pxe 0.47.1 → 0.48.0

package/src/config/index.ts

@@ -1,4 +1,11 @@
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js/constants';
+import {
+  type ConfigMappingsType,
+  booleanConfigHelper,
+  getConfigFromMappings,
+  numberConfigHelper,
+} from '@aztec/foundation/config';
+import { type Network } from '@aztec/types/network';
 
 import { readFileSync } from 'fs';
 import { dirname, resolve } from 'path';
@@ -33,26 +40,89 @@ export interface PXEConfig {
 
 export type PXEServiceConfig = PXEConfig & KernelProverConfig & BBProverConfig;
 
+export type CliPXEOptions = {
+  /** External Aztec network to connect to. e.g. devnet */
+  network?: Network;
+  /** API Key required by the external network's node */
+  apiKey?: string;
+  /** Custom Aztec Node URL to connect to  */
+  nodeUrl?: string;
+};
+
+export const pxeConfigMappings: ConfigMappingsType<PXEServiceConfig> = {
+  l2BlockPollingIntervalMS: {
+    env: 'PXE_BLOCK_POLLING_INTERVAL_MS',
+    description: 'The interval to wait between polling for new blocks.',
+    ...numberConfigHelper(1_000),
+  },
+  l2StartingBlock: {
+    env: 'PXE_L2_STARTING_BLOCK',
+    ...numberConfigHelper(INITIAL_L2_BLOCK_NUM),
+    description: 'L2 block to start scanning from for new accounts',
+  },
+  dataDirectory: {
+    env: 'PXE_DATA_DIRECTORY',
+    description: 'Where to store PXE data. If not set, will store in memory',
+  },
+  bbBinaryPath: {
+    env: 'BB_BINARY_PATH',
+    description: 'Path to the BB binary',
+  },
+  bbWorkingDirectory: {
+    env: 'BB_WORKING_DIRECTORY',
+    description: 'Working directory for the BB binary',
+  },
+  proverEnabled: {
+    env: 'PXE_PROVER_ENABLED',
+    description: 'Enable real proofs',
+    ...booleanConfigHelper(),
+  },
+};
+
 /**
  * Creates an instance of PXEServiceConfig out of environment variables using sensible defaults for integration testing if not set.
  */
 export function getPXEServiceConfig(): PXEServiceConfig {
-  const {
-    PXE_BLOCK_POLLING_INTERVAL_MS,
-    PXE_L2_STARTING_BLOCK,
-    PXE_DATA_DIRECTORY,
-    BB_BINARY_PATH,
-    BB_WORKING_DIRECTORY,
-    PXE_PROVER_ENABLED,
-  } = process.env;
+  return getConfigFromMappings<PXEServiceConfig>(pxeConfigMappings);
+}
+
+export const pxeCliConfigMappings: ConfigMappingsType<CliPXEOptions> = {
+  network: {
+    env: 'NETWORK',
+    parseEnv: (val: string) => val as Network,
+    description: 'External Aztec network to connect to. e.g. devnet',
+  },
+  apiKey: {
+    env: 'API_KEY',
+    description: "API Key required by the external network's node",
+  },
+  nodeUrl: {
+    env: 'AZTEC_NODE_URL',
+    description: 'Custom Aztec Node URL to connect to',
+  },
+};
 
+export const allPxeConfigMappings: ConfigMappingsType<CliPXEOptions & PXEServiceConfig> = {
+  ...pxeConfigMappings,
+  ...pxeCliConfigMappings,
+  proverEnabled: {
+    env: 'PXE_PROVER_ENABLED',
+    parseEnv: (val: string) => ['1', 'true', 'TRUE'].includes(val) || !!process.env.NETWORK,
+    description: 'Enable real proofs',
+    isBoolean: true,
+  },
+};
+
+/**
+ * Creates an instance of CliPxeOptions out of environment variables
+ */
+export function getCliPXEOptions(): CliPXEOptions & PXEServiceConfig {
+  const pxeConfig = getPXEServiceConfig();
+  const cliOptions = getConfigFromMappings<CliPXEOptions>(pxeCliConfigMappings);
   return {
-    l2BlockPollingIntervalMS: PXE_BLOCK_POLLING_INTERVAL_MS ? +PXE_BLOCK_POLLING_INTERVAL_MS : 1000,
-    l2StartingBlock: PXE_L2_STARTING_BLOCK ? +PXE_L2_STARTING_BLOCK : INITIAL_L2_BLOCK_NUM,
-    dataDirectory: PXE_DATA_DIRECTORY,
-    bbBinaryPath: BB_BINARY_PATH,
-    bbWorkingDirectory: BB_WORKING_DIRECTORY,
-    proverEnabled: ['1', 'true'].includes(PXE_PROVER_ENABLED!),
+    ...pxeConfig,
+    ...cliOptions,
+    proverEnabled: pxeConfig.proverEnabled || !!cliOptions.network,
   };
 }
 

package/src/database/incoming_note_dao.ts

@@ -23,10 +23,10 @@ export class IncomingNoteDao implements NoteData {
     /** The nonce of the note. */
     public nonce: Fr,
     /**
-     * Inner note hash of the note. This is customizable by the app circuit.
+     * A hash of the note. This is customizable by the app circuit.
      * We can use this value to compute siloedNoteHash and uniqueSiloedNoteHash.
      */
-    public innerNoteHash: Fr,
+    public noteHash: Fr,
     /**
      * The nullifier of the note (siloed by contract address).
      * Note: Might be set as 0 if the note was added to PXE as nullified.
@@ -46,7 +46,7 @@ export class IncomingNoteDao implements NoteData {
       this.noteTypeId,
       this.txHash.buffer,
       this.nonce,
-      this.innerNoteHash,
+      this.noteHash,
       this.siloedNullifier,
       this.index,
       this.ivpkM,
@@ -61,7 +61,7 @@ export class IncomingNoteDao implements NoteData {
     const noteTypeId = reader.readObject(NoteSelector);
     const txHash = reader.readObject(TxHash);
     const nonce = Fr.fromBuffer(reader);
-    const innerNoteHash = Fr.fromBuffer(reader);
+    const noteHash = Fr.fromBuffer(reader);
     const siloedNullifier = Fr.fromBuffer(reader);
     const index = toBigIntBE(reader.readBytes(32));
     const publicKey = Point.fromBuffer(reader);
@@ -73,7 +73,7 @@ export class IncomingNoteDao implements NoteData {
       noteTypeId,
       txHash,
       nonce,
-      innerNoteHash,
+      noteHash,
       siloedNullifier,
       index,
       publicKey,

package/src/database/kv_pxe_database.ts

@@ -14,6 +14,7 @@ import {
   type AztecKVStore,
   type AztecMap,
   type AztecMultiMap,
+  type AztecSet,
   type AztecSingleton,
 } from '@aztec/kv-store';
 import { contractArtifactFromBuffer, contractArtifactToBuffer } from '@aztec/types/abi';
@@ -36,10 +37,7 @@ export class KVPxeDatabase implements PxeDatabase {
   #notes: AztecMap<string, Buffer>;
   #nullifiedNotes: AztecMap<string, Buffer>;
   #nullifierToNoteId: AztecMap<string, string>;
-  #notesByContract: AztecMultiMap<string, string>;
-  #notesByStorageSlot: AztecMultiMap<string, string>;
-  #notesByTxHash: AztecMultiMap<string, string>;
-  #notesByIvpkM: AztecMultiMap<string, string>;
+
   #nullifiedNotesByContract: AztecMultiMap<string, string>;
   #nullifiedNotesByStorageSlot: AztecMultiMap<string, string>;
   #nullifiedNotesByTxHash: AztecMultiMap<string, string>;
@@ -57,6 +55,12 @@ export class KVPxeDatabase implements PxeDatabase {
   #outgoingNotesByTxHash: AztecMultiMap<string, string>;
   #outgoingNotesByOvpkM: AztecMultiMap<string, string>;
 
+  #scopes: AztecSet<string>;
+  #notesByContractAndScope: Map<string, AztecMultiMap<string, string>>;
+  #notesByStorageSlotAndScope: Map<string, AztecMultiMap<string, string>>;
+  #notesByTxHashAndScope: Map<string, AztecMultiMap<string, string>>;
+  #notesByIvpkMAndScope: Map<string, AztecMultiMap<string, string>>;
+
   constructor(private db: AztecKVStore) {
     this.#db = db;
 
@@ -76,11 +80,6 @@ export class KVPxeDatabase implements PxeDatabase {
     this.#nullifiedNotes = db.openMap('nullified_notes');
     this.#nullifierToNoteId = db.openMap('nullifier_to_note');
 
-    this.#notesByContract = db.openMultiMap('notes_by_contract');
-    this.#notesByStorageSlot = db.openMultiMap('notes_by_storage_slot');
-    this.#notesByTxHash = db.openMultiMap('notes_by_tx_hash');
-    this.#notesByIvpkM = db.openMultiMap('notes_by_ivpk_m');
-
     this.#nullifiedNotesByContract = db.openMultiMap('nullified_notes_by_contract');
     this.#nullifiedNotesByStorageSlot = db.openMultiMap('nullified_notes_by_storage_slot');
     this.#nullifiedNotesByTxHash = db.openMultiMap('nullified_notes_by_tx_hash');
@@ -94,6 +93,19 @@ export class KVPxeDatabase implements PxeDatabase {
     this.#outgoingNotesByStorageSlot = db.openMultiMap('outgoing_notes_by_storage_slot');
     this.#outgoingNotesByTxHash = db.openMultiMap('outgoing_notes_by_tx_hash');
     this.#outgoingNotesByOvpkM = db.openMultiMap('outgoing_notes_by_ovpk_m');
+
+    this.#scopes = db.openSet('scopes');
+    this.#notesByContractAndScope = new Map<string, AztecMultiMap<string, string>>();
+    this.#notesByStorageSlotAndScope = new Map<string, AztecMultiMap<string, string>>();
+    this.#notesByTxHashAndScope = new Map<string, AztecMultiMap<string, string>>();
+    this.#notesByIvpkMAndScope = new Map<string, AztecMultiMap<string, string>>();
+
+    for (const scope of this.#scopes.entries()) {
+      this.#notesByContractAndScope.set(scope, db.openMultiMap(`${scope}:notes_by_contract`));
+      this.#notesByStorageSlotAndScope.set(scope, db.openMultiMap(`${scope}:notes_by_storage_slot`));
+      this.#notesByTxHashAndScope.set(scope, db.openMultiMap(`${scope}:notes_by_tx_hash`));
+      this.#notesByIvpkMAndScope.set(scope, db.openMultiMap(`${scope}:notes_by_ivpk_m`));
+    }
   }
 
   public async getContract(
@@ -154,11 +166,19 @@ export class KVPxeDatabase implements PxeDatabase {
     return val?.map(b => Fr.fromBuffer(b));
   }
 
-  async addNote(note: IncomingNoteDao): Promise<void> {
-    await this.addNotes([note], []);
+  async addNote(note: IncomingNoteDao, scope?: AztecAddress): Promise<void> {
+    await this.addNotes([note], [], scope);
   }
 
-  addNotes(incomingNotes: IncomingNoteDao[], outgoingNotes: OutgoingNoteDao[]): Promise<void> {
+  async addNotes(
+    incomingNotes: IncomingNoteDao[],
+    outgoingNotes: OutgoingNoteDao[],
+    scope: AztecAddress = AztecAddress.ZERO,
+  ): Promise<void> {
+    if (!this.#scopes.has(scope.toString())) {
+      await this.#addScope(scope);
+    }
+
     return this.db.transaction(() => {
       for (const dao of incomingNotes) {
         // store notes by their index in the notes hash tree
@@ -168,10 +188,11 @@ export class KVPxeDatabase implements PxeDatabase {
         const noteIndex = toBufferBE(dao.index, 32).toString('hex');
         void this.#notes.set(noteIndex, dao.toBuffer());
         void this.#nullifierToNoteId.set(dao.siloedNullifier.toString(), noteIndex);
-        void this.#notesByContract.set(dao.contractAddress.toString(), noteIndex);
-        void this.#notesByStorageSlot.set(dao.storageSlot.toString(), noteIndex);
-        void this.#notesByTxHash.set(dao.txHash.toString(), noteIndex);
-        void this.#notesByIvpkM.set(dao.ivpkM.toString(), noteIndex);
+
+        void this.#notesByContractAndScope.get(scope.toString())!.set(dao.contractAddress.toString(), noteIndex);
+        void this.#notesByStorageSlotAndScope.get(scope.toString())!.set(dao.storageSlot.toString(), noteIndex);
+        void this.#notesByTxHashAndScope.get(scope.toString())!.set(dao.txHash.toString(), noteIndex);
+        void this.#notesByIvpkMAndScope.get(scope.toString())!.set(dao.ivpkM.toString(), noteIndex);
       }
 
       for (const dao of outgoingNotes) {
@@ -244,16 +265,31 @@ export class KVPxeDatabase implements PxeDatabase {
 
     const candidateNoteSources = [];
 
+    filter.scopes ??= [...this.#scopes.entries()].map(addressString => AztecAddress.fromString(addressString));
+
+    const activeNoteIdsPerScope: IterableIterator<string>[] = [];
+
+    for (const scope of new Set(filter.scopes)) {
+      const formattedScopeString = scope.toString();
+      if (!this.#scopes.has(formattedScopeString)) {
+        throw new Error('Trying to get incoming notes of an scope that is not in the PXE database');
+      }
+
+      activeNoteIdsPerScope.push(
+        publicKey
+          ? this.#notesByIvpkMAndScope.get(formattedScopeString)!.getValues(publicKey.toString())
+          : filter.txHash
+          ? this.#notesByTxHashAndScope.get(formattedScopeString)!.getValues(filter.txHash.toString())
+          : filter.contractAddress
+          ? this.#notesByContractAndScope.get(formattedScopeString)!.getValues(filter.contractAddress.toString())
+          : filter.storageSlot
+          ? this.#notesByStorageSlotAndScope.get(formattedScopeString)!.getValues(filter.storageSlot.toString())
+          : this.#notesByIvpkMAndScope.get(formattedScopeString)!.values(),
+      );
+    }
+
     candidateNoteSources.push({
-      ids: publicKey
-        ? this.#notesByIvpkM.getValues(publicKey.toString())
-        : filter.txHash
-        ? this.#notesByTxHash.getValues(filter.txHash.toString())
-        : filter.contractAddress
-        ? this.#notesByContract.getValues(filter.contractAddress.toString())
-        : filter.storageSlot
-        ? this.#notesByStorageSlot.getValues(filter.storageSlot.toString())
-        : this.#notes.keys(),
+      ids: new Set(activeNoteIdsPerScope.flatMap(iterableIterator => [...iterableIterator])),
       notes: this.#notes,
     });
 
@@ -358,7 +394,7 @@ export class KVPxeDatabase implements PxeDatabase {
     return Promise.resolve(notes);
   }
 
-  removeNullifiedNotes(nullifiers: Fr[], account: PublicKey): Promise<IncomingNoteDao[]> {
+  removeNullifiedNotes(nullifiers: Fr[], accountIvpkM: PublicKey): Promise<IncomingNoteDao[]> {
     if (nullifiers.length === 0) {
       return Promise.resolve([]);
     }
@@ -380,7 +416,7 @@ export class KVPxeDatabase implements PxeDatabase {
         }
 
         const note = IncomingNoteDao.fromBuffer(noteBuffer);
-        if (!note.ivpkM.equals(account)) {
+        if (!note.ivpkM.equals(accountIvpkM)) {
           // tried to nullify someone else's note
           continue;
         }
@@ -388,10 +424,13 @@ export class KVPxeDatabase implements PxeDatabase {
         nullifiedNotes.push(note);
 
         void this.#notes.delete(noteIndex);
-        void this.#notesByIvpkM.deleteValue(account.toString(), noteIndex);
-        void this.#notesByTxHash.deleteValue(note.txHash.toString(), noteIndex);
-        void this.#notesByContract.deleteValue(note.contractAddress.toString(), noteIndex);
-        void this.#notesByStorageSlot.deleteValue(note.storageSlot.toString(), noteIndex);
+
+        for (const scope in this.#scopes.entries()) {
+          void this.#notesByIvpkMAndScope.get(scope)!.deleteValue(accountIvpkM.toString(), noteIndex);
+          void this.#notesByTxHashAndScope.get(scope)!.deleteValue(note.txHash.toString(), noteIndex);
+          void this.#notesByContractAndScope.get(scope)!.deleteValue(note.contractAddress.toString(), noteIndex);
+          void this.#notesByStorageSlotAndScope.get(scope)!.deleteValue(note.storageSlot.toString(), noteIndex);
+        }
 
         void this.#nullifiedNotes.set(noteIndex, note.toBuffer());
         void this.#nullifiedNotesByContract.set(note.contractAddress.toString(), noteIndex);
@@ -440,6 +479,22 @@ export class KVPxeDatabase implements PxeDatabase {
     return Header.fromBuffer(headerBuffer);
   }
 
+  async #addScope(scope: AztecAddress): Promise<boolean> {
+    const scopeString = scope.toString();
+
+    if (this.#scopes.has(scopeString)) {
+      return false;
+    }
+
+    await this.#scopes.add(scopeString);
+    this.#notesByContractAndScope.set(scopeString, this.#db.openMultiMap(`${scopeString}:notes_by_contract`));
+    this.#notesByStorageSlotAndScope.set(scopeString, this.#db.openMultiMap(`${scopeString}:notes_by_storage_slot`));
+    this.#notesByTxHashAndScope.set(scopeString, this.#db.openMultiMap(`${scopeString}:notes_by_tx_hash`));
+    this.#notesByIvpkMAndScope.set(scopeString, this.#db.openMultiMap(`${scopeString}:notes_by_ivpk_m`));
+
+    return true;
+  }
+
   addCompleteAddress(completeAddress: CompleteAddress): Promise<boolean> {
     return this.#db.transaction(() => {
       const addressString = completeAddress.address.toString();

package/src/database/outgoing_note_dao.ts

@@ -22,10 +22,10 @@ export class OutgoingNoteDao {
     /** The nonce of the note. */
     public nonce: Fr,
     /**
-     * Inner note hash of the note. This is customizable by the app circuit.
-     * We can use this value to compute siloedNoteHash and uniqueSiloedNoteHash.
+     * A hash of the note. This is customizable by the app circuit.
+     * We can use this value to compute unique note hash and then siloed note hash.
      */
-    public innerNoteHash: Fr,
+    public noteHash: Fr,
     /** The location of the relevant note in the note hash tree. */
     public index: bigint,
     /** The public key with which the note was encrypted. */
@@ -40,7 +40,7 @@ export class OutgoingNoteDao {
       this.noteTypeId,
       this.txHash.buffer,
       this.nonce,
-      this.innerNoteHash,
+      this.noteHash,
       this.index,
       this.ovpkM,
     ]);
@@ -54,7 +54,7 @@ export class OutgoingNoteDao {
     const noteTypeId = reader.readObject(NoteSelector);
     const txHash = new TxHash(reader.readBytes(TxHash.SIZE));
     const nonce = Fr.fromBuffer(reader);
-    const innerNoteHash = Fr.fromBuffer(reader);
+    const noteHash = Fr.fromBuffer(reader);
     const index = toBigIntBE(reader.readBytes(32));
     const publicKey = Point.fromBuffer(reader);
 
@@ -65,7 +65,7 @@ export class OutgoingNoteDao {
       noteTypeId,
       txHash,
       nonce,
-      innerNoteHash,
+      noteHash,
       index,
       publicKey,
     );

package/src/database/pxe_database.ts

@@ -62,8 +62,10 @@ export interface PxeDatabase extends ContractArtifactDatabase, ContractInstanceD
   /**
    * Adds a note to DB.
    * @param note - The note to add.
+   * @param scope - The scope to add the note under. Currently optional.
+   * @remark - Will create a database for the scope if it does not already exist.
    */
-  addNote(note: IncomingNoteDao): Promise<void>;
+  addNote(note: IncomingNoteDao, scope?: AztecAddress): Promise<void>;
 
   /**
    * Adds a nullified note to DB.
@@ -78,8 +80,10 @@ export interface PxeDatabase extends ContractArtifactDatabase, ContractInstanceD
    *
    * @param incomingNotes - An array of notes which were decrypted as incoming.
    * @param outgoingNotes - An array of notes which were decrypted as outgoing.
+   * @param scope - The scope to add the notes under. Currently optional.
+   * @remark - Will create a database for the scope if it does not already exist.
    */
-  addNotes(incomingNotes: IncomingNoteDao[], outgoingNotes: OutgoingNoteDao[]): Promise<void>;
+  addNotes(incomingNotes: IncomingNoteDao[], outgoingNotes: OutgoingNoteDao[], scope?: AztecAddress): Promise<void>;
 
   /**
    * Add notes to the database that are intended for us, but we don't yet have the contract.

package/src/database/pxe_database_test_suite.ts

@@ -130,14 +130,19 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
 
       it.each(filteringTests)('stores notes in bulk and retrieves notes', async (getFilter, getExpected) => {
         await database.addNotes(notes, []);
-        await expect(database.getIncomingNotes(getFilter())).resolves.toEqual(getExpected());
+        const returnedNotes = await database.getIncomingNotes(getFilter());
+
+        expect(returnedNotes.sort()).toEqual(getExpected().sort());
       });
 
       it.each(filteringTests)('stores notes one by one and retrieves notes', async (getFilter, getExpected) => {
         for (const note of notes) {
           await database.addNote(note);
         }
-        await expect(database.getIncomingNotes(getFilter())).resolves.toEqual(getExpected());
+
+        const returnedNotes = await database.getIncomingNotes(getFilter());
+
+        expect(returnedNotes.sort()).toEqual(getExpected().sort());
       });
 
       it.each(filteringTests)('retrieves nullified notes', async (getFilter, getExpected) => {
@@ -196,6 +201,68 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
         // inserted combining active and nullified results.
         expect(result.sort()).toEqual([...notes].sort());
       });
+
+      it('stores notes one by one and retrieves notes with siloed account', async () => {
+        for (const note of notes.slice(0, 5)) {
+          await database.addNote(note, owners[0].address);
+        }
+
+        for (const note of notes.slice(5)) {
+          await database.addNote(note, owners[1].address);
+        }
+
+        const owner0IncomingNotes = await database.getIncomingNotes({
+          scopes: [owners[0].address],
+        });
+
+        expect(owner0IncomingNotes.sort()).toEqual(notes.slice(0, 5).sort());
+
+        const owner1IncomingNotes = await database.getIncomingNotes({
+          scopes: [owners[1].address],
+        });
+
+        expect(owner1IncomingNotes.sort()).toEqual(notes.slice(5).sort());
+
+        const bothOwnerIncomingNotes = await database.getIncomingNotes({
+          scopes: [owners[0].address, owners[1].address],
+        });
+
+        expect(bothOwnerIncomingNotes.sort()).toEqual(notes.sort());
+      });
+
+      it('a nullified note removes notes from all accounts in the pxe', async () => {
+        await database.addNote(notes[0], owners[0].address);
+        await database.addNote(notes[0], owners[1].address);
+
+        await expect(
+          database.getIncomingNotes({
+            scopes: [owners[0].address],
+          }),
+        ).resolves.toEqual([notes[0]]);
+        await expect(
+          database.getIncomingNotes({
+            scopes: [owners[1].address],
+          }),
+        ).resolves.toEqual([notes[0]]);
+
+        await expect(
+          database.removeNullifiedNotes(
+            [notes[0].siloedNullifier],
+            owners[0].publicKeys.masterIncomingViewingPublicKey,
+          ),
+        ).resolves.toEqual([notes[0]]);
+
+        await expect(
+          database.getIncomingNotes({
+            scopes: [owners[0].address],
+          }),
+        ).resolves.toEqual([]);
+        await expect(
+          database.getIncomingNotes({
+            scopes: [owners[1].address],
+          }),
+        ).resolves.toEqual([]);
+      });
     });
 
     describe('outgoing notes', () => {
@@ -264,7 +331,7 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
 
     describe('block header', () => {
       it('stores and retrieves the block header', async () => {
-        const header = makeHeader(randomInt(1000), INITIAL_L2_BLOCK_NUM);
+        const header = makeHeader(randomInt(1000), INITIAL_L2_BLOCK_NUM, 0 /** slot number */);
 
         await database.setHeader(header);
         expect(database.getHeader()).toEqual(header);

package/src/kernel_prover/{private_inputs_builders → hints}/build_private_kernel_reset_hints.ts

@@ -91,6 +91,7 @@ export async function buildPrivateKernelResetInputs(
   previousKernelData: PrivateKernelData,
   noteHashLeafIndexMap: Map<bigint, bigint>,
   noteHashNullifierCounterMap: Map<number, number>,
+  validationRequestsSplitCounter: number,
   oracle: ProvingDataOracle,
 ) {
   const publicInputs = previousKernelData.publicInputs;
@@ -181,6 +182,7 @@ export async function buildPrivateKernelResetInputs(
           noteHashReadRequestHints,
           nullifierReadRequestHints,
           keysHints,
+          validationRequestsSplitCounter,
         ).trimToSizes(
           hintSizes.NOTE_HASH_PENDING_AMOUNT,
           hintSizes.NOTE_HASH_SETTLED_AMOUNT,

package/src/kernel_prover/hints/index.ts

@@ -0,0 +1,2 @@
+export * from './build_private_kernel_reset_hints.js';
+export * from './needs_reset.js';

package/src/kernel_prover/hints/needs_reset.ts

@@ -0,0 +1,51 @@
+import {
+  MAX_KEY_VALIDATION_REQUESTS_PER_TX,
+  MAX_NOTE_ENCRYPTED_LOGS_PER_TX,
+  MAX_NOTE_HASHES_PER_TX,
+  MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
+  MAX_NULLIFIERS_PER_TX,
+  MAX_NULLIFIER_READ_REQUESTS_PER_TX,
+  type PrivateKernelCircuitPublicInputs,
+  getNonEmptyItems,
+} from '@aztec/circuits.js';
+import { type ExecutionResult } from '@aztec/simulator';
+
+export function needsReset(publicInputs: PrivateKernelCircuitPublicInputs, executionStack: ExecutionResult[]) {
+  const nextIteration = executionStack[executionStack.length - 1];
+  return (
+    getNonEmptyItems(nextIteration.callStackItem.publicInputs.noteHashes).length +
+      getNonEmptyItems(publicInputs.end.noteHashes).length >
+      MAX_NOTE_HASHES_PER_TX ||
+    getNonEmptyItems(nextIteration.callStackItem.publicInputs.nullifiers).length +
+      getNonEmptyItems(publicInputs.end.nullifiers).length >
+      MAX_NULLIFIERS_PER_TX ||
+    getNonEmptyItems(nextIteration.callStackItem.publicInputs.noteEncryptedLogsHashes).length +
+      getNonEmptyItems(publicInputs.end.noteEncryptedLogsHashes).length >
+      MAX_NOTE_ENCRYPTED_LOGS_PER_TX ||
+    getNonEmptyItems(nextIteration.callStackItem.publicInputs.noteHashReadRequests).length +
+      getNonEmptyItems(publicInputs.validationRequests.noteHashReadRequests).length >
+      MAX_NOTE_HASH_READ_REQUESTS_PER_TX ||
+    getNonEmptyItems(nextIteration.callStackItem.publicInputs.nullifierReadRequests).length +
+      getNonEmptyItems(publicInputs.validationRequests.nullifierReadRequests).length >
+      MAX_NULLIFIER_READ_REQUESTS_PER_TX ||
+    getNonEmptyItems(nextIteration.callStackItem.publicInputs.keyValidationRequestsAndGenerators).length +
+      getNonEmptyItems(publicInputs.validationRequests.scopedKeyValidationRequestsAndGenerators).length >
+      MAX_KEY_VALIDATION_REQUESTS_PER_TX
+  );
+}
+
+function hasTransientNullifier(publicInputs: PrivateKernelCircuitPublicInputs) {
+  const noteHashSet = new Set();
+  publicInputs.end.noteHashes.forEach(n => noteHashSet.add(n.noteHash.value.toBigInt()));
+  noteHashSet.delete(0n);
+  return publicInputs.end.nullifiers.some(n => noteHashSet.has(n.nullifiedNoteHash.toBigInt()));
+}
+
+export function somethingToReset(publicInputs: PrivateKernelCircuitPublicInputs) {
+  return (
+    getNonEmptyItems(publicInputs.validationRequests.noteHashReadRequests).length > 0 ||
+    getNonEmptyItems(publicInputs.validationRequests.nullifierReadRequests).length > 0 ||
+    getNonEmptyItems(publicInputs.validationRequests.scopedKeyValidationRequestsAndGenerators).length > 0 ||
+    hasTransientNullifier(publicInputs)
+  );
+}