@aztec/simulator 0.70.0 → 0.72.1

package/src/public/enqueued_call_side_effect_trace.ts

@@ -1,4 +1,3 @@
-import { UnencryptedFunctionL2Logs, UnencryptedL2Log } from '@aztec/circuit-types';
 import {
   AvmAccumulatedData,
   AvmAppendTreeHint,
@@ -19,15 +18,14 @@ import {
   type GlobalVariables,
   L1_TO_L2_MSG_TREE_HEIGHT,
   L2ToL1Message,
-  LogHash,
   MAX_ENQUEUED_CALLS_PER_TX,
   MAX_L2_TO_L1_MSGS_PER_TX,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
   MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+  MAX_PUBLIC_LOGS_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  MAX_UNENCRYPTED_LOGS_PER_TX,
   NOTE_HASH_TREE_HEIGHT,
   NULLIFIER_TREE_HEIGHT,
   NoteHash,
@@ -35,14 +33,15 @@ import {
   NullifierLeafPreimage,
   PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   PUBLIC_DATA_TREE_HEIGHT,
+  PUBLIC_LOG_DATA_SIZE_IN_FIELDS,
   PrivateToAvmAccumulatedData,
   PrivateToAvmAccumulatedDataArrayLengths,
   PublicCallRequest,
   PublicDataTreeLeafPreimage,
   PublicDataUpdateRequest,
   PublicDataWrite,
+  PublicLog,
   ScopedL2ToL1Message,
-  ScopedLogHash,
   SerializableContractInstance,
   type TreeSnapshots,
 } from '@aztec/circuits.js';
@@ -79,8 +78,7 @@ export type SideEffects = {
   nullifiers: Nullifier[];
   l2ToL1Msgs: ScopedL2ToL1Message[];
 
-  unencryptedLogs: UnencryptedL2Log[];
-  unencryptedLogsHashes: ScopedLogHash[];
+  publicLogs: PublicLog[];
 };
 
 export class SideEffectArrayLengths {
@@ -90,7 +88,7 @@ export class SideEffectArrayLengths {
     public readonly noteHashes: number,
     public readonly nullifiers: number,
     public readonly l2ToL1Msgs: number,
-    public readonly unencryptedLogs: number,
+    public readonly publicLogs: number,
   ) {}
 
   static empty() {
@@ -115,8 +113,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
   private noteHashes: NoteHash[] = [];
   private nullifiers: Nullifier[] = [];
   private l2ToL1Messages: ScopedL2ToL1Message[] = [];
-  private unencryptedLogs: UnencryptedL2Log[] = [];
-  private unencryptedLogsHashes: ScopedLogHash[] = [];
+  private publicLogs: PublicLog[] = [];
 
   private avmCircuitHints: AvmExecutionHints;
 
@@ -147,7 +144,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
         this.previousSideEffectArrayLengths.noteHashes + this.noteHashes.length,
         this.previousSideEffectArrayLengths.nullifiers + this.nullifiers.length,
         this.previousSideEffectArrayLengths.l2ToL1Msgs + this.l2ToL1Messages.length,
-        this.previousSideEffectArrayLengths.unencryptedLogs + this.unencryptedLogs.length,
+        this.previousSideEffectArrayLengths.publicLogs + this.publicLogs.length,
       ),
       this.gotBytecodeFromClassIds.fork(),
     );
@@ -169,8 +166,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
       this.noteHashes.push(...forkedTrace.noteHashes);
       this.nullifiers.push(...forkedTrace.nullifiers);
       this.l2ToL1Messages.push(...forkedTrace.l2ToL1Messages);
-      this.unencryptedLogs.push(...forkedTrace.unencryptedLogs);
-      this.unencryptedLogsHashes.push(...forkedTrace.unencryptedLogsHashes);
+      this.publicLogs.push(...forkedTrace.publicLogs);
     }
     this.mergeHints(forkedTrace);
   }
@@ -359,23 +355,17 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     this.incrementSideEffectCounter();
   }
 
-  public traceUnencryptedLog(contractAddress: AztecAddress, log: Fr[]) {
-    if (
-      this.unencryptedLogs.length + this.previousSideEffectArrayLengths.unencryptedLogs >=
-      MAX_UNENCRYPTED_LOGS_PER_TX
-    ) {
-      throw new SideEffectLimitReachedError('unencrypted log', MAX_UNENCRYPTED_LOGS_PER_TX);
+  public tracePublicLog(contractAddress: AztecAddress, log: Fr[]) {
+    if (this.publicLogs.length + this.previousSideEffectArrayLengths.publicLogs >= MAX_PUBLIC_LOGS_PER_TX) {
+      throw new SideEffectLimitReachedError('public log', MAX_PUBLIC_LOGS_PER_TX);
     }
 
-    const ulog = new UnencryptedL2Log(contractAddress, Buffer.concat(log.map(f => f.toBuffer())));
-    const basicLogHash = Fr.fromBuffer(ulog.hash());
-    this.unencryptedLogs.push(ulog);
-    // This length is for charging DA and is checked on-chain - has to be length of log preimage + 4 bytes.
-    // The .length call also has a +4 but that is unrelated
-    this.unencryptedLogsHashes.push(
-      new LogHash(basicLogHash, this.sideEffectCounter, new Fr(ulog.length + 4)).scope(contractAddress),
-    );
-    this.log.debug(`NEW_UNENCRYPTED_LOG cnt: ${this.sideEffectCounter}`);
+    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}`);
+    }
+    const publicLog = new PublicLog(contractAddress, padArrayEnd(log, Fr.ZERO, PUBLIC_LOG_DATA_SIZE_IN_FIELDS));
+    this.publicLogs.push(publicLog);
+    this.log.debug(`NEW_PUBLIC_LOG cnt: ${this.sideEffectCounter}`);
     this.incrementSideEffectCounter();
   }
 
@@ -518,8 +508,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
       noteHashes: this.noteHashes,
       nullifiers: this.nullifiers,
       l2ToL1Msgs: this.l2ToL1Messages,
-      unencryptedLogs: this.unencryptedLogs,
-      unencryptedLogsHashes: this.unencryptedLogsHashes,
+      publicLogs: this.publicLogs,
     };
   }
 
@@ -541,8 +530,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
         noteHashes: this.noteHashes,
         nullifiers: this.nullifiers,
         l2ToL1Messages: this.l2ToL1Messages,
-        unencryptedLogsHashes: this.unencryptedLogsHashes, // Scoped?
-        unencryptedLogs: new UnencryptedFunctionL2Logs(this.unencryptedLogs),
+        publicLogs: this.publicLogs,
       },
     };
   }
@@ -612,8 +600,8 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     throw new Error('Not implemented');
   }
 
-  public getUnencryptedLogs() {
-    return this.unencryptedLogs;
+  public getPublicLogs() {
+    return this.publicLogs;
   }
 
   public getAvmCircuitHints() {
@@ -633,7 +621,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
         MAX_NULLIFIERS_PER_TX,
       ),
       padArrayEnd(this.l2ToL1Messages, ScopedL2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_TX),
-      padArrayEnd(this.unencryptedLogsHashes, ScopedLogHash.empty(), MAX_UNENCRYPTED_LOGS_PER_TX),
+      padArrayEnd(this.publicLogs, PublicLog.empty(), MAX_PUBLIC_LOGS_PER_TX),
       padArrayEnd(
         this.publicDataWrites.map(w => new PublicDataWrite(w.leafSlot, w.newValue)),
         PublicDataWrite.empty(),

package/src/public/execution.ts

@@ -1,8 +1,4 @@
-import {
-  type PublicExecutionRequest,
-  type SimulationError,
-  type UnencryptedFunctionL2Logs,
-} from '@aztec/circuit-types';
+import { type PublicExecutionRequest, type SimulationError } from '@aztec/circuit-types';
 import {
   type AvmExecutionHints,
   type ContractStorageRead,
@@ -10,16 +6,15 @@ import {
   type Fr,
   Gas,
   type L2ToL1Message,
-  type LogHash,
   type NoteHash,
   type Nullifier,
   PublicCallStackItemCompressed,
   type PublicDataUpdateRequest,
   PublicInnerCallRequest,
+  type PublicLog,
   type ReadRequest,
   RevertCode,
   type ScopedL2ToL1Message,
-  type ScopedLogHash,
   type TreeLeafReadRequest,
 } from '@aztec/circuits.js';
 import { computeVarArgsHash } from '@aztec/circuits.js/hash';
@@ -33,16 +28,8 @@ export interface PublicSideEffects {
   nullifiers: Nullifier[];
   /** The new l2 to l1 messages generated to be inserted into the messages tree. */
   l2ToL1Messages: ScopedL2ToL1Message[];
-  /**
-   * The hashed logs with side effect counter.
-   * Note: required as we don't track the counter anywhere else.
-   */
-  unencryptedLogsHashes: ScopedLogHash[];
-  /**
-   * Unencrypted logs emitted during execution.
-   * Note: These are preimages to `unencryptedLogsHashes`.
-   */
-  unencryptedLogs: UnencryptedFunctionL2Logs;
+  /** Public logs emitted during execution. */
+  publicLogs: PublicLog[];
 }
 
 export interface EnqueuedPublicCallExecutionResult {
@@ -124,21 +111,10 @@ export interface PublicFunctionCallResult {
   /** L1 to L2 message read requests emitted in this call. */
   l1ToL2MsgReadRequests: TreeLeafReadRequest[];
   /**
-   * The hashed logs with side effect counter.
-   * Note: required as we don't track the counter anywhere else.
+   * The public logs emitted in this call.
+   * Note: PublicLog has no counter - unsure if this is needed bc this struct is unused
    */
-  unencryptedLogsHashes: LogHash[];
-  /**
-   * Unencrypted logs emitted during execution of this function call.
-   * Note: These are preimages to `unencryptedLogsHashes`.
-   */
-  unencryptedLogs: UnencryptedFunctionL2Logs;
-  /**
-   * Unencrypted logs emitted during this call AND any nested calls.
-   * Useful for maintaining correct ordering in ts.
-   */
-  allUnencryptedLogs: UnencryptedFunctionL2Logs;
-
+  publicLogs: PublicLog[];
   /** The requests to call public functions made by this call. */
   publicCallRequests: PublicInnerCallRequest[];
   /** The results of nested calls. */

package/src/public/fixtures/index.ts

@@ -32,7 +32,6 @@ import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr, Point } from '@aztec/foundation/fields';
 import { openTmpStore } from '@aztec/kv-store/lmdb';
 import { AvmTestContractArtifact } from '@aztec/noir-contracts.js/AvmTest';
-import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 import { MerkleTrees } from '@aztec/world-state';
 
 import { strict as assert } from 'assert';
@@ -53,25 +52,22 @@ export async function simulateAvmTestContractGenerateCircuitInputs(
   teardownFunctionName?: string,
   teardownArgs: Fr[] = [],
   expectRevert: boolean = false,
-  contractDataSource = new MockedAvmTestContractDataSource(),
+  contractDataSource?: MockedAvmTestContractDataSource,
   assertionErrString?: string,
 ): Promise<AvmCircuitInputs> {
   const globals = GlobalVariables.empty();
   globals.timestamp = TIMESTAMP;
 
-  const merkleTrees = await (await MerkleTrees.new(openTmpStore(), new NoopTelemetryClient())).fork();
+  const merkleTrees = await (await MerkleTrees.new(openTmpStore())).fork();
+  if (!contractDataSource) {
+    contractDataSource = await MockedAvmTestContractDataSource.create();
+  }
   await contractDataSource.deployContracts(merkleTrees);
   const worldStateDB = new WorldStateDB(merkleTrees, contractDataSource);
 
-  const simulator = new PublicTxSimulator(
-    merkleTrees,
-    worldStateDB,
-    new NoopTelemetryClient(),
-    globals,
-    /*doMerkleOperations=*/ true,
-  );
+  const simulator = new PublicTxSimulator(merkleTrees, worldStateDB, globals, /*doMerkleOperations=*/ true);
 
-  const sender = AztecAddress.random();
+  const sender = await AztecAddress.random();
   const callContext = new CallContext(
     sender,
     contractDataSource.firstContractInstance.address,
@@ -79,16 +75,14 @@ export async function simulateAvmTestContractGenerateCircuitInputs(
     /*isStaticCall=*/ false,
   );
   const setupExecutionRequests: PublicExecutionRequest[] = [];
-  // we reverse order because the simulator expects it to be like a "stack" of calls to pop from
-  for (let i = setupFunctionNames.length - 1; i >= 0; i--) {
+  for (let i = 0; i < setupFunctionNames.length; i++) {
     const functionSelector = getAvmTestContractFunctionSelector(setupFunctionNames[i]);
     const fnArgs = [functionSelector.toField(), ...setupArgs[i]];
     const executionRequest = new PublicExecutionRequest(callContext, fnArgs);
     setupExecutionRequests.push(executionRequest);
   }
   const appExecutionRequests: PublicExecutionRequest[] = [];
-  // we reverse order because the simulator expects it to be like a "stack" of calls to pop from
-  for (let i = appFunctionNames.length - 1; i >= 0; i--) {
+  for (let i = 0; i < appFunctionNames.length; i++) {
     const functionSelector = getAvmTestContractFunctionSelector(appFunctionNames[i]);
     const fnArgs = [functionSelector.toField(), ...appArgs[i]];
     const executionRequest = new PublicExecutionRequest(callContext, fnArgs);
@@ -102,7 +96,12 @@ export async function simulateAvmTestContractGenerateCircuitInputs(
     teardownExecutionRequest = new PublicExecutionRequest(callContext, fnArgs);
   }
 
-  const tx: Tx = createTxForPublicCalls(setupExecutionRequests, appExecutionRequests, teardownExecutionRequest);
+  const tx: Tx = createTxForPublicCalls(
+    setupExecutionRequests,
+    appExecutionRequests,
+    Fr.random(),
+    teardownExecutionRequest,
+  );
 
   const avmResult = await simulator.simulate(tx);
 
@@ -125,12 +124,16 @@ export async function simulateAvmTestContractCall(
   functionName: string,
   args: Fr[] = [],
   expectRevert: boolean = false,
-  contractDataSource = new MockedAvmTestContractDataSource(),
+  contractDataSource?: MockedAvmTestContractDataSource,
 ) {
   const globals = GlobalVariables.empty();
   globals.timestamp = TIMESTAMP;
 
-  const merkleTrees = await (await MerkleTrees.new(openTmpStore(), new NoopTelemetryClient())).fork();
+  if (!contractDataSource) {
+    contractDataSource = await MockedAvmTestContractDataSource.create();
+  }
+
+  const merkleTrees = await (await MerkleTrees.new(openTmpStore())).fork();
   await contractDataSource.deployContracts(merkleTrees);
   const worldStateDB = new WorldStateDB(merkleTrees, contractDataSource);
 
@@ -143,7 +146,7 @@ export async function simulateAvmTestContractCall(
     doMerkleOperations: true,
   });
 
-  const sender = AztecAddress.random();
+  const sender = await AztecAddress.random();
   const functionSelector = getAvmTestContractFunctionSelector(functionName);
   args = [functionSelector.toField(), ...args];
   const environment = initExecutionEnvironment({
@@ -167,6 +170,7 @@ export async function simulateAvmTestContractCall(
 export function createTxForPublicCalls(
   setupExecutionRequests: PublicExecutionRequest[],
   appExecutionRequests: PublicExecutionRequest[],
+  firstNullifier: Fr,
   teardownExecutionRequest?: PublicExecutionRequest,
   gasUsedByPrivate: Gas = Gas.empty(),
 ): Tx {
@@ -181,12 +185,13 @@ export function createTxForPublicCalls(
 
   const forPublic = PartialPrivateTailPublicInputsForPublic.empty();
   // TODO(#9269): Remove this fake nullifier method as we move away from 1st nullifier as hash.
-  forPublic.nonRevertibleAccumulatedData.nullifiers[0] = Fr.random(); // fake tx nullifier
+  forPublic.nonRevertibleAccumulatedData.nullifiers[0] = firstNullifier; // fake tx nullifier
 
-  for (let i = 0; i < setupExecutionRequests.length; i++) {
+  // 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[i] = setupCallRequests[i];
   }
-  for (let i = 0; i < appCallRequests.length; i++) {
+  for (let i = appCallRequests.length - 1; i >= 0; i--) {
     forPublic.revertibleAccumulatedData.publicCallRequests[i] = appCallRequests[i];
   }
   if (teardownExecutionRequest) {
@@ -207,12 +212,14 @@ export function createTxForPublicCalls(
   );
   const tx = Tx.newWithTxData(txData, teardownExecutionRequest);
 
-  for (let i = 0; i < setupExecutionRequests.length; i++) {
-    tx.enqueuedPublicFunctionCalls.push(setupExecutionRequests[i]);
-  }
-  for (let i = 0; i < appExecutionRequests.length; i++) {
+  // Reverse order because the simulator expects it to be like a "stack" of calls to pop from.
+  // Also push app calls before setup calls for this reason.
+  for (let i = appExecutionRequests.length - 1; i >= 0; i--) {
     tx.enqueuedPublicFunctionCalls.push(appExecutionRequests[i]);
   }
+  for (let i = setupExecutionRequests.length - 1; i >= 0; i--) {
+    tx.enqueuedPublicFunctionCalls.push(setupExecutionRequests[i]);
+  }
 
   return tx;
 }
@@ -234,45 +241,13 @@ export class MockedAvmTestContractDataSource implements ContractDataSource {
   );
   public instanceSameClassAsFirstContract: ContractInstanceWithAddress =
     SerializableContractInstance.default().withAddress(AztecAddress.fromNumber(0));
-  public otherContractInstance: ContractInstanceWithAddress;
+  public otherContractInstance!: ContractInstanceWithAddress;
 
-  constructor(private skipContractDeployments: boolean = false) {
+  private constructor(private skipContractDeployments: boolean) {
     this.bytecode = getAvmTestContractBytecode(this.fnName);
     this.fnSelector = getAvmTestContractFunctionSelector(this.fnName);
     this.publicFn = { bytecode: this.bytecode, selector: this.fnSelector };
     this.bytecodeCommitment = computePublicBytecodeCommitment(this.bytecode);
-
-    // create enough unique classes to hit the limit (plus two extra)
-    for (let i = 0; i < MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS + 1; i++) {
-      const contractClass = makeContractClassPublic(/*seed=*/ i, this.publicFn);
-      const contractInstance = makeContractInstanceFromClassId(contractClass.id, /*seed=*/ i);
-      this.contractClasses.set(contractClass.id.toString(), contractClass);
-      this.contractInstances.set(contractInstance.address.toString(), contractInstance);
-      if (i === 0) {
-        this.firstContractInstance = contractInstance;
-      }
-    }
-    // a contract with the same class but different instance/address as the first contract
-    this.instanceSameClassAsFirstContract = makeContractInstanceFromClassId(
-      this.firstContractInstance.contractClassId,
-      /*seed=*/ 1000,
-    );
-
-    // The values here should match those in `avm_simulator.test.ts`
-    // Used for GETCONTRACTINSTANCE test
-    this.otherContractInstance = new SerializableContractInstance({
-      version: 1,
-      salt: new Fr(0x123),
-      deployer: new AztecAddress(new Fr(0x456)),
-      contractClassId: new Fr(0x789),
-      initializationHash: new Fr(0x101112),
-      publicKeys: new PublicKeys(
-        new Point(new Fr(0x131415), new Fr(0x161718), false),
-        new Point(new Fr(0x192021), new Fr(0x222324), false),
-        new Point(new Fr(0x252627), new Fr(0x282930), false),
-        new Point(new Fr(0x313233), new Fr(0x343536), false),
-      ),
-    }).withAddress(AztecAddress.fromNumber(0x4444));
   }
 
   async deployContracts(merkleTrees: MerkleTreeWriteOperations) {
@@ -304,14 +279,39 @@ export class MockedAvmTestContractDataSource implements ContractDataSource {
     }
   }
 
-  public static async create(
-    merkleTrees: MerkleTreeWriteOperations,
-    skipContractDeployments: boolean = false,
-  ): Promise<MockedAvmTestContractDataSource> {
+  public static async create(skipContractDeployments: boolean = false): Promise<MockedAvmTestContractDataSource> {
     const dataSource = new MockedAvmTestContractDataSource(skipContractDeployments);
-    if (!skipContractDeployments) {
-      await dataSource.deployContracts(merkleTrees);
+    // create enough unique classes to hit the limit (plus two extra)
+    for (let i = 0; i < MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS + 1; i++) {
+      const contractClass = makeContractClassPublic(/*seed=*/ i, dataSource.publicFn);
+      const contractInstance = await makeContractInstanceFromClassId(contractClass.id, /*seed=*/ i);
+      dataSource.contractClasses.set(contractClass.id.toString(), contractClass);
+      dataSource.contractInstances.set(contractInstance.address.toString(), contractInstance);
+      if (i === 0) {
+        dataSource.firstContractInstance = contractInstance;
+      }
     }
+    // a contract with the same class but different instance/address as the first contract
+    dataSource.instanceSameClassAsFirstContract = await makeContractInstanceFromClassId(
+      dataSource.firstContractInstance.contractClassId,
+      /*seed=*/ 1000,
+    );
+
+    // The values here should match those in `avm_simulator.test.ts`
+    // Used for GETCONTRACTINSTANCE test
+    dataSource.otherContractInstance = new SerializableContractInstance({
+      version: 1,
+      salt: new Fr(0x123),
+      deployer: new AztecAddress(new Fr(0x456)),
+      contractClassId: new Fr(0x789),
+      initializationHash: new Fr(0x101112),
+      publicKeys: new PublicKeys(
+        new Point(new Fr(0x131415), new Fr(0x161718), false),
+        new Point(new Fr(0x192021), new Fr(0x222324), false),
+        new Point(new Fr(0x252627), new Fr(0x282930), false),
+        new Point(new Fr(0x313233), new Fr(0x343536), false),
+      ),
+    }).withAddress(AztecAddress.fromNumber(0x4444));
     return dataSource;
   }
 

package/src/public/public_processor.ts

@@ -12,7 +12,6 @@ import {
 } from '@aztec/circuit-types';
 import {
   type AztecAddress,
-  type BlockHeader,
   type ContractDataSource,
   Fr,
   Gas,
@@ -27,7 +26,14 @@ import { createLogger } from '@aztec/foundation/log';
 import { type DateProvider, Timer, elapsed, executeTimeout } from '@aztec/foundation/timer';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
-import { Attributes, type TelemetryClient, type Traceable, type Tracer, trackSpan } from '@aztec/telemetry-client';
+import {
+  Attributes,
+  type TelemetryClient,
+  type Traceable,
+  type Tracer,
+  getTelemetryClient,
+  trackSpan,
+} from '@aztec/telemetry-client';
 
 import { computeFeePayerBalanceLeafSlot, computeFeePayerBalanceStorageSlot } from './fee_payment.js';
 import { WorldStateDB } from './public_db_sources.js';
@@ -41,7 +47,7 @@ export class PublicProcessorFactory {
   constructor(
     private contractDataSource: ContractDataSource,
     private dateProvider: DateProvider,
-    private telemetryClient: TelemetryClient,
+    private telemetryClient: TelemetryClient = getTelemetryClient(),
   ) {}
 
   /**
@@ -53,26 +59,22 @@ 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,
       worldStateDB,
-      this.telemetryClient,
       globalVariables,
       /*doMerkleOperations=*/ true,
       enforceFeePayment,
+      this.telemetryClient,
     );
 
     return new PublicProcessor(
       merkleTree,
       globalVariables,
-      historicalHeader,
       worldStateDB,
       publicTxSimulator,
       this.dateProvider,
@@ -83,18 +85,18 @@ export class PublicProcessorFactory {
   protected createPublicTxSimulator(
     db: MerkleTreeWriteOperations,
     worldStateDB: WorldStateDB,
-    telemetryClient: TelemetryClient,
     globalVariables: GlobalVariables,
     doMerkleOperations: boolean,
     enforceFeePayment: boolean,
+    telemetryClient: TelemetryClient,
   ) {
     return new PublicTxSimulator(
       db,
       worldStateDB,
-      telemetryClient,
       globalVariables,
       doMerkleOperations,
       enforceFeePayment,
+      telemetryClient,
     );
   }
 }
@@ -115,11 +117,10 @@ export class PublicProcessor implements Traceable {
   constructor(
     protected db: MerkleTreeWriteOperations,
     protected globalVariables: GlobalVariables,
-    protected historicalHeader: BlockHeader,
     protected worldStateDB: WorldStateDB,
     protected publicTxSimulator: PublicTxSimulator,
     private dateProvider: DateProvider,
-    telemetryClient: TelemetryClient,
+    telemetryClient: TelemetryClient = getTelemetryClient(),
     private log = createLogger('simulator:public-processor'),
   ) {
     this.metrics = new PublicProcessorMetrics(telemetryClient, 'PublicProcessor');
@@ -279,7 +280,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,
@@ -308,7 +309,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,
@@ -371,17 +372,18 @@ export class PublicProcessor implements Traceable {
       return await processFn();
     }
 
+    const txHash = tx.getTxHash().toString();
     const timeout = +deadline - this.dateProvider.now();
+    if (timeout <= 0) {
+      throw new PublicProcessorTimeoutError();
+    }
+
     this.log.debug(`Processing tx ${tx.getTxHash().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,

package/src/public/public_tx_context.ts

@@ -97,7 +97,7 @@ export class PublicTxContext {
       /*noteHashes*/ 0,
       /*nullifiers=*/ 0,
       countAccumulatedItems(nonRevertibleAccumulatedDataFromPrivate.l2ToL1Msgs),
-      /*unencryptedLogsHashes*/ 0,
+      /*publicLogs*/ 0,
     );
     const enqueuedCallTrace = new PublicEnqueuedCallSideEffectTrace(
       /*startSideEffectCounter=*/ 0,

package/src/public/public_tx_simulator.ts

@@ -7,14 +7,13 @@ 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';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { Attributes, type TelemetryClient, type Tracer, trackSpan } from '@aztec/telemetry-client';
+import { Attributes, type TelemetryClient, type Tracer, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
 import { strict as assert } from 'assert';
 
@@ -53,10 +52,10 @@ export class PublicTxSimulator {
   constructor(
     private db: MerkleTreeReadOperations,
     private worldStateDB: WorldStateDB,
-    telemetryClient: TelemetryClient,
     private globalVariables: GlobalVariables,
     private doMerkleOperations: boolean = false,
     private enforceFeePayment: boolean = true,
+    telemetryClient: TelemetryClient = getTelemetryClient(),
   ) {
     this.log = createLogger(`simulator:public_tx_simulator`);
     this.metrics = new ExecutorMetrics(telemetryClient, 'PublicTxSimulator');
@@ -121,7 +120,6 @@ export class PublicTxSimulator {
     const endStateReference = await this.db.getStateReference();
 
     const avmProvingRequest = context.generateProvingRequest(endStateReference);
-    const avmCircuitPublicInputs = avmProvingRequest.inputs.output!;
 
     const revertCode = context.getFinalRevertCode();
     if (!revertCode.isOK()) {
@@ -131,13 +129,8 @@ export class PublicTxSimulator {
       // FIXME: we shouldn't need to directly modify worldStateDb here!
       await this.worldStateDB.removeNewContracts(tx);
       // 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,