@aztec/simulator 0.0.0-test.0 → 0.0.1-commit.03f7ef2

package/dest/public/side_effect_trace.js

@@ -1,36 +1,29 @@
-import { L1_TO_L2_MSG_TREE_HEIGHT, MAX_ENQUEUED_CALLS_PER_TX, MAX_L2_TO_L1_MSGS_PER_TX, MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS, MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, MAX_PUBLIC_LOGS_PER_TX, MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, NOTE_HASH_TREE_HEIGHT, NULLIFIER_TREE_HEIGHT, PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, PUBLIC_DATA_TREE_HEIGHT, PUBLIC_LOG_DATA_SIZE_IN_FIELDS } from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
+import { FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH, MAX_L2_TO_L1_MSGS_PER_TX, MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS, MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
-import { AvmAccumulatedData, AvmAppendTreeHint, AvmCircuitPublicInputs, AvmContractClassHint, AvmContractInstanceHint, AvmEnqueuedCallHint, AvmExecutionHints, AvmNullifierReadTreeHint, AvmNullifierWriteTreeHint, AvmPublicDataReadTreeHint, AvmPublicDataWriteTreeHint, PublicDataUpdateRequest, PublicDataWrite } from '@aztec/stdlib/avm';
-import { SerializableContractInstance } from '@aztec/stdlib/contract';
+import { PublicDataUpdateRequest } from '@aztec/stdlib/avm';
 import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
-import { NoteHash, Nullifier, PrivateToAvmAccumulatedData, PrivateToAvmAccumulatedDataArrayLengths, PublicCallRequest } from '@aztec/stdlib/kernel';
-import { PublicLog } from '@aztec/stdlib/logs';
-import { L2ToL1Message, ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
-import { NullifierLeafPreimage, PublicDataTreeLeafPreimage } from '@aztec/stdlib/trees';
+import { NoteHash, Nullifier } from '@aztec/stdlib/kernel';
+import { DebugLog, PublicLog } from '@aztec/stdlib/logs';
+import { L2ToL1Message } from '@aztec/stdlib/messaging';
 import { strict as assert } from 'assert';
-import { SideEffectLimitReachedError } from './side_effect_errors.js';
+import { L2ToL1MessageLimitReachedError, MaxCallsToUniqueContractClassIdsError, NoteHashLimitReachedError, NullifierLimitReachedError, SideEffectLimitReachedError } from './side_effect_errors.js';
 import { UniqueClassIds } from './unique_class_ids.js';
-const emptyPublicDataPath = ()=>new Array(PUBLIC_DATA_TREE_HEIGHT).fill(Fr.zero());
-const emptyNoteHashPath = ()=>new Array(NOTE_HASH_TREE_HEIGHT).fill(Fr.zero());
-const emptyNullifierPath = ()=>new Array(NULLIFIER_TREE_HEIGHT).fill(Fr.zero());
-const emptyL1ToL2MessagePath = ()=>new Array(L1_TO_L2_MSG_TREE_HEIGHT).fill(Fr.zero());
 export class SideEffectArrayLengths {
     publicDataWrites;
     protocolPublicDataWrites;
     noteHashes;
     nullifiers;
     l2ToL1Msgs;
-    publicLogs;
-    constructor(publicDataWrites, protocolPublicDataWrites, noteHashes, nullifiers, l2ToL1Msgs, publicLogs){
+    publicLogFields;
+    constructor(publicDataWrites, protocolPublicDataWrites, noteHashes, nullifiers, l2ToL1Msgs, publicLogFields){
         this.publicDataWrites = publicDataWrites;
         this.protocolPublicDataWrites = protocolPublicDataWrites;
         this.noteHashes = noteHashes;
         this.nullifiers = nullifiers;
         this.l2ToL1Msgs = l2ToL1Msgs;
-        this.publicLogs = publicLogs;
+        this.publicLogFields = publicLogFields;
     }
     static empty() {
         return new this(0, 0, 0, 0, 0, 0);
@@ -42,9 +35,11 @@ export class SideEffectArrayLengths {
     startSideEffectCounter;
     previousSideEffectArrayLengths;
     uniqueClassIds;
+    writtenPublicDataSlots;
+    debugLogs;
+    debugLogMemoryReads;
     log;
     /** The side effect counter increments with every call to the trace. */ sideEffectCounter;
-    enqueuedCalls;
     publicDataWrites;
     protocolPublicDataWritesLength;
     userPublicDataWritesLength;
@@ -52,16 +47,17 @@ export class SideEffectArrayLengths {
     nullifiers;
     l2ToL1Messages;
     publicLogs;
-    avmCircuitHints;
     /** Make sure a forked trace is never merged twice. */ alreadyMergedIntoParent;
     constructor(/** The counter of this trace's first side effect. */ startSideEffectCounter = 0, /** Track parent's (or previous kernel's) lengths so the AVM can properly enforce TX-wide limits,
      *  otherwise the public kernel can fail to prove because TX limits are breached.
-     */ previousSideEffectArrayLengths = SideEffectArrayLengths.empty(), /** We need to track the set of class IDs used, to enforce limits. */ uniqueClassIds = new UniqueClassIds()){
+     */ previousSideEffectArrayLengths = SideEffectArrayLengths.empty(), /** We need to track the set of class IDs used, to enforce limits. */ uniqueClassIds = new UniqueClassIds(), writtenPublicDataSlots = new Set(), debugLogs = [], debugLogMemoryReads = 0){
         this.startSideEffectCounter = startSideEffectCounter;
         this.previousSideEffectArrayLengths = previousSideEffectArrayLengths;
         this.uniqueClassIds = uniqueClassIds;
+        this.writtenPublicDataSlots = writtenPublicDataSlots;
+        this.debugLogs = debugLogs;
+        this.debugLogMemoryReads = debugLogMemoryReads;
         this.log = createLogger('simulator:side_effect_trace');
-        this.enqueuedCalls = [];
         this.publicDataWrites = [];
         this.protocolPublicDataWritesLength = 0;
         this.userPublicDataWritesLength = 0;
@@ -71,38 +67,30 @@ export class SideEffectArrayLengths {
         this.publicLogs = [];
         this.alreadyMergedIntoParent = false;
         this.sideEffectCounter = startSideEffectCounter;
-        this.avmCircuitHints = AvmExecutionHints.empty();
     }
     fork() {
-        return new SideEffectTrace(this.sideEffectCounter, new SideEffectArrayLengths(this.previousSideEffectArrayLengths.publicDataWrites + this.userPublicDataWritesLength, this.previousSideEffectArrayLengths.protocolPublicDataWrites + this.protocolPublicDataWritesLength, this.previousSideEffectArrayLengths.noteHashes + this.noteHashes.length, this.previousSideEffectArrayLengths.nullifiers + this.nullifiers.length, this.previousSideEffectArrayLengths.l2ToL1Msgs + this.l2ToL1Messages.length, this.previousSideEffectArrayLengths.publicLogs + this.publicLogs.length), this.uniqueClassIds.fork());
+        return new SideEffectTrace(this.sideEffectCounter, new SideEffectArrayLengths(this.previousSideEffectArrayLengths.publicDataWrites + this.userPublicDataWritesLength, this.previousSideEffectArrayLengths.protocolPublicDataWrites + this.protocolPublicDataWritesLength, this.previousSideEffectArrayLengths.noteHashes + this.noteHashes.length, this.previousSideEffectArrayLengths.nullifiers + this.nullifiers.length, this.previousSideEffectArrayLengths.l2ToL1Msgs + this.l2ToL1Messages.length, this.previousSideEffectArrayLengths.publicLogFields + this.publicLogs.reduce((acc, log)=>acc + log.sizeInFields(), 0)), this.uniqueClassIds.fork(), new Set(this.writtenPublicDataSlots), this.debugLogs.slice(), this.debugLogMemoryReads);
     }
     merge(forkedTrace, reverted = false) {
         // sanity check to avoid merging the same forked trace twice
         assert(!forkedTrace.alreadyMergedIntoParent, 'Bug! Cannot merge a forked trace that has already been merged into its parent!');
         forkedTrace.alreadyMergedIntoParent = true;
         this.sideEffectCounter = forkedTrace.sideEffectCounter;
-        this.enqueuedCalls.push(...forkedTrace.enqueuedCalls);
+        this.uniqueClassIds.acceptAndMerge(forkedTrace.uniqueClassIds);
+        this.debugLogs = forkedTrace.debugLogs;
+        this.debugLogMemoryReads = forkedTrace.debugLogMemoryReads;
         if (!reverted) {
             this.publicDataWrites.push(...forkedTrace.publicDataWrites);
             this.noteHashes.push(...forkedTrace.noteHashes);
             this.nullifiers.push(...forkedTrace.nullifiers);
             this.l2ToL1Messages.push(...forkedTrace.l2ToL1Messages);
             this.publicLogs.push(...forkedTrace.publicLogs);
+            this.userPublicDataWritesLength += forkedTrace.userPublicDataWritesLength;
+            this.protocolPublicDataWritesLength += forkedTrace.protocolPublicDataWritesLength;
+            for (const slot of forkedTrace.writtenPublicDataSlots){
+                this.writtenPublicDataSlots.add(slot);
+            }
         }
-        this.mergeHints(forkedTrace);
-    }
-    mergeHints(forkedTrace) {
-        this.uniqueClassIds.acceptAndMerge(forkedTrace.uniqueClassIds);
-        this.avmCircuitHints.enqueuedCalls.push(...forkedTrace.avmCircuitHints.enqueuedCalls);
-        this.avmCircuitHints.contractInstances.push(...forkedTrace.avmCircuitHints.contractInstances);
-        this.avmCircuitHints.contractClasses.push(...forkedTrace.avmCircuitHints.contractClasses);
-        this.avmCircuitHints.publicDataReads.push(...forkedTrace.avmCircuitHints.publicDataReads);
-        this.avmCircuitHints.publicDataWrites.push(...forkedTrace.avmCircuitHints.publicDataWrites);
-        this.avmCircuitHints.nullifierReads.push(...forkedTrace.avmCircuitHints.nullifierReads);
-        this.avmCircuitHints.nullifierWrites.push(...forkedTrace.avmCircuitHints.nullifierWrites);
-        this.avmCircuitHints.noteHashReads.push(...forkedTrace.avmCircuitHints.noteHashReads);
-        this.avmCircuitHints.noteHashWrites.push(...forkedTrace.avmCircuitHints.noteHashWrites);
-        this.avmCircuitHints.l1ToL2MessageReads.push(...forkedTrace.avmCircuitHints.l1ToL2MessageReads);
     }
     getCounter() {
         return this.sideEffectCounter;
@@ -113,117 +101,94 @@ export class SideEffectArrayLengths {
     getNoteHashCount() {
         return this.previousSideEffectArrayLengths.noteHashes + this.noteHashes.length;
     }
-    tracePublicStorageRead(contractAddress, slot, value, leafPreimage = PublicDataTreeLeafPreimage.empty(), leafIndex = Fr.zero(), path = emptyPublicDataPath()) {
-        this.avmCircuitHints.publicDataReads.push(new AvmPublicDataReadTreeHint(leafPreimage, leafIndex, path));
-        this.log.trace(`Tracing storage read (address=${contractAddress}, slot=${slot}): value=${value} (counter=${this.sideEffectCounter})`);
-        this.incrementSideEffectCounter();
-    }
-    async tracePublicStorageWrite(contractAddress, slot, value, protocolWrite, lowLeafPreimage = PublicDataTreeLeafPreimage.empty(), lowLeafIndex = Fr.zero(), lowLeafPath = emptyPublicDataPath(), newLeafPreimage = PublicDataTreeLeafPreimage.empty(), insertionPath = emptyPublicDataPath()) {
-        if (protocolWrite) {
-            if (this.protocolPublicDataWritesLength + this.previousSideEffectArrayLengths.protocolPublicDataWrites >= PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX) {
-                throw new SideEffectLimitReachedError('protocol public data (contract storage) write', PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX);
-            }
-            this.protocolPublicDataWritesLength++;
-        } else {
-            if (this.userPublicDataWritesLength + this.previousSideEffectArrayLengths.publicDataWrites >= MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX) {
-                throw new SideEffectLimitReachedError('public data (contract storage) write', MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX);
+    async tracePublicStorageWrite(contractAddress, slot, value, protocolWrite) {
+        // Only increment counts if the storage slot has not been written to before.
+        if (this.isStorageCold(contractAddress, slot)) {
+            if (protocolWrite) {
+                if (this.protocolPublicDataWritesLength + this.previousSideEffectArrayLengths.protocolPublicDataWrites >= PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX) {
+                    throw new SideEffectLimitReachedError('protocol public data (contract storage) write', PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX);
+                }
+                this.protocolPublicDataWritesLength++;
+            } else {
+                if (this.userPublicDataWritesLength + this.previousSideEffectArrayLengths.publicDataWrites >= MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX) {
+                    throw new SideEffectLimitReachedError('public data (contract storage) write', MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX);
+                }
+                this.userPublicDataWritesLength++;
             }
-            this.userPublicDataWritesLength++;
         }
         const leafSlot = await computePublicDataTreeLeafSlot(contractAddress, slot);
         this.publicDataWrites.push(new PublicDataUpdateRequest(leafSlot, value, this.sideEffectCounter));
-        // New hinting
-        const readHint = new AvmPublicDataReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath);
-        this.avmCircuitHints.publicDataWrites.push(new AvmPublicDataWriteTreeHint(readHint, newLeafPreimage, insertionPath));
         this.log.trace(`Traced public data write (address=${contractAddress}, slot=${slot}): value=${value} (counter=${this.sideEffectCounter}, isProtocol:${protocolWrite})`);
         this.incrementSideEffectCounter();
+        this.writtenPublicDataSlots.add(this.computePublicDataSlotKey(contractAddress, slot));
+    }
+    computePublicDataSlotKey(contractAddress, slot) {
+        return `${contractAddress.toString()}:${slot.toString()}`;
     }
-    // TODO(8287): _exists can be removed once we have the vm properly handling the equality check
-    traceNoteHashCheck(_contractAddress, noteHash, leafIndex, _exists, path = emptyNoteHashPath()) {
-        // New Hinting
-        this.avmCircuitHints.noteHashReads.push(new AvmAppendTreeHint(leafIndex, noteHash, path));
-        // NOTE: counter does not increment for note hash checks (because it doesn't rely on pending note hashes)
-        this.log.trace(`Tracing note hash check (counter=${this.sideEffectCounter})`);
+    isStorageCold(contractAddress, slot) {
+        return !this.writtenPublicDataSlots.has(this.computePublicDataSlotKey(contractAddress, slot));
     }
-    traceNewNoteHash(noteHash, leafIndex = Fr.zero(), path = emptyNoteHashPath()) {
+    traceNewNoteHash(noteHash) {
         if (this.noteHashes.length + this.previousSideEffectArrayLengths.noteHashes >= MAX_NOTE_HASHES_PER_TX) {
-            throw new SideEffectLimitReachedError('note hash', MAX_NOTE_HASHES_PER_TX);
+            throw new NoteHashLimitReachedError();
         }
         this.noteHashes.push(new NoteHash(noteHash, this.sideEffectCounter));
-        this.avmCircuitHints.noteHashWrites.push(new AvmAppendTreeHint(leafIndex, noteHash, path));
         this.log.trace(`Tracing new note hash (counter=${this.sideEffectCounter})`);
         this.incrementSideEffectCounter();
     }
-    traceNullifierCheck(_siloedNullifier, _exists, lowLeafPreimage = NullifierLeafPreimage.empty(), lowLeafIndex = Fr.zero(), lowLeafPath = emptyNullifierPath()) {
-        this.avmCircuitHints.nullifierReads.push(new AvmNullifierReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath));
-        this.log.trace(`Tracing nullifier check (counter=${this.sideEffectCounter})`);
-        this.incrementSideEffectCounter();
-    }
-    traceNewNullifier(siloedNullifier, lowLeafPreimage = NullifierLeafPreimage.empty(), lowLeafIndex = Fr.zero(), lowLeafPath = emptyNullifierPath(), insertionPath = emptyNullifierPath()) {
+    traceNewNullifier(siloedNullifier) {
         if (this.nullifiers.length + this.previousSideEffectArrayLengths.nullifiers >= MAX_NULLIFIERS_PER_TX) {
-            throw new SideEffectLimitReachedError('nullifier', MAX_NULLIFIERS_PER_TX);
+            throw new NullifierLimitReachedError();
         }
-        this.nullifiers.push(new Nullifier(siloedNullifier, this.sideEffectCounter, /*noteHash=*/ Fr.ZERO));
-        const lowLeafReadHint = new AvmNullifierReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath);
-        this.avmCircuitHints.nullifierWrites.push(new AvmNullifierWriteTreeHint(lowLeafReadHint, insertionPath));
+        this.nullifiers.push(new Nullifier(siloedNullifier, /*noteHash=*/ Fr.ZERO, this.sideEffectCounter));
         this.log.trace(`Tracing new nullifier (counter=${this.sideEffectCounter})`);
         this.incrementSideEffectCounter();
     }
-    // TODO(8287): _exists can be removed once we have the vm properly handling the equality check
-    traceL1ToL2MessageCheck(_contractAddress, msgHash, msgLeafIndex, _exists, path = emptyL1ToL2MessagePath()) {
-        this.avmCircuitHints.l1ToL2MessageReads.push(new AvmAppendTreeHint(msgLeafIndex, msgHash, path));
-        this.log.trace(`Tracing l1 to l2 message check (counter=${this.sideEffectCounter})`);
-    }
     traceNewL2ToL1Message(contractAddress, recipient, content) {
         if (this.l2ToL1Messages.length + this.previousSideEffectArrayLengths.l2ToL1Msgs >= MAX_L2_TO_L1_MSGS_PER_TX) {
-            throw new SideEffectLimitReachedError('l2 to l1 message', MAX_L2_TO_L1_MSGS_PER_TX);
+            throw new L2ToL1MessageLimitReachedError();
         }
         const recipientAddress = EthAddress.fromField(recipient);
-        this.l2ToL1Messages.push(new L2ToL1Message(recipientAddress, content, this.sideEffectCounter).scope(contractAddress));
+        this.l2ToL1Messages.push(new L2ToL1Message(recipientAddress, content).scope(contractAddress));
         this.log.trace(`Tracing new l2 to l1 message (counter=${this.sideEffectCounter})`);
         this.incrementSideEffectCounter();
     }
     tracePublicLog(contractAddress, log) {
-        if (this.publicLogs.length + this.previousSideEffectArrayLengths.publicLogs >= MAX_PUBLIC_LOGS_PER_TX) {
-            throw new SideEffectLimitReachedError('public log', MAX_PUBLIC_LOGS_PER_TX);
-        }
-        if (log.length > PUBLIC_LOG_DATA_SIZE_IN_FIELDS) {
-            throw new Error(`Emitted public log is too large, max: ${PUBLIC_LOG_DATA_SIZE_IN_FIELDS}, passed: ${log.length}`);
+        const previouslyEmittedPublicLogFieldsCount = this.previousSideEffectArrayLengths.publicLogFields + this.publicLogs.reduce((acc, log)=>acc + log.sizeInFields(), 0);
+        const publicLog = new PublicLog(contractAddress, log);
+        if (previouslyEmittedPublicLogFieldsCount + publicLog.sizeInFields() > FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH) {
+            throw new SideEffectLimitReachedError('public log fields', FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH);
         }
-        const publicLog = new PublicLog(contractAddress, padArrayEnd(log, Fr.ZERO, PUBLIC_LOG_DATA_SIZE_IN_FIELDS));
         this.publicLogs.push(publicLog);
         this.log.trace(`Tracing new public log (counter=${this.sideEffectCounter})`);
         this.incrementSideEffectCounter();
     }
-    traceGetContractInstance(contractAddress, exists, instance = SerializableContractInstance.default(), updateMembershipHint = AvmPublicDataReadTreeHint.empty(), updatePreimage = []) {
-        this.avmCircuitHints.contractInstances.push(new AvmContractInstanceHint(contractAddress, exists, instance.salt, instance.deployer, instance.currentContractClassId, instance.originalContractClassId, instance.initializationHash, instance.publicKeys, updateMembershipHint, updatePreimage));
-        this.log.trace(`Tracing contract instance retrieval (counter=${this.sideEffectCounter})`);
-        this.incrementSideEffectCounter();
+    traceDebugLog(contractAddress, level, message, fields) {
+        this.debugLogs.push(new DebugLog(contractAddress, level, message, fields));
+    }
+    getDebugLogs() {
+        return this.debugLogs;
+    }
+    getDebugLogMemoryReads() {
+        return this.debugLogMemoryReads;
+    }
+    traceDebugLogMemoryReads(memoryReads) {
+        this.debugLogMemoryReads += memoryReads;
     }
-    traceGetContractClass(contractClassId, exists, contractClass) {
-        if (!exists) {
-            this.avmCircuitHints.contractClasses.push(new AvmContractClassHint(contractClassId, exists, Fr.zero(), Fr.zero(), Fr.zero(), Buffer.alloc(0)));
-        } else if (!this.uniqueClassIds.has(contractClassId.toString())) {
+    traceGetContractClass(contractClassId, exists) {
+        // We limit the number of unique contract class IDs due to hashing and the trace length limit.
+        if (exists && !this.uniqueClassIds.has(contractClassId.toString())) {
             if (this.uniqueClassIds.size() >= MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS) {
                 this.log.debug(`Bytecode retrieval failure for contract class ID ${contractClassId} (limit reached)`);
-                throw new SideEffectLimitReachedError('contract calls to unique class IDs', MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS);
+                throw new MaxCallsToUniqueContractClassIdsError();
             }
+            this.log.trace(`Adding contract class ID ${contractClassId} (counter=${this.sideEffectCounter})`);
             this.uniqueClassIds.add(contractClassId.toString());
-            this.avmCircuitHints.contractClasses.push(new AvmContractClassHint(contractClassId, exists, contractClass.artifactHash, contractClass.privateFunctionsRoot, contractClass.publicBytecodeCommitment, contractClass.packedBytecode));
             this.incrementSideEffectCounter();
         }
     }
-    /**
-   * Trace an enqueued call.
-   * Accept some results from a finished call's trace into this one.
-   */ traceEnqueuedCall(/** The call request from private that enqueued this call. */ publicCallRequest, /** The call's calldata */ calldata, /** Did the call revert? */ _reverted) {
-        // TODO(4805): check if some threshold is reached for max enqueued or nested calls (to unique contracts?)
-        this.enqueuedCalls.push(publicCallRequest);
-        this.avmCircuitHints.enqueuedCalls.push(new AvmEnqueuedCallHint(publicCallRequest.contractAddress, calldata));
-    }
     getSideEffects() {
         return {
-            enqueuedCalls: this.enqueuedCalls,
             publicDataWrites: this.publicDataWrites,
             noteHashes: this.noteHashes,
             nullifiers: this.nullifiers,
@@ -231,19 +196,4 @@ export class SideEffectArrayLengths {
             publicLogs: this.publicLogs
         };
     }
-    toAvmCircuitPublicInputs(/** Globals. */ globalVariables, /** Start tree snapshots. */ startTreeSnapshots, /** Gas used at start of TX. */ startGasUsed, /** How much gas was available for this public execution. */ gasLimits, /** Address of the fee payer. */ feePayer, /** Call requests for setup phase. */ publicSetupCallRequests, /** Call requests for app logic phase. */ publicAppLogicCallRequests, /** Call request for teardown phase. */ publicTeardownCallRequest, /** End tree snapshots. */ endTreeSnapshots, /**
-     * Gas used by the whole transaction, assuming entire teardown limit is used.
-     * This is the gas used when computing transaction fee.
-     */ endGasUsed, /** Transaction fee. */ transactionFee, /** The call's results */ reverted) {
-        return new AvmCircuitPublicInputs(globalVariables, startTreeSnapshots, startGasUsed, gasLimits, feePayer, padArrayEnd(publicSetupCallRequests, PublicCallRequest.empty(), MAX_ENQUEUED_CALLS_PER_TX), padArrayEnd(publicAppLogicCallRequests, PublicCallRequest.empty(), MAX_ENQUEUED_CALLS_PER_TX), publicTeardownCallRequest, /*previousNonRevertibleAccumulatedDataArrayLengths=*/ PrivateToAvmAccumulatedDataArrayLengths.empty(), /*previousRevertibleAccumulatedDataArrayLengths=*/ PrivateToAvmAccumulatedDataArrayLengths.empty(), /*previousNonRevertibleAccumulatedDataArray=*/ PrivateToAvmAccumulatedData.empty(), /*previousRevertibleAccumulatedDataArray=*/ PrivateToAvmAccumulatedData.empty(), endTreeSnapshots, endGasUsed, /*accumulatedData=*/ this.getAvmAccumulatedData(), transactionFee, reverted);
-    }
-    getPublicLogs() {
-        return this.publicLogs;
-    }
-    getAvmCircuitHints() {
-        return this.avmCircuitHints;
-    }
-    getAvmAccumulatedData() {
-        return new AvmAccumulatedData(padArrayEnd(this.noteHashes.map((n)=>n.value), Fr.zero(), MAX_NOTE_HASHES_PER_TX), padArrayEnd(this.nullifiers.map((n)=>n.value), Fr.zero(), MAX_NULLIFIERS_PER_TX), padArrayEnd(this.l2ToL1Messages, ScopedL2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_TX), padArrayEnd(this.publicLogs, PublicLog.empty(), MAX_PUBLIC_LOGS_PER_TX), padArrayEnd(this.publicDataWrites.map((w)=>new PublicDataWrite(w.leafSlot, w.newValue)), PublicDataWrite.empty(), MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX));
-    }
 }

package/dest/public/side_effect_trace_interface.d.ts

@@ -1,34 +1,22 @@
-import type { Fr } from '@aztec/foundation/fields';
-import type { AvmPublicDataReadTreeHint } from '@aztec/stdlib/avm';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { LogLevel } from '@aztec/foundation/log';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { ContractClassWithCommitment, SerializableContractInstance } from '@aztec/stdlib/contract';
-import type { PublicCallRequest } from '@aztec/stdlib/kernel';
-import type { PublicLog } from '@aztec/stdlib/logs';
-import type { NullifierLeafPreimage, PublicDataTreeLeafPreimage } from '@aztec/stdlib/trees';
+import type { DebugLog } from '@aztec/stdlib/logs';
 export interface PublicSideEffectTraceInterface {
     fork(): PublicSideEffectTraceInterface;
     merge(nestedTrace: PublicSideEffectTraceInterface, reverted?: boolean): void;
     getCounter(): number;
-    tracePublicStorageRead(contractAddress: AztecAddress, slot: Fr, value: Fr, leafPreimage?: PublicDataTreeLeafPreimage, leafIndex?: Fr, path?: Fr[]): void;
-    tracePublicStorageWrite(contractAddress: AztecAddress, slot: Fr, // This is the storage slot not the computed leaf slot
-    value: Fr, protocolWrite: boolean, lowLeafPreimage?: PublicDataTreeLeafPreimage, lowLeafIndex?: Fr, lowLeafPath?: Fr[], newLeafPreimage?: PublicDataTreeLeafPreimage, insertionPath?: Fr[]): Promise<void>;
-    traceNoteHashCheck(contractAddress: AztecAddress, noteHash: Fr, leafIndex: Fr, exists: boolean, path?: Fr[]): void;
-    traceNewNoteHash(uniqueNoteHash: Fr, leafIndex?: Fr, path?: Fr[]): void;
+    tracePublicStorageWrite(contractAddress: AztecAddress, slot: Fr, value: Fr, protocolWrite: boolean): Promise<void>;
+    isStorageCold(contractAddress: AztecAddress, slot: Fr): boolean;
+    traceNewNoteHash(uniqueNoteHash: Fr): void;
     getNoteHashCount(): number;
-    traceNullifierCheck(siloedNullifier: Fr, exists: boolean, lowLeafPreimage?: NullifierLeafPreimage, lowLeafIndex?: Fr, lowLeafPath?: Fr[]): void;
-    traceNewNullifier(siloedNullifier: Fr, lowLeafPreimage?: NullifierLeafPreimage, lowLeafIndex?: Fr, lowLeafPath?: Fr[], insertionPath?: Fr[]): void;
-    traceL1ToL2MessageCheck(contractAddress: AztecAddress, msgHash: Fr, msgLeafIndex: Fr, exists: boolean, path?: Fr[]): void;
+    traceNewNullifier(siloedNullifier: Fr): void;
     traceNewL2ToL1Message(contractAddress: AztecAddress, recipient: Fr, content: Fr): void;
     tracePublicLog(contractAddress: AztecAddress, log: Fr[]): void;
-    traceGetContractInstance(contractAddress: AztecAddress, exists: boolean, instance?: SerializableContractInstance, updateMembershipHint?: AvmPublicDataReadTreeHint, updatePreimage?: Fr[]): void;
-    traceGetContractClass(contractClassId: Fr, exists: boolean, contractClass?: ContractClassWithCommitment): void;
-    traceEnqueuedCall(
-    /** The call request from private that enqueued this call. */
-    publicCallRequest: PublicCallRequest, 
-    /** The call's calldata */
-    calldata: Fr[], 
-    /** Did the call revert? */
-    reverted: boolean): void;
-    getPublicLogs(): PublicLog[];
+    traceDebugLog(contractAddress: AztecAddress, level: LogLevel, message: string, fields: Fr[]): void;
+    getDebugLogs(): DebugLog[];
+    getDebugLogMemoryReads(): number;
+    traceDebugLogMemoryReads(memoryReads: number): void;
+    traceGetContractClass(contractClassId: Fr, exists: boolean): void;
 }
-//# sourceMappingURL=side_effect_trace_interface.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lkZV9lZmZlY3RfdHJhY2VfaW50ZXJmYWNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHVibGljL3NpZGVfZWZmZWN0X3RyYWNlX2ludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN6RCxPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN0RCxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNoRSxPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUVuRCxNQUFNLFdBQVcsOEJBQThCO0lBQzdDLElBQUksSUFBSSw4QkFBOEIsQ0FBQztJQUN2QyxLQUFLLENBQUMsV0FBVyxFQUFFLDhCQUE4QixFQUFFLFFBQVEsQ0FBQyxFQUFFLE9BQU8sR0FBRyxJQUFJLENBQUM7SUFDN0UsVUFBVSxJQUFJLE1BQU0sQ0FBQztJQUVyQix1QkFBdUIsQ0FDckIsZUFBZSxFQUFFLFlBQVksRUFDN0IsSUFBSSxFQUFFLEVBQUUsRUFDUixLQUFLLEVBQUUsRUFBRSxFQUNULGFBQWEsRUFBRSxPQUFPLEdBQ3JCLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUNqQixhQUFhLENBQUMsZUFBZSxFQUFFLFlBQVksRUFBRSxJQUFJLEVBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQztJQUNoRSxnQkFBZ0IsQ0FBQyxjQUFjLEVBQUUsRUFBRSxHQUFHLElBQUksQ0FBQztJQUMzQyxnQkFBZ0IsSUFBSSxNQUFNLENBQUM7SUFDM0IsaUJBQWlCLENBQUMsZUFBZSxFQUFFLEVBQUUsR0FBRyxJQUFJLENBQUM7SUFDN0MscUJBQXFCLENBQUMsZUFBZSxFQUFFLFlBQVksRUFBRSxTQUFTLEVBQUUsRUFBRSxFQUFFLE9BQU8sRUFBRSxFQUFFLEdBQUcsSUFBSSxDQUFDO0lBQ3ZGLGNBQWMsQ0FBQyxlQUFlLEVBQUUsWUFBWSxFQUFFLEdBQUcsRUFBRSxFQUFFLEVBQUUsR0FBRyxJQUFJLENBQUM7SUFDL0QsYUFBYSxDQUFDLGVBQWUsRUFBRSxZQUFZLEVBQUUsS0FBSyxFQUFFLFFBQVEsRUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxFQUFFLEVBQUUsR0FBRyxJQUFJLENBQUM7SUFDbkcsWUFBWSxJQUFJLFFBQVEsRUFBRSxDQUFDO0lBQzNCLHNCQUFzQixJQUFJLE1BQU0sQ0FBQztJQUNqQyx3QkFBd0IsQ0FBQyxXQUFXLEVBQUUsTUFBTSxHQUFHLElBQUksQ0FBQztJQUNwRCxxQkFBcUIsQ0FBQyxlQUFlLEVBQUUsRUFBRSxFQUFFLE1BQU0sRUFBRSxPQUFPLEdBQUcsSUFBSSxDQUFDO0NBQ25FIn0=

package/dest/public/side_effect_trace_interface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"side_effect_trace_interface.d.ts","sourceRoot":"","sources":["../../src/public/side_effect_trace_interface.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"side_effect_trace_interface.d.ts","sourceRoot":"","sources":["../../src/public/side_effect_trace_interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD,MAAM,WAAW,8BAA8B;IAC7C,IAAI,IAAI,8BAA8B,CAAC;IACvC,KAAK,CAAC,WAAW,EAAE,8BAA8B,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC7E,UAAU,IAAI,MAAM,CAAC;IAErB,uBAAuB,CACrB,eAAe,EAAE,YAAY,EAC7B,IAAI,EAAE,EAAE,EACR,KAAK,EAAE,EAAE,EACT,aAAa,EAAE,OAAO,GACrB,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,aAAa,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC;IAChE,gBAAgB,CAAC,cAAc,EAAE,EAAE,GAAG,IAAI,CAAC;IAC3C,gBAAgB,IAAI,MAAM,CAAC;IAC3B,iBAAiB,CAAC,eAAe,EAAE,EAAE,GAAG,IAAI,CAAC;IAC7C,qBAAqB,CAAC,eAAe,EAAE,YAAY,EAAE,SAAS,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,GAAG,IAAI,CAAC;IACvF,cAAc,CAAC,eAAe,EAAE,YAAY,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC;IAC/D,aAAa,CAAC,eAAe,EAAE,YAAY,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC;IACnG,YAAY,IAAI,QAAQ,EAAE,CAAC;IAC3B,sBAAsB,IAAI,MAAM,CAAC;IACjC,wBAAwB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IACpD,qBAAqB,CAAC,eAAe,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;CACnE"}

package/dest/public/state_manager/index.d.ts

@@ -0,0 +1,2 @@
+export * from './state_manager.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wdWJsaWMvc3RhdGVfbWFuYWdlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9CQUFvQixDQUFDIn0=

package/dest/public/state_manager/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/public/state_manager/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dest/public/state_manager/index.js

@@ -0,0 +1 @@
+export * from './state_manager.js';

package/dest/public/{avm/journal → state_manager}/nullifiers.d.ts

@@ -1,5 +1,5 @@
-import type { Fr } from '@aztec/foundation/fields';
-import type { WorldStateDB } from '../../public_db_sources.js';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { PublicTreesDB } from '../public_db_sources.js';
 /**
  * A class to manage new nullifier staging and existence checks during a contract call's AVM simulation.
  * Maintains a siloed nullifier cache, and ensures that existence checks fall back to the correct source.
@@ -14,7 +14,7 @@ export declare class NullifierManager {
     private readonly parent?;
     constructor(
     /** Reference to node storage. Checked on parent cache-miss. */
-    hostNullifiers: WorldStateDB, 
+    hostNullifiers: PublicTreesDB, 
     /** Cache of siloed nullifiers. */
     cache?: Set<bigint>, 
     /** Parent nullifier manager to fall back on */
@@ -58,7 +58,4 @@ export declare class NullifierManager {
      */
     acceptAndMerge(incomingNullifiers: NullifierManager): void;
 }
-export declare class NullifierCollisionError extends Error {
-    constructor(message: string, ...rest: any[]);
-}
-//# sourceMappingURL=nullifiers.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVsbGlmaWVycy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3B1YmxpYy9zdGF0ZV9tYW5hZ2VyL251bGxpZmllcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFFekQsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFHN0Q7Ozs7R0FJRztBQUNILHFCQUFhLGdCQUFnQjtJQUV6QiwrREFBK0Q7SUFDL0QsT0FBTyxDQUFDLFFBQVEsQ0FBQyxjQUFjO0lBQy9CLGtDQUFrQztJQUNsQyxPQUFPLENBQUMsS0FBSztJQUNiLCtDQUErQztJQUMvQyxPQUFPLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQztJQU4xQjtJQUNFLCtEQUErRDtJQUM5QyxjQUFjLEVBQUUsYUFBYTtJQUM5QyxrQ0FBa0M7SUFDMUIsS0FBSyxHQUFFLEdBQUcsQ0FBQyxNQUFNLENBQWE7SUFDdEMsK0NBQStDO0lBQzlCLE1BQU0sQ0FBQyw4QkFBa0IsRUFDeEM7SUFFSjs7T0FFRztJQUNJLElBQUkscUJBRVY7SUFFRDs7Ozs7T0FLRztJQUNILE9BQU8sQ0FBQyx1QkFBdUI7SUFXL0I7Ozs7Ozs7Ozs7T0FVRztJQUNVLFdBQVcsQ0FBQyxlQUFlLEVBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQztRQUFFLE1BQU0sRUFBRSxPQUFPLENBQUM7UUFBQyxRQUFRLEVBQUUsT0FBTyxDQUFBO0tBQUUsQ0FBQyxDQWlCN0Y7SUFFRDs7OztPQUlHO0lBQ1UsTUFBTSxDQUFDLGVBQWUsRUFBRSxFQUFFLGlCQU10QztJQUVEOzs7O09BSUc7SUFDSSxjQUFjLENBQUMsa0JBQWtCLEVBQUUsZ0JBQWdCLFFBU3pEO0NBQ0YifQ==

package/dest/public/state_manager/nullifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nullifiers.d.ts","sourceRoot":"","sources":["../../../src/public/state_manager/nullifiers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAG7D;;;;GAIG;AACH,qBAAa,gBAAgB;IAEzB,+DAA+D;IAC/D,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,kCAAkC;IAClC,OAAO,CAAC,KAAK;IACb,+CAA+C;IAC/C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IAN1B;IACE,+DAA+D;IAC9C,cAAc,EAAE,aAAa;IAC9C,kCAAkC;IAC1B,KAAK,GAAE,GAAG,CAAC,MAAM,CAAa;IACtC,+CAA+C;IAC9B,MAAM,CAAC,8BAAkB,EACxC;IAEJ;;OAEG;IACI,IAAI,qBAEV;IAED;;;;;OAKG;IACH,OAAO,CAAC,uBAAuB;IAW/B;;;;;;;;;;OAUG;IACU,WAAW,CAAC,eAAe,EAAE,EAAE,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC,CAiB7F;IAED;;;;OAIG;IACU,MAAM,CAAC,eAAe,EAAE,EAAE,iBAMtC;IAED;;;;OAIG;IACI,cAAc,CAAC,kBAAkB,EAAE,gBAAgB,QASzD;CACF"}

package/dest/public/{avm/journal → state_manager}/nullifiers.js

@@ -1,3 +1,4 @@
+import { NullifierCollisionError } from '../side_effect_errors.js';
 /**
  * A class to manage new nullifier staging and existence checks during a contract call's AVM simulation.
  * Maintains a siloed nullifier cache, and ensures that existence checks fall back to the correct source.
@@ -53,8 +54,8 @@
             //  `${MerkleTreeId[MerkleTreeId.NULLIFIER_TREE]} low leaf index should always be found (even if target leaf does not exist)`,
             //);
             //existsInTree = leafOrLowLeafIndex.alreadyPresent;
-            const leafIndex = await this.hostNullifiers.getNullifierIndex(siloedNullifier);
-            existsInTree = leafIndex !== undefined;
+            const exists = await this.hostNullifiers.checkNullifierExists(siloedNullifier);
+            existsInTree = exists;
         }
         const exists = cacheHit || existsInTree;
         return Promise.resolve({
@@ -89,9 +90,3 @@
         ]);
     }
 }
-export class NullifierCollisionError extends Error {
-    constructor(message, ...rest){
-        super(message, ...rest);
-        this.name = 'NullifierCollisionError';
-    }
-}

package/dest/public/{avm/journal → state_manager}/public_storage.d.ts

@@ -1,6 +1,6 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { PublicStateDB } from '../../../common/db_interfaces.js';
+import type { PublicStateDBInterface } from '../db_interfaces.js';
 type PublicStorageReadResult = {
     value: Fr;
     cached: boolean;
@@ -19,7 +19,7 @@ export declare class PublicStorage {
     private readonly cache;
     constructor(
     /** Reference to node storage. Checked on parent cache-miss. */
-    hostPublicStorage: PublicStateDB, 
+    hostPublicStorage: PublicStateDBInterface, 
     /** Parent's storage. Checked on this' cache-miss. */
     parent?: PublicStorage | undefined);
     /**
@@ -63,4 +63,4 @@ export declare class PublicStorage {
     acceptAndMerge(incomingPublicStorage: PublicStorage): void;
 }
 export {};
-//# sourceMappingURL=public_storage.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX3N0b3JhZ2UuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wdWJsaWMvc3RhdGVfbWFuYWdlci9wdWJsaWNfc3RvcmFnZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDcEQsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFFaEUsT0FBTyxLQUFLLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVsRSxLQUFLLHVCQUF1QixHQUFHO0lBQzdCLEtBQUssRUFBRSxFQUFFLENBQUM7SUFDVixNQUFNLEVBQUUsT0FBTyxDQUFDO0NBQ2pCLENBQUM7QUFFRjs7OztHQUlHO0FBQ0gscUJBQWEsYUFBYTtJQUt0QiwrREFBK0Q7SUFDL0QsT0FBTyxDQUFDLFFBQVEsQ0FBQyxpQkFBaUI7SUFDbEMscURBQXFEO0lBQ3JELE9BQU8sQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDO0lBUDFCLDZCQUE2QjtJQUM3QixPQUFPLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBcUI7SUFFM0M7SUFDRSwrREFBK0Q7SUFDOUMsaUJBQWlCLEVBQUUsc0JBQXNCO0lBQzFELHFEQUFxRDtJQUNwQyxNQUFNLENBQUMsMkJBQWUsRUFHeEM7SUFFRDs7T0FFRztJQUNJLElBQUksa0JBRVY7SUFFRDs7Ozs7OztPQU9HO0lBQ0ksZ0JBQWdCLENBQUMsZUFBZSxFQUFFLFlBQVksRUFBRSxJQUFJLEVBQUUsRUFBRSxHQUFHLEVBQUUsR0FBRyxTQUFTLENBUy9FO0lBRUQ7Ozs7Ozs7Ozs7T0FVRztJQUNVLElBQUksQ0FBQyxlQUFlLEVBQUUsWUFBWSxFQUFFLElBQUksRUFBRSxFQUFFLEdBQUcsT0FBTyxDQUFDLHVCQUF1QixDQUFDLENBaUIzRjtJQUVEOzs7Ozs7T0FNRztJQUNJLEtBQUssQ0FBQyxlQUFlLEVBQUUsWUFBWSxFQUFFLElBQUksRUFBRSxFQUFFLEVBQUUsS0FBSyxFQUFFLEVBQUUsUUFFOUQ7SUFFRDs7OztPQUlHO0lBQ0ksY0FBYyxDQUFDLHFCQUFxQixFQUFFLGFBQWEsUUFFekQ7Q0FDRiJ9

package/dest/public/state_manager/public_storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public_storage.d.ts","sourceRoot":"","sources":["../../../src/public/state_manager/public_storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAElE,KAAK,uBAAuB,GAAG;IAC7B,KAAK,EAAE,EAAE,CAAC;IACV,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF;;;;GAIG;AACH,qBAAa,aAAa;IAKtB,+DAA+D;IAC/D,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,qDAAqD;IACrD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IAP1B,6BAA6B;IAC7B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqB;IAE3C;IACE,+DAA+D;IAC9C,iBAAiB,EAAE,sBAAsB;IAC1D,qDAAqD;IACpC,MAAM,CAAC,2BAAe,EAGxC;IAED;;OAEG;IACI,IAAI,kBAEV;IAED;;;;;;;OAOG;IACI,gBAAgB,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,GAAG,SAAS,CAS/E;IAED;;;;;;;;;;OAUG;IACU,IAAI,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAiB3F;IAED;;;;;;OAMG;IACI,KAAK,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,QAE9D;IAED;;;;OAIG;IACI,cAAc,CAAC,qBAAqB,EAAE,aAAa,QAEzD;CACF"}

package/dest/public/{avm/journal → state_manager}/public_storage.js

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 /**
  * A class to manage public storage reads and writes during a contract call's AVM simulation.
  * Maintains a storage write cache, and ensures that reads fall back to the correct source.