@aztec/pxe 4.0.0-nightly.20260113 → 4.0.0-nightly.20260114

package/src/pxe.ts

@@ -19,14 +19,13 @@ import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import {
   CompleteAddress,
-  type ContractClassWithId,
   type ContractInstanceWithAddress,
   type PartialAddress,
   computeContractAddressFromInstance,
   getContractClassFromArtifact,
 } from '@aztec/stdlib/contract';
 import { SimulationError } from '@aztec/stdlib/errors';
-import { computeProtocolNullifier, siloNullifier } from '@aztec/stdlib/hash';
+import { computeProtocolNullifier } from '@aztec/stdlib/hash';
 import type { AztecNode, PrivateKernelProver } from '@aztec/stdlib/interfaces/client';
 import type {
   PrivateExecutionStep,
@@ -69,7 +68,7 @@ import {
   PrivateKernelExecutionProver,
   type PrivateKernelExecutionProverConfig,
 } from './private_kernel/private_kernel_execution_prover.js';
-import { PrivateKernelOracleImpl } from './private_kernel/private_kernel_oracle_impl.js';
+import { PrivateKernelOracle } from './private_kernel/private_kernel_oracle.js';
 import { AddressStore } from './storage/address_store/address_store.js';
 import { AnchorBlockStore } from './storage/anchor_block_store/anchor_block_store.js';
 import { CapsuleStore } from './storage/capsule_store/capsule_store.js';
@@ -276,19 +275,6 @@ export class PXE {
     this.log.verbose(`Registered protocol contracts in pxe`, registered);
   }
 
-  async #isContractClassPubliclyRegistered(id: Fr): Promise<boolean> {
-    return !!(await this.node.getContractClass(id));
-  }
-
-  async #isContractPublished(address: AztecAddress): Promise<boolean> {
-    return !!(await this.node.getContract(address));
-  }
-
-  async #isContractInitialized(address: AztecAddress): Promise<boolean> {
-    const initNullifier = await siloNullifier(address, address.toField());
-    return !!(await this.node.getNullifierMembershipWitness('latest', initNullifier));
-  }
-
   // Executes the entrypoint private function, as well as all nested private
   // functions that might arise.
   async #executePrivate(
@@ -397,12 +383,7 @@ export class PXE {
     config: PrivateKernelExecutionProverConfig,
   ): Promise<PrivateKernelExecutionProofOutput<PrivateKernelTailCircuitPublicInputs>> {
     const simulationAnchorBlock = privateExecutionResult.getSimulationAnchorBlockNumber();
-    const kernelOracle = new PrivateKernelOracleImpl(
-      this.contractStore,
-      this.keyStore,
-      this.node,
-      simulationAnchorBlock,
-    );
+    const kernelOracle = new PrivateKernelOracle(this.contractStore, this.keyStore, this.node, simulationAnchorBlock);
     const kernelTraceProver = new PrivateKernelExecutionProver(kernelOracle, proofCreator, !this.proverEnabled);
     this.log.debug(`Executing kernel trace prover (${JSON.stringify(config)})...`);
     return await kernelTraceProver.proveWithKernels(txExecutionRequest.toTxRequest(), privateExecutionResult, config);
@@ -415,66 +396,12 @@ export class PXE {
   }
 
   /**
-   * Returns the contract class metadata given a contract class id.
-   * The metadata consists of its contract class, whether it has been publicly registered, and its artifact.
-   * @remark - it queries the node to check whether the contract class with the given id has been publicly registered.
-   * @param id - Identifier of the class.
-   * @param includeArtifact - Identifier of the class.
-   * @returns - It returns the contract class metadata, with the artifact field being optional, and will only be returned if true is passed in
-   * for `includeArtifact`
-   * TODO(@spalladino): The PXE actually holds artifacts and not classes, what should we return? Also,
-   * should the pxe query the node for contract public info, and merge it with its own definitions?
-   * TODO(@spalladino): This method is strictly needed to decide whether to publicly register a class or not
-   * during a public deployment. We probably want a nicer and more general API for this, but it'll have to
-   * do for the time being.
+   * Returns the contract artifact for a given contract class id, if it's registered in the PXE.
+   * @param id - Identifier of the contract class.
+   * @returns The contract artifact if found, undefined otherwise.
    */
-  public async getContractClassMetadata(
-    id: Fr,
-    includeArtifact: boolean = false,
-  ): Promise<{
-    contractClass: ContractClassWithId | undefined;
-    isContractClassPubliclyRegistered: boolean;
-    artifact: ContractArtifact | undefined;
-  }> {
-    const artifact = await this.contractStore.getContractArtifact(id);
-    if (!artifact) {
-      this.log.warn(`No artifact found for contract class ${id.toString()} when looking for its metadata`);
-    }
-
-    return {
-      contractClass: artifact && (await getContractClassFromArtifact(artifact)),
-      isContractClassPubliclyRegistered: await this.#isContractClassPubliclyRegistered(id),
-      artifact: includeArtifact ? artifact : undefined,
-    };
-  }
-
-  /**
-   * Returns the contract metadata given an address.
-   * The metadata consists of its contract instance, which includes the contract class identifier,
-   * initialization hash, deployment salt, and public keys hash; whether the contract instance has been initialized;
-   * and whether the contract instance with the given address has been publicly deployed.
-   * @remark - it queries the node to check whether the contract instance has been initialized / publicly deployed through a node.
-   * This query is not dependent on the PXE.
-   * @param address - The address that the contract instance resides at.
-   * @returns - It returns the contract metadata
-   * TODO(@spalladino): Should we return the public keys in plain as well here?
-   */
-  public async getContractMetadata(address: AztecAddress): Promise<{
-    contractInstance: ContractInstanceWithAddress | undefined;
-    isContractInitialized: boolean;
-    isContractPublished: boolean;
-  }> {
-    let instance;
-    try {
-      instance = await this.contractStore.getContractInstance(address);
-    } catch {
-      this.log.warn(`No instance found for contract ${address.toString()} when looking for its metadata`);
-    }
-    return {
-      contractInstance: instance,
-      isContractInitialized: await this.#isContractInitialized(address),
-      isContractPublished: await this.#isContractPublished(address),
-    };
+  public async getContractArtifact(id: Fr): Promise<ContractArtifact | undefined> {
+    return await this.contractStore.getContractArtifact(id);
   }
 
   /**

package/src/storage/note_store/note_store.ts

@@ -1,4 +1,3 @@
-import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import { toArray } from '@aztec/foundation/iterable';
 import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap } from '@aztec/kv-store';
@@ -15,32 +14,41 @@ import { NoteDao } from '@aztec/stdlib/note';
  **/
 export class NoteStore {
   #store: AztecAsyncKVStore;
+
+  // Note that we use the siloedNullifier as the note id in the store as it's guaranteed to be unique.
+
+  /** noteId (siloedNullifier) -> NoteDao (serialized) */
   #notes: AztecAsyncMap<string, Buffer>;
+  /** noteId (siloedNullifier) -> NoteDao (serialized) */
   #nullifiedNotes: AztecAsyncMap<string, Buffer>;
-  #nullifierToNoteId: AztecAsyncMap<string, string>;
+  /** blockNumber -> siloedNullifier */
   #nullifiersByBlockNumber: AztecAsyncMultiMap<number, string>;
 
+  /** noteId (siloedNullifier) -> scope */
   #nullifiedNotesToScope: AztecAsyncMultiMap<string, string>;
+  /** contractAddress -> noteId (siloedNullifier) */
   #nullifiedNotesByContract: AztecAsyncMultiMap<string, string>;
+  /** storageSlot -> noteId (siloedNullifier) */
   #nullifiedNotesByStorageSlot: AztecAsyncMultiMap<string, string>;
-  #nullifiedNotesByNullifier: AztecAsyncMap<string, string>;
 
+  /** scope (AztecAddress) -> true */
   #scopes: AztecAsyncMap<string, true>;
+  /** noteId (siloedNullifier) -> scope */
   #notesToScope: AztecAsyncMultiMap<string, string>;
+  /** scope -> MultiMap(contractAddress -> noteId) */
   #notesByContractAndScope: Map<string, AztecAsyncMultiMap<string, string>>;
+  /** scope -> MultiMap(storageSlot -> noteId) */
   #notesByStorageSlotAndScope: Map<string, AztecAsyncMultiMap<string, string>>;
 
   private constructor(store: AztecAsyncKVStore) {
     this.#store = store;
     this.#notes = store.openMap('notes');
     this.#nullifiedNotes = store.openMap('nullified_notes');
-    this.#nullifierToNoteId = store.openMap('nullifier_to_note');
     this.#nullifiersByBlockNumber = store.openMultiMap('nullifier_to_block_number');
 
     this.#nullifiedNotesToScope = store.openMultiMap('nullified_notes_to_scope');
     this.#nullifiedNotesByContract = store.openMultiMap('nullified_notes_by_contract');
     this.#nullifiedNotesByStorageSlot = store.openMultiMap('nullified_notes_by_storage_slot');
-    this.#nullifiedNotesByNullifier = store.openMap('nullified_notes_by_nullifier');
 
     this.#scopes = store.openMap('scopes');
     this.#notesToScope = store.openMultiMap('notes_to_scope');
@@ -92,9 +100,8 @@ export class NoteStore {
   /**
    * Adds multiple notes to the data provider under the specified scope.
    *
-   * Notes are stored using their index from the notes hash tree as the key, which provides
-   * uniqueness and maintains creation order. Each note is indexed by multiple criteria
-   * for efficient retrieval.
+   * Notes are stored using their siloedNullifier as the key, which provides uniqueness. Each note is indexed
+   * by multiple criteria for efficient retrieval.
    *
    * @param notes - Notes to store
    * @param scope - The scope (user/account) under which to store the notes
@@ -106,13 +113,12 @@ export class NoteStore {
       }
 
       for (const dao of notes) {
-        const noteIndex = toBufferBE(dao.index, 32).toString('hex');
-        await this.#notes.set(noteIndex, dao.toBuffer());
-        await this.#notesToScope.set(noteIndex, scope.toString());
-        await this.#nullifierToNoteId.set(dao.siloedNullifier.toString(), noteIndex);
+        const noteId = dao.siloedNullifier.toString();
+        await this.#notes.set(noteId, dao.toBuffer());
+        await this.#notesToScope.set(noteId, scope.toString());
 
-        await this.#notesByContractAndScope.get(scope.toString())!.set(dao.contractAddress.toString(), noteIndex);
-        await this.#notesByStorageSlotAndScope.get(scope.toString())!.set(dao.storageSlot.toString(), noteIndex);
+        await this.#notesByContractAndScope.get(scope.toString())!.set(dao.contractAddress.toString(), noteId);
+        await this.#notesByStorageSlotAndScope.get(scope.toString())!.set(dao.storageSlot.toString(), noteId);
       }
     });
   }
@@ -147,14 +153,13 @@ export class NoteStore {
     for (const note of notes) {
       const noteDao = NoteDao.fromBuffer(note);
       if (noteDao.l2BlockNumber > blockNumber) {
-        const noteIndex = toBufferBE(noteDao.index, 32).toString('hex');
-        await this.#notes.delete(noteIndex);
-        await this.#notesToScope.delete(noteIndex);
-        await this.#nullifierToNoteId.delete(noteDao.siloedNullifier.toString());
+        const noteId = noteDao.siloedNullifier.toString();
+        await this.#notes.delete(noteId);
+        await this.#notesToScope.delete(noteId);
         const scopes = await toArray(this.#scopes.keysAsync());
         for (const scope of scopes) {
-          await this.#notesByContractAndScope.get(scope)!.deleteValue(noteDao.contractAddress.toString(), noteIndex);
-          await this.#notesByStorageSlotAndScope.get(scope)!.deleteValue(noteDao.storageSlot.toString(), noteIndex);
+          await this.#notesByContractAndScope.get(scope)!.deleteValue(noteDao.contractAddress.toString(), noteId);
+          await this.#notesByStorageSlotAndScope.get(scope)!.deleteValue(noteDao.storageSlot.toString(), noteId);
         }
       }
     }
@@ -171,50 +176,45 @@ export class NoteStore {
    * @param synchedBlockNumber - Upper bound for the block range to process
    */
   async #rewindNullifiersAfterBlock(blockNumber: number, synchedBlockNumber: number): Promise<void> {
-    const nullifiersToUndo: string[] = [];
+    const noteIdsToReinsert: string[] = [];
     const currentBlockNumber = blockNumber + 1;
     for (let i = currentBlockNumber; i <= synchedBlockNumber; i++) {
-      nullifiersToUndo.push(...(await toArray(this.#nullifiersByBlockNumber.getValuesAsync(i))));
+      // noteId === siloedNullifier.toString(), so we can use nullifiers directly as noteIds
+      noteIdsToReinsert.push(...(await toArray(this.#nullifiersByBlockNumber.getValuesAsync(i))));
     }
-    const notesIndexesToReinsert = await Promise.all(
-      nullifiersToUndo.map(nullifier => this.#nullifiedNotesByNullifier.getAsync(nullifier)),
-    );
-    const notNullNoteIndexes = notesIndexesToReinsert.filter(noteIndex => noteIndex != undefined);
     const nullifiedNoteBuffers = await Promise.all(
-      notNullNoteIndexes.map(noteIndex => this.#nullifiedNotes.getAsync(noteIndex!)),
+      noteIdsToReinsert.map(noteId => this.#nullifiedNotes.getAsync(noteId)),
     );
     const noteDaos = nullifiedNoteBuffers
       .filter(buffer => buffer != undefined)
       .map(buffer => NoteDao.fromBuffer(buffer!));
 
     for (const dao of noteDaos) {
-      const noteIndex = toBufferBE(dao.index, 32).toString('hex');
+      const noteId = dao.siloedNullifier.toString();
 
-      const scopes = await toArray(this.#nullifiedNotesToScope.getValuesAsync(noteIndex));
+      const scopes = await toArray(this.#nullifiedNotesToScope.getValuesAsync(noteId));
 
       if (scopes.length === 0) {
         // We should never run into this error because notes always have a scope assigned to them - either on initial
         // insertion via `addNotes` or when removing their nullifiers.
-        throw new Error(`No scopes found for nullified note with index ${noteIndex}`);
+        throw new Error(`No scopes found for nullified note with nullifier ${noteId}`);
       }
 
       for (const scope of scopes) {
         await Promise.all([
-          this.#notesByContractAndScope.get(scope.toString())!.set(dao.contractAddress.toString(), noteIndex),
-          this.#notesByStorageSlotAndScope.get(scope.toString())!.set(dao.storageSlot.toString(), noteIndex),
-          this.#notesToScope.set(noteIndex, scope),
+          this.#notesByContractAndScope.get(scope.toString())!.set(dao.contractAddress.toString(), noteId),
+          this.#notesByStorageSlotAndScope.get(scope.toString())!.set(dao.storageSlot.toString(), noteId),
+          this.#notesToScope.set(noteId, scope),
         ]);
       }
 
       await Promise.all([
-        this.#notes.set(noteIndex, dao.toBuffer()),
-        this.#nullifierToNoteId.set(dao.siloedNullifier.toString(), noteIndex),
-        this.#nullifiedNotes.delete(noteIndex),
-        this.#nullifiedNotesToScope.delete(noteIndex),
+        this.#notes.set(noteId, dao.toBuffer()),
+        this.#nullifiedNotes.delete(noteId),
+        this.#nullifiedNotesToScope.delete(noteId),
         this.#nullifiersByBlockNumber.deleteValue(dao.l2BlockNumber, dao.siloedNullifier.toString()),
-        this.#nullifiedNotesByContract.deleteValue(dao.contractAddress.toString(), noteIndex),
-        this.#nullifiedNotesByStorageSlot.deleteValue(dao.storageSlot.toString(), noteIndex),
-        this.#nullifiedNotesByNullifier.delete(dao.siloedNullifier.toString()),
+        this.#nullifiedNotesByContract.deleteValue(dao.contractAddress.toString(), noteId),
+        this.#nullifiedNotesByStorageSlot.deleteValue(dao.storageSlot.toString(), noteId),
       ]);
     }
   }
@@ -334,6 +334,17 @@ export class NoteStore {
       }
     }
 
+    // Sort by block number, then by tx index within block, then by note index within tx
+    deduplicated.sort((a, b) => {
+      if (a.l2BlockNumber !== b.l2BlockNumber) {
+        return a.l2BlockNumber - b.l2BlockNumber;
+      }
+      if (a.txIndexInBlock !== b.txIndexInBlock) {
+        return a.txIndexInBlock - b.txIndexInBlock;
+      }
+      return a.noteIndexInTx - b.noteIndexInTx;
+    });
+
     return deduplicated;
   }
 
@@ -358,25 +369,18 @@ export class NoteStore {
 
       for (const blockScopedNullifier of nullifiers) {
         const { data: nullifier, l2BlockNumber: blockNumber } = blockScopedNullifier;
-        const nullifierKey = nullifier.toString();
+        const noteId = nullifier.toString();
 
-        const noteIndex = await this.#nullifierToNoteId.getAsync(nullifierKey);
-        if (!noteIndex) {
-          // Check if already nullified?
-          const alreadyNullified = await this.#nullifiedNotesByNullifier.getAsync(nullifierKey);
-          if (alreadyNullified) {
+        const noteBuffer = await this.#notes.getAsync(noteId);
+        if (!noteBuffer) {
+          // Check if already nullified (noteId === siloedNullifier, so we can check #nullifiedNotes directly)
+          if (await this.#nullifiedNotes.hasAsync(noteId)) {
             throw new Error(`Nullifier already applied in applyNullifiers`);
           }
           throw new Error('Nullifier not found in applyNullifiers');
         }
 
-        const noteBuffer = noteIndex ? await this.#notes.getAsync(noteIndex) : undefined;
-
-        if (!noteBuffer) {
-          throw new Error('Note not found in applyNullifiers');
-        }
-
-        const noteScopes = await toArray(this.#notesToScope.getValuesAsync(noteIndex));
+        const noteScopes = await toArray(this.#notesToScope.getValuesAsync(noteId));
         if (noteScopes.length === 0) {
           // We should never run into this error because notes always have a scope assigned to them - either on initial
           // insertion via `addNotes` or when removing their nullifiers.
@@ -387,26 +391,23 @@ export class NoteStore {
 
         nullifiedNotes.push(note);
 
-        await this.#notes.delete(noteIndex);
-        await this.#notesToScope.delete(noteIndex);
+        await this.#notes.delete(noteId);
+        await this.#notesToScope.delete(noteId);
 
         const scopes = await toArray(this.#scopes.keysAsync());
 
         for (const scope of scopes) {
-          await this.#notesByContractAndScope.get(scope)!.deleteValue(note.contractAddress.toString(), noteIndex);
-          await this.#notesByStorageSlotAndScope.get(scope)!.deleteValue(note.storageSlot.toString(), noteIndex);
+          await this.#notesByContractAndScope.get(scope)!.deleteValue(note.contractAddress.toString(), noteId);
+          await this.#notesByStorageSlotAndScope.get(scope)!.deleteValue(note.storageSlot.toString(), noteId);
         }
 
         for (const scope of noteScopes) {
-          await this.#nullifiedNotesToScope.set(noteIndex, scope);
+          await this.#nullifiedNotesToScope.set(noteId, scope);
         }
-        await this.#nullifiedNotes.set(noteIndex, note.toBuffer());
-        await this.#nullifiersByBlockNumber.set(blockNumber, nullifier.toString());
-        await this.#nullifiedNotesByContract.set(note.contractAddress.toString(), noteIndex);
-        await this.#nullifiedNotesByStorageSlot.set(note.storageSlot.toString(), noteIndex);
-        await this.#nullifiedNotesByNullifier.set(nullifier.toString(), noteIndex);
-
-        await this.#nullifierToNoteId.delete(nullifier.toString());
+        await this.#nullifiedNotes.set(noteId, note.toBuffer());
+        await this.#nullifiersByBlockNumber.set(blockNumber, noteId);
+        await this.#nullifiedNotesByContract.set(note.contractAddress.toString(), noteId);
+        await this.#nullifiedNotesByStorageSlot.set(note.storageSlot.toString(), noteId);
       }
       return nullifiedNotes;
     });

package/src/storage/private_event_store/private_event_store.ts

@@ -21,10 +21,13 @@ export type PrivateEventStoreFilter = {
 type PrivateEventEntry = {
   randomness: Fr; // Note that this value is currently not being returned on queries and is therefore temporarily unused
   msgContent: Buffer;
-  eventCommitmentIndex: number;
   l2BlockNumber: number;
   l2BlockHash: Buffer;
   txHash: Buffer;
+  /** The index of the tx within the block, used for ordering events */
+  txIndexInBlock: number;
+  /** The index of the event within the tx (based on nullifier position), used for ordering events */
+  eventIndexInTx: number;
   /** The lookup key for #eventsByContractScopeSelector, used for cleanup during rollback */
   lookupKey: string;
 };
@@ -32,6 +35,10 @@ type PrivateEventEntry = {
 type PrivateEventMetadata = InTx & {
   contractAddress: AztecAddress;
   scope: AztecAddress;
+  /** The index of the tx within the block */
+  txIndexInBlock: number;
+  /** The index of the event within the tx (based on nullifier position) */
+  eventIndexInTx: number;
 };
 
 /**
@@ -39,14 +46,14 @@ type PrivateEventMetadata = InTx & {
  */
 export class PrivateEventStore {
   #store: AztecAsyncKVStore;
-  /** Map storing the actual private event log entries, keyed by eventCommitmentIndex */
-  #eventLogs: AztecAsyncMap<number, PrivateEventEntry>;
-  /** Map from contractAddress_scope_eventSelector to eventCommitmentIndex[] for efficient lookup */
-  #eventsByContractScopeSelector: AztecAsyncMap<string, number[]>;
-  /** Map from block number to eventCommitmentIndex[] for rollback support */
-  #eventsByBlockNumber: AztecAsyncMap<number, number[]>;
-  /** Map from eventCommitmentIndex to boolean indicating if log has been seen. */
-  #seenLogs: AztecAsyncMap<number, boolean>;
+  /** Map storing the actual private event log entries, keyed by siloedEventCommitment */
+  #eventLogs: AztecAsyncMap<string, PrivateEventEntry>;
+  /** Map from contractAddress_scope_eventSelector to siloedEventCommitment[] for efficient lookup */
+  #eventsByContractScopeSelector: AztecAsyncMap<string, string[]>;
+  /** Map from block number to siloedEventCommitment[] for rollback support */
+  #eventsByBlockNumber: AztecAsyncMap<number, string[]>;
+  /** Map from siloedEventCommitment to boolean indicating if log has been seen. */
+  #seenLogs: AztecAsyncMap<string, boolean>;
 
   logger = createLogger('private_event_store');
 
@@ -65,8 +72,9 @@ export class PrivateEventStore {
   /**
    * Store a private event log.
    * @param eventSelector - The event selector of the event.
+   * @param randomness - The randomness used for the event commitment.
    * @param msgContent - The content of the event.
-   * @param eventCommitmentIndex - The index of the event commitment in the nullifier tree.
+   * @param siloedEventCommitment - The siloed event commitment (used as unique identifier).
    * @param metadata
    *  contractAddress - The address of the contract that emitted the event.
    *  scope - The address to which the event is scoped.
@@ -77,41 +85,45 @@ export class PrivateEventStore {
     eventSelector: EventSelector,
     randomness: Fr,
     msgContent: Fr[],
-    eventCommitmentIndex: number,
+    siloedEventCommitment: Fr,
     metadata: PrivateEventMetadata,
   ): Promise<void> {
-    const { contractAddress, scope, txHash, l2BlockNumber, l2BlockHash } = metadata;
+    const { contractAddress, scope, txHash, l2BlockNumber, l2BlockHash, txIndexInBlock, eventIndexInTx } = metadata;
 
     return this.#store.transactionAsync(async () => {
       const key = this.#keyFor(contractAddress, scope, eventSelector);
 
-      // Check if this exact log has already been stored using eventCommitmentIndex as unique identifier
-      const hasBeenSeen = await this.#seenLogs.getAsync(eventCommitmentIndex);
+      // The siloed event commitment is guaranteed to be unique as it's inserted into the nullifier tree. For this
+      // reason we use it as id.
+      const eventId = siloedEventCommitment.toString();
+
+      const hasBeenSeen = await this.#seenLogs.getAsync(eventId);
       if (hasBeenSeen) {
-        this.logger.verbose('Ignoring duplicate event log', { txHash: txHash.toString(), eventCommitmentIndex });
+        this.logger.verbose('Ignoring duplicate event log', { txHash: txHash.toString(), siloedEventCommitment });
         return;
       }
 
       this.logger.verbose('storing private event log', { contractAddress, scope, msgContent, l2BlockNumber });
 
-      await this.#eventLogs.set(eventCommitmentIndex, {
+      await this.#eventLogs.set(eventId, {
         randomness,
         msgContent: serializeToBuffer(msgContent),
         l2BlockNumber,
         l2BlockHash: l2BlockHash.toBuffer(),
-        eventCommitmentIndex,
         txHash: txHash.toBuffer(),
+        txIndexInBlock,
+        eventIndexInTx,
         lookupKey: key,
       });
 
-      const existingIndices = (await this.#eventsByContractScopeSelector.getAsync(key)) || [];
-      await this.#eventsByContractScopeSelector.set(key, [...existingIndices, eventCommitmentIndex]);
+      const existingIds = (await this.#eventsByContractScopeSelector.getAsync(key)) || [];
+      await this.#eventsByContractScopeSelector.set(key, [...existingIds, eventId]);
 
-      const existingBlockIndices = (await this.#eventsByBlockNumber.getAsync(l2BlockNumber)) || [];
-      await this.#eventsByBlockNumber.set(l2BlockNumber, [...existingBlockIndices, eventCommitmentIndex]);
+      const existingBlockIds = (await this.#eventsByBlockNumber.getAsync(l2BlockNumber)) || [];
+      await this.#eventsByBlockNumber.set(l2BlockNumber, [...existingBlockIds, eventId]);
 
-      // Mark this log as seen using eventCommitmentIndex
-      await this.#seenLogs.set(eventCommitmentIndex, true);
+      // Mark this log as seen
+      await this.#seenLogs.set(eventId, true);
     });
   }
 
@@ -123,21 +135,26 @@ export class PrivateEventStore {
    *  fromBlock: The block number to search from (inclusive).
    *  toBlock: The block number to search upto (exclusive).
    *  scope: - The addresses that decrypted the logs.
-   * @returns - The event log contents, augmented with metadata about
-   *  the transaction and block it the event was included in .
+   * @returns - The event log contents, augmented with metadata about the transaction and block in which the event was
+   * included.
    */
   public async getPrivateEvents(
     eventSelector: EventSelector,
     filter: PrivateEventStoreFilter,
   ): Promise<PackedPrivateEvent[]> {
-    const events: Array<{ eventCommitmentIndex: number; event: PackedPrivateEvent }> = [];
+    const events: Array<{
+      l2BlockNumber: number;
+      txIndexInBlock: number;
+      eventIndexInTx: number;
+      event: PackedPrivateEvent;
+    }> = [];
 
     for (const scope of filter.scopes) {
       const key = this.#keyFor(filter.contractAddress, scope, eventSelector);
-      const eventCommitmentIndices = (await this.#eventsByContractScopeSelector.getAsync(key)) || [];
+      const eventIds = (await this.#eventsByContractScopeSelector.getAsync(key)) || [];
 
-      for (const eventCommitmentIndex of eventCommitmentIndices) {
-        const entry = await this.#eventLogs.getAsync(eventCommitmentIndex);
+      for (const eventId of eventIds) {
+        const entry = await this.#eventLogs.getAsync(eventId);
         if (!entry || entry.l2BlockNumber < filter.fromBlock || entry.l2BlockNumber >= filter.toBlock) {
           continue;
         }
@@ -154,7 +171,9 @@ export class PrivateEventStore {
         }
 
         events.push({
-          eventCommitmentIndex: entry.eventCommitmentIndex,
+          l2BlockNumber: entry.l2BlockNumber,
+          txIndexInBlock: entry.txIndexInBlock,
+          eventIndexInTx: entry.eventIndexInTx,
           event: {
             packedEvent: msgContent,
             l2BlockNumber: BlockNumber(entry.l2BlockNumber),
@@ -166,8 +185,16 @@ export class PrivateEventStore {
       }
     }
 
-    // Sort by eventCommitmentIndex only
-    events.sort((a, b) => a.eventCommitmentIndex - b.eventCommitmentIndex);
+    // Sort by block number, then by tx index within block, then by event index within tx
+    events.sort((a, b) => {
+      if (a.l2BlockNumber !== b.l2BlockNumber) {
+        return a.l2BlockNumber - b.l2BlockNumber;
+      }
+      if (a.txIndexInBlock !== b.txIndexInBlock) {
+        return a.txIndexInBlock - b.txIndexInBlock;
+      }
+      return a.eventIndexInTx - b.eventIndexInTx;
+    });
     return events.map(ev => ev.event);
   }
 
@@ -181,29 +208,29 @@ export class PrivateEventStore {
     let removedCount = 0;
 
     for (let block = blockNumber + 1; block <= synchedBlockNumber; block++) {
-      const indices = await this.#eventsByBlockNumber.getAsync(block);
-      if (indices) {
+      const eventIds = await this.#eventsByBlockNumber.getAsync(block);
+      if (eventIds) {
         await this.#eventsByBlockNumber.delete(block);
 
-        for (const eventCommitmentIndex of indices) {
-          const entry = await this.#eventLogs.getAsync(eventCommitmentIndex);
+        for (const eventId of eventIds) {
+          const entry = await this.#eventLogs.getAsync(eventId);
           if (!entry) {
-            throw new Error(`Event log not found for eventCommitmentIndex ${eventCommitmentIndex}`);
+            throw new Error(`Event log not found for eventId ${eventId}`);
           }
 
-          await this.#eventLogs.delete(eventCommitmentIndex);
-          await this.#seenLogs.delete(eventCommitmentIndex);
+          await this.#eventLogs.delete(eventId);
+          await this.#seenLogs.delete(eventId);
 
           // Update #eventsByContractScopeSelector using the stored lookupKey
-          const existingIndices = await this.#eventsByContractScopeSelector.getAsync(entry.lookupKey);
-          if (!existingIndices || existingIndices.length === 0) {
-            throw new Error(`No indices found in #eventsByContractScopeSelector for key ${entry.lookupKey}`);
+          const existingIds = await this.#eventsByContractScopeSelector.getAsync(entry.lookupKey);
+          if (!existingIds || existingIds.length === 0) {
+            throw new Error(`No ids found in #eventsByContractScopeSelector for key ${entry.lookupKey}`);
           }
-          const filteredIndices = existingIndices.filter(idx => idx !== eventCommitmentIndex);
-          if (filteredIndices.length === 0) {
+          const filteredIds = existingIds.filter(id => id !== eventId);
+          if (filteredIds.length === 0) {
             await this.#eventsByContractScopeSelector.delete(entry.lookupKey);
           } else {
-            await this.#eventsByContractScopeSelector.set(entry.lookupKey, filteredIndices);
+            await this.#eventsByContractScopeSelector.set(entry.lookupKey, filteredIds);
           }
 
           removedCount++;

package/dest/private_kernel/private_kernel_oracle_impl.d.ts

@@ -1,46 +0,0 @@
-import { NOTE_HASH_TREE_HEIGHT } from '@aztec/constants';
-import type { Fr } from '@aztec/foundation/curves/bn254';
-import type { GrumpkinScalar, Point } from '@aztec/foundation/curves/grumpkin';
-import { MembershipWitness } from '@aztec/foundation/trees';
-import type { KeyStore } from '@aztec/key-store';
-import type { FunctionSelector } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { BlockParameter } from '@aztec/stdlib/block';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import { UpdatedClassIdHints } from '@aztec/stdlib/kernel';
-import type { NullifierMembershipWitness } from '@aztec/stdlib/trees';
-import type { VerificationKeyAsFields } from '@aztec/stdlib/vks';
-import type { ContractStore } from '../storage/contract_store/contract_store.js';
-import type { PrivateKernelOracle } from './private_kernel_oracle.js';
-/**
- * A data oracle that provides information needed for simulating a transaction.
- */
-export declare class PrivateKernelOracleImpl implements PrivateKernelOracle {
-    private contractStore;
-    private keyStore;
-    private node;
-    private blockNumber;
-    private log;
-    constructor(contractStore: ContractStore, keyStore: KeyStore, node: AztecNode, blockNumber?: BlockParameter, log?: import("@aztec/foundation/log").Logger);
-    getContractAddressPreimage(address: AztecAddress): Promise<{
-        version: 1;
-        salt: Fr;
-        deployer: AztecAddress;
-        currentContractClassId: Fr;
-        originalContractClassId: Fr;
-        initializationHash: Fr;
-        publicKeys: import("../../../stdlib/dest/keys/public_keys.js").PublicKeys;
-        address: AztecAddress;
-        saltedInitializationHash: Fr;
-    }>;
-    getContractClassIdPreimage(contractClassId: Fr): Promise<import("@aztec/stdlib/contract").ContractClassIdPreimage>;
-    getFunctionMembershipWitness(contractClassId: Fr, selector: FunctionSelector): Promise<MembershipWitness<7>>;
-    getVkMembershipWitness(vk: VerificationKeyAsFields): Promise<MembershipWitness<7>>;
-    getNoteHashMembershipWitness(noteHash: Fr): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT> | undefined>;
-    getNullifierMembershipWitness(nullifier: Fr): Promise<NullifierMembershipWitness | undefined>;
-    getNoteHashTreeRoot(): Promise<Fr>;
-    getMasterSecretKey(masterPublicKey: Point): Promise<GrumpkinScalar>;
-    getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string>;
-    getUpdatedClassIdHints(contractAddress: AztecAddress): Promise<UpdatedClassIdHints>;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpdmF0ZV9rZXJuZWxfb3JhY2xlX2ltcGwuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcml2YXRlX2tlcm5lbC9wcml2YXRlX2tlcm5lbF9vcmFjbGVfaW1wbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUscUJBQXFCLEVBQTJDLE1BQU0sa0JBQWtCLENBQUM7QUFDbEcsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDekQsT0FBTyxLQUFLLEVBQUUsY0FBYyxFQUFFLEtBQUssRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBRS9FLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQzVELE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBR2pELE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDMUQsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDaEUsT0FBTyxLQUFLLEVBQUUsY0FBYyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFJMUQsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDakUsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDM0QsT0FBTyxLQUFLLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUN0RSxPQUFPLEtBQUssRUFBRSx1QkFBdUIsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRWpFLE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxNQUFNLDZDQUE2QyxDQUFDO0FBQ2pGLE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFLdEU7O0dBRUc7QUFDSCxxQkFBYSx1QkFBd0IsWUFBVyxtQkFBbUI7SUFFL0QsT0FBTyxDQUFDLGFBQWE7SUFDckIsT0FBTyxDQUFDLFFBQVE7SUFDaEIsT0FBTyxDQUFDLElBQUk7SUFDWixPQUFPLENBQUMsV0FBVztJQUNuQixPQUFPLENBQUMsR0FBRztJQUxiLFlBQ1UsYUFBYSxFQUFFLGFBQWEsRUFDNUIsUUFBUSxFQUFFLFFBQVEsRUFDbEIsSUFBSSxFQUFFLFNBQVMsRUFDZixXQUFXLEdBQUUsY0FBeUIsRUFDdEMsR0FBRyx5Q0FBb0MsRUFDN0M7SUFFUywwQkFBMEIsQ0FBQyxPQUFPLEVBQUUsWUFBWTs7Ozs7Ozs7OztPQVM1RDtJQUVZLDBCQUEwQixDQUFDLGVBQWUsRUFBRSxFQUFFLHFFQU0xRDtJQUVZLDRCQUE0QixDQUFDLGVBQWUsRUFBRSxFQUFFLEVBQUUsUUFBUSxFQUFFLGdCQUFnQixpQ0FReEY7SUFFTSxzQkFBc0IsQ0FBQyxFQUFFLEVBQUUsdUJBQXVCLGlDQUd4RDtJQUVELDRCQUE0QixDQUFDLFFBQVEsRUFBRSxFQUFFLEdBQUcsT0FBTyxDQUFDLGlCQUFpQixDQUFDLE9BQU8scUJBQXFCLENBQUMsR0FBRyxTQUFTLENBQUMsQ0FFL0c7SUFFRCw2QkFBNkIsQ0FBQyxTQUFTLEVBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQywwQkFBMEIsR0FBRyxTQUFTLENBQUMsQ0FFNUY7SUFFSyxtQkFBbUIsSUFBSSxPQUFPLENBQUMsRUFBRSxDQUFDLENBTXZDO0lBRU0sa0JBQWtCLENBQUMsZUFBZSxFQUFFLEtBQUssR0FBRyxPQUFPLENBQUMsY0FBYyxDQUFDLENBRXpFO0lBRU0sb0JBQW9CLENBQUMsZUFBZSxFQUFFLFlBQVksRUFBRSxRQUFRLEVBQUUsZ0JBQWdCLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUV0RztJQUVZLHNCQUFzQixDQUFDLGVBQWUsRUFBRSxZQUFZLEdBQUcsT0FBTyxDQUFDLG1CQUFtQixDQUFDLENBOEIvRjtDQUNGIn0=