@aztec/pxe 0.0.1-commit.c7c42ec → 0.0.1-commit.f295ac2

package/src/contract_function_simulator/execution_note_cache.ts

@@ -32,19 +32,22 @@ export class ExecutionNoteCache {
   private nullifierMap: Map<bigint, Set<bigint>> = new Map();
 
   /**
-   * All nullifiers emitted in this transaction.
+   * Nullifiers emitted by private calls in this transaction.
    */
-  private allNullifiers: Set<bigint> = new Set();
+  private emittedNullifiers: Set<bigint> = new Set();
 
+  /**
+   * The counter that separates non-revertible side effects (which persist even if the tx reverts) from revertible ones.
+   */
   private minRevertibleSideEffectCounter = 0;
 
   private inRevertiblePhase = false;
 
   /**
-   * We don't need to use the tx request hash for nonces if another non revertible nullifier is emitted.
-   * In that case we disable injecting the tx request hash as a nullifier.
+   * Whether the protocol nullifier was used for nonce generation.
+   * We don't need to use the protocol nullifier if a non-revertible nullifier is emitted.
    */
-  private usedProtocolNullifierForNonces = true;
+  private usedProtocolNullifierForNonces: boolean | undefined;
 
   constructor(private readonly protocolNullifier: Fr) {}
 
@@ -60,17 +63,18 @@ export class ExecutionNoteCache {
     }
     this.inRevertiblePhase = true;
     this.minRevertibleSideEffectCounter = minRevertibleSideEffectCounter;
-    let nonceGenerator = this.protocolNullifier;
-    const nullifiers = this.getAllNullifiers();
-    if (nullifiers.length > 0) {
-      nonceGenerator = new Fr(nullifiers[0]);
-      this.usedProtocolNullifierForNonces = false;
-    }
+
+    const nullifiers = this.getEmittedNullifiers();
+    // If there are no nullifiers emitted by private calls so far, we use the protocol nullifier as the nonce generator.
+    // Note: There could still be nullifiers emitted after the counter is set, but those nullifiers are revertible, so
+    // we don't want to use them as the nonce generator.
+    this.usedProtocolNullifierForNonces = nullifiers.length === 0;
+    const nonceGenerator = this.usedProtocolNullifierForNonces ? this.protocolNullifier : new Fr(nullifiers[0]);
 
     // The existing pending notes are all non-revertible.
     // They cannot be squashed by nullifiers emitted after minRevertibleSideEffectCounter is set.
     // Their indexes in the tx are known at this point and won't change. So we can assign a nonce to each one of them.
-    // The nonces will be used to create the "complete" nullifier.
+    // The nonces will be used to create the "unique" note hashes.
     const updatedNotes = await Promise.all(
       this.notes.map(async ({ note, counter }, i) => {
         const noteNonce = await computeNoteHashNonce(nonceGenerator, i);
@@ -99,15 +103,11 @@ export class ExecutionNoteCache {
   }
 
   public finish() {
-    // If we never entered the revertible phase, we need to use the protocol nullifier to compute the nonces for the
-    // notes if no nullifiers have been emitted.
+    // If we never entered the revertible phase, and there are no nullifiers emitted, we need to use the protocol
+    // nullifier as the nonce generator.
     if (!this.inRevertiblePhase) {
-      this.usedProtocolNullifierForNonces = this.getAllNullifiers().length === 0;
+      this.usedProtocolNullifierForNonces = this.getEmittedNullifiers().length === 0;
     }
-    // If we entered the revertible phase, the nonce generator was decided based on wether or not a nullifier was emitted before entering.
-    return {
-      usedProtocolNullifierForNonces: this.usedProtocolNullifierForNonces,
-    };
   }
 
   /**
@@ -150,11 +150,11 @@ export class ExecutionNoteCache {
 
       // If the note is non revertible and the nullifier was emitted in the revertible phase, both the note hash and the nullifier will be emitted
       if (this.inRevertiblePhase && note.counter < this.minRevertibleSideEffectCounter) {
-        this.recordNullifier(contractAddress, siloedNullifier);
+        this.#recordNullifier(contractAddress, siloedNullifier);
       }
     } else {
       // If the note being nullified comes from a previous tx the nullifier will be emitted.
-      this.recordNullifier(contractAddress, siloedNullifier);
+      this.#recordNullifier(contractAddress, siloedNullifier);
     }
     return nullifiedNoteHashCounter;
   }
@@ -166,7 +166,7 @@ export class ExecutionNoteCache {
    */
   public async nullifierCreated(contractAddress: AztecAddress, innerNullifier: Fr) {
     const siloedNullifier = (await siloNullifier(contractAddress, innerNullifier)).toBigInt();
-    this.recordNullifier(contractAddress, siloedNullifier);
+    this.#recordNullifier(contractAddress, siloedNullifier);
   }
 
   /**
@@ -215,11 +215,30 @@ export class ExecutionNoteCache {
     return this.notes;
   }
 
+  /**
+   * @returns All nullifiers emitted by private calls in this transaction.
+   */
+  getEmittedNullifiers(): Fr[] {
+    return [...this.emittedNullifiers].map(n => new Fr(n));
+  }
+
+  /**
+   * @returns All nullifiers emitted by private calls in this transaction. If the protocol nullifier was used as the
+   * nonce generator, it is injected as the first nullifier.
+   */
   getAllNullifiers(): Fr[] {
-    return [...this.allNullifiers].map(n => new Fr(n));
+    if (this.usedProtocolNullifierForNonces === undefined) {
+      throw new Error('usedProtocolNullifierForNonces is not set yet. Call finish() to complete the transaction.');
+    }
+    const allNullifiers = this.getEmittedNullifiers();
+    return [...(this.usedProtocolNullifierForNonces ? [this.protocolNullifier] : []), ...allNullifiers];
+  }
+
+  getNonceGenerator(): Fr {
+    return this.getAllNullifiers()[0];
   }
 
-  recordNullifier(contractAddress: AztecAddress, siloedNullifier: bigint) {
+  #recordNullifier(contractAddress: AztecAddress, siloedNullifier: bigint) {
     const nullifiers = this.getNullifiers(contractAddress);
 
     if (nullifiers.has(siloedNullifier)) {
@@ -228,6 +247,6 @@ export class ExecutionNoteCache {
 
     nullifiers.add(siloedNullifier);
     this.nullifierMap.set(contractAddress.toBigInt(), nullifiers);
-    this.allNullifiers.add(siloedNullifier);
+    this.emittedNullifiers.add(siloedNullifier);
   }
 }

package/src/contract_function_simulator/noir-structs/event_validation_request.ts

@@ -15,6 +15,7 @@ export class EventValidationRequest {
   constructor(
     public contractAddress: AztecAddress,
     public eventTypeId: EventSelector,
+    public randomness: Fr,
     public serializedEvent: Fr[],
     public eventCommitment: Fr,
     public txHash: TxHash,
@@ -27,6 +28,8 @@ export class EventValidationRequest {
     const contractAddress = AztecAddress.fromField(reader.readField());
     const eventTypeId = EventSelector.fromField(reader.readField());
 
+    const randomness = reader.readField();
+
     const eventStorage = reader.readFieldArray(MAX_EVENT_SERIALIZED_LEN);
     const eventLen = reader.readField().toNumber();
     const serializedEvent = eventStorage.slice(0, eventLen);
@@ -38,6 +41,7 @@ export class EventValidationRequest {
     return new EventValidationRequest(
       contractAddress,
       eventTypeId,
+      randomness,
       serializedEvent,
       eventCommitment,
       txHash,

package/src/contract_function_simulator/noir-structs/utility_context.ts

@@ -1,42 +1,23 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
-import type { FieldsOf } from '@aztec/foundation/types';
+import { toACVMField } from '@aztec/simulator/client';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { UInt64 } from '@aztec/stdlib/types';
+import type { BlockHeader } from '@aztec/stdlib/tx';
 
 /**
  * TypeScript counterpart of utility_context.nr. Used only as a return value for the utilityGetUtilityContext oracle.
  */
 export class UtilityContext {
-  private constructor(
-    public readonly blockNumber: number,
-    public readonly timestamp: UInt64,
+  constructor(
+    public readonly blockHeader: BlockHeader,
     public readonly contractAddress: AztecAddress,
-    public readonly version: Fr,
-    public readonly chainId: Fr,
   ) {}
 
-  static from(fields: FieldsOf<UtilityContext>) {
-    return new UtilityContext(
-      fields.blockNumber,
-      fields.timestamp,
-      fields.contractAddress,
-      fields.version,
-      fields.chainId,
-    );
-  }
-
   /**
    * Returns a representation of the utility context as expected by intrinsic Noir deserialization.
    * The order of the fields has to be the same as the order of the fields in the utility_context.nr.
    */
   public toNoirRepresentation(): (string | string[])[] {
     // TODO(#12874): remove the stupid as string conversion by modifying ForeignCallOutput type in acvm.js
-    return [
-      new Fr(this.blockNumber).toString() as string,
-      new Fr(this.timestamp).toString() as string,
-      this.contractAddress.toString() as string,
-      this.version.toString() as string,
-      this.chainId.toString() as string,
-    ];
+    const blockHeaderFields = this.blockHeader.toFields().map(toACVMField);
+    return [...blockHeaderFields, this.contractAddress.toString() as string];
   }
 }

package/src/contract_function_simulator/oracle/interfaces.ts

@@ -4,6 +4,7 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import { Point } from '@aztec/foundation/curves/grumpkin';
 import type { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { L2BlockHash } from '@aztec/stdlib/block';
 import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
 import type { KeyValidationRequest } from '@aztec/stdlib/kernel';
 import type { ContractClassLog, Tag } from '@aztec/stdlib/logs';
@@ -32,10 +33,10 @@ export interface NoteData {
   noteNonce: Fr;
   /** A hash of the note as it gets stored in the note hash tree. */
   noteHash: Fr;
+  /** True if the note is pending, false if settled. */
+  isPending: boolean;
   /** The corresponding nullifier of the note. Undefined for pending notes. */
   siloedNullifier?: Fr;
-  /** The note's leaf index in the note hash tree. Undefined for pending notes. */
-  index?: bigint;
 }
 
 // These interfaces contain the list of oracles required by aztec-nr in order to simulate and execute transactions, i.e.
@@ -65,14 +66,14 @@ export interface IUtilityExecutionOracle {
   utilityGetUtilityContext(): UtilityContext;
   utilityGetKeyValidationRequest(pkMHash: Fr): Promise<KeyValidationRequest>;
   utilityGetContractInstance(address: AztecAddress): Promise<ContractInstance>;
-  utilityGetMembershipWitness(blockNumber: BlockNumber, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[] | undefined>;
+  utilityGetMembershipWitness(blockHash: L2BlockHash, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[] | undefined>;
   utilityGetNullifierMembershipWitness(
-    blockNumber: BlockNumber,
+    blockHash: L2BlockHash,
     nullifier: Fr,
   ): Promise<NullifierMembershipWitness | undefined>;
-  utilityGetPublicDataWitness(blockNumber: BlockNumber, leafSlot: Fr): Promise<PublicDataWitness | undefined>;
+  utilityGetPublicDataWitness(blockHash: L2BlockHash, leafSlot: Fr): Promise<PublicDataWitness | undefined>;
   utilityGetLowNullifierMembershipWitness(
-    blockNumber: BlockNumber,
+    blockHash: L2BlockHash,
     nullifier: Fr,
   ): Promise<NullifierMembershipWitness | undefined>;
   utilityGetBlockHeader(blockNumber: BlockNumber): Promise<BlockHeader | undefined>;
@@ -102,9 +103,9 @@ export interface IUtilityExecutionOracle {
     secret: Fr,
   ): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>>;
   utilityStorageRead(
+    blockHash: L2BlockHash,
     contractAddress: AztecAddress,
     startStorageSlot: Fr,
-    blockNumber: BlockNumber,
     numberOfElements: number,
   ): Promise<Fr[]>;
   utilityFetchTaggedLogs(pendingTaggedLogArrayBaseSlot: Fr): Promise<void>;

package/src/contract_function_simulator/oracle/note_packing_utils.ts

@@ -28,7 +28,7 @@ function fromRawData(nonzeroNoteHashCounter: boolean, maybeNoteNonce: Fr): { sta
  * @param randomness - The randomness injected into the note to get the hiding property of commitments
  * @param storageSlot - The storage slot of the note
  * @param noteNonce - The nonce injected into the note hash preimage by kernels.
- * @param index - Optional index in the note hash tree. If undefined, indicates a transient note
+ * @param isPending - True if the note is pending, false if settled
  * @param note - The note content containing the actual note data
  * @returns The packed note as an array of field elements
  */
@@ -38,7 +38,7 @@ export function packAsRetrievedNote({
   randomness,
   storageSlot,
   noteNonce,
-  index,
+  isPending,
   note,
 }: {
   contractAddress: AztecAddress;
@@ -46,14 +46,14 @@ export function packAsRetrievedNote({
   randomness: Fr;
   storageSlot: Fr;
   noteNonce: Fr;
-  index?: bigint;
+  isPending: boolean;
   note: Note;
 }) {
-  // If index is undefined, the note is transient which implies that the nonzero_note_hash_counter has to be true
-  const nonzeroNoteHashCounter = index === undefined;
+  // If the note is pending it means it has a non-zero note hash counter associated with it.
+  const nonZeroNoteHashCounter = isPending;
 
   // To pack the note as retrieved note we first need to reconstruct the note metadata.
-  const noteMetadata = fromRawData(nonzeroNoteHashCounter, noteNonce);
+  const noteMetadata = fromRawData(nonZeroNoteHashCounter, noteNonce);
 
   // Pack in order: note, contract_address, owner, randomness, storage_slot, metadata (stage, maybe_note_nonce)
   return [

package/src/contract_function_simulator/oracle/oracle.ts

@@ -12,6 +12,7 @@ import {
 } from '@aztec/simulator/client';
 import { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { L2BlockHash } from '@aztec/stdlib/block';
 import { ContractClassLog, ContractClassLogFields } from '@aztec/stdlib/logs';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 
@@ -138,76 +139,77 @@ export class Oracle {
   }
 
   async utilityGetMembershipWitness(
-    [blockNumber]: ACVMField[],
+    [blockHash]: ACVMField[],
     [treeId]: ACVMField[],
     [leafValue]: ACVMField[],
   ): Promise<(ACVMField | ACVMField[])[]> {
-    const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
+    const parsedBlockHash = L2BlockHash.fromString(blockHash);
     const parsedTreeId = Fr.fromString(treeId).toNumber();
     const parsedLeafValue = Fr.fromString(leafValue);
 
     const witness = await this.handlerAsUtility().utilityGetMembershipWitness(
-      BlockNumber(parsedBlockNumber),
+      parsedBlockHash,
       parsedTreeId,
       parsedLeafValue,
     );
     if (!witness) {
       throw new Error(
-        `Leaf ${leafValue} not found in the tree ${MerkleTreeId[parsedTreeId]} at block ${parsedBlockNumber}.`,
+        `Leaf ${leafValue} not found in the tree ${MerkleTreeId[parsedTreeId]} at block hash ${parsedBlockHash.toString()}.`,
       );
     }
     return [toACVMField(witness[0]), witness.slice(1).map(toACVMField)];
   }
 
   async utilityGetNullifierMembershipWitness(
-    [blockNumber]: ACVMField[],
+    [blockHash]: ACVMField[],
     [nullifier]: ACVMField[], // nullifier, we try to find the witness for (to prove inclusion)
   ): Promise<(ACVMField | ACVMField[])[]> {
-    const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
+    const parsedBlockHash = L2BlockHash.fromString(blockHash);
     const parsedNullifier = Fr.fromString(nullifier);
 
     const witness = await this.handlerAsUtility().utilityGetNullifierMembershipWitness(
-      BlockNumber(parsedBlockNumber),
+      parsedBlockHash,
       parsedNullifier,
     );
     if (!witness) {
-      throw new Error(`Nullifier witness not found for nullifier ${parsedNullifier} at block ${parsedBlockNumber}.`);
+      throw new Error(
+        `Nullifier witness not found for nullifier ${parsedNullifier} at block hash ${parsedBlockHash.toString()}.`,
+      );
     }
     return witness.toNoirRepresentation();
   }
 
   async utilityGetLowNullifierMembershipWitness(
-    [blockNumber]: ACVMField[],
+    [blockHash]: ACVMField[],
     [nullifier]: ACVMField[], // nullifier, we try to find the low nullifier witness for (to prove non-inclusion)
   ): Promise<(ACVMField | ACVMField[])[]> {
-    const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
+    const parsedBlockHash = L2BlockHash.fromString(blockHash);
     const parsedNullifier = Fr.fromString(nullifier);
 
     const witness = await this.handlerAsUtility().utilityGetLowNullifierMembershipWitness(
-      BlockNumber(parsedBlockNumber),
+      parsedBlockHash,
       parsedNullifier,
     );
     if (!witness) {
       throw new Error(
-        `Low nullifier witness not found for nullifier ${parsedNullifier} at block ${parsedBlockNumber}.`,
+        `Low nullifier witness not found for nullifier ${parsedNullifier} at block hash ${parsedBlockHash.toString()}.`,
       );
     }
     return witness.toNoirRepresentation();
   }
 
   async utilityGetPublicDataWitness(
-    [blockNumber]: ACVMField[],
+    [blockHash]: ACVMField[],
     [leafSlot]: ACVMField[],
   ): Promise<(ACVMField | ACVMField[])[]> {
-    const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
+    const parsedBlockHash = L2BlockHash.fromString(blockHash);
     const parsedLeafSlot = Fr.fromString(leafSlot);
 
-    const witness = await this.handlerAsUtility().utilityGetPublicDataWitness(
-      BlockNumber(parsedBlockNumber),
-      parsedLeafSlot,
-    );
+    const witness = await this.handlerAsUtility().utilityGetPublicDataWitness(parsedBlockHash, parsedLeafSlot);
     if (!witness) {
-      throw new Error(`Public data witness not found for slot ${parsedLeafSlot} at block ${parsedBlockNumber}.`);
+      throw new Error(
+        `Public data witness not found for slot ${parsedLeafSlot} at block hash ${parsedBlockHash.toString()}.`,
+      );
     }
     return witness.toNoirRepresentation();
   }
@@ -286,7 +288,7 @@ export class Oracle {
         randomness: noteData.randomness,
         storageSlot: noteData.storageSlot,
         noteNonce: noteData.noteNonce,
-        index: noteData.index,
+        isPending: noteData.isPending,
         note: noteData.note,
       }),
     );
@@ -358,15 +360,15 @@ export class Oracle {
   }
 
   async utilityStorageRead(
+    [blockHash]: ACVMField[],
     [contractAddress]: ACVMField[],
     [startStorageSlot]: ACVMField[],
-    [blockNumber]: ACVMField[],
     [numberOfElements]: ACVMField[],
   ): Promise<ACVMField[][]> {
     const values = await this.handlerAsUtility().utilityStorageRead(
+      L2BlockHash.fromString(blockHash),
       new AztecAddress(Fr.fromString(contractAddress)),
       Fr.fromString(startStorageSlot),
-      BlockNumber(+blockNumber),
       +numberOfElements,
     );
     return [values.map(toACVMField)];

package/src/contract_function_simulator/oracle/private_execution.ts

@@ -1,5 +1,4 @@
 import { PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH, PRIVATE_CONTEXT_INPUTS_LENGTH } from '@aztec/constants';
-import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
@@ -19,13 +18,13 @@ import {
   countArgumentsSize,
 } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { L2BlockHash } from '@aztec/stdlib/block';
 import type { ContractInstance } from '@aztec/stdlib/contract';
 import { DelayedPublicMutableValues, DelayedPublicMutableValuesWithHash } from '@aztec/stdlib/delayed-public-mutable';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import { PrivateCircuitPublicInputs } from '@aztec/stdlib/kernel';
 import type { CircuitWitnessGenerationStats } from '@aztec/stdlib/stats';
 import { BlockHeader, PrivateCallExecutionResult } from '@aztec/stdlib/tx';
-import type { UInt64 } from '@aztec/stdlib/types';
 
 import { ContractStore } from '../../storage/contract_store/index.js';
 import { Oracle } from './oracle.js';
@@ -85,7 +84,6 @@ export async function executePrivateFunction(
 
   const rawReturnValues = await privateExecutionOracle.privateLoadFromExecutionCache(publicInputs.returnsHash);
 
-  const noteHashLeafIndexMap = privateExecutionOracle.getNoteHashLeafIndexMap();
   const newNotes = privateExecutionOracle.getNewNotes();
   const noteHashNullifierCounterMap = privateExecutionOracle.getNoteHashNullifierCounterMap();
   const offchainEffects = privateExecutionOracle.getOffchainEffects();
@@ -108,7 +106,6 @@ export async function executePrivateFunction(
     Buffer.from(artifact.verificationKey!, 'base64'),
     partialWitness,
     publicInputs,
-    noteHashLeafIndexMap,
     newNotes,
     noteHashNullifierCounterMap,
     rawReturnValues,
@@ -154,21 +151,22 @@ export function extractPrivateCircuitPublicInputs(
  * from the instance is used.
  * @param contractAddress - The address of the contract to read the class id for.
  * @param instance - The instance of the contract.
- * @param executionStore - The execution data provider.
- * @param blockNumber - The block number at which to load the DelayedPublicMutable storing the class id.
- * @param timestamp - The timestamp at which to obtain the class id from the DelayedPublicMutable.
+ * @param aztecNode - The Aztec node to query for storage.
+ * @param header - The header of the block at which to load the DelayedPublicMutable storing the class id.
  * @returns The current class id.
  */
 export async function readCurrentClassId(
   contractAddress: AztecAddress,
   instance: ContractInstance,
   aztecNode: AztecNode,
-  blockNumber: BlockNumber,
-  timestamp: UInt64,
+  header: BlockHeader,
 ) {
+  const blockHashFr = await header.hash();
+  const blockHash = L2BlockHash.fromField(blockHashFr);
+  const timestamp = header.globalVariables.timestamp;
   const { delayedPublicMutableSlot } = await DelayedPublicMutableValuesWithHash.getContractUpdateSlots(contractAddress);
   const delayedPublicMutableValues = await DelayedPublicMutableValues.readFromTree(delayedPublicMutableSlot, slot =>
-    aztecNode.getPublicStorageAt(blockNumber, ProtocolContractAddress.ContractInstanceRegistry, slot),
+    aztecNode.getPublicStorageAt(blockHash, ProtocolContractAddress.ContractInstanceRegistry, slot),
   );
   let currentClassId = delayedPublicMutableValues.svc.getCurrentAt(timestamp)[0];
   if (currentClassId.isZero()) {
@@ -180,8 +178,7 @@ export async function readCurrentClassId(
 /**
  * Verify that the current class id of a contract obtained from AztecNode is the same as the one in contract data
  * provider (i.e. PXE's own storage).
- * @param header - The header of the block at which to verify the current class id. If not provided, the anchor block
- * header of the execution data provider is used.
+ * @param header - The header of the block at which to verify the current class id.
  */
 export async function verifyCurrentClassId(
   contractAddress: AztecAddress,
@@ -194,13 +191,7 @@ export async function verifyCurrentClassId(
     throw new Error(`No contract instance found for address ${contractAddress.toString()}`);
   }
 
-  const currentClassId = await readCurrentClassId(
-    contractAddress,
-    instance,
-    aztecNode,
-    header.globalVariables.blockNumber,
-    header.globalVariables.timestamp,
-  );
+  const currentClassId = await readCurrentClassId(contractAddress, instance, aztecNode, header);
   if (!instance.currentContractClassId.equals(currentClassId)) {
     throw new Error(
       `Contract ${contractAddress} is outdated, current class id is ${currentClassId}, local class id is ${instance.currentContractClassId}`,

package/src/contract_function_simulator/oracle/private_execution_oracle.ts

@@ -7,13 +7,14 @@ import { type CircuitSimulator, toACVMWitness } from '@aztec/simulator/client';
 import {
   type FunctionAbi,
   type FunctionArtifact,
+  type FunctionCall,
   FunctionSelector,
   type NoteSelector,
   countArgumentsSize,
 } from '@aztec/stdlib/abi';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
+import { siloNullifier } from '@aztec/stdlib/hash';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import { PrivateContextInputs } from '@aztec/stdlib/kernel';
 import { type ContractClassLog, DirectionalAppTaggingSecret, type PreTag } from '@aztec/stdlib/logs';
@@ -63,16 +64,6 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle implements IP
    * Users can also use this to get a clearer idea of what's happened during a simulation.
    */
   private newNotes: NoteAndSlot[] = [];
-  /**
-   * Notes from previous transactions that are returned to the oracle call `getNotes` during this execution.
-   * The mapping maps from the unique siloed note hash to the index for notes created in private executions.
-   * It maps from siloed note hash to the index for notes created by public functions.
-   *
-   * They are not part of the ExecutionNoteCache and being forwarded to nested contexts via `extend()`
-   * because these notes are meant to be maintained on a per-call basis
-   * They should act as references for the read requests output by an app circuit via public inputs.
-   */
-  private noteHashLeafIndexMap: Map<bigint, bigint> = new Map();
   private noteHashNullifierCounterMap: Map<number, number> = new Map();
   private contractClassLogs: CountedContractClassLog[] = [];
   private offchainEffects: { data: Fr[] }[] = [];
@@ -84,6 +75,8 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle implements IP
     private readonly callContext: CallContext,
     /** Header of a block whose state is used during private execution (not the block the transaction is included in). */
     protected override readonly anchorBlockHeader: BlockHeader,
+    /** Needed to trigger contract synchronization before nested calls */
+    private readonly utilityExecutor: (call: FunctionCall) => Promise<void>,
     /** List of transient auth witnesses to be used during this simulation */
     authWitnesses: AuthWitness[],
     capsules: Capsule[],
@@ -101,6 +94,7 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle implements IP
     senderAddressBookStore: SenderAddressBookStore,
     capsuleStore: CapsuleStore,
     privateEventStore: PrivateEventStore,
+    jobId: string,
     private totalPublicCalldataCount: number = 0,
     protected sideEffectCounter: number = 0,
     log = createLogger('simulator:client_execution_context'),
@@ -123,6 +117,7 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle implements IP
       senderAddressBookStore,
       capsuleStore,
       privateEventStore,
+      jobId,
       log,
       scopes,
     );
@@ -157,14 +152,6 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle implements IP
     return toACVMWitness(0, fields);
   }
 
-  /**
-   * The KernelProver will use this to fully populate witnesses and provide hints to the kernel circuit
-   * regarding which note hash each settled read request corresponds to.
-   */
-  public getNoteHashLeafIndexMap() {
-    return this.noteHashLeafIndexMap;
-  }
-
   /**
    * Get the data for the newly created notes.
    */
@@ -278,9 +265,9 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle implements IP
       // This is a tagging secret we've not yet used in this tx, so first sync our store to make sure its indices
       // are up to date. We do this here because this store is not synced as part of the global sync because
       // that'd be wasteful as most tagging secrets are not used in each tx.
-      await syncSenderTaggingIndexes(secret, this.contractAddress, this.aztecNode, this.senderTaggingStore);
+      await syncSenderTaggingIndexes(secret, this.contractAddress, this.aztecNode, this.senderTaggingStore, this.jobId);
 
-      const lastUsedIndex = await this.senderTaggingStore.getLastUsedIndex(secret);
+      const lastUsedIndex = await this.senderTaggingStore.getLastUsedIndex(secret, this.jobId);
       // If lastUsedIndex is undefined, we've never used this secret, so start from 0
       // Otherwise, the next index to use is one past the last used index
       return lastUsedIndex === undefined ? 0 : lastUsedIndex + 1;
@@ -399,23 +386,6 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle implements IP
         .join(', ')}`,
     );
 
-    const noteHashesAndIndexes = await Promise.all(
-      notes.map(async n => {
-        if (n.index !== undefined) {
-          const siloedNoteHash = await siloNoteHash(n.contractAddress, n.noteHash);
-          const uniqueNoteHash = await computeUniqueNoteHash(n.noteNonce, siloedNoteHash);
-
-          return { hash: uniqueNoteHash, index: n.index };
-        }
-      }),
-    );
-
-    noteHashesAndIndexes
-      .filter(n => n !== undefined)
-      .forEach(n => {
-        this.noteHashLeafIndexMap.set(n!.hash.toBigInt(), n!.index);
-      });
-
     return notes;
   }
 
@@ -458,6 +428,7 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle implements IP
         note,
         siloedNullifier: undefined, // Siloed nullifier cannot be known for newly created note.
         noteHash,
+        isPending: true, // This note has just been created and hence is not settled yet.
       },
       counter,
     );
@@ -550,6 +521,8 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle implements IP
 
     await verifyCurrentClassId(targetContractAddress, this.aztecNode, this.contractStore, this.anchorBlockHeader);
 
+    await this.contractStore.syncPrivateState(targetContractAddress, functionSelector, this.utilityExecutor);
+
     const targetArtifact = await this.contractStore.getFunctionArtifactWithDebugMetadata(
       targetContractAddress,
       functionSelector,
@@ -564,6 +537,7 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle implements IP
       derivedTxContext,
       derivedCallContext,
       this.anchorBlockHeader,
+      this.utilityExecutor,
       this.authWitnesses,
       this.capsules,
       this.executionCache,
@@ -580,6 +554,7 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle implements IP
       this.senderAddressBookStore,
       this.capsuleStore,
       this.privateEventStore,
+      this.jobId,
       this.totalPublicCalldataCount,
       sideEffectCounter,
       this.log,