@aztec/simulator 0.86.0-starknet.1 → 0.87.0-nightly.20250521

package/src/public/public_processor/public_processor.ts

@@ -58,6 +58,7 @@ export class PublicProcessorFactory {
     merkleTree: MerkleTreeWriteOperations,
     globalVariables: GlobalVariables,
     skipFeeEnforcement: boolean,
+    clientInitiatedSimulation: boolean = false,
   ): PublicProcessor {
     const contractsDB = new PublicContractsDB(this.contractDataSource);
     const publicTxSimulator = this.createPublicTxSimulator(
@@ -66,6 +67,7 @@ export class PublicProcessorFactory {
       globalVariables,
       /*doMerkleOperations=*/ true,
       skipFeeEnforcement,
+      clientInitiatedSimulation,
     );
 
     return new PublicProcessor(
@@ -84,6 +86,7 @@ export class PublicProcessorFactory {
     globalVariables: GlobalVariables,
     doMerkleOperations: boolean,
     skipFeeEnforcement: boolean,
+    clientInitiatedSimulation: boolean,
   ): PublicTxSimulator {
     return new TelemetryPublicTxSimulator(
       merkleTree,
@@ -91,6 +94,7 @@ export class PublicProcessorFactory {
       globalVariables,
       doMerkleOperations,
       skipFeeEnforcement,
+      clientInitiatedSimulation,
       this.telemetryClient,
     );
   }
@@ -145,10 +149,11 @@ export class PublicProcessor implements Traceable {
       preprocessValidator?: TxValidator<Tx>;
       nullifierCache?: { addNullifiers: (nullifiers: Buffer[]) => void };
     } = {},
-  ): Promise<[ProcessedTx[], FailedTx[], NestedProcessReturnValues[]]> {
+  ): Promise<[ProcessedTx[], FailedTx[], Tx[], NestedProcessReturnValues[]]> {
     const { maxTransactions, maxBlockSize, deadline, maxBlockGas } = limits;
     const { preprocessValidator, nullifierCache } = validator;
     const result: ProcessedTx[] = [];
+    const usedTxs: Tx[] = [];
     const failed: FailedTx[] = [];
     const timer = new Timer();
 
@@ -244,6 +249,7 @@ export class PublicProcessor implements Traceable {
         // I'd rather pass the validators the processedTx as well and let them deal with it.
         nullifierCache?.addNullifiers(processedTx.txEffect.nullifiers.map(n => n.toBuffer()));
         result.push(processedTx);
+        usedTxs.push(tx);
         returns = returns.concat(returnValues);
 
         totalPublicGas = totalPublicGas.add(processedTx.gasUsed.publicGas);
@@ -281,7 +287,7 @@ export class PublicProcessor implements Traceable {
       totalSizeInBytes,
     });
 
-    return [result, failed, returns];
+    return [result, failed, usedTxs, returns];
   }
 
   @trackSpan('PublicProcessor.processTx', async tx => ({ [Attributes.TX_HASH]: (await tx.getTxHash()).toString() }))
@@ -334,7 +340,7 @@ export class PublicProcessor implements Traceable {
         padArrayEnd(processedTx.txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map(n => n.toBuffer()),
         NULLIFIER_SUBTREE_HEIGHT,
       );
-    } catch (error) {
+    } catch {
       if (txValidator) {
         // Ideally the validator has already caught this above, but just in case:
         throw new Error(`Transaction ${processedTx.hash} invalid after processing public functions`);

package/src/public/public_tx_simulator/measured_public_tx_simulator.ts

@@ -22,9 +22,10 @@ export class MeasuredPublicTxSimulator extends PublicTxSimulator {
     globalVariables: GlobalVariables,
     doMerkleOperations: boolean = false,
     skipFeeEnforcement: boolean = false,
+    clientInitiatedSimulation: boolean = false,
     protected readonly metrics: ExecutorMetricsInterface,
   ) {
-    super(merkleTree, contractsDB, globalVariables, doMerkleOperations, skipFeeEnforcement);
+    super(merkleTree, contractsDB, globalVariables, doMerkleOperations, skipFeeEnforcement, clientInitiatedSimulation);
   }
 
   public override async simulate(tx: Tx, txLabel: string = 'unlabeledTx'): Promise<PublicTxResult> {
@@ -83,7 +84,7 @@ export class MeasuredPublicTxSimulator extends PublicTxSimulator {
 
     this.log.verbose(
       result.reverted
-        ? `Simulation of enqueued public call ${fnName} reverted with reason ${result.revertReason}.`
+        ? `Simulation of enqueued public call ${fnName} reverted with reason ${result.revertReason?.message}.`
         : `Simulation of enqueued public call ${fnName} completed successfully.`,
       {
         eventName: 'avm-simulation',

package/src/public/public_tx_simulator/public_tx_context.ts

@@ -21,7 +21,6 @@ import {
   type PrivateToPublicAccumulatedData,
   PublicCallRequest,
   countAccumulatedItems,
-  mergeAccumulatedData,
 } from '@aztec/stdlib/kernel';
 import { PublicLog } from '@aztec/stdlib/logs';
 import { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
@@ -40,7 +39,7 @@ import { inspect } from 'util';
 
 import type { PublicContractsDBInterface } from '../db_interfaces.js';
 import type { PublicTreesDB } from '../public_db_sources.js';
-import { SideEffectArrayLengths, SideEffectTrace } from '../side_effect_trace.js';
+import { SideEffectTrace } from '../side_effect_trace.js';
 import { PublicPersistableStateManager } from '../state_manager/state_manager.js';
 import { getCallRequestsWithCalldataByPhase } from '../utils.js';
 
@@ -89,16 +88,7 @@ export class PublicTxContext {
   ) {
     const nonRevertibleAccumulatedDataFromPrivate = tx.data.forPublic!.nonRevertibleAccumulatedData;
 
-    const previousAccumulatedDataArrayLengths = new SideEffectArrayLengths(
-      /*publicDataWrites*/ 0,
-      /*protocolPublicDataWrites*/ 0,
-      /*noteHashes*/ 0,
-      /*nullifiers=*/ 0,
-      countAccumulatedItems(nonRevertibleAccumulatedDataFromPrivate.l2ToL1Msgs),
-      /*publicLogs*/ 0,
-    );
-
-    const trace = new SideEffectTrace(/*startSideEffectCounter=*/ 0, previousAccumulatedDataArrayLengths);
+    const trace = new SideEffectTrace();
 
     const firstNullifier = nonRevertibleAccumulatedDataFromPrivate.nullifiers[0];
 
@@ -153,7 +143,7 @@ export class PublicTxContext {
    * NOTE: this does not "halt" the entire transaction execution.
    */
   revert(phase: TxExecutionPhase, revertReason: SimulationError | undefined = undefined, culprit = '') {
-    this.log.warn(`${TxExecutionPhase[phase]} phase reverted! ${culprit} failed with reason: ${revertReason}`);
+    this.log.warn(`${TxExecutionPhase[phase]} phase reverted! ${culprit} failed with reason: ${revertReason?.message}`);
 
     if (revertReason && !this.revertReason) {
       // don't override revertReason
@@ -315,15 +305,6 @@ export class PublicTxContext {
       publicLogs: avmPublicLogs,
     } = this.trace.getSideEffects();
 
-    // We concatenate messages.
-    const msgsFromPrivate = this.revertCode.isOK()
-      ? mergeAccumulatedData(
-          this.nonRevertibleAccumulatedDataFromPrivate.l2ToL1Msgs,
-          this.revertibleAccumulatedDataFromPrivate.l2ToL1Msgs,
-        )
-      : this.nonRevertibleAccumulatedDataFromPrivate.l2ToL1Msgs;
-    const finalL2ToL1Msgs = mergeAccumulatedData(msgsFromPrivate, avmL2ToL1Msgs);
-
     // Private generates PrivateLogs, and public execution generates PublicLogs.
     // Since these are two different categories, they should not be merged.
     const finalPublicLogs = avmPublicLogs;
@@ -354,7 +335,7 @@ export class PublicTxContext {
         Fr.zero(),
         MAX_NULLIFIERS_PER_TX,
       ),
-      /*l2ToL1Msgs=*/ padArrayEnd(finalL2ToL1Msgs, ScopedL2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_TX),
+      /*l2ToL1Msgs=*/ padArrayEnd(avmL2ToL1Msgs, ScopedL2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_TX),
       /*publicLogs=*/ padArrayEnd(finalPublicLogs, PublicLog.empty(), MAX_PUBLIC_LOGS_PER_TX),
       /*publicDataWrites=*/ padArrayEnd(
         finalPublicDataWrites,

package/src/public/public_tx_simulator/public_tx_simulator.ts

@@ -60,6 +60,7 @@ export class PublicTxSimulator {
     private globalVariables: GlobalVariables,
     private doMerkleOperations: boolean = false,
     private skipFeeEnforcement: boolean = false,
+    private clientInitiatedSimulation: boolean = false,
   ) {
     this.log = createLogger(`simulator:public_tx_simulator`);
   }
@@ -230,7 +231,7 @@ export class PublicTxSimulator {
     const returnValues: NestedProcessReturnValues[] = [];
     let reverted = false;
     let revertReason: SimulationError | undefined;
-    for (let i = callRequests.length - 1; i >= 0; i--) {
+    for (let i = 0; i < callRequests.length; i++) {
       if (reverted) {
         break;
       }
@@ -331,6 +332,7 @@ export class PublicTxSimulator {
       request.isStaticCall,
       calldata,
       allocatedGas,
+      this.clientInitiatedSimulation,
     );
     const avmCallResult = await simulator.execute();
     return avmCallResult.finalize();
@@ -359,6 +361,12 @@ export class PublicTxSimulator {
         await stateManager.writeUniqueNoteHash(noteHash);
       }
     }
+    for (const l2ToL1Message of context.nonRevertibleAccumulatedDataFromPrivate.l2ToL1Msgs) {
+      if (!l2ToL1Message.isEmpty()) {
+        stateManager.writeScopedL2ToL1Message(l2ToL1Message);
+      }
+    }
+
     // 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?
     // FIXME(fcarreiro): this should conceptually use the hinted contracts db.
@@ -400,6 +408,11 @@ export class PublicTxSimulator {
         await stateManager.writeSiloedNoteHash(noteHash);
       }
     }
+    for (const l2ToL1Message of context.revertibleAccumulatedDataFromPrivate.l2ToL1Msgs) {
+      if (!l2ToL1Message.isEmpty()) {
+        stateManager.writeScopedL2ToL1Message(l2ToL1Message);
+      }
+    }
     // add new contracts to the contracts db so that their functions may be found and called
     // FIXME(fcarreiro): this should conceptually use the hinted contracts db.
     // However things should work as they are now because the hinted db would still pick up the new contracts.

package/src/public/public_tx_simulator/telemetry_public_tx_simulator.ts

@@ -24,10 +24,19 @@ export class TelemetryPublicTxSimulator extends MeasuredPublicTxSimulator {
     globalVariables: GlobalVariables,
     doMerkleOperations: boolean = false,
     skipFeeEnforcement: boolean = false,
+    clientInitiatedSimulation: boolean = false,
     telemetryClient: TelemetryClient = getTelemetryClient(),
   ) {
     const metrics = new ExecutorMetrics(telemetryClient, 'PublicTxSimulator');
-    super(merkleTree, contractsDB, globalVariables, doMerkleOperations, skipFeeEnforcement, metrics);
+    super(
+      merkleTree,
+      contractsDB,
+      globalVariables,
+      doMerkleOperations,
+      skipFeeEnforcement,
+      clientInitiatedSimulation,
+      metrics,
+    );
     this.tracer = metrics.tracer;
   }
 

package/src/public/side_effect_trace.ts

@@ -6,7 +6,7 @@ import {
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   MAX_PUBLIC_LOGS_PER_TX,
   PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  PUBLIC_LOG_DATA_SIZE_IN_FIELDS,
+  PUBLIC_LOG_SIZE_IN_FIELDS,
 } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -199,9 +199,7 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
     }
 
     const recipientAddress = EthAddress.fromField(recipient);
-    this.l2ToL1Messages.push(
-      new L2ToL1Message(recipientAddress, content, this.sideEffectCounter).scope(contractAddress),
-    );
+    this.l2ToL1Messages.push(new L2ToL1Message(recipientAddress, content, 0).scope(contractAddress));
     this.log.trace(`Tracing new l2 to l1 message (counter=${this.sideEffectCounter})`);
     this.incrementSideEffectCounter();
   }
@@ -211,10 +209,10 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
       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}`);
+    if (log.length > PUBLIC_LOG_SIZE_IN_FIELDS) {
+      throw new Error(`Emitted public log is too large, max: ${PUBLIC_LOG_SIZE_IN_FIELDS}, passed: ${log.length}`);
     }
-    const publicLog = new PublicLog(contractAddress, padArrayEnd(log, Fr.ZERO, PUBLIC_LOG_DATA_SIZE_IN_FIELDS));
+    const publicLog = new PublicLog(contractAddress, padArrayEnd(log, Fr.ZERO, PUBLIC_LOG_SIZE_IN_FIELDS), log.length);
     this.publicLogs.push(publicLog);
     this.log.trace(`Tracing new public log (counter=${this.sideEffectCounter})`);
     this.incrementSideEffectCounter();

package/src/public/state_manager/state_manager.ts

@@ -15,6 +15,7 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractClassPublicWithCommitment, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { SerializableContractInstance } from '@aztec/stdlib/contract';
 import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
+import { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
 import { SharedMutableValues, SharedMutableValuesWithHash } from '@aztec/stdlib/shared-mutable';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import type { TreeSnapshots } from '@aztec/stdlib/tx';
@@ -301,6 +302,18 @@ export class PublicPersistableStateManager {
     this.trace.traceNewL2ToL1Message(contractAddress, recipient, content);
   }
 
+  /**
+   * Write a scoped L2 to L1 message.
+   * @param l2ToL1Message - The L2 to L1 message to write.
+   */
+  public writeScopedL2ToL1Message(l2ToL1Message: ScopedL2ToL1Message) {
+    this.writeL2ToL1Message(
+      l2ToL1Message.contractAddress,
+      l2ToL1Message.message.recipient.toField(),
+      l2ToL1Message.message.content,
+    );
+  }
+
   /**
    * Write a public log
    * @param contractAddress - address of the contract that emitted the log

package/src/public/avm/opcodes/.eslintrc.cjs

@@ -1,8 +0,0 @@
-const baseConfig = require('@aztec/foundation/eslint');
-module.exports = {
-  ...baseConfig,
-  rules: {
-    ...baseConfig.rules,
-    'require-await': 'off',
-  },
-};