refactor: stop calling public kernels

yarn-project/simulator/src/avm/journal/journal.ts

@@ -428,18 +428,21 @@ export class AvmPersistableStateManager {
   }
 
   /**
-   * Accept nested world state modifications
+   * Accept forked world state modifications & traced side effects / hints
    */
   public mergeForkedState(forkedState: AvmPersistableStateManager) {
     this.publicStorage.acceptAndMerge(forkedState.publicStorage);
     this.nullifiers.acceptAndMerge(forkedState.nullifiers);
-    this.trace.mergeSuccessfulForkedTrace(forkedState.trace);
+    this.trace.mergeForkedTrace(forkedState.trace, /*reverted=*/ false);
   }
 
+  /**
+   * Reject forked world state modifications & traced side effects, keep traced hints
+   */
   public rejectForkedState(forkedState: AvmPersistableStateManager) {
     this.publicStorage.acceptAndMerge(forkedState.publicStorage);
     this.nullifiers.acceptAndMerge(forkedState.nullifiers);
-    this.trace.mergeRevertedForkedTrace(forkedState.trace);
+    this.trace.mergeForkedTrace(forkedState.trace, /*reverted=*/ true);
   }
 
   /**

yarn-project/simulator/src/public/dual_side_effect_trace.ts

@@ -232,12 +232,8 @@ export class DualSideEffectTrace implements PublicSideEffectTraceInterface {
     this.enqueuedCallTrace.traceEnqueuedCall(publicCallRequest, calldata, reverted);
   }
 
-  public mergeSuccessfulForkedTrace(nestedTrace: this) {
-    this.enqueuedCallTrace.mergeSuccessfulForkedTrace(nestedTrace.enqueuedCallTrace);
-  }
-
-  public mergeRevertedForkedTrace(nestedTrace: this) {
-    this.enqueuedCallTrace.mergeRevertedForkedTrace(nestedTrace.enqueuedCallTrace);
+  public mergeForkedTrace(nestedTrace: this, reverted: boolean = false) {
+    this.enqueuedCallTrace.mergeForkedTrace(nestedTrace.enqueuedCallTrace, reverted);
   }
 
   /**

yarn-project/simulator/src/public/enqueued_call_side_effect_trace.ts

@@ -523,36 +523,24 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     this.avmCircuitHints.enqueuedCalls.items.push(new AvmEnqueuedCallHint(publicCallRequest.contractAddress, calldata));
   }
 
-  public mergeSuccessfulForkedTrace(nestedTrace: this) {
+  public mergeForkedTrace(nestedTrace: this, reverted: boolean = false) {
     // TODO(dbanks12): accept & merge nested trace's hints!
     this.sideEffectCounter = nestedTrace.sideEffectCounter;
-
     this.enqueuedCalls.push(...nestedTrace.enqueuedCalls);
 
-    this.publicDataReads.push(...nestedTrace.publicDataReads);
-    this.publicDataWrites.push(...nestedTrace.publicDataWrites);
-    this.noteHashReadRequests.push(...nestedTrace.noteHashReadRequests);
-    this.noteHashes.push(...nestedTrace.noteHashes);
-    this.nullifierReadRequests.push(...nestedTrace.nullifierReadRequests);
-    this.nullifierNonExistentReadRequests.push(...nestedTrace.nullifierNonExistentReadRequests);
-    this.log.debug(`Merging nullifiers: ${nestedTrace.nullifiers.length}`);
-    this.log.debug(`Into parent nullifiers: ${this.nullifiers.length}`);
-    this.nullifiers.push(...nestedTrace.nullifiers);
-    this.log.debug(`After merge: ${JSON.stringify(this.nullifiers)}`);
-    this.l1ToL2MsgReadRequests.push(...nestedTrace.l1ToL2MsgReadRequests);
-    this.l2ToL1Messages.push(...nestedTrace.l2ToL1Messages);
-    this.unencryptedLogs.push(...nestedTrace.unencryptedLogs);
-    this.unencryptedLogsHashes.push(...nestedTrace.unencryptedLogsHashes);
-  }
-
-  /**
-   * Discard accumulated side effects, but keep hints.
-   */
-  public mergeRevertedForkedTrace(nestedTrace: this) {
-    // TODO(dbanks12): accept & merge nested trace's hints!
-    this.sideEffectCounter = nestedTrace.sideEffectCounter;
-
-    this.enqueuedCalls.push(...nestedTrace.enqueuedCalls);
+    if (!reverted) {
+      this.publicDataReads.push(...nestedTrace.publicDataReads);
+      this.publicDataWrites.push(...nestedTrace.publicDataWrites);
+      this.noteHashReadRequests.push(...nestedTrace.noteHashReadRequests);
+      this.noteHashes.push(...nestedTrace.noteHashes);
+      this.nullifierReadRequests.push(...nestedTrace.nullifierReadRequests);
+      this.nullifierNonExistentReadRequests.push(...nestedTrace.nullifierNonExistentReadRequests);
+      this.nullifiers.push(...nestedTrace.nullifiers);
+      this.l1ToL2MsgReadRequests.push(...nestedTrace.l1ToL2MsgReadRequests);
+      this.l2ToL1Messages.push(...nestedTrace.l2ToL1Messages);
+      this.unencryptedLogs.push(...nestedTrace.unencryptedLogs);
+      this.unencryptedLogsHashes.push(...nestedTrace.unencryptedLogsHashes);
+    }
   }
 
   public getSideEffects(): SideEffects {
@@ -617,7 +605,6 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     /** The call's results */
     avmCallResults: AvmContractCallResult,
   ): VMCircuitPublicInputs {
-    this.log.debug(`Creating public inputs with call result: ${avmCallResults.reverted}`);
     return new VMCircuitPublicInputs(
       /*constants=*/ constants,
       /*callRequest=*/ callRequest,

yarn-project/simulator/src/public/public_tx_context.ts

@@ -7,6 +7,7 @@ import {
   TxExecutionPhase,
 } from '@aztec/circuit-types';
 import {
+  type AvmCircuitPublicInputs,
   CombinedConstantData,
   Fr,
   Gas,
@@ -29,40 +30,7 @@ import { DualSideEffectTrace } from './dual_side_effect_trace.js';
 import { PublicEnqueuedCallSideEffectTrace } from './enqueued_call_side_effect_trace.js';
 import { type WorldStateDB } from './public_db_sources.js';
 import { PublicSideEffectTrace } from './side_effect_trace.js';
-import { getCallRequestsByPhase, getExecutionRequestsByPhase, getPublicKernelCircuitPublicInputs } from './utils.js';
-
-class PhaseStateManager {
-  private currentlyActiveStateManager: AvmPersistableStateManager | undefined;
-
-  constructor(private readonly txStateManager: AvmPersistableStateManager) {}
-
-  fork() {
-    assert(!this.currentlyActiveStateManager, 'Cannot fork when already forked');
-    this.currentlyActiveStateManager = this.txStateManager.fork();
-  }
-
-  getActiveStateManager() {
-    return this.currentlyActiveStateManager || this.txStateManager;
-  }
-
-  isForked() {
-    return !!this.currentlyActiveStateManager;
-  }
-
-  mergeForkedState() {
-    assert(this.currentlyActiveStateManager, 'No forked state to merge');
-    this.txStateManager.mergeForkedState(this.currentlyActiveStateManager!);
-    // Drop the forked state manager now that it is merged
-    this.currentlyActiveStateManager = undefined;
-  }
-
-  discardForkedState() {
-    assert(this.currentlyActiveStateManager, 'No forked state to discard');
-    this.txStateManager.rejectForkedState(this.currentlyActiveStateManager!);
-    // Drop the forked state manager. We don't want it!
-    this.currentlyActiveStateManager = undefined;
-  }
-}
+import { generateAvmCircuitPublicInputs, getCallRequestsByPhase, getExecutionRequestsByPhase, getPublicKernelCircuitPublicInputs } from './utils.js';
 
 export class PublicTxContext {
   private log: DebugLogger;
@@ -93,6 +61,7 @@ export class PublicTxContext {
     private readonly setupExecutionRequests: PublicExecutionRequest[],
     private readonly appLogicExecutionRequests: PublicExecutionRequest[],
     private readonly teardownExecutionRequests: PublicExecutionRequest[],
+    private firstPublicKernelOutput: PublicKernelCircuitPublicInputs,
     public latestPublicKernelOutput: PublicKernelCircuitPublicInputs,
     public trace: PublicEnqueuedCallSideEffectTrace,
   ) {
@@ -107,19 +76,19 @@ export class PublicTxContext {
     globalVariables: GlobalVariables,
   ) {
     const privateKernelOutput = tx.data;
-    const latestPublicKernelOutput = getPublicKernelCircuitPublicInputs(privateKernelOutput, globalVariables);
+    const firstPublicKernelOutput = getPublicKernelCircuitPublicInputs(privateKernelOutput, globalVariables);
 
-    const nonRevertibleNullifiersFromPrivate = latestPublicKernelOutput.endNonRevertibleData.nullifiers
+    const nonRevertibleNullifiersFromPrivate = firstPublicKernelOutput.endNonRevertibleData.nullifiers
       .filter(n => !n.isEmpty())
       .map(n => n.value);
-    const _revertibleNullifiersFromPrivate = latestPublicKernelOutput.end.nullifiers
+    const _revertibleNullifiersFromPrivate = firstPublicKernelOutput.end.nullifiers
       .filter(n => !n.isEmpty())
       .map(n => n.value);
 
     // During SETUP, non revertible side effects from private are our "previous data"
-    const prevAccumulatedData = latestPublicKernelOutput.endNonRevertibleData;
+    const prevAccumulatedData = firstPublicKernelOutput.endNonRevertibleData;
     const previousValidationRequestArrayLengths = PublicValidationRequestArrayLengths.new(
-      latestPublicKernelOutput.validationRequests,
+      firstPublicKernelOutput.validationRequests,
     );
 
     const previousAccumulatedDataArrayLengths = PublicAccumulatedDataArrayLengths.new(prevAccumulatedData);
@@ -153,7 +122,8 @@ export class PublicTxContext {
       getExecutionRequestsByPhase(tx, TxExecutionPhase.SETUP),
       getExecutionRequestsByPhase(tx, TxExecutionPhase.APP_LOGIC),
       getExecutionRequestsByPhase(tx, TxExecutionPhase.TEARDOWN),
-      latestPublicKernelOutput,
+      firstPublicKernelOutput,
+      firstPublicKernelOutput,
       enqueuedCallTrace,
     );
   }
@@ -251,7 +221,7 @@ export class PublicTxContext {
   /**
    * Compute the gas used using the actual gas used during teardown instead
    * of the teardown gas limit.
-   * Note that this.startGasUsed comes from private and private includes
+   * Note that this.gasUsed comes from private and private includes
    * teardown gas limit in its output gasUsed.
    */
   getActualGasUsed(): Gas {
@@ -265,15 +235,15 @@ export class PublicTxContext {
     return this.gasUsed;
   }
 
-  getTransactionFeeAtCurrentPhase(): Fr {
+  getTransactionFee(): Fr {
     if (this.currentPhase === TxExecutionPhase.TEARDOWN) {
       return this.getTransactionFeeUnsafe();
     } else {
       return Fr.zero();
     }
   }
 
-  getTransactionFee(): Fr {
+  getFinalTransactionFee(): Fr {
     assert(this.currentPhase === TxExecutionPhase.TEARDOWN, 'Transaction fee is only known during/after teardown');
     return this.getTransactionFeeUnsafe();
   }
@@ -287,4 +257,60 @@ export class PublicTxContext {
     });
     return txFee;
   }
+
+  private async generateAvmCircuitPublicInputs(endStateReference: StateReference): Promise<AvmCircuitPublicInputs> {
+    assert(this.currentPhase === TxExecutionPhase.TEARDOWN, 'Can only get AvmCircuitPublicInputs after teardown (tx done)');
+    return generateAvmCircuitPublicInputs(
+      this.tx,
+      this.trace,
+      this.globalVariables,
+      this.startStateReference,
+      endStateReference,
+      this.gasUsed,
+      this.getFinalTransactionFee(),
+      this.revertCode,
+      this.firstPublicKernelOutput,
+    );
+  }
+
+  async generateProvingRequest(endStateReference: StateReference): Promise<AvmProvingRequest> {
+    // TODO(dbanks12): Once we actually have tx-level proving, this will generate the entire
+    // proving request for the first time
+    this.avmProvingRequest!.inputs.output = await this.generateAvmCircuitPublicInputs(endStateReference);
+    return this.avmProvingRequest!;
+  }
 }
+
+class PhaseStateManager {
+  private currentlyActiveStateManager: AvmPersistableStateManager | undefined;
+
+  constructor(private readonly txStateManager: AvmPersistableStateManager) {}
+
+  fork() {
+    assert(!this.currentlyActiveStateManager, 'Cannot fork when already forked');
+    this.currentlyActiveStateManager = this.txStateManager.fork();
+  }
+
+  getActiveStateManager() {
+    return this.currentlyActiveStateManager || this.txStateManager;
+  }
+
+  isForked() {
+    return !!this.currentlyActiveStateManager;
+  }
+
+  mergeForkedState() {
+    assert(this.currentlyActiveStateManager, 'No forked state to merge');
+    this.txStateManager.mergeForkedState(this.currentlyActiveStateManager!);
+    // Drop the forked state manager now that it is merged
+    this.currentlyActiveStateManager = undefined;
+  }
+
+  discardForkedState() {
+    assert(this.currentlyActiveStateManager, 'No forked state to discard');
+    this.txStateManager.rejectForkedState(this.currentlyActiveStateManager!);
+    // Drop the forked state manager. We don't want it!
+    this.currentlyActiveStateManager = undefined;
+  }
+}
+

yarn-project/simulator/src/public/public_tx_simulator.ts

@@ -17,7 +17,7 @@ import { type WorldStateDB } from './public_db_sources.js';
 import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
 import { PublicKernelTailSimulator } from './public_kernel_tail_simulator.js';
 import { PublicTxContext } from './public_tx_context.js';
-import { generateAvmCircuitPublicInputs, runMergeKernelCircuit } from './utils.js';
+import { generateAvmCircuitPublicInputs, generateAvmCircuitPublicInputsDeprecated, runMergeKernelCircuit } from './utils.js';
 
 export type ProcessedPhase = {
   phase: TxExecutionPhase;
@@ -94,24 +94,23 @@ export class PublicTxSimulator {
       result => result !== undefined,
     ) as ProcessedPhase[];
 
-    const _endStateReference = await this.db.getStateReference();
-    const transactionFee = context.getTransactionFee();
+    const endStateReference = await this.db.getStateReference();
 
     const tailKernelOutput = await this.publicKernelTailSimulator.simulate(context.latestPublicKernelOutput);
 
-    context.avmProvingRequest!.inputs.output = generateAvmCircuitPublicInputs(
+    generateAvmCircuitPublicInputsDeprecated(
       tx,
       tailKernelOutput,
       context.getGasUsedForFee(),
-      transactionFee,
+      context.getFinalTransactionFee(),
     );
 
     const gasUsed = {
       totalGas: context.getActualGasUsed(),
       teardownGas: context.teardownGasUsed,
     };
     return {
-      avmProvingRequest: context.avmProvingRequest!,
+      avmProvingRequest: await context.generateProvingRequest(endStateReference),
       gasUsed,
       revertCode: context.revertCode,
       revertReason: context.revertReason,
@@ -212,7 +211,7 @@ export class PublicTxSimulator {
         executionRequest,
         context.constants,
         /*availableGas=*/ context.getGasLeftForCurrentPhase(),
-        /*transactionFee=*/ context.getTransactionFeeAtCurrentPhase(),
+        /*transactionFee=*/ context.getTransactionFee(),
         enqueuedCallStateManager,
       );
 

yarn-project/simulator/src/public/side_effect_trace.ts

@@ -440,11 +440,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     throw new Error('Not implemented');
   }
 
-  public mergeSuccessfulForkedTrace(_nestedTrace: this) {
-    throw new Error('Not implemented');
-  }
-
-  public mergeRevertedForkedTrace(_nestedTrace: this) {
+  public mergeForkedTrace(_nestedTrace: this, _reverted: boolean = false) {
     throw new Error('Not implemented');
   }
 

yarn-project/simulator/src/public/side_effect_trace_interface.ts

@@ -18,6 +18,7 @@ import { type EnqueuedPublicCallExecutionResultWithSideEffects, type PublicFunct
 
 export interface PublicSideEffectTraceInterface {
   fork(incrementSideEffectCounter?: boolean): PublicSideEffectTraceInterface;
+  mergeForkedTrace(nestedTrace: PublicSideEffectTraceInterface, reverted?: boolean): void;
   getCounter(): number;
   // all "trace*" functions can throw SideEffectLimitReachedError
   tracePublicStorageRead(
@@ -101,8 +102,6 @@ export interface PublicSideEffectTraceInterface {
     /** Did the call revert? */
     reverted: boolean,
   ): void;
-  mergeSuccessfulForkedTrace(nestedTrace: PublicSideEffectTraceInterface): void;
-  mergeRevertedForkedTrace(nestedTrace: PublicSideEffectTraceInterface): void;
   toPublicEnqueuedCallExecutionResult(
     /** How much gas was left after this public execution. */
     endGasLeft: Gas,