@aztec/pxe 0.41.0 → 0.43.0

package/src/note_processor/note_processor.ts

@@ -1,36 +1,34 @@
-import {
-  type AztecNode,
-  type EncryptedL2BlockL2Logs,
-  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: EncryptedL2BlockL2Logs[]): 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,57 @@ 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 incomingTaggedNote = TaggedLog.decryptAsIncoming(log.data, ivskM)!;
+            const outgoingTaggedNote = TaggedLog.decryptAsOutgoing(log.data, ovskM)!;
+
+            if (incomingTaggedNote || outgoingTaggedNote) {
+              // TODO(#7053): Re-enable this check
+              // 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)}`,
+              //   );
+              // }
+
+              const payload = incomingTaggedNote?.payload || outgoingTaggedNote?.payload;
+
               const txHash = block.body.txEffects[indexOfTxInABlock].txHash;
-              try {
-                const noteDao = await produceNoteDao(
-                  this.simulator,
-                  this.masterIncomingViewingPublicKey,
-                  payload,
-                  txHash,
-                  newNoteHashes,
-                  dataStartIndexForTx,
-                  excludedIndices,
-                );
-                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 { 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 +205,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 +230,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 +262,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 +292,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 };
   }
 }