@aztec/simulator 0.0.0-test.0

package/dest/public/side_effect_trace.js

@@ -0,0 +1,249 @@
+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 { 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 { 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 { strict as assert } from 'assert';
+import { 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){
+        this.publicDataWrites = publicDataWrites;
+        this.protocolPublicDataWrites = protocolPublicDataWrites;
+        this.noteHashes = noteHashes;
+        this.nullifiers = nullifiers;
+        this.l2ToL1Msgs = l2ToL1Msgs;
+        this.publicLogs = publicLogs;
+    }
+    static empty() {
+        return new this(0, 0, 0, 0, 0, 0);
+    }
+}
+/**
+ * Trace side effects for an enqueued public call's execution.
+ */ export class SideEffectTrace {
+    startSideEffectCounter;
+    previousSideEffectArrayLengths;
+    uniqueClassIds;
+    log;
+    /** The side effect counter increments with every call to the trace. */ sideEffectCounter;
+    enqueuedCalls;
+    publicDataWrites;
+    protocolPublicDataWritesLength;
+    userPublicDataWritesLength;
+    noteHashes;
+    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()){
+        this.startSideEffectCounter = startSideEffectCounter;
+        this.previousSideEffectArrayLengths = previousSideEffectArrayLengths;
+        this.uniqueClassIds = uniqueClassIds;
+        this.log = createLogger('simulator:side_effect_trace');
+        this.enqueuedCalls = [];
+        this.publicDataWrites = [];
+        this.protocolPublicDataWritesLength = 0;
+        this.userPublicDataWritesLength = 0;
+        this.noteHashes = [];
+        this.nullifiers = [];
+        this.l2ToL1Messages = [];
+        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());
+    }
+    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);
+        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.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;
+    }
+    incrementSideEffectCounter() {
+        this.sideEffectCounter++;
+    }
+    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);
+            }
+            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();
+    }
+    // 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})`);
+    }
+    traceNewNoteHash(noteHash, leafIndex = Fr.zero(), path = emptyNoteHashPath()) {
+        if (this.noteHashes.length + this.previousSideEffectArrayLengths.noteHashes >= MAX_NOTE_HASHES_PER_TX) {
+            throw new SideEffectLimitReachedError('note hash', MAX_NOTE_HASHES_PER_TX);
+        }
+        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()) {
+        if (this.nullifiers.length + this.previousSideEffectArrayLengths.nullifiers >= MAX_NULLIFIERS_PER_TX) {
+            throw new SideEffectLimitReachedError('nullifier', MAX_NULLIFIERS_PER_TX);
+        }
+        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.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);
+        }
+        const recipientAddress = EthAddress.fromField(recipient);
+        this.l2ToL1Messages.push(new L2ToL1Message(recipientAddress, content, this.sideEffectCounter).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 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();
+    }
+    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())) {
+            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);
+            }
+            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,
+            l2ToL1Msgs: this.l2ToL1Messages,
+            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

@@ -0,0 +1,34 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { AvmPublicDataReadTreeHint } from '@aztec/stdlib/avm';
+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';
+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;
+    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;
+    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[];
+}
+//# sourceMappingURL=side_effect_trace_interface.d.ts.map

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

@@ -0,0 +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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"}

package/dest/public/side_effect_trace_interface.js

@@ -0,0 +1 @@
+export { };

package/dest/public/tx_contract_cache.d.ts

@@ -0,0 +1,41 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+/**
+ * A cache for contract classes and instances for a single transaction.
+ * Useful for tracking/retrieving contracts for a tx while leaving
+ * the option to clear them if the tx is reverted.
+ */
+export declare class TxContractCache {
+    private instanceCache;
+    private classCache;
+    /**
+     * Add a contract instance to the cache
+     */
+    addInstance(address: AztecAddress, instance: ContractInstanceWithAddress): void;
+    /**
+     * Add a contract class to the cache
+     */
+    addClass(classId: Fr, contractClass: ContractClassPublic): void;
+    /**
+     * Get a contract instance from the cache
+     */
+    getInstance(address: AztecAddress): ContractInstanceWithAddress | undefined;
+    /**
+     * Get a contract class from the cache
+     */
+    getClass(classId: Fr): ContractClassPublic | undefined;
+    /**
+     * Check if the cache has a contract class
+     */
+    hasClass(classId: Fr): boolean;
+    /**
+     * Clear all entries from the cache
+     */
+    clear(): void;
+    /**
+     * Merge another cache into this one
+     */
+    mergeFrom(other: TxContractCache): void;
+}
+//# sourceMappingURL=tx_contract_cache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tx_contract_cache.d.ts","sourceRoot":"","sources":["../../src/public/tx_contract_cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAE/F;;;;GAIG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,aAAa,CAAkD;IACvE,OAAO,CAAC,UAAU,CAA0C;IAE5D;;OAEG;IACI,WAAW,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,2BAA2B,GAAG,IAAI;IAItF;;OAEG;IACI,QAAQ,CAAC,OAAO,EAAE,EAAE,EAAE,aAAa,EAAE,mBAAmB,GAAG,IAAI;IAItE;;OAEG;IACI,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,2BAA2B,GAAG,SAAS;IAIlF;;OAEG;IACI,QAAQ,CAAC,OAAO,EAAE,EAAE,GAAG,mBAAmB,GAAG,SAAS;IAI7D;;OAEG;IACI,QAAQ,CAAC,OAAO,EAAE,EAAE,GAAG,OAAO;IAIrC;;OAEG;IACI,KAAK,IAAI,IAAI;IAKpB;;OAEG;IACI,SAAS,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI;CAS/C"}

package/dest/public/tx_contract_cache.js

@@ -0,0 +1,49 @@
+/**
+ * A cache for contract classes and instances for a single transaction.
+ * Useful for tracking/retrieving contracts for a tx while leaving
+ * the option to clear them if the tx is reverted.
+ */ export class TxContractCache {
+    instanceCache = new Map();
+    classCache = new Map();
+    /**
+   * Add a contract instance to the cache
+   */ addInstance(address, instance) {
+        this.instanceCache.set(address.toString(), instance);
+    }
+    /**
+   * Add a contract class to the cache
+   */ addClass(classId, contractClass) {
+        this.classCache.set(classId.toString(), contractClass);
+    }
+    /**
+   * Get a contract instance from the cache
+   */ getInstance(address) {
+        return this.instanceCache.get(address.toString());
+    }
+    /**
+   * Get a contract class from the cache
+   */ getClass(classId) {
+        return this.classCache.get(classId.toString());
+    }
+    /**
+   * Check if the cache has a contract class
+   */ hasClass(classId) {
+        return this.classCache.has(classId.toString());
+    }
+    /**
+   * Clear all entries from the cache
+   */ clear() {
+        this.instanceCache.clear();
+        this.classCache.clear();
+    }
+    /**
+   * Merge another cache into this one
+   */ mergeFrom(other) {
+        other.instanceCache.forEach((value, key)=>{
+            this.instanceCache.set(key, value);
+        });
+        other.classCache.forEach((value, key)=>{
+            this.classCache.set(key, value);
+        });
+    }
+}

package/dest/public/unique_class_ids.d.ts

@@ -0,0 +1,37 @@
+/**
+ * A class manage a de-duplicated set of class IDs that errors if you try to add a duplicate.
+ * Useful for bytecode retrieval hints to avoid duplicates in parent trace & grandparent trace....
+ */
+export declare class UniqueClassIds {
+    private readonly parent?;
+    private readonly classIds;
+    constructor(parent?: UniqueClassIds | undefined);
+    /**
+     * Create a fork that references this one as its parent
+     */
+    fork(): UniqueClassIds;
+    /**
+     * Check for a class ID here or in parent's (recursively).
+     *
+     * @param classId - the contract class ID (as a string) to check
+     * @returns boolean: whether the class ID is here
+     */
+    has(classId: string): boolean;
+    /**
+     * Get the total number of classIds
+     */
+    size(): number;
+    /**
+     * Add a class ID (if not already present) to the set.
+     *
+     * @param classId - the contract class ID (as a string)
+     */
+    add(classId: string): void;
+    /**
+     * Merge in another set of unique class IDs into this one, but fail on duplicates.
+     *
+     * @param incoming: other unique class IDs
+     */
+    acceptAndMerge(incoming: UniqueClassIds): void;
+}
+//# sourceMappingURL=unique_class_ids.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unique_class_ids.d.ts","sourceRoot":"","sources":["../../src/public/unique_class_ids.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,qBAAa,cAAc;IAGb,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IAFpC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0B;gBAEtB,MAAM,CAAC,4BAAgB;IAEpD;;OAEG;IACI,IAAI;IAIX;;;;;OAKG;IACI,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAWpC;;OAEG;IACI,IAAI,IAAI,MAAM;IAIrB;;;;OAIG;IACI,GAAG,CAAC,OAAO,EAAE,MAAM;IAW1B;;;;OAIG;IACI,cAAc,CAAC,QAAQ,EAAE,cAAc;CAc/C"}

package/dest/public/unique_class_ids.js

@@ -0,0 +1,61 @@
+import { MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS } from '@aztec/constants';
+import { strict as assert } from 'assert';
+/**
+ * A class manage a de-duplicated set of class IDs that errors if you try to add a duplicate.
+ * Useful for bytecode retrieval hints to avoid duplicates in parent trace & grandparent trace....
+ */ export class UniqueClassIds {
+    parent;
+    classIds;
+    constructor(parent){
+        this.parent = parent;
+        this.classIds = new Set();
+    }
+    /**
+   * Create a fork that references this one as its parent
+   */ fork() {
+        return new UniqueClassIds(/*parent=*/ this);
+    }
+    /**
+   * Check for a class ID here or in parent's (recursively).
+   *
+   * @param classId - the contract class ID (as a string) to check
+   * @returns boolean: whether the class ID is here
+   */ has(classId) {
+        // First try check this' classIds
+        let here = this.classIds.has(classId);
+        // Then try parent's
+        if (!here && this.parent) {
+            // Note: this will recurse to grandparent/etc until we reach top or find it
+            here = this.parent.has(classId);
+        }
+        return here;
+    }
+    /**
+   * Get the total number of classIds
+   */ size() {
+        return this.classIds.size + (this.parent ? this.parent.size() : 0);
+    }
+    /**
+   * Add a class ID (if not already present) to the set.
+   *
+   * @param classId - the contract class ID (as a string)
+   */ add(classId) {
+        assert(!this.has(classId), `Bug! Tried to add duplicate classId ${classId} to set of unique classIds.`);
+        if (!this.has(classId)) {
+            this.classIds.add(classId);
+            assert(this.size() <= MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS, `Bug! Surpassed limit (${MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS}) of unique contract class IDs used for bytecode retrievals.`);
+        }
+    }
+    /**
+   * Merge in another set of unique class IDs into this one, but fail on duplicates.
+   *
+   * @param incoming: other unique class IDs
+   */ acceptAndMerge(incoming) {
+        for (const classId of incoming.classIds.keys()){
+            assert(!this.has(classId), `Bug! Cannot merge classId ${classId} into set of unique classIds as it already exists.`);
+            this.classIds.add(classId);
+        }
+        // since set() has an assertion, and size() always checks parent, this should be impossible
+        assert(this.size() <= MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS, `Bug! Merging unique class Ids should never exceed the limit of ${MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS}.`);
+    }
+}

package/dest/public/utils.d.ts

@@ -0,0 +1,5 @@
+import type { PublicCallRequest } from '@aztec/stdlib/kernel';
+import { type PublicExecutionRequest, type Tx, TxExecutionPhase } from '@aztec/stdlib/tx';
+export declare function getExecutionRequestsByPhase(tx: Tx, phase: TxExecutionPhase): PublicExecutionRequest[];
+export declare function getCallRequestsByPhase(tx: Tx, phase: TxExecutionPhase): PublicCallRequest[];
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/public/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,KAAK,sBAAsB,EAAE,KAAK,EAAE,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAE1F,wBAAgB,2BAA2B,CAAC,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,gBAAgB,GAAG,sBAAsB,EAAE,CAarG;AAED,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,gBAAgB,GAAG,iBAAiB,EAAE,CAa3F"}

package/dest/public/utils.js

@@ -0,0 +1,35 @@
+import { TxExecutionPhase } from '@aztec/stdlib/tx';
+export function getExecutionRequestsByPhase(tx, phase) {
+    switch(phase){
+        case TxExecutionPhase.SETUP:
+            return tx.getNonRevertiblePublicExecutionRequests();
+        case TxExecutionPhase.APP_LOGIC:
+            return tx.getRevertiblePublicExecutionRequests();
+        case TxExecutionPhase.TEARDOWN:
+            {
+                const request = tx.getPublicTeardownExecutionRequest();
+                return request ? [
+                    request
+                ] : [];
+            }
+        default:
+            throw new Error(`Unknown phase: ${phase}`);
+    }
+}
+export function getCallRequestsByPhase(tx, phase) {
+    switch(phase){
+        case TxExecutionPhase.SETUP:
+            return tx.data.getNonRevertiblePublicCallRequests();
+        case TxExecutionPhase.APP_LOGIC:
+            return tx.data.getRevertiblePublicCallRequests();
+        case TxExecutionPhase.TEARDOWN:
+            {
+                const request = tx.data.getTeardownPublicCallRequest();
+                return request ? [
+                    request
+                ] : [];
+            }
+        default:
+            throw new Error(`Unknown phase: ${phase}`);
+    }
+}

package/dest/server.d.ts

@@ -0,0 +1,6 @@
+export * from './public/index.js';
+export { WASMSimulatorWithBlobs } from './private/providers/acvm_wasm_with_blobs.js';
+export { NativeACVMSimulator } from './private/providers/acvm_native.js';
+export { type SimulationProvider } from './private/providers/simulation_provider.js';
+export * from './common/index.js';
+//# sourceMappingURL=server.d.ts.map

package/dest/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,sBAAsB,EAAE,MAAM,6CAA6C,CAAC;AACrF,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,4CAA4C,CAAC;AACrF,cAAc,mBAAmB,CAAC"}

package/dest/server.js

@@ -0,0 +1,4 @@
+export * from './public/index.js';
+export { WASMSimulatorWithBlobs } from './private/providers/acvm_wasm_with_blobs.js';
+export { NativeACVMSimulator } from './private/providers/acvm_native.js';
+export * from './common/index.js';

package/dest/test/utils.d.ts

@@ -0,0 +1,13 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { L1ToL2Message } from '@aztec/stdlib/messaging';
+/**
+ * Test utility function to craft an L1 to L2 message.
+ * @param selector - The cross chain message selector.
+ * @param contentPreimage - The args after the selector.
+ * @param targetContract - The contract to consume the message.
+ * @param secret - The secret to unlock the message.
+ * @returns The L1 to L2 message.
+ */
+export declare const buildL1ToL2Message: (selector: string, contentPreimage: Fr[], targetContract: AztecAddress, secret: Fr, msgIndex: Fr | number) => Promise<L1ToL2Message>;
+//# sourceMappingURL=utils.d.ts.map

package/dest/test/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/test/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,EAAW,aAAa,EAAW,MAAM,yBAAyB,CAAC;AAE1E;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,aACnB,MAAM,mBACC,EAAE,EAAE,kBACL,YAAY,UACpB,EAAE,YACA,EAAE,GAAG,MAAM,2BAetB,CAAC"}

package/dest/test/utils.js

@@ -0,0 +1,22 @@
+import { sha256ToField } from '@aztec/foundation/crypto';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { computeSecretHash } from '@aztec/stdlib/hash';
+import { L1Actor, L1ToL2Message, L2Actor } from '@aztec/stdlib/messaging';
+/**
+ * Test utility function to craft an L1 to L2 message.
+ * @param selector - The cross chain message selector.
+ * @param contentPreimage - The args after the selector.
+ * @param targetContract - The contract to consume the message.
+ * @param secret - The secret to unlock the message.
+ * @returns The L1 to L2 message.
+ */ export const buildL1ToL2Message = async (selector, contentPreimage, targetContract, secret, msgIndex)=>{
+    // Write the selector into a buffer.
+    const selectorBuf = Buffer.from(selector, 'hex');
+    const content = sha256ToField([
+        selectorBuf,
+        ...contentPreimage
+    ]);
+    const secretHash = await computeSecretHash(secret);
+    return new L1ToL2Message(new L1Actor(EthAddress.random(), 1), new L2Actor(targetContract, 1), content, secretHash, new Fr(msgIndex));
+};