@aztec/simulator 0.42.0 → 0.43.0

package/src/client/simulator.ts

@@ -132,29 +132,31 @@ export class AcirSimulator {
    * @param nonce - The nonce of the note hash.
    * @param storageSlot - The storage slot.
    * @param noteTypeId - The note type identifier.
+   * @param computeNullifier - A flag indicating whether to compute the nullifier or just return 0.
    * @param note - The note.
    * @returns The nullifier.
    */
-  public async computeNoteHashAndNullifier(
+  public async computeNoteHashAndOptionallyANullifier(
     contractAddress: AztecAddress,
     nonce: Fr,
     storageSlot: Fr,
     noteTypeId: Fr,
+    computeNullifier: boolean,
     note: Note,
   ) {
     const artifact: FunctionArtifact | undefined = await this.db.getFunctionArtifactByName(
       contractAddress,
-      'compute_note_hash_and_nullifier',
+      'compute_note_hash_and_optionally_a_nullifier',
     );
     if (!artifact) {
       throw new Error(
-        `Mandatory implementation of "compute_note_hash_and_nullifier" missing in noir contract ${contractAddress.toString()}.`,
+        `Mandatory implementation of "compute_note_hash_and_optionally_a_nullifier" missing in noir contract ${contractAddress.toString()}.`,
       );
     }
 
-    if (artifact.parameters.length != 5) {
+    if (artifact.parameters.length != 6) {
       throw new Error(
-        `Expected 5 parameters in mandatory implementation of "compute_note_hash_and_nullifier", but found ${
+        `Expected 6 parameters in mandatory implementation of "compute_note_hash_and_optionally_a_nullifier", but found ${
           artifact.parameters.length
         } in noir contract ${contractAddress.toString()}.`,
       );
@@ -163,7 +165,7 @@ export class AcirSimulator {
     const maxNoteFields = (artifact.parameters[artifact.parameters.length - 1].type as ArrayType).length;
     if (maxNoteFields < note.items.length) {
       throw new Error(
-        `The note being processed has ${note.items.length} fields, while "compute_note_hash_and_nullifier" can only handle a maximum of ${maxNoteFields} fields. Please reduce the number of fields in your note.`,
+        `The note being processed has ${note.items.length} fields, while "compute_note_hash_and_optionally_a_nullifier" can only handle a maximum of ${maxNoteFields} fields. Please reduce the number of fields in your note.`,
       );
     }
 
@@ -175,7 +177,14 @@ export class AcirSimulator {
       selector: FunctionSelector.empty(),
       type: FunctionType.UNCONSTRAINED,
       isStatic: artifact.isStatic,
-      args: encodeArguments(artifact, [contractAddress, nonce, storageSlot, noteTypeId, extendedNoteItems]),
+      args: encodeArguments(artifact, [
+        contractAddress,
+        nonce,
+        storageSlot,
+        noteTypeId,
+        computeNullifier,
+        extendedNoteItems,
+      ]),
       returnTypes: artifact.returnTypes,
     };
 
@@ -202,11 +211,12 @@ export class AcirSimulator {
    * @returns The note hash.
    */
   public async computeInnerNoteHash(contractAddress: AztecAddress, storageSlot: Fr, noteTypeId: Fr, note: Note) {
-    const { innerNoteHash } = await this.computeNoteHashAndNullifier(
+    const { innerNoteHash } = await this.computeNoteHashAndOptionallyANullifier(
       contractAddress,
       Fr.ZERO,
       storageSlot,
       noteTypeId,
+      false,
       note,
     );
     return innerNoteHash;

package/src/public/abstract_phase_manager.ts

@@ -67,36 +67,15 @@ import { type MerkleTreeOperations } from '@aztec/world-state';
 
 import { HintsBuilder } from './hints_builder.js';
 import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
-import { lastSideEffectCounter } from './utils.js';
 
-export enum PublicKernelPhase {
-  SETUP = 'setup',
-  APP_LOGIC = 'app-logic',
-  TEARDOWN = 'teardown',
-  TAIL = 'tail',
-}
-
-export const PhaseIsRevertible: Record<PublicKernelPhase, boolean> = {
-  [PublicKernelPhase.SETUP]: false,
-  [PublicKernelPhase.APP_LOGIC]: true,
-  [PublicKernelPhase.TEARDOWN]: true,
-  [PublicKernelPhase.TAIL]: false,
+export const PhaseIsRevertible: Record<PublicKernelType, boolean> = {
+  [PublicKernelType.NON_PUBLIC]: false,
+  [PublicKernelType.SETUP]: false,
+  [PublicKernelType.APP_LOGIC]: true,
+  [PublicKernelType.TEARDOWN]: true,
+  [PublicKernelType.TAIL]: false,
 };
 
-// REFACTOR: Unify both enums and move to types or circuit-types.
-export function publicKernelPhaseToKernelType(phase: PublicKernelPhase): PublicKernelType {
-  switch (phase) {
-    case PublicKernelPhase.SETUP:
-      return PublicKernelType.SETUP;
-    case PublicKernelPhase.APP_LOGIC:
-      return PublicKernelType.APP_LOGIC;
-    case PublicKernelPhase.TEARDOWN:
-      return PublicKernelType.TEARDOWN;
-    case PublicKernelPhase.TAIL:
-      return PublicKernelType.TAIL;
-  }
-}
-
 export type PublicProvingInformation = {
   calldata: Fr[];
   bytecode: Buffer;
@@ -159,7 +138,7 @@ export abstract class AbstractPhaseManager {
     protected publicKernel: PublicKernelCircuitSimulator,
     protected globalVariables: GlobalVariables,
     protected historicalHeader: Header,
-    public phase: PublicKernelPhase,
+    public phase: PublicKernelType,
   ) {
     this.hintsBuilder = new HintsBuilder(db);
     this.log = createDebugLogger(`aztec:sequencer:${phase}`);
@@ -171,14 +150,15 @@ export abstract class AbstractPhaseManager {
    */
   abstract handle(tx: Tx, publicKernelPublicInputs: PublicKernelCircuitPublicInputs): Promise<PhaseResult>;
 
-  public static extractEnqueuedPublicCallsByPhase(tx: Tx): Record<PublicKernelPhase, PublicCallRequest[]> {
+  public static extractEnqueuedPublicCallsByPhase(tx: Tx): Record<PublicKernelType, PublicCallRequest[]> {
     const data = tx.data.forPublic;
     if (!data) {
       return {
-        [PublicKernelPhase.SETUP]: [],
-        [PublicKernelPhase.APP_LOGIC]: [],
-        [PublicKernelPhase.TEARDOWN]: [],
-        [PublicKernelPhase.TAIL]: [],
+        [PublicKernelType.NON_PUBLIC]: [],
+        [PublicKernelType.SETUP]: [],
+        [PublicKernelType.APP_LOGIC]: [],
+        [PublicKernelType.TEARDOWN]: [],
+        [PublicKernelType.TAIL]: [],
       };
     }
     const publicCallsStack = tx.enqueuedPublicFunctionCalls.slice().reverse();
@@ -196,10 +176,11 @@ export abstract class AbstractPhaseManager {
 
     if (callRequestsStack.length === 0) {
       return {
-        [PublicKernelPhase.SETUP]: [],
-        [PublicKernelPhase.APP_LOGIC]: [],
-        [PublicKernelPhase.TEARDOWN]: [],
-        [PublicKernelPhase.TAIL]: [],
+        [PublicKernelType.NON_PUBLIC]: [],
+        [PublicKernelType.SETUP]: [],
+        [PublicKernelType.APP_LOGIC]: [],
+        [PublicKernelType.TEARDOWN]: [],
+        [PublicKernelType.TAIL]: [],
       };
     }
 
@@ -212,25 +193,28 @@ export abstract class AbstractPhaseManager {
 
     if (firstRevertibleCallIndex === 0) {
       return {
-        [PublicKernelPhase.SETUP]: [],
-        [PublicKernelPhase.APP_LOGIC]: publicCallsStack,
-        [PublicKernelPhase.TEARDOWN]: teardownCallStack,
-        [PublicKernelPhase.TAIL]: [],
+        [PublicKernelType.NON_PUBLIC]: [],
+        [PublicKernelType.SETUP]: [],
+        [PublicKernelType.APP_LOGIC]: publicCallsStack,
+        [PublicKernelType.TEARDOWN]: teardownCallStack,
+        [PublicKernelType.TAIL]: [],
       };
     } else if (firstRevertibleCallIndex === -1) {
       // there's no app logic, split the functions between setup (many) and teardown (just one function call)
       return {
-        [PublicKernelPhase.SETUP]: publicCallsStack,
-        [PublicKernelPhase.APP_LOGIC]: [],
-        [PublicKernelPhase.TEARDOWN]: teardownCallStack,
-        [PublicKernelPhase.TAIL]: [],
+        [PublicKernelType.NON_PUBLIC]: [],
+        [PublicKernelType.SETUP]: publicCallsStack,
+        [PublicKernelType.APP_LOGIC]: [],
+        [PublicKernelType.TEARDOWN]: teardownCallStack,
+        [PublicKernelType.TAIL]: [],
       };
     } else {
       return {
-        [PublicKernelPhase.SETUP]: publicCallsStack.slice(0, firstRevertibleCallIndex),
-        [PublicKernelPhase.APP_LOGIC]: publicCallsStack.slice(firstRevertibleCallIndex),
-        [PublicKernelPhase.TEARDOWN]: teardownCallStack,
-        [PublicKernelPhase.TAIL]: [],
+        [PublicKernelType.NON_PUBLIC]: [],
+        [PublicKernelType.SETUP]: publicCallsStack.slice(0, firstRevertibleCallIndex),
+        [PublicKernelType.APP_LOGIC]: publicCallsStack.slice(firstRevertibleCallIndex),
+        [PublicKernelType.TEARDOWN]: teardownCallStack,
+        [PublicKernelType.TAIL]: [],
       };
     }
   }
@@ -278,19 +262,15 @@ export abstract class AbstractPhaseManager {
       while (executionStack.length) {
         const current = executionStack.pop()!;
         const isExecutionRequest = !isPublicExecutionResult(current);
-        const sideEffectCounter = lastSideEffectCounter(kernelPublicOutput) + 1;
-        const availableGas = this.getAvailableGas(tx, kernelPublicOutput);
-        const pendingNullifiers = this.getSiloedPendingNullifiers(kernelPublicOutput);
-
         const result = isExecutionRequest
           ? await this.publicExecutor.simulate(
               current,
               this.globalVariables,
-              availableGas,
+              /*availableGas=*/ this.getAvailableGas(tx, kernelPublicOutput),
               tx.data.constants.txContext,
-              pendingNullifiers,
+              /*pendingNullifiers=*/ this.getSiloedPendingNullifiers(kernelPublicOutput),
               transactionFee,
-              sideEffectCounter,
+              /*startSideEffectCounter=*/ AbstractPhaseManager.getMaxSideEffectCounter(kernelPublicOutput) + 1,
             )
           : current;
 
@@ -407,11 +387,11 @@ export abstract class AbstractPhaseManager {
     // We take a deep copy (clone) of these inputs to be passed to the prover
     const inputs = new PublicKernelCircuitPrivateInputs(previousKernel, callData);
     switch (this.phase) {
-      case PublicKernelPhase.SETUP:
+      case PublicKernelType.SETUP:
         return [inputs.clone(), await this.publicKernel.publicKernelCircuitSetup(inputs)];
-      case PublicKernelPhase.APP_LOGIC:
+      case PublicKernelType.APP_LOGIC:
         return [inputs.clone(), await this.publicKernel.publicKernelCircuitAppLogic(inputs)];
-      case PublicKernelPhase.TEARDOWN:
+      case PublicKernelType.TEARDOWN:
         return [inputs.clone(), await this.publicKernel.publicKernelCircuitTeardown(inputs)];
       default:
         throw new Error(`No public kernel circuit for inputs`);
@@ -508,6 +488,44 @@ export abstract class AbstractPhaseManager {
     return await Promise.all(nested.map(n => this.getPublicCallStackItem(n)));
   }
 
+  /**
+   * Looks at the side effects of a transaction and returns the highest counter
+   * @param tx - A transaction
+   * @returns The highest side effect counter in the transaction so far
+   */
+  static getMaxSideEffectCounter(inputs: PublicKernelCircuitPublicInputs): number {
+    const sideEffectCounters = [
+      ...inputs.endNonRevertibleData.newNoteHashes,
+      ...inputs.endNonRevertibleData.newNullifiers,
+      ...inputs.endNonRevertibleData.noteEncryptedLogsHashes,
+      ...inputs.endNonRevertibleData.encryptedLogsHashes,
+      ...inputs.endNonRevertibleData.unencryptedLogsHashes,
+      ...inputs.endNonRevertibleData.publicCallStack,
+      ...inputs.endNonRevertibleData.publicDataUpdateRequests,
+      ...inputs.end.newNoteHashes,
+      ...inputs.end.newNullifiers,
+      ...inputs.end.noteEncryptedLogsHashes,
+      ...inputs.end.encryptedLogsHashes,
+      ...inputs.end.unencryptedLogsHashes,
+      ...inputs.end.publicCallStack,
+      ...inputs.end.publicDataUpdateRequests,
+    ];
+
+    let max = 0;
+    for (const sideEffect of sideEffectCounters) {
+      if ('startSideEffectCounter' in sideEffect) {
+        // look at both start and end counters because for enqueued public calls start > 0 while end === 0
+        max = Math.max(max, sideEffect.startSideEffectCounter.toNumber(), sideEffect.endSideEffectCounter.toNumber());
+      } else if ('counter' in sideEffect) {
+        max = Math.max(max, sideEffect.counter);
+      } else {
+        throw new Error('Unknown side effect type');
+      }
+    }
+
+    return max;
+  }
+
   protected getBytecodeHash(_result: PublicExecutionResult) {
     // TODO: Determine how to calculate bytecode hash. Circuits just check it isn't zero for now.
     // See https://github.com/AztecProtocol/aztec3-packages/issues/378

package/src/public/app_logic_phase_manager.ts

@@ -3,7 +3,7 @@ import { type GlobalVariables, type Header, type PublicKernelCircuitPublicInputs
 import { type PublicExecutor, type PublicStateDB } from '@aztec/simulator';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
-import { AbstractPhaseManager, PublicKernelPhase, makeAvmProvingRequest } from './abstract_phase_manager.js';
+import { AbstractPhaseManager, makeAvmProvingRequest } from './abstract_phase_manager.js';
 import { type ContractsDataSourcePublicDB } from './public_db_sources.js';
 import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
 
@@ -19,7 +19,7 @@ export class AppLogicPhaseManager extends AbstractPhaseManager {
     historicalHeader: Header,
     protected publicContractsDB: ContractsDataSourcePublicDB,
     protected publicStateDB: PublicStateDB,
-    phase: PublicKernelPhase = PublicKernelPhase.APP_LOGIC,
+    phase: PublicKernelType = PublicKernelType.APP_LOGIC,
   ) {
     super(db, publicExecutor, publicKernel, globalVariables, historicalHeader, phase);
   }

package/src/public/db_interfaces.ts

@@ -67,6 +67,8 @@ export interface PublicContractsDB {
    * @returns The contract instance or undefined if not found.
    */
   getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined>;
+
+  getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
 }
 
 /** Database interface for providing access to commitment tree, l1 to l2 message tree, and nullifier tree. */

package/src/public/execution.ts

@@ -9,11 +9,8 @@ import {
   type NoteHash,
   type Nullifier,
   type PublicCallRequest,
-  PublicDataRead,
-  PublicDataUpdateRequest,
   type ReadRequest,
 } from '@aztec/circuits.js';
-import { computePublicDataTreeLeafSlot, computePublicDataTreeValue } from '@aztec/circuits.js/hash';
 
 import { type Gas } from '../avm/avm_gas.js';
 
@@ -98,72 +95,6 @@ export function isPublicExecutionResult(
   return 'execution' in input && input.execution !== undefined;
 }
 
-/**
- * Collect all public storage reads across all nested executions
- * and convert them to PublicDataReads (to match kernel output).
- * @param execResult - The topmost execution result.
- * @returns All public data reads (in execution order).
- */
-export function collectPublicDataReads(execResult: PublicExecutionResult): PublicDataRead[] {
-  // HACK(#1622): part of temporary hack - may be able to remove this function after public state ordering is fixed
-  const thisExecPublicDataReads = execResult.contractStorageReads.map(read =>
-    contractStorageReadToPublicDataRead(read),
-  );
-  const unsorted = [
-    ...thisExecPublicDataReads,
-    ...[...execResult.nestedExecutions].flatMap(result => collectPublicDataReads(result)),
-  ];
-  return unsorted.sort((a, b) => a.sideEffectCounter! - b.sideEffectCounter!);
-}
-
-/**
- * Collect all public storage update requests across all nested executions
- * and convert them to PublicDataUpdateRequests (to match kernel output).
- * @param execResult - The topmost execution result.
- * @returns All public data reads (in execution order).
- */
-export function collectPublicDataUpdateRequests(execResult: PublicExecutionResult): PublicDataUpdateRequest[] {
-  // HACK(#1622): part of temporary hack - may be able to remove this function after public state ordering is fixed
-  const thisExecPublicDataUpdateRequests = execResult.contractStorageUpdateRequests.map(update =>
-    contractStorageUpdateRequestToPublicDataUpdateRequest(update),
-  );
-  const unsorted = [
-    ...thisExecPublicDataUpdateRequests,
-    ...[...execResult.nestedExecutions].flatMap(result => collectPublicDataUpdateRequests(result)),
-  ];
-  return unsorted.sort((a, b) => a.sideEffectCounter! - b.sideEffectCounter!);
-}
-
-/**
- * Convert a Contract Storage Read to a Public Data Read.
- * @param read - the contract storage read to convert
- * @param contractAddress - the contract address of the read
- * @returns The public data read.
- */
-function contractStorageReadToPublicDataRead(read: ContractStorageRead): PublicDataRead {
-  return new PublicDataRead(
-    computePublicDataTreeLeafSlot(read.contractAddress!, read.storageSlot),
-    computePublicDataTreeValue(read.currentValue),
-    read.sideEffectCounter!,
-  );
-}
-
-/**
- * Convert a Contract Storage Update Request to a Public Data Update Request.
- * @param update - the contract storage update request to convert
- * @param contractAddress - the contract address of the data update request.
- * @returns The public data update request.
- */
-function contractStorageUpdateRequestToPublicDataUpdateRequest(
-  update: ContractStorageUpdateRequest,
-): PublicDataUpdateRequest {
-  return new PublicDataUpdateRequest(
-    computePublicDataTreeLeafSlot(update.contractAddress!, update.storageSlot),
-    computePublicDataTreeValue(update.newValue),
-    update.sideEffectCounter!,
-  );
-}
-
 /**
  * Checks whether the child execution result is valid for a static call (no state modifications).
  * @param executionResult - The execution result of a public function

package/src/public/executor.ts

@@ -1,5 +1,7 @@
+import { type AvmSimulationStats } from '@aztec/circuit-types/stats';
 import { Fr, type Gas, type GlobalVariables, type Header, type Nullifier, type TxContext } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
 
 import { AvmContext } from '../avm/avm_context.js';
 import { AvmMachineState } from '../avm/avm_machine_state.js';
@@ -36,25 +38,25 @@ export class PublicExecutor {
     txContext: TxContext,
     pendingNullifiers: Nullifier[],
     transactionFee: Fr = Fr.ZERO,
-    sideEffectCounter: number = 0,
+    startSideEffectCounter: number = 0,
   ): Promise<PublicExecutionResult> {
     const address = execution.contractAddress;
     const selector = execution.functionSelector;
     const startGas = availableGas;
+    const fnName = await this.contractsDb.getDebugFunctionName(address, selector);
 
-    PublicExecutor.log.verbose(`[AVM] Executing public external function ${address.toString()}:${selector}.`);
+    PublicExecutor.log.verbose(`[AVM] Executing public external function ${fnName}.`);
+    const timer = new Timer();
 
     // Temporary code to construct the AVM context
     // These data structures will permeate across the simulator when the public executor is phased out
     const hostStorage = new HostStorage(this.stateDb, this.contractsDb, this.commitmentsDb);
 
-    const startSideEffectCounter = sideEffectCounter;
     const worldStateJournal = new AvmPersistableStateManager(hostStorage);
     for (const nullifier of pendingNullifiers) {
       worldStateJournal.nullifiers.cache.appendSiloed(nullifier.value);
     }
-    // All the subsequent side effects will have a counter larger than the call's start counter.
-    worldStateJournal.trace.accessCounter = startSideEffectCounter + 1;
+    worldStateJournal.trace.accessCounter = startSideEffectCounter;
 
     const executionEnv = createAvmExecutionEnvironment(
       execution,
@@ -68,6 +70,7 @@ export class PublicExecutor {
     const avmContext = new AvmContext(worldStateJournal, executionEnv, machineState);
     const simulator = new AvmSimulator(avmContext);
     const avmResult = await simulator.execute();
+    const bytecode = simulator.getBytecode();
 
     // Commit the journals state to the DBs since this is a top-level execution.
     // Observe that this will write all the state changes to the DBs, not only the latest for each slot.
@@ -75,9 +78,15 @@ export class PublicExecutor {
     await avmContext.persistableState.publicStorage.commitToDB();
 
     PublicExecutor.log.verbose(
-      `[AVM] ${address.toString()}:${selector} returned, reverted: ${avmResult.reverted}, reason: ${
-        avmResult.revertReason
+      `[AVM] ${fnName} returned, reverted: ${avmResult.reverted}${
+        avmResult.reverted ? ', reason: ' + avmResult.revertReason : ''
       }.`,
+      {
+        eventName: 'avm-simulation',
+        appCircuitName: fnName ?? 'unknown',
+        duration: timer.ms(),
+        bytecodeSize: bytecode!.length,
+      } satisfies AvmSimulationStats,
     );
 
     const executionResult = convertAvmResultsToPxResult(
@@ -86,7 +95,7 @@ export class PublicExecutor {
       execution,
       startGas,
       avmContext,
-      simulator.getBytecode(),
+      bytecode,
     );
 
     // TODO(https://github.com/AztecProtocol/aztec-packages/issues/5818): is this really needed?

package/src/public/index.ts

@@ -1,16 +1,10 @@
+export * from './abstract_phase_manager.js';
 export * from './db_interfaces.js';
-export {
-  type PublicExecution,
-  type PublicExecutionResult,
-  isPublicExecutionResult,
-  collectPublicDataReads,
-  collectPublicDataUpdateRequests,
-} from './execution.js';
+export { isPublicExecutionResult, type PublicExecution, type PublicExecutionResult } from './execution.js';
 export { PublicExecutor } from './executor.js';
-export { PublicProcessor, PublicProcessorFactory } from './public_processor.js';
+export * from './fee_payment.js';
+export { HintsBuilder } from './hints_builder.js';
 export * from './public_db_sources.js';
-export * from './abstract_phase_manager.js';
-export * from './public_kernel_circuit_simulator.js';
 export * from './public_kernel.js';
-export { HintsBuilder } from './hints_builder.js';
-export * from './fee_payment.js';
+export * from './public_kernel_circuit_simulator.js';
+export { PublicProcessor, PublicProcessorFactory } from './public_processor.js';

package/src/public/phase_manager_factory.ts

@@ -1,9 +1,9 @@
-import { type Tx } from '@aztec/circuit-types';
+import { PublicKernelType, type Tx } from '@aztec/circuit-types';
 import { type GlobalVariables, type Header, type PublicKernelCircuitPublicInputs } from '@aztec/circuits.js';
 import { type PublicExecutor, type PublicStateDB } from '@aztec/simulator';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
-import { type AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
+import { type AbstractPhaseManager } from './abstract_phase_manager.js';
 import { AppLogicPhaseManager } from './app_logic_phase_manager.js';
 import { type ContractsDataSourcePublicDB } from './public_db_sources.js';
 import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
@@ -12,7 +12,7 @@ import { TailPhaseManager } from './tail_phase_manager.js';
 import { TeardownPhaseManager } from './teardown_phase_manager.js';
 
 export class PhaseDidNotChangeError extends Error {
-  constructor(phase: PublicKernelPhase) {
+  constructor(phase: PublicKernelType) {
     super(`Tried to advance the phase from [${phase}] when the circuit still needs [${phase}]`);
   }
 }
@@ -84,7 +84,7 @@ export class PhaseManagerFactory {
     if (output.needsSetup) {
       throw new CannotTransitionToSetupError();
     } else if (output.needsAppLogic) {
-      if (currentPhaseManager.phase === PublicKernelPhase.APP_LOGIC) {
+      if (currentPhaseManager.phase === PublicKernelType.APP_LOGIC) {
         throw new PhaseDidNotChangeError(currentPhaseManager.phase);
       }
       return new AppLogicPhaseManager(
@@ -97,7 +97,7 @@ export class PhaseManagerFactory {
         publicStateDB,
       );
     } else if (output.needsTeardown) {
-      if (currentPhaseManager.phase === PublicKernelPhase.TEARDOWN) {
+      if (currentPhaseManager.phase === PublicKernelType.TEARDOWN) {
         throw new PhaseDidNotChangeError(currentPhaseManager.phase);
       }
       return new TeardownPhaseManager(
@@ -109,7 +109,7 @@ export class PhaseManagerFactory {
         publicContractsDB,
         publicStateDB,
       );
-    } else if (currentPhaseManager.phase !== PublicKernelPhase.TAIL) {
+    } else if (currentPhaseManager.phase !== PublicKernelType.TAIL) {
       return new TailPhaseManager(
         db,
         publicExecutor,