@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.5476d83

package/dest/public/side_effect_errors.d.ts

@@ -1,4 +1,44 @@
-export declare class SideEffectLimitReachedError extends Error {
+import { CheckedPublicExecutionError } from './public_errors.js';
+/**
+ * Any error that can be thrown during side effect insertion in public.
+ * Includes SideEffectLimitReachedError and NullifierCollisionError.
+ */
+export declare abstract class SideEffectError extends CheckedPublicExecutionError {
+    constructor(message: string);
+}
+export declare class SideEffectLimitReachedError extends SideEffectError {
     constructor(sideEffectType: string, limit: number);
 }
-//# sourceMappingURL=side_effect_errors.d.ts.map
+export declare class MaxCallsToUniqueContractClassIdsError extends SideEffectLimitReachedError {
+    constructor();
+}
+export declare class NullifierLimitReachedError extends SideEffectLimitReachedError {
+    constructor();
+}
+export declare class NoteHashLimitReachedError extends SideEffectLimitReachedError {
+    constructor();
+}
+export declare class L2ToL1MessageLimitReachedError extends SideEffectLimitReachedError {
+    constructor();
+}
+export declare class NullifierCollisionError extends SideEffectError {
+    constructor(message: string);
+}
+/**
+ * Any error that can be thrown during side effect reads in public.
+ * Note: Thrown at state manager level and unknown by simulation, hence NOT considered
+ * CheckedPublicExecutionErrors. Currently only includes append-only tree reads.
+ */
+export declare abstract class SideEffectReadError extends Error {
+    constructor(message: string);
+}
+export declare class IndexOutOfRangeError extends SideEffectReadError {
+    constructor(tree: string, index: number, limit: number);
+}
+export declare class NoteHashIndexOutOfRangeError extends IndexOutOfRangeError {
+    constructor(index: number);
+}
+export declare class L1ToL2MessageIndexOutOfRangeError extends IndexOutOfRangeError {
+    constructor(index: number);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lkZV9lZmZlY3RfZXJyb3JzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHVibGljL3NpZGVfZWZmZWN0X2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFTQSxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUVqRTs7O0dBR0c7QUFDSCw4QkFBc0IsZUFBZ0IsU0FBUSwyQkFBMkI7SUFDdkUsWUFBWSxPQUFPLEVBQUUsTUFBTSxFQUcxQjtDQUNGO0FBRUQscUJBQWEsMkJBQTRCLFNBQVEsZUFBZTtJQUM5RCxZQUFZLGNBQWMsRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFHaEQ7Q0FDRjtBQUVELHFCQUFhLHFDQUFzQyxTQUFRLDJCQUEyQjtJQUNwRixjQUdDO0NBQ0Y7QUFFRCxxQkFBYSwwQkFBMkIsU0FBUSwyQkFBMkI7SUFDekUsY0FHQztDQUNGO0FBRUQscUJBQWEseUJBQTBCLFNBQVEsMkJBQTJCO0lBQ3hFLGNBR0M7Q0FDRjtBQUVELHFCQUFhLDhCQUErQixTQUFRLDJCQUEyQjtJQUM3RSxjQUdDO0NBQ0Y7QUFFRCxxQkFBYSx1QkFBd0IsU0FBUSxlQUFlO0lBQzFELFlBQVksT0FBTyxFQUFFLE1BQU0sRUFHMUI7Q0FDRjtBQUVEOzs7O0dBSUc7QUFDSCw4QkFBc0IsbUJBQW9CLFNBQVEsS0FBSztJQUNyRCxZQUFZLE9BQU8sRUFBRSxNQUFNLEVBRzFCO0NBQ0Y7QUFFRCxxQkFBYSxvQkFBcUIsU0FBUSxtQkFBbUI7SUFDM0QsWUFBWSxJQUFJLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFHckQ7Q0FDRjtBQUVELHFCQUFhLDRCQUE2QixTQUFRLG9CQUFvQjtJQUNwRSxZQUFZLEtBQUssRUFBRSxNQUFNLEVBR3hCO0NBQ0Y7QUFFRCxxQkFBYSxpQ0FBa0MsU0FBUSxvQkFBb0I7SUFDekUsWUFBWSxLQUFLLEVBQUUsTUFBTSxFQUd4QjtDQUNGIn0=

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

@@ -1 +1 @@
-{"version":3,"file":"side_effect_errors.d.ts","sourceRoot":"","sources":["../../src/public/side_effect_errors.ts"],"names":[],"mappings":"AAAA,qBAAa,2BAA4B,SAAQ,KAAK;gBACxC,cAAc,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;CAIlD"}
+{"version":3,"file":"side_effect_errors.d.ts","sourceRoot":"","sources":["../../src/public/side_effect_errors.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAEjE;;;GAGG;AACH,8BAAsB,eAAgB,SAAQ,2BAA2B;IACvE,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED,qBAAa,2BAA4B,SAAQ,eAAe;IAC9D,YAAY,cAAc,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAGhD;CACF;AAED,qBAAa,qCAAsC,SAAQ,2BAA2B;IACpF,cAGC;CACF;AAED,qBAAa,0BAA2B,SAAQ,2BAA2B;IACzE,cAGC;CACF;AAED,qBAAa,yBAA0B,SAAQ,2BAA2B;IACxE,cAGC;CACF;AAED,qBAAa,8BAA+B,SAAQ,2BAA2B;IAC7E,cAGC;CACF;AAED,qBAAa,uBAAwB,SAAQ,eAAe;IAC1D,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED;;;;GAIG;AACH,8BAAsB,mBAAoB,SAAQ,KAAK;IACrD,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED,qBAAa,oBAAqB,SAAQ,mBAAmB;IAC3D,YAAY,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAGrD;CACF;AAED,qBAAa,4BAA6B,SAAQ,oBAAoB;IACpE,YAAY,KAAK,EAAE,MAAM,EAGxB;CACF;AAED,qBAAa,iCAAkC,SAAQ,oBAAoB;IACzE,YAAY,KAAK,EAAE,MAAM,EAGxB;CACF"}

package/dest/public/side_effect_errors.js

@@ -1,6 +1,75 @@
-export class SideEffectLimitReachedError extends Error {
+import { L1_TO_L2_MSG_TREE_LEAF_COUNT, MAX_L2_TO_L1_MSGS_PER_TX, MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS, NOTE_HASH_TREE_LEAF_COUNT } from '@aztec/constants';
+import { CheckedPublicExecutionError } from './public_errors.js';
+/**
+ * Any error that can be thrown during side effect insertion in public.
+ * Includes SideEffectLimitReachedError and NullifierCollisionError.
+ */ export class SideEffectError extends CheckedPublicExecutionError {
+    constructor(message){
+        super(message);
+        this.name = 'SideEffectInsertionError';
+    }
+}
+export class SideEffectLimitReachedError extends SideEffectError {
     constructor(sideEffectType, limit){
         super(`Reached the limit (${limit}) on number of '${sideEffectType}' per tx`);
         this.name = 'SideEffectLimitReachedError';
     }
 }
+export class MaxCallsToUniqueContractClassIdsError extends SideEffectLimitReachedError {
+    constructor(){
+        super('contract calls to unique class IDs', MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS);
+        this.name = 'MaxCallsToUniqueContractClassIdsError';
+    }
+}
+export class NullifierLimitReachedError extends SideEffectLimitReachedError {
+    constructor(){
+        super('nullifier', MAX_NULLIFIERS_PER_TX);
+        this.name = 'NullifierLimitReachedError';
+    }
+}
+export class NoteHashLimitReachedError extends SideEffectLimitReachedError {
+    constructor(){
+        super('note hash', MAX_NOTE_HASHES_PER_TX);
+        this.name = 'NoteHashLimitReachedError';
+    }
+}
+export class L2ToL1MessageLimitReachedError extends SideEffectLimitReachedError {
+    constructor(){
+        super('l2 to l1 message', MAX_L2_TO_L1_MSGS_PER_TX);
+        this.name = 'L2ToL1MessageLimitReachedError';
+    }
+}
+export class NullifierCollisionError extends SideEffectError {
+    constructor(message){
+        super(`Nullifier collision: ${message}`);
+        this.name = 'NullifierCollisionError';
+    }
+}
+/**
+ * Any error that can be thrown during side effect reads in public.
+ * Note: Thrown at state manager level and unknown by simulation, hence NOT considered
+ * CheckedPublicExecutionErrors. Currently only includes append-only tree reads.
+ */ export class SideEffectReadError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'SideEffectReadError';
+    }
+}
+export class IndexOutOfRangeError extends SideEffectReadError {
+    constructor(tree, index, limit){
+        super(`Attempting to read index ${index} of ${tree} tree with maximum ${limit} leaves`);
+        this.name = 'IndexOutOfRangeError';
+    }
+}
+export class NoteHashIndexOutOfRangeError extends IndexOutOfRangeError {
+    constructor(index){
+        super('note hash', index, NOTE_HASH_TREE_LEAF_COUNT);
+        this.name = 'NoteHashIndexOutOfRangeError';
+    }
+}
+export class L1ToL2MessageIndexOutOfRangeError extends IndexOutOfRangeError {
+    constructor(index){
+        super('l1 to l2 message', index, L1_TO_L2_MSG_TREE_LEAF_COUNT);
+        this.name = 'L1ToL2MessageIndexOutOfRangeError';
+    }
+}

package/dest/public/side_effect_trace.d.ts

@@ -1,13 +1,10 @@
 import { Fr } from '@aztec/foundation/fields';
-import { AvmCircuitPublicInputs, AvmExecutionHints, AvmPublicDataReadTreeHint, PublicDataUpdateRequest } from '@aztec/stdlib/avm';
+import { type LogLevel } from '@aztec/foundation/log';
+import { PublicDataUpdateRequest } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { type ContractClassWithCommitment, SerializableContractInstance } from '@aztec/stdlib/contract';
-import type { Gas, GasSettings } from '@aztec/stdlib/gas';
-import { NoteHash, Nullifier, PublicCallRequest } from '@aztec/stdlib/kernel';
-import { PublicLog } from '@aztec/stdlib/logs';
+import { NoteHash, Nullifier } from '@aztec/stdlib/kernel';
+import { DebugLog, PublicLog } from '@aztec/stdlib/logs';
 import { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
-import { NullifierLeafPreimage, PublicDataTreeLeafPreimage } from '@aztec/stdlib/trees';
-import type { GlobalVariables, TreeSnapshots } from '@aztec/stdlib/tx';
 import type { PublicSideEffectTraceInterface } from './side_effect_trace_interface.js';
 import { UniqueClassIds } from './unique_class_ids.js';
 /**
@@ -16,7 +13,6 @@ import { UniqueClassIds } from './unique_class_ids.js';
  * This struct is helpful for testing and checking array lengths.
  **/
 export type SideEffects = {
-    enqueuedCalls: PublicCallRequest[];
     publicDataWrites: PublicDataUpdateRequest[];
     noteHashes: NoteHash[];
     nullifiers: Nullifier[];
@@ -29,15 +25,14 @@ export declare class SideEffectArrayLengths {
     readonly noteHashes: number;
     readonly nullifiers: number;
     readonly l2ToL1Msgs: number;
-    readonly publicLogs: number;
-    constructor(publicDataWrites: number, protocolPublicDataWrites: number, noteHashes: number, nullifiers: number, l2ToL1Msgs: number, publicLogs: number);
+    readonly publicLogFields: number;
+    constructor(publicDataWrites: number, protocolPublicDataWrites: number, noteHashes: number, nullifiers: number, l2ToL1Msgs: number, publicLogFields: number);
     static empty(): SideEffectArrayLengths;
 }
 /**
  * Trace side effects for an enqueued public call's execution.
  */
 export declare class SideEffectTrace implements PublicSideEffectTraceInterface {
-    /** The counter of this trace's first side effect. */
     readonly startSideEffectCounter: number;
     /** 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.
@@ -45,10 +40,12 @@ export declare class SideEffectTrace implements PublicSideEffectTraceInterface {
     private readonly previousSideEffectArrayLengths;
     /** We need to track the set of class IDs used, to enforce limits. */
     private uniqueClassIds;
+    private writtenPublicDataSlots;
+    private debugLogs;
+    private debugLogMemoryReads;
     log: import("@aztec/foundation/log").Logger;
     /** The side effect counter increments with every call to the trace. */
     private sideEffectCounter;
-    private enqueuedCalls;
     private publicDataWrites;
     private protocolPublicDataWritesLength;
     private userPublicDataWritesLength;
@@ -56,7 +53,6 @@ export declare class SideEffectTrace implements PublicSideEffectTraceInterface {
     private nullifiers;
     private l2ToL1Messages;
     private publicLogs;
-    private avmCircuitHints;
     /** Make sure a forked trace is never merged twice. */
     private alreadyMergedIntoParent;
     constructor(
@@ -67,66 +63,24 @@ export declare class SideEffectTrace implements PublicSideEffectTraceInterface {
      */
     previousSideEffectArrayLengths?: SideEffectArrayLengths, 
     /** We need to track the set of class IDs used, to enforce limits. */
-    uniqueClassIds?: UniqueClassIds);
+    uniqueClassIds?: UniqueClassIds, writtenPublicDataSlots?: Set<string>, debugLogs?: DebugLog[], debugLogMemoryReads?: number);
     fork(): SideEffectTrace;
     merge(forkedTrace: this, reverted?: boolean): void;
-    private mergeHints;
     getCounter(): number;
     private incrementSideEffectCounter;
     getNoteHashCount(): number;
-    tracePublicStorageRead(contractAddress: AztecAddress, slot: Fr, value: Fr, leafPreimage?: PublicDataTreeLeafPreimage, leafIndex?: Fr, path?: Fr[]): void;
-    tracePublicStorageWrite(contractAddress: AztecAddress, slot: Fr, 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(noteHash: Fr, leafIndex?: Fr, path?: Fr[]): void;
-    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;
+    tracePublicStorageWrite(contractAddress: AztecAddress, slot: Fr, value: Fr, protocolWrite: boolean): Promise<void>;
+    private computePublicDataSlotKey;
+    isStorageCold(contractAddress: AztecAddress, slot: Fr): boolean;
+    traceNewNoteHash(noteHash: 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;
-    /**
-     * 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: PublicCallRequest, 
-    /** The call's calldata */
-    calldata: Fr[], 
-    /** Did the call revert? */
-    _reverted: boolean): void;
+    traceDebugLog(contractAddress: AztecAddress, level: LogLevel, message: string, fields: Fr[]): void;
+    getDebugLogs(): DebugLog[];
+    getDebugLogMemoryReads(): number;
+    traceDebugLogMemoryReads(memoryReads: number): void;
+    traceGetContractClass(contractClassId: Fr, exists: boolean): void;
     getSideEffects(): SideEffects;
-    toAvmCircuitPublicInputs(
-    /** Globals. */
-    globalVariables: GlobalVariables, 
-    /** Start tree snapshots. */
-    startTreeSnapshots: TreeSnapshots, 
-    /** Gas used at start of TX. */
-    startGasUsed: Gas, 
-    /** How much gas was available for this public execution. */
-    gasLimits: GasSettings, 
-    /** Address of the fee payer. */
-    feePayer: AztecAddress, 
-    /** Call requests for setup phase. */
-    publicSetupCallRequests: PublicCallRequest[], 
-    /** Call requests for app logic phase. */
-    publicAppLogicCallRequests: PublicCallRequest[], 
-    /** Call request for teardown phase. */
-    publicTeardownCallRequest: PublicCallRequest, 
-    /** End tree snapshots. */
-    endTreeSnapshots: TreeSnapshots, 
-    /**
-     * Gas used by the whole transaction, assuming entire teardown limit is used.
-     * This is the gas used when computing transaction fee.
-     */
-    endGasUsed: Gas, 
-    /** Transaction fee. */
-    transactionFee: Fr, 
-    /** The call's results */
-    reverted: boolean): AvmCircuitPublicInputs;
-    getPublicLogs(): PublicLog[];
-    getAvmCircuitHints(): AvmExecutionHints;
-    private getAvmAccumulatedData;
 }
-//# sourceMappingURL=side_effect_trace.d.ts.map
+//# sourceMappingURL=data:application/json;base64,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

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

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

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 { 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));
-    }
 }