@aztec/pxe 5.0.0-rc.2 → 5.0.1

package/src/contract/contract_class_service.ts

@@ -0,0 +1,83 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { isProtocolContract } from '@aztec/protocol-contracts';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+
+import type { ContractStore } from '../storage/contract_store/contract_store.js';
+
+/**
+ * Resolves the contract class id that an address runs at a given anchor block, as tracked by the chain.
+ *
+ * PXE does not store a contract's current class id: it is mutable, chain-derived state that changes when a contract is
+ * upgraded and can be undone by a reorg. Instead this service asks the node for the current class at an anchor block,
+ * falling back to a local instance if no upgrades were scheduled.
+ */
+export class ContractClassService {
+  /**
+   * Class ids are cached per `(address, anchorHash)`. This avoid unnecessary network roundtrips in scenarios where
+   * multiple executions are done on the same anchor block (e.g. simulation followed by witgen), or when the same
+   * contract is invoked multiple times in an execution (e.g. authwit checks).
+   * It also means the callers don't need to worry about caching this service's return values, simplifying callsites.
+   */
+  #cache: Map<string, Promise<Fr | undefined>> = new Map();
+
+  constructor(
+    private node: AztecNode,
+    private contractStore: ContractStore,
+  ) {}
+
+  /**
+   * Returns the class id that corresponds to `address` as of `anchorBlockHeader`, or `undefined` if no instance is
+   * registered for `address`. A missing instance is an absence the caller decides how to handle, not an error; genuine
+   * failures (e.g. the node being unreachable) still throw.
+   */
+  async getCurrentClassId(address: AztecAddress, anchorBlockHeader: BlockHeader): Promise<Fr | undefined> {
+    // Protocol contracts are not in the registry and cannot be upgraded, so their original class is always current.
+    // Short-circuiting avoids a node round-trip.
+    if (isProtocolContract(address)) {
+      const instance = await this.contractStore.getContractInstance(address);
+      return instance?.originalContractClassId;
+    }
+
+    const key = `${address.toString()}:${(await anchorBlockHeader.hash()).toString()}`;
+    let promise = this.#cache.get(key);
+    if (!promise) {
+      promise = (async () => {
+        // The node resolves the current class from the same scheduled value change the AVM enforces against the public
+        // data tree. If the contract was upgraded the node returns a non-undefined instance; an undefined result means
+        // no upgrade happened (or the node has no record of it, e.g. it was never publicly deployed), so the original
+        // class is current.
+
+        const nodeInstance = await this.node.getContract(address, await anchorBlockHeader.hash());
+
+        if (nodeInstance) {
+          return nodeInstance.currentContractClassId;
+        } else {
+          return (await this.contractStore.getContractInstance(address))?.originalContractClassId;
+        }
+      })().catch(err => {
+        this.#cache.delete(key);
+        throw err;
+      });
+      this.#cache.set(key, promise);
+    }
+
+    const classId = await promise;
+    if (classId === undefined) {
+      // Don't memoize a missing instance: it may be registered later in this PXE (e.g. via contract sync
+      // mid-execution), and a cached miss would then hide it. Only successful resolutions stay cached.
+      this.#cache.delete(key);
+    }
+    return classId;
+  }
+
+  /**
+   * Clears the cache.
+   *
+   * This is not required for correctness, only to limit how much memory the cache uses. The cache is resilient against
+   * reorgs etc. as it is based on block hashes, not block numbers. */
+  wipe(): void {
+    this.#cache.clear();
+  }
+}

package/src/{contract_sync → contract}/contract_sync_service.ts

@@ -10,7 +10,8 @@ import type { StagedStore } from '../job_coordinator/job_coordinator.js';
 import { NoteService } from '../notes/note_service.js';
 import type { ContractStore } from '../storage/contract_store/contract_store.js';
 import type { NoteStore } from '../storage/note_store/note_store.js';
-import { syncScope, verifyCurrentClassId } from './helpers.js';
+import type { ContractClassService } from './contract_class_service.js';
+import { syncScope } from './helpers.js';
 
 /**
  * Maximum number of scope syncs running concurrently within a single sync call. Sized to trade off parallelism
@@ -19,8 +20,8 @@ import { syncScope, verifyCurrentClassId } from './helpers.js';
 export const MAX_CONCURRENT_SCOPE_SYNCS = 5;
 
 /**
- * Service for syncing the private state of contracts and verifying that the PXE holds the current class artifact.
- * It uses a cache to avoid redundant sync operations - the cache is wiped when the anchor block changes.
+ * Service for syncing the private state of contracts. It uses a cache to avoid redundant sync operations - the cache
+ * is wiped when the anchor block changes.
  *
  * TODO: The StagedStore naming is broken here. Figure out a better name.
  */
@@ -32,19 +33,16 @@ export class ContractSyncService implements StagedStore {
   // The value is a promise that resolves when the contract is synced.
   private syncedContracts: Map<string, Promise<void>> = new Map();
 
-  // Tracks class ID verification per contract. Keyed by contract address only (no scope), since
-  // class ID verification is scope-independent. Cleared on wipe/discard.
-  private classIdVerificationCache: Map<string, Promise<void>> = new Map();
-
   constructor(
     private aztecNode: AztecNode,
     private contractStore: ContractStore,
+    private contractClassService: ContractClassService,
     private noteStore: NoteStore,
     private log: Logger,
   ) {}
 
   /**
-   * Ensures a contract's private state is synchronized and that the PXE holds the current class artifact.
+   * Ensures a contract's private state is synchronized.
    * Uses a cache to avoid redundant sync operations - the cache is wiped when the anchor block changes.
    * @param contractAddress - The address of the contract to sync.
    * @param functionToInvokeAfterSync - The function selector that will be called after sync (used to validate it's
@@ -61,7 +59,15 @@ export class ContractSyncService implements StagedStore {
     scopes: AztecAddress[],
   ): Promise<void> {
     this.#startSyncIfNeeded(contractAddress, scopes, anchorBlockHeader, jobId, scope =>
-      syncScope(contractAddress, this.contractStore, functionToInvokeAfterSync, utilityExecutor, scope),
+      syncScope(
+        contractAddress,
+        this.contractStore,
+        this.contractClassService,
+        anchorBlockHeader,
+        functionToInvokeAfterSync,
+        utilityExecutor,
+        scope,
+      ),
     );
 
     await this.#awaitSync(contractAddress, scopes);
@@ -79,7 +85,6 @@ export class ContractSyncService implements StagedStore {
   wipe(): void {
     this.log.debug(`Wiping contract sync cache (${this.syncedContracts.size} entries)`);
     this.syncedContracts.clear();
-    this.classIdVerificationCache.clear();
   }
 
   commit(_jobId: string): Promise<void> {
@@ -90,15 +95,13 @@ export class ContractSyncService implements StagedStore {
     // We clear the synced contracts cache here because, when the job is discarded, any associated database writes from
     // the sync are also undone.
     this.syncedContracts.clear();
-    this.classIdVerificationCache.clear();
     return Promise.resolve();
   }
 
   /**
    * For each unsynced scope, creates a promise that waits on:
-   *  1. Class ID verification (cached per contract, scope-independent).
-   *  2. Note nullifier sync (shared, batched across all unsynced scopes).
-   *  3. Per-scope sync (individual, semaphore-bounded).
+   *  1. Note nullifier sync (shared, batched across all unsynced scopes).
+   *  2. Per-scope sync (individual, semaphore-bounded).
    */
   #startSyncIfNeeded(
     contractAddress: AztecAddress,
@@ -114,7 +117,6 @@ export class ContractSyncService implements StagedStore {
 
     this.log.debug(`Syncing contract ${contractAddress} for ${scopesToSync.length} scope(s)`);
 
-    const verifyPromise = this.#verifyClassId(contractAddress, anchorBlockHeader);
     const syncNullifiersPromise = this.#syncNoteNullifiers(contractAddress, anchorBlockHeader, jobId, scopesToSync);
 
     // We build a new semaphore for each sync call, so it rate-limits the scopes within that single call. We do
@@ -123,11 +125,7 @@ export class ContractSyncService implements StagedStore {
 
     for (const scope of scopesToSync) {
       const key = toKey(contractAddress, scope);
-      const promise = Promise.all([
-        verifyPromise,
-        syncNullifiersPromise,
-        runBounded(syncSlot, () => syncScopeFn(scope)),
-      ])
+      const promise = Promise.all([syncNullifiersPromise, runBounded(syncSlot, () => syncScopeFn(scope))])
         .then(() => {})
         .catch(err => {
           this.syncedContracts.delete(key);
@@ -137,23 +135,6 @@ export class ContractSyncService implements StagedStore {
     }
   }
 
-  /** Verifies the local class ID matches the on-chain value (cached, evicts on failure so retries re-verify). */
-  #verifyClassId(contractAddress: AztecAddress, anchorBlockHeader: BlockHeader): Promise<void> {
-    const contractKey = contractAddress.toString();
-    const cached = this.classIdVerificationCache.get(contractKey);
-    if (cached) {
-      return cached;
-    }
-    const promise = verifyCurrentClassId(contractAddress, this.aztecNode, this.contractStore, anchorBlockHeader).catch(
-      err => {
-        this.classIdVerificationCache.delete(contractKey);
-        throw err;
-      },
-    );
-    this.classIdVerificationCache.set(contractKey, promise);
-    return promise;
-  }
-
   /** Syncs note nullifiers across all unsynced scopes in a single batched call. */
   async #syncNoteNullifiers(
     contractAddress: AztecAddress,

package/src/contract/helpers.ts

@@ -0,0 +1,35 @@
+import { isProtocolContract } from '@aztec/protocol-contracts';
+import type { FunctionCall, FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+
+import type { ContractStore } from '../storage/contract_store/contract_store.js';
+import type { ContractClassService } from './contract_class_service.js';
+
+export async function syncScope(
+  contractAddress: AztecAddress,
+  contractStore: ContractStore,
+  contractClassService: ContractClassService,
+  anchorBlockHeader: BlockHeader,
+  functionToInvokeAfterSync: FunctionSelector | null,
+  utilityExecutor: (privateSyncCall: FunctionCall, scopes: AztecAddress[]) => Promise<any>,
+  scope: AztecAddress,
+) {
+  // Protocol contracts don't have private state to sync
+  if (isProtocolContract(contractAddress)) {
+    return;
+  }
+
+  const classId = await contractClassService.getCurrentClassId(contractAddress, anchorBlockHeader);
+  if (!classId) {
+    throw new Error(`Cannot sync contract ${contractAddress}: its instance is not registered nor published.`);
+  }
+  const syncStateFunctionCall = await contractStore.getFunctionCall('sync_state', [scope], contractAddress, classId);
+  if (functionToInvokeAfterSync && functionToInvokeAfterSync.equals(syncStateFunctionCall.selector)) {
+    throw new Error(
+      'Forbidden `sync_state` invocation. `sync_state` can only be invoked by PXE, manual execution can lead to inconsistencies.',
+    );
+  }
+
+  await utilityExecutor(syncStateFunctionCall, [scope]);
+}

package/src/contract_function_simulator/anchored_contract_data.ts

@@ -0,0 +1,74 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { FunctionArtifactWithContractName, FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstancePreimageWithAddress } from '@aztec/stdlib/contract';
+import type { BlockHeader, ContractOverrides } from '@aztec/stdlib/tx';
+
+import type { ContractClassService } from '../contract/contract_class_service.js';
+import type { ContractStore } from '../storage/contract_store/contract_store.js';
+
+/**
+ * Per-run view of contract data for a single simulation, bound to its anchor block.
+ *
+ * The {@link ContractStore} is pure class-id-keyed storage and has no notion of which class an address runs. This
+ * class bridges that gap: it resolves an address to its current class id (via the {@link ContractClassService}
+ * at the run's anchor block) and then serves artifacts from the store. It is also the single place contract
+ * overrides are applied — when an address is overridden, both its instance and its class id come from the override
+ * rather than the chain, so a simulation can execute different bytecode at that address. Overrides are only set for
+ * `simulateTx` (which skips the kernels), so the override path never reaches proving.
+ */
+export class AnchoredContractData {
+  constructor(
+    private readonly store: ContractStore,
+    private readonly contractClassService: ContractClassService,
+    private readonly anchorBlockHeader: BlockHeader,
+    private readonly overrides?: ContractOverrides,
+  ) {}
+
+  /** Returns the address preimage of the instance at `address`, from the override if any, else from storage. */
+  getContractInstance(address: AztecAddress): Promise<ContractInstancePreimageWithAddress | undefined> {
+    const override = this.overrides?.[address.toString()];
+    if (override) {
+      return Promise.resolve(override.instance);
+    }
+    return this.store.getContractInstance(address);
+  }
+
+  /**
+   * Resolves the class id `address` runs in this simulation: the override's class if overridden, else resolved against
+   * the chain at the anchor block.
+   */
+  getCurrentClassId(address: AztecAddress): Promise<Fr | undefined> {
+    const override = this.overrides?.[address.toString()];
+    if (override) {
+      return Promise.resolve(override.instance.currentContractClassId);
+    }
+    return this.contractClassService.getCurrentClassId(address, this.anchorBlockHeader);
+  }
+
+  async getFunctionArtifact(
+    address: AztecAddress,
+    selector: FunctionSelector,
+  ): Promise<FunctionArtifactWithContractName | undefined> {
+    const classId = await this.getCurrentClassId(address);
+    return classId ? this.store.getFunctionArtifact(classId, selector) : undefined;
+  }
+
+  async getFunctionArtifactWithDebugMetadata(
+    address: AztecAddress,
+    selector: FunctionSelector,
+  ): Promise<FunctionArtifactWithContractName | undefined> {
+    const classId = await this.getCurrentClassId(address);
+    return classId ? this.store.getFunctionArtifactWithDebugMetadata(classId, selector) : undefined;
+  }
+
+  async getDebugContractName(address: AztecAddress): Promise<string | undefined> {
+    const classId = await this.getCurrentClassId(address);
+    return classId ? this.store.getDebugContractName(classId) : undefined;
+  }
+
+  async getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string> {
+    const classId = await this.getCurrentClassId(address);
+    return classId ? this.store.getDebugFunctionName(classId, selector) : `${address}:${selector}`;
+  }
+}

package/src/contract_function_simulator/aztec_node_read_cache.ts

@@ -0,0 +1,89 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockHash, BlockParameter } from '@aztec/stdlib/block';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import type { TxHash } from '@aztec/stdlib/tx';
+
+/**
+ * Per-execution cache for immutable Aztec node reads.
+ */
+export class AztecNodeReadCache {
+  private readonly cache = new Map<string, Promise<unknown>>();
+
+  constructor(private readonly aztecNode: AztecNode) {}
+
+  /** Fetches a block without reissuing the same node request. */
+  public getBlock(block: BlockParameter) {
+    return this.#cachedRead(`block:${this.#keyPart(block)}`, () => this.aztecNode.getBlock(block));
+  }
+
+  /** Fetches a transaction receipt with its effect attached. */
+  public getTxReceiptWithEffect(txHash: TxHash) {
+    return this.#cachedRead(`tx-receipt-with-effect:${txHash.toString()}`, () =>
+      this.aztecNode.getTxReceipt(txHash, { includeTxEffect: true } as const),
+    );
+  }
+
+  /** Fetches an archive-tree witness for a block hash. */
+  public getBlockHashMembershipWitness(referenceBlock: BlockParameter, blockHash: BlockHash) {
+    return this.#cachedRead(
+      `block-hash-membership-witness:${this.#keyPart(referenceBlock)}:${blockHash.toString()}`,
+      () => this.aztecNode.getBlockHashMembershipWitness(referenceBlock, blockHash),
+    );
+  }
+
+  /** Fetches a public-data-tree witness for a leaf slot. */
+  public getPublicDataWitness(referenceBlock: BlockParameter, leafSlot: Fr) {
+    return this.#cachedRead(`public-data-witness:${this.#keyPart(referenceBlock)}:${leafSlot.toString()}`, () =>
+      this.aztecNode.getPublicDataWitness(referenceBlock, leafSlot),
+    );
+  }
+
+  /** Fetches public storage for a single slot. */
+  public getPublicStorageAt(referenceBlock: BlockParameter, contractAddress: AztecAddress, storageSlot: Fr) {
+    return this.#cachedRead(
+      `public-storage:${this.#keyPart(referenceBlock)}:${contractAddress.toString()}:${storageSlot.toString()}`,
+      () => this.aztecNode.getPublicStorageAt(referenceBlock, contractAddress, storageSlot),
+    );
+  }
+
+  /** Fetches a contiguous public storage range, reusing cached reads for overlapping slots. */
+  public getPublicStorageRange(
+    referenceBlock: BlockParameter,
+    contractAddress: AztecAddress,
+    startStorageSlot: Fr,
+    numberOfElements: number,
+  ) {
+    const slots = Array(numberOfElements)
+      .fill(0)
+      .map((_, i) => new Fr(startStorageSlot.value + BigInt(i)));
+
+    return Promise.all(slots.map(storageSlot => this.getPublicStorageAt(referenceBlock, contractAddress, storageSlot)));
+  }
+
+  #cachedRead<T>(key: string, fetch: () => Promise<T>): Promise<T> {
+    const cached = this.cache.get(key);
+    if (cached) {
+      return cached as Promise<T>;
+    }
+
+    const promise = fetch();
+    promise.catch(() => this.cache.delete(key));
+    this.cache.set(key, promise);
+    return promise;
+  }
+
+  #keyPart(value: unknown): string {
+    if (['string', 'number', 'bigint', 'boolean'].includes(typeof value)) {
+      return String(value);
+    }
+    if (value && typeof value === 'object') {
+      const toString = (value as { toString?: () => string }).toString;
+      if (toString && toString !== Object.prototype.toString) {
+        return toString.call(value);
+      }
+      return JSON.stringify(value, (_key, nested) => (typeof nested === 'bigint' ? nested.toString() : nested));
+    }
+    return String(value);
+  }
+}

package/src/contract_function_simulator/contract_function_simulator.ts

@@ -19,6 +19,7 @@ import {
   MAX_PRIVATE_LOGS_PER_TX,
   MAX_TX_LIFETIME,
   PRIVATE_TX_L2_GAS_OVERHEAD,
+  PUBLIC_DATA_WRITE_LENGTH,
   PUBLIC_TX_L2_GAS_OVERHEAD,
   TX_DA_GAS_OVERHEAD,
 } from '@aztec/constants';
@@ -80,6 +81,7 @@ import { MerkleTreeId } from '@aztec/stdlib/trees';
 import {
   BlockHeader,
   CallContext,
+  type ContractOverrides,
   HashedValues,
   type OffchainEffect,
   PrivateExecutionResult,
@@ -90,7 +92,8 @@ import {
   getFinalMinRevertibleSideEffectCounter,
 } from '@aztec/stdlib/tx';
 
-import type { ContractSyncService } from '../contract_sync/contract_sync_service.js';
+import type { ContractClassService } from '../contract/contract_class_service.js';
+import type { ContractSyncService } from '../contract/contract_sync_service.js';
 import type { ExecutionHooks } from '../hooks/index.js';
 import type { TxResolverService } from '../messages/tx_resolver_service.js';
 import type { AddressStore } from '../storage/address_store/address_store.js';
@@ -104,6 +107,7 @@ import type { PrivateEventStore } from '../storage/private_event_store/private_e
 import type { RecipientTaggingStore } from '../storage/tagging_store/recipient_tagging_store.js';
 import type { SenderTaggingStore } from '../storage/tagging_store/sender_tagging_store.js';
 import type { TaggingSecretSourcesStore } from '../storage/tagging_store/tagging_secret_sources_store.js';
+import { AnchoredContractData } from './anchored_contract_data.js';
 import type { BenchmarkedNode } from './benchmarked_node.js';
 import { ExecutionNoteCache } from './execution_note_cache.js';
 import { ExecutionTaggingIndexCache } from './execution_tagging_index_cache.js';
@@ -131,6 +135,9 @@ export type ContractSimulatorRunOpts = {
 /** Args for ContractFunctionSimulator constructor. */
 export type ContractFunctionSimulatorArgs = {
   contractStore: ContractStore;
+  contractClassService: ContractClassService;
+  /** Per-simulation contract overrides. */
+  overrides?: ContractOverrides;
   noteStore: NoteStore;
   keyStore: KeyStore;
   addressStore: AddressStore;
@@ -154,6 +161,8 @@ export type ContractFunctionSimulatorArgs = {
 export class ContractFunctionSimulator {
   private readonly log: Logger;
   private readonly contractStore: ContractStore;
+  private readonly contractClassService: ContractClassService;
+  private readonly overrides: ContractOverrides | undefined;
   private readonly noteStore: NoteStore;
   private readonly keyStore: KeyStore;
   private readonly addressStore: AddressStore;
@@ -172,6 +181,8 @@ export class ContractFunctionSimulator {
 
   constructor(args: ContractFunctionSimulatorArgs) {
     this.contractStore = args.contractStore;
+    this.contractClassService = args.contractClassService;
+    this.overrides = args.overrides;
     this.noteStore = args.noteStore;
     this.keyStore = args.keyStore;
     this.addressStore = args.addressStore;
@@ -208,10 +219,23 @@ export class ContractFunctionSimulator {
 
     const contractAddress = request.origin;
 
-    const entryPointArtifact = await this.contractStore.getFunctionArtifactWithDebugMetadata(
+    const anchoredContractData = new AnchoredContractData(
+      this.contractStore,
+      this.contractClassService,
+      anchorBlockHeader,
+      this.overrides,
+    );
+
+    const entryPointArtifact = await anchoredContractData.getFunctionArtifactWithDebugMetadata(
       contractAddress,
       request.functionSelector,
     );
+    if (!entryPointArtifact) {
+      throw new Error(
+        `Cannot run function ${request.functionSelector} on ${contractAddress}: the contract is not registered. ` +
+          `Register it via wallet.registerContract(...).`,
+      );
+    }
 
     if (entryPointArtifact.functionType !== FunctionType.PRIVATE) {
       throw new Error(`Cannot run ${entryPointArtifact.functionType} function as private`);
@@ -239,6 +263,7 @@ export class ContractFunctionSimulator {
     const privateExecutionOracle = new PrivateExecutionOracle({
       argsHash: request.firstCallArgsHash,
       txContext: request.txContext,
+      txRequestSalt: request.salt,
       callContext,
       anchorBlockHeader,
       utilityExecutor: async (call, execScopes) => {
@@ -249,7 +274,7 @@ export class ContractFunctionSimulator {
       executionCache: HashedValuesCache.create(request.argsOfCalls),
       noteCache,
       taggingIndexCache,
-      contractStore: this.contractStore,
+      anchoredContractData,
       noteStore: this.noteStore,
       keyStore: this.keyStore,
       addressStore: this.addressStore,
@@ -289,8 +314,7 @@ export class ContractFunctionSimulator {
       );
       const simulatorTeardownTimer = new Timer();
 
-      noteCache.finish();
-      const firstNullifierHint = noteCache.getNonceGenerator();
+      const firstNullifier = noteCache.getNonceGenerator();
 
       const publicCallRequests = collectNested([executionResult], r =>
         r.publicInputs.publicCallRequests
@@ -313,9 +337,9 @@ export class ContractFunctionSimulator {
       }
 
       // Not to be confused with a PrivateCallExecutionResult. This is a superset
-      // of the PrivateCallExecutionResult, containing also firstNullifierHint
+      // of the PrivateCallExecutionResult, containing also firstNullifier
       // and publicFunctionsCalldata.
-      return new PrivateExecutionResult(executionResult, firstNullifierHint, publicFunctionsCalldata);
+      return new PrivateExecutionResult(executionResult, firstNullifier, publicFunctionsCalldata);
     } catch (err) {
       throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
     }
@@ -333,7 +357,20 @@ export class ContractFunctionSimulator {
     scopes: AztecAddress[],
     jobId: string,
   ): Promise<{ result: Fr[]; offchainEffects: OffchainEffect[] }> {
-    const entryPointArtifact = await this.contractStore.getFunctionArtifactWithDebugMetadata(call.to, call.selector);
+    const anchoredContractData = new AnchoredContractData(
+      this.contractStore,
+      this.contractClassService,
+      anchorBlockHeader,
+      this.overrides,
+    );
+
+    const entryPointArtifact = await anchoredContractData.getFunctionArtifactWithDebugMetadata(call.to, call.selector);
+    if (!entryPointArtifact) {
+      throw new Error(
+        `Cannot run function ${call.selector} on ${call.to}: the contract is not registered. ` +
+          `Register it via wallet.registerContract(...).`,
+      );
+    }
 
     if (entryPointArtifact.functionType !== FunctionType.UTILITY) {
       throw new Error(`Cannot run ${entryPointArtifact.functionType} function as utility`);
@@ -353,7 +390,7 @@ export class ContractFunctionSimulator {
       authWitnesses: authwits,
       capsules: [],
       anchorBlockHeader,
-      contractStore: this.contractStore,
+      anchoredContractData,
       noteStore: this.noteStore,
       keyStore: this.keyStore,
       addressStore: this.addressStore,
@@ -618,12 +655,12 @@ export async function generateSimulatedProvingResult(
     siloedNullifiers,
     minRevertibleSideEffectCounter,
   );
+  // The protocol nullifier is the nonce generator and the tx's first nullifier. It is injected by the
+  // init kernel (at counter 1, index 0) rather than emitted by any private call, so it is absent from
+  // the executed nullifiers above. Mirror the kernel here by prepending it as the first non-revertible
+  // nullifier.
   const nonceGenerator = privateExecutionResult.firstNullifier;
-  if (nonRevertibleNullifiers.length === 0) {
-    nonRevertibleNullifiers.push(nonceGenerator);
-  } else if (!nonRevertibleNullifiers[0].equals(nonceGenerator)) {
-    throw new Error('The first non revertible nullifier should be equal to the nonce generator. This is a bug!');
-  }
+  nonRevertibleNullifiers.unshift(nonceGenerator);
 
   if (isPrivateOnlyTx) {
     // We must make the note hashes unique by using the
@@ -886,6 +923,11 @@ function meterGasUsed(data: PrivateToRollupAccumulatedData | PrivateToPublicAccu
   );
   meteredL2Gas += numContractClassLogs * L2_GAS_PER_CONTRACT_CLASS_LOG;
 
+  if (isPrivateOnlyTx) {
+    // The public data write that the private tx base rollup always performs to update the fee payer's balance.
+    meteredDAFields += PUBLIC_DATA_WRITE_LENGTH;
+  }
+
   const meteredDAGas = meteredDAFields * DA_GAS_PER_FIELD;
 
   if ((data as PrivateToPublicAccumulatedData).publicCallRequests) {

package/src/contract_function_simulator/execution_note_cache.ts

@@ -43,12 +43,6 @@ export class ExecutionNoteCache {
 
   private inRevertiblePhase = false;
 
-  /**
-   * 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: boolean | undefined;
-
   constructor(private readonly protocolNullifier: Fr) {}
 
   /**
@@ -64,12 +58,9 @@ export class ExecutionNoteCache {
     this.inRevertiblePhase = true;
     this.minRevertibleSideEffectCounter = minRevertibleSideEffectCounter;
 
-    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 protocol nullifier is always the tx's first nullifier (injected by the kernel init), so it is the
+    // nonce generator for every note hash.
+    const nonceGenerator = this.protocolNullifier;
 
     // The existing pending notes are all non-revertible.
     // They cannot be squashed by nullifiers emitted after minRevertibleSideEffectCounter is set.
@@ -102,14 +93,6 @@ export class ExecutionNoteCache {
     return sideEffectCounter >= this.minRevertibleSideEffectCounter;
   }
 
-  public finish() {
-    // 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.getEmittedNullifiers().length === 0;
-    }
-  }
-
   /**
    * Add a new note to cache.
    * @param note - New note created during execution.
@@ -223,19 +206,15 @@ export class ExecutionNoteCache {
   }
 
   /**
-   * @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.
+   * @returns All nullifiers of the transaction: the protocol nullifier (the kernel-injected first nullifier),
+   * followed by those emitted by private calls.
    */
   getAllNullifiers(): Fr[] {
-    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];
+    return [this.protocolNullifier, ...this.getEmittedNullifiers()];
   }
 
   getNonceGenerator(): Fr {
-    return this.getAllNullifiers()[0];
+    return this.protocolNullifier;
   }
 
   #recordNullifier(contractAddress: AztecAddress, siloedNullifier: bigint) {