@aztec/simulator 0.0.0-test.0

package/dest/public/public_tx_simulator/public_tx_simulator.js

@@ -0,0 +1,334 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
+import { SimulationError } from '@aztec/stdlib/errors';
+import { NestedProcessReturnValues, TxExecutionPhase } from '@aztec/stdlib/tx';
+import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
+import { strict as assert } from 'assert';
+import { getPublicFunctionDebugName } from '../../common/debug_fn_name.js';
+import { AvmSimulator } from '../avm/index.js';
+import { NullifierCollisionError } from '../avm/journal/nullifiers.js';
+import { ExecutorMetrics } from '../executor_metrics.js';
+import { PublicTxContext } from './public_tx_context.js';
+export class PublicTxSimulator {
+    db;
+    worldStateDB;
+    globalVariables;
+    doMerkleOperations;
+    skipFeeEnforcement;
+    metrics;
+    log;
+    constructor(db, worldStateDB, globalVariables, doMerkleOperations = false, skipFeeEnforcement = false, telemetryClient = getTelemetryClient()){
+        this.db = db;
+        this.worldStateDB = worldStateDB;
+        this.globalVariables = globalVariables;
+        this.doMerkleOperations = doMerkleOperations;
+        this.skipFeeEnforcement = skipFeeEnforcement;
+        this.log = createLogger(`simulator:public_tx_simulator`);
+        this.metrics = new ExecutorMetrics(telemetryClient, 'PublicTxSimulator');
+    }
+    get tracer() {
+        return this.metrics.tracer;
+    }
+    /**
+   * Simulate a transaction's public portion including all of its phases.
+   * @param tx - The transaction to simulate.
+   * @returns The result of the transaction's public execution.
+   */ async simulate(tx) {
+        try {
+            const startTime = process.hrtime.bigint();
+            const txHash = await tx.getTxHash();
+            this.log.debug(`Simulating ${tx.enqueuedPublicFunctionCalls.length} public calls for tx ${txHash}`, {
+                txHash
+            });
+            const context = await PublicTxContext.create(this.db, this.worldStateDB, tx, this.globalVariables, this.doMerkleOperations);
+            const nonRevertStart = process.hrtime.bigint();
+            await this.insertNonRevertiblesFromPrivate(context);
+            // add new contracts to the contracts db so that their functions may be found and called
+            // TODO(#6464): Should we allow emitting contracts in the private setup phase?
+            await this.worldStateDB.addNewNonRevertibleContracts(tx);
+            const nonRevertEnd = process.hrtime.bigint();
+            this.metrics.recordPrivateEffectsInsertion(Number(nonRevertEnd - nonRevertStart) / 1_000, 'non-revertible');
+            const processedPhases = [];
+            if (context.hasPhase(TxExecutionPhase.SETUP)) {
+                const setupResult = await this.simulateSetupPhase(context);
+                processedPhases.push(setupResult);
+            }
+            const revertStart = process.hrtime.bigint();
+            const success = await this.insertRevertiblesFromPrivate(context);
+            if (success) {
+                // add new contracts to the contracts db so that their functions may be found and called
+                await this.worldStateDB.addNewRevertibleContracts(tx);
+                const revertEnd = process.hrtime.bigint();
+                this.metrics.recordPrivateEffectsInsertion(Number(revertEnd - revertStart) / 1_000, 'revertible');
+                // Only proceed with app logic if there was no revert during revertible insertion
+                if (context.hasPhase(TxExecutionPhase.APP_LOGIC)) {
+                    const appLogicResult = await this.simulateAppLogicPhase(context);
+                    processedPhases.push(appLogicResult);
+                }
+            } else {
+                this.log.debug(`Revertible insertions failed. Skipping app logic.`);
+            }
+            if (context.hasPhase(TxExecutionPhase.TEARDOWN)) {
+                const teardownResult = await this.simulateTeardownPhase(context);
+                processedPhases.push(teardownResult);
+            }
+            await context.halt();
+            await this.payFee(context);
+            const endStateReference = await this.db.getStateReference();
+            const avmProvingRequest = await context.generateProvingRequest(endStateReference);
+            const revertCode = context.getFinalRevertCode();
+            if (!revertCode.isOK()) {
+                await tx.filterRevertedLogs();
+            }
+            // Commit contracts from this TX to the block-level cache and clear tx cache
+            // If the tx reverted, only commit non-revertible contracts
+            // NOTE: You can't create contracts in public, so this is only relevant for private-created contracts
+            this.worldStateDB.commitContractsForTx(/*onlyNonRevertibles=*/ !revertCode.isOK());
+            const endTime = process.hrtime.bigint();
+            this.log.debug(`Public TX simulator took ${Number(endTime - startTime) / 1_000_000} ms\n`);
+            return {
+                avmProvingRequest,
+                gasUsed: {
+                    totalGas: context.getActualGasUsed(),
+                    teardownGas: context.teardownGasUsed,
+                    publicGas: context.getActualPublicGasUsed(),
+                    billedGas: context.getTotalGasUsed()
+                },
+                revertCode,
+                revertReason: context.revertReason,
+                processedPhases: processedPhases
+            };
+        } finally{
+            // Make sure there are no new contracts in the tx-level cache.
+            // They should either be committed to block-level cache or cleared.
+            this.worldStateDB.clearContractsForTx();
+        }
+    }
+    /**
+   * Simulate the setup phase of a transaction's public execution.
+   * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
+   * @returns The phase result.
+   */ async simulateSetupPhase(context) {
+        return await this.simulatePhase(TxExecutionPhase.SETUP, context);
+    }
+    /**
+   * Simulate the app logic phase of a transaction's public execution.
+   * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
+   * @returns The phase result.
+   */ async simulateAppLogicPhase(context) {
+        assert(context.state.isForked(), 'App logic phase should operate with forked state.');
+        const result = await this.simulatePhase(TxExecutionPhase.APP_LOGIC, context);
+        if (result.reverted) {
+            // Drop the currently active forked state manager and rollback to end of setup.
+            await context.state.discardForkedState();
+        } else {
+            if (!context.hasPhase(TxExecutionPhase.TEARDOWN)) {
+                // Nothing to do after this (no teardown), so merge state updates now instead of letting teardown handle it.
+                await context.state.mergeForkedState();
+            }
+        }
+        return result;
+    }
+    /**
+   * Simulate the teardown phase of a transaction's public execution.
+   * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
+   * @returns The phase result.
+   */ async simulateTeardownPhase(context) {
+        if (!context.state.isForked()) {
+            // If state isn't forked (app logic reverted), fork now
+            // so we can rollback to the end of setup if teardown reverts.
+            await context.state.fork();
+        }
+        const result = await this.simulatePhase(TxExecutionPhase.TEARDOWN, context);
+        if (result.reverted) {
+            // Drop the currently active forked state manager and rollback to end of setup.
+            await context.state.discardForkedState();
+        } else {
+            // Merge state updates from teardown,
+            await context.state.mergeForkedState();
+        }
+        return result;
+    }
+    /**
+   * Simulate a phase of a transaction's public execution.
+   * @param phase - The current phase
+   * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
+   * @returns The phase result.
+   */ async simulatePhase(phase, context) {
+        const callRequests = context.getCallRequestsForPhase(phase);
+        const executionRequests = context.getExecutionRequestsForPhase(phase);
+        this.log.debug(`Processing phase ${TxExecutionPhase[phase]} for tx ${context.txHash}`, {
+            txHash: context.txHash.toString(),
+            phase: TxExecutionPhase[phase],
+            callRequests: callRequests.length,
+            executionRequests: executionRequests.length
+        });
+        const returnValues = [];
+        let reverted = false;
+        let revertReason;
+        const phaseTimer = new Timer();
+        for(let i = callRequests.length - 1; i >= 0; i--){
+            if (reverted) {
+                break;
+            }
+            const callRequest = callRequests[i];
+            const executionRequest = executionRequests[i];
+            const enqueuedCallResult = await this.simulateEnqueuedCall(phase, context, callRequest, executionRequest);
+            returnValues.push(new NestedProcessReturnValues(enqueuedCallResult.output));
+            if (enqueuedCallResult.reverted) {
+                reverted = true;
+                revertReason = enqueuedCallResult.revertReason;
+            }
+        }
+        return {
+            phase,
+            durationMs: phaseTimer.ms(),
+            returnValues,
+            reverted,
+            revertReason
+        };
+    }
+    /**
+   * Simulate an enqueued public call.
+   * @param phase - The current phase of public execution
+   * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
+   * @param callRequest - The enqueued call to execute
+   * @param executionRequest - The execution request (includes args)
+   * @returns The result of execution.
+   */ async simulateEnqueuedCall(phase, context, callRequest, executionRequest) {
+        const stateManager = context.state.getActiveStateManager();
+        const address = executionRequest.callContext.contractAddress;
+        const fnName = await getPublicFunctionDebugName(this.worldStateDB, address, executionRequest.args);
+        const allocatedGas = context.getGasLeftAtPhase(phase);
+        const result = await this.simulateEnqueuedCallInternal(context.state.getActiveStateManager(), executionRequest, allocatedGas, /*transactionFee=*/ context.getTransactionFee(phase), fnName);
+        const gasUsed = allocatedGas.sub(result.gasLeft); // by enqueued call
+        context.consumeGas(phase, gasUsed);
+        this.log.debug(`Simulated enqueued public call (${fnName}) consumed ${gasUsed.l2Gas} L2 gas ending with ${result.gasLeft.l2Gas} L2 gas left.`);
+        stateManager.traceEnqueuedCall(callRequest, executionRequest.args, result.reverted);
+        if (result.reverted) {
+            const culprit = `${executionRequest.callContext.contractAddress}:${executionRequest.callContext.functionSelector}`;
+            context.revert(phase, result.revertReason, culprit); // throws if in setup (non-revertible) phase
+        }
+        return result;
+    }
+    /**
+   * Simulate an enqueued public call, without modifying the context (PublicTxContext).
+   * Resulting modifications to the context can be applied by the caller.
+   *
+   * This function can be mocked for testing to skip actual AVM simulation
+   * while still simulating phases and generating a proving request.
+   *
+   * @param stateManager - The state manager for AvmSimulation
+   * @param context - The context of the currently executing public transaction portion
+   * @param executionRequest - The execution request (includes args)
+   * @param allocatedGas - The gas allocated to the enqueued call
+   * @param fnName - The name of the function
+   * @returns The result of execution.
+   */ async simulateEnqueuedCallInternal(stateManager, executionRequest, allocatedGas, transactionFee, fnName) {
+        const address = executionRequest.callContext.contractAddress;
+        const sender = executionRequest.callContext.msgSender;
+        this.log.debug(`Executing enqueued public call to external function ${fnName}@${address} with ${allocatedGas.l2Gas} allocated L2 gas.`);
+        const timer = new Timer();
+        const simulator = await AvmSimulator.create(stateManager, address, sender, transactionFee, this.globalVariables, executionRequest.callContext.isStaticCall, executionRequest.args, allocatedGas);
+        const avmCallResult = await simulator.execute();
+        const result = avmCallResult.finalize();
+        this.log.verbose(result.reverted ? `Simulation of enqueued public call ${fnName} reverted with reason ${result.revertReason}.` : `Simulation of enqueued public call ${fnName} completed successfully.`, {
+            eventName: 'avm-simulation',
+            appCircuitName: fnName,
+            duration: timer.ms()
+        });
+        if (result.reverted) {
+            this.metrics.recordFunctionSimulationFailure();
+        } else {
+            this.metrics.recordFunctionSimulation(timer.ms(), allocatedGas.sub(result.gasLeft).l2Gas, fnName);
+        }
+        return result;
+    }
+    /**
+   * Insert the non-revertible accumulated data from private into the public state.
+   */ async insertNonRevertiblesFromPrivate(context) {
+        const stateManager = context.state.getActiveStateManager();
+        try {
+            await stateManager.writeSiloedNullifiersFromPrivate(context.nonRevertibleAccumulatedDataFromPrivate.nullifiers);
+        } catch (e) {
+            if (e instanceof NullifierCollisionError) {
+                throw new NullifierCollisionError(`Nullifier collision encountered when inserting non-revertible nullifiers from private.\nDetails: ${e.message}\nStack:${e.stack}`);
+            }
+        }
+        for (const noteHash of context.nonRevertibleAccumulatedDataFromPrivate.noteHashes){
+            if (!noteHash.isEmpty()) {
+                await stateManager.writeUniqueNoteHash(noteHash);
+            }
+        }
+    }
+    /**
+   * Insert the revertible accumulated data from private into the public state.
+   * Start by forking state so we can rollback to the end of setup if app logic or teardown reverts.
+   */ async insertRevertiblesFromPrivate(context) {
+        // Fork the state manager so we can rollback to end of setup if app logic reverts.
+        await context.state.fork();
+        const stateManager = context.state.getActiveStateManager();
+        try {
+            await stateManager.writeSiloedNullifiersFromPrivate(context.revertibleAccumulatedDataFromPrivate.nullifiers);
+        } catch (e) {
+            if (e instanceof NullifierCollisionError) {
+                // Instead of throwing, revert the app_logic phase
+                context.revert(TxExecutionPhase.APP_LOGIC, new SimulationError(`Nullifier collision encountered when inserting revertible nullifiers from private\nDetails: ${e.message}\nError stack: ${e.stack}`, []), /*culprit=*/ 'insertRevertiblesFromPrivate');
+                return /*success=*/ false;
+            } else {
+                throw e;
+            }
+        }
+        for (const noteHash of context.revertibleAccumulatedDataFromPrivate.noteHashes){
+            if (!noteHash.isEmpty()) {
+                // Revertible note hashes from private are not hashed with nonce, since private can't know their final position, only we can.
+                await stateManager.writeSiloedNoteHash(noteHash);
+            }
+        }
+        return /*success=*/ true;
+    }
+    async payFee(context) {
+        const txFee = context.getTransactionFee(TxExecutionPhase.TEARDOWN);
+        if (context.feePayer.isZero()) {
+            this.log.debug(`No one is paying the fee of ${txFee.toBigInt()}`);
+            return;
+        }
+        const feeJuiceAddress = ProtocolContractAddress.FeeJuice;
+        const balanceSlot = await computeFeePayerBalanceStorageSlot(context.feePayer);
+        this.log.debug(`Deducting ${txFee.toBigInt()} balance in Fee Juice for ${context.feePayer}`);
+        const stateManager = context.state.getActiveStateManager();
+        let currentBalance = await stateManager.readStorage(feeJuiceAddress, balanceSlot);
+        // We allow to fake the balance of the fee payer to allow fee estimation
+        // When mocking the balance of the fee payer, the circuit should not be able to prove the simulation
+        if (currentBalance.lt(txFee)) {
+            if (!this.skipFeeEnforcement) {
+                throw new Error(`Not enough balance for fee payer to pay for transaction (got ${currentBalance.toBigInt()} needs ${txFee.toBigInt()})`);
+            } else {
+                currentBalance = txFee;
+            }
+        }
+        const updatedBalance = currentBalance.sub(txFee);
+        await stateManager.writeStorage(feeJuiceAddress, balanceSlot, updatedBalance, true);
+    }
+}
+_ts_decorate([
+    trackSpan('PublicTxSimulator.simulateEnqueuedCall', (phase, context, _callRequest, executionRequest)=>({
+            [Attributes.TX_HASH]: context.txHash.toString(),
+            [Attributes.TARGET_ADDRESS]: executionRequest.callContext.contractAddress.toString(),
+            [Attributes.SENDER_ADDRESS]: executionRequest.callContext.msgSender.toString(),
+            [Attributes.SIMULATOR_PHASE]: TxExecutionPhase[phase].toString()
+        }))
+], PublicTxSimulator.prototype, "simulateEnqueuedCall", null);
+_ts_decorate([
+    trackSpan('PublicTxSimulator.simulateEnqueuedCallInternal', (_stateManager, _executionRequest, _allocatedGas, _transactionFee, fnName)=>({
+            [Attributes.APP_CIRCUIT_NAME]: fnName
+        }))
+], PublicTxSimulator.prototype, "simulateEnqueuedCallInternal", null);

package/dest/public/side_effect_errors.d.ts

@@ -0,0 +1,4 @@
+export declare class SideEffectLimitReachedError extends Error {
+    constructor(sideEffectType: string, limit: number);
+}
+//# sourceMappingURL=side_effect_errors.d.ts.map

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

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

package/dest/public/side_effect_errors.js

@@ -0,0 +1,6 @@
+export class SideEffectLimitReachedError extends Error {
+    constructor(sideEffectType, limit){
+        super(`Reached the limit (${limit}) on number of '${sideEffectType}' per tx`);
+        this.name = 'SideEffectLimitReachedError';
+    }
+}

package/dest/public/side_effect_trace.d.ts

@@ -0,0 +1,132 @@
+import { Fr } from '@aztec/foundation/fields';
+import { AvmCircuitPublicInputs, AvmExecutionHints, AvmPublicDataReadTreeHint, 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 { 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';
+/**
+ * A struct containing just the side effects as regular arrays
+ * as opposed to "Tuple" arrays used by circuit public inputs.
+ * This struct is helpful for testing and checking array lengths.
+ **/
+export type SideEffects = {
+    enqueuedCalls: PublicCallRequest[];
+    publicDataWrites: PublicDataUpdateRequest[];
+    noteHashes: NoteHash[];
+    nullifiers: Nullifier[];
+    l2ToL1Msgs: ScopedL2ToL1Message[];
+    publicLogs: PublicLog[];
+};
+export declare class SideEffectArrayLengths {
+    readonly publicDataWrites: number;
+    readonly protocolPublicDataWrites: number;
+    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);
+    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.
+     */
+    private readonly previousSideEffectArrayLengths;
+    /** We need to track the set of class IDs used, to enforce limits. */
+    private uniqueClassIds;
+    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;
+    private noteHashes;
+    private nullifiers;
+    private l2ToL1Messages;
+    private publicLogs;
+    private avmCircuitHints;
+    /** Make sure a forked trace is never merged twice. */
+    private alreadyMergedIntoParent;
+    constructor(
+    /** The counter of this trace's first side effect. */
+    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.
+     */
+    previousSideEffectArrayLengths?: SideEffectArrayLengths, 
+    /** We need to track the set of class IDs used, to enforce limits. */
+    uniqueClassIds?: UniqueClassIds);
+    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;
+    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;
+    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

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

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