@aztec/pxe 0.42.0 → 0.44.0

package/src/database/pxe_database_test_suite.ts

@@ -1,4 +1,4 @@
-import { type NoteFilter, NoteStatus, randomTxHash } from '@aztec/circuit-types';
+import { type IncomingNotesFilter, NoteStatus, type OutgoingNotesFilter, randomTxHash } from '@aztec/circuit-types';
 import { AztecAddress, CompleteAddress, INITIAL_L2_BLOCK_NUM, PublicKeys } from '@aztec/circuits.js';
 import { makeHeader } from '@aztec/circuits.js/testing';
 import { randomInt } from '@aztec/foundation/crypto';
@@ -6,8 +6,10 @@ import { Fr, Point } from '@aztec/foundation/fields';
 import { BenchmarkingContractArtifact } from '@aztec/noir-contracts.js/Benchmarking';
 import { SerializableContractInstance } from '@aztec/types/contracts';
 
-import { type NoteDao } from './note_dao.js';
-import { randomNoteDao } from './note_dao.test.js';
+import { type IncomingNoteDao } from './incoming_note_dao.js';
+import { randomIncomingNoteDao } from './incoming_note_dao.test.js';
+import { type OutgoingNoteDao } from './outgoing_note_dao.js';
+import { randomOutgoingNoteDao } from './outgoing_note_dao.test.js';
 import { type PxeDatabase } from './pxe_database.js';
 
 /**
@@ -68,13 +70,13 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       });
     });
 
-    describe('notes', () => {
+    describe('incoming notes', () => {
       let owners: CompleteAddress[];
       let contractAddresses: AztecAddress[];
       let storageSlots: Fr[];
-      let notes: NoteDao[];
+      let notes: IncomingNoteDao[];
 
-      const filteringTests: [() => NoteFilter, () => NoteDao[]][] = [
+      const filteringTests: [() => IncomingNotesFilter, () => IncomingNoteDao[]][] = [
         [() => ({}), () => notes],
 
         [
@@ -94,7 +96,7 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
 
         [
           () => ({ owner: owners[0].address }),
-          () => notes.filter(note => note.publicKey.equals(owners[0].publicKeys.masterIncomingViewingPublicKey)),
+          () => notes.filter(note => note.ivpkM.equals(owners[0].publicKeys.masterIncomingViewingPublicKey)),
         ],
 
         [
@@ -107,46 +109,44 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
         [() => ({ contractAddress: contractAddresses[0], storageSlot: storageSlots[1] }), () => []],
       ];
 
-      beforeEach(() => {
+      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) =>
-          randomNoteDao({
+          randomIncomingNoteDao({
             contractAddress: contractAddresses[i % contractAddresses.length],
             storageSlot: storageSlots[i % storageSlots.length],
-            publicKey: owners[i % owners.length].publicKeys.masterIncomingViewingPublicKey,
+            ivpkM: owners[i % owners.length].publicKeys.masterIncomingViewingPublicKey,
             index: BigInt(i),
           }),
         );
-      });
 
-      beforeEach(async () => {
         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.getNotes(getFilter())).resolves.toEqual(getExpected());
+        await database.addNotes(notes, []);
+        await expect(database.getIncomingNotes(getFilter())).resolves.toEqual(getExpected());
       });
 
       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.getNotes(getFilter())).resolves.toEqual(getExpected());
+        await expect(database.getIncomingNotes(getFilter())).resolves.toEqual(getExpected());
       });
 
       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) {
           const notesToNullify = notes.filter(note =>
-            note.publicKey.equals(owner.publicKeys.masterIncomingViewingPublicKey),
+            note.ivpkM.equals(owner.publicKeys.masterIncomingViewingPublicKey),
           );
           const nullifiers = notesToNullify.map(note => note.siloedNullifier);
           await expect(
@@ -154,41 +154,41 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
           ).resolves.toEqual(notesToNullify);
         }
 
-        await expect(database.getNotes({ ...getFilter(), status: NoteStatus.ACTIVE_OR_NULLIFIED })).resolves.toEqual(
-          getExpected(),
-        );
+        await expect(
+          database.getIncomingNotes({ ...getFilter(), status: NoteStatus.ACTIVE_OR_NULLIFIED }),
+        ).resolves.toEqual(getExpected());
       });
 
       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.publicKey.equals(owners[0].publicKeys.masterIncomingViewingPublicKey),
+          note.ivpkM.equals(owners[0].publicKeys.masterIncomingViewingPublicKey),
         );
         const nullifiers = notesToNullify.map(note => note.siloedNullifier);
-        await expect(database.removeNullifiedNotes(nullifiers, notesToNullify[0].publicKey)).resolves.toEqual(
+        await expect(database.removeNullifiedNotes(nullifiers, notesToNullify[0].ivpkM)).resolves.toEqual(
           notesToNullify,
         );
 
-        const actualNotesWithDefault = await database.getNotes({});
-        const actualNotesWithActive = await database.getNotes({ status: NoteStatus.ACTIVE });
+        const actualNotesWithDefault = await database.getIncomingNotes({});
+        const actualNotesWithActive = await database.getIncomingNotes({ status: NoteStatus.ACTIVE });
 
         expect(actualNotesWithDefault).toEqual(actualNotesWithActive);
         expect(actualNotesWithActive).toEqual(notes.filter(note => !notesToNullify.includes(note)));
       });
 
       it('returns active and nullified notes when requesting either', async () => {
-        await database.addNotes(notes);
+        await database.addNotes(notes, []);
 
         const notesToNullify = notes.filter(note =>
-          note.publicKey.equals(owners[0].publicKeys.masterIncomingViewingPublicKey),
+          note.ivpkM.equals(owners[0].publicKeys.masterIncomingViewingPublicKey),
         );
         const nullifiers = notesToNullify.map(note => note.siloedNullifier);
-        await expect(database.removeNullifiedNotes(nullifiers, notesToNullify[0].publicKey)).resolves.toEqual(
+        await expect(database.removeNullifiedNotes(nullifiers, notesToNullify[0].ivpkM)).resolves.toEqual(
           notesToNullify,
         );
 
-        const result = await database.getNotes({
+        const result = await database.getIncomingNotes({
           status: NoteStatus.ACTIVE_OR_NULLIFIED,
         });
 
@@ -198,6 +198,70 @@ 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) =>
+          randomOutgoingNoteDao({
+            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);

package/src/index.ts

@@ -9,3 +9,6 @@ export * from '@aztec/foundation/fields';
 export * from '@aztec/foundation/eth-address';
 export * from '@aztec/foundation/aztec-address';
 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';

package/src/note_processor/note_processor.ts

@@ -1,36 +1,34 @@
-import {
-  type AztecNode,
-  type EncryptedNoteL2BlockL2Logs,
-  L1NotePayload,
-  type L2Block,
-  TaggedNote,
-} from '@aztec/circuit-types';
+import { type AztecNode, L1NotePayload, type L2Block, TaggedLog } from '@aztec/circuit-types';
 import { type NoteProcessorStats } from '@aztec/circuit-types/stats';
-import { INITIAL_L2_BLOCK_NUM, MAX_NEW_NOTE_HASHES_PER_TX, type PublicKey } from '@aztec/circuits.js';
+import {
+  type AztecAddress,
+  INITIAL_L2_BLOCK_NUM,
+  MAX_NEW_NOTE_HASHES_PER_TX,
+  type PublicKey,
+} from '@aztec/circuits.js';
 import { type Fr } from '@aztec/foundation/fields';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { type Logger, createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { type KeyStore } from '@aztec/key-store';
-import { ContractNotFoundError } from '@aztec/simulator';
+import { type AcirSimulator } from '@aztec/simulator';
 
-import { DeferredNoteDao } from '../database/deferred_note_dao.js';
+import { type DeferredNoteDao } from '../database/deferred_note_dao.js';
+import { type IncomingNoteDao } from '../database/incoming_note_dao.js';
 import { type PxeDatabase } from '../database/index.js';
-import { type NoteDao } from '../database/note_dao.js';
+import { type OutgoingNoteDao } from '../database/outgoing_note_dao.js';
 import { getAcirSimulator } from '../simulator/index.js';
-import { produceNoteDao } from './produce_note_dao.js';
+import { produceNoteDaos } from './produce_note_dao.js';
 
 /**
  * Contains all the decrypted data in this array so that we can later batch insert it all into the database.
  */
 interface ProcessedData {
-  /**
-   * Holds L2 block.
-   */
+  /** Holds L2 block. */
   block: L2Block;
-  /**
-   * DAOs of processed notes.
-   */
-  noteDaos: NoteDao[];
+  /** DAOs of processed incoming notes. */
+  incomingNotes: IncomingNoteDao[];
+  /** DAOs of processed outgoing notes. */
+  outgoingNotes: OutgoingNoteDao[];
 }
 
 /**
@@ -42,21 +40,46 @@ export class NoteProcessor {
   public readonly timer: Timer = new Timer();
 
   /** Stats accumulated for this processor. */
-  public readonly stats: NoteProcessorStats = { seen: 0, decrypted: 0, deferred: 0, failed: 0, blocks: 0, txs: 0 };
+  public readonly stats: NoteProcessorStats = {
+    seen: 0,
+    decryptedIncoming: 0,
+    decryptedOutgoing: 0,
+    deferredIncoming: 0,
+    deferredOutgoing: 0,
+    failed: 0,
+    blocks: 0,
+    txs: 0,
+  };
 
-  constructor(
-    /**
-     * The public counterpart to the private key to be used in note decryption.
-     */
-    public readonly masterIncomingViewingPublicKey: PublicKey,
+  private constructor(
+    public readonly account: AztecAddress,
+    /** The public counterpart to the secret key to be used in the decryption of incoming note logs. */
+    private readonly ivpkM: PublicKey,
+    /** The public counterpart to the secret key to be used in the decryption of outgoing note logs. */
+    private readonly ovpkM: PublicKey,
     private keyStore: KeyStore,
     private db: PxeDatabase,
     private node: AztecNode,
-    private startingBlock: number = INITIAL_L2_BLOCK_NUM,
-    private simulator = getAcirSimulator(db, node, keyStore),
-    private log = createDebugLogger('aztec:note_processor'),
+    private startingBlock: number,
+    private simulator: AcirSimulator,
+    private log: Logger,
   ) {}
 
+  public static async create(
+    account: AztecAddress,
+    keyStore: KeyStore,
+    db: PxeDatabase,
+    node: AztecNode,
+    startingBlock: number = INITIAL_L2_BLOCK_NUM,
+    simulator = getAcirSimulator(db, node, keyStore),
+    log = createDebugLogger('aztec:note_processor'),
+  ) {
+    const ivpkM = await keyStore.getMasterIncomingViewingPublicKey(account);
+    const ovpkM = await keyStore.getMasterOutgoingViewingPublicKey(account);
+
+    return new NoteProcessor(account, ivpkM, ovpkM, keyStore, db, node, startingBlock, simulator, log);
+  }
+
   /**
    * Check if the NoteProcessor is synchronized with the remote block number.
    * The function queries the remote block number from the AztecNode and compares it with the syncedToBlock value in the NoteProcessor.
@@ -77,46 +100,40 @@ export class NoteProcessor {
   }
 
   private getSyncedToBlock(): number {
-    return this.db.getSynchedBlockNumberForPublicKey(this.masterIncomingViewingPublicKey) ?? this.startingBlock - 1;
+    return this.db.getSynchedBlockNumberForPublicKey(this.ivpkM) ?? this.startingBlock - 1;
   }
 
   /**
    * Extracts new user-relevant notes from the information contained in the provided L2 blocks and encrypted logs.
    *
-   * @throws If the number of blocks and encrypted logs do not match.
-   * @param l2Blocks - L2 blocks to be processed.
-   * @param encryptedL2BlockLogs - Encrypted logs associated with the L2 blocks.
+   * @param blocks - L2 blocks to be processed.
    * @returns A promise that resolves once the processing is completed.
    */
-  public async process(l2Blocks: L2Block[], encryptedL2BlockLogs: EncryptedNoteL2BlockL2Logs[]): Promise<void> {
-    if (l2Blocks.length !== encryptedL2BlockLogs.length) {
-      throw new Error(
-        `Number of blocks and EncryptedLogs is not equal. Received ${l2Blocks.length} blocks, ${encryptedL2BlockLogs.length} encrypted logs.`,
-      );
-    }
-    if (l2Blocks.length === 0) {
+  public async process(blocks: L2Block[]): Promise<void> {
+    if (blocks.length === 0) {
       return;
     }
 
     const blocksAndNotes: ProcessedData[] = [];
     // Keep track of notes that we couldn't process because the contract was not found.
-    const deferredNoteDaos: DeferredNoteDao[] = [];
+    const deferredIncomingNotes: DeferredNoteDao[] = [];
+    const deferredOutgoingNotes: DeferredNoteDao[] = [];
+
+    const ivskM = await this.keyStore.getMasterSecretKey(this.ivpkM);
+    const ovskM = await this.keyStore.getMasterSecretKey(this.ovpkM);
 
     // Iterate over both blocks and encrypted logs.
-    for (let blockIndex = 0; blockIndex < encryptedL2BlockLogs.length; ++blockIndex) {
+    for (const block of blocks) {
       this.stats.blocks++;
-      const { txLogs } = encryptedL2BlockLogs[blockIndex];
-      const block = l2Blocks[blockIndex];
+      const { txLogs } = block.body.noteEncryptedLogs;
       const dataStartIndexForBlock =
         block.header.state.partial.noteHashTree.nextAvailableLeafIndex -
         block.body.numberOfTxsIncludingPadded * MAX_NEW_NOTE_HASHES_PER_TX;
 
       // We are using set for `userPertainingTxIndices` to avoid duplicates. This would happen in case there were
       // multiple encrypted logs in a tx pertaining to a user.
-      const noteDaos: NoteDao[] = [];
-      const secretKey = await this.keyStore.getMasterIncomingViewingSecretKeyForPublicKey(
-        this.masterIncomingViewingPublicKey,
-      );
+      const incomingNotes: IncomingNoteDao[] = [];
+      const outgoingNotes: OutgoingNoteDao[] = [];
 
       // Iterate over all the encrypted logs and try decrypting them. If successful, store the note.
       for (let indexOfTxInABlock = 0; indexOfTxInABlock < txLogs.length; ++indexOfTxInABlock) {
@@ -130,43 +147,56 @@ export class NoteProcessor {
         for (const functionLogs of txFunctionLogs) {
           for (const log of functionLogs.logs) {
             this.stats.seen++;
-            // @todo Issue(#6410) We should also try decrypting as outgoing if this fails.
-            const taggedNote = TaggedNote.decryptAsIncoming(log.data, secretKey);
-            if (taggedNote?.notePayload) {
-              const { notePayload: payload } = taggedNote;
-              // We have successfully decrypted the data.
-              const txHash = block.body.txEffects[indexOfTxInABlock].txHash;
-              try {
-                const noteDao = await produceNoteDao(
-                  this.simulator,
-                  this.masterIncomingViewingPublicKey,
-                  payload,
-                  txHash,
-                  newNoteHashes,
-                  dataStartIndexForTx,
-                  excludedIndices,
+            const incomingTaggedNote = TaggedLog.decryptAsIncoming(log.data, ivskM)!;
+            const outgoingTaggedNote = TaggedLog.decryptAsOutgoing(log.data, ovskM)!;
+
+            if (incomingTaggedNote || outgoingTaggedNote) {
+              if (
+                incomingTaggedNote &&
+                outgoingTaggedNote &&
+                !incomingTaggedNote.payload.equals(outgoingTaggedNote.payload)
+              ) {
+                throw new Error(
+                  `Incoming and outgoing note payloads do not match. Incoming: ${JSON.stringify(
+                    incomingTaggedNote.payload,
+                  )}, Outgoing: ${JSON.stringify(outgoingTaggedNote.payload)}`,
                 );
-                noteDaos.push(noteDao);
-                this.stats.decrypted++;
-              } catch (e) {
-                if (e instanceof ContractNotFoundError) {
-                  this.stats.deferred++;
-                  this.log.warn(e.message);
-                  const deferredNoteDao = new DeferredNoteDao(
-                    this.masterIncomingViewingPublicKey,
-                    payload.note,
-                    payload.contractAddress,
-                    payload.storageSlot,
-                    payload.noteTypeId,
-                    txHash,
-                    newNoteHashes,
-                    dataStartIndexForTx,
-                  );
-                  deferredNoteDaos.push(deferredNoteDao);
-                } else {
-                  this.stats.failed++;
-                  this.log.error(`Could not process note because of "${e}". Discarding note...`);
-                }
+              }
+
+              const payload = incomingTaggedNote?.payload || outgoingTaggedNote?.payload;
+
+              const txHash = block.body.txEffects[indexOfTxInABlock].txHash;
+              const { incomingNote, outgoingNote, incomingDeferredNote, outgoingDeferredNote } = await produceNoteDaos(
+                this.simulator,
+                incomingTaggedNote ? this.ivpkM : undefined,
+                outgoingTaggedNote ? this.ovpkM : undefined,
+                payload,
+                txHash,
+                newNoteHashes,
+                dataStartIndexForTx,
+                excludedIndices,
+                this.log,
+              );
+
+              if (incomingNote) {
+                incomingNotes.push(incomingNote);
+                this.stats.decryptedIncoming++;
+              }
+              if (outgoingNote) {
+                outgoingNotes.push(outgoingNote);
+                this.stats.decryptedOutgoing++;
+              }
+              if (incomingDeferredNote) {
+                deferredIncomingNotes.push(incomingDeferredNote);
+                this.stats.deferredIncoming++;
+              }
+              if (outgoingDeferredNote) {
+                deferredOutgoingNotes.push(outgoingDeferredNote);
+                this.stats.deferredOutgoing++;
+              }
+
+              if (incomingNote == undefined && outgoingNote == undefined && incomingDeferredNote == undefined) {
+                this.stats.failed++;
               }
             }
           }
@@ -174,16 +204,17 @@ export class NoteProcessor {
       }
 
       blocksAndNotes.push({
-        block: l2Blocks[blockIndex],
-        noteDaos,
+        block,
+        incomingNotes,
+        outgoingNotes,
       });
     }
 
     await this.processBlocksAndNotes(blocksAndNotes);
-    await this.processDeferredNotes(deferredNoteDaos);
+    await this.processDeferredNotes(deferredIncomingNotes, deferredOutgoingNotes);
 
-    const syncedToBlock = l2Blocks[l2Blocks.length - 1].number;
-    await this.db.setSynchedBlockNumberForPublicKey(this.masterIncomingViewingPublicKey, syncedToBlock);
+    const syncedToBlock = blocks[blocks.length - 1].number;
+    await this.db.setSynchedBlockNumberForPublicKey(this.ivpkM, syncedToBlock);
 
     this.log.debug(`Synched block ${syncedToBlock}`);
   }
@@ -198,22 +229,26 @@ export class NoteProcessor {
    * @param blocksAndNotes - Array of objects containing L2 blocks, user-pertaining transaction indices, and NoteDaos.
    */
   private async processBlocksAndNotes(blocksAndNotes: ProcessedData[]) {
-    const noteDaos = blocksAndNotes.flatMap(b => b.noteDaos);
-    if (noteDaos.length) {
-      await this.db.addNotes(noteDaos);
-      noteDaos.forEach(noteDao => {
+    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);
+      incomingNotes.forEach(noteDao => {
         this.log.verbose(
-          `Added note for contract ${noteDao.contractAddress} at slot ${
+          `Added incoming note for contract ${noteDao.contractAddress} at slot ${
             noteDao.storageSlot
           } with nullifier ${noteDao.siloedNullifier.toString()}`,
         );
       });
+      outgoingNotes.forEach(noteDao => {
+        this.log.verbose(`Added outgoing note for contract ${noteDao.contractAddress} at slot ${noteDao.storageSlot}`);
+      });
     }
 
     const newNullifiers: Fr[] = blocksAndNotes.flatMap(b =>
       b.block.body.txEffects.flatMap(txEffect => txEffect.nullifiers),
     );
-    const removedNotes = await this.db.removeNullifiedNotes(newNullifiers, this.masterIncomingViewingPublicKey);
+    const removedNotes = await this.db.removeNullifiedNotes(newNullifiers, this.ivpkM);
     removedNotes.forEach(noteDao => {
       this.log.verbose(
         `Removed note for contract ${noteDao.contractAddress} at slot ${
@@ -226,14 +261,25 @@ export class NoteProcessor {
   /**
    * Store the given deferred notes in the database for later decoding.
    *
-   * @param deferredNoteDaos - notes that are intended for us but we couldn't process because the contract was not found.
+   * @param deferredIncomingNotes - incoming notes that are intended for us but we couldn't process because the contract was not found.
+   * @param deferredOutgoingNotes - outgoing notes that we couldn't process because the contract was not found.
    */
-  private async processDeferredNotes(deferredNoteDaos: DeferredNoteDao[]) {
-    if (deferredNoteDaos.length) {
-      await this.db.addDeferredNotes(deferredNoteDaos);
-      deferredNoteDaos.forEach(noteDao => {
+  private async processDeferredNotes(
+    deferredIncomingNotes: DeferredNoteDao[],
+    deferredOutgoingNotes: DeferredNoteDao[],
+  ) {
+    if (deferredIncomingNotes.length || deferredOutgoingNotes.length) {
+      await this.db.addDeferredNotes([...deferredIncomingNotes, ...deferredOutgoingNotes]);
+      deferredIncomingNotes.forEach(noteDao => {
+        this.log.verbose(
+          `Deferred incoming note for contract ${noteDao.contractAddress} at slot ${
+            noteDao.storageSlot
+          } in tx ${noteDao.txHash.toString()}`,
+        );
+      });
+      deferredOutgoingNotes.forEach(noteDao => {
         this.log.verbose(
-          `Deferred note for contract ${noteDao.contractAddress} at slot ${
+          `Deferred outgoing note for contract ${noteDao.contractAddress} at slot ${
             noteDao.storageSlot
           } in tx ${noteDao.txHash.toString()}`,
         );
@@ -245,37 +291,60 @@ export class NoteProcessor {
    * Retry decoding the given deferred notes because we now have the contract code.
    *
    * @param deferredNoteDaos - notes that we have previously deferred because the contract was not found
-   * @returns An array of NoteDaos that were successfully decoded.
+   * @returns An object containing arrays of incoming and outgoing notes that were successfully decoded.
    *
    * @remarks Caller is responsible for making sure that we have the contract for the
    * deferred notes provided: we will not retry notes that fail again.
    */
-  public async decodeDeferredNotes(deferredNoteDaos: DeferredNoteDao[]): Promise<NoteDao[]> {
+  public async decodeDeferredNotes(deferredNoteDaos: DeferredNoteDao[]): Promise<{
+    incomingNotes: IncomingNoteDao[];
+    outgoingNotes: OutgoingNoteDao[];
+  }> {
     const excludedIndices: Set<number> = new Set();
-    const noteDaos: NoteDao[] = [];
+    const incomingNotes: IncomingNoteDao[] = [];
+    const outgoingNotes: OutgoingNoteDao[] = [];
+
     for (const deferredNote of deferredNoteDaos) {
-      const { note, contractAddress, storageSlot, noteTypeId, txHash, newNoteHashes, dataStartIndexForTx } =
+      const { publicKey, note, contractAddress, storageSlot, noteTypeId, txHash, newNoteHashes, dataStartIndexForTx } =
         deferredNote;
       const payload = new L1NotePayload(note, contractAddress, storageSlot, noteTypeId);
 
-      try {
-        const noteDao = await produceNoteDao(
-          this.simulator,
-          this.masterIncomingViewingPublicKey,
-          payload,
-          txHash,
-          newNoteHashes,
-          dataStartIndexForTx,
-          excludedIndices,
-        );
-        noteDaos.push(noteDao);
-        this.stats.decrypted++;
-      } catch (e) {
-        this.stats.failed++;
-        this.log.warn(`Could not process deferred note because of "${e}". Discarding note...`);
+      const isIncoming = publicKey.equals(this.ivpkM);
+      const isOutgoing = publicKey.equals(this.ovpkM);
+
+      if (!isIncoming && !isOutgoing) {
+        // The note does not belong to this note processor
+        continue;
+      }
+
+      const { incomingNote, outgoingNote } = await produceNoteDaos(
+        this.simulator,
+        isIncoming ? this.ivpkM : undefined,
+        isOutgoing ? this.ovpkM : undefined,
+        payload,
+        txHash,
+        newNoteHashes,
+        dataStartIndexForTx,
+        excludedIndices,
+        this.log,
+      );
+
+      if (isIncoming) {
+        if (!incomingNote) {
+          throw new Error('Deferred incoming note could not be decoded');
+        }
+        incomingNotes.push(incomingNote);
+        this.stats.decryptedIncoming++;
+      }
+      if (outgoingNote) {
+        if (!outgoingNote) {
+          throw new Error('Deferred outgoing note could not be decoded');
+        }
+        outgoingNotes.push(outgoingNote);
+        this.stats.decryptedOutgoing++;
       }
     }
 
-    return noteDaos;
+    return { incomingNotes, outgoingNotes };
   }
 }