@aztec/simulator 0.76.4 → 0.77.0-testnet-ignition.21

package/dest/private/client_execution_context.js

@@ -0,0 +1,378 @@
+import { PRIVATE_CONTEXT_INPUTS_LENGTH, PUBLIC_DISPATCH_SELECTOR } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { FunctionSelector, countArgumentsSize } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { computeUniqueNoteHash, siloNoteHash } from '@aztec/stdlib/hash';
+import { PrivateContextInputs } from '@aztec/stdlib/kernel';
+import { Note } from '@aztec/stdlib/note';
+import { CallContext, CountedContractClassLog, CountedPublicExecutionRequest, NoteAndSlot, PublicExecutionRequest } from '@aztec/stdlib/tx';
+import { toACVMWitness } from './acvm/index.js';
+import { pickNotes } from './pick_notes.js';
+import { executePrivateFunction, verifyCurrentClassId } from './private_execution.js';
+import { ViewDataOracle } from './view_data_oracle.js';
+/**
+ * The execution context for a client tx simulation.
+ */ export class ClientExecutionContext extends ViewDataOracle {
+    argsHash;
+    txContext;
+    callContext;
+    historicalHeader;
+    executionCache;
+    noteCache;
+    node;
+    provider;
+    sideEffectCounter;
+    /**
+   * 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;
+    nestedExecutions;
+    enqueuedPublicFunctionCalls;
+    publicTeardownFunctionCall;
+    constructor(argsHash, txContext, callContext, /** Header of a block whose state is used during private execution (not the block the transaction is included in). */ historicalHeader, /** List of transient auth witnesses to be used during this simulation */ authWitnesses, capsules, executionCache, noteCache, db, node, provider, sideEffectCounter = 0, log = createLogger('simulator:client_execution_context'), scopes){
+        super(callContext.contractAddress, authWitnesses, capsules, db, node, log, scopes), this.argsHash = argsHash, this.txContext = txContext, this.callContext = callContext, this.historicalHeader = historicalHeader, this.executionCache = executionCache, this.noteCache = noteCache, this.node = node, this.provider = provider, this.sideEffectCounter = sideEffectCounter, this.newNotes = [], this.noteHashLeafIndexMap = new Map(), this.noteHashNullifierCounterMap = new Map(), this.contractClassLogs = [], this.nestedExecutions = [], this.enqueuedPublicFunctionCalls = [], this.publicTeardownFunctionCall = PublicExecutionRequest.empty();
+    }
+    // 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 privateContextInputs = new PrivateContextInputs(this.callContext, this.historicalHeader, this.txContext, this.sideEffectCounter);
+        const privateContextInputsAsFields = privateContextInputs.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 nested execution results during this execution.
+   */ getNestedExecutions() {
+        return this.nestedExecutions;
+    }
+    /**
+   * Return the enqueued public function calls during this execution.
+   */ getEnqueuedPublicFunctionCalls() {
+        return this.enqueuedPublicFunctionCalls;
+    }
+    /**
+   * Return the public teardown function call set during this execution.
+   */ getPublicTeardownFunctionCall() {
+        return this.publicTeardownFunctionCall;
+    }
+    /**
+   * Store values in the execution cache.
+   * @param values - Values to store.
+   * @returns The hash of the values.
+   */ storeInExecutionCache(values) {
+        return this.executionCache.store(values);
+    }
+    /**
+   * Gets values from the execution cache.
+   * @param hash - Hash of the values.
+   * @returns The values.
+   */ loadFromExecutionCache(hash) {
+        return Promise.resolve(this.executionCache.getPreimage(hash));
+    }
+    /**
+   * 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 getNotes(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.db.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.nonce.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.nonce, 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
+   */ notifyCreatedNote(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,
+            nonce: 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 notifyNullifiedNote(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.
+   */ notifyCreatedNullifier(innerNullifier) {
+        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.
+   * We could also return the hash here if we must save extra gates.
+   * @param log - The contract class log to be emitted.
+   * @param counter - The contract class log's counter.
+   */ emitContractClassLog(log, counter) {
+        this.contractClassLogs.push(new CountedContractClassLog(log, counter));
+        const text = log.toBuffer().toString('hex');
+        this.log.verbose(`Emitted log from ContractClassRegisterer: "${text.length > 100 ? text.slice(0, 100) + '...' : text}"`);
+    }
+    #checkValidStaticCall(childExecutionResult) {
+        if (childExecutionResult.publicInputs.noteHashes.some((item)=>!item.isEmpty()) || childExecutionResult.publicInputs.nullifiers.some((item)=>!item.isEmpty()) || childExecutionResult.publicInputs.l2ToL1Msgs.some((item)=>!item.isEmpty()) || childExecutionResult.publicInputs.privateLogs.some((item)=>!item.isEmpty()) || childExecutionResult.publicInputs.contractClassLogsHashes.some((item)=>!item.isEmpty())) {
+            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 callPrivateFunction(targetContractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall) {
+        this.log.debug(`Calling private function ${targetContractAddress}:${functionSelector} from ${this.callContext.contractAddress}`);
+        isStaticCall = isStaticCall || this.callContext.isStaticCall;
+        await verifyCurrentClassId(targetContractAddress, await this.db.getContractInstance(targetContractAddress), this.node, this.historicalHeader.globalVariables.blockNumber.toNumber());
+        const targetArtifact = await this.db.getFunctionArtifact(targetContractAddress, functionSelector);
+        const derivedTxContext = this.txContext.clone();
+        const derivedCallContext = await this.deriveCallContext(targetContractAddress, targetArtifact, isStaticCall);
+        const context = new ClientExecutionContext(argsHash, derivedTxContext, derivedCallContext, this.historicalHeader, this.authWitnesses, this.capsules, this.executionCache, this.noteCache, this.db, this.node, this.provider, sideEffectCounter, this.log, this.scopes);
+        const childExecutionResult = await executePrivateFunction(this.provider, context, targetArtifact, targetContractAddress, functionSelector);
+        if (isStaticCall) {
+            this.#checkValidStaticCall(childExecutionResult);
+        }
+        this.nestedExecutions.push(childExecutionResult);
+        const publicInputs = childExecutionResult.publicInputs;
+        return {
+            endSideEffectCounter: publicInputs.endSideEffectCounter,
+            returnsHash: publicInputs.returnsHash
+        };
+    }
+    /**
+   * Creates a PublicExecutionRequest object representing the request to call a public function.
+   * @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 public call stack item with the request information.
+   */ async createPublicExecutionRequest(callType, targetContractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall) {
+        const targetArtifact = await this.db.getFunctionArtifact(targetContractAddress, functionSelector);
+        const derivedCallContext = await this.deriveCallContext(targetContractAddress, targetArtifact, isStaticCall);
+        const args = this.executionCache.getPreimage(argsHash);
+        this.log.verbose(`Created ${callType} public execution request to ${targetArtifact.name}@${targetContractAddress}`, {
+            sideEffectCounter,
+            isStaticCall,
+            functionSelector,
+            targetContractAddress,
+            callType
+        });
+        const request = PublicExecutionRequest.from({
+            args,
+            callContext: derivedCallContext
+        });
+        if (callType === 'enqueued') {
+            this.enqueuedPublicFunctionCalls.push(new CountedPublicExecutionRequest(request, sideEffectCounter));
+        } else {
+            this.publicTeardownFunctionCall = request;
+        }
+    }
+    /**
+   * Creates and enqueues a PublicExecutionRequest object representing the request to call a public function. No function
+   * is actually called, since that must happen on the sequencer side. All the fields related to the result
+   * of the execution are empty.
+   * @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 public call stack item with the request information.
+   */ async enqueuePublicFunctionCall(targetContractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall) {
+        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.
+        // WARNING: This is insecure and should be temporary!
+        // The oracle re-hashes the arguments and returns a new args_hash.
+        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.
+        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and
+        // b) this is only temporary.
+        const newArgsHash = await this.executionCache.store([
+            functionSelector.toField(),
+            ...this.executionCache.getPreimage(argsHash)
+        ]);
+        await this.createPublicExecutionRequest('enqueued', targetContractAddress, FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)), newArgsHash, sideEffectCounter, isStaticCall);
+        return newArgsHash;
+    }
+    /**
+   * Creates a PublicExecutionRequest and sets it as the public teardown function. No function
+   * is actually called, since that must happen on the sequencer side. All the fields related to the result
+   * of the execution are empty.
+   * @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 public call stack item with the request information.
+   */ async setPublicTeardownFunctionCall(targetContractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall) {
+        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.
+        // WARNING: This is insecure and should be temporary!
+        // The oracle rehashes the arguments and returns a new args_hash.
+        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.
+        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and
+        // b) this is only temporary.
+        const newArgsHash = await this.executionCache.store([
+            functionSelector.toField(),
+            ...this.executionCache.getPreimage(argsHash)
+        ]);
+        await this.createPublicExecutionRequest('teardown', targetContractAddress, FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)), newArgsHash, sideEffectCounter, isStaticCall);
+        return newArgsHash;
+    }
+    notifySetMinRevertibleSideEffectCounter(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.db.getDebugFunctionName(this.contractAddress, this.callContext.functionSelector);
+    }
+    async incrementAppTaggingSecretIndexAsSender(sender, recipient) {
+        await this.db.incrementAppTaggingSecretIndexAsSender(this.contractAddress, sender, recipient);
+    }
+    async syncNotes() {
+        const taggedLogsByRecipient = await this.db.syncTaggedLogs(this.contractAddress, this.historicalHeader.globalVariables.blockNumber.toNumber(), this.scopes);
+        for (const [recipient, taggedLogs] of taggedLogsByRecipient.entries()){
+            await this.db.processTaggedLogs(taggedLogs, AztecAddress.fromString(recipient));
+        }
+        await this.db.removeNullifiedNotes(this.contractAddress);
+    }
+}

package/dest/{client → private}/db_oracle.d.ts

@@ -1,10 +1,15 @@
-import { type L2Block, type MerkleTreeId, type NoteStatus, type NullifierMembershipWitness, type PublicDataWitness, type TxScopedL2Log } from '@aztec/circuit-types';
-import { type BlockHeader, type CompleteAddress, type ContractInstance, type IndexedTaggingSecret, type KeyValidationRequest } from '@aztec/circuits.js';
-import { type FunctionArtifact, type FunctionSelector } from '@aztec/foundation/abi';
-import { type AztecAddress } from '@aztec/foundation/aztec-address';
-import { type Fr } from '@aztec/foundation/fields';
-import { type NoteData } from '../acvm/index.js';
-import { type CommitmentsDB } from '../public/db_interfaces.js';
+import type { Fr } from '@aztec/foundation/fields';
+import type { FunctionArtifact, 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 { IndexedTaggingSecret, LogWithTxData, TxScopedL2Log } from '@aztec/stdlib/logs';
+import type { NoteStatus } from '@aztec/stdlib/note';
+import { type MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+import type { CommitmentsDB } from '../common/db_interfaces.js';
+import type { NoteData } from './acvm/index.js';
 /**
  * Error thrown when a contract is not found in the database.
  */
@@ -182,6 +187,13 @@ export interface DBOracle extends CommitmentsDB {
      * @param recipient - The account that discovered the note
      */
     deliverNote(contractAddress: AztecAddress, storageSlot: Fr, nonce: Fr, content: Fr[], noteHash: Fr, nullifier: Fr, txHash: Fr, recipient: AztecAddress): Promise<void>;
+    /**
+     * Searches for a log with the corresponding `tag` and returns it along with contextual transaction information.
+     * Returns null if no such log exists, and throws if more than one exists.
+     *
+     * @param tag - The log tag to search for.
+     */
+    getLogByTag(tag: Fr): Promise<LogWithTxData | null>;
     /**
      * Removes all of a contract's notes that have been nullified from the note database.
      */

package/dest/private/db_oracle.d.ts.map

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

package/dest/private/db_oracle.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/{client → private}/execution_note_cache.d.ts

@@ -1,6 +1,6 @@
-import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
-import { type NoteData } from '../acvm/index.js';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { NoteData } from './acvm/index.js';
 interface PendingNote {
     note: NoteData;
     counter: number;

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

@@ -0,0 +1 @@
+{"version":3,"file":"execution_note_cache.d.ts","sourceRoot":"","sources":["../../src/private/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,iBAAiB,CAAC;AAEhD,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,EAAE;CAMnE"}

package/dest/private/execution_note_cache.js

@@ -0,0 +1,180 @@
+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 nonce = await computeNoteHashNonce(nonceGenerator, i);
+            const uniqueNoteHash = await computeUniqueNoteHash(nonce, await siloNoteHash(note.contractAddress, note.noteHash));
+            return {
+                counter,
+                note: {
+                    ...note,
+                    nonce
+                },
+                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);
+        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);
+        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);
+        nullifiers.add(siloedNullifier.toBigInt());
+        this.nullifierMap.set(contractAddress.toBigInt(), nullifiers);
+        this.allNullifiers.add(siloedNullifier.toBigInt());
+    }
+}

package/dest/{common → private}/hashed_values_cache.d.ts

@@ -1,5 +1,5 @@
-import { HashedValues } from '@aztec/circuit-types';
-import { Fr } from '@aztec/circuits.js';
+import { Fr } from '@aztec/foundation/fields';
+import { HashedValues } from '@aztec/stdlib/tx';
 /**
  * A cache for hashed values (arguments, returns) during transaction execution.
  */

package/dest/private/hashed_values_cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashed_values_cache.d.ts","sourceRoot":"","sources":["../../src/private/hashed_values_cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEhD;;GAEG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,KAAK,CAAoB;gBAErB,gBAAgB,GAAE,YAAY,EAAO;IAOjD;;;;OAIG;WACW,MAAM,CAAC,gBAAgB,GAAE,YAAY,EAAO;IAI1D;;;;OAIG;IACI,WAAW,CAAC,IAAI,EAAE,EAAE,GAAG,EAAE,EAAE;IAWlC;;;;OAIG;IACU,KAAK,CAAC,MAAM,EAAE,EAAE,EAAE;CAQhC"}