@aztec/simulator 0.77.0-testnet-ignition.26 → 0.77.0-testnet-ignition.28

package/dest/private/index.js

@@ -1,6 +1,6 @@
 export { AcirSimulator } from './simulator.js';
-export { ViewDataOracle } from './view_data_oracle.js';
-export { ContractClassNotFoundError, ContractNotFoundError } from './db_oracle.js';
+export { UnconstrainedExecutionOracle } from './unconstrained_execution_oracle.js';
+export { ContractClassNotFoundError, ContractNotFoundError } from './execution_data_provider.js';
 export * from './pick_notes.js';
 export { ExecutionNoteCache } from './execution_note_cache.js';
 export { extractPrivateCircuitPublicInputs, readCurrentClassId } from './private_execution.js';

package/dest/private/private_execution.js

@@ -12,14 +12,14 @@ import { fromACVMField, witnessMapToFields } from './acvm/deserialize.js';
 import { Oracle, extractCallStack } from './acvm/index.js';
 /**
  * Execute a private function and return the execution result.
- */ export async function executePrivateFunction(simulator, context, artifact, contractAddress, functionSelector, log = createLogger('simulator:private_execution')) {
-    const functionName = await context.getDebugFunctionName();
+ */ export async function executePrivateFunction(simulator, privateExecutionOracle, artifact, contractAddress, functionSelector, log = createLogger('simulator:private_execution')) {
+    const functionName = await privateExecutionOracle.getDebugFunctionName();
     log.verbose(`Executing private function ${functionName}`, {
         contract: contractAddress
     });
     const acir = artifact.bytecode;
-    const initialWitness = context.getInitialWitness(artifact);
-    const acvmCallback = new Oracle(context);
+    const initialWitness = privateExecutionOracle.getInitialWitness(artifact);
+    const acvmCallback = new Oracle(privateExecutionOracle);
     const timer = new Timer();
     const acirExecutionResult = await simulator.executeUserCircuit(acir, initialWitness, acvmCallback).catch((err)=>{
         err.message = resolveAssertionMessageFromError(err, artifact);
@@ -43,14 +43,14 @@ import { Oracle, extractCallStack } from './acvm/index.js';
         outputSize: publicInputs.toBuffer().length,
         appCircuitName: functionName
     });
-    const contractClassLogs = context.getContractClassLogs();
-    const rawReturnValues = await context.loadFromExecutionCache(publicInputs.returnsHash);
-    const noteHashLeafIndexMap = context.getNoteHashLeafIndexMap();
-    const newNotes = context.getNewNotes();
-    const noteHashNullifierCounterMap = context.getNoteHashNullifierCounterMap();
-    const nestedExecutions = context.getNestedExecutions();
-    const enqueuedPublicFunctionCalls = context.getEnqueuedPublicFunctionCalls();
-    const publicTeardownFunctionCall = context.getPublicTeardownFunctionCall();
+    const contractClassLogs = privateExecutionOracle.getContractClassLogs();
+    const rawReturnValues = await privateExecutionOracle.loadFromExecutionCache(publicInputs.returnsHash);
+    const noteHashLeafIndexMap = privateExecutionOracle.getNoteHashLeafIndexMap();
+    const newNotes = privateExecutionOracle.getNewNotes();
+    const noteHashNullifierCounterMap = privateExecutionOracle.getNoteHashNullifierCounterMap();
+    const nestedExecutions = privateExecutionOracle.getNestedExecutions();
+    const enqueuedPublicFunctionCalls = privateExecutionOracle.getEnqueuedPublicFunctionCalls();
+    const publicTeardownFunctionCall = privateExecutionOracle.getPublicTeardownFunctionCall();
     log.debug(`Returning from call to ${contractAddress.toString()}:${functionSelector}`);
     return new PrivateCallExecutionResult(acir, Buffer.from(artifact.verificationKey, 'base64'), partialWitness, publicInputs, noteHashLeafIndexMap, newNotes, noteHashNullifierCounterMap, rawReturnValues, nestedExecutions, enqueuedPublicFunctionCalls, publicTeardownFunctionCall, contractClassLogs);
 }
@@ -73,17 +73,19 @@ import { Oracle, extractCallStack } from './acvm/index.js';
     }
     return PrivateCircuitPublicInputs.fromFields(returnData);
 }
-export async function readCurrentClassId(contractAddress, instance, node, blockNumber) {
+export async function readCurrentClassId(contractAddress, instance, executionDataProvider, blockNumber) {
     const { sharedMutableSlot } = await SharedMutableValuesWithHash.getContractUpdateSlots(contractAddress);
-    const sharedMutableValues = await SharedMutableValues.readFromTree(sharedMutableSlot, (slot)=>node.getPublicStorageAt(ProtocolContractAddress.ContractInstanceDeployer, slot, blockNumber));
+    const sharedMutableValues = await SharedMutableValues.readFromTree(sharedMutableSlot, (slot)=>executionDataProvider.getPublicStorageAt(blockNumber, ProtocolContractAddress.ContractInstanceDeployer, slot));
     let currentClassId = sharedMutableValues.svc.getCurrentAt(blockNumber)[0];
     if (currentClassId.isZero()) {
         currentClassId = instance.originalContractClassId;
     }
     return currentClassId;
 }
-export async function verifyCurrentClassId(contractAddress, instance, node, blockNumber) {
-    const currentClassId = await readCurrentClassId(contractAddress, instance, node, blockNumber);
+export async function verifyCurrentClassId(contractAddress, executionDataProvider, blockNumber) {
+    const instance = await executionDataProvider.getContractInstance(contractAddress);
+    blockNumber = blockNumber ?? await executionDataProvider.getBlockNumber();
+    const currentClassId = await readCurrentClassId(contractAddress, instance, executionDataProvider, blockNumber);
     if (!instance.currentContractClassId.equals(currentClassId)) {
         throw new Error(`Contract ${contractAddress} is outdated, current class id is ${currentClassId}, local class id is ${instance.currentContractClassId}`);
     }

package/dest/private/{client_execution_context.js → private_execution_oracle.js}

@@ -1,4 +1,4 @@
-import { PRIVATE_CONTEXT_INPUTS_LENGTH, PUBLIC_DISPATCH_SELECTOR } from '@aztec/constants';
+import { MAX_FR_ARGS_TO_ALL_ENQUEUED_CALLS, 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';
@@ -10,18 +10,18 @@ import { CallContext, CountedContractClassLog, CountedPublicExecutionRequest, No
 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';
+import { UnconstrainedExecutionOracle } from './unconstrained_execution_oracle.js';
 /**
- * The execution context for a client tx simulation.
- */ export class ClientExecutionContext extends ViewDataOracle {
+ * The execution oracle for the private part of a transaction.
+ */ export class PrivateExecutionOracle extends UnconstrainedExecutionOracle {
     argsHash;
     txContext;
     callContext;
     historicalHeader;
     executionCache;
     noteCache;
-    node;
     provider;
+    totalPublicArgsCount;
     sideEffectCounter;
     /**
    * New notes created during this execution.
@@ -44,8 +44,8 @@ import { ViewDataOracle } from './view_data_oracle.js';
     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();
+    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, executionDataProvider, provider, totalPublicArgsCount, sideEffectCounter = 0, log = createLogger('simulator:client_execution_context'), scopes){
+        super(callContext.contractAddress, authWitnesses, capsules, executionDataProvider, log, scopes), this.argsHash = argsHash, this.txContext = txContext, this.callContext = callContext, this.historicalHeader = historicalHeader, this.executionCache = executionCache, this.noteCache = noteCache, this.provider = provider, this.totalPublicArgsCount = totalPublicArgsCount, 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
@@ -141,7 +141,7 @@ import { ViewDataOracle } from './view_data_oracle.js';
         // 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 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,
@@ -257,11 +257,11 @@ import { ViewDataOracle } from './view_data_oracle.js';
    */ 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);
+        await verifyCurrentClassId(targetContractAddress, this.executionDataProvider, this.historicalHeader.globalVariables.blockNumber.toNumber());
+        const targetArtifact = await this.executionDataProvider.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 context = new PrivateExecutionOracle(argsHash, derivedTxContext, derivedCallContext, this.historicalHeader, this.authWitnesses, this.capsules, this.executionCache, this.noteCache, this.executionDataProvider, this.provider, this.totalPublicArgsCount, sideEffectCounter, this.log, this.scopes);
         const childExecutionResult = await executePrivateFunction(this.provider, context, targetArtifact, targetContractAddress, functionSelector);
         if (isStaticCall) {
             this.#checkValidStaticCall(childExecutionResult);
@@ -282,7 +282,7 @@ import { ViewDataOracle } from './view_data_oracle.js';
    * @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 targetArtifact = await this.executionDataProvider.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}`, {
@@ -319,11 +319,16 @@ import { ViewDataOracle } from './view_data_oracle.js';
         // 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([
+        const newArgs = [
             functionSelector.toField(),
             ...this.executionCache.getPreimage(argsHash)
-        ]);
+        ];
+        const newArgsHash = await this.executionCache.store(newArgs);
         await this.createPublicExecutionRequest('enqueued', targetContractAddress, FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)), newArgsHash, sideEffectCounter, isStaticCall);
+        this.totalPublicArgsCount += newArgs.length;
+        if (this.totalPublicArgsCount > MAX_FR_ARGS_TO_ALL_ENQUEUED_CALLS) {
+            throw new Error(`Too many total args to all enqueued public calls! (> ${MAX_FR_ARGS_TO_ALL_ENQUEUED_CALLS})`);
+        }
         return newArgsHash;
     }
     /**
@@ -363,16 +368,16 @@ import { ViewDataOracle } from './view_data_oracle.js';
         return new CallContext(this.contractAddress, targetContractAddress, await FunctionSelector.fromNameAndParameters(targetArtifact.name, targetArtifact.parameters), isStaticCall);
     }
     getDebugFunctionName() {
-        return this.db.getDebugFunctionName(this.contractAddress, this.callContext.functionSelector);
+        return this.executionDataProvider.getDebugFunctionName(this.contractAddress, this.callContext.functionSelector);
     }
     async incrementAppTaggingSecretIndexAsSender(sender, recipient) {
-        await this.db.incrementAppTaggingSecretIndexAsSender(this.contractAddress, sender, recipient);
+        await this.executionDataProvider.incrementAppTaggingSecretIndexAsSender(this.contractAddress, sender, recipient);
     }
     async syncNotes() {
-        const taggedLogsByRecipient = await this.db.syncTaggedLogs(this.contractAddress, this.historicalHeader.globalVariables.blockNumber.toNumber(), this.scopes);
+        const taggedLogsByRecipient = await this.executionDataProvider.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.executionDataProvider.processTaggedLogs(taggedLogs, AztecAddress.fromString(recipient));
         }
-        await this.db.removeNullifiedNotes(this.contractAddress);
+        await this.executionDataProvider.removeNullifiedNotes(this.contractAddress);
     }
 }

package/dest/private/simulator.js

@@ -4,22 +4,20 @@ import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { CallContext, PrivateExecutionResult } from '@aztec/stdlib/tx';
 import { createSimulationError } from '../common/errors.js';
-import { ClientExecutionContext } from './client_execution_context.js';
 import { ExecutionNoteCache } from './execution_note_cache.js';
 import { HashedValuesCache } from './hashed_values_cache.js';
 import { executePrivateFunction, verifyCurrentClassId } from './private_execution.js';
+import { PrivateExecutionOracle } from './private_execution_oracle.js';
 import { executeUnconstrainedFunction } from './unconstrained_execution.js';
-import { ViewDataOracle } from './view_data_oracle.js';
+import { UnconstrainedExecutionOracle } from './unconstrained_execution_oracle.js';
 /**
  * The ACIR simulator.
  */ export class AcirSimulator {
-    db;
-    node;
+    executionDataProvider;
     simulationProvider;
     log;
-    constructor(db, node, simulationProvider){
-        this.db = db;
-        this.node = node;
+    constructor(executionDataProvider, simulationProvider){
+        this.executionDataProvider = executionDataProvider;
         this.simulationProvider = simulationProvider;
         this.log = createLogger('simulator');
     }
@@ -32,9 +30,9 @@ import { ViewDataOracle } from './view_data_oracle.js';
    * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
    * @returns The result of the execution.
    */ async run(request, contractAddress, selector, msgSender = AztecAddress.fromField(Fr.MAX_FIELD_VALUE), scopes) {
-        const header = await this.db.getBlockHeader();
-        await verifyCurrentClassId(contractAddress, await this.db.getContractInstance(contractAddress), this.node, header.globalVariables.blockNumber.toNumber());
-        const entryPointArtifact = await this.db.getFunctionArtifact(contractAddress, selector);
+        const header = await this.executionDataProvider.getBlockHeader();
+        await verifyCurrentClassId(contractAddress, this.executionDataProvider);
+        const entryPointArtifact = await this.executionDataProvider.getFunctionArtifact(contractAddress, selector);
         if (entryPointArtifact.functionType !== FunctionType.PRIVATE) {
             throw new Error(`Cannot run ${entryPointArtifact.functionType} function as private`);
         }
@@ -46,7 +44,7 @@ import { ViewDataOracle } from './view_data_oracle.js';
         const callContext = new CallContext(msgSender, contractAddress, await FunctionSelector.fromNameAndParameters(entryPointArtifact.name, entryPointArtifact.parameters), entryPointArtifact.isStatic);
         const txRequestHash = await request.toTxRequest().hash();
         const noteCache = new ExecutionNoteCache(txRequestHash);
-        const context = new ClientExecutionContext(request.firstCallArgsHash, request.txContext, callContext, header, request.authWitnesses, request.capsules, HashedValuesCache.create(request.argsOfCalls), noteCache, this.db, this.node, this.simulationProvider, startSideEffectCounter, undefined, scopes);
+        const context = new PrivateExecutionOracle(request.firstCallArgsHash, request.txContext, callContext, header, request.authWitnesses, request.capsules, HashedValuesCache.create(request.argsOfCalls), noteCache, this.executionDataProvider, this.simulationProvider, /*totalPublicArgsCount=*/ 0, startSideEffectCounter, undefined, scopes);
         try {
             const executionResult = await executePrivateFunction(this.simulationProvider, context, entryPointArtifact, contractAddress, request.functionSelector);
             const { usedTxRequestHashForNonces } = noteCache.finish();
@@ -63,12 +61,12 @@ import { ViewDataOracle } from './view_data_oracle.js';
    * @param contractAddress - The address of the contract.
    * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
    */ async runUnconstrained(request, contractAddress, selector, scopes) {
-        await verifyCurrentClassId(contractAddress, await this.db.getContractInstance(contractAddress), this.node, await this.node.getBlockNumber());
-        const entryPointArtifact = await this.db.getFunctionArtifact(contractAddress, selector);
+        await verifyCurrentClassId(contractAddress, this.executionDataProvider);
+        const entryPointArtifact = await this.executionDataProvider.getFunctionArtifact(contractAddress, selector);
         if (entryPointArtifact.functionType !== FunctionType.UNCONSTRAINED) {
             throw new Error(`Cannot run ${entryPointArtifact.functionType} function as unconstrained`);
         }
-        const context = new ViewDataOracle(contractAddress, [], [], this.db, this.node, undefined, scopes);
+        const context = new UnconstrainedExecutionOracle(contractAddress, [], [], this.executionDataProvider, undefined, scopes);
         try {
             return await executeUnconstrainedFunction(this.simulationProvider, context, entryPointArtifact, contractAddress, request.selector, request.args);
         } catch (err) {

package/dest/private/{view_data_oracle.js → unconstrained_execution_oracle.js}

@@ -6,30 +6,28 @@ import { siloNullifier } from '@aztec/stdlib/hash';
 import { TypedOracle } from './acvm/index.js';
 import { pickNotes } from './pick_notes.js';
 /**
- * The execution context for a client view tx simulation.
- * It only reads data from data sources. Nothing will be updated or created during this simulation.
- */ export class ViewDataOracle extends TypedOracle {
+ * The oracle for an unconstrained function execution.
+ */ export class UnconstrainedExecutionOracle extends TypedOracle {
     contractAddress;
     authWitnesses;
     capsules;
-    db;
-    aztecNode;
+    executionDataProvider;
     log;
     scopes;
-    constructor(contractAddress, /** List of transient auth witnesses to be used during this simulation */ authWitnesses, capsules, db, aztecNode, log = createLogger('simulator:client_view_context'), scopes){
-        super(), this.contractAddress = contractAddress, this.authWitnesses = authWitnesses, this.capsules = capsules, this.db = db, this.aztecNode = aztecNode, this.log = log, this.scopes = scopes;
+    constructor(contractAddress, /** List of transient auth witnesses to be used during this simulation */ authWitnesses, capsules, executionDataProvider, log = createLogger('simulator:client_view_context'), scopes){
+        super(), this.contractAddress = contractAddress, this.authWitnesses = authWitnesses, this.capsules = capsules, this.executionDataProvider = executionDataProvider, this.log = log, this.scopes = scopes;
     }
     getBlockNumber() {
-        return this.aztecNode.getBlockNumber();
+        return this.executionDataProvider.getBlockNumber();
     }
     getContractAddress() {
         return Promise.resolve(this.contractAddress);
     }
     getChainId() {
-        return Promise.resolve(this.aztecNode.getChainId().then((id)=>new Fr(id)));
+        return Promise.resolve(this.executionDataProvider.getChainId().then((id)=>new Fr(id)));
     }
     getVersion() {
-        return Promise.resolve(this.aztecNode.getVersion().then((v)=>new Fr(v)));
+        return Promise.resolve(this.executionDataProvider.getVersion().then((v)=>new Fr(v)));
     }
     /**
    * Retrieve keys associated with a specific master public key and app address.
@@ -37,7 +35,7 @@ import { pickNotes } from './pick_notes.js';
    * @returns A Promise that resolves to nullifier keys.
    * @throws If the keys are not registered in the key store.
    */ getKeyValidationRequest(pkMHash) {
-        return this.db.getKeyValidationRequest(pkMHash, this.contractAddress);
+        return this.executionDataProvider.getKeyValidationRequest(pkMHash, this.contractAddress);
     }
     /**
    * Fetches the index and sibling path of a leaf at a given block from a given tree.
@@ -46,7 +44,7 @@ import { pickNotes } from './pick_notes.js';
    * @param leafValue - The leaf value
    * @returns The index and sibling path concatenated [index, sibling_path]
    */ getMembershipWitness(blockNumber, treeId, leafValue) {
-        return this.db.getMembershipWitness(blockNumber, treeId, leafValue);
+        return this.executionDataProvider.getMembershipWitness(blockNumber, treeId, leafValue);
     }
     /**
    * Returns a nullifier membership witness for a given nullifier at a given block.
@@ -54,7 +52,7 @@ import { pickNotes } from './pick_notes.js';
    * @param nullifier - Nullifier we try to find witness for.
    * @returns The nullifier membership witness (if found).
    */ async getNullifierMembershipWitness(blockNumber, nullifier) {
-        return await this.db.getNullifierMembershipWitness(blockNumber, nullifier);
+        return await this.executionDataProvider.getNullifierMembershipWitness(blockNumber, nullifier);
     }
     /**
    * Returns a low nullifier membership witness for a given nullifier at a given block.
@@ -65,7 +63,7 @@ import { pickNotes } from './pick_notes.js';
    * 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.
    */ async getLowNullifierMembershipWitness(blockNumber, nullifier) {
-        return await this.db.getLowNullifierMembershipWitness(blockNumber, nullifier);
+        return await this.executionDataProvider.getLowNullifierMembershipWitness(blockNumber, nullifier);
     }
     /**
    * Returns a public data tree witness for a given leaf slot at a given block.
@@ -73,14 +71,14 @@ import { pickNotes } from './pick_notes.js';
    * @param leafSlot - The slot of the public data tree to get the witness for.
    * @returns - The witness
    */ async getPublicDataTreeWitness(blockNumber, leafSlot) {
-        return await this.db.getPublicDataTreeWitness(blockNumber, leafSlot);
+        return await this.executionDataProvider.getPublicDataTreeWitness(blockNumber, leafSlot);
     }
     /**
    * Fetches a block header of a given block.
    * @param blockNumber - The number of a block of which to get the block header.
    * @returns Block extracted from a block with block number `blockNumber`.
    */ async getBlockHeader(blockNumber) {
-        const block = await this.db.getBlock(blockNumber);
+        const block = await this.executionDataProvider.getBlock(blockNumber);
         if (!block) {
             return undefined;
         }
@@ -92,14 +90,14 @@ import { pickNotes } from './pick_notes.js';
    * @returns A complete address associated with the input address.
    * @throws An error if the account is not registered in the database.
    */ getCompleteAddress(account) {
-        return this.db.getCompleteAddress(account);
+        return this.executionDataProvider.getCompleteAddress(account);
     }
     /**
    * Returns a contract instance associated with an address or throws if not found.
    * @param address - Address.
    * @returns A contract instance.
    */ getContractInstance(address) {
-        return this.db.getContractInstance(address);
+        return this.executionDataProvider.getContractInstance(address);
     }
     /**
    * Returns an auth witness for the given message hash. Checks on the list of transient witnesses
@@ -107,7 +105,7 @@ import { pickNotes } from './pick_notes.js';
    * @param messageHash - Hash of the message to authenticate.
    * @returns Authentication witness for the requested message hash.
    */ getAuthWitness(messageHash) {
-        return Promise.resolve(this.authWitnesses.find((w)=>w.requestHash.equals(messageHash))?.witness ?? this.db.getAuthWitness(messageHash));
+        return Promise.resolve(this.authWitnesses.find((w)=>w.requestHash.equals(messageHash))?.witness ?? this.executionDataProvider.getAuthWitness(messageHash));
     }
     /**
    * Gets some notes for a contract address and storage slot.
@@ -130,7 +128,7 @@ import { pickNotes } from './pick_notes.js';
    * @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) {
-        const dbNotes = await this.db.getNotes(this.contractAddress, storageSlot, status, this.scopes);
+        const dbNotes = await this.executionDataProvider.getNotes(this.contractAddress, storageSlot, status, this.scopes);
         return pickNotes(dbNotes, {
             selects: selectByIndexes.slice(0, numSelects).map((index, i)=>({
                     selector: {
@@ -159,18 +157,18 @@ import { pickNotes } from './pick_notes.js';
    * @returns A boolean indicating whether the nullifier exists in the tree or not.
    */ async checkNullifierExists(innerNullifier) {
         const nullifier = await siloNullifier(this.contractAddress, innerNullifier);
-        const index = await this.db.getNullifierIndex(nullifier);
+        const index = await this.executionDataProvider.getNullifierIndex(nullifier);
         return index !== undefined;
     }
     /**
-   * Fetches a message from the db, given its key.
+   * Fetches a message from the executionDataProvider, 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).
    */ async getL1ToL2MembershipWitness(contractAddress, messageHash, secret) {
-        return await this.db.getL1ToL2MembershipWitness(contractAddress, messageHash, secret);
+        return await this.executionDataProvider.getL1ToL2MembershipWitness(contractAddress, messageHash, secret);
     }
     /**
    * Read the public storage data.
@@ -182,7 +180,7 @@ import { pickNotes } from './pick_notes.js';
         const values = [];
         for(let i = 0n; i < numberOfElements; i++){
             const storageSlot = new Fr(startStorageSlot.value + i);
-            const value = await this.aztecNode.getPublicStorageAt(contractAddress, storageSlot, blockNumber);
+            const value = await this.executionDataProvider.getPublicStorageAt(blockNumber, contractAddress, storageSlot);
             this.log.debug(`Oracle storage read: slot=${storageSlot.toString()} address-${contractAddress.toString()} value=${value}`);
             values.push(value);
         }
@@ -205,52 +203,52 @@ import { pickNotes } from './pick_notes.js';
    * @param recipient - The address receiving the note
    * @returns A tagging secret that can be used to tag notes.
    */ async getIndexedTaggingSecretAsSender(sender, recipient) {
-        return await this.db.getIndexedTaggingSecretAsSender(this.contractAddress, sender, recipient);
+        return await this.executionDataProvider.getIndexedTaggingSecretAsSender(this.contractAddress, sender, recipient);
     }
     async syncNotes() {
-        const taggedLogsByRecipient = await this.db.syncTaggedLogs(this.contractAddress, await this.aztecNode.getBlockNumber(), this.scopes);
+        const taggedLogsByRecipient = await this.executionDataProvider.syncTaggedLogs(this.contractAddress, await this.executionDataProvider.getBlockNumber(), this.scopes);
         for (const [recipient, taggedLogs] of taggedLogsByRecipient.entries()){
-            await this.db.processTaggedLogs(taggedLogs, AztecAddress.fromString(recipient));
+            await this.executionDataProvider.processTaggedLogs(taggedLogs, AztecAddress.fromString(recipient));
         }
-        await this.db.removeNullifiedNotes(this.contractAddress);
+        await this.executionDataProvider.removeNullifiedNotes(this.contractAddress);
     }
     async deliverNote(contractAddress, storageSlot, nonce, content, noteHash, nullifier, txHash, recipient) {
         // TODO(#10727): allow other contracts to deliver notes
         if (!this.contractAddress.equals(contractAddress)) {
             throw new Error(`Got a note delivery request from ${contractAddress}, expected ${this.contractAddress}`);
         }
-        await this.db.deliverNote(contractAddress, storageSlot, nonce, content, noteHash, nullifier, txHash, recipient);
+        await this.executionDataProvider.deliverNote(contractAddress, storageSlot, nonce, content, noteHash, nullifier, txHash, recipient);
     }
     getLogByTag(tag) {
-        return this.db.getLogByTag(tag);
+        return this.executionDataProvider.getLogByTag(tag);
     }
     storeCapsule(contractAddress, slot, capsule) {
         if (!contractAddress.equals(this.contractAddress)) {
             // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
             throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
         }
-        return this.db.storeCapsule(this.contractAddress, slot, capsule);
+        return this.executionDataProvider.storeCapsule(this.contractAddress, slot, capsule);
     }
     async loadCapsule(contractAddress, slot) {
         if (!contractAddress.equals(this.contractAddress)) {
             // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
             throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
         }
-        return this.capsules.find((c)=>c.contractAddress.equals(contractAddress) && c.storageSlot.equals(slot))?.data ?? await this.db.loadCapsule(this.contractAddress, slot);
+        return this.capsules.find((c)=>c.contractAddress.equals(contractAddress) && c.storageSlot.equals(slot))?.data ?? await this.executionDataProvider.loadCapsule(this.contractAddress, slot);
     }
     deleteCapsule(contractAddress, slot) {
         if (!contractAddress.equals(this.contractAddress)) {
             // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
             throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
         }
-        return this.db.deleteCapsule(this.contractAddress, slot);
+        return this.executionDataProvider.deleteCapsule(this.contractAddress, slot);
     }
     copyCapsule(contractAddress, srcSlot, dstSlot, numEntries) {
         if (!contractAddress.equals(this.contractAddress)) {
             // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
             throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
         }
-        return this.db.copyCapsule(this.contractAddress, srcSlot, dstSlot, numEntries);
+        return this.executionDataProvider.copyCapsule(this.contractAddress, srcSlot, dstSlot, numEntries);
     }
     // TODO(#11849): consider replacing this oracle with a pure Noir implementation of aes decryption.
     aes128Decrypt(ciphertext, iv, symKey) {

package/dest/public/public_tx_simulator/public_tx_simulator.js

@@ -8,6 +8,7 @@ import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
+import { SimulationError } from '@aztec/stdlib/errors';
 import { NestedProcessReturnValues, TxExecutionPhase } from '@aztec/stdlib/tx';
 import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 import { strict as assert } from 'assert';
@@ -61,15 +62,19 @@ export class PublicTxSimulator {
                 processedPhases.push(setupResult);
             }
             const revertStart = process.hrtime.bigint();
-            // FIXME(#12375): TX shouldn't die if revertible insertions fail. Should just revert to snapshot.
-            await this.insertRevertiblesFromPrivate(context);
-            // add new contracts to the contracts db so that their functions may be found and called
-            await this.worldStateDB.addNewRevertibleContracts(tx);
-            const revertEnd = process.hrtime.bigint();
-            this.metrics.recordPrivateEffectsInsertion(Number(revertEnd - revertStart) / 1_000, 'revertible');
-            if (context.hasPhase(TxExecutionPhase.APP_LOGIC)) {
-                const appLogicResult = await this.simulateAppLogicPhase(context);
-                processedPhases.push(appLogicResult);
+            const success = await this.insertRevertiblesFromPrivate(context);
+            if (success) {
+                // add new contracts to the contracts db so that their functions may be found and called
+                await this.worldStateDB.addNewRevertibleContracts(tx);
+                const revertEnd = process.hrtime.bigint();
+                this.metrics.recordPrivateEffectsInsertion(Number(revertEnd - revertStart) / 1_000, 'revertible');
+                // Only proceed with app logic if there was no revert during revertible insertion
+                if (context.hasPhase(TxExecutionPhase.APP_LOGIC)) {
+                    const appLogicResult = await this.simulateAppLogicPhase(context);
+                    processedPhases.push(appLogicResult);
+                }
+            } else {
+                this.log.debug(`Revertible insertions failed. Skipping app logic.`);
             }
             if (context.hasPhase(TxExecutionPhase.TEARDOWN)) {
                 const teardownResult = await this.simulateTeardownPhase(context);
@@ -255,7 +260,7 @@ export class PublicTxSimulator {
             await stateManager.writeSiloedNullifiersFromPrivate(context.nonRevertibleAccumulatedDataFromPrivate.nullifiers);
         } catch (e) {
             if (e instanceof NullifierCollisionError) {
-                throw new NullifierCollisionError(`Nullifier collision encountered when inserting non-revertible nullifiers from private.\nDetails: ${e.message}\n.Stack:${e.stack}`);
+                throw new NullifierCollisionError(`Nullifier collision encountered when inserting non-revertible nullifiers from private.\nDetails: ${e.message}\nStack:${e.stack}`);
             }
         }
         for (const noteHash of context.nonRevertibleAccumulatedDataFromPrivate.noteHashes){
@@ -275,8 +280,11 @@ export class PublicTxSimulator {
             await stateManager.writeSiloedNullifiersFromPrivate(context.revertibleAccumulatedDataFromPrivate.nullifiers);
         } catch (e) {
             if (e instanceof NullifierCollisionError) {
-                // FIXME(#12375): simulator should be able to recover from this and just revert to snapshot.
-                throw new NullifierCollisionError(`Nullifier collision encountered when inserting revertible nullifiers from private. Details:\n${e.message}\n.Stack:${e.stack}`);
+                // Instead of throwing, revert the app_logic phase
+                context.revert(TxExecutionPhase.APP_LOGIC, new SimulationError(`Nullifier collision encountered when inserting revertible nullifiers from private\nDetails: ${e.message}\nError stack: ${e.stack}`, []), /*culprit=*/ 'insertRevertiblesFromPrivate');
+                return /*success=*/ false;
+            } else {
+                throw e;
             }
         }
         for (const noteHash of context.revertibleAccumulatedDataFromPrivate.noteHashes){
@@ -285,6 +293,7 @@ export class PublicTxSimulator {
                 await stateManager.writeSiloedNoteHash(noteHash);
             }
         }
+        return /*success=*/ true;
     }
     async payFee(context) {
         const txFee = context.getTransactionFee(TxExecutionPhase.TEARDOWN);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/simulator",
-  "version": "0.77.0-testnet-ignition.26",
+  "version": "0.77.0-testnet-ignition.28",
   "type": "module",
   "exports": {
     "./server": "./dest/server.js",
@@ -59,26 +59,26 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "0.77.0-testnet-ignition.26",
-    "@aztec/foundation": "0.77.0-testnet-ignition.26",
-    "@aztec/noir-protocol-circuits-types": "0.77.0-testnet-ignition.26",
-    "@aztec/protocol-contracts": "0.77.0-testnet-ignition.26",
-    "@aztec/stdlib": "0.77.0-testnet-ignition.26",
-    "@aztec/telemetry-client": "0.77.0-testnet-ignition.26",
-    "@aztec/world-state": "0.77.0-testnet-ignition.26",
+    "@aztec/constants": "0.77.0-testnet-ignition.28",
+    "@aztec/foundation": "0.77.0-testnet-ignition.28",
+    "@aztec/noir-protocol-circuits-types": "0.77.0-testnet-ignition.28",
+    "@aztec/protocol-contracts": "0.77.0-testnet-ignition.28",
+    "@aztec/stdlib": "0.77.0-testnet-ignition.28",
+    "@aztec/telemetry-client": "0.77.0-testnet-ignition.28",
+    "@aztec/world-state": "0.77.0-testnet-ignition.28",
     "levelup": "^5.1.1",
     "lodash.clonedeep": "^4.5.0",
     "lodash.merge": "^4.6.2",
     "memdown": "^6.1.1",
     "tslib": "^2.4.0",
-    "@aztec/noir-acvm_js": "0.77.0-testnet-ignition.26",
-    "@aztec/noir-noirc_abi": "0.77.0-testnet-ignition.26",
-    "@aztec/noir-types": "0.77.0-testnet-ignition.26"
+    "@aztec/noir-acvm_js": "0.77.0-testnet-ignition.28",
+    "@aztec/noir-noirc_abi": "0.77.0-testnet-ignition.28",
+    "@aztec/noir-types": "0.77.0-testnet-ignition.28"
   },
   "devDependencies": {
-    "@aztec/kv-store": "0.77.0-testnet-ignition.26",
-    "@aztec/merkle-tree": "0.77.0-testnet-ignition.26",
-    "@aztec/noir-contracts.js": "0.77.0-testnet-ignition.26",
+    "@aztec/kv-store": "0.77.0-testnet-ignition.28",
+    "@aztec/merkle-tree": "0.77.0-testnet-ignition.28",
+    "@aztec/noir-contracts.js": "0.77.0-testnet-ignition.28",
     "@jest/globals": "^29.5.0",
     "@types/jest": "^29.5.0",
     "@types/levelup": "^5.1.3",