@aztec/sequencer-client 0.32.1 → 0.34.0

package/src/sequencer/abstract_phase_manager.ts

@@ -7,18 +7,18 @@ import {
   Fr,
   type GlobalVariables,
   type Header,
+  type KernelCircuitPublicInputs,
   L2ToL1Message,
   MAX_NEW_L2_TO_L1_MSGS_PER_CALL,
   MAX_NEW_NOTE_HASHES_PER_CALL,
   MAX_NEW_NULLIFIERS_PER_CALL,
-  MAX_NON_REVERTIBLE_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL,
   MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
   MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
   MAX_PUBLIC_DATA_READS_PER_CALL,
   MAX_PUBLIC_DATA_READS_PER_TX,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
-  MAX_REVERTIBLE_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+  MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   MembershipWitness,
   type PrivateKernelTailCircuitPublicInputs,
   type Proof,
@@ -31,7 +31,6 @@ import {
   PublicKernelCircuitPrivateInputs,
   type PublicKernelCircuitPublicInputs,
   PublicKernelData,
-  PublicKernelTailCircuitPrivateInputs,
   RETURN_VALUES_LENGTH,
   ReadRequest,
   RevertCode,
@@ -42,6 +41,13 @@ import {
   makeEmptyProof,
 } from '@aztec/circuits.js';
 import { computeVarArgsHash } from '@aztec/circuits.js/hash';
+import {
+  type AbiType,
+  type DecodedReturn,
+  type FunctionArtifact,
+  type ProcessReturnValues,
+  decodeReturnValues,
+} from '@aztec/foundation/abi';
 import { arrayNonEmptyLength, padArrayEnd } from '@aztec/foundation/collection';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { type Tuple } from '@aztec/foundation/serialize';
@@ -102,6 +108,10 @@ export abstract class AbstractPhaseManager {
      * the output of the public kernel circuit for this phase
      */
     publicKernelOutput: PublicKernelCircuitPublicInputs;
+    /**
+     * the final output of the public kernel circuit for this phase
+     */
+    finalKernelOutput?: KernelCircuitPublicInputs;
     /**
      * the proof of the public kernel circuit for this phase
      */
@@ -110,6 +120,7 @@ export abstract class AbstractPhaseManager {
      * revert reason, if any
      */
     revertReason: SimulationError | undefined;
+    returnValues: ProcessReturnValues;
   }>;
 
   public static extractEnqueuedPublicCallsByPhase(
@@ -117,8 +128,10 @@ export abstract class AbstractPhaseManager {
     enqueuedPublicFunctionCalls: PublicCallRequest[],
   ): Record<PublicKernelPhase, PublicCallRequest[]> {
     const publicCallsStack = enqueuedPublicFunctionCalls.slice().reverse();
-    const nonRevertibleCallStack = publicInputs.endNonRevertibleData.publicCallStack.filter(i => !i.isEmpty());
-    const revertibleCallStack = publicInputs.end.publicCallStack.filter(i => !i.isEmpty());
+    const nonRevertibleCallStack = publicInputs.forPublic!.endNonRevertibleData.publicCallStack.filter(
+      i => !i.isEmpty(),
+    );
+    const revertibleCallStack = publicInputs.forPublic!.end.publicCallStack.filter(i => !i.isEmpty());
 
     const callRequestsStack = publicCallsStack
       .map(call => call.toCallRequest())
@@ -180,14 +193,22 @@ export abstract class AbstractPhaseManager {
     tx: Tx,
     previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
     previousPublicKernelProof: Proof,
-  ): Promise<[PublicKernelCircuitPublicInputs, Proof, UnencryptedFunctionL2Logs[], SimulationError | undefined]> {
+  ): Promise<
+    [
+      PublicKernelCircuitPublicInputs,
+      Proof,
+      UnencryptedFunctionL2Logs[],
+      SimulationError | undefined,
+      ProcessReturnValues,
+    ]
+  > {
     let kernelOutput = previousPublicKernelOutput;
     let kernelProof = previousPublicKernelProof;
 
     const enqueuedCalls = this.extractEnqueuedPublicCalls(tx);
 
     if (!enqueuedCalls || !enqueuedCalls.length) {
-      return [kernelOutput, kernelProof, [], undefined];
+      return [kernelOutput, kernelProof, [], undefined, undefined];
     }
 
     const newUnencryptedFunctionLogs: UnencryptedFunctionL2Logs[] = [];
@@ -196,24 +217,24 @@ export abstract class AbstractPhaseManager {
     // separate public callstacks to be proven by separate public kernel sequences
     // and submitted separately to the base rollup?
 
+    const returns = [];
+
     for (const enqueuedCall of enqueuedCalls) {
       const executionStack: (PublicExecution | PublicExecutionResult)[] = [enqueuedCall];
 
+      let currentReturn: DecodedReturn | undefined = undefined;
+
       // Keep track of which result is for the top/enqueued call
       let enqueuedExecutionResult: PublicExecutionResult | undefined;
 
       while (executionStack.length) {
         const current = executionStack.pop()!;
         const isExecutionRequest = !isPublicExecutionResult(current);
-
         const sideEffectCounter = lastSideEffectCounter(tx) + 1;
-        // NOTE: temporary glue to incorporate avm execution calls.
-        const simulator = (execution: PublicExecution, globalVariables: GlobalVariables) =>
-          execution.functionData.isTranspiled
-            ? this.publicExecutor.simulateAvm(execution, globalVariables, sideEffectCounter)
-            : this.publicExecutor.simulate(execution, globalVariables, sideEffectCounter);
 
-        const result = isExecutionRequest ? await simulator(current, this.globalVariables) : current;
+        const result = isExecutionRequest
+          ? await this.publicExecutor.simulate(current, this.globalVariables, sideEffectCounter)
+          : current;
 
         const functionSelector = result.execution.functionData.selector.toString();
         if (result.reverted && !PhaseIsRevertible[this.phase]) {
@@ -238,7 +259,7 @@ export abstract class AbstractPhaseManager {
         // sanity check. Note we can't expect them to just be equal, because e.g.
         // if the simulator reverts in app logic, it "resets" and result.reverted will be false when we run teardown,
         // but the kernel carries the reverted flag forward. But if the simulator reverts, so should the kernel.
-        if (result.reverted && kernelOutput.endNonRevertibleData.revertCode.isOK()) {
+        if (result.reverted && kernelOutput.revertCode.isOK()) {
           throw new Error(
             `Public kernel circuit did not revert on ${result.execution.contractAddress.toString()}:${functionSelector}, but simulator did.`,
           );
@@ -252,64 +273,52 @@ export abstract class AbstractPhaseManager {
               result.revertReason
             }`,
           );
-          return [kernelOutput, kernelProof, [], result.revertReason];
+          return [kernelOutput, kernelProof, [], result.revertReason, undefined];
         }
 
         if (!enqueuedExecutionResult) {
           enqueuedExecutionResult = result;
+
+          // Padding as the AVM is not always returning the expected return size (4)
+          // which is expected by the kernel.
+          const paddedReturn = padArrayEnd(result.returnValues, Fr.ZERO, RETURN_VALUES_LENGTH);
+
+          // TODO(#5450) Need to use the proper return values here
+          const returnTypes: AbiType[] = [{ kind: 'array', length: 4, type: { kind: 'field' } }];
+          const mockArtifact = { returnTypes } as any as FunctionArtifact;
+
+          currentReturn = decodeReturnValues(mockArtifact, paddedReturn);
         }
       }
       // HACK(#1622): Manually patches the ordering of public state actions
       // TODO(#757): Enforce proper ordering of public state actions
       patchPublicStorageActionOrdering(kernelOutput, enqueuedExecutionResult!, this.phase);
+
+      returns.push(currentReturn);
     }
 
     // TODO(#3675): This should be done in a public kernel circuit
-    removeRedundantPublicDataWrites(kernelOutput);
+    removeRedundantPublicDataWrites(kernelOutput, this.phase);
 
-    return [kernelOutput, kernelProof, newUnencryptedFunctionLogs, undefined];
+    return [kernelOutput, kernelProof, newUnencryptedFunctionLogs, undefined, returns];
   }
 
   protected async runKernelCircuit(
     previousOutput: PublicKernelCircuitPublicInputs,
     previousProof: Proof,
-    callData?: PublicCallData,
+    callData: PublicCallData,
   ): Promise<[PublicKernelCircuitPublicInputs, Proof]> {
     const output = await this.getKernelCircuitOutput(previousOutput, previousProof, callData);
     return [output, makeEmptyProof()];
   }
 
-  protected async getKernelCircuitOutput(
+  protected getKernelCircuitOutput(
     previousOutput: PublicKernelCircuitPublicInputs,
     previousProof: Proof,
-    callData?: PublicCallData,
+    callData: PublicCallData,
   ): Promise<PublicKernelCircuitPublicInputs> {
     const previousKernel = this.getPreviousKernelData(previousOutput, previousProof);
 
-    if (this.phase === PublicKernelPhase.TAIL) {
-      const { validationRequests, endNonRevertibleData, end } = previousOutput;
-      const nullifierReadRequestHints = await this.hintsBuilder.getNullifierReadRequestHints(
-        validationRequests.nullifierReadRequests,
-        endNonRevertibleData.newNullifiers,
-        end.newNullifiers,
-      );
-      const nullifierNonExistentReadRequestHints = await this.hintsBuilder.getNullifierNonExistentReadRequestHints(
-        validationRequests.nullifierNonExistentReadRequests,
-        endNonRevertibleData.newNullifiers,
-        end.newNullifiers,
-      );
-      const inputs = new PublicKernelTailCircuitPrivateInputs(
-        previousKernel,
-        nullifierReadRequestHints,
-        nullifierNonExistentReadRequestHints,
-      );
-      return this.publicKernel.publicKernelCircuitTail(inputs);
-    }
-
-    if (!callData) {
-      throw new Error(`Cannot run public kernel circuit without call data for phase '${this.phase}'.`);
-    }
-
     const inputs = new PublicKernelCircuitPrivateInputs(previousKernel, callData);
     switch (this.phase) {
       case PublicKernelPhase.SETUP:
@@ -435,26 +444,30 @@ export abstract class AbstractPhaseManager {
   }
 }
 
-function removeRedundantPublicDataWrites(publicInputs: PublicKernelCircuitPublicInputs) {
-  const patch = <N extends number>(requests: Tuple<PublicDataUpdateRequest, N>) => {
-    const lastWritesMap = new Map<string, PublicDataUpdateRequest>();
-    for (const write of requests) {
-      const key = write.leafSlot.toString();
-      lastWritesMap.set(key, write);
-    }
-    return requests.filter(write => lastWritesMap.get(write.leafSlot.toString())?.equals(write));
-  };
+function removeRedundantPublicDataWrites(publicInputs: PublicKernelCircuitPublicInputs, phase: PublicKernelPhase) {
+  const lastWritesMap = new Map<string, boolean>();
+  const patch = <N extends number>(requests: Tuple<PublicDataUpdateRequest, N>) =>
+    requests.filter(write => {
+      const leafSlot = write.leafSlot.toString();
+      const exists = lastWritesMap.get(leafSlot);
+      lastWritesMap.set(leafSlot, true);
+      return !exists;
+    });
+
+  const [prev, curr] = PhaseIsRevertible[phase]
+    ? [publicInputs.endNonRevertibleData, publicInputs.end]
+    : [publicInputs.end, publicInputs.endNonRevertibleData];
 
-  publicInputs.end.publicDataUpdateRequests = padArrayEnd(
-    patch(publicInputs.end.publicDataUpdateRequests),
+  curr.publicDataUpdateRequests = padArrayEnd(
+    patch(curr.publicDataUpdateRequests.reverse()).reverse(),
     PublicDataUpdateRequest.empty(),
-    MAX_REVERTIBLE_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+    MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   );
 
-  publicInputs.endNonRevertibleData.publicDataUpdateRequests = padArrayEnd(
-    patch(publicInputs.endNonRevertibleData.publicDataUpdateRequests),
+  prev.publicDataUpdateRequests = padArrayEnd(
+    patch(prev.publicDataUpdateRequests.reverse()),
     PublicDataUpdateRequest.empty(),
-    MAX_NON_REVERTIBLE_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+    MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   );
 }
 
@@ -531,8 +544,6 @@ function patchPublicStorageActionOrdering(
       ...simPublicDataUpdateRequests,
     ],
     PublicDataUpdateRequest.empty(),
-    PhaseIsRevertible[phase]
-      ? MAX_REVERTIBLE_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
-      : MAX_NON_REVERTIBLE_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+    MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   );
 }

package/src/sequencer/app_logic_phase_manager.ts

@@ -38,9 +38,9 @@ export class AppLogicPhaseManager extends AbstractPhaseManager {
     // TODO(#4073): This is catching only private deployments, when we add public ones, we'll
     // have to capture contracts emitted in that phase as well.
     // TODO(@spalladino): Should we allow emitting contracts in the fee preparation phase?
-    this.log(`Processing tx ${tx.getTxHash()}`);
+    this.log.verbose(`Processing tx ${tx.getTxHash()}`);
     await this.publicContractsDB.addNewContracts(tx);
-    const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs, revertReason] =
+    const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs, revertReason, returnValues] =
       await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof).catch(
         // if we throw for any reason other than simulation, we need to rollback and drop the TX
         async err => {
@@ -57,6 +57,6 @@ export class AppLogicPhaseManager extends AbstractPhaseManager {
       await this.publicStateDB.checkpoint();
     }
 
-    return { publicKernelOutput, publicKernelProof, revertReason };
+    return { publicKernelOutput, publicKernelProof, revertReason, returnValues };
   }
 }

package/src/sequencer/hints_builder.ts

@@ -2,18 +2,21 @@ import { MerkleTreeId } from '@aztec/circuit-types';
 import {
   type Fr,
   MAX_NEW_NULLIFIERS_PER_TX,
-  type MAX_NON_REVERTIBLE_NULLIFIERS_PER_TX,
   type MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX,
   type MAX_NULLIFIER_READ_REQUESTS_PER_TX,
-  type MAX_REVERTIBLE_NULLIFIERS_PER_TX,
+  MAX_PUBLIC_DATA_READS_PER_TX,
   MembershipWitness,
   NULLIFIER_TREE_HEIGHT,
+  PUBLIC_DATA_TREE_HEIGHT,
+  type PublicDataRead,
+  PublicDataTreeLeafPreimage,
   type ReadRequestContext,
   type SideEffectLinkedToNoteHash,
   buildNullifierNonExistentReadRequestHints,
   buildNullifierReadRequestHints,
-  concatAccumulatedData,
+  mergeAccumulatedData,
 } from '@aztec/circuits.js';
+import { makeTuple } from '@aztec/foundation/array';
 import { type Tuple } from '@aztec/foundation/serialize';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
@@ -22,22 +25,22 @@ export class HintsBuilder {
 
   getNullifierReadRequestHints(
     nullifierReadRequests: Tuple<ReadRequestContext, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
-    nullifiersNonRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NON_REVERTIBLE_NULLIFIERS_PER_TX>,
-    nullifiersRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_REVERTIBLE_NULLIFIERS_PER_TX>,
+    nullifiersNonRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NEW_NULLIFIERS_PER_TX>,
+    nullifiersRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NEW_NULLIFIERS_PER_TX>,
   ) {
     return buildNullifierReadRequestHints(
       this,
       nullifierReadRequests,
-      concatAccumulatedData(MAX_NEW_NULLIFIERS_PER_TX, nullifiersNonRevertible, nullifiersRevertible),
+      mergeAccumulatedData(MAX_NEW_NULLIFIERS_PER_TX, nullifiersNonRevertible, nullifiersRevertible),
     );
   }
 
   getNullifierNonExistentReadRequestHints(
     nullifierNonExistentReadRequests: Tuple<ReadRequestContext, typeof MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX>,
-    nullifiersNonRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NON_REVERTIBLE_NULLIFIERS_PER_TX>,
-    nullifiersRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_REVERTIBLE_NULLIFIERS_PER_TX>,
+    nullifiersNonRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NEW_NULLIFIERS_PER_TX>,
+    nullifiersRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NEW_NULLIFIERS_PER_TX>,
   ) {
-    const pendingNullifiers = concatAccumulatedData(
+    const pendingNullifiers = mergeAccumulatedData(
       MAX_NEW_NULLIFIERS_PER_TX,
       nullifiersNonRevertible,
       nullifiersRevertible,
@@ -83,4 +86,34 @@ export class HintsBuilder {
 
     return { membershipWitness, leafPreimage };
   }
+
+  async getPublicDataReadsInfo(publicDataReads: PublicDataRead[]) {
+    const newPublicDataReadsWitnesses: Tuple<
+      MembershipWitness<typeof PUBLIC_DATA_TREE_HEIGHT>,
+      typeof MAX_PUBLIC_DATA_READS_PER_TX
+    > = makeTuple(MAX_PUBLIC_DATA_READS_PER_TX, () => MembershipWitness.empty(PUBLIC_DATA_TREE_HEIGHT, 0n));
+
+    const newPublicDataReadsPreimages: Tuple<PublicDataTreeLeafPreimage, typeof MAX_PUBLIC_DATA_READS_PER_TX> =
+      makeTuple(MAX_PUBLIC_DATA_READS_PER_TX, () => PublicDataTreeLeafPreimage.empty());
+
+    for (const i in publicDataReads) {
+      const leafSlot = publicDataReads[i].leafSlot.value;
+      const lowLeafResult = await this.db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
+      if (!lowLeafResult) {
+        throw new Error(`Public data tree should have one initial leaf`);
+      }
+      const preimage = await this.db.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
+      const path = await this.db.getSiblingPath(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
+      newPublicDataReadsWitnesses[i] = new MembershipWitness(
+        PUBLIC_DATA_TREE_HEIGHT,
+        BigInt(lowLeafResult.index),
+        path.toTuple<typeof PUBLIC_DATA_TREE_HEIGHT>(),
+      );
+      newPublicDataReadsPreimages[i] = preimage! as PublicDataTreeLeafPreimage;
+    }
+    return {
+      newPublicDataReadsWitnesses,
+      newPublicDataReadsPreimages,
+    };
+  }
 }

package/src/sequencer/phase_manager_factory.ts

@@ -34,7 +34,8 @@ export class PhaseManagerFactory {
     publicContractsDB: ContractsDataSourcePublicDB,
     publicStateDB: PublicStateDB,
   ): AbstractPhaseManager | undefined {
-    if (tx.data.needsSetup) {
+    const data = tx.data.forPublic!;
+    if (data.needsSetup) {
       return new SetupPhaseManager(
         db,
         publicExecutor,
@@ -44,7 +45,7 @@ export class PhaseManagerFactory {
         publicContractsDB,
         publicStateDB,
       );
-    } else if (tx.data.needsAppLogic) {
+    } else if (data.needsAppLogic) {
       return new AppLogicPhaseManager(
         db,
         publicExecutor,
@@ -54,7 +55,7 @@ export class PhaseManagerFactory {
         publicContractsDB,
         publicStateDB,
       );
-    } else if (tx.data.needsTeardown) {
+    } else if (data.needsTeardown) {
       return new TeardownPhaseManager(
         db,
         publicExecutor,

package/src/sequencer/public_processor.ts

@@ -1,16 +1,17 @@
 import {
+  type BlockProver,
   type FailedTx,
   type ProcessedTx,
   type SimulationError,
   Tx,
-  getPreviousOutputAndProof,
   makeEmptyProcessedTx,
   makeProcessedTx,
   toTxEffect,
   validateProcessedTx,
 } from '@aztec/circuit-types';
 import { type TxSequencerProcessingStats } from '@aztec/circuit-types/stats';
-import { type GlobalVariables, type Header } from '@aztec/circuits.js';
+import { type GlobalVariables, type Header, type KernelCircuitPublicInputs } from '@aztec/circuits.js';
+import { type ProcessReturnValues } from '@aztec/foundation/abi';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { PublicExecutor, type PublicStateDB, type SimulationProvider } from '@aztec/simulator';
@@ -20,8 +21,9 @@ import { type MerkleTreeOperations } from '@aztec/world-state';
 import { type PublicKernelCircuitSimulator } from '../simulator/index.js';
 import { ContractsDataSourcePublicDB, WorldStateDB, WorldStatePublicDB } from '../simulator/public_executor.js';
 import { RealPublicKernelCircuitSimulator } from '../simulator/public_kernel.js';
-import { type AbstractPhaseManager } from './abstract_phase_manager.js';
+import { type AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
 import { PhaseManagerFactory } from './phase_manager_factory.js';
+import { type TxValidator } from './tx_validator.js';
 
 /**
  * Creates new instances of PublicProcessor given the provided merkle tree db and contract data source.
@@ -84,60 +86,45 @@ export class PublicProcessor {
    * @param txs - Txs to process.
    * @returns The list of processed txs with their circuit simulation outputs.
    */
-  public async process(txs: Tx[]): Promise<[ProcessedTx[], FailedTx[]]> {
+  public async process(
+    txs: Tx[],
+    maxTransactions = txs.length,
+    blockProver?: BlockProver,
+    txValidator?: TxValidator,
+  ): Promise<[ProcessedTx[], FailedTx[], ProcessReturnValues[]]> {
     // The processor modifies the tx objects in place, so we need to clone them.
     txs = txs.map(tx => Tx.clone(tx));
     const result: ProcessedTx[] = [];
     const failed: FailedTx[] = [];
+    const returns: ProcessReturnValues[] = [];
 
     for (const tx of txs) {
-      let phase: AbstractPhaseManager | undefined = PhaseManagerFactory.phaseFromTx(
-        tx,
-        this.db,
-        this.publicExecutor,
-        this.publicKernel,
-        this.globalVariables,
-        this.historicalHeader,
-        this.publicContractsDB,
-        this.publicStateDB,
-      );
-      this.log(`Beginning processing in phase ${phase?.phase} for tx ${tx.getTxHash()}`);
-      let { publicKernelPublicInput, previousProof: proof } = getPreviousOutputAndProof(tx, undefined, undefined);
-      let revertReason: SimulationError | undefined;
-      const timer = new Timer();
+      // only process up to the limit of the block
+      if (result.length >= maxTransactions) {
+        break;
+      }
       try {
-        while (phase) {
-          const output = await phase.handle(tx, publicKernelPublicInput, proof);
-          publicKernelPublicInput = output.publicKernelOutput;
-          proof = output.publicKernelProof;
-          revertReason ??= output.revertReason;
-          phase = PhaseManagerFactory.phaseFromOutput(
-            publicKernelPublicInput,
-            phase,
-            this.db,
-            this.publicExecutor,
-            this.publicKernel,
-            this.globalVariables,
-            this.historicalHeader,
-            this.publicContractsDB,
-            this.publicStateDB,
-          );
+        const [processedTx, returnValues] = !tx.hasPublicCalls()
+          ? [makeProcessedTx(tx, tx.data.toKernelCircuitPublicInputs(), tx.proof)]
+          : await this.processTxWithPublicCalls(tx);
+        validateProcessedTx(processedTx);
+        // Re-validate the transaction
+        if (txValidator) {
+          // Only accept processed transactions that are not double-spends,
+          // public functions emitting nullifiers would pass earlier check but fail here.
+          // Note that we're checking all nullifiers generated in the private execution twice,
+          // we could store the ones already checked and skip them here as an optimization.
+          const [_, invalid] = await txValidator.validateTxs([processedTx]);
+          if (invalid.length) {
+            throw new Error(`Transaction ${invalid[0].hash} invalid after processing public functions`);
+          }
         }
-
-        const processedTransaction = makeProcessedTx(tx, publicKernelPublicInput, proof, revertReason);
-        validateProcessedTx(processedTransaction);
-
-        result.push(processedTransaction);
-
-        this.log(`Processed public part of ${tx.data.endNonRevertibleData.newNullifiers[0].value}`, {
-          eventName: 'tx-sequencer-processing',
-          duration: timer.ms(),
-          effectsSize: toTxEffect(processedTransaction).toBuffer().length,
-          publicDataUpdateRequests:
-            processedTransaction.data.combinedData.publicDataUpdateRequests.filter(x => !x.leafSlot.isZero()).length ??
-            0,
-          ...tx.getStats(),
-        } satisfies TxSequencerProcessingStats);
+        // if we were given a prover then send the transaction to it for proving
+        if (blockProver) {
+          await blockProver.addNewTx(processedTx);
+        }
+        result.push(processedTx);
+        returns.push(returnValues);
       } catch (err: any) {
         const errorMessage = err instanceof Error ? err.message : 'Unknown error';
         this.log.warn(`Failed to process tx ${tx.getTxHash()}: ${errorMessage}`);
@@ -146,10 +133,11 @@ export class PublicProcessor {
           tx,
           error: err instanceof Error ? err : new Error(errorMessage),
         });
+        returns.push([]);
       }
     }
 
-    return [result, failed];
+    return [result, failed, returns];
   }
 
   /**
@@ -158,6 +146,64 @@ export class PublicProcessor {
    */
   public makeEmptyProcessedTx(): ProcessedTx {
     const { chainId, version } = this.globalVariables;
-    return makeEmptyProcessedTx(this.historicalHeader, chainId, version);
+    return makeEmptyProcessedTx(this.historicalHeader.clone(), chainId, version);
+  }
+
+  private async processTxWithPublicCalls(tx: Tx): Promise<[ProcessedTx, ProcessReturnValues | undefined]> {
+    let returnValues: ProcessReturnValues = undefined;
+    let phase: AbstractPhaseManager | undefined = PhaseManagerFactory.phaseFromTx(
+      tx,
+      this.db,
+      this.publicExecutor,
+      this.publicKernel,
+      this.globalVariables,
+      this.historicalHeader,
+      this.publicContractsDB,
+      this.publicStateDB,
+    );
+    this.log.debug(`Beginning processing in phase ${phase?.phase} for tx ${tx.getTxHash()}`);
+    let proof = tx.proof;
+    let publicKernelPublicInput = tx.data.toPublicKernelCircuitPublicInputs();
+    let finalKernelOutput: KernelCircuitPublicInputs | undefined;
+    let revertReason: SimulationError | undefined;
+    const timer = new Timer();
+    while (phase) {
+      const output = await phase.handle(tx, publicKernelPublicInput, proof);
+      if (phase.phase === PublicKernelPhase.APP_LOGIC) {
+        returnValues = output.returnValues;
+      }
+      publicKernelPublicInput = output.publicKernelOutput;
+      finalKernelOutput = output.finalKernelOutput;
+      proof = output.publicKernelProof;
+      revertReason ??= output.revertReason;
+      phase = PhaseManagerFactory.phaseFromOutput(
+        publicKernelPublicInput,
+        phase,
+        this.db,
+        this.publicExecutor,
+        this.publicKernel,
+        this.globalVariables,
+        this.historicalHeader,
+        this.publicContractsDB,
+        this.publicStateDB,
+      );
+    }
+
+    if (!finalKernelOutput) {
+      throw new Error('Final public kernel was not executed.');
+    }
+
+    const processedTx = makeProcessedTx(tx, finalKernelOutput, proof, revertReason);
+
+    this.log.debug(`Processed public part of ${tx.getTxHash()}`, {
+      eventName: 'tx-sequencer-processing',
+      duration: timer.ms(),
+      effectsSize: toTxEffect(processedTx).toBuffer().length,
+      publicDataUpdateRequests:
+        processedTx.data.end.publicDataUpdateRequests.filter(x => !x.leafSlot.isZero()).length ?? 0,
+      ...tx.getStats(),
+    } satisfies TxSequencerProcessingStats);
+
+    return [processedTx, returnValues];
   }
 }