@aztec/simulator 0.86.0 → 0.87.0

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

@@ -66,10 +66,11 @@ export class Set extends Instruction {
     const res = TaggedMemory.buildFromTagTruncating(this.value, this.inTag);
 
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.dstOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [dstOffset] = addressing.resolve(operands, memory);
     memory.set(dstOffset, res);
   }
@@ -94,16 +95,22 @@ export class Cast extends Instruction {
     OperandType.TAG,
   ];
 
-  constructor(private indirect: number, private srcOffset: number, private dstOffset: number, private dstTag: number) {
+  constructor(
+    private indirect: number,
+    private srcOffset: number,
+    private dstOffset: number,
+    private dstTag: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.srcOffset, this.dstOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [srcOffset, dstOffset] = addressing.resolve(operands, memory);
 
     const a = memory.get(srcOffset);
@@ -132,16 +139,21 @@ export class Mov extends Instruction {
     OperandType.UINT16,
   ];
 
-  constructor(private indirect: number, private srcOffset: number, private dstOffset: number) {
+  constructor(
+    private indirect: number,
+    private srcOffset: number,
+    private dstOffset: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.srcOffset, this.dstOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [srcOffset, dstOffset] = addressing.resolve(operands, memory);
     const a = memory.get(srcOffset);
     memory.set(dstOffset, a);
@@ -162,8 +174,8 @@ export class CalldataCopy extends Instruction {
 
   constructor(
     private indirect: number,
-    private cdStartOffset: number,
     private copySizeOffset: number,
+    private cdStartOffset: number,
     private dstOffset: number,
   ) {
     super();
@@ -171,9 +183,10 @@ export class CalldataCopy extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
-    const operands = [this.cdStartOffset, this.copySizeOffset, this.dstOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [cdStartOffset, copySizeOffset, dstOffset] = addressing.resolve(operands, memory);
+    const addressing = Addressing.fromWire(this.indirect);
+
+    const operands = [this.copySizeOffset, this.cdStartOffset, this.dstOffset];
+    const [copySizeOffset, cdStartOffset, dstOffset] = addressing.resolve(operands, memory);
 
     memory.checkTags(TypeTag.UINT32, cdStartOffset, copySizeOffset);
     const cdStart = memory.get(cdStartOffset).toNumber();
@@ -195,14 +208,18 @@ export class ReturndataSize extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16];
 
-  constructor(private indirect: number, private dstOffset: number) {
+  constructor(
+    private indirect: number,
+    private dstOffset: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     const operands = [this.dstOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [dstOffset] = addressing.resolve(operands, memory);
     context.machineState.consumeGas(this.gasCost());
 
@@ -224,8 +241,8 @@ export class ReturndataCopy extends Instruction {
 
   constructor(
     private indirect: number,
-    private rdStartOffset: number,
     private copySizeOffset: number,
+    private rdStartOffset: number,
     private dstOffset: number,
   ) {
     super();
@@ -233,9 +250,10 @@ export class ReturndataCopy extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
-    const operands = [this.rdStartOffset, this.copySizeOffset, this.dstOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [rdStartOffset, copySizeOffset, dstOffset] = addressing.resolve(operands, memory);
+    const addressing = Addressing.fromWire(this.indirect);
+
+    const operands = [this.copySizeOffset, this.rdStartOffset, this.dstOffset];
+    const [copySizeOffset, rdStartOffset, dstOffset] = addressing.resolve(operands, memory);
 
     memory.checkTags(TypeTag.UINT32, rdStartOffset, copySizeOffset);
     const rdStart = memory.get(rdStartOffset).toNumber();

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

@@ -33,28 +33,36 @@ export class DebugLog extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     const operands = [this.messageOffset, this.fieldsOffset, this.fieldsSizeOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [messageOffset, fieldsOffset, fieldsSizeOffset] = addressing.resolve(operands, memory);
-
     memory.checkTag(TypeTag.UINT32, fieldsSizeOffset);
-    const fieldsSize = memory.get(fieldsSizeOffset).toNumber();
 
-    const rawMessage = memory.getSlice(messageOffset, this.messageSize);
-    const fields = memory.getSlice(fieldsOffset, fieldsSize);
+    // 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')) {
+      const fieldsSize = memory.get(fieldsSizeOffset).toNumber();
+
+      const rawMessage = memory.getSlice(messageOffset, this.messageSize);
+      const fields = memory.getSlice(fieldsOffset, fieldsSize);
 
-    memory.checkTagsRange(TypeTag.UINT8, messageOffset, this.messageSize);
-    memory.checkTagsRange(TypeTag.FIELD, fieldsOffset, fieldsSize);
+      memory.checkTagsRange(TypeTag.UINT8, messageOffset, this.messageSize);
+      memory.checkTagsRange(TypeTag.FIELD, fieldsOffset, fieldsSize);
 
-    context.machineState.consumeGas(this.gasCost(this.messageSize + fieldsSize));
+      // Interpret str<N> = [u8; N] to string.
+      const messageAsStr = rawMessage.map(field => String.fromCharCode(field.toNumber())).join('');
+      const formattedStr = applyStringFormatting(
+        messageAsStr,
+        fields.map(field => field.toFr()),
+      );
 
-    // Interpret str<N> = [u8; N] to string.
-    const messageAsStr = rawMessage.map(field => String.fromCharCode(field.toNumber())).join('');
-    const formattedStr = applyStringFormatting(
-      messageAsStr,
-      fields.map(field => field.toFr()),
-    );
+      DebugLog.logger.verbose(formattedStr);
+    }
 
-    DebugLog.logger.verbose(formattedStr);
+    // Despite having dynamic "size" operands, the gas cost is fixed because
+    // this opcode is a no-op except during client-initiated simulation
+    context.machineState.consumeGas(this.gasCost());
   }
 }

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

@@ -14,7 +14,11 @@ abstract class BaseStorageInstruction extends Instruction {
     OperandType.UINT16,
   ];
 
-  constructor(protected indirect: number, protected aOffset: number, protected bOffset: number) {
+  constructor(
+    protected indirect: number,
+    protected aOffset: number,
+    protected bOffset: number,
+  ) {
     super();
   }
 }
@@ -33,10 +37,11 @@ export class SStore extends BaseStorageInstruction {
     }
 
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.aOffset, this.bOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [srcOffset, slotOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.FIELD, slotOffset);
     memory.checkTag(TypeTag.FIELD, srcOffset);
@@ -57,10 +62,11 @@ export class SLoad extends BaseStorageInstruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.aOffset, this.bOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [slotOffset, dstOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.FIELD, slotOffset);
 

package/src/public/avm/serialization/buffer_cursor.ts

@@ -2,7 +2,10 @@
  * A Buffer-like class that automatically advances the position.
  */
 export class BufferCursor {
-  constructor(private _buffer: Buffer, private _position: number = 0) {}
+  constructor(
+    private _buffer: Buffer,
+    private _position: number = 0,
+  ) {}
 
   public position(): number {
     return this._position;

package/src/public/executor_metrics.ts

@@ -17,7 +17,7 @@ export class ExecutorMetrics implements ExecutorMetricsInterface {
   private fnDuration: Histogram;
   private manaPerSecond: Histogram;
   private manaUsed: Histogram;
-  private totalInstructions: Histogram;
+  private totalInstructionsExecuted: Histogram;
   private txHashing: Histogram;
   private privateEffectsInsertions: Histogram;
 
@@ -47,9 +47,9 @@ export class ExecutorMetrics implements ExecutorMetricsInterface {
       valueType: ValueType.INT,
     });
 
-    this.totalInstructions = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_SIMULATION_TOTAL_INSTRUCTIONS, {
+    this.totalInstructionsExecuted = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_SIMULATION_TOTAL_INSTRUCTIONS, {
       description: 'Total number of instructions executed',
-      unit: 'instructions',
+      unit: '#instructions',
       valueType: ValueType.INT,
     });
 
@@ -74,7 +74,12 @@ export class ExecutorMetrics implements ExecutorMetricsInterface {
     // do nothing (unimplemented)
   }
 
-  recordEnqueuedCallSimulation(fnName: string, durationMs: number, manaUsed: number, totalInstructions: number) {
+  recordEnqueuedCallSimulation(
+    fnName: string,
+    durationMs: number,
+    manaUsed: number,
+    totalInstructionsExecuted: number,
+  ) {
     this.fnCount.add(1, {
       [Attributes.OK]: true,
       [Attributes.APP_CIRCUIT_NAME]: fnName,
@@ -82,7 +87,7 @@ export class ExecutorMetrics implements ExecutorMetricsInterface {
     this.manaUsed.record(Math.ceil(manaUsed), {
       [Attributes.APP_CIRCUIT_NAME]: fnName,
     });
-    this.totalInstructions.record(Math.ceil(totalInstructions), {
+    this.totalInstructionsExecuted.record(Math.ceil(totalInstructionsExecuted), {
       [Attributes.APP_CIRCUIT_NAME]: fnName,
     });
     this.fnDuration.record(Math.ceil(durationMs), {
@@ -100,7 +105,7 @@ export class ExecutorMetrics implements ExecutorMetricsInterface {
     _fnName: string,
     _durationMs: number,
     _manaUsed: number,
-    _totalInstructions: number,
+    _totalInstructionsExecuted: number,
   ) {
     this.fnCount.add(1, {
       [Attributes.OK]: false,

package/src/public/executor_metrics_interface.ts

@@ -8,7 +8,7 @@ export interface ExecutorMetricsInterface {
     fnName: string,
     durationMs: number,
     manaUsed: number,
-    totalInstructions: number,
+    totalInstructionsExecuted: number,
   ): void;
   recordTxHashComputation(durationMs: number): void;
   recordPrivateEffectsInsertion(durationUs: number, type: 'revertible' | 'non-revertible'): void;

package/src/public/fixtures/public_tx_simulation_tester.ts

@@ -54,6 +54,7 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
       globals,
       /*doMerkleOperations=*/ true,
       /*skipFeeEnforcement=*/ false,
+      /*clientInitiatedSimulation=*/ true,
       this.metrics,
     );
   }
@@ -107,8 +108,8 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
 
     await this.setFeePayerBalance(feePayer);
 
-    const txLabelWithCount = `${txLabel}.${this.txCount - 1}`;
-    const fullTxLabel = this.metricsPrefix ? `${this.metricsPrefix}.${txLabelWithCount}` : txLabelWithCount;
+    const txLabelWithCount = `${txLabel}/${this.txCount - 1}`;
+    const fullTxLabel = this.metricsPrefix ? `${this.metricsPrefix}/${txLabelWithCount}` : txLabelWithCount;
 
     const avmResult = await this.simulator.simulate(tx, fullTxLabel);
 

package/src/public/fixtures/utils.ts

@@ -1,5 +1,4 @@
 import {
-  CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS,
   DEFAULT_GAS_LIMIT,
   DEPLOYER_CONTRACT_ADDRESS,
   MAX_L2_GAS_PER_TX_PUBLIC_PORTION,
@@ -7,8 +6,8 @@ import {
   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 { assertLength } from '@aztec/foundation/serialize';
 import { DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG } from '@aztec/protocol-contracts';
 import { bufferAsFields } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -16,14 +15,14 @@ import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/st
 import { Gas, GasFees, GasSettings } from '@aztec/stdlib/gas';
 import { siloNullifier } from '@aztec/stdlib/hash';
 import {
+  LogHash,
   PartialPrivateTailPublicInputsForPublic,
   PartialPrivateTailPublicInputsForRollup,
   PrivateKernelTailCircuitPublicInputs,
   RollupValidationRequests,
-  ScopedLogHash,
   countAccumulatedItems,
 } from '@aztec/stdlib/kernel';
-import { ContractClassLog, PrivateLog } from '@aztec/stdlib/logs';
+import { ContractClassLogFields, PrivateLog } from '@aztec/stdlib/logs';
 import { ClientIvcProof } from '@aztec/stdlib/proofs';
 import {
   BlockHeader,
@@ -58,13 +57,11 @@ export function createTxForPublicCalls(
   // TODO(#9269): Remove this fake nullifier method as we move away from 1st nullifier as hash.
   forPublic.nonRevertibleAccumulatedData.nullifiers[0] = firstNullifier;
 
-  // We reverse order because the simulator expects it to be like a "stack" of calls to pop from
-  for (let i = setupCallRequests.length - 1; i >= 0; i--) {
-    forPublic.nonRevertibleAccumulatedData.publicCallRequests[setupCallRequests.length - i - 1] =
-      setupCallRequests[i].request;
+  for (let i = 0; i < setupCallRequests.length; i++) {
+    forPublic.nonRevertibleAccumulatedData.publicCallRequests[i] = setupCallRequests[i].request;
   }
-  for (let i = appCallRequests.length - 1; i >= 0; i--) {
-    forPublic.revertibleAccumulatedData.publicCallRequests[appCallRequests.length - i - 1] = appCallRequests[i].request;
+  for (let i = 0; i < appCallRequests.length; i++) {
+    forPublic.revertibleAccumulatedData.publicCallRequests[i] = appCallRequests[i].request;
   }
   if (teardownCallRequest) {
     forPublic.publicTeardownCallRequest = teardownCallRequest.request;
@@ -128,18 +125,14 @@ export async function addNewContractClassToTx(
     new Fr(contractClass.privateFunctionsRoot),
     ...bufferAsFields(contractClass.packedBytecode, Math.ceil(contractClass.packedBytecode.length / 31) + 1),
   ];
-  const contractClassLog = ContractClassLog.fromFields([
-    new Fr(REGISTERER_CONTRACT_ADDRESS),
-    ...contractClassLogFields.concat(
-      new Array(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS - contractClassLogFields.length).fill(Fr.ZERO),
-    ),
-  ]);
-  const contractClassLogHash = ScopedLogHash.fromFields([
-    await contractClassLog.hash(),
-    new Fr(7),
-    new Fr(contractClassLog.getEmittedLength()),
-    new Fr(REGISTERER_CONTRACT_ADDRESS),
-  ]);
+  const contractAddress = new AztecAddress(new Fr(REGISTERER_CONTRACT_ADDRESS));
+  const emittedLength = contractClassLogFields.length;
+  const log = ContractClassLogFields.fromEmittedFields(contractClassLogFields);
+
+  const contractClassLogHash = LogHash.from({
+    value: await log.hash(),
+    length: emittedLength,
+  }).scope(contractAddress);
 
   const accumulatedData = tx.data.forPublic ? tx.data.forPublic!.revertibleAccumulatedData : tx.data.forRollup!.end;
   if (!skipNullifierInsertion) {
@@ -150,7 +143,7 @@ export async function addNewContractClassToTx(
   const nextLogIndex = countAccumulatedItems(accumulatedData.contractClassLogsHashes);
   accumulatedData.contractClassLogsHashes[nextLogIndex] = contractClassLogHash;
 
-  tx.contractClassLogs.push(contractClassLog);
+  tx.contractClassLogs.push(log);
 }
 
 export async function addNewContractInstanceToTx(
@@ -170,7 +163,7 @@ export async function addNewContractInstanceToTx(
     contractInstance.publicKeys.masterTaggingPublicKey.x,
     contractInstance.publicKeys.masterTaggingPublicKey.y,
   ];
-  const fields = [
+  const logFields = [
     DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG,
     contractInstance.address.toField(),
     new Fr(contractInstance.version),
@@ -179,11 +172,11 @@ export async function addNewContractInstanceToTx(
     contractInstance.initializationHash,
     ...publicKeysAsFields,
     contractInstance.deployer.toField(),
-    new Fr(0),
-    new Fr(0),
-    new Fr(0),
   ];
-  const contractInstanceLog = new PrivateLog(assertLength(fields, PRIVATE_LOG_SIZE_IN_FIELDS));
+  const contractInstanceLog = new PrivateLog(
+    padArrayEnd(logFields, Fr.ZERO, PRIVATE_LOG_SIZE_IN_FIELDS),
+    logFields.length,
+  );
 
   const contractAddressNullifier = await siloNullifier(
     AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),

package/src/public/hinting_db_sources.ts

@@ -47,7 +47,10 @@ import type { PublicContractsDBInterface } from './db_interfaces.js';
  * A public contracts database that forwards requests and collects AVM hints.
  */
 export class HintingPublicContractsDB implements PublicContractsDBInterface {
-  constructor(private readonly db: PublicContractsDBInterface, private hints: AvmExecutionHints) {}
+  constructor(
+    private readonly db: PublicContractsDBInterface,
+    private hints: AvmExecutionHints,
+  ) {}
 
   public async getContractInstance(
     address: AztecAddress,
@@ -129,7 +132,10 @@ export class HintingMerkleWriteOperations implements MerkleTreeWriteOperations {
   }
 
   // Use create() to instantiate.
-  private constructor(private db: MerkleTreeWriteOperations, private hints: AvmExecutionHints) {}
+  private constructor(
+    private db: MerkleTreeWriteOperations,
+    private hints: AvmExecutionHints,
+  ) {}
 
   // Getters.
   public async getSiblingPath<N extends number>(treeId: MerkleTreeId, index: bigint): Promise<SiblingPath<N>> {
@@ -284,8 +290,15 @@ export class HintingMerkleWriteOperations implements MerkleTreeWriteOperations {
 
     // We need to process each leaf individually because we need the sibling path after insertion, to be able to constraint the insertion.
     // TODO(https://github.com/AztecProtocol/aztec-packages/issues/13380): This can be changed if the world state appendLeaves returns the sibling paths.
-    for (const leaf of leaves) {
-      await this.appendLeafInternal(treeId, leaf);
+    if (leaves.length === 1) {
+      await this.appendLeafInternal(treeId, leaves[0]);
+      return;
+    } else {
+      // TODO(dbanks12): NON-HINTING! We skip hinting here for now because:
+      // 1. We only ever append multiple leaves (for now) when padding (all empty leaves).
+      // 2. We don't need hints per-item when padding.
+      // 3. In order to get per-item hints today, you need to append one-at-a-time (mentioned above), which is VERY slow.
+      await this.db.appendLeaves<ID>(treeId, leaves);
     }
   }
 

package/src/public/public_processor/public_processor.ts

@@ -2,7 +2,7 @@ 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 { type DateProvider, Timer, elapsed, executeTimeout } from '@aztec/foundation/timer';
+import { DateProvider, Timer, elapsed, executeTimeout } from '@aztec/foundation/timer';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
 import { computeFeePayerBalanceLeafSlot, computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
@@ -43,7 +43,7 @@ import { PublicProcessorMetrics } from './public_processor_metrics.js';
 export class PublicProcessorFactory {
   constructor(
     private contractDataSource: ContractDataSource,
-    private dateProvider: DateProvider,
+    private dateProvider: DateProvider = new DateProvider(),
     protected telemetryClient: TelemetryClient = getTelemetryClient(),
   ) {}
 
@@ -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/apps_tests/amm_test.ts

@@ -34,7 +34,7 @@ export async function ammTest(tester: PublicTxSimulationTester, logger: Logger)
   );
 
   const ammConstructorResult = await tester.simulateTxWithLabel(
-    /*txLabel=*/ 'constructor',
+    /*txLabel=*/ 'AMM/constructor',
     /*sender=*/ admin,
     /*setupCalls=*/ [],
     /*appCalls=*/ [
@@ -51,7 +51,7 @@ export async function ammTest(tester: PublicTxSimulationTester, logger: Logger)
 
   // set the AMM as the minter for the liquidity token
   const setMinterResult = await tester.simulateTxWithLabel(
-    /*txLabel=*/ 'set_minter',
+    /*txLabel=*/ 'AMM/set_minter',
     /*sender=*/ admin,
     /*setupCalls=*/ [],
     /*appCalls=*/ [
@@ -139,7 +139,7 @@ async function addLiquidity(
   };
 
   return await tester.simulateTxWithLabel(
-    /*txLabel=*/ 'add_liquidity',
+    /*txLabel=*/ 'AMM/add_liquidity',
     /*sender=*/ sender,
     /*setupCalls=*/ [],
     /*appCalls=*/ [
@@ -218,7 +218,7 @@ async function swapExactTokensForTokens(
   };
 
   return await tester.simulateTxWithLabel(
-    /*txLabel=*/ 'swap_exact_tokens_for_tokens',
+    /*txLabel=*/ 'AMM/swap_exact_tokens_for_tokens',
     /*sender=*/ sender,
     /*setupCalls=*/ [],
     /*appCalls=*/ [
@@ -267,7 +267,7 @@ async function removeLiquidity(
   };
 
   return await tester.simulateTxWithLabel(
-    /*txLabel=*/ 'remove_liquidity',
+    /*txLabel=*/ 'AMM/remove_liquidity',
     /*sender=*/ sender,
     /*setupCalls=*/ [],
     /*appCalls=*/ [

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

@@ -17,7 +17,7 @@ export async function tokenTest(tester: PublicTxSimulationTester, logger: Logger
 
   const mintAmount = 100n;
   const mintResult = await tester.simulateTxWithLabel(
-    /*txLabel=*/ 'mint_to_public',
+    /*txLabel=*/ 'Token/mint_to_public',
     /*sender=*/ admin,
     /*setupCalls=*/ [],
     /*appCalls=*/ [
@@ -34,7 +34,7 @@ export async function tokenTest(tester: PublicTxSimulationTester, logger: Logger
   const nonce = new Fr(0);
   const transferAmount = 50n;
   const transferResult = await tester.simulateTxWithLabel(
-    /*txLabel=*/ 'transfer_in_public',
+    /*txLabel=*/ 'Token/transfer_in_public',
     /*sender=*/ sender,
     /*setupCalls=*/ [],
     /*appCalls=*/ [
@@ -50,7 +50,7 @@ export async function tokenTest(tester: PublicTxSimulationTester, logger: Logger
   await checkBalance(tester, token, sender, receiver, transferAmount);
 
   const balResult = await tester.simulateTxWithLabel(
-    /*txLabel=*/ 'balance_of_public',
+    /*txLabel=*/ 'Token/balance_of_public',
     sender,
     /*setupCalls=*/ [],
     /*appCalls=*/ [
@@ -65,7 +65,7 @@ export async function tokenTest(tester: PublicTxSimulationTester, logger: Logger
   expect(balResult.revertCode.isOK()).toBe(true);
 
   const burnResult = await tester.simulateTxWithLabel(
-    /*txLabel=*/ 'burn_public',
+    /*txLabel=*/ 'Token/burn_public',
     /*sender=*/ receiver,
     /*setupCalls=*/ [],
     /*appCalls=*/ [
@@ -95,7 +95,7 @@ export async function deployToken(tester: PublicTxSimulationTester, admin: Aztec
   );
 
   const result = await tester.simulateTxWithLabel(
-    /*txLabel=*/ 'Token.constructor',
+    /*txLabel=*/ 'Token/constructor',
     /*sender=*/ admin,
     /*setupCalls=*/ [],
     /*appCalls=*/ [
@@ -118,7 +118,7 @@ async function checkBalance(
   expectedBalance: bigint,
 ) {
   const balResult = await tester.simulateTxWithLabel(
-    /*txLabel=*/ 'balance_of_public',
+    /*txLabel=*/ 'Token/balance_of_public',
     sender,
     /*setupCalls=*/ [],
     /*appCalls=*/ [