@aztec/pxe 0.0.0-test.1 → 0.0.1-commit.b655e406

package/dest/contract_function_simulator/oracle/private_execution_oracle.d.ts

@@ -0,0 +1,236 @@
+import { Fr } from '@aztec/foundation/fields';
+import { type CircuitSimulator } from '@aztec/simulator/client';
+import { type FunctionAbi, FunctionSelector, type NoteSelector } from '@aztec/stdlib/abi';
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { PrivateContextInputs } from '@aztec/stdlib/kernel';
+import type { ContractClassLog, PreTag } from '@aztec/stdlib/logs';
+import { type NoteStatus } from '@aztec/stdlib/note';
+import { type BlockHeader, CallContext, Capsule, CountedContractClassLog, NoteAndSlot, PrivateCallExecutionResult, type TxContext } from '@aztec/stdlib/tx';
+import { Tag } from '../../tagging/tag.js';
+import type { ExecutionDataProvider } from '../execution_data_provider.js';
+import type { ExecutionNoteCache } from '../execution_note_cache.js';
+import { ExecutionTaggingIndexCache } from '../execution_tagging_index_cache.js';
+import type { HashedValuesCache } from '../hashed_values_cache.js';
+import type { IPrivateExecutionOracle, NoteData } from './interfaces.js';
+import { UtilityExecutionOracle } from './utility_execution_oracle.js';
+/**
+ * The execution oracle for the private part of a transaction.
+ */
+export declare class PrivateExecutionOracle extends UtilityExecutionOracle implements IPrivateExecutionOracle {
+    #private;
+    private readonly argsHash;
+    private readonly txContext;
+    private readonly callContext;
+    /** Header of a block whose state is used during private execution (not the block the transaction is included in). */
+    protected readonly anchorBlockHeader: BlockHeader;
+    private readonly executionCache;
+    private readonly noteCache;
+    private readonly taggingIndexCache;
+    private totalPublicCalldataCount;
+    protected sideEffectCounter: number;
+    private senderForTags?;
+    private simulator?;
+    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
+     * the ExecutionNoteCache and the final proof data. But we still include those notes in the execution result because
+     * 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.
+     */
+    private 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.
+     */
+    private noteHashLeafIndexMap;
+    private noteHashNullifierCounterMap;
+    private contractClassLogs;
+    private offchainEffects;
+    private nestedExecutionResults;
+    constructor(argsHash: Fr, txContext: TxContext, callContext: CallContext, 
+    /** Header of a block whose state is used during private execution (not the block the transaction is included in). */
+    anchorBlockHeader: BlockHeader, 
+    /** List of transient auth witnesses to be used during this simulation */
+    authWitnesses: AuthWitness[], capsules: Capsule[], executionCache: HashedValuesCache, noteCache: ExecutionNoteCache, taggingIndexCache: ExecutionTaggingIndexCache, executionDataProvider: ExecutionDataProvider, totalPublicCalldataCount?: number, sideEffectCounter?: number, log?: import("@aztec/foundation/log").Logger, scopes?: AztecAddress[], senderForTags?: AztecAddress | undefined, simulator?: CircuitSimulator | undefined);
+    getPrivateContextInputs(): PrivateContextInputs;
+    /**
+     * Writes the function inputs to the initial witness.
+     * @param abi - The function ABI.
+     * @returns The initial witness.
+     */
+    getInitialWitness(abi: FunctionAbi): Map<number, string>;
+    /**
+     * 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(): Map<bigint, bigint>;
+    /**
+     * Get the data for the newly created notes.
+     */
+    getNewNotes(): NoteAndSlot[];
+    getNoteHashNullifierCounterMap(): Map<number, number>;
+    /**
+     * Return the contract class logs emitted during this execution.
+     */
+    getContractClassLogs(): CountedContractClassLog[];
+    /**
+     * Return the offchain effects emitted during this execution.
+     */
+    getOffchainEffects(): {
+        data: Fr[];
+    }[];
+    /**
+     * Returns the pre tags that were used in this execution (and that need to be stored in the db).
+     */
+    getUsedPreTags(): PreTag[];
+    /**
+     * Return the nested execution results during this execution.
+     */
+    getNestedExecutionResults(): PrivateCallExecutionResult[];
+    /**
+     * Get 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.
+     *
+     * The value persists through nested calls, meaning all calls down the stack will use the same
+     * 'senderForTags' value (unless it is replaced).
+     */
+    privateGetSenderForTags(): Promise<AztecAddress | undefined>;
+    /**
+     * 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: AztecAddress): Promise<void>;
+    /**
+     * Returns the next app tag for a given sender and recipient pair.
+     * @param sender - The address sending the log
+     * @param recipient - The address receiving the log
+     * @returns An app tag to be used in a log.
+     */
+    privateGetNextAppTagAsSender(sender: AztecAddress, recipient: AztecAddress): Promise<Tag>;
+    /**
+     * Store values in the execution cache.
+     * @param values - Values to store.
+     * @returns The hash of the values.
+     */
+    privateStoreInExecutionCache(values: Fr[], hash: Fr): void;
+    /**
+     * Gets values from the execution cache.
+     * @param hash - Hash of the values.
+     * @returns The values.
+     */
+    privateLoadFromExecutionCache(hash: Fr): Promise<Fr[]>;
+    utilityCheckNullifierExists(innerNullifier: Fr): Promise<boolean>;
+    /**
+     * Gets some notes for a storage slot.
+     *
+     * @remarks
+     * Check for pending notes with matching slot.
+     * Real notes coming from DB will have a leafIndex which
+     * represents their index in the note hash tree.
+     *
+     * @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.
+     * @param selectValues - The values to match.
+     * @param selectComparators - The comparators to match by.
+     * @param sortBy - An array of indices of the fields to sort.
+     * @param sortOrder - The order of the corresponding index in sortBy. (1: DESC, 2: ASC, 0: Do nothing)
+     * @param limit - The number of notes to retrieve per query.
+     * @param offset - The starting index for pagination.
+     * @param status - The status of notes to fetch.
+     * @returns Array of note data.
+     */
+    utilityGetNotes(storageSlot: Fr, numSelects: number, selectByIndexes: number[], selectByOffsets: number[], selectByLengths: number[], selectValues: Fr[], selectComparators: number[], sortByIndexes: number[], sortByOffsets: number[], sortByLengths: number[], sortOrder: number[], limit: number, offset: number, status: NoteStatus): Promise<NoteData[]>;
+    /**
+     * 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 storageSlot - The storage slot.
+     * @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: Fr, noteTypeId: NoteSelector, noteItems: Fr[], noteHash: Fr, counter: number): void;
+    /**
+     * 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.
+     */
+    privateNotifyNullifiedNote(innerNullifier: Fr, noteHash: Fr, counter: number): Promise<void>;
+    /**
+     * 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.
+     */
+    privateNotifyCreatedNullifier(innerNullifier: Fr): Promise<void>;
+    /**
+     * 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 counter - The contract class log's counter.
+     */
+    privateNotifyCreatedContractClassLog(log: ContractClassLog, counter: number): void;
+    /**
+     * Calls a private function as a nested execution.
+     * @param targetContractAddress - The address of the contract to call.
+     * @param functionSelector - The function selector of the function 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.
+     * @returns The execution result.
+     */
+    privateCallPrivateFunction(targetContractAddress: AztecAddress, functionSelector: FunctionSelector, argsHash: Fr, sideEffectCounter: number, isStaticCall: boolean): Promise<{
+        endSideEffectCounter: Fr;
+        returnsHash: Fr;
+    }>;
+    /**
+     * 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: AztecAddress, calldataHash: Fr, _sideEffectCounter: number, _isStaticCall: boolean): Promise<void>;
+    /**
+     * 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: AztecAddress, calldataHash: Fr, _sideEffectCounter: number, _isStaticCall: boolean): Promise<void>;
+    privateNotifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: number): Promise<void>;
+    /**
+     * Derives the call context for a nested execution.
+     * @param targetContractAddress - The address of the contract being called.
+     * @param targetArtifact - The artifact of the function being called.
+     * @param isStaticCall - Whether the call is a static call.
+     * @returns The derived call context.
+     */
+    private deriveCallContext;
+    getDebugFunctionName(): Promise<string>;
+    utilityEmitOffchainEffect(data: Fr[]): Promise<void>;
+}
+//# sourceMappingURL=private_execution_oracle.d.ts.map

package/dest/contract_function_simulator/oracle/private_execution_oracle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"private_execution_oracle.d.ts","sourceRoot":"","sources":["../../../src/contract_function_simulator/oracle/private_execution_oracle.ts"],"names":[],"mappings":"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"}

package/dest/contract_function_simulator/oracle/private_execution_oracle.js

@@ -0,0 +1,417 @@
+import { MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS, PRIVATE_CONTEXT_INPUTS_LENGTH } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+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 { PrivateContextInputs } from '@aztec/stdlib/kernel';
+import { Note } from '@aztec/stdlib/note';
+import { CallContext, CountedContractClassLog, NoteAndSlot } from '@aztec/stdlib/tx';
+import { Tag } from '../../tagging/tag.js';
+import { pickNotes } from '../pick_notes.js';
+import { executePrivateFunction, verifyCurrentClassId } 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;
+    /**
+   * 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
+   * the ExecutionNoteCache and the final proof data. But we still include those notes in the execution result because
+   * 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 = [];
+    }
+    getPrivateContextInputs() {
+        return new PrivateContextInputs(this.callContext, this.anchorBlockHeader, this.txContext, this.sideEffectCounter);
+    }
+    // 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
+    /**
+   * Writes the function inputs to the initial witness.
+   * @param abi - The function ABI.
+   * @returns The initial witness.
+   */ getInitialWitness(abi) {
+        const argumentsSize = countArgumentsSize(abi);
+        const args = this.executionCache.getPreimage(this.argsHash);
+        if (args?.length !== argumentsSize) {
+            throw new Error(`Invalid arguments size: expected ${argumentsSize}, got ${args?.length}`);
+        }
+        const privateContextInputsAsFields = this.getPrivateContextInputs().toFields();
+        if (privateContextInputsAsFields.length !== PRIVATE_CONTEXT_INPUTS_LENGTH) {
+            throw new Error('Invalid private context inputs size');
+        }
+        const fields = [
+            ...privateContextInputsAsFields,
+            ...args
+        ];
+        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;
+    }
+    getNoteHashNullifierCounterMap() {
+        return this.noteHashNullifierCounterMap;
+    }
+    /**
+   * Return the contract class logs emitted during this execution.
+   */ getContractClassLogs() {
+        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();
+    }
+    /**
+   * Return the nested execution results during this execution.
+   */ getNestedExecutionResults() {
+        return this.nestedExecutionResults;
+    }
+    /**
+   * Get 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.
+   *
+   * 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);
+    }
+    /**
+   * 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();
+    }
+    /**
+   * Returns the next app tag for a given sender and recipient pair.
+   * @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);
+        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
+        });
+    }
+    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.
+        const lastUsedIndexInTx = this.taggingIndexCache.getLastUsedIndex(secret);
+        if (lastUsedIndexInTx !== undefined) {
+            return lastUsedIndexInTx + 1;
+        } else {
+            // 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);
+            // 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;
+        }
+    }
+    /**
+   * Store values in the execution cache.
+   * @param values - Values to store.
+   * @returns The hash of the values.
+   */ privateStoreInExecutionCache(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) {
+        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) {
+        // 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}`, {
+            contractAddress: this.contractAddress
+        });
+        const nullifier = (await siloNullifier(this.contractAddress, innerNullifier)).toBigInt();
+        return this.noteCache.getNullifiers(this.contractAddress).has(nullifier) || await super.utilityCheckNullifierExists(innerNullifier);
+    }
+    /**
+   * Gets some notes for a storage slot.
+   *
+   * @remarks
+   * Check for pending notes with matching slot.
+   * Real notes coming from DB will have a leafIndex which
+   * represents their index in the note hash tree.
+   *
+   * @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.
+   * @param selectValues - The values to match.
+   * @param selectComparators - The comparators to match by.
+   * @param sortBy - An array of indices of the fields to sort.
+   * @param sortOrder - The order of the corresponding index in sortBy. (1: DESC, 2: ASC, 0: Do nothing)
+   * @param limit - The number of notes to retrieve per query.
+   * @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) {
+        // Nullified pending notes are already removed from the list.
+        const pendingNotes = this.noteCache.getNotes(this.callContext.contractAddress, storageSlot);
+        const pendingNullifiers = this.noteCache.getNullifiers(this.callContext.contractAddress);
+        const dbNotes = await this.executionDataProvider.getNotes(this.callContext.contractAddress, storageSlot, status, this.scopes);
+        const dbNotesFiltered = dbNotes.filter((n)=>!pendingNullifiers.has(n.siloedNullifier.value));
+        const notes = pickNotes([
+            ...dbNotesFiltered,
+            ...pendingNotes
+        ], {
+            selects: selectByIndexes.slice(0, numSelects).map((index, i)=>({
+                    selector: {
+                        index,
+                        offset: selectByOffsets[i],
+                        length: selectByLengths[i]
+                    },
+                    value: selectValues[i],
+                    comparator: selectComparators[i]
+                })),
+            sorts: sortByIndexes.map((index, i)=>({
+                    selector: {
+                        index,
+                        offset: sortByOffsets[i],
+                        length: sortByLengths[i]
+                    },
+                    order: sortOrder[i]
+                })),
+            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);
+        });
+        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 storageSlot - The storage slot.
+   * @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}`, {
+            contractAddress: this.callContext.contractAddress,
+            storageSlot,
+            noteTypeId,
+            counter
+        });
+        const note = new Note(noteItems);
+        this.noteCache.addNewNote({
+            contractAddress: this.callContext.contractAddress,
+            storageSlot,
+            noteNonce: Fr.ZERO,
+            note,
+            siloedNullifier: undefined,
+            noteHash
+        }, counter);
+        this.newNotes.push(new NoteAndSlot(note, storageSlot, 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) {
+        const nullifiedNoteHashCounter = await this.noteCache.nullifyNote(this.callContext.contractAddress, innerNullifier, noteHash);
+        if (nullifiedNoteHashCounter !== undefined) {
+            this.noteHashNullifierCounterMap.set(nullifiedNoteHashCounter, counter);
+        }
+    }
+    /**
+   * 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.
+   */ privateNotifyCreatedNullifier(innerNullifier) {
+        this.log.debug(`Notified of new inner nullifier ${innerNullifier}`, {
+            contractAddress: this.contractAddress
+        });
+        return this.noteCache.nullifierCreated(this.callContext.contractAddress, innerNullifier);
+    }
+    /**
+   * 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 counter - The contract class log's counter.
+   */ privateNotifyCreatedContractClassLog(log, counter) {
+        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}"`);
+    }
+    #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) {
+            throw new Error(`Static call cannot update the state, emit L2->L1 messages or generate logs`);
+        }
+    }
+    /**
+   * Calls a private function as a nested execution.
+   * @param targetContractAddress - The address of the contract to call.
+   * @param functionSelector - The function selector of the function 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.
+   * @returns The execution result.
+   */ async privateCallPrivateFunction(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}`);
+        isStaticCall = isStaticCall || this.callContext.isStaticCall;
+        await verifyCurrentClassId(targetContractAddress, this.executionDataProvider, this.anchorBlockHeader);
+        const targetArtifact = await this.executionDataProvider.getFunctionArtifact(targetContractAddress, functionSelector);
+        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 setupTime = simulatorSetupTimer.ms();
+        const childExecutionResult = await executePrivateFunction(this.simulator, privateExecutionOracle, targetArtifact, targetContractAddress, functionSelector);
+        if (isStaticCall) {
+            this.#checkValidStaticCall(childExecutionResult);
+        }
+        this.nestedExecutionResults.push(childExecutionResult);
+        const publicInputs = childExecutionResult.publicInputs;
+        // Add simulator overhead to this call
+        if (childExecutionResult.profileResult) {
+            childExecutionResult.profileResult.timings.witgen += setupTime;
+        }
+        return {
+            endSideEffectCounter: publicInputs.endSideEffectCounter,
+            returnsHash: publicInputs.returnsHash
+        };
+    }
+    #onNewPublicFunctionCall(calldataHash) {
+        const calldata = this.executionCache.getPreimage(calldataHash);
+        if (!calldata) {
+            throw new Error('Calldata for public call not found in cache');
+        }
+        this.totalPublicCalldataCount += calldata.length;
+        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();
+    }
+    privateNotifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter) {
+        return this.noteCache.setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter);
+    }
+    /**
+   * Derives the call context for a nested execution.
+   * @param targetContractAddress - The address of the contract being called.
+   * @param targetArtifact - The artifact of the function being called.
+   * @param isStaticCall - Whether the call is a static call.
+   * @returns The derived call context.
+   */ async deriveCallContext(targetContractAddress, targetArtifact, isStaticCall = false) {
+        return new CallContext(this.contractAddress, targetContractAddress, await FunctionSelector.fromNameAndParameters(targetArtifact.name, targetArtifact.parameters), isStaticCall);
+    }
+    getDebugFunctionName() {
+        return this.executionDataProvider.getDebugFunctionName(this.contractAddress, this.callContext.functionSelector);
+    }
+    utilityEmitOffchainEffect(data) {
+        this.offchainEffects.push({
+            data
+        });
+        return Promise.resolve();
+    }
+}