@aztec/simulator 1.2.0 → 2.0.0-nightly.20250813

package/src/public/avm/opcodes/misc.ts

@@ -41,12 +41,12 @@ export class DebugLog extends Instruction {
 
     const operands = [this.messageOffset, this.fieldsOffset, this.fieldsSizeOffset];
     const [messageOffset, fieldsOffset, fieldsSizeOffset] = addressing.resolve(operands, memory);
-    memory.checkTag(TypeTag.UINT32, fieldsSizeOffset);
 
     // DebugLog is a no-op except when doing client-initiated simulation with debug logging enabled.
     // Note that we still do address resolution and basic tag-checking (above)
     // To avoid a special-case in the witness generator and circuit.
     if (context.environment.clientInitiatedSimulation && DebugLog.logger.isLevelEnabled('verbose')) {
+      memory.checkTag(TypeTag.UINT32, fieldsSizeOffset);
       const fieldsSize = memory.get(fieldsSizeOffset).toNumber();
 
       const rawMessage = memory.getSlice(messageOffset, this.messageSize);

package/src/public/avm/test_utils.ts

@@ -27,9 +27,9 @@ export function mockStorageReadWithMap(worldStateDB: PublicTreesDB, mockedStorag
   );
 }
 
-export function mockNoteHashExists(worldStateDB: PublicTreesDB, _leafIndex: Fr, value?: Fr) {
+export function mockNoteHashExists(worldStateDB: PublicTreesDB, _leafIndex: bigint, value?: Fr) {
   (worldStateDB as jest.Mocked<PublicTreesDB>).getNoteHash.mockImplementation((index: bigint) => {
-    if (index == _leafIndex.toBigInt()) {
+    if (index == _leafIndex) {
       return Promise.resolve(value);
     } else {
       // This is ok for now since the traceing functions handle it
@@ -44,12 +44,12 @@ export function mockCheckNullifierExists(worldStateDB: PublicTreesDB, exists: bo
 
 export function mockL1ToL2MessageExists(
   worldStateDB: PublicTreesDB,
-  leafIndex: Fr,
+  leafIndex: bigint,
   value: Fr,
   valueAtOtherIndices?: Fr,
 ) {
   (worldStateDB as jest.Mocked<PublicTreesDB>).getL1ToL2LeafValue.mockImplementation((index: bigint) => {
-    if (index == leafIndex.toBigInt()) {
+    if (index == leafIndex) {
       return Promise.resolve(value);
     } else {
       // any indices other than mockAtLeafIndex will return a different value

package/src/public/executor_metrics.ts

@@ -112,10 +112,6 @@ export class ExecutorMetrics implements ExecutorMetricsInterface {
     });
   }
 
-  recordTxHashComputation(durationMs: number) {
-    this.txHashing.record(Math.ceil(durationMs));
-  }
-
   recordPrivateEffectsInsertion(durationUs: number, type: 'revertible' | 'non-revertible') {
     this.privateEffectsInsertions.record(Math.ceil(durationUs), {
       [Attributes.REVERTIBILITY]: type,

package/src/public/executor_metrics_interface.ts

@@ -10,6 +10,5 @@ export interface ExecutorMetricsInterface {
     manaUsed: number,
     totalInstructionsExecuted: number,
   ): void;
-  recordTxHashComputation(durationMs: number): void;
   recordPrivateEffectsInsertion(durationUs: number, type: 'revertible' | 'non-revertible'): void;
 }

package/src/public/fixtures/index.ts

@@ -2,3 +2,4 @@ export * from './public_tx_simulation_tester.js';
 export * from './utils.js';
 export * from './simple_contract_data_source.js';
 export { readAvmMinimalPublicTxInputsFromFile, createAvmMinimalPublicTx } from './minimal_public_tx.js';
+export { TestExecutorMetrics } from '../test_executor_metrics.js';

package/src/public/fixtures/minimal_public_tx.ts

@@ -45,6 +45,8 @@ export async function createAvmMinimalPublicTx(): Promise<PublicTxResult> {
         args: [],
       },
     ],
+    /*teardownCall=*/ undefined,
+    /*feePayer=*/ deployer,
   );
 }
 

package/src/public/fixtures/public_tx_simulation_tester.ts

@@ -39,7 +39,7 @@ export type TestEnqueuedCall = {
  * transactions.
  */
 export class PublicTxSimulationTester extends BaseAvmSimulationTester {
-  private txCount = 0;
+  protected txCount: number = 0;
   private simulator: MeasuredPublicTxSimulator;
   private metricsPrefix?: string;
 
@@ -83,7 +83,7 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     teardownCall?: TestEnqueuedCall,
     feePayer: AztecAddress = sender,
     /* need some unique first nullifier for note-nonce computations */
-    privateInsertions: TestPrivateInsertions = { nonRevertible: { nullifiers: [new Fr(420000 + this.txCount++)] } },
+    privateInsertions: TestPrivateInsertions = { nonRevertible: { nullifiers: [new Fr(420000 + this.txCount)] } },
   ): Promise<Tx> {
     const setupCallRequests = await asyncMap(setupCalls, call =>
       this.#createPubicCallRequestForCall(call, call.sender ?? sender),
@@ -95,6 +95,7 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
       ? await this.#createPubicCallRequestForCall(teardownCall, teardownCall.sender ?? sender)
       : undefined;
 
+    this.txCount++;
     return createTxForPublicCalls(
       privateInsertions,
       setupCallRequests,

package/src/public/fixtures/utils.ts

@@ -1,14 +1,14 @@
 import {
+  CONTRACT_CLASS_PUBLISHED_MAGIC_VALUE,
+  CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,
+  CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS,
   DEFAULT_GAS_LIMIT,
-  DEPLOYER_CONTRACT_ADDRESS,
   MAX_L2_GAS_PER_TX_PUBLIC_PORTION,
   PRIVATE_LOG_SIZE_IN_FIELDS,
-  REGISTERER_CONTRACT_ADDRESS,
-  REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE,
 } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
-import { DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG } from '@aztec/protocol-contracts';
+import { CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG } from '@aztec/protocol-contracts';
 import { bufferAsFields } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
@@ -19,10 +19,10 @@ import {
   PartialPrivateTailPublicInputsForPublic,
   PartialPrivateTailPublicInputsForRollup,
   PrivateKernelTailCircuitPublicInputs,
-  RollupValidationRequests,
   countAccumulatedItems,
 } from '@aztec/stdlib/kernel';
 import { ContractClassLogFields, PrivateLog } from '@aztec/stdlib/logs';
+import type { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
 import { ClientIvcProof } from '@aztec/stdlib/proofs';
 import {
   BlockHeader,
@@ -40,17 +40,19 @@ export type TestPrivateInsertions = {
   revertible?: {
     nullifiers?: Fr[];
     noteHashes?: Fr[];
+    l2ToL1Msgs?: ScopedL2ToL1Message[];
   };
   nonRevertible?: {
     nullifiers?: Fr[];
     noteHashes?: Fr[];
+    l2ToL1Msgs?: ScopedL2ToL1Message[];
   };
 };
 
 /**
  * Craft a carrier transaction for some public calls for simulation by PublicTxSimulator.
  */
-export function createTxForPublicCalls(
+export async function createTxForPublicCalls(
   privateInsertions: TestPrivateInsertions,
   setupCallRequests: PublicCallRequestWithCalldata[],
   appCallRequests: PublicCallRequestWithCalldata[],
@@ -58,7 +60,7 @@ export function createTxForPublicCalls(
   feePayer = AztecAddress.zero(),
   gasUsedByPrivate: Gas = Gas.empty(),
   globals: GlobalVariables = GlobalVariables.empty(),
-): Tx {
+): Promise<Tx> {
   assert(
     setupCallRequests.length > 0 || appCallRequests.length > 0 || teardownCallRequest !== undefined,
     "Can't create public tx with no enqueued calls",
@@ -83,6 +85,12 @@ export function createTxForPublicCalls(
       forPublic.nonRevertibleAccumulatedData.noteHashes[i] = privateInsertions.nonRevertible.noteHashes[i];
     }
   }
+  if (privateInsertions.nonRevertible.l2ToL1Msgs) {
+    for (let i = 0; i < privateInsertions.nonRevertible.l2ToL1Msgs.length; i++) {
+      assert(i < forPublic.nonRevertibleAccumulatedData.l2ToL1Msgs.length, 'L2 to L1 message index out of bounds');
+      forPublic.nonRevertibleAccumulatedData.l2ToL1Msgs[i] = privateInsertions.nonRevertible.l2ToL1Msgs[i];
+    }
+  }
 
   // Revertible private insertions
   if (privateInsertions.revertible) {
@@ -98,6 +106,12 @@ export function createTxForPublicCalls(
         forPublic.revertibleAccumulatedData.nullifiers[i] = privateInsertions.revertible.nullifiers[i];
       }
     }
+    if (privateInsertions.revertible.l2ToL1Msgs) {
+      for (let i = 0; i < privateInsertions.revertible.l2ToL1Msgs.length; i++) {
+        assert(i < forPublic.revertibleAccumulatedData.l2ToL1Msgs.length, 'L2 to L1 message index out of bounds');
+        forPublic.revertibleAccumulatedData.l2ToL1Msgs[i] = privateInsertions.revertible.l2ToL1Msgs[i];
+      }
+    }
   }
 
   for (let i = 0; i < setupCallRequests.length; i++) {
@@ -117,12 +131,13 @@ export function createTxForPublicCalls(
   const header = BlockHeader.empty();
   header.globalVariables = globals;
   const constantData = new TxConstantData(header, txContext, Fr.zero(), Fr.zero());
+  const includeByTimestamp = 0n; // Not used in the simulator.
 
   const txData = new PrivateKernelTailCircuitPublicInputs(
     constantData,
-    RollupValidationRequests.empty(),
     /*gasUsed=*/ gasUsedByPrivate,
     feePayer,
+    includeByTimestamp,
     forPublic,
   );
 
@@ -132,10 +147,18 @@ export function createTxForPublicCalls(
     ...(teardownCallRequest ? [teardownCallRequest] : []),
   ].map(r => new HashedValues(r.calldata, r.request.calldataHash));
 
-  return new Tx(txData, ClientIvcProof.empty(), [], calldata);
+  return await Tx.create({
+    data: txData,
+    clientIvcProof: ClientIvcProof.empty(),
+    contractClassLogFields: [],
+    publicFunctionCalldata: calldata,
+  });
 }
 
-export function createTxForPrivateOnly(feePayer = AztecAddress.zero(), gasUsedByPrivate: Gas = new Gas(10, 10)): Tx {
+export async function createTxForPrivateOnly(
+  feePayer = AztecAddress.zero(),
+  gasUsedByPrivate: Gas = new Gas(10, 10),
+): Promise<Tx> {
   // use max limits
   const gasLimits = new Gas(DEFAULT_GAS_LIMIT, MAX_L2_GAS_PER_TX_PUBLIC_PORTION);
 
@@ -145,16 +168,22 @@ export function createTxForPrivateOnly(feePayer = AztecAddress.zero(), gasUsedBy
   const gasSettings = new GasSettings(gasLimits, Gas.empty(), maxFeesPerGas, GasFees.empty());
   const txContext = new TxContext(Fr.zero(), Fr.zero(), gasSettings);
   const constantData = new TxConstantData(BlockHeader.empty(), txContext, Fr.zero(), Fr.zero());
+  const includeByTimestamp = 0n; // Not used in the simulator.
 
   const txData = new PrivateKernelTailCircuitPublicInputs(
     constantData,
-    RollupValidationRequests.empty(),
     /*gasUsed=*/ gasUsedByPrivate,
     feePayer,
+    includeByTimestamp,
     /*forPublic=*/ undefined,
     forRollup,
   );
-  return new Tx(txData, ClientIvcProof.empty(), [], []);
+  return await Tx.create({
+    data: txData,
+    clientIvcProof: ClientIvcProof.empty(),
+    contractClassLogFields: [],
+    publicFunctionCalldata: [],
+  });
 }
 
 export async function addNewContractClassToTx(
@@ -163,14 +192,14 @@ export async function addNewContractClassToTx(
   skipNullifierInsertion = false,
 ) {
   const contractClassLogFields = [
-    new Fr(REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE),
+    new Fr(CONTRACT_CLASS_PUBLISHED_MAGIC_VALUE),
     contractClass.id,
     new Fr(contractClass.version),
     new Fr(contractClass.artifactHash),
     new Fr(contractClass.privateFunctionsRoot),
     ...bufferAsFields(contractClass.packedBytecode, Math.ceil(contractClass.packedBytecode.length / 31) + 1),
   ];
-  const contractAddress = new AztecAddress(new Fr(REGISTERER_CONTRACT_ADDRESS));
+  const contractAddress = new AztecAddress(new Fr(CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS));
   const emittedLength = contractClassLogFields.length;
   const logFields = ContractClassLogFields.fromEmittedFields(contractClassLogFields);
 
@@ -209,7 +238,7 @@ export async function addNewContractInstanceToTx(
     contractInstance.publicKeys.masterTaggingPublicKey.y,
   ];
   const logFields = [
-    DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG,
+    CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG,
     contractInstance.address.toField(),
     new Fr(contractInstance.version),
     new Fr(contractInstance.salt),
@@ -224,7 +253,7 @@ export async function addNewContractInstanceToTx(
   );
 
   const contractAddressNullifier = await siloNullifier(
-    AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
+    AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS),
     contractInstance.address.toField(),
   );
 

package/src/public/public_db_sources.ts

@@ -2,8 +2,8 @@ import { NULLIFIER_SUBTREE_HEIGHT, PUBLIC_DATA_SUBTREE_HEIGHT } from '@aztec/con
 import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
-import { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
-import { ContractInstanceDeployedEvent } from '@aztec/protocol-contracts/instance-deployer';
+import { ContractClassPublishedEvent } from '@aztec/protocol-contracts/class-registry';
+import { ContractInstancePublishedEvent } from '@aztec/protocol-contracts/instance-registry';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -143,12 +143,12 @@ export class PublicContractsDB implements PublicContractsDBInterface {
     cacheType: string,
   ) {
     const contractClassEvents = siloedContractClassLogs
-      .filter((log: ContractClassLog) => ContractClassRegisteredEvent.isContractClassRegisteredEvent(log))
-      .map((log: ContractClassLog) => ContractClassRegisteredEvent.fromLog(log));
+      .filter((log: ContractClassLog) => ContractClassPublishedEvent.isContractClassPublishedEvent(log))
+      .map((log: ContractClassLog) => ContractClassPublishedEvent.fromLog(log));
 
     // Cache contract classes
     await Promise.all(
-      contractClassEvents.map(async (event: ContractClassRegisteredEvent) => {
+      contractClassEvents.map(async (event: ContractClassPublishedEvent) => {
         this.log.debug(`Adding class ${event.contractClassId.toString()} to contract's ${cacheType} tx cache`);
         const contractClass = await event.toContractClassPublic();
 
@@ -165,8 +165,8 @@ export class PublicContractsDB implements PublicContractsDBInterface {
    */
   private addContractInstancesFromLogs(contractInstanceLogs: PrivateLog[], cache: TxContractCache, cacheType: string) {
     const contractInstanceEvents = contractInstanceLogs
-      .filter(log => ContractInstanceDeployedEvent.isContractInstanceDeployedEvent(log))
-      .map(log => ContractInstanceDeployedEvent.fromLog(log));
+      .filter(log => ContractInstancePublishedEvent.isContractInstancePublishedEvent(log))
+      .map(log => ContractInstancePublishedEvent.fromLog(log));
 
     // Cache contract instances
     contractInstanceEvents.forEach(e => {

package/src/public/public_processor/public_processor.ts

@@ -2,9 +2,10 @@ import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NULLIFIER_SUBTREE_HEIGHT
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
+import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider, Timer, elapsed, executeTimeout } from '@aztec/foundation/timer';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
+import { ContractClassPublishedEvent } from '@aztec/protocol-contracts/class-registry';
 import { computeFeePayerBalanceLeafSlot, computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -14,6 +15,7 @@ import type {
   MerkleTreeWriteOperations,
   PublicProcessorLimits,
   PublicProcessorValidator,
+  SequencerConfig,
 } from '@aztec/stdlib/interfaces/server';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import {
@@ -130,6 +132,7 @@ export class PublicProcessor implements Traceable {
     private dateProvider: DateProvider,
     telemetryClient: TelemetryClient = getTelemetryClient(),
     private log = createLogger('simulator:public-processor'),
+    private opts: Pick<SequencerConfig, 'fakeProcessingDelayPerTxMs'> = {},
   ) {
     this.metrics = new PublicProcessorMetrics(telemetryClient, 'PublicProcessor');
   }
@@ -176,7 +179,7 @@ export class PublicProcessor implements Traceable {
       }
 
       // Skip this tx if it'd exceed max block size
-      const txHash = (await origTx.getTxHash()).toString();
+      const txHash = 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`, {
@@ -206,16 +209,16 @@ 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();
+        const txHash = tx.getTxHash();
         if (result.result === 'invalid') {
           const reason = result.reason.join(', ');
-          this.log.warn(`Rejecting tx ${txHash.toString()} due to pre-process validation fail: ${reason}`);
+          this.log.debug(`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 ${txHash.toString()} due to pre-process validation: ${reason}`);
+          this.log.debug(`Skipping tx ${txHash.toString()} due to pre-process validation: ${reason}`);
           returns.push(new NestedProcessReturnValues([]));
           continue;
         } else {
@@ -237,7 +240,7 @@ export class PublicProcessor implements Traceable {
         // If the actual size of this tx would exceed block size, skip it
         const txSize = processedTx.txEffect.getDASize();
         if (maxBlockSize !== undefined && totalSizeInBytes + txSize > maxBlockSize) {
-          this.log.warn(`Skipping processed tx ${txHash} sized ${txSize} due to max block size.`, {
+          this.log.debug(`Skipping processed tx ${txHash} sized ${txSize} due to max block size.`, {
             txHash,
             sizeInBytes: txSize,
             totalSizeInBytes,
@@ -334,8 +337,8 @@ export class PublicProcessor implements Traceable {
     }
   }
 
-  @trackSpan('PublicProcessor.processTx', async tx => ({ [Attributes.TX_HASH]: (await tx.getTxHash()).toString() }))
-  private async processTx(tx: Tx, deadline?: Date): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
+  @trackSpan('PublicProcessor.processTx', tx => ({ [Attributes.TX_HASH]: tx.getTxHash().toString() }))
+  private async processTx(tx: Tx, deadline: Date | undefined): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
     const [time, [processedTx, returnValues]] = await elapsed(() => this.processTxWithinDeadline(tx, deadline));
 
     this.log.verbose(
@@ -401,17 +404,29 @@ export class PublicProcessor implements Traceable {
   /** Processes the given tx within deadline. Returns timeout if deadline is hit. */
   private async processTxWithinDeadline(
     tx: Tx,
-    deadline?: Date,
+    deadline: Date | undefined,
   ): Promise<[ProcessedTx, NestedProcessReturnValues[] | undefined]> {
-    const processFn: () => Promise<[ProcessedTx, NestedProcessReturnValues[] | undefined]> = tx.hasPublicCalls()
+    const innerProcessFn: () => Promise<[ProcessedTx, NestedProcessReturnValues[] | undefined]> = tx.hasPublicCalls()
       ? () => this.processTxWithPublicCalls(tx)
       : () => this.processPrivateOnlyTx(tx);
 
+    // Fake a delay per tx if instructed (used for tests)
+    const fakeDelayPerTxMs = this.opts.fakeProcessingDelayPerTxMs;
+    const processFn =
+      fakeDelayPerTxMs && fakeDelayPerTxMs > 0
+        ? async () => {
+            const result = await innerProcessFn();
+            this.log.warn(`Sleeping ${fakeDelayPerTxMs}ms after processing tx ${tx.getTxHash().toString()}`);
+            await sleep(fakeDelayPerTxMs);
+            return result;
+          }
+        : innerProcessFn;
+
     if (!deadline) {
       return await processFn();
     }
 
-    const txHash = await tx.getTxHash();
+    const txHash = tx.getTxHash();
     const timeout = +deadline - this.dateProvider.now();
     if (timeout <= 0) {
       throw new PublicProcessorTimeoutError();
@@ -458,8 +473,8 @@ export class PublicProcessor implements Traceable {
     return new PublicDataWrite(leafSlot, updatedBalance);
   }
 
-  @trackSpan('PublicProcessor.processPrivateOnlyTx', async (tx: Tx) => ({
-    [Attributes.TX_HASH]: (await tx.getTxHash()).toString(),
+  @trackSpan('PublicProcessor.processPrivateOnlyTx', (tx: Tx) => ({
+    [Attributes.TX_HASH]: tx.getTxHash().toString(),
   }))
   private async processPrivateOnlyTx(tx: Tx): Promise<[ProcessedTx, undefined]> {
     const gasFees = this.globalVariables.gasFees;
@@ -467,18 +482,18 @@ export class PublicProcessor implements Traceable {
 
     const feePaymentPublicDataWrite = await this.performFeePaymentPublicDataWrite(transactionFee, tx.data.feePayer);
 
-    const processedTx = await makeProcessedTxFromPrivateOnlyTx(
+    const processedTx = makeProcessedTxFromPrivateOnlyTx(
       tx,
       transactionFee,
       feePaymentPublicDataWrite,
       this.globalVariables,
     );
 
-    this.metrics.recordClassRegistration(
+    this.metrics.recordClassPublication(
       ...tx
         .getContractClassLogs()
-        .filter(log => ContractClassRegisteredEvent.isContractClassRegisteredEvent(log))
-        .map(log => ContractClassRegisteredEvent.fromLog(log)),
+        .filter(log => ContractClassPublishedEvent.isContractClassPublishedEvent(log))
+        .map(log => ContractClassPublishedEvent.fromLog(log)),
     );
 
     // Fee payment insertion has already been done. Do the rest.
@@ -492,8 +507,8 @@ export class PublicProcessor implements Traceable {
     return [processedTx, undefined];
   }
 
-  @trackSpan('PublicProcessor.processTxWithPublicCalls', async tx => ({
-    [Attributes.TX_HASH]: (await tx.getTxHash()).toString(),
+  @trackSpan('PublicProcessor.processTxWithPublicCalls', tx => ({
+    [Attributes.TX_HASH]: tx.getTxHash().toString(),
   }))
   private async processTxWithPublicCalls(tx: Tx): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
     const timer = new Timer();
@@ -517,23 +532,17 @@ export class PublicProcessor implements Traceable {
     const contractClassLogs = revertCode.isOK()
       ? tx.getContractClassLogs()
       : tx.getSplitContractClassLogs(false /* revertible */);
-    this.metrics.recordClassRegistration(
+    this.metrics.recordClassPublication(
       ...contractClassLogs
-        .filter(log => ContractClassRegisteredEvent.isContractClassRegisteredEvent(log))
-        .map(log => ContractClassRegisteredEvent.fromLog(log)),
+        .filter(log => ContractClassPublishedEvent.isContractClassPublishedEvent(log))
+        .map(log => ContractClassPublishedEvent.fromLog(log)),
     );
 
     const phaseCount = processedPhases.length;
     const durationMs = timer.ms();
     this.metrics.recordTx(phaseCount, durationMs, gasUsed.publicGas);
 
-    const processedTx = await makeProcessedTxFromTxWithPublicCalls(
-      tx,
-      avmProvingRequest,
-      gasUsed,
-      revertCode,
-      revertReason,
-    );
+    const processedTx = makeProcessedTxFromTxWithPublicCalls(tx, avmProvingRequest, gasUsed, revertCode, revertReason);
 
     const returnValues = processedPhases.find(({ phase }) => phase === TxExecutionPhase.APP_LOGIC)?.returnValues ?? [];
 

package/src/public/public_processor/public_processor_metrics.ts

@@ -1,4 +1,4 @@
-import type { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
+import type { ContractClassPublishedEvent } from '@aztec/protocol-contracts/class-registry';
 import type { Gas } from '@aztec/stdlib/gas';
 import type { TxExecutionPhase } from '@aztec/stdlib/tx';
 import {
@@ -137,7 +137,7 @@ export class PublicProcessorMetrics {
     this.phaseCount.add(1, { [Attributes.TX_PHASE_NAME]: phaseName, [Attributes.OK]: false });
   }
 
-  recordClassRegistration(...events: ContractClassRegisteredEvent[]) {
+  recordClassPublication(...events: ContractClassPublishedEvent[]) {
     let totalBytecode = 0;
     for (const event of events) {
       totalBytecode += event.packedPublicBytecode.length;

package/src/public/public_tx_simulator/apps_tests/amm_test.ts

@@ -7,7 +7,7 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 
 import { PublicTxSimulationTester } from '../../fixtures/public_tx_simulation_tester.js';
-import { deployToken } from './token_test.js';
+import { setUpToken } from './token_test.js';
 
 const INITIAL_TOKEN_BALANCE = 1_000_000_000n;
 /**
@@ -22,9 +22,9 @@ export async function ammTest(tester: PublicTxSimulationTester, logger: Logger)
   const sender = AztecAddress.fromNumber(111);
 
   logger.debug(`Deploying tokens`);
-  const token0 = await deployToken(tester, admin, /*seed=*/ 0);
-  const token1 = await deployToken(tester, admin, /*seed=*/ 1);
-  const liquidityToken = await deployToken(tester, admin, /*seed=*/ 2);
+  const token0 = await setUpToken(tester, admin, /*seed=*/ 0);
+  const token1 = await setUpToken(tester, admin, /*seed=*/ 1);
+  const liquidityToken = await setUpToken(tester, admin, /*seed=*/ 2);
   logger.debug(`Deploying AMM`);
   const constructorArgs = [token0, token1, liquidityToken];
   const amm = await tester.registerAndDeployContract(

package/src/public/public_tx_simulator/apps_tests/token_test.ts

@@ -13,7 +13,7 @@ export async function tokenTest(tester: PublicTxSimulationTester, logger: Logger
   const sender = AztecAddress.fromNumber(111);
   const receiver = AztecAddress.fromNumber(222);
 
-  const token = await deployToken(tester, admin);
+  const token = await setUpToken(tester, admin);
 
   const mintAmount = 100n;
   const mintResult = await tester.simulateTxWithLabel(
@@ -84,7 +84,7 @@ export async function tokenTest(tester: PublicTxSimulationTester, logger: Logger
   logger.info(`TokenContract public tx simulator test took ${endTime - startTime}ms\n`);
 }
 
-export async function deployToken(tester: PublicTxSimulationTester, admin: AztecAddress, seed = 0) {
+export async function setUpToken(tester: PublicTxSimulationTester, admin: AztecAddress, seed = 0) {
   const constructorArgs = [admin, /*name=*/ 'Token', /*symbol=*/ 'TOK', /*decimals=*/ new Fr(18)];
   const token = await tester.registerAndDeployContract(
     constructorArgs,

package/src/public/public_tx_simulator/measured_public_tx_simulator.ts

@@ -39,13 +39,6 @@ export class MeasuredPublicTxSimulator extends PublicTxSimulator {
     return avmResult;
   }
 
-  protected override async computeTxHash(tx: Tx) {
-    const timer = new Timer();
-    const txHash = await super.computeTxHash(tx);
-    this.metrics.recordTxHashComputation(timer.ms());
-    return txHash;
-  }
-
   protected override async insertNonRevertiblesFromPrivate(context: PublicTxContext, tx: Tx) {
     const timer = new Timer();
     await super.insertNonRevertiblesFromPrivate(context, tx);

package/src/public/public_tx_simulator/public_tx_context.ts

@@ -119,7 +119,7 @@ export class PublicTxContext {
     const gasAllocatedToPublicTeardown = clampedGasSettings.teardownGasLimits;
 
     return new PublicTxContext(
-      await tx.getTxHash(),
+      tx.getTxHash(),
       new PhaseStateManager(txStateManager),
       await txStateManager.getTreeSnapshots(),
       globalVariables,
@@ -143,10 +143,8 @@ export class PublicTxContext {
    * All phases have been processed.
    * Actual transaction fee and actual total consumed gas can now be queried.
    */
-  async halt() {
-    if (this.state.isForked()) {
-      await this.state.mergeForkedState();
-    }
+  halt() {
+    assert(!this.state.isForked(), 'Cannot halt when state is forked');
     this.halted = true;
   }
 
@@ -165,11 +163,6 @@ export class PublicTxContext {
     }
     if (phase === TxExecutionPhase.SETUP) {
       this.log.warn(`Setup phase reverted! The transaction will be thrown out.`);
-      if (revertReason) {
-        throw revertReason;
-      } else {
-        throw new Error(`Setup phase reverted! The transaction will be thrown out. ${culprit} failed`);
-      }
     } else if (phase === TxExecutionPhase.APP_LOGIC) {
       this.revertCode = RevertCode.APP_LOGIC_REVERTED;
     } else if (phase === TxExecutionPhase.TEARDOWN) {
@@ -338,6 +331,15 @@ export class PublicTxContext {
       );
     })();
 
+    // Count before padding.
+    const accumulatedDataArrayLengths = new AvmAccumulatedDataArrayLengths(
+      avmNoteHashes.length,
+      avmNullifiers.length,
+      avmL2ToL1Msgs.length,
+      finalPublicLogs.length,
+      finalPublicDataWrites.length,
+    );
+
     const accumulatedData = new AvmAccumulatedData(
       /*noteHashes=*/ padArrayEnd(
         avmNoteHashes.map(n => n.value),
@@ -376,14 +378,6 @@ export class PublicTxContext {
         countAccumulatedItems(from.nullifiers),
         countAccumulatedItems(from.l2ToL1Msgs),
       );
-    const getAvmAccumulatedDataArrayLengths = (from: AvmAccumulatedData) =>
-      new AvmAccumulatedDataArrayLengths(
-        from.noteHashes.length,
-        from.nullifiers.length,
-        from.l2ToL1Msgs.length,
-        from.publicLogs.length,
-        from.publicDataWrites.length,
-      );
 
     return new AvmCircuitPublicInputs(
       this.globalVariables,
@@ -416,7 +410,7 @@ export class PublicTxContext {
       convertAccumulatedData(this.revertibleAccumulatedDataFromPrivate),
       endTreeSnapshots,
       this.getTotalGasUsed(),
-      getAvmAccumulatedDataArrayLengths(accumulatedData),
+      accumulatedDataArrayLengths,
       accumulatedData,
       /*transactionFee=*/ this.getTransactionFeeUnsafe(),
       /*isReverted=*/ !this.revertCode.isOK(),