@aztec/simulator 0.71.0 → 0.73.0

package/src/public/public_db_sources.ts

@@ -1,4 +1,5 @@
 import {
+  ContractClassTxL2Logs,
   MerkleTreeId,
   type MerkleTreeReadOperations,
   type MerkleTreeWriteOperations,
@@ -44,16 +45,18 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
    * Add new contracts from a transaction
    * @param tx - The transaction to add contracts from.
    */
-  public addNewContracts(tx: Tx): Promise<void> {
+  public async addNewContracts(tx: Tx): Promise<void> {
     // Extract contract class and instance data from logs and add to cache for this block
     const logs = tx.contractClassLogs.unrollLogs();
-    logs
+    const contractClassRegisteredEvents = logs
       .filter(log => ContractClassRegisteredEvent.isContractClassRegisteredEvent(log.data))
-      .forEach(log => {
-        const event = ContractClassRegisteredEvent.fromLog(log.data);
+      .map(log => ContractClassRegisteredEvent.fromLog(log.data));
+    await Promise.all(
+      contractClassRegisteredEvents.map(async event => {
         this.log.debug(`Adding class ${event.contractClassId.toString()} to public execution contract cache`);
-        this.classCache.set(event.contractClassId.toString(), event.toContractClassPublic());
-      });
+        this.classCache.set(event.contractClassId.toString(), await event.toContractClassPublic());
+      }),
+    );
 
     // We store the contract instance deployed event log in private logs, contract_instance_deployer_contract/src/main.nr
     const contractInstanceEvents = tx.data
@@ -66,20 +69,26 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
       );
       this.instanceCache.set(e.address.toString(), e.toContractInstance());
     });
-
-    return Promise.resolve();
   }
 
   /**
    * Removes new contracts added from transactions
    * @param tx - The tx's contracts to be removed
+   * @param onlyRevertible - Whether to only remove contracts added from revertible contract class logs
    */
-  public removeNewContracts(tx: Tx): Promise<void> {
+  public removeNewContracts(tx: Tx, onlyRevertible: boolean = false): Promise<void> {
     // TODO(@spalladino): Can this inadvertently delete a valid contract added by another tx?
     // Let's say we have two txs adding the same contract on the same block. If the 2nd one reverts,
     // wouldn't that accidentally remove the contract added on the first one?
-    const logs = tx.contractClassLogs.unrollLogs();
-    logs
+    const contractClassLogs = onlyRevertible
+      ? tx.contractClassLogs
+          .filterScoped(
+            tx.data.forPublic!.revertibleAccumulatedData.contractClassLogsHashes,
+            ContractClassTxL2Logs.empty(),
+          )
+          .unrollLogs()
+      : tx.contractClassLogs.unrollLogs();
+    contractClassLogs
       .filter(log => ContractClassRegisteredEvent.isContractClassRegisteredEvent(log.data))
       .forEach(log => {
         const event = ContractClassRegisteredEvent.fromLog(log.data);
@@ -87,8 +96,10 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
       });
 
     // We store the contract instance deployed event log in private logs, contract_instance_deployer_contract/src/main.nr
-    const contractInstanceEvents = tx.data
-      .getNonEmptyPrivateLogs()
+    const privateLogs = onlyRevertible
+      ? tx.data.forPublic!.revertibleAccumulatedData.privateLogs.filter(l => !l.isEmpty())
+      : tx.data.getNonEmptyPrivateLogs();
+    const contractInstanceEvents = privateLogs
       .filter(log => ContractInstanceDeployedEvent.isContractInstanceDeployedEvent(log))
       .map(ContractInstanceDeployedEvent.fromLog);
     contractInstanceEvents.forEach(e => this.instanceCache.delete(e.address.toString()));
@@ -124,7 +135,7 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
       return undefined;
     }
 
-    const value = computePublicBytecodeCommitment(contractClass.packedBytecode);
+    const value = await computePublicBytecodeCommitment(contractClass.packedBytecode);
     this.bytecodeCommitmentCache.set(key, value);
     return value;
   }
@@ -171,7 +182,7 @@ export class WorldStateDB extends ContractsDataSourcePublicDB implements PublicS
    * @returns The current value in the storage slot.
    */
   public async storageRead(contract: AztecAddress, slot: Fr): Promise<Fr> {
-    const leafSlot = computePublicDataTreeLeafSlot(contract, slot).value;
+    const leafSlot = (await computePublicDataTreeLeafSlot(contract, slot)).toBigInt();
     const uncommitted = this.publicUncommittedWriteCache.get(leafSlot);
     if (uncommitted !== undefined) {
       return uncommitted;
@@ -195,10 +206,10 @@ export class WorldStateDB extends ContractsDataSourcePublicDB implements PublicS
    * @param newValue - The new value to store.
    * @returns The slot of the written leaf in the public data tree.
    */
-  public storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<bigint> {
-    const index = computePublicDataTreeLeafSlot(contract, slot).value;
+  public async storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<bigint> {
+    const index = (await computePublicDataTreeLeafSlot(contract, slot)).toBigInt();
     this.publicUncommittedWriteCache.set(index, newValue);
-    return Promise.resolve(index);
+    return index;
   }
 
   public async getNullifierMembershipWitnessAtLatestBlock(
@@ -243,7 +254,7 @@ export class WorldStateDB extends ContractsDataSourcePublicDB implements PublicS
       throw new Error(`No L1 to L2 message found for message hash ${messageHash.toString()}`);
     }
 
-    const messageNullifier = computeL1ToL2MessageNullifier(contractAddress, messageHash, secret);
+    const messageNullifier = await computeL1ToL2MessageNullifier(contractAddress, messageHash, secret);
     const nullifierIndex = await this.getNullifierIndex(messageNullifier);
 
     if (nullifierIndex !== undefined) {
@@ -348,7 +359,7 @@ export class WorldStateDB extends ContractsDataSourcePublicDB implements PublicS
 }
 
 export async function readPublicState(db: MerkleTreeReadOperations, contract: AztecAddress, slot: Fr): Promise<Fr> {
-  const leafSlot = computePublicDataTreeLeafSlot(contract, slot).toBigInt();
+  const leafSlot = (await computePublicDataTreeLeafSlot(contract, slot)).toBigInt();
 
   const lowLeafResult = await db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
   if (!lowLeafResult || !lowLeafResult.alreadyPresent) {

package/src/public/public_processor.ts

@@ -12,7 +12,6 @@ import {
 } from '@aztec/circuit-types';
 import {
   type AztecAddress,
-  type BlockHeader,
   type ContractDataSource,
   Fr,
   Gas,
@@ -60,12 +59,9 @@ export class PublicProcessorFactory {
    */
   public create(
     merkleTree: MerkleTreeWriteOperations,
-    maybeHistoricalHeader: BlockHeader | undefined,
     globalVariables: GlobalVariables,
     enforceFeePayment: boolean,
   ): PublicProcessor {
-    const historicalHeader = maybeHistoricalHeader ?? merkleTree.getInitialHeader();
-
     const worldStateDB = new WorldStateDB(merkleTree, this.contractDataSource);
     const publicTxSimulator = this.createPublicTxSimulator(
       merkleTree,
@@ -79,7 +75,6 @@ export class PublicProcessorFactory {
     return new PublicProcessor(
       merkleTree,
       globalVariables,
-      historicalHeader,
       worldStateDB,
       publicTxSimulator,
       this.dateProvider,
@@ -122,7 +117,6 @@ export class PublicProcessor implements Traceable {
   constructor(
     protected db: MerkleTreeWriteOperations,
     protected globalVariables: GlobalVariables,
-    protected historicalHeader: BlockHeader,
     protected worldStateDB: WorldStateDB,
     protected publicTxSimulator: PublicTxSimulator,
     private dateProvider: DateProvider,
@@ -143,7 +137,7 @@ export class PublicProcessor implements Traceable {
    * @returns The list of processed txs with their circuit simulation outputs.
    */
   public async process(
-    txs: Iterable<Tx>,
+    txs: Iterable<Tx> | AsyncIterable<Tx>,
     limits: {
       maxTransactions?: number;
       maxBlockSize?: number;
@@ -167,7 +161,7 @@ export class PublicProcessor implements Traceable {
     let totalPublicGas = new Gas(0, 0);
     let totalBlockGas = new Gas(0, 0);
 
-    for (const origTx of txs) {
+    for await (const origTx of txs) {
       // Only process up to the max tx limit
       if (maxTransactions !== undefined && result.length >= maxTransactions) {
         this.log.debug(`Stopping tx processing due to reaching the max tx limit.`);
@@ -181,7 +175,7 @@ export class PublicProcessor implements Traceable {
       }
 
       // Skip this tx if it'd exceed max block size
-      const txHash = origTx.getTxHash().toString();
+      const txHash = (await origTx.getTxHash()).toString();
       const preTxSizeInBytes = origTx.getEstimatedPrivateTxEffectsSize();
       if (maxBlockSize !== undefined && totalSizeInBytes + preTxSizeInBytes > maxBlockSize) {
         this.log.warn(`Skipping processing of tx ${txHash} sized ${preTxSizeInBytes} bytes due to block size limit`, {
@@ -211,19 +205,20 @@ export class PublicProcessor implements Traceable {
       // We validate the tx before processing it, to avoid unnecessary work.
       if (preprocessValidator) {
         const result = await preprocessValidator.validateTx(tx);
+        const txHash = await tx.getTxHash();
         if (result.result === 'invalid') {
           const reason = result.reason.join(', ');
-          this.log.warn(`Rejecting tx ${tx.getTxHash().toString()} due to pre-process validation fail: ${reason}`);
+          this.log.warn(`Rejecting tx ${txHash.toString()} due to pre-process validation fail: ${reason}`);
           failed.push({ tx, error: new Error(`Tx failed preprocess validation: ${reason}`) });
           returns.push(new NestedProcessReturnValues([]));
           continue;
         } else if (result.result === 'skipped') {
           const reason = result.reason.join(', ');
-          this.log.warn(`Skipping tx ${tx.getTxHash().toString()} due to pre-process validation: ${reason}`);
+          this.log.warn(`Skipping tx ${txHash.toString()} due to pre-process validation: ${reason}`);
           returns.push(new NestedProcessReturnValues([]));
           continue;
         } else {
-          this.log.trace(`Tx ${tx.getTxHash().toString()} is valid before processing.`);
+          this.log.trace(`Tx ${txHash.toString()} is valid before processing.`);
         }
       }
 
@@ -256,7 +251,7 @@ export class PublicProcessor implements Traceable {
             failed.push({ tx, error: new Error(`Tx failed post-process validation: ${reason}`) });
             continue;
           } else {
-            this.log.trace(`Tx ${tx.getTxHash().toString()} is valid post processing.`);
+            this.log.trace(`Tx ${(await tx.getTxHash()).toString()} is valid post processing.`);
           }
         }
 
@@ -286,7 +281,7 @@ export class PublicProcessor implements Traceable {
     const rate = duration > 0 ? totalPublicGas.l2Gas / duration : 0;
     this.metrics.recordAllTxs(totalPublicGas, rate);
 
-    this.log.info(`Processed ${result.length} succesful txs and ${failed.length} txs in ${duration}ms`, {
+    this.log.info(`Processed ${result.length} successful txs and ${failed.length} txs in ${duration}s`, {
       duration,
       rate,
       totalPublicGas,
@@ -297,7 +292,7 @@ export class PublicProcessor implements Traceable {
     return [result, failed, returns];
   }
 
-  @trackSpan('PublicProcessor.processTx', tx => ({ [Attributes.TX_HASH]: tx.getTxHash().toString() }))
+  @trackSpan('PublicProcessor.processTx', async tx => ({ [Attributes.TX_HASH]: (await tx.getTxHash()).toString() }))
   private async processTx(tx: Tx, deadline?: Date): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
     const [time, [processedTx, returnValues]] = await elapsed(() => this.processTxWithinDeadline(tx, deadline));
 
@@ -315,7 +310,7 @@ export class PublicProcessor implements Traceable {
         nullifierCount: processedTx.txEffect.nullifiers.length,
         noteHashCount: processedTx.txEffect.noteHashes.length,
         contractClassLogCount: processedTx.txEffect.contractClassLogs.getTotalLogCount(),
-        unencryptedLogCount: processedTx.txEffect.unencryptedLogs.getTotalLogCount(),
+        publicLogCount: processedTx.txEffect.publicLogs.length,
         privateLogCount: processedTx.txEffect.privateLogs.length,
         l2ToL1MessageCount: processedTx.txEffect.l2ToL1Msgs.length,
         durationMs: time,
@@ -378,17 +373,18 @@ export class PublicProcessor implements Traceable {
       return await processFn();
     }
 
+    const txHash = await tx.getTxHash();
     const timeout = +deadline - this.dateProvider.now();
-    this.log.debug(`Processing tx ${tx.getTxHash().toString()} within ${timeout}ms`, {
+    if (timeout <= 0) {
+      throw new PublicProcessorTimeoutError();
+    }
+
+    this.log.debug(`Processing tx ${txHash.toString()} within ${timeout}ms`, {
       deadline: deadline.toISOString(),
       now: new Date(this.dateProvider.now()).toISOString(),
-      txHash: tx.getTxHash().toString(),
+      txHash,
     });
 
-    if (timeout < 0) {
-      throw new PublicProcessorTimeoutError();
-    }
-
     return await executeTimeout(
       () => processFn(),
       timeout,
@@ -408,8 +404,8 @@ export class PublicProcessor implements Traceable {
     }
 
     const feeJuiceAddress = ProtocolContractAddress.FeeJuice;
-    const balanceSlot = computeFeePayerBalanceStorageSlot(feePayer);
-    const leafSlot = computeFeePayerBalanceLeafSlot(feePayer);
+    const balanceSlot = await computeFeePayerBalanceStorageSlot(feePayer);
+    const leafSlot = await computeFeePayerBalanceLeafSlot(feePayer);
 
     this.log.debug(`Deducting ${txFee.toBigInt()} balance in Fee Juice for ${feePayer}`);
 
@@ -427,8 +423,8 @@ export class PublicProcessor implements Traceable {
     return new PublicDataWrite(leafSlot, updatedBalance);
   }
 
-  @trackSpan('PublicProcessor.processPrivateOnlyTx', (tx: Tx) => ({
-    [Attributes.TX_HASH]: tx.getTxHash().toString(),
+  @trackSpan('PublicProcessor.processPrivateOnlyTx', async (tx: Tx) => ({
+    [Attributes.TX_HASH]: (await tx.getTxHash()).toString(),
   }))
   private async processPrivateOnlyTx(tx: Tx): Promise<[ProcessedTx, undefined]> {
     const gasFees = this.globalVariables.gasFees;
@@ -436,7 +432,7 @@ export class PublicProcessor implements Traceable {
 
     const feePaymentPublicDataWrite = await this.getFeePaymentPublicDataWrite(transactionFee, tx.data.feePayer);
 
-    const processedTx = makeProcessedTxFromPrivateOnlyTx(
+    const processedTx = await makeProcessedTxFromPrivateOnlyTx(
       tx,
       transactionFee,
       feePaymentPublicDataWrite,
@@ -452,8 +448,8 @@ export class PublicProcessor implements Traceable {
     return [processedTx, undefined];
   }
 
-  @trackSpan('PublicProcessor.processTxWithPublicCalls', tx => ({
-    [Attributes.TX_HASH]: tx.getTxHash().toString(),
+  @trackSpan('PublicProcessor.processTxWithPublicCalls', async tx => ({
+    [Attributes.TX_HASH]: (await tx.getTxHash()).toString(),
   }))
   private async processTxWithPublicCalls(tx: Tx): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
     const timer = new Timer();
@@ -485,7 +481,13 @@ export class PublicProcessor implements Traceable {
     const durationMs = timer.ms();
     this.metrics.recordTx(phaseCount, durationMs, gasUsed.publicGas);
 
-    const processedTx = makeProcessedTxFromTxWithPublicCalls(tx, avmProvingRequest, gasUsed, revertCode, revertReason);
+    const processedTx = await makeProcessedTxFromTxWithPublicCalls(
+      tx,
+      avmProvingRequest,
+      gasUsed,
+      revertCode,
+      revertReason,
+    );
 
     const returnValues = processedPhases.find(({ phase }) => phase === TxExecutionPhase.APP_LOGIC)?.returnValues ?? [];
 

package/src/public/public_tx_context.ts

@@ -18,26 +18,32 @@ import {
   type GasSettings,
   type GlobalVariables,
   MAX_L2_GAS_PER_TX_PUBLIC_PORTION,
+  MAX_L2_TO_L1_MSGS_PER_TX,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
+  MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+  PrivateToAvmAccumulatedData,
+  PrivateToAvmAccumulatedDataArrayLengths,
   type PrivateToPublicAccumulatedData,
-  type PublicCallRequest,
-  PublicCircuitPublicInputs,
+  PublicCallRequest,
+  PublicDataWrite,
   RevertCode,
   type StateReference,
   TreeSnapshots,
   computeTransactionFee,
   countAccumulatedItems,
+  mergeAccumulatedData,
 } from '@aztec/circuits.js';
+import { padArrayEnd } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import { assertLength } from '@aztec/foundation/serialize';
 
 import { strict as assert } from 'assert';
 import { inspect } from 'util';
 
 import { AvmPersistableStateManager } from '../avm/index.js';
-import { PublicEnqueuedCallSideEffectTrace, SideEffectArrayLengths } from './enqueued_call_side_effect_trace.js';
 import { type WorldStateDB } from './public_db_sources.js';
-import { generateAvmCircuitPublicInputs } from './transitional_adapters.js';
+import { SideEffectArrayLengths, SideEffectTrace } from './side_effect_trace.js';
 import { getCallRequestsByPhase, getExecutionRequestsByPhase } from './utils.js';
 
 /**
@@ -77,7 +83,7 @@ export class PublicTxContext {
     public readonly nonRevertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData,
     public readonly revertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData,
     public readonly feePayer: AztecAddress,
-    public trace: PublicEnqueuedCallSideEffectTrace, // FIXME(dbanks12): should be private
+    public trace: SideEffectTrace, // FIXME(dbanks12): should be private
   ) {
     this.log = createLogger(`simulator:public_tx_context`);
   }
@@ -97,19 +103,17 @@ export class PublicTxContext {
       /*noteHashes*/ 0,
       /*nullifiers=*/ 0,
       countAccumulatedItems(nonRevertibleAccumulatedDataFromPrivate.l2ToL1Msgs),
-      /*unencryptedLogsHashes*/ 0,
-    );
-    const enqueuedCallTrace = new PublicEnqueuedCallSideEffectTrace(
-      /*startSideEffectCounter=*/ 0,
-      previousAccumulatedDataArrayLengths,
+      /*publicLogs*/ 0,
     );
 
+    const trace = new SideEffectTrace(/*startSideEffectCounter=*/ 0, previousAccumulatedDataArrayLengths);
+
     const firstNullifier = nonRevertibleAccumulatedDataFromPrivate.nullifiers[0];
 
     // Transaction level state manager that will be forked for revertible phases.
     const txStateManager = await AvmPersistableStateManager.create(
       worldStateDB,
-      enqueuedCallTrace,
+      trace,
       doMerkleOperations,
       firstNullifier,
     );
@@ -120,7 +124,7 @@ export class PublicTxContext {
     const gasAllocatedToPublic = applyMaxToAvailableGas(gasSettings.gasLimits.sub(gasUsedByPrivate));
 
     return new PublicTxContext(
-      tx.getTxHash(),
+      await tx.getTxHash(),
       new PhaseStateManager(txStateManager),
       globalVariables,
       await db.getStateReference(),
@@ -136,7 +140,7 @@ export class PublicTxContext {
       tx.data.forPublic!.nonRevertibleAccumulatedData,
       tx.data.forPublic!.revertibleAccumulatedData,
       tx.data.feePayer,
-      enqueuedCallTrace,
+      trace,
     );
   }
 
@@ -319,13 +323,14 @@ export class PublicTxContext {
   /**
    * Generate the public inputs for the AVM circuit.
    */
-  private generateAvmCircuitPublicInputs(endStateReference: StateReference): AvmCircuitPublicInputs {
+  private async generateAvmCircuitPublicInputs(endStateReference: StateReference): Promise<AvmCircuitPublicInputs> {
     assert(this.halted, 'Can only get AvmCircuitPublicInputs after tx execution ends');
     const ephemeralTrees = this.state.getActiveStateManager().merkleTrees;
 
-    const noteHashTree = ephemeralTrees.getTreeSnapshot(MerkleTreeId.NOTE_HASH_TREE);
-    const nullifierTree = ephemeralTrees.getTreeSnapshot(MerkleTreeId.NULLIFIER_TREE);
-    const publicDataTree = ephemeralTrees.getTreeSnapshot(MerkleTreeId.PUBLIC_DATA_TREE);
+    const noteHashTree = await ephemeralTrees.getTreeSnapshot(MerkleTreeId.NOTE_HASH_TREE);
+    const nullifierTree = await ephemeralTrees.getTreeSnapshot(MerkleTreeId.NULLIFIER_TREE);
+    const publicDataTree = await ephemeralTrees.getTreeSnapshot(MerkleTreeId.PUBLIC_DATA_TREE);
+
     // Pad the note hash and nullifier trees
     const paddedNoteHashTreeSize =
       this.startStateReference.partial.noteHashTree.nextAvailableLeafIndex + MAX_NOTE_HASHES_PER_TX;
@@ -352,38 +357,92 @@ export class PublicTxContext {
       publicDataTree,
     );
 
-    return generateAvmCircuitPublicInputs(
-      this.trace,
+    const startTreeSnapshots = new TreeSnapshots(
+      this.startStateReference.l1ToL2MessageTree,
+      this.startStateReference.partial.noteHashTree,
+      this.startStateReference.partial.nullifierTree,
+      this.startStateReference.partial.publicDataTree,
+    );
+
+    const avmCircuitPublicInputs = this.trace.toAvmCircuitPublicInputs(
       this.globalVariables,
-      this.startStateReference,
+      startTreeSnapshots,
       /*startGasUsed=*/ this.gasUsedByPrivate,
       this.gasSettings,
       this.feePayer,
       this.setupCallRequests,
       this.appLogicCallRequests,
-      this.teardownCallRequests,
-      this.nonRevertibleAccumulatedDataFromPrivate,
-      this.revertibleAccumulatedDataFromPrivate,
+      /*teardownCallRequest=*/ this.teardownCallRequests.length
+        ? this.teardownCallRequests[0]
+        : PublicCallRequest.empty(),
       endTreeSnapshots,
       /*endGasUsed=*/ this.getTotalGasUsed(),
-      this.getTransactionFeeUnsafe(),
-      this.revertCode,
+      /*transactionFee=*/ this.getTransactionFeeUnsafe(),
+      /*reverted=*/ !this.revertCode.isOK(),
+    );
+
+    const getArrayLengths = (from: PrivateToPublicAccumulatedData) =>
+      new PrivateToAvmAccumulatedDataArrayLengths(
+        countAccumulatedItems(from.noteHashes),
+        countAccumulatedItems(from.nullifiers),
+        countAccumulatedItems(from.l2ToL1Msgs),
+      );
+    const convertAccumulatedData = (from: PrivateToPublicAccumulatedData) =>
+      new PrivateToAvmAccumulatedData(from.noteHashes, from.nullifiers, from.l2ToL1Msgs);
+    // Temporary overrides as these entries aren't yet populated in trace
+    avmCircuitPublicInputs.previousNonRevertibleAccumulatedDataArrayLengths = getArrayLengths(
+      this.nonRevertibleAccumulatedDataFromPrivate,
+    );
+    avmCircuitPublicInputs.previousRevertibleAccumulatedDataArrayLengths = getArrayLengths(
+      this.revertibleAccumulatedDataFromPrivate,
+    );
+    avmCircuitPublicInputs.previousNonRevertibleAccumulatedData = convertAccumulatedData(
+      this.nonRevertibleAccumulatedDataFromPrivate,
+    );
+    avmCircuitPublicInputs.previousRevertibleAccumulatedData = convertAccumulatedData(
+      this.revertibleAccumulatedDataFromPrivate,
+    );
+
+    const msgsFromPrivate = this.revertCode.isOK()
+      ? mergeAccumulatedData(
+          avmCircuitPublicInputs.previousNonRevertibleAccumulatedData.l2ToL1Msgs,
+          avmCircuitPublicInputs.previousRevertibleAccumulatedData.l2ToL1Msgs,
+        )
+      : avmCircuitPublicInputs.previousNonRevertibleAccumulatedData.l2ToL1Msgs;
+    avmCircuitPublicInputs.accumulatedData.l2ToL1Msgs = assertLength(
+      mergeAccumulatedData(msgsFromPrivate, avmCircuitPublicInputs.accumulatedData.l2ToL1Msgs),
+      MAX_L2_TO_L1_MSGS_PER_TX,
+    );
+
+    // Maps slot to value. Maps in TS are iterable in insertion order, which is exactly what we want for
+    // squashing "to the left", where the first occurrence of a slot uses the value of the last write to it,
+    // and the rest occurrences are omitted
+    const squashedPublicDataWrites: Map<bigint, Fr> = new Map();
+    for (const publicDataWrite of avmCircuitPublicInputs.accumulatedData.publicDataWrites) {
+      squashedPublicDataWrites.set(publicDataWrite.leafSlot.toBigInt(), publicDataWrite.value);
+    }
+
+    avmCircuitPublicInputs.accumulatedData.publicDataWrites = padArrayEnd(
+      Array.from(squashedPublicDataWrites.entries()).map(([slot, value]) => new PublicDataWrite(new Fr(slot), value)),
+      PublicDataWrite.empty(),
+      MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
     );
+
+    return avmCircuitPublicInputs;
   }
 
   /**
    * Generate the proving request for the AVM circuit.
    */
-  generateProvingRequest(endStateReference: StateReference): AvmProvingRequest {
+  async generateProvingRequest(endStateReference: StateReference): Promise<AvmProvingRequest> {
     const hints = this.trace.getAvmCircuitHints();
     return {
       type: ProvingRequestType.PUBLIC_VM,
       inputs: new AvmCircuitInputs(
         'public_dispatch',
         [],
-        PublicCircuitPublicInputs.empty(),
         hints,
-        this.generateAvmCircuitPublicInputs(endStateReference),
+        await this.generateAvmCircuitPublicInputs(endStateReference),
       ),
     };
   }

package/src/public/public_tx_simulator.ts

@@ -7,7 +7,6 @@ import {
   type SimulationError,
   type Tx,
   TxExecutionPhase,
-  UnencryptedFunctionL2Logs,
 } from '@aztec/circuit-types';
 import { type AvmSimulationStats } from '@aztec/circuit-types/stats';
 import { type Fr, type Gas, type GlobalVariables, type PublicCallRequest, type RevertCode } from '@aztec/circuits.js';
@@ -71,7 +70,7 @@ export class PublicTxSimulator {
    * @returns The result of the transaction's public execution.
    */
   public async simulate(tx: Tx): Promise<PublicTxResult> {
-    const txHash = tx.getTxHash();
+    const txHash = await tx.getTxHash();
     this.log.debug(`Simulating ${tx.enqueuedPublicFunctionCalls.length} public calls for tx ${txHash}`, { txHash });
 
     const context = await PublicTxContext.create(
@@ -120,8 +119,7 @@ export class PublicTxSimulator {
 
     const endStateReference = await this.db.getStateReference();
 
-    const avmProvingRequest = context.generateProvingRequest(endStateReference);
-    const avmCircuitPublicInputs = avmProvingRequest.inputs.output!;
+    const avmProvingRequest = await context.generateProvingRequest(endStateReference);
 
     const revertCode = context.getFinalRevertCode();
     if (!revertCode.isOK()) {
@@ -129,15 +127,10 @@ export class PublicTxSimulator {
       // if so, this is removing contracts deployed in private setup
       // You can't submit contracts in public, so this is only relevant for private-created side effects
       // FIXME: we shouldn't need to directly modify worldStateDb here!
-      await this.worldStateDB.removeNewContracts(tx);
+      await this.worldStateDB.removeNewContracts(tx, true);
       // FIXME(dbanks12): should not be changing immutable tx
-      tx.filterRevertedLogs(
-        tx.data.forPublic!.nonRevertibleAccumulatedData,
-        avmCircuitPublicInputs.accumulatedData.unencryptedLogsHashes,
-      );
+      tx.filterRevertedLogs(tx.data.forPublic!.nonRevertibleAccumulatedData);
     }
-    // FIXME(dbanks12): should not be changing immutable tx
-    tx.unencryptedLogs.addFunctionLogs([new UnencryptedFunctionL2Logs(context.trace.getUnencryptedLogs())]);
 
     return {
       avmProvingRequest,
@@ -391,7 +384,7 @@ export class PublicTxSimulator {
     }
     for (const noteHash of context.nonRevertibleAccumulatedDataFromPrivate.noteHashes) {
       if (!noteHash.isEmpty()) {
-        stateManager.writeUniqueNoteHash(noteHash);
+        await stateManager.writeUniqueNoteHash(noteHash);
       }
     }
   }
@@ -416,7 +409,7 @@ export class PublicTxSimulator {
     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.
-        stateManager.writeSiloedNoteHash(noteHash);
+        await stateManager.writeSiloedNoteHash(noteHash);
       }
     }
   }
@@ -430,7 +423,7 @@ export class PublicTxSimulator {
     }
 
     const feeJuiceAddress = ProtocolContractAddress.FeeJuice;
-    const balanceSlot = computeFeePayerBalanceStorageSlot(context.feePayer);
+    const balanceSlot = await computeFeePayerBalanceStorageSlot(context.feePayer);
 
     this.log.debug(`Deducting ${txFee.toBigInt()} balance in Fee Juice for ${context.feePayer}`);
     const stateManager = context.state.getActiveStateManager();