@aztec/pxe 0.47.1 → 0.49.2

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

@@ -21,6 +21,7 @@ import {
   buildNoteHashReadRequestHints,
   buildNullifierReadRequestHints,
   buildTransientDataHints,
+  countAccumulatedItems,
   getNonEmptyItems,
 } from '@aztec/circuits.js';
 import { makeTuple } from '@aztec/foundation/array';
@@ -68,7 +69,9 @@ async function getMasterSecretKeysAndAppKeyGenerators(
   keyValidationRequests: Tuple<ScopedKeyValidationRequestAndGenerator, typeof MAX_KEY_VALIDATION_REQUESTS_PER_TX>,
   oracle: ProvingDataOracle,
 ) {
-  const keysHints = makeTuple(MAX_KEY_VALIDATION_REQUESTS_PER_TX, KeyValidationHint.empty);
+  const keysHints = makeTuple(MAX_KEY_VALIDATION_REQUESTS_PER_TX, () =>
+    KeyValidationHint.nada(MAX_KEY_VALIDATION_REQUESTS_PER_TX),
+  );
 
   let keyIndex = 0;
   for (let i = 0; i < keyValidationRequests.length; ++i) {
@@ -91,6 +94,8 @@ export async function buildPrivateKernelResetInputs(
   previousKernelData: PrivateKernelData,
   noteHashLeafIndexMap: Map<bigint, bigint>,
   noteHashNullifierCounterMap: Map<number, number>,
+  validationRequestsSplitCounter: number,
+  shouldSilo: boolean,
   oracle: ProvingDataOracle,
 ) {
   const publicInputs = previousKernelData.publicInputs;
@@ -153,9 +158,11 @@ export async function buildPrivateKernelResetInputs(
     executionResult => executionResult.callStackItem.publicInputs.nullifierReadRequests,
   );
 
-  const [transientNullifierIndexesForNoteHashes, transientNoteHashIndexesForNullifiers] = buildTransientDataHints(
-    publicInputs.end.noteHashes,
-    publicInputs.end.nullifiers,
+  const noteHashes = publicInputs.end.noteHashes;
+  const nullifiers = publicInputs.end.nullifiers;
+  const { numTransientData, hints: transientDataIndexHints } = buildTransientDataHints(
+    noteHashes,
+    nullifiers,
     futureNoteHashReads,
     futureNullifierReads,
     noteHashNullifierCounterMap,
@@ -163,30 +170,47 @@ export async function buildPrivateKernelResetInputs(
     MAX_NULLIFIERS_PER_TX,
   );
 
+  const remainingNoteHashes = countAccumulatedItems(noteHashes) - numTransientData;
+
+  const remainingNullifiers = countAccumulatedItems(nullifiers) - numTransientData;
+
+  const numEncryptedLogHashes = countAccumulatedItems(publicInputs.end.encryptedLogsHashes);
+
   let privateInputs;
 
   for (const [sizeTag, hintSizes] of Object.entries(PRIVATE_RESET_VARIANTS)) {
+    const noSiloing =
+      !hintSizes.NOTE_HASH_SILOING_AMOUNT &&
+      !hintSizes.NULLIFIER_SILOING_AMOUNT &&
+      !hintSizes.ENCRYPTED_LOG_SILOING_AMOUNT;
+    const enoughSiloing =
+      hintSizes.NOTE_HASH_SILOING_AMOUNT >= remainingNoteHashes &&
+      hintSizes.NULLIFIER_SILOING_AMOUNT >= remainingNullifiers &&
+      hintSizes.ENCRYPTED_LOG_SILOING_AMOUNT >= numEncryptedLogHashes;
     if (
       hintSizes.NOTE_HASH_PENDING_AMOUNT >= noteHashPendingReadHints &&
       hintSizes.NOTE_HASH_SETTLED_AMOUNT >= noteHashSettledReadHints &&
       hintSizes.NULLIFIER_PENDING_AMOUNT >= nullifierPendingReadHints &&
       hintSizes.NULLIFIER_SETTLED_AMOUNT >= nullifierSettledReadHints &&
-      hintSizes.NULLIFIER_KEYS >= keysCount
+      hintSizes.NULLIFIER_KEYS >= keysCount &&
+      hintSizes.TRANSIENT_DATA_AMOUNT >= numTransientData &&
+      ((!shouldSilo && noSiloing) || (shouldSilo && enoughSiloing))
     ) {
       privateInputs = new PrivateKernelResetCircuitPrivateInputs(
         previousKernelData,
         new PrivateKernelResetHints(
-          transientNullifierIndexesForNoteHashes,
-          transientNoteHashIndexesForNullifiers,
           noteHashReadRequestHints,
           nullifierReadRequestHints,
           keysHints,
+          transientDataIndexHints,
+          validationRequestsSplitCounter,
         ).trimToSizes(
           hintSizes.NOTE_HASH_PENDING_AMOUNT,
           hintSizes.NOTE_HASH_SETTLED_AMOUNT,
           hintSizes.NULLIFIER_PENDING_AMOUNT,
           hintSizes.NULLIFIER_SETTLED_AMOUNT,
           hintSizes.NULLIFIER_KEYS,
+          hintSizes.TRANSIENT_DATA_AMOUNT,
         ),
         sizeTag,
       );

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,54 @@
+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,
+  countAccumulatedItems,
+} from '@aztec/circuits.js';
+import { type ExecutionResult } from '@aztec/simulator';
+
+export function needsReset(publicInputs: PrivateKernelCircuitPublicInputs, executionStack: ExecutionResult[]) {
+  const nextIteration = executionStack[executionStack.length - 1];
+  return (
+    countAccumulatedItems(nextIteration.callStackItem.publicInputs.noteHashes) +
+      countAccumulatedItems(publicInputs.end.noteHashes) >
+      MAX_NOTE_HASHES_PER_TX ||
+    countAccumulatedItems(nextIteration.callStackItem.publicInputs.nullifiers) +
+      countAccumulatedItems(publicInputs.end.nullifiers) >
+      MAX_NULLIFIERS_PER_TX ||
+    countAccumulatedItems(nextIteration.callStackItem.publicInputs.noteEncryptedLogsHashes) +
+      countAccumulatedItems(publicInputs.end.noteEncryptedLogsHashes) >
+      MAX_NOTE_ENCRYPTED_LOGS_PER_TX ||
+    countAccumulatedItems(nextIteration.callStackItem.publicInputs.noteHashReadRequests) +
+      countAccumulatedItems(publicInputs.validationRequests.noteHashReadRequests) >
+      MAX_NOTE_HASH_READ_REQUESTS_PER_TX ||
+    countAccumulatedItems(nextIteration.callStackItem.publicInputs.nullifierReadRequests) +
+      countAccumulatedItems(publicInputs.validationRequests.nullifierReadRequests) >
+      MAX_NULLIFIER_READ_REQUESTS_PER_TX ||
+    countAccumulatedItems(nextIteration.callStackItem.publicInputs.keyValidationRequestsAndGenerators) +
+      countAccumulatedItems(publicInputs.validationRequests.scopedKeyValidationRequestsAndGenerators) >
+      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 needsFinalReset(publicInputs: PrivateKernelCircuitPublicInputs) {
+  return (
+    countAccumulatedItems(publicInputs.end.noteHashes) > 0 ||
+    countAccumulatedItems(publicInputs.end.nullifiers) > 0 ||
+    countAccumulatedItems(publicInputs.end.encryptedLogsHashes) > 0 ||
+    countAccumulatedItems(publicInputs.validationRequests.noteHashReadRequests) > 0 ||
+    countAccumulatedItems(publicInputs.validationRequests.nullifierReadRequests) > 0 ||
+    countAccumulatedItems(publicInputs.validationRequests.scopedKeyValidationRequestsAndGenerators) > 0 ||
+    hasTransientNullifier(publicInputs)
+  );
+}

package/src/kernel_prover/kernel_prover.ts

@@ -1,12 +1,6 @@
 import { type PrivateKernelProver, type PrivateKernelSimulateOutput } from '@aztec/circuit-types';
 import {
   Fr,
-  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,
   PrivateCallData,
   PrivateKernelCircuitPublicInputs,
   PrivateKernelData,
@@ -17,7 +11,6 @@ import {
   type TxRequest,
   VK_TREE_HEIGHT,
   VerificationKeyAsFields,
-  getNonEmptyItems,
 } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { assertLength } from '@aztec/foundation/serialize';
@@ -27,11 +20,18 @@ import {
   PrivateResetTagToArtifactName,
   getVKTreeRoot,
 } from '@aztec/noir-protocol-circuits-types';
-import { type ExecutionResult, collectNoteHashLeafIndexMap, collectNullifiedNoteHashCounters } from '@aztec/simulator';
+import {
+  type ExecutionResult,
+  collectEnqueuedPublicFunctionCalls,
+  collectNoteHashLeafIndexMap,
+  collectNoteHashNullifierCounterMap,
+  collectPublicTeardownFunctionCall,
+  getFinalMinRevertibleSideEffectCounter,
+} from '@aztec/simulator';
 
 import { type WitnessMap } from '@noir-lang/types';
 
-import { buildPrivateKernelResetInputs } from './private_inputs_builders/index.js';
+import { buildPrivateKernelResetInputs, needsFinalReset, needsReset } from './hints/index.js';
 import { type ProvingDataOracle } from './proving_data_oracle.js';
 
 const NULL_PROVE_OUTPUT: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs> = {
@@ -71,18 +71,24 @@ export class KernelProver {
     let output = NULL_PROVE_OUTPUT;
 
     const noteHashLeafIndexMap = collectNoteHashLeafIndexMap(executionResult);
-    const noteHashNullifierCounterMap = collectNullifiedNoteHashCounters(executionResult);
+    const noteHashNullifierCounterMap = collectNoteHashNullifierCounterMap(executionResult);
+    const enqueuedPublicFunctions = collectEnqueuedPublicFunctionCalls(executionResult);
+    const hasPublicCalls =
+      enqueuedPublicFunctions.length > 0 || !collectPublicTeardownFunctionCall(executionResult).isEmpty();
+    const validationRequestsSplitCounter = hasPublicCalls ? getFinalMinRevertibleSideEffectCounter(executionResult) : 0;
     // vector of gzipped bincode acirs
     const acirs: Buffer[] = [];
     const witnessStack: WitnessMap[] = [];
 
     while (executionStack.length) {
-      if (!firstIteration && this.needsReset(executionStack, output)) {
+      if (!firstIteration && needsReset(output.publicInputs, executionStack)) {
         const resetInputs = await this.getPrivateKernelResetInputs(
           executionStack,
           output,
           noteHashLeafIndexMap,
           noteHashNullifierCounterMap,
+          validationRequestsSplitCounter,
+          false,
         );
         output = await this.proofCreator.simulateProofReset(resetInputs);
         // TODO(#7368) consider refactoring this redundant bytecode pushing
@@ -130,12 +136,14 @@ export class KernelProver {
       firstIteration = false;
     }
 
-    if (this.somethingToReset(output)) {
+    if (needsFinalReset(output.publicInputs)) {
       const resetInputs = await this.getPrivateKernelResetInputs(
         executionStack,
         output,
         noteHashLeafIndexMap,
         noteHashNullifierCounterMap,
+        validationRequestsSplitCounter,
+        true,
       );
       output = await this.proofCreator.simulateProofReset(resetInputs);
       // TODO(#7368) consider refactoring this redundant bytecode pushing
@@ -176,47 +184,13 @@ export class KernelProver {
     return tailOutput;
   }
 
-  private needsReset(
-    executionStack: ExecutionResult[],
-    output: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>,
-  ) {
-    const nextIteration = executionStack[executionStack.length - 1];
-    return (
-      getNonEmptyItems(nextIteration.callStackItem.publicInputs.noteHashes).length +
-        getNonEmptyItems(output.publicInputs.end.noteHashes).length >
-        MAX_NOTE_HASHES_PER_TX ||
-      getNonEmptyItems(nextIteration.callStackItem.publicInputs.nullifiers).length +
-        getNonEmptyItems(output.publicInputs.end.nullifiers).length >
-        MAX_NULLIFIERS_PER_TX ||
-      getNonEmptyItems(nextIteration.callStackItem.publicInputs.noteEncryptedLogsHashes).length +
-        getNonEmptyItems(output.publicInputs.end.noteEncryptedLogsHashes).length >
-        MAX_NOTE_ENCRYPTED_LOGS_PER_TX ||
-      getNonEmptyItems(nextIteration.callStackItem.publicInputs.noteHashReadRequests).length +
-        getNonEmptyItems(output.publicInputs.validationRequests.noteHashReadRequests).length >
-        MAX_NOTE_HASH_READ_REQUESTS_PER_TX ||
-      getNonEmptyItems(nextIteration.callStackItem.publicInputs.nullifierReadRequests).length +
-        getNonEmptyItems(output.publicInputs.validationRequests.nullifierReadRequests).length >
-        MAX_NULLIFIER_READ_REQUESTS_PER_TX ||
-      getNonEmptyItems(nextIteration.callStackItem.publicInputs.keyValidationRequestsAndGenerators).length +
-        getNonEmptyItems(output.publicInputs.validationRequests.scopedKeyValidationRequestsAndGenerators).length >
-        MAX_KEY_VALIDATION_REQUESTS_PER_TX
-    );
-  }
-
-  private somethingToReset(output: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>) {
-    return (
-      getNonEmptyItems(output.publicInputs.validationRequests.noteHashReadRequests).length > 0 ||
-      getNonEmptyItems(output.publicInputs.validationRequests.nullifierReadRequests).length > 0 ||
-      getNonEmptyItems(output.publicInputs.validationRequests.scopedKeyValidationRequestsAndGenerators).length > 0 ||
-      output.publicInputs.end.nullifiers.find(nullifier => !nullifier.nullifiedNoteHash.equals(Fr.zero()))
-    );
-  }
-
   private async getPrivateKernelResetInputs(
     executionStack: ExecutionResult[],
     output: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>,
     noteHashLeafIndexMap: Map<bigint, bigint>,
     noteHashNullifierCounterMap: Map<number, number>,
+    validationRequestsSplitCounter: number,
+    shouldSilo: boolean,
   ) {
     const previousVkMembershipWitness = await this.oracle.getVkMembershipWitness(output.verificationKey);
     const previousKernelData = new PrivateKernelData(
@@ -231,6 +205,8 @@ export class KernelProver {
       previousKernelData,
       noteHashLeafIndexMap,
       noteHashNullifierCounterMap,
+      validationRequestsSplitCounter,
+      shouldSilo,
       this.oracle,
     );
   }

package/src/note_processor/note_processor.ts

@@ -227,7 +227,7 @@ export class NoteProcessor {
     const incomingNotes = blocksAndNotes.flatMap(b => b.incomingNotes);
     const outgoingNotes = blocksAndNotes.flatMap(b => b.outgoingNotes);
     if (incomingNotes.length || outgoingNotes.length) {
-      await this.db.addNotes(incomingNotes, outgoingNotes);
+      await this.db.addNotes(incomingNotes, outgoingNotes, this.account);
       incomingNotes.forEach(noteDao => {
         this.log.verbose(
           `Added incoming note for contract ${noteDao.contractAddress} at slot ${

package/src/note_processor/produce_note_dao.ts

@@ -51,7 +51,7 @@ export async function produceNoteDaos(
 
   try {
     if (ivpkM) {
-      const { noteHashIndex, nonce, innerNoteHash, siloedNullifier } = await findNoteIndexAndNullifier(
+      const { noteHashIndex, nonce, noteHash, siloedNullifier } = await findNoteIndexAndNullifier(
         simulator,
         noteHashes,
         txHash,
@@ -69,7 +69,7 @@ export async function produceNoteDaos(
         payload.noteTypeId,
         txHash,
         nonce,
-        innerNoteHash,
+        noteHash,
         siloedNullifier,
         index,
         ivpkM,
@@ -108,12 +108,12 @@ export async function produceNoteDaos(
           payload.noteTypeId,
           txHash,
           incomingNote.nonce,
-          incomingNote.innerNoteHash,
+          incomingNote.noteHash,
           incomingNote.index,
           ovpkM,
         );
       } else {
-        const { noteHashIndex, nonce, innerNoteHash } = await findNoteIndexAndNullifier(
+        const { noteHashIndex, nonce, noteHash } = await findNoteIndexAndNullifier(
           simulator,
           noteHashes,
           txHash,
@@ -130,7 +130,7 @@ export async function produceNoteDaos(
           payload.noteTypeId,
           txHash,
           nonce,
-          innerNoteHash,
+          noteHash,
           index,
           ovpkM,
         );
@@ -170,7 +170,7 @@ export async function produceNoteDaos(
  * @dev Finds the index in the note hash tree by computing the note hash with different nonce and see which hash for
  * the current tx matches this value.
  * @remarks This method assists in identifying spent notes in the note hash tree.
- * @param noteHashes - Note hashes in the tx. One of them should correspond to the note we are looking for
+ * @param siloedNoteHashes - Note hashes in the tx. One of them should correspond to the note we are looking for
  * @param txHash - Hash of a tx the note was emitted in.
  * @param l1NotePayload - The note payload.
  * @param excludedIndices - Indices that have been assigned a note in the same tx. Notes in a tx can have the same
@@ -181,7 +181,7 @@ export async function produceNoteDaos(
  */
 async function findNoteIndexAndNullifier(
   simulator: AcirSimulator,
-  noteHashes: Fr[],
+  siloedNoteHashes: Fr[],
   txHash: TxHash,
   { contractAddress, storageSlot, noteTypeId, note }: L1NotePayload,
   excludedIndices: Set<number>,
@@ -189,23 +189,23 @@ async function findNoteIndexAndNullifier(
 ) {
   let noteHashIndex = 0;
   let nonce: Fr | undefined;
-  let innerNoteHash: Fr | undefined;
+  let noteHash: Fr | undefined;
   let siloedNoteHash: Fr | undefined;
   let innerNullifier: Fr | undefined;
   const firstNullifier = Fr.fromBuffer(txHash.toBuffer());
 
-  for (; noteHashIndex < noteHashes.length; ++noteHashIndex) {
+  for (; noteHashIndex < siloedNoteHashes.length; ++noteHashIndex) {
     if (excludedIndices.has(noteHashIndex)) {
       continue;
     }
 
-    const noteHash = noteHashes[noteHashIndex];
-    if (noteHash.equals(Fr.ZERO)) {
+    const siloedNoteHashFromTxEffect = siloedNoteHashes[noteHashIndex];
+    if (siloedNoteHashFromTxEffect.equals(Fr.ZERO)) {
       break;
     }
 
     const expectedNonce = computeNoteHashNonce(firstNullifier, noteHashIndex);
-    ({ innerNoteHash, siloedNoteHash, innerNullifier } = await simulator.computeNoteHashAndOptionallyANullifier(
+    ({ noteHash, siloedNoteHash, innerNullifier } = await simulator.computeNoteHashAndOptionallyANullifier(
       contractAddress,
       expectedNonce,
       storageSlot,
@@ -214,7 +214,7 @@ async function findNoteIndexAndNullifier(
       note,
     ));
 
-    if (noteHash.equals(siloedNoteHash)) {
+    if (siloedNoteHashFromTxEffect.equals(siloedNoteHash)) {
       nonce = expectedNonce;
       break;
     }
@@ -229,7 +229,7 @@ async function findNoteIndexAndNullifier(
   return {
     noteHashIndex,
     nonce,
-    innerNoteHash: innerNoteHash!,
+    noteHash: noteHash!,
     siloedNullifier: siloNullifier(contractAddress, innerNullifier!),
   };
 }

package/src/pxe_http/pxe_http_server.ts

@@ -16,12 +16,14 @@ import {
   TxHash,
   TxReceipt,
   UnencryptedL2BlockL2Logs,
+  UniqueNote,
 } from '@aztec/circuit-types';
 import { FunctionSelector } from '@aztec/circuits.js';
 import { NoteSelector } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr, GrumpkinScalar, Point } from '@aztec/foundation/fields';
+import { BaseHashType } from '@aztec/foundation/hash';
 import { JsonRpcServer, createNamespacedJsonRpcServer } from '@aztec/foundation/json-rpc/server';
 
 import http from 'http';
@@ -40,12 +42,14 @@ export function createPXERpcServer(pxeService: PXE): JsonRpcServer {
       ExtendedUnencryptedL2Log,
       FunctionSelector,
       TxHash,
+      BaseHashType,
       EthAddress,
       Point,
       Fr,
       GrumpkinScalar,
       Note,
       ExtendedNote,
+      UniqueNote,
       AuthWitness,
       L2Block,
       TxEffect,

package/src/pxe_service/create_pxe_service.ts

@@ -7,7 +7,7 @@ import { AztecLmdbStore } from '@aztec/kv-store/lmdb';
 import { initStoreForRollup } from '@aztec/kv-store/utils';
 import { getCanonicalAuthRegistry } from '@aztec/protocol-contracts/auth-registry';
 import { getCanonicalClassRegisterer } from '@aztec/protocol-contracts/class-registerer';
-import { getCanonicalGasToken } from '@aztec/protocol-contracts/gas-token';
+import { getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
 import { getCanonicalInstanceDeployer } from '@aztec/protocol-contracts/instance-deployer';
 import { getCanonicalKeyRegistry } from '@aztec/protocol-contracts/key-registry';
 import { getCanonicalMultiCallEntrypointContract } from '@aztec/protocol-contracts/multi-call-entrypoint';
@@ -57,6 +57,7 @@ export async function createPXEService(
       : new BBNativePrivateKernelProver(
           config.bbBinaryPath!,
           config.bbWorkingDirectory!,
+          !!config.bbSkipCleanup,
           createDebugLogger('aztec:pxe:bb-native-prover' + (logSuffix ? `:${logSuffix}` : '')),
         );
   }
@@ -66,7 +67,7 @@ export async function createPXEService(
     getCanonicalClassRegisterer(),
     getCanonicalInstanceDeployer(),
     getCanonicalMultiCallEntrypointContract(),
-    getCanonicalGasToken(),
+    getCanonicalFeeJuice(),
     getCanonicalKeyRegistry(),
     getCanonicalAuthRegistry(),
   ]) {