@aztec/pxe 0.63.0 → 0.64.0

package/src/database/kv_pxe_database.ts

@@ -1,4 +1,10 @@
-import { type IncomingNotesFilter, MerkleTreeId, NoteStatus, type OutgoingNotesFilter } from '@aztec/circuit-types';
+import {
+  type InBlock,
+  type IncomingNotesFilter,
+  MerkleTreeId,
+  NoteStatus,
+  type OutgoingNotesFilter,
+} from '@aztec/circuit-types';
 import {
   AztecAddress,
   CompleteAddress,
@@ -7,9 +13,8 @@ import {
   type IndexedTaggingSecret,
   type PublicKey,
   SerializableContractInstance,
-  computePoint,
 } from '@aztec/circuits.js';
-import { type ContractArtifact } from '@aztec/foundation/abi';
+import { type ContractArtifact, FunctionSelector, FunctionType } from '@aztec/foundation/abi';
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { Fr } from '@aztec/foundation/fields';
 import {
@@ -39,11 +44,14 @@ export class KVPxeDatabase implements PxeDatabase {
   #notes: AztecMap<string, Buffer>;
   #nullifiedNotes: AztecMap<string, Buffer>;
   #nullifierToNoteId: AztecMap<string, string>;
+  #nullifiersByBlockNumber: AztecMultiMap<number, string>;
 
+  #nullifiedNotesToScope: AztecMultiMap<string, string>;
   #nullifiedNotesByContract: AztecMultiMap<string, string>;
   #nullifiedNotesByStorageSlot: AztecMultiMap<string, string>;
   #nullifiedNotesByTxHash: AztecMultiMap<string, string>;
   #nullifiedNotesByAddressPoint: AztecMultiMap<string, string>;
+  #nullifiedNotesByNullifier: AztecMap<string, string>;
   #syncedBlockPerPublicKey: AztecMap<string, number>;
   #contractArtifacts: AztecMap<string, Buffer>;
   #contractInstances: AztecMap<string, Buffer>;
@@ -56,6 +64,7 @@ export class KVPxeDatabase implements PxeDatabase {
   #outgoingNotesByOvpkM: AztecMultiMap<string, string>;
 
   #scopes: AztecSet<string>;
+  #notesToScope: AztecMultiMap<string, string>;
   #notesByContractAndScope: Map<string, AztecMultiMap<string, string>>;
   #notesByStorageSlotAndScope: Map<string, AztecMultiMap<string, string>>;
   #notesByTxHashAndScope: Map<string, AztecMultiMap<string, string>>;
@@ -87,11 +96,14 @@ export class KVPxeDatabase implements PxeDatabase {
     this.#notes = db.openMap('notes');
     this.#nullifiedNotes = db.openMap('nullified_notes');
     this.#nullifierToNoteId = db.openMap('nullifier_to_note');
+    this.#nullifiersByBlockNumber = db.openMultiMap('nullifier_to_block_number');
 
+    this.#nullifiedNotesToScope = db.openMultiMap('nullified_notes_to_scope');
     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.#nullifiedNotesByAddressPoint = db.openMultiMap('nullified_notes_by_address_point');
+    this.#nullifiedNotesByNullifier = db.openMap('nullified_notes_by_nullifier');
 
     this.#outgoingNotes = db.openMap('outgoing_notes');
     this.#outgoingNotesByContract = db.openMultiMap('outgoing_notes_by_contract');
@@ -100,6 +112,7 @@ export class KVPxeDatabase implements PxeDatabase {
     this.#outgoingNotesByOvpkM = db.openMultiMap('outgoing_notes_by_ovpk_m');
 
     this.#scopes = db.openSet('scopes');
+    this.#notesToScope = db.openMultiMap('notes_to_scope');
     this.#notesByContractAndScope = new Map<string, AztecMultiMap<string, string>>();
     this.#notesByStorageSlotAndScope = new Map<string, AztecMultiMap<string, string>>();
     this.#notesByTxHashAndScope = new Map<string, AztecMultiMap<string, string>>();
@@ -128,6 +141,19 @@ export class KVPxeDatabase implements PxeDatabase {
   }
 
   public async addContractArtifact(id: Fr, contract: ContractArtifact): Promise<void> {
+    const privateSelectors = contract.functions
+      .filter(functionArtifact => functionArtifact.functionType === FunctionType.PRIVATE)
+      .map(privateFunctionArtifact =>
+        FunctionSelector.fromNameAndParameters(
+          privateFunctionArtifact.name,
+          privateFunctionArtifact.parameters,
+        ).toString(),
+      );
+
+    if (privateSelectors.length !== new Set(privateSelectors).size) {
+      throw new Error('Repeated function selectors of private functions');
+    }
+
     await this.#contractArtifacts.set(id.toString(), contractArtifactToBuffer(contract));
   }
 
@@ -195,6 +221,7 @@ export class KVPxeDatabase implements PxeDatabase {
         // Had we stored them by their nullifier, they would be returned in random order
         const noteIndex = toBufferBE(dao.index, 32).toString('hex');
         void this.#notes.set(noteIndex, dao.toBuffer());
+        void this.#notesToScope.set(noteIndex, scope.toString());
         void this.#nullifierToNoteId.set(dao.siloedNullifier.toString(), noteIndex);
 
         void this.#notesByContractAndScope.get(scope.toString())!.set(dao.contractAddress.toString(), noteIndex);
@@ -214,8 +241,92 @@ export class KVPxeDatabase implements PxeDatabase {
     });
   }
 
+  public removeNotesAfter(blockNumber: number): Promise<void> {
+    return this.db.transaction(() => {
+      for (const note of this.#notes.values()) {
+        const noteDao = IncomingNoteDao.fromBuffer(note);
+        if (noteDao.l2BlockNumber > blockNumber) {
+          const noteIndex = toBufferBE(noteDao.index, 32).toString('hex');
+          void this.#notes.delete(noteIndex);
+          void this.#notesToScope.delete(noteIndex);
+          void this.#nullifierToNoteId.delete(noteDao.siloedNullifier.toString());
+          for (const scope of this.#scopes.entries()) {
+            void this.#notesByAddressPointAndScope.get(scope)!.deleteValue(noteDao.addressPoint.toString(), noteIndex);
+            void this.#notesByTxHashAndScope.get(scope)!.deleteValue(noteDao.txHash.toString(), noteIndex);
+            void this.#notesByContractAndScope.get(scope)!.deleteValue(noteDao.contractAddress.toString(), noteIndex);
+            void this.#notesByStorageSlotAndScope.get(scope)!.deleteValue(noteDao.storageSlot.toString(), noteIndex);
+          }
+        }
+      }
+
+      for (const note of this.#outgoingNotes.values()) {
+        const noteDao = OutgoingNoteDao.fromBuffer(note);
+        if (noteDao.l2BlockNumber > blockNumber) {
+          const noteIndex = toBufferBE(noteDao.index, 32).toString('hex');
+          void this.#outgoingNotes.delete(noteIndex);
+          void this.#outgoingNotesByContract.deleteValue(noteDao.contractAddress.toString(), noteIndex);
+          void this.#outgoingNotesByStorageSlot.deleteValue(noteDao.storageSlot.toString(), noteIndex);
+          void this.#outgoingNotesByTxHash.deleteValue(noteDao.txHash.toString(), noteIndex);
+          void this.#outgoingNotesByOvpkM.deleteValue(noteDao.ovpkM.toString(), noteIndex);
+        }
+      }
+    });
+  }
+
+  public async unnullifyNotesAfter(blockNumber: number): Promise<void> {
+    const nullifiersToUndo: string[] = [];
+    const currentBlockNumber = blockNumber + 1;
+    const maxBlockNumber = this.getBlockNumber() ?? currentBlockNumber;
+    for (let i = currentBlockNumber; i <= maxBlockNumber; i++) {
+      nullifiersToUndo.push(...this.#nullifiersByBlockNumber.getValues(i));
+    }
+
+    const notesIndexesToReinsert = await this.db.transaction(() =>
+      nullifiersToUndo.map(nullifier => this.#nullifiedNotesByNullifier.get(nullifier)),
+    );
+    const nullifiedNoteBuffers = await this.db.transaction(() => {
+      return notesIndexesToReinsert
+        .filter(noteIndex => noteIndex != undefined)
+        .map(noteIndex => this.#nullifiedNotes.get(noteIndex!));
+    });
+    const noteDaos = nullifiedNoteBuffers
+      .filter(buffer => buffer != undefined)
+      .map(buffer => IncomingNoteDao.fromBuffer(buffer!));
+
+    await this.db.transaction(() => {
+      for (const dao of noteDaos) {
+        const noteIndex = toBufferBE(dao.index, 32).toString('hex');
+        void this.#notes.set(noteIndex, dao.toBuffer());
+        void this.#nullifierToNoteId.set(dao.siloedNullifier.toString(), noteIndex);
+
+        let scopes = Array.from(this.#nullifiedNotesToScope.getValues(noteIndex) ?? []);
+
+        if (scopes.length === 0) {
+          scopes = [new AztecAddress(dao.addressPoint.x).toString()];
+        }
+
+        for (const scope of scopes) {
+          void this.#notesByContractAndScope.get(scope)!.set(dao.contractAddress.toString(), noteIndex);
+          void this.#notesByStorageSlotAndScope.get(scope)!.set(dao.storageSlot.toString(), noteIndex);
+          void this.#notesByTxHashAndScope.get(scope)!.set(dao.txHash.toString(), noteIndex);
+          void this.#notesByAddressPointAndScope.get(scope)!.set(dao.addressPoint.toString(), noteIndex);
+          void this.#notesToScope.set(noteIndex, scope);
+        }
+
+        void this.#nullifiedNotes.delete(noteIndex);
+        void this.#nullifiedNotesToScope.delete(noteIndex);
+        void this.#nullifiersByBlockNumber.deleteValue(dao.l2BlockNumber, dao.siloedNullifier.toString());
+        void this.#nullifiedNotesByContract.deleteValue(dao.contractAddress.toString(), noteIndex);
+        void this.#nullifiedNotesByStorageSlot.deleteValue(dao.storageSlot.toString(), noteIndex);
+        void this.#nullifiedNotesByTxHash.deleteValue(dao.txHash.toString(), noteIndex);
+        void this.#nullifiedNotesByAddressPoint.deleteValue(dao.addressPoint.toString(), noteIndex);
+        void this.#nullifiedNotesByNullifier.delete(dao.siloedNullifier.toString());
+      }
+    });
+  }
+
   getIncomingNotes(filter: IncomingNotesFilter): Promise<IncomingNoteDao[]> {
-    const publicKey: PublicKey | undefined = filter.owner ? computePoint(filter.owner) : undefined;
+    const publicKey: PublicKey | undefined = filter.owner ? filter.owner.toAddressPoint() : undefined;
 
     filter.status = filter.status ?? NoteStatus.ACTIVE;
 
@@ -350,7 +461,7 @@ export class KVPxeDatabase implements PxeDatabase {
     return Promise.resolve(notes);
   }
 
-  removeNullifiedNotes(nullifiers: Fr[], accountAddressPoint: PublicKey): Promise<IncomingNoteDao[]> {
+  removeNullifiedNotes(nullifiers: InBlock<Fr>[], accountAddressPoint: PublicKey): Promise<IncomingNoteDao[]> {
     if (nullifiers.length === 0) {
       return Promise.resolve([]);
     }
@@ -358,7 +469,8 @@ export class KVPxeDatabase implements PxeDatabase {
     return this.#db.transaction(() => {
       const nullifiedNotes: IncomingNoteDao[] = [];
 
-      for (const nullifier of nullifiers) {
+      for (const blockScopedNullifier of nullifiers) {
+        const { data: nullifier, l2BlockNumber: blockNumber } = blockScopedNullifier;
         const noteIndex = this.#nullifierToNoteId.get(nullifier.toString());
         if (!noteIndex) {
           continue;
@@ -370,7 +482,7 @@ export class KVPxeDatabase implements PxeDatabase {
           // note doesn't exist. Maybe it got nullified already
           continue;
         }
-
+        const noteScopes = this.#notesToScope.getValues(noteIndex) ?? [];
         const note = IncomingNoteDao.fromBuffer(noteBuffer);
         if (!note.addressPoint.equals(accountAddressPoint)) {
           // tried to nullify someone else's note
@@ -380,19 +492,27 @@ export class KVPxeDatabase implements PxeDatabase {
         nullifiedNotes.push(note);
 
         void this.#notes.delete(noteIndex);
+        void this.#notesToScope.delete(noteIndex);
 
-        for (const scope in this.#scopes.entries()) {
+        for (const scope of this.#scopes.entries()) {
           void this.#notesByAddressPointAndScope.get(scope)!.deleteValue(accountAddressPoint.toString(), noteIndex);
           void this.#notesByTxHashAndScope.get(scope)!.deleteValue(note.txHash.toString(), noteIndex);
           void this.#notesByContractAndScope.get(scope)!.deleteValue(note.contractAddress.toString(), noteIndex);
           void this.#notesByStorageSlotAndScope.get(scope)!.deleteValue(note.storageSlot.toString(), noteIndex);
         }
 
+        if (noteScopes !== undefined) {
+          for (const scope of noteScopes) {
+            void this.#nullifiedNotesToScope.set(noteIndex, scope);
+          }
+        }
         void this.#nullifiedNotes.set(noteIndex, note.toBuffer());
+        void this.#nullifiersByBlockNumber.set(blockNumber, nullifier.toString());
         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.#nullifiedNotesByAddressPoint.set(note.addressPoint.toString(), noteIndex);
+        void this.#nullifiedNotesByNullifier.set(nullifier.toString(), noteIndex);
 
         void this.#nullifierToNoteId.delete(nullifier.toString());
       }
@@ -548,25 +668,19 @@ export class KVPxeDatabase implements PxeDatabase {
     return incomingNotesSize + outgoingNotesSize + treeRootsSize + authWitsSize + addressesSize;
   }
 
-  async incrementTaggingSecretsIndexesAsSender(appTaggingSecrets: Fr[]): Promise<void> {
-    await this.#incrementTaggingSecretsIndexes(appTaggingSecrets, this.#taggingSecretIndexesForSenders);
+  async setTaggingSecretsIndexesAsSender(indexedSecrets: IndexedTaggingSecret[]): Promise<void> {
+    await this.#setTaggingSecretsIndexes(indexedSecrets, this.#taggingSecretIndexesForSenders);
   }
 
-  async #incrementTaggingSecretsIndexes(appTaggingSecrets: Fr[], storageMap: AztecMap<string, number>): Promise<void> {
-    const indexes = await this.#getTaggingSecretsIndexes(appTaggingSecrets, storageMap);
-    await this.db.transaction(() => {
-      indexes.forEach((taggingSecretIndex, listIndex) => {
-        const nextIndex = taggingSecretIndex + 1;
-        void storageMap.set(appTaggingSecrets[listIndex].toString(), nextIndex);
-      });
-    });
+  async setTaggingSecretsIndexesAsRecipient(indexedSecrets: IndexedTaggingSecret[]): Promise<void> {
+    await this.#setTaggingSecretsIndexes(indexedSecrets, this.#taggingSecretIndexesForRecipients);
   }
 
-  async setTaggingSecretsIndexesAsRecipient(indexedSecrets: IndexedTaggingSecret[]): Promise<void> {
-    await this.db.transaction(() => {
-      indexedSecrets.forEach(indexedSecret => {
-        void this.#taggingSecretIndexesForRecipients.set(indexedSecret.secret.toString(), indexedSecret.index);
-      });
+  #setTaggingSecretsIndexes(indexedSecrets: IndexedTaggingSecret[], storageMap: AztecMap<string, number>) {
+    return this.db.transaction(() => {
+      indexedSecrets.forEach(
+        indexedSecret => void storageMap.set(indexedSecret.secret.toString(), indexedSecret.index),
+      );
     });
   }
 
@@ -581,4 +695,15 @@ export class KVPxeDatabase implements PxeDatabase {
   #getTaggingSecretsIndexes(appTaggingSecrets: Fr[], storageMap: AztecMap<string, number>): Promise<number[]> {
     return this.db.transaction(() => appTaggingSecrets.map(secret => storageMap.get(`${secret.toString()}`) ?? 0));
   }
+
+  async resetNoteSyncData(): Promise<void> {
+    await this.db.transaction(() => {
+      for (const recipient of this.#taggingSecretIndexesForRecipients.keys()) {
+        void this.#taggingSecretIndexesForRecipients.delete(recipient);
+      }
+      for (const sender of this.#taggingSecretIndexesForSenders.keys()) {
+        void this.#taggingSecretIndexesForSenders.delete(sender);
+      }
+    });
+  }
 }

package/src/database/outgoing_note_dao.ts

@@ -1,4 +1,4 @@
-import { type L1NotePayload, Note, TxHash } from '@aztec/circuit-types';
+import { type L1NotePayload, Note, TxHash, randomTxHash } from '@aztec/circuit-types';
 import { AztecAddress, Fr, Point, type PublicKey } from '@aztec/circuits.js';
 import { NoteSelector } from '@aztec/foundation/abi';
 import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
@@ -21,6 +21,10 @@ export class OutgoingNoteDao {
     public noteTypeId: NoteSelector,
     /** The hash of the tx the note was created in. */
     public txHash: TxHash,
+    /** The L2 block number in which the tx with this note was included. */
+    public l2BlockNumber: number,
+    /** The L2 block hash in which the tx with this note was included. */
+    public l2BlockHash: string,
     /** The nonce of the note. */
     public nonce: Fr,
     /**
@@ -38,6 +42,8 @@ export class OutgoingNoteDao {
     note: Note,
     payload: L1NotePayload,
     noteInfo: NoteInfo,
+    l2BlockNumber: number,
+    l2BlockHash: string,
     dataStartIndexForTx: number,
     ovpkM: PublicKey,
   ) {
@@ -48,6 +54,8 @@ export class OutgoingNoteDao {
       payload.storageSlot,
       payload.noteTypeId,
       noteInfo.txHash,
+      l2BlockNumber,
+      l2BlockHash,
       noteInfo.nonce,
       noteInfo.noteHash,
       noteHashIndexInTheWholeTree,
@@ -62,6 +70,8 @@ export class OutgoingNoteDao {
       this.storageSlot,
       this.noteTypeId,
       this.txHash.buffer,
+      this.l2BlockNumber,
+      Fr.fromString(this.l2BlockHash),
       this.nonce,
       this.noteHash,
       this.index,
@@ -76,6 +86,8 @@ export class OutgoingNoteDao {
     const storageSlot = Fr.fromBuffer(reader);
     const noteTypeId = reader.readObject(NoteSelector);
     const txHash = new TxHash(reader.readBytes(TxHash.SIZE));
+    const l2BlockNumber = reader.readNumber();
+    const l2BlockHash = Fr.fromBuffer(reader).toString();
     const nonce = Fr.fromBuffer(reader);
     const noteHash = Fr.fromBuffer(reader);
     const index = toBigIntBE(reader.readBytes(32));
@@ -87,6 +99,8 @@ export class OutgoingNoteDao {
       storageSlot,
       noteTypeId,
       txHash,
+      l2BlockNumber,
+      l2BlockHash,
       nonce,
       noteHash,
       index,
@@ -111,4 +125,32 @@ export class OutgoingNoteDao {
     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;
   }
+
+  static random({
+    note = Note.random(),
+    contractAddress = AztecAddress.random(),
+    txHash = randomTxHash(),
+    storageSlot = Fr.random(),
+    noteTypeId = NoteSelector.random(),
+    nonce = Fr.random(),
+    l2BlockNumber = Math.floor(Math.random() * 1000),
+    l2BlockHash = Fr.random().toString(),
+    noteHash = Fr.random(),
+    index = Fr.random().toBigInt(),
+    ovpkM = Point.random(),
+  }: Partial<OutgoingNoteDao> = {}) {
+    return new OutgoingNoteDao(
+      note,
+      contractAddress,
+      storageSlot,
+      noteTypeId,
+      txHash,
+      l2BlockNumber,
+      l2BlockHash,
+      nonce,
+      noteHash,
+      index,
+      ovpkM,
+    );
+  }
 }

package/src/database/pxe_database.ts

@@ -1,4 +1,4 @@
-import { type IncomingNotesFilter, type OutgoingNotesFilter } from '@aztec/circuit-types';
+import { type InBlock, type IncomingNotesFilter, type OutgoingNotesFilter } from '@aztec/circuit-types';
 import {
   type CompleteAddress,
   type ContractInstanceWithAddress,
@@ -96,7 +96,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<IncomingNoteDao[]>;
+  removeNullifiedNotes(nullifiers: InBlock<Fr>[], account: PublicKey): Promise<IncomingNoteDao[]>;
 
   /**
    * Gets the most recently processed block number.
@@ -202,11 +202,11 @@ export interface PxeDatabase extends ContractArtifactDatabase, ContractInstanceD
   getTaggingSecretsIndexesAsSender(appTaggingSecrets: Fr[]): Promise<number[]>;
 
   /**
-   * Increments the index for the provided app siloed tagging secrets in the senders database
-   * To be used when the generated tags have been used as sender
+   * Sets the index for the provided app siloed tagging secrets
+   * To be used when the generated tags have been "seen" as a sender
    * @param appTaggingSecrets - The app siloed tagging secrets.
    */
-  incrementTaggingSecretsIndexesAsSender(appTaggingSecrets: Fr[]): Promise<void>;
+  setTaggingSecretsIndexesAsSender(indexedTaggingSecrets: IndexedTaggingSecret[]): Promise<void>;
 
   /**
    * Sets the index for the provided app siloed tagging secrets
@@ -214,4 +214,24 @@ export interface PxeDatabase extends ContractArtifactDatabase, ContractInstanceD
    * @param appTaggingSecrets - The app siloed tagging secrets.
    */
   setTaggingSecretsIndexesAsRecipient(indexedTaggingSecrets: IndexedTaggingSecret[]): Promise<void>;
+
+  /**
+   * Deletes all notes synched after this block number.
+   * @param blockNumber - All notes strictly after this block number are removed.
+   */
+  removeNotesAfter(blockNumber: number): Promise<void>;
+
+  /**
+   * Restores notes nullified after the given block.
+   * @param blockNumber - All nullifiers strictly after this block are removed.
+   */
+  unnullifyNotesAfter(blockNumber: number): Promise<void>;
+
+  /**
+   * Resets the indexes used to sync notes to 0 for every sender and recipient, causing the next sync process to
+   * start from scratch, taking longer than usual.
+   * This can help fix desynchronization issues, including finding logs that had previously been overlooked, and
+   * is also required to deal with chain reorgs.
+   */
+  resetNoteSyncData(): Promise<void>;
 }

package/src/database/pxe_database_test_suite.ts

@@ -5,17 +5,16 @@ import {
   INITIAL_L2_BLOCK_NUM,
   PublicKeys,
   SerializableContractInstance,
-  computePoint,
 } from '@aztec/circuits.js';
 import { makeHeader } from '@aztec/circuits.js/testing';
+import { FunctionType } from '@aztec/foundation/abi';
 import { randomInt } from '@aztec/foundation/crypto';
 import { Fr, Point } from '@aztec/foundation/fields';
 import { BenchmarkingContractArtifact } from '@aztec/noir-contracts.js/Benchmarking';
+import { TestContractArtifact } from '@aztec/noir-contracts.js/Test';
 
-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 { IncomingNoteDao } from './incoming_note_dao.js';
+import { OutgoingNoteDao } from './outgoing_note_dao.js';
 import { type PxeDatabase } from './pxe_database.js';
 
 /**
@@ -102,7 +101,7 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
 
         [
           () => ({ owner: owners[0].address }),
-          () => notes.filter(note => note.addressPoint.equals(computePoint(owners[0].address))),
+          () => notes.filter(note => note.addressPoint.equals(owners[0].address.toAddressPoint())),
         ],
 
         [
@@ -121,11 +120,12 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
         storageSlots = Array.from({ length: 2 }).map(() => Fr.random());
 
         notes = Array.from({ length: 10 }).map((_, i) =>
-          randomIncomingNoteDao({
+          IncomingNoteDao.random({
             contractAddress: contractAddresses[i % contractAddresses.length],
             storageSlot: storageSlots[i % storageSlots.length],
-            addressPoint: computePoint(owners[i % owners.length].address),
+            addressPoint: owners[i % owners.length].address.toAddressPoint(),
             index: BigInt(i),
+            l2BlockNumber: i,
           }),
         );
 
@@ -156,9 +156,13 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
 
         // Nullify all notes and use the same filter as other test cases
         for (const owner of owners) {
-          const notesToNullify = notes.filter(note => note.addressPoint.equals(computePoint(owner.address)));
-          const nullifiers = notesToNullify.map(note => note.siloedNullifier);
-          await expect(database.removeNullifiedNotes(nullifiers, computePoint(owner.address))).resolves.toEqual(
+          const notesToNullify = notes.filter(note => note.addressPoint.equals(owner.address.toAddressPoint()));
+          const nullifiers = notesToNullify.map(note => ({
+            data: note.siloedNullifier,
+            l2BlockNumber: note.l2BlockNumber,
+            l2BlockHash: note.l2BlockHash,
+          }));
+          await expect(database.removeNullifiedNotes(nullifiers, owner.address.toAddressPoint())).resolves.toEqual(
             notesToNullify,
           );
         }
@@ -171,8 +175,12 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       it('skips nullified notes by default or when requesting active', async () => {
         await database.addNotes(notes, []);
 
-        const notesToNullify = notes.filter(note => note.addressPoint.equals(computePoint(owners[0].address)));
-        const nullifiers = notesToNullify.map(note => note.siloedNullifier);
+        const notesToNullify = notes.filter(note => note.addressPoint.equals(owners[0].address.toAddressPoint()));
+        const nullifiers = notesToNullify.map(note => ({
+          data: note.siloedNullifier,
+          l2BlockNumber: note.l2BlockNumber,
+          l2BlockHash: note.l2BlockHash,
+        }));
         await expect(database.removeNullifiedNotes(nullifiers, notesToNullify[0].addressPoint)).resolves.toEqual(
           notesToNullify,
         );
@@ -184,11 +192,35 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
         expect(actualNotesWithActive).toEqual(notes.filter(note => !notesToNullify.includes(note)));
       });
 
+      it('handles note unnullification', async () => {
+        await database.setHeader(makeHeader(randomInt(1000), 100, 0 /** slot number */));
+        await database.addNotes(notes, []);
+
+        const notesToNullify = notes.filter(note => note.addressPoint.equals(owners[0].address.toAddressPoint()));
+        const nullifiers = notesToNullify.map(note => ({
+          data: note.siloedNullifier,
+          l2BlockNumber: 99,
+          l2BlockHash: Fr.random().toString(),
+        }));
+        await expect(database.removeNullifiedNotes(nullifiers, notesToNullify[0].addressPoint)).resolves.toEqual(
+          notesToNullify,
+        );
+        await expect(database.unnullifyNotesAfter(98)).resolves.toEqual(undefined);
+
+        const result = await database.getIncomingNotes({ status: NoteStatus.ACTIVE, owner: owners[0].address });
+
+        expect(result.sort()).toEqual([...notesToNullify].sort());
+      });
+
       it('returns active and nullified notes when requesting either', async () => {
         await database.addNotes(notes, []);
 
-        const notesToNullify = notes.filter(note => note.addressPoint.equals(computePoint(owners[0].address)));
-        const nullifiers = notesToNullify.map(note => note.siloedNullifier);
+        const notesToNullify = notes.filter(note => note.addressPoint.equals(owners[0].address.toAddressPoint()));
+        const nullifiers = notesToNullify.map(note => ({
+          data: note.siloedNullifier,
+          l2BlockNumber: note.l2BlockNumber,
+          l2BlockHash: note.l2BlockHash,
+        }));
         await expect(database.removeNullifiedNotes(nullifiers, notesToNullify[0].addressPoint)).resolves.toEqual(
           notesToNullify,
         );
@@ -246,7 +278,16 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
         ).resolves.toEqual([notes[0]]);
 
         await expect(
-          database.removeNullifiedNotes([notes[0].siloedNullifier], computePoint(owners[0].address)),
+          database.removeNullifiedNotes(
+            [
+              {
+                data: notes[0].siloedNullifier,
+                l2BlockHash: notes[0].l2BlockHash,
+                l2BlockNumber: notes[0].l2BlockNumber,
+              },
+            ],
+            owners[0].address.toAddressPoint(),
+          ),
         ).resolves.toEqual([notes[0]]);
 
         await expect(
@@ -260,6 +301,14 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
           }),
         ).resolves.toEqual([]);
       });
+
+      it('removes notes after a given block', async () => {
+        await database.addNotes(notes, [], owners[0].address);
+
+        await database.removeNotesAfter(5);
+        const result = await database.getIncomingNotes({ scopes: [owners[0].address] });
+        expect(new Set(result)).toEqual(new Set(notes.slice(0, 6)));
+      });
     });
 
     describe('outgoing notes', () => {
@@ -307,7 +356,7 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
         storageSlots = Array.from({ length: 2 }).map(() => Fr.random());
 
         notes = Array.from({ length: 10 }).map((_, i) =>
-          randomOutgoingNoteDao({
+          OutgoingNoteDao.random({
             contractAddress: contractAddresses[i % contractAddresses.length],
             storageSlot: storageSlots[i % storageSlots.length],
             ovpkM: owners[i % owners.length].publicKeys.masterOutgoingViewingPublicKey,
@@ -391,6 +440,19 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
         await expect(database.getContractArtifact(id)).resolves.toEqual(artifact);
       });
 
+      it('does not store a contract artifact with a duplicate private function selector', async () => {
+        const artifact = TestContractArtifact;
+        const index = artifact.functions.findIndex(fn => fn.functionType === FunctionType.PRIVATE);
+
+        const copiedFn = structuredClone(artifact.functions[index]);
+        artifact.functions.push(copiedFn);
+
+        const id = Fr.random();
+        await expect(database.addContractArtifact(id, artifact)).rejects.toThrow(
+          'Repeated function selectors of private functions',
+        );
+      });
+
       it('stores a contract instance', async () => {
         const address = AztecAddress.random();
         const instance = SerializableContractInstance.random().withAddress(address);

package/src/kernel_oracle/index.ts

@@ -70,7 +70,7 @@ export class KernelOracle implements ProvingDataOracle {
   }
 
   async getNoteHashTreeRoot(): Promise<Fr> {
-    const header = await this.node.getHeader(this.blockNumber);
+    const header = await this.node.getBlockHeader(this.blockNumber);
     return header.state.partial.noteHashTree.root;
   }
 

package/src/note_decryption_utils/produce_note_daos.ts

@@ -34,6 +34,8 @@ export async function produceNoteDaos(
   ovpkM: PublicKey | undefined,
   payload: L1NotePayload,
   txHash: TxHash,
+  l2BlockNumber: number,
+  l2BlockHash: string,
   noteHashes: Fr[],
   dataStartIndexForTx: number,
   excludedIndices: Set<number>,
@@ -56,6 +58,8 @@ export async function produceNoteDaos(
       addressPoint,
       payload,
       txHash,
+      l2BlockNumber,
+      l2BlockHash,
       noteHashes,
       dataStartIndexForTx,
       excludedIndices,
@@ -74,6 +78,8 @@ export async function produceNoteDaos(
         incomingNote.storageSlot,
         incomingNote.noteTypeId,
         incomingNote.txHash,
+        incomingNote.l2BlockNumber,
+        incomingNote.l2BlockHash,
         incomingNote.nonce,
         incomingNote.noteHash,
         incomingNote.index,
@@ -86,6 +92,8 @@ export async function produceNoteDaos(
         ovpkM,
         payload,
         txHash,
+        l2BlockNumber,
+        l2BlockHash,
         noteHashes,
         dataStartIndexForTx,
         excludedIndices,