@aztec/pxe 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/dest/contract_function_simulator/oracle/private_execution_oracle.js

@@ -1,32 +1,25 @@
 import { MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS, PRIVATE_CONTEXT_INPUTS_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { toACVMWitness } from '@aztec/simulator/client';
 import { FunctionSelector, countArgumentsSize } from '@aztec/stdlib/abi';
-import { computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
+import { siloNullifier } from '@aztec/stdlib/hash';
 import { PrivateContextInputs } from '@aztec/stdlib/kernel';
+import { AppTaggingSecret, AppTaggingSecretKind, ContractClassLog, ContractClassLogFields } from '@aztec/stdlib/logs';
 import { Note } from '@aztec/stdlib/note';
 import { CallContext, CountedContractClassLog, NoteAndSlot } from '@aztec/stdlib/tx';
-import { Tag } from '../../tagging/tag.js';
+import { NoteService } from '../../notes/note_service.js';
+import { syncSenderTaggingIndexes } from '../../tagging/index.js';
+import { BoundedVec } from '../noir-structs/bounded_vec.js';
+import { Option } from '../noir-structs/option.js';
 import { pickNotes } from '../pick_notes.js';
-import { executePrivateFunction, verifyCurrentClassId } from './private_execution.js';
+import { executePrivateFunction } from './private_execution.js';
 import { UtilityExecutionOracle } from './utility_execution_oracle.js';
 /**
  * The execution oracle for the private part of a transaction.
  */ export class PrivateExecutionOracle extends UtilityExecutionOracle {
-    argsHash;
-    txContext;
-    callContext;
-    anchorBlockHeader;
-    executionCache;
-    noteCache;
-    taggingIndexCache;
-    totalPublicCalldataCount;
-    sideEffectCounter;
-    senderForTags;
-    simulator;
-    isPrivate;
+    isPrivate = true;
     /**
    * New notes created during this execution.
    * It's possible that a note in this list has been nullified (in the same or other executions) and doesn't exist in
@@ -34,25 +27,38 @@ import { UtilityExecutionOracle } from './utility_execution_oracle.js';
    * their commitments are still in the public inputs of this execution.
    * This information is only for references (currently used for tests), and is not used for any sort of constrains.
    * Users can also use this to get a clearer idea of what's happened during a simulation.
-   */ newNotes;
-    /**
-   * 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.
-   */ noteHashLeafIndexMap;
-    noteHashNullifierCounterMap;
-    contractClassLogs;
-    offchainEffects;
-    nestedExecutionResults;
-    constructor(argsHash, txContext, callContext, /** Header of a block whose state is used during private execution (not the block the transaction is included in). */ anchorBlockHeader, /** List of transient auth witnesses to be used during this simulation */ authWitnesses, capsules, executionCache, noteCache, taggingIndexCache, executionDataProvider, totalPublicCalldataCount = 0, sideEffectCounter = 0, log = createLogger('simulator:client_execution_context'), scopes, senderForTags, simulator){
-        super(callContext.contractAddress, authWitnesses, capsules, executionDataProvider, log, scopes), this.argsHash = argsHash, this.txContext = txContext, this.callContext = callContext, this.anchorBlockHeader = anchorBlockHeader, this.executionCache = executionCache, this.noteCache = noteCache, this.taggingIndexCache = taggingIndexCache, this.totalPublicCalldataCount = totalPublicCalldataCount, this.sideEffectCounter = sideEffectCounter, this.senderForTags = senderForTags, this.simulator = simulator, this.isPrivate = true, this.newNotes = [], this.noteHashLeafIndexMap = new Map(), this.noteHashNullifierCounterMap = new Map(), this.contractClassLogs = [], this.offchainEffects = [], this.nestedExecutionResults = [];
+   */ newNotes = [];
+    noteHashNullifierCounterMap = new Map();
+    contractClassLogs = [];
+    nestedExecutionResults = [];
+    argsHash;
+    txContext;
+    txRequestSalt;
+    executionCache;
+    noteCache;
+    taggingIndexCache;
+    senderTaggingStore;
+    totalPublicCalldataCount;
+    initialSideEffectCounter;
+    /** Sender for tags passed in at oracle construction time. Returned by `getSenderForTags`. */ defaultSenderForTags;
+    constructor(args){
+        super({
+            ...args,
+            log: args.log ?? createLogger('simulator:client_execution_context')
+        });
+        this.argsHash = args.argsHash;
+        this.txContext = args.txContext;
+        this.txRequestSalt = args.txRequestSalt;
+        this.executionCache = args.executionCache;
+        this.noteCache = args.noteCache;
+        this.taggingIndexCache = args.taggingIndexCache;
+        this.senderTaggingStore = args.senderTaggingStore;
+        this.totalPublicCalldataCount = args.totalPublicCalldataCount ?? 0;
+        this.initialSideEffectCounter = args.sideEffectCounter ?? 0;
+        this.defaultSenderForTags = args.senderForTags;
     }
     getPrivateContextInputs() {
-        return new PrivateContextInputs(this.callContext, this.anchorBlockHeader, this.txContext, this.sideEffectCounter);
+        return new PrivateContextInputs(this.callContext, this.anchorBlockHeader, this.txContext, this.initialSideEffectCounter, this.txRequestSalt);
     }
     // We still need this function until we can get user-defined ordering of structs for fn arguments
     // TODO When that is sorted out on noir side, we can use instead the utilities in serialize.ts
@@ -77,12 +83,6 @@ import { UtilityExecutionOracle } from './utility_execution_oracle.js';
         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.
-   */ getNoteHashLeafIndexMap() {
-        return this.noteHashLeafIndexMap;
-    }
-    /**
    * Get the data for the newly created notes.
    */ getNewNotes() {
         return this.newNotes;
@@ -96,14 +96,9 @@ import { UtilityExecutionOracle } from './utility_execution_oracle.js';
         return this.contractClassLogs;
     }
     /**
-   * Return the offchain effects emitted during this execution.
-   */ getOffchainEffects() {
-        return this.offchainEffects;
-    }
-    /**
-   * Returns the pre tags that were used in this execution (and that need to be stored in the db).
-   */ getUsedPreTags() {
-        return this.taggingIndexCache.getUsedPreTags();
+   * Returns the tagging index ranges that were used in this execution (and that need to be stored in the db).
+   */ getUsedTaggingIndexRanges() {
+        return this.taggingIndexCache.getUsedTaggingIndexRanges();
     }
     /**
    * Return the nested execution results during this execution.
@@ -117,39 +112,154 @@ import { UtilityExecutionOracle } from './utility_execution_oracle.js';
    * for a tag in order to emit a log. Constrained tagging should not use this as there is no
    * guarantee that the recipient knows about the sender, and hence about the shared secret.
    *
-   * The value persists through nested calls, meaning all calls down the stack will use the same
-   * 'senderForTags' value (unless it is replaced).
-   */ privateGetSenderForTags() {
-        return Promise.resolve(this.senderForTags);
+   * Returns the wallet-supplied default sender for tags, or `None` if no default was provided.
+   */ getSenderForTags() {
+        return Promise.resolve(this.defaultSenderForTags ? Option.some(this.defaultSenderForTags) : Option.none());
     }
     /**
-   * Set the sender for tags.
-   *
-   * This unconstrained value is used as the sender when computing an unconstrained shared secret
-   * for a tag in order to emit a log. Constrained tagging should not use this as there is no
-   * guarantee that the recipient knows about the sender, and hence about the shared secret.
-   *
-   * Account contracts typically set this value before calling other contracts. The value persists
-   * through nested calls, meaning all calls down the stack will use the same 'senderForTags'
-   * value (unless it is replaced by another call to this setter).
-   */ privateSetSenderForTags(senderForTags) {
-        this.senderForTags = senderForTags;
-        return Promise.resolve();
+   * Resolves a custom, caller-defined request via the {@link ResolveCustomRequest} hook, which produces the response
+   * however it needs to. Throws when no hook is configured, since the request cannot be served.
+   */ async resolveCustomRequest(kind, payload) {
+        const hook = this.hooks?.resolveCustomRequest;
+        if (!hook) {
+            throw new Error('Cannot serve a request: no resolveCustomRequest hook is configured');
+        }
+        const contractClassId = await this.#getCurrentContractClassId(this.contractAddress);
+        return hook({
+            contractAddress: this.contractAddress,
+            contractClassId,
+            kind,
+            payload
+        });
+    }
+    /**
+   * Resolves the tagging strategy for a message via the wallet's {@link ResolveTaggingSecretStrategy} hook. The contract receives a ready-to-use {@link ResolvedTaggingStrategy}.
+   * When no hook is configured, applies a default: a non-interactive handshake, except for an unconstrained self-send,
+   * which uses an address-derived secret.
+   */ async resolveTaggingStrategy(sender, recipient, deliveryMode) {
+        const [isUnconstrainedSelfSend, chosenStrategy] = await Promise.all([
+            this.#isUnconstrainedSelfSend(recipient, deliveryMode),
+            this.#chooseTaggingSecretStrategy(sender, recipient, deliveryMode)
+        ]);
+        // For unconstrained delivery, a self-send uses a local address-derived secret instead of a non-interactive
+        // handshake. A self-send is one where the wallet controls the recipient's keys, so both sides' keys are local: no
+        // handshake is needed and nothing is revealed onchain. It also avoids a recursion: a handshake self-delivers its
+        // note via unconstrained delivery, which would establish yet another handshake. This guard runs regardless of the
+        // resolved strategy (hook or default), to protect wallets from invalid configuration.
+        const strategy = isUnconstrainedSelfSend ? {
+            type: 'address-derived'
+        } : chosenStrategy;
+        return this.#resolveTaggingSecretStrategy(strategy, sender, recipient);
+    }
+    async #chooseTaggingSecretStrategy(sender, recipient, deliveryMode) {
+        const hook = this.hooks?.resolveTaggingSecretStrategy;
+        if (!hook) {
+            // With no hook, both delivery modes default to a non-interactive handshake
+            return {
+                type: 'non-interactive-handshake'
+            };
+        }
+        const contractClassId = await this.#getCurrentContractClassId(this.contractAddress);
+        return hook({
+            contractAddress: this.contractAddress,
+            contractClassId,
+            sender,
+            recipient,
+            deliveryMode
+        });
     }
     /**
-   * Returns the next app tag for a given sender and recipient pair.
+   * Resolves the class id the given contract runs at this simulation's anchor block. The instance no longer carries
+   * its class id (it is chain-derived), so it is resolved via the anchored contract data instead.
+   */ async #getCurrentContractClassId(address) {
+        const classId = await this.anchoredContractData.getCurrentClassId(address);
+        if (classId === undefined) {
+            throw new Error(`Cannot resolve the current contract class for ${address}`);
+        }
+        return classId;
+    }
+    /** Whether this is an unconstrained delivery to one of the wallet's own accounts (a self-send). */ #isUnconstrainedSelfSend(recipient, deliveryMode) {
+        return deliveryMode === AppTaggingSecretKind.UNCONSTRAINED ? this.keyStore.hasAccount(recipient) : Promise.resolve(false);
+    }
+    /** Resolves a wallet-provided {@link TaggingSecretStrategy} into the app-siloed secret handed to the contract. */ async #resolveTaggingSecretStrategy(strategy, sender, recipient) {
+        // PXE only performs the derivation; it does not reject a strategy that is unsound for the delivery mode (e.g. an
+        // address-derived or arbitrary-secret strategy for constrained delivery). That soundness check belongs in the
+        // Noir circuit, which constrains the resolved strategy against the delivery mode.
+        switch(strategy.type){
+            case 'non-interactive-handshake':
+                return {
+                    type: 'non-interactive-handshake'
+                };
+            case 'interactive-handshake':
+                return {
+                    type: 'interactive-handshake'
+                };
+            case 'address-derived':
+                return this.#addressDerivedSecret(sender, recipient);
+            case 'arbitrary-secret':
+                {
+                    // App-silo the raw arbitrary secret point here so wallets never replicate the derivation.
+                    const appTaggingSecret = await AppTaggingSecret.computeDirectional(strategy.secret, this.contractAddress, recipient);
+                    return {
+                        type: 'unconstrained-secret',
+                        secret: appTaggingSecret.secret
+                    };
+                }
+        }
+    }
+    /**
+   * The app-siloed, recipient-directional secret derived from the sender's and recipient's address keys via ECDH,
+   * ready to hand to the contract. Callers must validate the recipient in-circuit before reaching here, so an invalid one is unexpected.
+   */ async #addressDerivedSecret(sender, recipient) {
+        const secret = await this.getAppTaggingSecret(sender, recipient);
+        if (!secret.isSome()) {
+            throw new Error(`Cannot derive an address-derived tagging secret for invalid recipient ${recipient}`);
+        }
+        return {
+            type: 'unconstrained-secret',
+            secret: secret.value
+        };
+    }
+    /**
+   * Returns the sender-side app tagging secret for a `(sender, recipient)` pair.
+   *
+   * The caller obtains an index via {@link getNextTaggingIndex} and computes the final tag itself.
+   * The only expected `None` case is an invalid recipient address; missing sender data fails while deriving.
+   *
    * @param sender - The address sending the log
    * @param recipient - The address receiving the log
-   * @returns An app tag to be used in a log.
-   */ async privateGetNextAppTagAsSender(sender, recipient) {
-        const secret = await this.executionDataProvider.calculateDirectionalAppTaggingSecret(this.contractAddress, sender, recipient);
+   * @returns The app tagging secret, or `None` if the recipient is invalid.
+   */ async getAppTaggingSecret(sender, recipient) {
+        const extendedSecret = await this.#calculateAppTaggingSecret(this.contractAddress, sender, recipient);
+        if (!extendedSecret) {
+            this.logger.warn(`Computing a tagging secret for invalid recipient ${recipient} - returning no secret`, {
+                contractAddress: this.contractAddress
+            });
+            return Option.none();
+        }
+        return Option.some(extendedSecret.secret);
+    }
+    /**
+   * Returns the next sender-side tagging index for a given secret and delivery mode.
+   *
+   * @param secret - The tagging secret to allocate an index for.
+   * @param kind - The sender-side index namespace.
+   * @returns The next index to use for this secret.
+   */ async getNextTaggingIndex(secret, kind) {
+        const appTaggingSecret = new AppTaggingSecret(secret, this.contractAddress, kind);
+        const index = await this.#reserveNextIndexForSecret(appTaggingSecret);
+        this.logger.debug(`Incrementing ${kind} tagging index for secret in contract ${this.contractAddress} to ${index}`);
+        return index;
+    }
+    /** Resolves the next index for a given tagging secret, syncing from chain if it is missing from the in-tx cache. */ async #reserveNextIndexForSecret(secret) {
         const index = await this.#getIndexToUseForSecret(secret);
-        this.log.debug(`Incrementing tagging index for sender: ${sender}, recipient: ${recipient}, contract: ${this.contractAddress} to ${index}`);
         this.taggingIndexCache.setLastUsedIndex(secret, index);
-        return Tag.compute({
-            secret,
-            index
-        });
+        return index;
+    }
+    async #calculateAppTaggingSecret(contractAddress, sender, recipient) {
+        const senderCompleteAddress = await this.getCompleteAddressOrFail(sender);
+        const senderIvsk = await this.keyStore.getMasterIncomingViewingSecretKey(sender);
+        return AppTaggingSecret.computeViaEcdh(senderCompleteAddress, senderIvsk, recipient, contractAddress, recipient);
     }
     async #getIndexToUseForSecret(secret) {
         // If we have the tagging index in the cache, we use it. If not we obtain it from the execution data provider.
@@ -160,8 +270,8 @@ import { UtilityExecutionOracle } from './utility_execution_oracle.js';
             // 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 this.executionDataProvider.syncTaggedLogsAsSender(secret, this.contractAddress);
-            const lastUsedIndex = await this.executionDataProvider.getLastUsedIndexAsSender(secret);
+            await syncSenderTaggingIndexes(secret, this.aztecNode, this.senderTaggingStore, await this.anchorBlockHeader.hash(), this.jobId);
+            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;
@@ -171,29 +281,29 @@ import { UtilityExecutionOracle } from './utility_execution_oracle.js';
    * Store values in the execution cache.
    * @param values - Values to store.
    * @returns The hash of the values.
-   */ privateStoreInExecutionCache(values, hash) {
+   */ setHashPreimage(values, hash) {
         return this.executionCache.store(values, hash);
     }
     /**
    * Gets values from the execution cache.
    * @param hash - Hash of the values.
    * @returns The values.
-   */ privateLoadFromExecutionCache(hash) {
+   */ getHashPreimage(hash) {
         const preimage = this.executionCache.getPreimage(hash);
         if (!preimage) {
             throw new Error(`Preimage for hash ${hash.toString()} not found in cache`);
         }
         return Promise.resolve(preimage);
     }
-    async utilityCheckNullifierExists(innerNullifier) {
+    async doesNullifierExist(innerNullifier) {
         // This oracle must be overridden because while utility execution can only meaningfully check if a nullifier exists
         // in the synched block, during private execution there's also the possibility of it being pending, i.e. created
         // in the current transaction.
-        this.log.debug(`Checking existence of inner nullifier ${innerNullifier}`, {
+        this.logger.debug(`Checking existence of inner nullifier ${innerNullifier}`, {
             contractAddress: this.contractAddress
         });
         const nullifier = (await siloNullifier(this.contractAddress, innerNullifier)).toBigInt();
-        return this.noteCache.getNullifiers(this.contractAddress).has(nullifier) || await super.utilityCheckNullifierExists(innerNullifier);
+        return this.noteCache.getNullifiers(this.contractAddress).has(nullifier) || await super.doesNullifierExist(innerNullifier);
     }
     /**
    * Gets some notes for a storage slot.
@@ -203,6 +313,7 @@ import { UtilityExecutionOracle } from './utility_execution_oracle.js';
    * 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. If undefined, returns notes for all owners.
    * @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.
@@ -214,11 +325,12 @@ import { UtilityExecutionOracle } from './utility_execution_oracle.js';
    * @param offset - The starting index for pagination.
    * @param status - The status of notes to fetch.
    * @returns Array of note data.
-   */ async utilityGetNotes(storageSlot, numSelects, selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, limit, offset, status) {
+   */ async getNotes(owner, storageSlot, numSelects, selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, limit, offset, status, maxNotes, packedHintedNoteLength) {
         // 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.value, storageSlot);
         const pendingNullifiers = this.noteCache.getNullifiers(this.callContext.contractAddress);
-        const dbNotes = await this.executionDataProvider.getNotes(this.callContext.contractAddress, storageSlot, status, this.scopes);
+        const noteService = new NoteService(this.noteStore, this.aztecNode, this.anchorBlockHeader, this.jobId);
+        const dbNotes = await noteService.getNotes(this.callContext.contractAddress, owner.value, storageSlot, status, this.scopes);
         const dbNotesFiltered = dbNotes.filter((n)=>!pendingNullifiers.has(n.siloedNullifier.value));
         const notes = pickNotes([
             ...dbNotesFiltered,
@@ -244,55 +356,56 @@ import { UtilityExecutionOracle } from './utility_execution_oracle.js';
             limit,
             offset
         });
-        this.log.debug(`Returning ${notes.length} notes for ${this.callContext.contractAddress} at ${storageSlot}: ${notes.map((n)=>`${n.noteNonce.toString()}:[${n.note.items.map((i)=>i.toString()).join(',')}]`).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);
+        this.logger.debug(`Returning ${notes.length} notes for ${this.callContext.contractAddress} at ${storageSlot}: ${notes.map((n)=>`${n.noteNonce.toString()}:[${n.note.items.map((i)=>i.toString()).join(',')}]`).join(', ')}`);
+        return BoundedVec.from({
+            data: notes,
+            maxLength: maxNotes,
+            elementSize: packedHintedNoteLength
         });
-        return notes;
     }
     /**
    * 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.
    * @param noteItems - The items to be included in a Note.
    * @param noteHash - A hash of the new note.
    * @returns
-   */ privateNotifyCreatedNote(storageSlot, noteTypeId, noteItems, noteHash, counter) {
-        this.log.debug(`Notified of new note with inner hash ${noteHash}`, {
+   */ notifyCreatedNote(owner, storageSlot, randomness, noteTypeId, noteItems, noteHash, counter) {
+        this.logger.debug(`Notified of new note with inner hash ${noteHash}`, {
             contractAddress: this.callContext.contractAddress,
             storageSlot,
+            randomness,
             noteTypeId,
             counter
         });
         const note = new Note(noteItems);
         this.noteCache.addNewNote({
             contractAddress: this.callContext.contractAddress,
+            owner,
             storageSlot,
+            randomness,
             noteNonce: Fr.ZERO,
             note,
             siloedNullifier: undefined,
-            noteHash
+            noteHash,
+            isPending: true
         }, counter);
-        this.newNotes.push(new NoteAndSlot(note, storageSlot, noteTypeId));
+        this.newNotes.push(NoteAndSlot.from({
+            note,
+            storageSlot,
+            randomness,
+            noteTypeId
+        }));
     }
     /**
    * Adding a siloed nullifier into the current set of all pending nullifiers created
    * within the current transaction/execution.
    * @param innerNullifier - The pending nullifier to add in the list (not yet siloed by contract address).
    * @param noteHash - A hash of the new note.
-   */ async privateNotifyNullifiedNote(innerNullifier, noteHash, counter) {
+   */ async notifyNullifiedNote(innerNullifier, noteHash, counter) {
         const nullifiedNoteHashCounter = await this.noteCache.nullifyNote(this.callContext.contractAddress, innerNullifier, noteHash);
         if (nullifiedNoteHashCounter !== undefined) {
             this.noteHashNullifierCounterMap.set(nullifiedNoteHashCounter, counter);
@@ -303,22 +416,38 @@ import { UtilityExecutionOracle } from './utility_execution_oracle.js';
    * within the current transaction/execution.
    * @param innerNullifier - The pending nullifier to add in the list (not yet siloed by contract address).
    * @param noteHash - A hash of the new note.
-   */ privateNotifyCreatedNullifier(innerNullifier) {
-        this.log.debug(`Notified of new inner nullifier ${innerNullifier}`, {
+   */ notifyCreatedNullifier(innerNullifier) {
+        this.logger.debug(`Notified of new inner nullifier ${innerNullifier}`, {
             contractAddress: this.contractAddress
         });
         return this.noteCache.nullifierCreated(this.callContext.contractAddress, innerNullifier);
     }
     /**
+   * Check if a nullifier has been emitted in the same transaction, i.e. if notifyCreatedNullifier has been
+   * called for this inner nullifier from the contract with the specified address.
+   * @param innerNullifier - The inner nullifier to check.
+   * @param contractAddress - Address of the contract that emitted the nullifier.
+   * @returns A boolean indicating whether the nullifier is pending or not.
+   */ async isNullifierPending(innerNullifier, contractAddress) {
+        const siloedNullifier = await siloNullifier(contractAddress, innerNullifier);
+        const isNullifierPending = this.noteCache.getNullifiers(contractAddress).has(siloedNullifier.toBigInt());
+        return Promise.resolve(isNullifierPending);
+    }
+    /**
    * Emit a contract class log.
    * This fn exists because we only carry a poseidon hash through the kernels, and need to
    * keep the preimage in ts for later.
-   * @param log - The contract class log to be emitted.
+   * @param logData - The contract class log to be emitted.
    * @param counter - The contract class log's counter.
-   */ privateNotifyCreatedContractClassLog(log, counter) {
+   */ notifyCreatedContractClassLog(logData, counter) {
+        const log = ContractClassLog.from({
+            contractAddress: logData.contractAddress,
+            fields: new ContractClassLogFields(logData.fields),
+            emittedLength: logData.emittedLength
+        });
         this.contractClassLogs.push(new CountedContractClassLog(log, counter));
         const text = log.toBuffer().toString('hex');
-        this.log.verbose(`Emitted log from ContractClassRegistry: "${text.length > 100 ? text.slice(0, 100) + '...' : text}"`);
+        this.logger.verbose(`Emitted log from ContractClassRegistry: "${text.length > 100 ? text.slice(0, 100) + '...' : text}"`);
     }
     #checkValidStaticCall(childExecutionResult) {
         if (childExecutionResult.publicInputs.noteHashes.claimedLength > 0 || childExecutionResult.publicInputs.nullifiers.claimedLength > 0 || childExecutionResult.publicInputs.l2ToL1Msgs.claimedLength > 0 || childExecutionResult.publicInputs.privateLogs.claimedLength > 0 || childExecutionResult.publicInputs.contractClassLogsHashes.claimedLength > 0) {
@@ -333,22 +462,62 @@ import { UtilityExecutionOracle } from './utility_execution_oracle.js';
    * @param sideEffectCounter - The side effect counter at the start of the call.
    * @param isStaticCall - Whether the call is a static call.
    * @returns The execution result.
-   */ async privateCallPrivateFunction(targetContractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall) {
+   */ async callPrivateFunction(targetContractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall) {
         if (!this.simulator) {
             // In practice it is only when creating inline private contexts in a Noir test using TXE that we create an
             // instance of this class without a simulator.
             throw new Error('No simulator provided, cannot perform a nested private call');
         }
         const simulatorSetupTimer = new Timer();
-        this.log.debug(`Calling private function ${targetContractAddress}:${functionSelector} from ${this.callContext.contractAddress}`);
+        this.logger.debug(`Calling private function ${targetContractAddress}:${functionSelector} from ${this.callContext.contractAddress}`);
         isStaticCall = isStaticCall || this.callContext.isStaticCall;
-        await verifyCurrentClassId(targetContractAddress, this.executionDataProvider, this.anchorBlockHeader);
-        const targetArtifact = await this.executionDataProvider.getFunctionArtifact(targetContractAddress, functionSelector);
+        await this.contractSyncService.ensureContractSynced(targetContractAddress, functionSelector, this.utilityExecutor, this.anchorBlockHeader, this.jobId, this.scopes);
+        const targetArtifact = await this.anchoredContractData.getFunctionArtifactWithDebugMetadata(targetContractAddress, functionSelector);
+        if (!targetArtifact) {
+            throw new Error(`Cannot call ${targetContractAddress}:${functionSelector}: the contract is not registered. ` + `Register it via wallet.registerContract(...).`);
+        }
         const derivedTxContext = this.txContext.clone();
         const derivedCallContext = await this.deriveCallContext(targetContractAddress, targetArtifact, isStaticCall);
-        const privateExecutionOracle = new PrivateExecutionOracle(argsHash, derivedTxContext, derivedCallContext, this.anchorBlockHeader, this.authWitnesses, this.capsules, this.executionCache, this.noteCache, this.taggingIndexCache, this.executionDataProvider, this.totalPublicCalldataCount, sideEffectCounter, this.log, this.scopes, this.senderForTags, this.simulator);
+        const privateExecutionOracle = new PrivateExecutionOracle({
+            argsHash,
+            txContext: derivedTxContext,
+            txRequestSalt: this.txRequestSalt,
+            callContext: derivedCallContext,
+            anchorBlockHeader: this.anchorBlockHeader,
+            utilityExecutor: this.utilityExecutor,
+            authWitnesses: this.authWitnesses,
+            capsules: this.capsules,
+            executionCache: this.executionCache,
+            noteCache: this.noteCache,
+            taggingIndexCache: this.taggingIndexCache,
+            anchoredContractData: this.anchoredContractData,
+            noteStore: this.noteStore,
+            keyStore: this.keyStore,
+            addressStore: this.addressStore,
+            aztecNode: this.aztecNode,
+            senderTaggingStore: this.senderTaggingStore,
+            recipientTaggingStore: this.recipientTaggingStore,
+            taggingSecretSourcesStore: this.taggingSecretSourcesStore,
+            capsuleService: this.capsuleService,
+            factService: this.factService,
+            privateEventStore: this.privateEventStore,
+            txResolver: this.txResolver,
+            contractSyncService: this.contractSyncService,
+            jobId: this.jobId,
+            totalPublicCalldataCount: this.totalPublicCalldataCount,
+            sideEffectCounter,
+            log: this.logger,
+            scopes: this.scopes,
+            senderForTags: this.defaultSenderForTags,
+            simulator: this.simulator,
+            hooks: this.hooks,
+            l2TipsStore: this.l2TipsStore,
+            transientArrayService: this.transientArrayService
+        });
         const setupTime = simulatorSetupTimer.ms();
         const childExecutionResult = await executePrivateFunction(this.simulator, privateExecutionOracle, targetArtifact, targetContractAddress, functionSelector);
+        // Propagate the nested call's calldata count so the parent sees its increments on subsequent enqueues.
+        this.totalPublicCalldataCount = privateExecutionOracle.getTotalPublicCalldataCount();
         if (isStaticCall) {
             this.#checkValidStaticCall(childExecutionResult);
         }
@@ -363,7 +532,7 @@ import { UtilityExecutionOracle } from './utility_execution_oracle.js';
             returnsHash: publicInputs.returnsHash
         };
     }
-    #onNewPublicFunctionCall(calldataHash) {
+    /** Validates the calldata preimage exists in the cache and checks cumulative calldata size is within limits. */ assertValidPublicCalldata(calldataHash) {
         const calldata = this.executionCache.getPreimage(calldataHash);
         if (!calldata) {
             throw new Error('Calldata for public call not found in cache');
@@ -372,30 +541,17 @@ import { UtilityExecutionOracle } from './utility_execution_oracle.js';
         if (this.totalPublicCalldataCount > MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS) {
             throw new Error(`Too many total args to all enqueued public calls! (> ${MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS})`);
         }
-    }
-    /**
-   * Verify relevant information when a public function is enqueued.
-   * @param targetContractAddress - The address of the contract to call.
-   * @param calldataHash - The hash of the function selector and arguments.
-   * @param sideEffectCounter - The side effect counter at the start of the call.
-   * @param isStaticCall - Whether the call is a static call.
-   */ privateNotifyEnqueuedPublicFunctionCall(_targetContractAddress, calldataHash, _sideEffectCounter, _isStaticCall) {
-        this.#onNewPublicFunctionCall(calldataHash);
         return Promise.resolve();
     }
-    /**
-   * Verify relevant information when a public teardown function is set.
-   * @param targetContractAddress - The address of the contract to call.
-   * @param argsHash - The arguments hash to pass to the function.
-   * @param sideEffectCounter - The side effect counter at the start of the call.
-   * @param isStaticCall - Whether the call is a static call.
-   */ privateNotifySetPublicTeardownFunctionCall(_targetContractAddress, calldataHash, _sideEffectCounter, _isStaticCall) {
-        this.#onNewPublicFunctionCall(calldataHash);
-        return Promise.resolve();
+    getTotalPublicCalldataCount() {
+        return this.totalPublicCalldataCount;
     }
-    privateNotifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter) {
+    notifyRevertiblePhaseStart(minRevertibleSideEffectCounter) {
         return this.noteCache.setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter);
     }
+    isExecutionInRevertiblePhase(sideEffectCounter) {
+        return Promise.resolve(this.noteCache.isSideEffectCounterRevertible(sideEffectCounter));
+    }
     /**
    * Derives the call context for a nested execution.
    * @param targetContractAddress - The address of the contract being called.
@@ -406,12 +562,9 @@ import { UtilityExecutionOracle } from './utility_execution_oracle.js';
         return new CallContext(this.contractAddress, targetContractAddress, await FunctionSelector.fromNameAndParameters(targetArtifact.name, targetArtifact.parameters), isStaticCall);
     }
     getDebugFunctionName() {
-        return this.executionDataProvider.getDebugFunctionName(this.contractAddress, this.callContext.functionSelector);
+        return this.anchoredContractData.getDebugFunctionName(this.contractAddress, this.callContext.functionSelector);
     }
-    utilityEmitOffchainEffect(data) {
-        this.offchainEffects.push({
-            data
-        });
-        return Promise.resolve();
+    get callerContext() {
+        return this.callContext.isStaticCall ? 'private view' : 'private';
     }
 }