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

package/dest/contract_function_simulator/execution_data_provider.d.ts

@@ -0,0 +1,274 @@
+import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
+import type { Fr, Point } from '@aztec/foundation/fields';
+import type { FunctionArtifact, FunctionArtifactWithContractName, FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { L2Block } from '@aztec/stdlib/block';
+import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
+import type { KeyValidationRequest } from '@aztec/stdlib/kernel';
+import type { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
+import type { NoteStatus } from '@aztec/stdlib/note';
+import { type MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
+import type { BlockHeader, NodeStats } from '@aztec/stdlib/tx';
+import type { NoteData } from './oracle/interfaces.js';
+import type { MessageLoadOracleInputs } from './oracle/message_load_oracle_inputs.js';
+/**
+ * Error thrown when a contract is not found in the database.
+ */
+export declare class ContractNotFoundError extends Error {
+    constructor(contractAddress: string);
+}
+/**
+ * Error thrown when a contract class is not found in the database.
+ */
+export declare class ContractClassNotFoundError extends Error {
+    constructor(contractClassId: string);
+}
+export type ExecutionStats = {
+    /**
+     * Contains an entry for each RPC call performed during the execution
+     */
+    nodeRPCCalls: NodeStats;
+};
+/**
+ * The interface for the data layer required to perform private and utility execution.
+ */
+export interface ExecutionDataProvider {
+    /**
+     * Returns a contract instance associated with an address, if available.
+     * @param address - Address.
+     * @returns A contract instance.
+     */
+    getContractInstance(address: AztecAddress): Promise<ContractInstance>;
+    /**
+     * Retrieve the complete address associated to a given address.
+     * @param account - The account address.
+     * @returns A complete address associated with the input address.
+     * @throws An error if the account is not registered in the database.
+     */
+    getCompleteAddress(account: AztecAddress): Promise<CompleteAddress>;
+    /**
+     * Retrieve keys associated with a specific master public key and app address.
+     * @param pkMHash - The master public key hash.
+     * @returns A Promise that resolves to nullifier keys.
+     * @throws If the keys are not registered in the key store.
+     */
+    getKeyValidationRequest(pkMHash: Fr, contractAddress: AztecAddress): Promise<KeyValidationRequest>;
+    /**
+     * Retrieves a set of notes stored in the database for a given contract address and storage slot.
+     * The query result is paginated using 'limit' and 'offset' values.
+     * Returns an object containing an array of note data.
+     *
+     * @param contractAddress - The contract address of the notes.
+     * @param storageSlot - The storage slot of the notes.
+     * @param status - The status of notes to fetch.
+     * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
+     * @returns A Promise that resolves to an array of note data.
+     */
+    getNotes(contractAddress: AztecAddress, storageSlot: Fr, status: NoteStatus, scopes?: AztecAddress[]): Promise<NoteData[]>;
+    /**
+     * Retrieve the artifact information of a specific function within a contract.
+     * The function is identified by its selector, which is a unique identifier generated from the function signature.
+     *
+     * @param contractAddress - The contract address.
+     * @param selector - The corresponding function selector.
+     * @returns A Promise that resolves to a FunctionArtifact object.
+     */
+    getFunctionArtifact(contractAddress: AztecAddress, selector: FunctionSelector): Promise<FunctionArtifactWithContractName>;
+    /**
+     * Generates a stable function name for debug purposes.
+     * @param contractAddress - The contract address.
+     * @param selector - The corresponding function selector.
+     */
+    getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string>;
+    /**
+     * Retrieves the artifact of a specified function within a given contract.
+     * The function is identified by its name, which is unique within a contract.
+     *
+     * @param contractAddress - The AztecAddress representing the contract containing the function.
+     * @param functionName - The name of the function.
+     * @returns The corresponding function's artifact as an object.
+     */
+    getFunctionArtifactByName(contractAddress: AztecAddress, functionName: string): Promise<FunctionArtifact | undefined>;
+    /**
+     * Gets the index of a nullifier in the nullifier tree.
+     * @param nullifier - The nullifier.
+     * @returns - The index of the nullifier. Undefined if it does not exist in the tree.
+     */
+    getNullifierIndex(nullifier: Fr): Promise<bigint | undefined>;
+    /**
+     * Returns a nullifier membership witness for the given nullifier or undefined if not found.
+     * REFACTOR: Same as getL1ToL2MembershipWitness, can be combined with aztec-node method that does almost the same thing.
+     * @param nullifier - Nullifier we're looking for.
+     */
+    getNullifierMembershipWitnessAtLatestBlock(nullifier: Fr): Promise<NullifierMembershipWitness | undefined>;
+    /**
+     * Fetches a message from the db, given its key.
+     * @param contractAddress - Address of a contract by which the message was emitted.
+     * @param messageHash - Hash of the message.
+     * @param secret - Secret used to compute a nullifier.
+     * @dev Contract address and secret are only used to compute the nullifier to get non-nullified messages
+     * @returns The l1 to l2 membership witness (index of message in the tree and sibling path).
+     */
+    getL1ToL2MembershipWitness(contractAddress: AztecAddress, messageHash: Fr, secret: Fr): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>>;
+    /**
+     * Retrieve the latest block header synchronized by the execution data provider. This block header is referred
+     * to as the anchor block header in Aztec terminology and it defines the state that is used during private function
+     * execution.
+     * @returns The anchor block header.
+     */
+    getAnchorBlockHeader(): Promise<BlockHeader>;
+    /**
+     * Fetches the index and sibling path of a leaf at a given block from a given tree.
+     * @param blockNumber - The block number at which to get the membership witness.
+     * @param treeId - Id of the tree to get the sibling path from.
+     * @param leafValue - The leaf value
+     * @returns The index and sibling path concatenated [index, sibling_path]
+     */
+    getMembershipWitness(blockNumber: number, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[]>;
+    /**
+     * Returns a nullifier membership witness for a given nullifier at a given block.
+     * @param blockNumber - The block number at which to get the index.
+     * @param nullifier - Nullifier we try to find witness for.
+     * @returns The nullifier membership witness (if found).
+     */
+    getNullifierMembershipWitness(blockNumber: number, nullifier: Fr): Promise<NullifierMembershipWitness | undefined>;
+    /**
+     * Returns a low nullifier membership witness for a given nullifier at a given block.
+     * @param blockNumber - The block number at which to get the index.
+     * @param nullifier - Nullifier we try to find the low nullifier witness for.
+     * @returns The low nullifier membership witness (if found).
+     * @remarks Low nullifier witness can be used to perform a nullifier non-inclusion proof by leveraging the "linked
+     * list structure" of leaves and proving that a lower nullifier is pointing to a bigger next value than the nullifier
+     * we are trying to prove non-inclusion for.
+     */
+    getLowNullifierMembershipWitness(blockNumber: number, nullifier: Fr): Promise<NullifierMembershipWitness | undefined>;
+    /**
+     * Returns a witness for a given slot of the public data tree at a given block.
+     * @param blockNumber - The block number at which to get the witness.
+     * @param leafSlot - The slot of the public data in the public data tree.
+     */
+    getPublicDataWitness(blockNumber: number, leafSlot: Fr): Promise<PublicDataWitness | undefined>;
+    /**
+     * Gets the storage value at the given contract storage slot.
+     *
+     * @remarks The storage slot here refers to the slot as it is defined in Noir not the index in the merkle tree.
+     * Aztec's version of `eth_getStorageAt`.
+     *
+     * @param blockNumber - The block number at which to get the data.
+     * @param contract - Address of the contract to query.
+     * @param slot - Slot to query.
+     * @returns Storage value at the given contract slot.
+     * @throws If the contract is not deployed.
+     */
+    getPublicStorageAt(blockNumber: number, contract: AztecAddress, slot: Fr): Promise<Fr>;
+    /**
+     * Fetch a block corresponding to the given block number.
+     * @param blockNumber - The block number of a block to fetch.
+     * @returns - The block corresponding to the given block number. Undefined if it does not exist.
+     */
+    getBlock(blockNumber: number): Promise<L2Block | undefined>;
+    /**
+     * Assert that the oracle version is compatible with the expected version.
+     * @param version - The expected version.
+     */
+    assertCompatibleOracleVersion(version: number): void;
+    /**
+     * Calculates the directional app tagging secret for a given contract, sender and recipient.
+     * @param contractAddress - The contract address to silo the secret for
+     * @param sender - The address sending the note
+     * @param recipient - The address receiving the note
+     * @returns The directional app tagging secret
+     */
+    calculateDirectionalAppTaggingSecret(contractAddress: AztecAddress, sender: AztecAddress, recipient: AztecAddress): Promise<DirectionalAppTaggingSecret>;
+    /**
+     * Updates the local index of the shared tagging secret of a (sender, recipient, contract) tuple if a log with
+     * a larger index is found from the node.
+     * @param secret - The secret that's unique for (sender, recipient, contract) tuple while the direction
+     * of sender -> recipient matters.
+     * @param contractAddress - The address of the contract that the logs are tagged for. Needs to be provided to store
+     * because the function performs second round of siloing which is necessary because kernels do it as well (they silo
+     * first field of the private log which corresponds to the tag).
+     */
+    syncTaggedLogsAsSender(secret: DirectionalAppTaggingSecret, contractAddress: AztecAddress): Promise<void>;
+    /**
+     * Returns the last used index when sending a log with a given secret.
+     * @param secret - The directional app tagging secret.
+     * @returns The last used index for the given directional app tagging secret, or undefined if we never sent a log
+     * from this sender to a recipient in a given contract (implicitly included in the secret).
+     */
+    getLastUsedIndexAsSender(secret: DirectionalAppTaggingSecret): Promise<number | undefined>;
+    /**
+     * Synchronizes the private logs tagged with scoped addresses and all the senders in the address book. Stores the found
+     * logs in CapsuleArray ready for a later retrieval in Aztec.nr.
+     * @param contractAddress - The address of the contract that the logs are tagged for.
+     * @param pendingTaggedLogArrayBaseSlot - The base slot of the pending tagged log capsule array in which found logs will be stored.
+     * @param scopes - The scoped addresses to sync logs for. If not provided, all accounts in the address book will be
+     * synced.
+     */
+    syncTaggedLogs(contractAddress: AztecAddress, pendingTaggedLogArrayBaseSlot: Fr, scopes?: AztecAddress[]): Promise<void>;
+    /**
+     * Validates all note and event validation requests enqueued via `enqueue_note_for_validation` and
+     * `enqueue_event_for_validation`, inserting them into the note database and event store respectively, making them
+     * queryable via `get_notes` and `getPrivateEvents`.
+     *
+     * This automatically clears both validation request queues, so no further work needs to be done by the caller.
+     * @param contractAddress - The address of the contract that the logs are tagged for.
+     * @param noteValidationRequestsArrayBaseSlot - The base slot of capsule array containing note validation requests.
+     * @param eventValidationRequestsArrayBaseSlot - The base slot of capsule array containing event validation requests.
+     */
+    validateEnqueuedNotesAndEvents(contractAddress: AztecAddress, noteValidationRequestsArrayBaseSlot: Fr, eventValidationRequestsArrayBaseSlot: Fr): Promise<void>;
+    bulkRetrieveLogs(contractAddress: AztecAddress, logRetrievalRequestsArrayBaseSlot: Fr, logRetrievalResponsesArrayBaseSlot: Fr): Promise<void>;
+    /**
+     * Looks for nullifiers of active contract notes and marks them as nullified in the db if a nullifier is found.
+     */
+    syncNoteNullifiers(contractAddress: AztecAddress): Promise<void>;
+    /**
+     * Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `loadCapsule`.
+     * * If data was already stored at this slot, it is overwritten.
+     * @param contractAddress - The contract address to scope the data under.
+     * @param slot - The slot in the database in which to store the value. Slots need not be contiguous.
+     * @param capsule - An array of field elements representing the capsule.
+     * @remarks A capsule is a "blob" of data that is passed to the contract through an oracle. It works similarly
+     * to public contract storage in that it's indexed by the contract address and storage slot but instead of the global
+     * network state it's backed by local PXE db.
+     */
+    storeCapsule(contractAddress: AztecAddress, slot: Fr, capsule: Fr[]): Promise<void>;
+    /**
+     * Returns data previously stored via `storeCapsule` in the per-contract non-volatile database.
+     * @param contractAddress - The contract address under which the data is scoped.
+     * @param slot - The slot in the database to read.
+     * @returns The stored data or `null` if no data is stored under the slot.
+     */
+    loadCapsule(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null>;
+    /**
+     * Deletes data in the per-contract non-volatile database. Does nothing if no data was present.
+     * @param contractAddress - The contract address under which the data is scoped.
+     * @param slot - The slot in the database to delete.
+     */
+    deleteCapsule(contractAddress: AztecAddress, slot: Fr): Promise<void>;
+    /**
+     * Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data
+     * structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.
+     * Supports overlapping source and destination regions (which will result in the overlapped source values being
+     * overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)
+     *
+     * @param contractAddress - The contract address under which the data is scoped.
+     * @param srcSlot - The first slot to copy from.
+     * @param dstSlot - The first slot to copy to.
+     * @param numEntries - The number of entries to copy.
+     */
+    copyCapsule(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void>;
+    /**
+     * Retrieves the shared secret for a given address and ephemeral public key.
+     * @param address - The address to get the secret for.
+     * @param ephPk - The ephemeral public key to get the secret for.
+     * @returns The secret for the given address.
+     */
+    getSharedSecret(address: AztecAddress, ephPk: Point): Promise<Point>;
+    /**
+     * Returns the execution statistics collected during the simulator run.
+     * @returns The execution statistics.
+     */
+    getStats(): ExecutionStats;
+}
+//# sourceMappingURL=execution_data_provider.d.ts.map

package/dest/contract_function_simulator/execution_data_provider.d.ts.map

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

package/dest/contract_function_simulator/execution_data_provider.js

@@ -0,0 +1,14 @@
+/**
+ * Error thrown when a contract is not found in the database.
+ */ export class ContractNotFoundError extends Error {
+    constructor(contractAddress){
+        super(`DB has no contract with address ${contractAddress}`);
+    }
+}
+/**
+ * Error thrown when a contract class is not found in the database.
+ */ export class ContractClassNotFoundError extends Error {
+    constructor(contractClassId){
+        super(`DB has no contract class with id ${contractClassId}`);
+    }
+}

package/dest/contract_function_simulator/execution_note_cache.d.ts

@@ -0,0 +1,93 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { NoteData } from './oracle/interfaces.js';
+interface PendingNote {
+    note: NoteData;
+    counter: number;
+    noteHashForConsumption: Fr;
+}
+/**
+ * Data that's accessible by all the function calls in an execution.
+ */
+export declare class ExecutionNoteCache {
+    #private;
+    private readonly txRequestHash;
+    /**
+     * New notes created in this transaction.
+     * They are pushed to this array in the same order as they are emitted.
+     */
+    private notes;
+    /**
+     * This mapping maps from a contract address to the notes in the contract.
+     */
+    private noteMap;
+    /**
+     * This maps from a contract address to the nullifiers emitted from the contract.
+     * The note which is nullified might be new or not (i.e., was generated in a previous transaction).
+     * Note that their value (bigint representation) is used because Frs cannot be looked up in Sets.
+     */
+    private nullifierMap;
+    /**
+     * All nullifiers emitted in this transaction.
+     */
+    private allNullifiers;
+    private minRevertibleSideEffectCounter;
+    private inRevertiblePhase;
+    /**
+     * We don't need to use the tx request hash for nonces if another non revertible nullifier is emitted.
+     * In that case we disable injecting the tx request hash as a nullifier.
+     */
+    private usedTxRequestHashForNonces;
+    constructor(txRequestHash: Fr);
+    /**
+     * Enters the revertible phase of the transaction.
+     * @param minRevertibleSideEffectCounter - The counter at which the transaction enters the revertible phase.
+     */
+    setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: number): Promise<void>;
+    finish(): {
+        usedTxRequestHashForNonces: boolean;
+    };
+    /**
+     * Add a new note to cache.
+     * @param note - New note created during execution.
+     */
+    addNewNote(note: NoteData, counter: number): void;
+    /**
+     * Add a nullifier to cache. It could be for a db note or a new note created during execution.
+     * @param contractAddress - Contract address of the note.
+     * @param innerNullifier - Inner nullifier of the note.
+     * @param noteHash - A hash of the note. If this value equals 0, it means the note being nullified is from a previous
+     * transaction (and thus not a new note).
+     */
+    nullifyNote(contractAddress: AztecAddress, innerNullifier: Fr, noteHash: Fr): Promise<number | undefined>;
+    /**
+     * Adds a nullifier to the cache. Note cache needs to track all nullifiers to decide which nullifier to use for note siloing.
+     * @param contractAddress - Contract address that emitted the nullifier.
+     * @param innerNullifier
+     */
+    nullifierCreated(contractAddress: AztecAddress, innerNullifier: Fr): Promise<void>;
+    /**
+     * Return notes created up to current point in execution.
+     * If a nullifier for a note in this list is emitted, the note will be deleted.
+     * @param contractAddress - Contract address of the notes.
+     * @param storageSlot - Storage slot of the notes.
+     **/
+    getNotes(contractAddress: AztecAddress, storageSlot: Fr): NoteData[];
+    /**
+     * Check if a note exists in the newNotes array.
+     * @param contractAddress - Contract address of the note.
+     * @param storageSlot - Storage slot of the note.
+     * @param noteHash - A hash of the note.
+     **/
+    checkNoteExists(contractAddress: AztecAddress, noteHash: Fr): boolean;
+    /**
+     * Return all nullifiers emitted from a contract.
+     * @param contractAddress - Address of the contract.
+     */
+    getNullifiers(contractAddress: AztecAddress): Set<bigint>;
+    getAllNotes(): PendingNote[];
+    getAllNullifiers(): Fr[];
+    recordNullifier(contractAddress: AztecAddress, siloedNullifier: bigint): void;
+}
+export {};
+//# sourceMappingURL=execution_note_cache.d.ts.map

package/dest/contract_function_simulator/execution_note_cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution_note_cache.d.ts","sourceRoot":"","sources":["../../src/contract_function_simulator/execution_note_cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAGhE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEvD,UAAU,WAAW;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,sBAAsB,EAAE,EAAE,CAAC;CAC5B;AAED;;GAEG;AACH,qBAAa,kBAAkB;;IAiCjB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAhC1C;;;OAGG;IACH,OAAO,CAAC,KAAK,CAAqB;IAClC;;OAEG;IACH,OAAO,CAAC,OAAO,CAAyC;IAExD;;;;OAIG;IACH,OAAO,CAAC,YAAY,CAAuC;IAE3D;;OAEG;IACH,OAAO,CAAC,aAAa,CAA0B;IAE/C,OAAO,CAAC,8BAA8B,CAAK;IAE3C,OAAO,CAAC,iBAAiB,CAAS;IAElC;;;OAGG;IACH,OAAO,CAAC,0BAA0B,CAAQ;gBAEb,aAAa,EAAE,EAAE;IAE9C;;;OAGG;IACU,iCAAiC,CAAC,8BAA8B,EAAE,MAAM;IAwC9E,MAAM;;;IAWb;;;OAGG;IACI,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM;IAWjD;;;;;;OAMG;IACU,WAAW,CAAC,eAAe,EAAE,YAAY,EAAE,cAAc,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE;IA2BxF;;;;OAIG;IACU,gBAAgB,CAAC,eAAe,EAAE,YAAY,EAAE,cAAc,EAAE,EAAE;IAK/E;;;;;QAKI;IACG,QAAQ,CAAC,eAAe,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;IAK9D;;;;;QAKI;IACG,eAAe,CAAC,eAAe,EAAE,YAAY,EAAE,QAAQ,EAAE,EAAE;IAKlE;;;OAGG;IACI,aAAa,CAAC,eAAe,EAAE,YAAY,GAAG,GAAG,CAAC,MAAM,CAAC;IAYhE,WAAW,IAAI,WAAW,EAAE;IAI5B,gBAAgB,IAAI,EAAE,EAAE;IAIxB,eAAe,CAAC,eAAe,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM;CAWvE"}

package/dest/contract_function_simulator/execution_note_cache.js

@@ -0,0 +1,183 @@
+import { Fr } from '@aztec/foundation/fields';
+import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
+/**
+ * Data that's accessible by all the function calls in an execution.
+ */ export class ExecutionNoteCache {
+    txRequestHash;
+    /**
+   * New notes created in this transaction.
+   * They are pushed to this array in the same order as they are emitted.
+   */ notes;
+    /**
+   * This mapping maps from a contract address to the notes in the contract.
+   */ noteMap;
+    /**
+   * This maps from a contract address to the nullifiers emitted from the contract.
+   * The note which is nullified might be new or not (i.e., was generated in a previous transaction).
+   * Note that their value (bigint representation) is used because Frs cannot be looked up in Sets.
+   */ nullifierMap;
+    /**
+   * All nullifiers emitted in this transaction.
+   */ allNullifiers;
+    minRevertibleSideEffectCounter;
+    inRevertiblePhase;
+    /**
+   * We don't need to use the tx request hash for nonces if another non revertible nullifier is emitted.
+   * In that case we disable injecting the tx request hash as a nullifier.
+   */ usedTxRequestHashForNonces;
+    constructor(txRequestHash){
+        this.txRequestHash = txRequestHash;
+        this.notes = [];
+        this.noteMap = new Map();
+        this.nullifierMap = new Map();
+        this.allNullifiers = new Set();
+        this.minRevertibleSideEffectCounter = 0;
+        this.inRevertiblePhase = false;
+        this.usedTxRequestHashForNonces = true;
+    }
+    /**
+   * Enters the revertible phase of the transaction.
+   * @param minRevertibleSideEffectCounter - The counter at which the transaction enters the revertible phase.
+   */ async setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter) {
+        if (this.inRevertiblePhase) {
+            throw new Error(`Cannot enter the revertible phase twice. Current counter: ${minRevertibleSideEffectCounter}. Previous enter counter: ${this.minRevertibleSideEffectCounter}`);
+        }
+        this.inRevertiblePhase = true;
+        this.minRevertibleSideEffectCounter = minRevertibleSideEffectCounter;
+        let nonceGenerator = this.txRequestHash;
+        const nullifiers = this.getAllNullifiers();
+        if (nullifiers.length > 0) {
+            nonceGenerator = new Fr(nullifiers[0]);
+            this.usedTxRequestHashForNonces = false;
+        }
+        // The existing pending notes are all non-revertible.
+        // They cannot be squashed by nullifiers emitted after minRevertibleSideEffectCounter is set.
+        // Their indexes in the tx are known at this point and won't change. So we can assign a nonce to each one of them.
+        // The nonces will be used to create the "complete" nullifier.
+        const updatedNotes = await Promise.all(this.notes.map(async ({ note, counter }, i)=>{
+            const noteNonce = await computeNoteHashNonce(nonceGenerator, i);
+            const uniqueNoteHash = await computeUniqueNoteHash(noteNonce, await siloNoteHash(note.contractAddress, note.noteHash));
+            return {
+                counter,
+                note: {
+                    ...note,
+                    noteNonce
+                },
+                noteHashForConsumption: uniqueNoteHash
+            };
+        }));
+        // Rebuild the data.
+        this.notes = [];
+        this.noteMap = new Map();
+        updatedNotes.forEach((n)=>this.#addNote(n));
+    }
+    finish() {
+        // If we never entered the revertible phase, we need to use the tx request hash as a nonce for the notes if no nullifiers have been emitted.
+        if (!this.inRevertiblePhase) {
+            this.usedTxRequestHashForNonces = this.getAllNullifiers().length === 0;
+        }
+        // If we entered the revertible phase, the nonce generator was decided based on wether or not a nullifier was emitted before entering.
+        return {
+            usedTxRequestHashForNonces: this.usedTxRequestHashForNonces
+        };
+    }
+    /**
+   * Add a new note to cache.
+   * @param note - New note created during execution.
+   */ addNewNote(note, counter) {
+        const previousNote = this.notes[this.notes.length - 1];
+        if (previousNote && previousNote.counter >= counter) {
+            throw new Error(`Note hash counters must be strictly increasing. Current counter: ${counter}. Previous counter: ${previousNote.counter}.`);
+        }
+        this.#addNote({
+            note,
+            counter,
+            noteHashForConsumption: note.noteHash
+        });
+    }
+    /**
+   * Add a nullifier to cache. It could be for a db note or a new note created during execution.
+   * @param contractAddress - Contract address of the note.
+   * @param innerNullifier - Inner nullifier of the note.
+   * @param noteHash - A hash of the note. If this value equals 0, it means the note being nullified is from a previous
+   * transaction (and thus not a new note).
+   */ async nullifyNote(contractAddress, innerNullifier, noteHash) {
+        const siloedNullifier = (await siloNullifier(contractAddress, innerNullifier)).toBigInt();
+        let nullifiedNoteHashCounter = undefined;
+        // Find and remove the matching new note and log(s) if the emitted noteHash is not empty.
+        if (!noteHash.isEmpty()) {
+            const notesInContract = this.noteMap.get(contractAddress.toBigInt()) ?? [];
+            const noteIndexToRemove = notesInContract.findIndex((n)=>n.noteHashForConsumption.equals(noteHash));
+            if (noteIndexToRemove === -1) {
+                throw new Error('Attempt to remove a pending note that does not exist.');
+            }
+            const note = notesInContract.splice(noteIndexToRemove, 1)[0];
+            nullifiedNoteHashCounter = note.counter;
+            this.noteMap.set(contractAddress.toBigInt(), notesInContract);
+            this.notes = this.notes.filter((n)=>n.counter !== note.counter);
+            // If the note is non revertible and the nullifier was emitted in the revertible phase, both the note hash and the nullifier will be emitted
+            if (this.inRevertiblePhase && note.counter < this.minRevertibleSideEffectCounter) {
+                this.recordNullifier(contractAddress, siloedNullifier);
+            }
+        } else {
+            // If the note being nullified comes from a previous tx the nullifier will be emitted.
+            this.recordNullifier(contractAddress, siloedNullifier);
+        }
+        return nullifiedNoteHashCounter;
+    }
+    /**
+   * Adds a nullifier to the cache. Note cache needs to track all nullifiers to decide which nullifier to use for note siloing.
+   * @param contractAddress - Contract address that emitted the nullifier.
+   * @param innerNullifier
+   */ async nullifierCreated(contractAddress, innerNullifier) {
+        const siloedNullifier = (await siloNullifier(contractAddress, innerNullifier)).toBigInt();
+        this.recordNullifier(contractAddress, siloedNullifier);
+    }
+    /**
+   * Return notes created up to current point in execution.
+   * If a nullifier for a note in this list is emitted, the note will be deleted.
+   * @param contractAddress - Contract address of the notes.
+   * @param storageSlot - Storage slot of the notes.
+   **/ getNotes(contractAddress, storageSlot) {
+        const notes = this.noteMap.get(contractAddress.toBigInt()) ?? [];
+        return notes.filter((n)=>n.note.storageSlot.equals(storageSlot)).map((n)=>n.note);
+    }
+    /**
+   * Check if a note exists in the newNotes array.
+   * @param contractAddress - Contract address of the note.
+   * @param storageSlot - Storage slot of the note.
+   * @param noteHash - A hash of the note.
+   **/ checkNoteExists(contractAddress, noteHash) {
+        const notes = this.noteMap.get(contractAddress.toBigInt()) ?? [];
+        return notes.some((n)=>n.note.noteHash.equals(noteHash));
+    }
+    /**
+   * Return all nullifiers emitted from a contract.
+   * @param contractAddress - Address of the contract.
+   */ getNullifiers(contractAddress) {
+        return this.nullifierMap.get(contractAddress.toBigInt()) ?? new Set();
+    }
+    #addNote(note) {
+        this.notes.push(note);
+        const notes = this.noteMap.get(note.note.contractAddress.toBigInt()) ?? [];
+        notes.push(note);
+        this.noteMap.set(note.note.contractAddress.toBigInt(), notes);
+    }
+    getAllNotes() {
+        return this.notes;
+    }
+    getAllNullifiers() {
+        return [
+            ...this.allNullifiers
+        ].map((n)=>new Fr(n));
+    }
+    recordNullifier(contractAddress, siloedNullifier) {
+        const nullifiers = this.getNullifiers(contractAddress);
+        if (nullifiers.has(siloedNullifier)) {
+            throw new Error(`Duplicate siloed nullifier ${siloedNullifier} emitted by contract ${contractAddress}`);
+        }
+        nullifiers.add(siloedNullifier);
+        this.nullifierMap.set(contractAddress.toBigInt(), nullifiers);
+        this.allNullifiers.add(siloedNullifier);
+    }
+}

package/dest/contract_function_simulator/execution_tagging_index_cache.d.ts

@@ -0,0 +1,16 @@
+import { DirectionalAppTaggingSecret, type PreTag } from '@aztec/stdlib/logs';
+/**
+ * A map that stores the tagging index for a given directional app tagging secret.
+ * Note: The directional app tagging secret is unique for a (sender, recipient, contract) tuple while the direction
+ * of sender -> recipient matters.
+ */
+export declare class ExecutionTaggingIndexCache {
+    private taggingIndexMap;
+    getLastUsedIndex(secret: DirectionalAppTaggingSecret): number | undefined;
+    setLastUsedIndex(secret: DirectionalAppTaggingSecret, index: number): void;
+    /**
+     * Returns the pre tags that were used in this execution (and that need to be stored in the db).
+     */
+    getUsedPreTags(): PreTag[];
+}
+//# sourceMappingURL=execution_tagging_index_cache.d.ts.map

package/dest/contract_function_simulator/execution_tagging_index_cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution_tagging_index_cache.d.ts","sourceRoot":"","sources":["../../src/contract_function_simulator/execution_tagging_index_cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE9E;;;;GAIG;AACH,qBAAa,0BAA0B;IACrC,OAAO,CAAC,eAAe,CAAkC;IAElD,gBAAgB,CAAC,MAAM,EAAE,2BAA2B,GAAG,MAAM,GAAG,SAAS;IAIzE,gBAAgB,CAAC,MAAM,EAAE,2BAA2B,EAAE,KAAK,EAAE,MAAM;IAQ1E;;OAEG;IACI,cAAc,IAAI,MAAM,EAAE;CAMlC"}

package/dest/contract_function_simulator/execution_tagging_index_cache.js

@@ -0,0 +1,26 @@
+import { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
+/**
+ * A map that stores the tagging index for a given directional app tagging secret.
+ * Note: The directional app tagging secret is unique for a (sender, recipient, contract) tuple while the direction
+ * of sender -> recipient matters.
+ */ export class ExecutionTaggingIndexCache {
+    taggingIndexMap = new Map();
+    getLastUsedIndex(secret) {
+        return this.taggingIndexMap.get(secret.toString());
+    }
+    setLastUsedIndex(secret, index) {
+        const currentValue = this.taggingIndexMap.get(secret.toString());
+        if (currentValue !== undefined && currentValue !== index - 1) {
+            throw new Error(`Invalid tagging index update. Current value: ${currentValue}, new value: ${index}`);
+        }
+        this.taggingIndexMap.set(secret.toString(), index);
+    }
+    /**
+   * Returns the pre tags that were used in this execution (and that need to be stored in the db).
+   */ getUsedPreTags() {
+        return Array.from(this.taggingIndexMap.entries()).map(([secret, index])=>({
+                secret: DirectionalAppTaggingSecret.fromString(secret),
+                index
+            }));
+    }
+}

package/dest/contract_function_simulator/hashed_values_cache.d.ts

@@ -0,0 +1,28 @@
+import { Fr } from '@aztec/foundation/fields';
+import { HashedValues } from '@aztec/stdlib/tx';
+/**
+ * A cache for hashed values (arguments, returns) during transaction execution.
+ */
+export declare class HashedValuesCache {
+    private cache;
+    constructor(initialArguments?: HashedValues[]);
+    /**
+     * Creates a new hashed values cache.
+     * @param initialArguments - The initial arguments to add to the cache.
+     * @returns The new hashed values cache.
+     */
+    static create(initialArguments?: HashedValues[]): HashedValuesCache;
+    /**
+     * Gets preimage of a hash.
+     * @param hash - The hash to get the preimage of.
+     * @returns The preimage.
+     */
+    getPreimage(hash: Fr): Fr[] | undefined;
+    /**
+     * Stores values in cache and returns its hash.
+     * @param values - The values to store.
+     * @returns The hash of the values.
+     */
+    store(values: Fr[], hash: Fr): void;
+}
+//# sourceMappingURL=hashed_values_cache.d.ts.map