@aztec/pxe 0.41.0 → 0.43.0

package/src/database/kv_pxe_database.ts

@@ -1,4 +1,10 @@
-import { MerkleTreeId, type NoteFilter, NoteStatus, type PublicKey } from '@aztec/circuit-types';
+import {
+  type IncomingNotesFilter,
+  MerkleTreeId,
+  NoteStatus,
+  type OutgoingNotesFilter,
+  type PublicKey,
+} from '@aztec/circuit-types';
 import { AztecAddress, CompleteAddress, Header } from '@aztec/circuits.js';
 import { type ContractArtifact } from '@aztec/foundation/abi';
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
@@ -14,7 +20,8 @@ import { contractArtifactFromBuffer, contractArtifactToBuffer } from '@aztec/typ
 import { type ContractInstanceWithAddress, SerializableContractInstance } from '@aztec/types/contracts';
 
 import { DeferredNoteDao } from './deferred_note_dao.js';
-import { NoteDao } from './note_dao.js';
+import { IncomingNoteDao } from './incoming_note_dao.js';
+import { OutgoingNoteDao } from './outgoing_note_dao.js';
 import { type PxeDatabase } from './pxe_database.js';
 
 /**
@@ -32,11 +39,11 @@ export class KVPxeDatabase implements PxeDatabase {
   #notesByContract: AztecMultiMap<string, string>;
   #notesByStorageSlot: AztecMultiMap<string, string>;
   #notesByTxHash: AztecMultiMap<string, string>;
-  #notesByOwner: AztecMultiMap<string, string>;
+  #notesByIvpkM: AztecMultiMap<string, string>;
   #nullifiedNotesByContract: AztecMultiMap<string, string>;
   #nullifiedNotesByStorageSlot: AztecMultiMap<string, string>;
   #nullifiedNotesByTxHash: AztecMultiMap<string, string>;
-  #nullifiedNotesByOwner: AztecMultiMap<string, string>;
+  #nullifiedNotesByIvpkM: AztecMultiMap<string, string>;
   #deferredNotes: AztecArray<Buffer | null>;
   #deferredNotesByContract: AztecMultiMap<string, number>;
   #syncedBlockPerPublicKey: AztecMap<string, number>;
@@ -44,6 +51,12 @@ export class KVPxeDatabase implements PxeDatabase {
   #contractInstances: AztecMap<string, Buffer>;
   #db: AztecKVStore;
 
+  #outgoingNotes: AztecMap<string, Buffer>;
+  #outgoingNotesByContract: AztecMultiMap<string, string>;
+  #outgoingNotesByStorageSlot: AztecMultiMap<string, string>;
+  #outgoingNotesByTxHash: AztecMultiMap<string, string>;
+  #outgoingNotesByOvpkM: AztecMultiMap<string, string>;
+
   constructor(private db: AztecKVStore) {
     this.#db = db;
 
@@ -66,15 +79,21 @@ export class KVPxeDatabase implements PxeDatabase {
     this.#notesByContract = db.openMultiMap('notes_by_contract');
     this.#notesByStorageSlot = db.openMultiMap('notes_by_storage_slot');
     this.#notesByTxHash = db.openMultiMap('notes_by_tx_hash');
-    this.#notesByOwner = db.openMultiMap('notes_by_owner');
+    this.#notesByIvpkM = db.openMultiMap('notes_by_ivpk_m');
 
     this.#nullifiedNotesByContract = db.openMultiMap('nullified_notes_by_contract');
     this.#nullifiedNotesByStorageSlot = db.openMultiMap('nullified_notes_by_storage_slot');
     this.#nullifiedNotesByTxHash = db.openMultiMap('nullified_notes_by_tx_hash');
-    this.#nullifiedNotesByOwner = db.openMultiMap('nullified_notes_by_owner');
+    this.#nullifiedNotesByIvpkM = db.openMultiMap('nullified_notes_by_ivpk_m');
 
     this.#deferredNotes = db.openArray('deferred_notes');
     this.#deferredNotesByContract = db.openMultiMap('deferred_notes_by_contract');
+
+    this.#outgoingNotes = db.openMap('outgoing_notes');
+    this.#outgoingNotesByContract = db.openMultiMap('outgoing_notes_by_contract');
+    this.#outgoingNotesByStorageSlot = db.openMultiMap('outgoing_notes_by_storage_slot');
+    this.#outgoingNotesByTxHash = db.openMultiMap('outgoing_notes_by_tx_hash');
+    this.#outgoingNotesByOvpkM = db.openMultiMap('outgoing_notes_by_ovpk_m');
   }
 
   public async getContract(
@@ -135,13 +154,13 @@ export class KVPxeDatabase implements PxeDatabase {
     return val?.map(b => Fr.fromBuffer(b));
   }
 
-  async addNote(note: NoteDao): Promise<void> {
-    await this.addNotes([note]);
+  async addNote(note: IncomingNoteDao): Promise<void> {
+    await this.addNotes([note], []);
   }
 
-  addNotes(notes: NoteDao[]): Promise<void> {
+  addNotes(incomingNotes: IncomingNoteDao[], outgoingNotes: OutgoingNoteDao[]): Promise<void> {
     return this.db.transaction(() => {
-      for (const dao of notes) {
+      for (const dao of incomingNotes) {
         // store notes by their index in the notes hash tree
         // this provides the uniqueness we need to store individual notes
         // and should also return notes in the order that they were created.
@@ -152,7 +171,16 @@ export class KVPxeDatabase implements PxeDatabase {
         void this.#notesByContract.set(dao.contractAddress.toString(), noteIndex);
         void this.#notesByStorageSlot.set(dao.storageSlot.toString(), noteIndex);
         void this.#notesByTxHash.set(dao.txHash.toString(), noteIndex);
-        void this.#notesByOwner.set(dao.publicKey.toString(), noteIndex);
+        void this.#notesByIvpkM.set(dao.ivpkM.toString(), noteIndex);
+      }
+
+      for (const dao of outgoingNotes) {
+        const noteIndex = toBufferBE(dao.index, 32).toString('hex');
+        void this.#outgoingNotes.set(noteIndex, dao.toBuffer());
+        void this.#outgoingNotesByContract.set(dao.contractAddress.toString(), noteIndex);
+        void this.#outgoingNotesByStorageSlot.set(dao.storageSlot.toString(), noteIndex);
+        void this.#outgoingNotesByTxHash.set(dao.txHash.toString(), noteIndex);
+        void this.#outgoingNotesByOvpkM.set(dao.ovpkM.toString(), noteIndex);
       }
     });
   }
@@ -207,7 +235,7 @@ export class KVPxeDatabase implements PxeDatabase {
     });
   }
 
-  #getNotes(filter: NoteFilter): NoteDao[] {
+  getIncomingNotes(filter: IncomingNotesFilter): Promise<IncomingNoteDao[]> {
     const publicKey: PublicKey | undefined = filter.owner
       ? this.#getCompleteAddress(filter.owner)?.publicKeys.masterIncomingViewingPublicKey
       : undefined;
@@ -218,7 +246,7 @@ export class KVPxeDatabase implements PxeDatabase {
 
     candidateNoteSources.push({
       ids: publicKey
-        ? this.#notesByOwner.getValues(publicKey.toString())
+        ? this.#notesByIvpkM.getValues(publicKey.toString())
         : filter.txHash
         ? this.#notesByTxHash.getValues(filter.txHash.toString())
         : filter.contractAddress
@@ -232,7 +260,7 @@ export class KVPxeDatabase implements PxeDatabase {
     if (filter.status == NoteStatus.ACTIVE_OR_NULLIFIED) {
       candidateNoteSources.push({
         ids: publicKey
-          ? this.#nullifiedNotesByOwner.getValues(publicKey.toString())
+          ? this.#nullifiedNotesByIvpkM.getValues(publicKey.toString())
           : filter.txHash
           ? this.#nullifiedNotesByTxHash.getValues(filter.txHash.toString())
           : filter.contractAddress
@@ -244,7 +272,7 @@ export class KVPxeDatabase implements PxeDatabase {
       });
     }
 
-    const result: NoteDao[] = [];
+    const result: IncomingNoteDao[] = [];
     for (const { ids, notes } of candidateNoteSources) {
       for (const id of ids) {
         const serializedNote = notes.get(id);
@@ -252,7 +280,7 @@ export class KVPxeDatabase implements PxeDatabase {
           continue;
         }
 
-        const note = NoteDao.fromBuffer(serializedNote);
+        const note = IncomingNoteDao.fromBuffer(serializedNote);
         if (filter.contractAddress && !note.contractAddress.equals(filter.contractAddress)) {
           continue;
         }
@@ -265,7 +293,11 @@ export class KVPxeDatabase implements PxeDatabase {
           continue;
         }
 
-        if (publicKey && !note.publicKey.equals(publicKey)) {
+        if (publicKey && !note.ivpkM.equals(publicKey)) {
+          continue;
+        }
+
+        if (filter.siloedNullifier && !note.siloedNullifier.equals(filter.siloedNullifier)) {
           continue;
         }
 
@@ -273,20 +305,66 @@ export class KVPxeDatabase implements PxeDatabase {
       }
     }
 
-    return result;
+    return Promise.resolve(result);
   }
 
-  getNotes(filter: NoteFilter): Promise<NoteDao[]> {
-    return Promise.resolve(this.#getNotes(filter));
+  getOutgoingNotes(filter: OutgoingNotesFilter): Promise<OutgoingNoteDao[]> {
+    const ovpkM: PublicKey | undefined = filter.owner
+      ? this.#getCompleteAddress(filter.owner)?.publicKeys.masterOutgoingViewingPublicKey
+      : undefined;
+
+    // Check if ovpkM is truthy
+    const ids = ovpkM
+      ? this.#outgoingNotesByOvpkM.getValues(ovpkM.toString())
+      : // If ovpkM is falsy, check if filter.txHash is truthy
+      filter.txHash
+      ? this.#outgoingNotesByTxHash.getValues(filter.txHash.toString())
+      : // If both ovpkM and filter.txHash are falsy, check if filter.contractAddress is truthy
+      filter.contractAddress
+      ? this.#outgoingNotesByContract.getValues(filter.contractAddress.toString())
+      : // If ovpkM, filter.txHash, and filter.contractAddress are all falsy, check if filter.storageSlot is truthy
+      filter.storageSlot
+      ? this.#outgoingNotesByStorageSlot.getValues(filter.storageSlot.toString())
+      : // If none of the above conditions are met, retrieve all keys from this.#outgoingNotes
+        this.#outgoingNotes.keys();
+
+    const notes: OutgoingNoteDao[] = [];
+    for (const id of ids) {
+      const serializedNote = this.#outgoingNotes.get(id);
+      if (!serializedNote) {
+        continue;
+      }
+
+      const note = OutgoingNoteDao.fromBuffer(serializedNote);
+      if (filter.contractAddress && !note.contractAddress.equals(filter.contractAddress)) {
+        continue;
+      }
+
+      if (filter.txHash && !note.txHash.equals(filter.txHash)) {
+        continue;
+      }
+
+      if (filter.storageSlot && !note.storageSlot.equals(filter.storageSlot!)) {
+        continue;
+      }
+
+      if (ovpkM && !note.ovpkM.equals(ovpkM)) {
+        continue;
+      }
+
+      notes.push(note);
+    }
+
+    return Promise.resolve(notes);
   }
 
-  removeNullifiedNotes(nullifiers: Fr[], account: PublicKey): Promise<NoteDao[]> {
+  removeNullifiedNotes(nullifiers: Fr[], account: PublicKey): Promise<IncomingNoteDao[]> {
     if (nullifiers.length === 0) {
       return Promise.resolve([]);
     }
 
     return this.#db.transaction(() => {
-      const nullifiedNotes: NoteDao[] = [];
+      const nullifiedNotes: IncomingNoteDao[] = [];
 
       for (const nullifier of nullifiers) {
         const noteIndex = this.#nullifierToNoteId.get(nullifier.toString());
@@ -301,8 +379,8 @@ export class KVPxeDatabase implements PxeDatabase {
           continue;
         }
 
-        const note = NoteDao.fromBuffer(noteBuffer);
-        if (!note.publicKey.equals(account)) {
+        const note = IncomingNoteDao.fromBuffer(noteBuffer);
+        if (!note.ivpkM.equals(account)) {
           // tried to nullify someone else's note
           continue;
         }
@@ -310,7 +388,7 @@ export class KVPxeDatabase implements PxeDatabase {
         nullifiedNotes.push(note);
 
         void this.#notes.delete(noteIndex);
-        void this.#notesByOwner.deleteValue(account.toString(), noteIndex);
+        void this.#notesByIvpkM.deleteValue(account.toString(), noteIndex);
         void this.#notesByTxHash.deleteValue(note.txHash.toString(), noteIndex);
         void this.#notesByContract.deleteValue(note.contractAddress.toString(), noteIndex);
         void this.#notesByStorageSlot.deleteValue(note.storageSlot.toString(), noteIndex);
@@ -319,7 +397,7 @@ export class KVPxeDatabase implements PxeDatabase {
         void this.#nullifiedNotesByContract.set(note.contractAddress.toString(), noteIndex);
         void this.#nullifiedNotesByStorageSlot.set(note.storageSlot.toString(), noteIndex);
         void this.#nullifiedNotesByTxHash.set(note.txHash.toString(), noteIndex);
-        void this.#nullifiedNotesByOwner.set(note.publicKey.toString(), noteIndex);
+        void this.#nullifiedNotesByIvpkM.set(note.ivpkM.toString(), noteIndex);
 
         void this.#nullifierToNoteId.delete(nullifier.toString());
       }
@@ -328,6 +406,18 @@ export class KVPxeDatabase implements PxeDatabase {
     });
   }
 
+  async addNullifiedNote(note: IncomingNoteDao): Promise<void> {
+    const noteIndex = toBufferBE(note.index, 32).toString('hex');
+
+    await this.#nullifiedNotes.set(noteIndex, note.toBuffer());
+    await this.#nullifiedNotesByContract.set(note.contractAddress.toString(), noteIndex);
+    await this.#nullifiedNotesByStorageSlot.set(note.storageSlot.toString(), noteIndex);
+    await this.#nullifiedNotesByTxHash.set(note.txHash.toString(), noteIndex);
+    await this.#nullifiedNotesByIvpkM.set(note.ivpkM.toString(), noteIndex);
+
+    return Promise.resolve();
+  }
+
   async setHeader(header: Header): Promise<void> {
     await this.#synchronizedBlock.set(header.toBuffer());
   }
@@ -401,8 +491,16 @@ export class KVPxeDatabase implements PxeDatabase {
     return this.#syncedBlockPerPublicKey.set(publicKey.toString(), blockNumber);
   }
 
-  estimateSize(): number {
-    const notesSize = Array.from(this.#getNotes({})).reduce((sum, note) => sum + note.getSize(), 0);
+  async estimateSize(): Promise<number> {
+    const incomingNotesSize = Array.from(await this.getIncomingNotes({})).reduce(
+      (sum, note) => sum + note.getSize(),
+      0,
+    );
+    const outgoingNotesSize = Array.from(await this.getOutgoingNotes({})).reduce(
+      (sum, note) => sum + note.getSize(),
+      0,
+    );
+
     const authWitsSize = Array.from(this.#authWitnesses.values()).reduce(
       (sum, value) => sum + value.length * Fr.SIZE_IN_BYTES,
       0,
@@ -410,6 +508,6 @@ export class KVPxeDatabase implements PxeDatabase {
     const addressesSize = this.#addresses.length * CompleteAddress.SIZE_IN_BYTES;
     const treeRootsSize = Object.keys(MerkleTreeId).length * Fr.SIZE_IN_BYTES;
 
-    return notesSize + treeRootsSize + authWitsSize + addressesSize;
+    return incomingNotesSize + outgoingNotesSize + treeRootsSize + authWitsSize + addressesSize;
   }
 }

package/src/database/outgoing_note_dao.ts

@@ -0,0 +1,90 @@
+import { Note, TxHash } from '@aztec/circuit-types';
+import { AztecAddress, Fr, Point, type PublicKey } from '@aztec/circuits.js';
+import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+/**
+ * A note with contextual data which was decrypted as outgoing.
+ */
+export class OutgoingNoteDao {
+  constructor(
+    /** The note as emitted from the Noir contract. */
+    public note: Note,
+    /** The contract address this note is created in. */
+    public contractAddress: AztecAddress,
+    /** The specific storage location of the note on the contract. */
+    public storageSlot: Fr,
+    /** The note type identifier for the contract. */
+    public noteTypeId: Fr,
+    /** The hash of the tx the note was created in. */
+    public txHash: TxHash,
+    /** The nonce of the note. */
+    public nonce: Fr,
+    /**
+     * Inner note hash of the note. This is customizable by the app circuit.
+     * We can use this value to compute siloedNoteHash and uniqueSiloedNoteHash.
+     */
+    public innerNoteHash: Fr,
+    /** The location of the relevant note in the note hash tree. */
+    public index: bigint,
+    /** The public key with which the note was encrypted. */
+    public ovpkM: PublicKey,
+  ) {}
+
+  toBuffer(): Buffer {
+    return serializeToBuffer([
+      this.note,
+      this.contractAddress,
+      this.storageSlot,
+      this.noteTypeId,
+      this.txHash.buffer,
+      this.nonce,
+      this.innerNoteHash,
+      this.index,
+      this.ovpkM,
+    ]);
+  }
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+
+    const note = Note.fromBuffer(reader);
+    const contractAddress = AztecAddress.fromBuffer(reader);
+    const storageSlot = Fr.fromBuffer(reader);
+    const noteTypeId = Fr.fromBuffer(reader);
+    const txHash = new TxHash(reader.readBytes(TxHash.SIZE));
+    const nonce = Fr.fromBuffer(reader);
+    const innerNoteHash = Fr.fromBuffer(reader);
+    const index = toBigIntBE(reader.readBytes(32));
+    const publicKey = Point.fromBuffer(reader);
+
+    return new OutgoingNoteDao(
+      note,
+      contractAddress,
+      storageSlot,
+      noteTypeId,
+      txHash,
+      nonce,
+      innerNoteHash,
+      index,
+      publicKey,
+    );
+  }
+
+  toString() {
+    return '0x' + this.toBuffer().toString('hex');
+  }
+
+  static fromString(str: string) {
+    const hex = str.replace(/^0x/, '');
+    return OutgoingNoteDao.fromBuffer(Buffer.from(hex, 'hex'));
+  }
+
+  /**
+   * Returns the size in bytes of the Note Dao.
+   * @returns - Its size in bytes.
+   */
+  public getSize() {
+    const noteSize = 4 + this.note.items.length * Fr.SIZE_IN_BYTES;
+    return noteSize + AztecAddress.SIZE_IN_BYTES + Fr.SIZE_IN_BYTES * 2 + TxHash.SIZE + Point.SIZE_IN_BYTES;
+  }
+}

package/src/database/pxe_database.ts

@@ -1,4 +1,4 @@
-import { type NoteFilter } from '@aztec/circuit-types';
+import { type IncomingNotesFilter, type OutgoingNotesFilter } from '@aztec/circuit-types';
 import { type CompleteAddress, type Header, type PublicKey } from '@aztec/circuits.js';
 import { type ContractArtifact } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
@@ -8,7 +8,8 @@ import { type ContractInstanceWithAddress } from '@aztec/types/contracts';
 import { type ContractArtifactDatabase } from './contracts/contract_artifact_db.js';
 import { type ContractInstanceDatabase } from './contracts/contract_instance_db.js';
 import { type DeferredNoteDao } from './deferred_note_dao.js';
-import { type NoteDao } from './note_dao.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
@@ -46,26 +47,39 @@ export interface PxeDatabase extends ContractArtifactDatabase, ContractInstanceD
   popCapsule(): Promise<Fr[] | undefined>;
 
   /**
-   * Gets notes based on the provided filter.
+   * Gets incoming notes based on the provided filter.
    * @param filter - The filter to apply to the notes.
    * @returns The requested notes.
    */
-  getNotes(filter: NoteFilter): Promise<NoteDao[]>;
+  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.
    */
-  addNote(note: NoteDao): Promise<void>;
+  addNote(note: IncomingNoteDao): Promise<void>;
+
+  /**
+   * Adds a nullified note to DB.
+   * @param note - The note to add.
+   */
+  addNullifiedNote(note: IncomingNoteDao): Promise<void>;
 
   /**
    * Adds an array of notes to DB.
    * This function is used to insert multiple notes to the database at once,
    * which can improve performance when dealing with large numbers of transactions.
    *
-   * @param notes - An array of notes.
+   * @param incomingNotes - An array of notes which were decrypted as incoming.
+   * @param outgoingNotes - An array of notes which were decrypted as outgoing.
    */
-  addNotes(notes: NoteDao[]): Promise<void>;
+  addNotes(incomingNotes: IncomingNoteDao[], outgoingNotes: OutgoingNoteDao[]): Promise<void>;
 
   /**
    * Add notes to the database that are intended for us, but we don't yet have the contract.
@@ -93,7 +107,7 @@ export interface PxeDatabase extends ContractArtifactDatabase, ContractInstanceD
    * @param account - A PublicKey instance representing the account for which the records are being removed.
    * @returns Removed notes.
    */
-  removeNullifiedNotes(nullifiers: Fr[], account: PublicKey): Promise<NoteDao[]>;
+  removeNullifiedNotes(nullifiers: Fr[], account: PublicKey): Promise<IncomingNoteDao[]>;
 
   /**
    * Gets the most recently processed block number.
@@ -162,5 +176,5 @@ export interface PxeDatabase extends ContractArtifactDatabase, ContractInstanceD
    * Returns the estimated size in bytes of this db.
    * @returns The estimated size in bytes of this db.
    */
-  estimateSize(): number;
+  estimateSize(): Promise<number>;
 }