@aztec/pxe 0.66.0 → 0.67.0

package/src/database/outgoing_note_dao.ts

@@ -71,7 +71,7 @@ export class OutgoingNoteDao {
       this.noteTypeId,
       this.txHash.buffer,
       this.l2BlockNumber,
-      Fr.fromString(this.l2BlockHash),
+      Fr.fromHexString(this.l2BlockHash),
       this.nonce,
       this.noteHash,
       this.index,

package/src/database/pxe_database.ts

@@ -1,8 +1,8 @@
-import { type InBlock, type IncomingNotesFilter, type OutgoingNotesFilter } from '@aztec/circuit-types';
+import { type InBlock, type IncomingNotesFilter } from '@aztec/circuit-types';
 import {
+  type BlockHeader,
   type CompleteAddress,
   type ContractInstanceWithAddress,
-  type Header,
   type IndexedTaggingSecret,
   type PublicKey,
 } from '@aztec/circuits.js';
@@ -13,7 +13,6 @@ import { type Fr } from '@aztec/foundation/fields';
 import { type ContractArtifactDatabase } from './contracts/contract_artifact_db.js';
 import { type ContractInstanceDatabase } from './contracts/contract_instance_db.js';
 import { type IncomingNoteDao } from './incoming_note_dao.js';
-import { type OutgoingNoteDao } from './outgoing_note_dao.js';
 
 /**
  * A database interface that provides methods for retrieving, adding, and removing transactional data related to Aztec
@@ -57,12 +56,6 @@ export interface PxeDatabase extends ContractArtifactDatabase, ContractInstanceD
    */
   getIncomingNotes(filter: IncomingNotesFilter): Promise<IncomingNoteDao[]>;
 
-  /**
-   * Gets outgoing notes.
-   * @returns The outgoing notes.
-   */
-  getOutgoingNotes(filter: OutgoingNotesFilter): Promise<OutgoingNoteDao[]>;
-
   /**
    * Adds a note to DB.
    * @param note - The note to add.
@@ -83,11 +76,10 @@ export interface PxeDatabase extends ContractArtifactDatabase, ContractInstanceD
    * which can improve performance when dealing with large numbers of transactions.
    *
    * @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[], scope?: AztecAddress): Promise<void>;
+  addNotes(incomingNotes: IncomingNoteDao[], scope?: AztecAddress): Promise<void>;
 
   /**
    * Remove nullified notes associated with the given account and nullifiers.
@@ -102,7 +94,7 @@ export interface PxeDatabase extends ContractArtifactDatabase, ContractInstanceD
    * Gets the most recently processed block number.
    * @returns The most recently processed block number or undefined if never synched.
    */
-  getBlockNumber(): number | undefined;
+  getBlockNumber(): Promise<number | undefined>;
 
   /**
    * Retrieve the stored Block Header from the database.
@@ -115,7 +107,7 @@ export interface PxeDatabase extends ContractArtifactDatabase, ContractInstanceD
    * @returns The Block Header.
    * @throws If no block have been processed yet.
    */
-  getHeader(): Header;
+  getBlockHeader(): Promise<BlockHeader>;
 
   /**
    * Set the latest Block Header.
@@ -124,7 +116,7 @@ export interface PxeDatabase extends ContractArtifactDatabase, ContractInstanceD
    * @param header - An object containing the most recent block header.
    * @returns A Promise that resolves when the hash has been successfully updated in the database.
    */
-  setHeader(header: Header): Promise<void>;
+  setHeader(header: BlockHeader): Promise<void>;
 
   /**
    * Adds contact address to the database.
@@ -137,7 +129,7 @@ export interface PxeDatabase extends ContractArtifactDatabase, ContractInstanceD
    * Retrieves the list of contact addresses in the address book.
    * @returns An array of Aztec addresses.
    */
-  getContactAddresses(): AztecAddress[];
+  getContactAddresses(): Promise<AztecAddress[]>;
 
   /**
    * Removes a contact address from the database.
@@ -168,19 +160,6 @@ export interface PxeDatabase extends ContractArtifactDatabase, ContractInstanceD
    */
   getCompleteAddresses(): Promise<CompleteAddress[]>;
 
-  /**
-   * Updates up to which block number we have processed notes for a given public key.
-   * @param account - The account to set the synched block number for.
-   * @param blockNumber - The block number to set.
-   */
-  setSynchedBlockNumberForAccount(account: AztecAddress, blockNumber: number): Promise<void>;
-
-  /**
-   * Get the synched block number for a given public key.
-   * @param account - The account to get the synched block number for.
-   */
-  getSynchedBlockNumberForAccount(account: AztecAddress): number | undefined;
-
   /**
    * Returns the estimated size in bytes of this db.
    * @returns The estimated size in bytes of this db.

package/src/database/pxe_database_test_suite.ts

@@ -1,4 +1,4 @@
-import { type IncomingNotesFilter, NoteStatus, type OutgoingNotesFilter, randomTxHash } from '@aztec/circuit-types';
+import { type IncomingNotesFilter, NoteStatus, randomTxHash } from '@aztec/circuit-types';
 import {
   AztecAddress,
   CompleteAddress,
@@ -14,7 +14,6 @@ import { BenchmarkingContractArtifact } from '@aztec/noir-contracts.js/Benchmark
 import { TestContractArtifact } from '@aztec/noir-contracts.js/Test';
 
 import { IncomingNoteDao } from './incoming_note_dao.js';
-import { OutgoingNoteDao } from './outgoing_note_dao.js';
 import { type PxeDatabase } from './pxe_database.js';
 
 /**
@@ -135,7 +134,7 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       });
 
       it.each(filteringTests)('stores notes in bulk and retrieves notes', async (getFilter, getExpected) => {
-        await database.addNotes(notes, []);
+        await database.addNotes(notes);
         const returnedNotes = await database.getIncomingNotes(getFilter());
 
         expect(returnedNotes.sort()).toEqual(getExpected().sort());
@@ -152,7 +151,7 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       });
 
       it.each(filteringTests)('retrieves nullified notes', async (getFilter, getExpected) => {
-        await database.addNotes(notes, []);
+        await database.addNotes(notes);
 
         // Nullify all notes and use the same filter as other test cases
         for (const owner of owners) {
@@ -173,7 +172,7 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       });
 
       it('skips nullified notes by default or when requesting active', async () => {
-        await database.addNotes(notes, []);
+        await database.addNotes(notes);
 
         const notesToNullify = notes.filter(note => note.addressPoint.equals(owners[0].address.toAddressPoint()));
         const nullifiers = notesToNullify.map(note => ({
@@ -194,7 +193,7 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
 
       it('handles note unnullification', async () => {
         await database.setHeader(makeHeader(randomInt(1000), 100, 0 /** slot number */));
-        await database.addNotes(notes, []);
+        await database.addNotes(notes);
 
         const notesToNullify = notes.filter(note => note.addressPoint.equals(owners[0].address.toAddressPoint()));
         const nullifiers = notesToNullify.map(note => ({
@@ -213,7 +212,7 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       });
 
       it('returns active and nullified notes when requesting either', async () => {
-        await database.addNotes(notes, []);
+        await database.addNotes(notes);
 
         const notesToNullify = notes.filter(note => note.addressPoint.equals(owners[0].address.toAddressPoint()));
         const nullifiers = notesToNullify.map(note => ({
@@ -303,7 +302,7 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       });
 
       it('removes notes after a given block', async () => {
-        await database.addNotes(notes, [], owners[0].address);
+        await database.addNotes(notes, owners[0].address);
 
         await database.removeNotesAfter(5);
         const result = await database.getIncomingNotes({ scopes: [owners[0].address] });
@@ -311,80 +310,16 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       });
     });
 
-    describe('outgoing notes', () => {
-      let owners: CompleteAddress[];
-      let contractAddresses: AztecAddress[];
-      let storageSlots: Fr[];
-      let notes: OutgoingNoteDao[];
-
-      const filteringTests: [() => OutgoingNotesFilter, () => OutgoingNoteDao[]][] = [
-        [() => ({}), () => notes],
-
-        [
-          () => ({ contractAddress: contractAddresses[0] }),
-          () => notes.filter(note => note.contractAddress.equals(contractAddresses[0])),
-        ],
-        [() => ({ contractAddress: AztecAddress.random() }), () => []],
-
-        [
-          () => ({ storageSlot: storageSlots[0] }),
-          () => notes.filter(note => note.storageSlot.equals(storageSlots[0])),
-        ],
-        [() => ({ storageSlot: Fr.random() }), () => []],
-
-        [() => ({ txHash: notes[0].txHash }), () => [notes[0]]],
-        [() => ({ txHash: randomTxHash() }), () => []],
-
-        [
-          () => ({ owner: owners[0].address }),
-          () => notes.filter(note => note.ovpkM.equals(owners[0].publicKeys.masterOutgoingViewingPublicKey)),
-        ],
-
-        [
-          () => ({ contractAddress: contractAddresses[0], storageSlot: storageSlots[0] }),
-          () =>
-            notes.filter(
-              note => note.contractAddress.equals(contractAddresses[0]) && note.storageSlot.equals(storageSlots[0]),
-            ),
-        ],
-        [() => ({ contractAddress: contractAddresses[0], storageSlot: storageSlots[1] }), () => []],
-      ];
-
-      beforeEach(async () => {
-        owners = Array.from({ length: 2 }).map(() => CompleteAddress.random());
-        contractAddresses = Array.from({ length: 2 }).map(() => AztecAddress.random());
-        storageSlots = Array.from({ length: 2 }).map(() => Fr.random());
-
-        notes = Array.from({ length: 10 }).map((_, i) =>
-          OutgoingNoteDao.random({
-            contractAddress: contractAddresses[i % contractAddresses.length],
-            storageSlot: storageSlots[i % storageSlots.length],
-            ovpkM: owners[i % owners.length].publicKeys.masterOutgoingViewingPublicKey,
-            index: BigInt(i),
-          }),
-        );
-
-        for (const owner of owners) {
-          await database.addCompleteAddress(owner);
-        }
-      });
-
-      it.each(filteringTests)('stores notes in bulk and retrieves notes', async (getFilter, getExpected) => {
-        await database.addNotes([], notes);
-        await expect(database.getOutgoingNotes(getFilter())).resolves.toEqual(getExpected());
-      });
-    });
-
     describe('block header', () => {
       it('stores and retrieves the block header', async () => {
         const header = makeHeader(randomInt(1000), INITIAL_L2_BLOCK_NUM, 0 /** slot number */);
 
         await database.setHeader(header);
-        expect(database.getHeader()).toEqual(header);
+        await expect(database.getBlockHeader()).resolves.toEqual(header);
       });
 
-      it('rejects getting header if no block set', () => {
-        expect(() => database.getHeader()).toThrow();
+      it('rejects getting header if no block set', async () => {
+        await expect(() => database.getBlockHeader()).rejects.toThrow();
       });
     });
 
@@ -423,6 +358,16 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
         expect(result).toEqual(expect.arrayContaining(addresses));
       });
 
+      it('returns a single address', async () => {
+        const addresses = Array.from({ length: 10 }).map(() => CompleteAddress.random());
+        for (const address of addresses) {
+          await database.addCompleteAddress(address);
+        }
+
+        const result = await database.getCompleteAddress(addresses[3].address);
+        expect(result).toEqual(addresses[3]);
+      });
+
       it("returns an empty array if it doesn't have addresses", async () => {
         expect(await database.getCompleteAddresses()).toEqual([]);
       });

package/src/index.ts

@@ -1,6 +1,7 @@
 export * from './pxe_service/index.js';
 export * from './pxe_http/index.js';
 export * from './config/index.js';
+export * from './utils/create_pxe_service.js';
 
 export { Tx, TxHash } from '@aztec/circuit-types';
 
@@ -12,3 +13,4 @@ export * from '@aztec/key-store';
 export * from './database/index.js';
 export { ContractDataOracle } from './contract_data_oracle/index.js';
 export { PrivateFunctionsTree } from './contract_data_oracle/private_functions_tree.js';
+export { SimulatorOracle } from './simulator_oracle/index.js';

package/src/kernel_oracle/index.ts

@@ -12,7 +12,7 @@ import {
   computeContractClassIdPreimage,
   computeSaltedInitializationHash,
 } from '@aztec/circuits.js';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 import { type Tuple } from '@aztec/foundation/serialize';
 import { type KeyStore } from '@aztec/key-store';
 import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types';
@@ -31,7 +31,7 @@ export class KernelOracle implements ProvingDataOracle {
     private keyStore: KeyStore,
     private node: AztecNode,
     private blockNumber: L2BlockNumber = 'latest',
-    private log = createDebugLogger('aztec:pxe:kernel_oracle'),
+    private log = createLogger('pxe:kernel_oracle'),
   ) {}
 
   public async getContractAddressPreimage(address: AztecAddress) {

package/src/kernel_prover/index.ts

@@ -1,2 +1,4 @@
+export { TestPrivateKernelProver } from './test/test_circuit_prover.js';
+
 export * from './kernel_prover.js';
 export * from './proving_data_oracle.js';

package/src/kernel_prover/kernel_prover.ts

@@ -19,6 +19,8 @@ import {
   PrivateKernelInnerCircuitPrivateInputs,
   PrivateKernelTailCircuitPrivateInputs,
   type PrivateKernelTailCircuitPublicInputs,
+  type PrivateLog,
+  type ScopedPrivateLogData,
   type TxRequest,
   VK_TREE_HEIGHT,
   VerificationKeyAsFields,
@@ -26,7 +28,7 @@ import {
 import { hashVK } from '@aztec/circuits.js/hash';
 import { makeTuple } from '@aztec/foundation/array';
 import { vkAsFieldsMegaHonk } from '@aztec/foundation/crypto';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 import { assertLength } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types';
@@ -37,10 +39,48 @@ import {
 } from '@aztec/protocol-contracts';
 
 import { type WitnessMap } from '@noir-lang/types';
+import { strict as assert } from 'assert';
 
 import { PrivateKernelResetPrivateInputsBuilder } from './hints/build_private_kernel_reset_private_inputs.js';
 import { type ProvingDataOracle } from './proving_data_oracle.js';
 
+// TODO(#10592): Temporary workaround to check that the private logs are correctly split into non-revertible set and revertible set.
+// This should be done in TailToPublicOutputValidator in private kernel tail.
+function checkPrivateLogs(
+  privateLogs: ScopedPrivateLogData[],
+  nonRevertiblePrivateLogs: PrivateLog[],
+  revertiblePrivateLogs: PrivateLog[],
+  splitCounter: number,
+) {
+  let numNonRevertible = 0;
+  let numRevertible = 0;
+  privateLogs
+    .filter(privateLog => privateLog.inner.counter !== 0)
+    .forEach(privateLog => {
+      if (privateLog.inner.counter < splitCounter) {
+        assert(
+          privateLog.inner.log.toBuffer().equals(nonRevertiblePrivateLogs[numNonRevertible].toBuffer()),
+          `mismatch non-revertible private logs at index ${numNonRevertible}`,
+        );
+        numNonRevertible++;
+      } else {
+        assert(
+          privateLog.inner.log.toBuffer().equals(revertiblePrivateLogs[numRevertible].toBuffer()),
+          `mismatch revertible private logs at index ${numRevertible}`,
+        );
+        numRevertible++;
+      }
+    });
+  assert(
+    nonRevertiblePrivateLogs.slice(numNonRevertible).every(l => l.isEmpty()),
+    'Unexpected non-empty private log in non-revertible set.',
+  );
+  assert(
+    revertiblePrivateLogs.slice(numRevertible).every(l => l.isEmpty()),
+    'Unexpected non-empty private log in revertible set.',
+  );
+}
+
 const NULL_PROVE_OUTPUT: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs> = {
   publicInputs: PrivateKernelCircuitPublicInputs.empty(),
   verificationKey: VerificationKeyAsFields.makeEmpty(CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS),
@@ -55,7 +95,7 @@ const NULL_PROVE_OUTPUT: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicI
  * constructs private call data based on the execution results.
  */
 export class KernelProver {
-  private log = createDebugLogger('aztec:kernel-prover');
+  private log = createLogger('pxe:kernel-prover');
 
   constructor(private oracle: ProvingDataOracle, private proofCreator: PrivateKernelProver) {}
 
@@ -78,6 +118,8 @@ export class KernelProver {
     profile: boolean = false,
     dryRun: boolean = false,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
+    const isPrivateOnlyTx = this.isPrivateOnly(executionResult);
+
     const executionStack = [executionResult];
     let firstIteration = true;
 
@@ -153,6 +195,7 @@ export class KernelProver {
           getVKTreeRoot(),
           protocolContractTreeRoot,
           privateCallData,
+          isPrivateOnlyTx,
         );
         pushTestData('private-kernel-inputs-init', proofInput);
         output = await this.proofCreator.simulateProofInit(proofInput);
@@ -225,6 +268,12 @@ export class KernelProver {
 
     pushTestData('private-kernel-inputs-ordering', privateInputs);
     const tailOutput = await this.proofCreator.simulateProofTail(privateInputs);
+    if (tailOutput.publicInputs.forPublic) {
+      const privateLogs = privateInputs.previousKernel.publicInputs.end.privateLogs;
+      const nonRevertiblePrivateLogs = tailOutput.publicInputs.forPublic.nonRevertibleAccumulatedData.privateLogs;
+      const revertiblePrivateLogs = tailOutput.publicInputs.forPublic.revertibleAccumulatedData.privateLogs;
+      checkPrivateLogs(privateLogs, nonRevertiblePrivateLogs, revertiblePrivateLogs, validationRequestsSplitCounter);
+    }
 
     acirs.push(tailOutput.bytecode);
     witnessStack.push(tailOutput.outputWitness);
@@ -278,4 +327,14 @@ export class KernelProver {
       acirHash,
     });
   }
+
+  private isPrivateOnly(executionResult: PrivateExecutionResult): boolean {
+    const makesPublicCalls =
+      executionResult.enqueuedPublicFunctionCalls.some(enqueuedCall => !enqueuedCall.isEmpty()) ||
+      !executionResult.publicTeardownFunctionCall.isEmpty();
+    return (
+      !makesPublicCalls &&
+      executionResult.nestedExecutions.every(nestedExecution => this.isPrivateOnly(nestedExecution))
+    );
+  }
 }

package/src/kernel_prover/test/test_circuit_prover.ts

@@ -15,7 +15,7 @@ import {
   type PrivateKernelTailCircuitPublicInputs,
   VerificationKeyAsFields,
 } from '@aztec/circuits.js';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
 import {
   type ProtocolArtifact,
@@ -35,7 +35,7 @@ import { type WitnessMap } from '@noir-lang/types';
  * Test Proof Creator executes circuit simulations and provides fake proofs.
  */
 export class TestPrivateKernelProver implements PrivateKernelProver {
-  constructor(private log = createDebugLogger('aztec:test_proof_creator')) {}
+  constructor(private log = createLogger('pxe:test_proof_creator')) {}
 
   createClientIvcProof(_acirs: Buffer[], _witnessStack: WitnessMap[]): Promise<ClientIvcProof> {
     return Promise.resolve(ClientIvcProof.empty());
@@ -73,7 +73,9 @@ export class TestPrivateKernelProver implements PrivateKernelProver {
     privateInputs: PrivateKernelResetCircuitPrivateInputs,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
     const variantPrivateInputs = privateInputs.trimToSizes();
-    const [duration, result] = await elapsed(() => executeReset(variantPrivateInputs, privateInputs.dimensions));
+    const [duration, result] = await elapsed(() =>
+      executeReset(variantPrivateInputs, privateInputs.dimensions, privateInputs),
+    );
     this.log.debug(`Simulated private kernel reset`, {
       eventName: 'circuit-simulation',
       circuitName: 'private-kernel-reset',

package/src/note_decryption_utils/add_public_values_to_payload.ts

@@ -1,5 +1,5 @@
 import { type L1NotePayload, Note } from '@aztec/circuit-types';
-import { ContractNotFoundError } from '@aztec/simulator';
+import { ContractNotFoundError } from '@aztec/simulator/client';
 
 import { type PxeDatabase } from '../database/pxe_database.js';
 

package/src/note_decryption_utils/brute_force_note_info.ts

@@ -3,7 +3,7 @@ import { type AztecAddress } from '@aztec/circuits.js';
 import { computeNoteHashNonce, siloNullifier } from '@aztec/circuits.js/hash';
 import { type NoteSelector } from '@aztec/foundation/abi';
 import { Fr } from '@aztec/foundation/fields';
-import { type AcirSimulator } from '@aztec/simulator';
+import { type AcirSimulator } from '@aztec/simulator/client';
 
 export interface NoteInfo {
   noteHashIndex: number;
@@ -18,7 +18,7 @@ export interface NoteInfo {
  * @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 siloedNoteHashes - Note hashes in the tx. One of them should correspond to the note we are looking for
+ * @param uniqueNoteHashes - 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 contractAddress - Address of the contract the note was emitted in.
  * @param storageSlot - Storage slot of the note.
@@ -32,7 +32,7 @@ export interface NoteInfo {
  */
 export async function bruteForceNoteInfo(
   simulator: AcirSimulator,
-  siloedNoteHashes: Fr[],
+  uniqueNoteHashes: Fr[],
   txHash: TxHash,
   contractAddress: AztecAddress,
   storageSlot: Fr,
@@ -44,22 +44,22 @@ export async function bruteForceNoteInfo(
   let noteHashIndex = 0;
   let nonce: Fr | undefined;
   let noteHash: Fr | undefined;
-  let siloedNoteHash: Fr | undefined;
+  let uniqueNoteHash: Fr | undefined;
   let innerNullifier: Fr | undefined;
   const firstNullifier = Fr.fromBuffer(txHash.toBuffer());
 
-  for (; noteHashIndex < siloedNoteHashes.length; ++noteHashIndex) {
+  for (; noteHashIndex < uniqueNoteHashes.length; ++noteHashIndex) {
     if (excludedIndices.has(noteHashIndex)) {
       continue;
     }
 
-    const siloedNoteHashFromTxEffect = siloedNoteHashes[noteHashIndex];
-    if (siloedNoteHashFromTxEffect.equals(Fr.ZERO)) {
+    const uniqueNoteHashFromTxEffect = uniqueNoteHashes[noteHashIndex];
+    if (uniqueNoteHashFromTxEffect.equals(Fr.ZERO)) {
       break;
     }
 
     const expectedNonce = computeNoteHashNonce(firstNullifier, noteHashIndex);
-    ({ noteHash, siloedNoteHash, innerNullifier } = await simulator.computeNoteHashAndOptionallyANullifier(
+    ({ noteHash, uniqueNoteHash, innerNullifier } = await simulator.computeNoteHashAndOptionallyANullifier(
       contractAddress,
       expectedNonce,
       storageSlot,
@@ -68,7 +68,7 @@ export async function bruteForceNoteInfo(
       note,
     ));
 
-    if (siloedNoteHashFromTxEffect.equals(siloedNoteHash)) {
+    if (uniqueNoteHashFromTxEffect.equals(uniqueNoteHash)) {
       nonce = expectedNonce;
       break;
     }

package/src/note_decryption_utils/produce_note_daos.ts

@@ -1,10 +1,9 @@
 import { type L1NotePayload, type PublicKey, type TxHash } from '@aztec/circuit-types';
 import { type Fr } from '@aztec/foundation/fields';
 import { type Logger } from '@aztec/foundation/log';
-import { type AcirSimulator } from '@aztec/simulator';
+import { type AcirSimulator } from '@aztec/simulator/client';
 
 import { IncomingNoteDao } from '../database/incoming_note_dao.js';
-import { OutgoingNoteDao } from '../database/outgoing_note_dao.js';
 import { type PxeDatabase } from '../database/pxe_database.js';
 import { produceNoteDaosForKey } from './produce_note_daos_for_key.js';
 
@@ -17,7 +16,6 @@ import { produceNoteDaosForKey } from './produce_note_daos_for_key.js';
  * @param simulator - An instance of AcirSimulator.
  * @param db - An instance of PxeDatabase.
  * @param addressPoint - The public counterpart to the address secret, which is used in the decryption of incoming note logs.
- * @param ovpkM - The public counterpart to the secret key to be used in the decryption of outgoing note logs.
  * @param payload - An instance of l1NotePayload.
  * @param txHash - The hash of the transaction that created the note. Equivalent to the first nullifier of the transaction.
  * @param noteHashes - New note hashes in this transaction, one of which belongs to this note.
@@ -25,13 +23,12 @@ import { produceNoteDaosForKey } from './produce_note_daos_for_key.js';
  * @param excludedIndices - Indices that have been assigned a note in the same tx. Notes in a tx can have the same l1NotePayload, we need to find a different index for each replicate.
  * @param logger - An instance of Logger.
  * @param unencryptedLogs - Unencrypted logs for the transaction (used to complete partial notes).
- * @returns An object containing the incoming, outgoing, and deferred notes.
+ * @returns An object containing the incoming notes.
  */
 export async function produceNoteDaos(
   simulator: AcirSimulator,
   db: PxeDatabase,
   addressPoint: PublicKey | undefined,
-  ovpkM: PublicKey | undefined,
   payload: L1NotePayload,
   txHash: TxHash,
   l2BlockNumber: number,
@@ -40,16 +37,12 @@ export async function produceNoteDaos(
   dataStartIndexForTx: number,
   excludedIndices: Set<number>,
   logger: Logger,
-): Promise<{
-  incomingNote: IncomingNoteDao | undefined;
-  outgoingNote: OutgoingNoteDao | undefined;
-}> {
-  if (!addressPoint && !ovpkM) {
-    throw new Error('Both addressPoint and ovpkM are undefined. Cannot create note.');
+): Promise<{ incomingNote: IncomingNoteDao | undefined }> {
+  if (!addressPoint) {
+    throw new Error('addressPoint is undefined. Cannot create note.');
   }
 
   let incomingNote: IncomingNoteDao | undefined;
-  let outgoingNote: OutgoingNoteDao | undefined;
 
   if (addressPoint) {
     incomingNote = await produceNoteDaosForKey(
@@ -68,43 +61,7 @@ export async function produceNoteDaos(
     );
   }
 
-  if (ovpkM) {
-    if (incomingNote) {
-      // Incoming note is defined meaning that this PXE has both the incoming and outgoing keys. We can skip computing
-      // note hash and note index since we already have them in the incoming note.
-      outgoingNote = new OutgoingNoteDao(
-        incomingNote.note,
-        incomingNote.contractAddress,
-        incomingNote.storageSlot,
-        incomingNote.noteTypeId,
-        incomingNote.txHash,
-        incomingNote.l2BlockNumber,
-        incomingNote.l2BlockHash,
-        incomingNote.nonce,
-        incomingNote.noteHash,
-        incomingNote.index,
-        ovpkM,
-      );
-    } else {
-      outgoingNote = await produceNoteDaosForKey(
-        simulator,
-        db,
-        ovpkM,
-        payload,
-        txHash,
-        l2BlockNumber,
-        l2BlockHash,
-        noteHashes,
-        dataStartIndexForTx,
-        excludedIndices,
-        logger,
-        OutgoingNoteDao.fromPayloadAndNoteInfo,
-      );
-    }
-  }
-
   return {
     incomingNote,
-    outgoingNote,
   };
 }

package/src/note_decryption_utils/produce_note_daos_for_key.ts

@@ -1,7 +1,7 @@
 import { type L1NotePayload, type Note, type TxHash } from '@aztec/circuit-types';
 import { type Fr, type PublicKey } from '@aztec/circuits.js';
 import { type Logger } from '@aztec/foundation/log';
-import { type AcirSimulator } from '@aztec/simulator';
+import { type AcirSimulator } from '@aztec/simulator/client';
 
 import { type PxeDatabase } from '../database/pxe_database.js';
 import { getOrderedNoteItems } from './add_public_values_to_payload.js';