@aztec/pxe 3.0.0-nightly.20251128 → 3.0.0-nightly.20251202

package/src/contract_function_simulator/oracle/private_execution_oracle.ts

@@ -282,6 +282,7 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle implements IP
    * Real notes coming from DB will have a leafIndex which
    * represents their index in the note hash tree.
    *
+   * @param owner - The owner of the notes.
    * @param storageSlot - The storage slot.
    * @param numSelects - The number of valid selects in selectBy and selectValues.
    * @param selectBy - An array of indices of the fields to selects.
@@ -295,6 +296,7 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle implements IP
    * @returns Array of note data.
    */
   public override async utilityGetNotes(
+    owner: AztecAddress,
     storageSlot: Fr,
     numSelects: number,
     selectByIndexes: number[],
@@ -311,11 +313,12 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle implements IP
     status: NoteStatus,
   ): Promise<NoteData[]> {
     // Nullified pending notes are already removed from the list.
-    const pendingNotes = this.noteCache.getNotes(this.callContext.contractAddress, storageSlot);
+    const pendingNotes = this.noteCache.getNotes(this.callContext.contractAddress, owner, storageSlot);
 
     const pendingNullifiers = this.noteCache.getNullifiers(this.callContext.contractAddress);
     const dbNotes = await this.executionDataProvider.getNotes(
       this.callContext.contractAddress,
+      owner,
       storageSlot,
       status,
       this.scopes,
@@ -365,7 +368,7 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle implements IP
   /**
    * Keep track of the new note created during execution.
    * It can be used in subsequent calls (or transactions when chaining txs is possible).
-   * @param contractAddress - The contract address.
+   * @param owner - The owner of the note.
    * @param storageSlot - The storage slot.
    * @param randomness - The randomness injected into the note.
    * @param noteTypeId - The type ID of the note.
@@ -374,6 +377,7 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle implements IP
    * @returns
    */
   public privateNotifyCreatedNote(
+    owner: AztecAddress,
     storageSlot: Fr,
     randomness: Fr,
     noteTypeId: NoteSelector,
@@ -393,6 +397,7 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle implements IP
     this.noteCache.addNewNote(
       {
         contractAddress: this.callContext.contractAddress,
+        owner,
         storageSlot,
         randomness,
         noteNonce: Fr.ZERO, // Nonce cannot be known during private execution.

package/src/contract_function_simulator/oracle/utility_execution_oracle.ts

@@ -164,6 +164,7 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
    * Real notes coming from DB will have a leafIndex which
    * represents their index in the note hash tree.
    *
+   * @param owner - The owner of the notes.
    * @param storageSlot - The storage slot.
    * @param numSelects - The number of valid selects in selectBy and selectValues.
    * @param selectBy - An array of indices of the fields to selects.
@@ -177,6 +178,7 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
    * @returns Array of note data.
    */
   public async utilityGetNotes(
+    owner: AztecAddress,
     storageSlot: Fr,
     numSelects: number,
     selectByIndexes: number[],
@@ -192,7 +194,13 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
     offset: number,
     status: NoteStatus,
   ): Promise<NoteData[]> {
-    const dbNotes = await this.executionDataProvider.getNotes(this.contractAddress, storageSlot, status, this.scopes);
+    const dbNotes = await this.executionDataProvider.getNotes(
+      this.contractAddress,
+      owner,
+      storageSlot,
+      status,
+      this.scopes,
+    );
     return pickNotes<NoteData>(dbNotes, {
       selects: selectByIndexes.slice(0, numSelects).map((index, i) => ({
         selector: { index, offset: selectByOffsets[i], length: selectByLengths[i] },

package/src/contract_function_simulator/pxe_oracle_interface.ts

@@ -5,7 +5,7 @@ import { createLogger } from '@aztec/foundation/log';
 import type { KeyStore } from '@aztec/key-store';
 import { EventSelector, type FunctionArtifactWithContractName, FunctionSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { InBlock, L2Block, L2BlockNumber } from '@aztec/stdlib/block';
+import type { DataInBlock, L2Block, L2BlockNumber } from '@aztec/stdlib/block';
 import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
 import { computeUniqueNoteHash, siloNoteHash, siloNullifier, siloPrivateLog } from '@aztec/stdlib/hash';
 import { type AztecNode, MAX_RPC_LEN } from '@aztec/stdlib/interfaces/client';
@@ -90,16 +90,24 @@ export class PXEOracleInterface implements ExecutionDataProvider {
     return instance;
   }
 
-  async getNotes(contractAddress: AztecAddress, storageSlot: Fr, status: NoteStatus, scopes?: AztecAddress[]) {
+  async getNotes(
+    contractAddress: AztecAddress,
+    owner: AztecAddress,
+    storageSlot: Fr,
+    status: NoteStatus,
+    scopes?: AztecAddress[],
+  ) {
     const noteDaos = await this.noteDataProvider.getNotes({
       contractAddress,
+      owner,
       storageSlot,
       status,
       scopes,
     });
     return noteDaos.map(
-      ({ contractAddress, storageSlot, randomness, noteNonce, note, noteHash, siloedNullifier, index }) => ({
+      ({ contractAddress, owner, storageSlot, randomness, noteNonce, note, noteHash, siloedNullifier, index }) => ({
         contractAddress,
+        owner,
         storageSlot,
         randomness,
         noteNonce,
@@ -599,6 +607,7 @@ export class PXEOracleInterface implements ExecutionDataProvider {
     const noteDeliveries = noteValidationRequests.map(request =>
       this.deliverNote(
         request.contractAddress,
+        request.owner,
         request.storageSlot,
         request.randomness,
         request.noteNonce,
@@ -630,6 +639,7 @@ export class PXEOracleInterface implements ExecutionDataProvider {
 
   async deliverNote(
     contractAddress: AztecAddress,
+    owner: AztecAddress,
     storageSlot: Fr,
     randomness: Fr,
     noteNonce: Fr,
@@ -682,6 +692,7 @@ export class PXEOracleInterface implements ExecutionDataProvider {
     const noteDao = new NoteDao(
       new Note(content),
       contractAddress,
+      owner,
       storageSlot,
       randomness,
       noteNonce,
@@ -756,7 +767,7 @@ export class PXEOracleInterface implements ExecutionDataProvider {
             privateLog.firstNullifierInTx,
           );
         } else {
-          null;
+          return null;
         }
       }),
     );
@@ -941,10 +952,10 @@ export class PXEOracleInterface implements ExecutionDataProvider {
     const foundNullifiers = nullifiersToCheck
       .map((nullifier, i) => {
         if (nullifierIndexes[i] !== undefined) {
-          return { ...nullifierIndexes[i], ...{ data: nullifier } } as InBlock<Fr>;
+          return { ...nullifierIndexes[i], ...{ data: nullifier } } as DataInBlock<Fr>;
         }
       })
-      .filter(nullifier => nullifier !== undefined) as InBlock<Fr>[];
+      .filter(nullifier => nullifier !== undefined) as DataInBlock<Fr>[];
 
     const nullifiedNotes = await this.noteDataProvider.applyNullifiers(foundNullifiers);
     nullifiedNotes.forEach(noteDao => {

package/src/private_kernel/hints/compute_side_effect_uniqueness_hints.ts

@@ -0,0 +1,173 @@
+import {
+  GLOBAL_INDEX_CONTRACT_CLASS_LOG_HASH_OFFSET,
+  GLOBAL_INDEX_L2_TO_L1_MSG_OFFSET,
+  GLOBAL_INDEX_NOTE_HASH_OFFSET,
+  GLOBAL_INDEX_NOTE_HASH_READ_REQUEST_OFFSET,
+  GLOBAL_INDEX_NULLIFIER_OFFSET,
+  GLOBAL_INDEX_NULLIFIER_READ_REQUEST_OFFSET,
+  GLOBAL_INDEX_PRIVATE_CALL_REQUEST_OFFSET,
+  GLOBAL_INDEX_PRIVATE_LOG_OFFSET,
+  GLOBAL_INDEX_PUBLIC_CALL_REQUEST_OFFSET,
+  MAX_CONTRACT_CLASS_LOGS_PER_CALL,
+  MAX_ENQUEUED_CALLS_PER_CALL,
+  MAX_L2_TO_L1_MSGS_PER_CALL,
+  MAX_NOTE_HASHES_PER_CALL,
+  MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
+  MAX_NULLIFIERS_PER_CALL,
+  MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
+  MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,
+  MAX_PRIVATE_LOGS_PER_CALL,
+  TOTAL_COUNTED_SIDE_EFFECTS_PER_CALL,
+} from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import type { Serializable } from '@aztec/foundation/serialize';
+import {
+  ClaimedLengthArray,
+  PrivateCallRequest,
+  type PrivateCircuitPublicInputs,
+  SideEffectCounterRange,
+  SideEffectUniquenessHints,
+} from '@aztec/stdlib/kernel';
+
+export function computeSideEffectUniquenessHints(publicInputs: PrivateCircuitPublicInputs): SideEffectUniquenessHints {
+  let sideEffectRanges: SideEffectCounterRange[] = [];
+
+  sideEffectRanges = sideEffectRanges.concat(
+    createRangesFromClaimedLengthArray(
+      publicInputs.noteHashReadRequests,
+      GLOBAL_INDEX_NOTE_HASH_READ_REQUEST_OFFSET,
+      createRangeFromCountedItem,
+    ),
+  );
+  sideEffectRanges = sideEffectRanges.concat(
+    createRangesFromClaimedLengthArray(
+      publicInputs.nullifierReadRequests,
+      GLOBAL_INDEX_NULLIFIER_READ_REQUEST_OFFSET,
+      createRangeFromCountedItem,
+    ),
+  );
+  sideEffectRanges = sideEffectRanges.concat(
+    createRangesFromClaimedLengthArray(
+      publicInputs.noteHashes,
+      GLOBAL_INDEX_NOTE_HASH_OFFSET,
+      createRangeFromCountedItem,
+    ),
+  );
+  sideEffectRanges = sideEffectRanges.concat(
+    createRangesFromClaimedLengthArray(
+      publicInputs.nullifiers,
+      GLOBAL_INDEX_NULLIFIER_OFFSET,
+      createRangeFromCountedItem,
+    ),
+  );
+  sideEffectRanges = sideEffectRanges.concat(
+    createRangesFromClaimedLengthArray(
+      publicInputs.privateCallRequests,
+      GLOBAL_INDEX_PRIVATE_CALL_REQUEST_OFFSET,
+      createRangeFromPrivateCallRequest,
+    ),
+  );
+  sideEffectRanges = sideEffectRanges.concat(
+    createRangesFromClaimedLengthArray(
+      publicInputs.publicCallRequests,
+      GLOBAL_INDEX_PUBLIC_CALL_REQUEST_OFFSET,
+      createRangeFromCountedItem,
+    ),
+  );
+  sideEffectRanges = sideEffectRanges.concat(
+    createRangesFromClaimedLengthArray(
+      publicInputs.l2ToL1Msgs,
+      GLOBAL_INDEX_L2_TO_L1_MSG_OFFSET,
+      createRangeFromCountedItem,
+    ),
+  );
+  sideEffectRanges = sideEffectRanges.concat(
+    createRangesFromClaimedLengthArray(
+      publicInputs.privateLogs,
+      GLOBAL_INDEX_PRIVATE_LOG_OFFSET,
+      createRangeFromCountedItem,
+    ),
+  );
+  sideEffectRanges = sideEffectRanges.concat(
+    createRangesFromClaimedLengthArray(
+      publicInputs.contractClassLogsHashes,
+      GLOBAL_INDEX_CONTRACT_CLASS_LOG_HASH_OFFSET,
+      createRangeFromCountedItem,
+    ),
+  );
+
+  sideEffectRanges.sort((a, b) => a.start - b.start);
+
+  const sideEffectRangeIndices = makeTuple(TOTAL_COUNTED_SIDE_EFFECTS_PER_CALL, () => 0);
+  for (let i = 0; i < sideEffectRanges.length; i++) {
+    const range = sideEffectRanges[i];
+    sideEffectRangeIndices[range.sideEffectGlobalIndex] = i;
+  }
+
+  const hints = SideEffectUniquenessHints.from({
+    sideEffectRanges: padArrayEnd(
+      sideEffectRanges,
+      SideEffectCounterRange.empty(),
+      TOTAL_COUNTED_SIDE_EFFECTS_PER_CALL,
+    ),
+    noteHashReadRequestIndices: makeTuple(
+      MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
+      i => sideEffectRangeIndices[i + GLOBAL_INDEX_NOTE_HASH_READ_REQUEST_OFFSET],
+    ),
+    nullifierReadRequestIndices: makeTuple(
+      MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
+      i => sideEffectRangeIndices[i + GLOBAL_INDEX_NULLIFIER_READ_REQUEST_OFFSET],
+    ),
+    noteHashesIndices: makeTuple(
+      MAX_NOTE_HASHES_PER_CALL,
+      i => sideEffectRangeIndices[i + GLOBAL_INDEX_NOTE_HASH_OFFSET],
+    ),
+    nullifiersIndices: makeTuple(
+      MAX_NULLIFIERS_PER_CALL,
+      i => sideEffectRangeIndices[i + GLOBAL_INDEX_NULLIFIER_OFFSET],
+    ),
+    privateCallRequestsIndices: makeTuple(
+      MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,
+      i => sideEffectRangeIndices[i + GLOBAL_INDEX_PRIVATE_CALL_REQUEST_OFFSET],
+    ),
+    publicCallRequestsIndices: makeTuple(
+      MAX_ENQUEUED_CALLS_PER_CALL,
+      i => sideEffectRangeIndices[i + GLOBAL_INDEX_PUBLIC_CALL_REQUEST_OFFSET],
+    ),
+    l2ToL1MsgsIndices: makeTuple(
+      MAX_L2_TO_L1_MSGS_PER_CALL,
+      i => sideEffectRangeIndices[i + GLOBAL_INDEX_L2_TO_L1_MSG_OFFSET],
+    ),
+    privateLogsIndices: makeTuple(
+      MAX_PRIVATE_LOGS_PER_CALL,
+      i => sideEffectRangeIndices[i + GLOBAL_INDEX_PRIVATE_LOG_OFFSET],
+    ),
+    contractClassLogsHashesIndices: makeTuple(
+      MAX_CONTRACT_CLASS_LOGS_PER_CALL,
+      i => sideEffectRangeIndices[i + GLOBAL_INDEX_CONTRACT_CLASS_LOG_HASH_OFFSET],
+    ),
+  });
+
+  return hints;
+}
+
+function createRangesFromClaimedLengthArray<T extends Serializable, N extends number>(
+  array: ClaimedLengthArray<T, N>,
+  globalIndexOffset: number,
+  rangeConstructor: (item: T, globalIndex: number) => SideEffectCounterRange,
+): SideEffectCounterRange[] {
+  const ranges = [];
+  for (let i = 0; i < array.claimedLength; i++) {
+    ranges.push(rangeConstructor(array.array[i], globalIndexOffset + i));
+  }
+  return ranges;
+}
+
+function createRangeFromCountedItem(item: { counter: number }, globalIndex: number): SideEffectCounterRange {
+  return new SideEffectCounterRange(item.counter, item.counter, globalIndex);
+}
+
+function createRangeFromPrivateCallRequest(item: PrivateCallRequest, globalIndex: number): SideEffectCounterRange {
+  return new SideEffectCounterRange(item.startSideEffectCounter, item.endSideEffectCounter, globalIndex);
+}

package/src/private_kernel/private_kernel_execution_prover.ts

@@ -35,6 +35,7 @@ import {
 import { VerificationKeyAsFields, VerificationKeyData, VkData } from '@aztec/stdlib/vks';
 
 import { PrivateKernelResetPrivateInputsBuilder } from './hints/build_private_kernel_reset_private_inputs.js';
+import { computeSideEffectUniquenessHints } from './hints/compute_side_effect_uniqueness_hints.js';
 import type { PrivateKernelOracle } from './private_kernel_oracle.js';
 
 const NULL_SIMULATE_OUTPUT: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs> = {
@@ -415,6 +416,9 @@ export class PrivateKernelExecutionProver {
       await this.oracle.getContractClassIdPreimage(currentContractClassId);
 
     const updatedClassIdHints = await this.oracle.getUpdatedClassIdHints(contractAddress);
+
+    const sideEffectUniquenessHints = computeSideEffectUniquenessHints(publicInputs);
+
     return PrivateCallData.from({
       publicInputs,
       vk,
@@ -426,6 +430,7 @@ export class PrivateKernelExecutionProver {
         functionLeafMembershipWitness,
         updatedClassIdHints,
       }),
+      sideEffectUniquenessHints,
     });
   }
 }

package/src/storage/note_data_provider/note_data_provider.ts

@@ -3,7 +3,7 @@ import type { Fr } from '@aztec/foundation/fields';
 import { toArray } from '@aztec/foundation/iterable';
 import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap } from '@aztec/kv-store';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { InBlock } from '@aztec/stdlib/block';
+import type { DataInBlock } from '@aztec/stdlib/block';
 import { NoteStatus, type NotesFilter } from '@aztec/stdlib/note';
 import { NoteDao } from '@aztec/stdlib/note';
 
@@ -224,7 +224,7 @@ export class NoteDataProvider {
    * parameters.
    *
    * @param filter - Filter criteria including contractAddress (required), and optional
-   *                 storageSlot, status, scopes and siloedNullifier.
+   *                 owner, storageSlot, status, scopes, and siloedNullifier.
    * @returns Promise resolving to array of NoteDao objects matching the filter
    * @throws If filtering by an empty scopes array. Scopes have to be set to undefined or to a non-empty array.
    */
@@ -307,6 +307,10 @@ export class NoteDataProvider {
           continue;
         }
 
+        if (filter.owner && !note.owner.equals(filter.owner)) {
+          continue;
+        }
+
         if (filter.storageSlot && !note.storageSlot.equals(filter.storageSlot!)) {
           continue;
         }
@@ -333,7 +337,7 @@ export class NoteDataProvider {
    * @returns Promise resolving to array of nullified NoteDao objects
    * @throws Error if any nullifier is not found in the active notes
    */
-  applyNullifiers(nullifiers: InBlock<Fr>[]): Promise<NoteDao[]> {
+  applyNullifiers(nullifiers: DataInBlock<Fr>[]): Promise<NoteDao[]> {
     if (nullifiers.length === 0) {
       return Promise.resolve([]);
     }