@aztec/sequencer-client 0.26.5 → 0.27.0

package/src/publisher/viem-tx-sender.ts

@@ -1,8 +1,7 @@
-import { ExtendedContractData, L2Block } from '@aztec/circuit-types';
-import { BLOB_SIZE_IN_BYTES } from '@aztec/circuits.js/constants';
+import { L2Block } from '@aztec/circuit-types';
 import { createEthereumChain } from '@aztec/ethereum';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { AvailabilityOracleAbi, ContractDeploymentEmitterAbi, RollupAbi } from '@aztec/l1-artifacts';
+import { AvailabilityOracleAbi, RollupAbi } from '@aztec/l1-artifacts';
 
 import {
   GetContractReturnType,
@@ -40,10 +39,6 @@ export class ViemTxSender implements L1PublisherTxSender {
     typeof RollupAbi,
     WalletClient<HttpTransport, chains.Chain, PrivateKeyAccount>
   >;
-  private contractDeploymentEmitterContract: GetContractReturnType<
-    typeof ContractDeploymentEmitterAbi,
-    WalletClient<HttpTransport, chains.Chain, PrivateKeyAccount>
-  >;
 
   private log = createDebugLogger('aztec:sequencer:viem-tx-sender');
   private publicClient: PublicClient<HttpTransport, chains.Chain>;
@@ -74,11 +69,6 @@ export class ViemTxSender implements L1PublisherTxSender {
       abi: RollupAbi,
       client: walletClient,
     });
-    this.contractDeploymentEmitterContract = getContract({
-      address: getAddress(l1Contracts.contractDeploymentEmitterAddress.toString()),
-      abi: ContractDeploymentEmitterAbi,
-      client: walletClient,
-    });
   }
 
   async getCurrentArchive(): Promise<Buffer> {
@@ -169,46 +159,6 @@ export class ViemTxSender implements L1PublisherTxSender {
     return hash;
   }
 
-  /**
-   * Sends a tx to the contract deployment emitter contract with contract deployment data such as bytecode. Returns once the tx has been mined.
-   * @param l2BlockNum - Number of the L2 block that owns this encrypted logs.
-   * @param l2BlockHash - The hash of the block corresponding to this data.
-   * @param newExtendedContractData - Data to publish.
-   * @returns The hash of the mined tx.
-   */
-  async sendEmitContractDeploymentTx(
-    l2BlockNum: number,
-    l2BlockHash: Buffer,
-    newExtendedContractData: ExtendedContractData[],
-  ): Promise<(string | undefined)[]> {
-    const hashes: string[] = [];
-    for (const extendedContractData of newExtendedContractData) {
-      const args = [
-        BigInt(l2BlockNum),
-        extendedContractData.contractData.contractAddress.toString() as Hex,
-        extendedContractData.contractData.portalContractAddress.toString() as Hex,
-        `0x${l2BlockHash.toString('hex')}`,
-        extendedContractData.contractClassId.toString(),
-        extendedContractData.saltedInitializationHash.toString(),
-        extendedContractData.publicKeyHash.toString(),
-        `0x${extendedContractData.bytecode.toString('hex')}`,
-      ] as const;
-
-      const codeSize = extendedContractData.bytecode.length;
-      this.log(`Bytecode is ${codeSize} bytes and require ${codeSize / BLOB_SIZE_IN_BYTES} blobs`);
-
-      const gas = await this.contractDeploymentEmitterContract.estimateGas.emitContractDeployment(args, {
-        account: this.account,
-      });
-      const hash = await this.contractDeploymentEmitterContract.write.emitContractDeployment(args, {
-        gas,
-        account: this.account,
-      });
-      hashes.push(hash);
-    }
-    return hashes;
-  }
-
   /**
    * Gets the chain object for the given chain id.
    * @param chainId - Chain id of the target EVM chain.

package/src/sequencer/abstract_phase_manager.ts

@@ -1,4 +1,4 @@
-import { FunctionL2Logs, MerkleTreeId, Tx } from '@aztec/circuit-types';
+import { FunctionL2Logs, MerkleTreeId, SimulationError, Tx } from '@aztec/circuit-types';
 import {
   AztecAddress,
   CallRequest,
@@ -13,6 +13,7 @@ import {
   MAX_NEW_NULLIFIERS_PER_CALL,
   MAX_NON_REVERTIBLE_PUBLIC_DATA_READS_PER_TX,
   MAX_NON_REVERTIBLE_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+  MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
   MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
   MAX_PUBLIC_DATA_READS_PER_CALL,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
@@ -21,8 +22,6 @@ import {
   MembershipWitness,
   PrivateKernelTailCircuitPublicInputs,
   Proof,
-  PublicAccumulatedNonRevertibleData,
-  PublicAccumulatedRevertibleData,
   PublicCallData,
   PublicCallRequest,
   PublicCallStackItem,
@@ -32,7 +31,9 @@ import {
   PublicKernelCircuitPrivateInputs,
   PublicKernelCircuitPublicInputs,
   PublicKernelData,
+  PublicKernelTailCircuitPrivateInputs,
   RETURN_VALUES_LENGTH,
+  ReadRequest,
   SideEffect,
   SideEffectLinkedToNoteHash,
   VK_TREE_HEIGHT,
@@ -56,21 +57,25 @@ import { env } from 'process';
 import { getVerificationKeys } from '../mocks/verification_keys.js';
 import { PublicProver } from '../prover/index.js';
 import { PublicKernelCircuitSimulator } from '../simulator/index.js';
+import { HintsBuilder } from './hints_builder.js';
 import { FailedTx } from './processed_tx.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]: false,
+  [PublicKernelPhase.TAIL]: false,
 };
 
 export abstract class AbstractPhaseManager {
+  protected hintsBuilder: HintsBuilder;
   protected log: DebugLogger;
   constructor(
     protected db: MerkleTreeOperations,
@@ -81,6 +86,7 @@ export abstract class AbstractPhaseManager {
     protected historicalHeader: Header,
     public phase: PublicKernelPhase,
   ) {
+    this.hintsBuilder = new HintsBuilder(db);
     this.log = createDebugLogger(`aztec:sequencer:${phase}`);
   }
   /**
@@ -102,6 +108,10 @@ export abstract class AbstractPhaseManager {
      * the proof of the public kernel circuit for this phase
      */
     publicKernelProof: Proof;
+    /**
+     * revert reason, if any
+     */
+    revertReason: SimulationError | undefined;
   }>;
   abstract rollback(tx: Tx, err: unknown): Promise<FailedTx>;
 
@@ -127,6 +137,7 @@ export abstract class AbstractPhaseManager {
         [PublicKernelPhase.SETUP]: [],
         [PublicKernelPhase.APP_LOGIC]: [],
         [PublicKernelPhase.TEARDOWN]: [],
+        [PublicKernelPhase.TAIL]: [],
       };
     }
 
@@ -140,12 +151,14 @@ export abstract class AbstractPhaseManager {
         [PublicKernelPhase.SETUP]: [],
         [PublicKernelPhase.APP_LOGIC]: publicCallsStack,
         [PublicKernelPhase.TEARDOWN]: [],
+        [PublicKernelPhase.TAIL]: [],
       };
     } else {
       return {
         [PublicKernelPhase.SETUP]: publicCallsStack.slice(0, firstRevertibleCallIndex - 1),
         [PublicKernelPhase.APP_LOGIC]: publicCallsStack.slice(firstRevertibleCallIndex),
         [PublicKernelPhase.TEARDOWN]: [publicCallsStack[firstRevertibleCallIndex - 1]],
+        [PublicKernelPhase.TAIL]: [],
       };
     }
   }
@@ -158,55 +171,18 @@ export abstract class AbstractPhaseManager {
     return calls;
   }
 
-  public static getKernelOutputAndProof(
-    tx: Tx,
-    publicKernelPublicInput?: PublicKernelCircuitPublicInputs,
-    previousPublicKernelProof?: Proof,
-  ): {
-    /**
-     * the output of the public kernel circuit for this phase
-     */
-    publicKernelPublicInput: PublicKernelCircuitPublicInputs;
-    /**
-     * the proof of the public kernel circuit for this phase
-     */
-    publicKernelProof: Proof;
-  } {
-    if (publicKernelPublicInput && previousPublicKernelProof) {
-      return {
-        publicKernelPublicInput: publicKernelPublicInput,
-        publicKernelProof: previousPublicKernelProof,
-      };
-    } else {
-      const publicKernelPublicInput = new PublicKernelCircuitPublicInputs(
-        tx.data.aggregationObject,
-        PublicAccumulatedNonRevertibleData.fromPrivateAccumulatedNonRevertibleData(tx.data.endNonRevertibleData),
-        PublicAccumulatedRevertibleData.fromPrivateAccumulatedRevertibleData(tx.data.end),
-        tx.data.constants,
-        tx.data.needsSetup,
-        tx.data.needsAppLogic,
-        tx.data.needsTeardown,
-      );
-      const publicKernelProof = previousPublicKernelProof || tx.proof;
-      return {
-        publicKernelPublicInput,
-        publicKernelProof,
-      };
-    }
-  }
-
   protected async processEnqueuedPublicCalls(
     tx: Tx,
     previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
     previousPublicKernelProof: Proof,
-  ): Promise<[PublicKernelCircuitPublicInputs, Proof, FunctionL2Logs[]]> {
+  ): Promise<[PublicKernelCircuitPublicInputs, Proof, FunctionL2Logs[], SimulationError | undefined]> {
     let kernelOutput = previousPublicKernelOutput;
     let kernelProof = previousPublicKernelProof;
 
     const enqueuedCalls = this.extractEnqueuedPublicCalls(tx);
 
     if (!enqueuedCalls || !enqueuedCalls.length) {
-      return [kernelOutput, kernelProof, []];
+      return [kernelOutput, kernelProof, [], undefined];
     }
 
     const newUnencryptedFunctionLogs: FunctionL2Logs[] = [];
@@ -241,7 +217,18 @@ export abstract class AbstractPhaseManager {
         executionStack.push(...result.nestedExecutions);
         const callData = await this.getPublicCallData(result, isExecutionRequest);
 
-        [kernelOutput, kernelProof] = await this.runKernelCircuit(callData, kernelOutput, kernelProof);
+        [kernelOutput, kernelProof] = await this.runKernelCircuit(kernelOutput, kernelProof, callData);
+
+        if (kernelOutput.reverted && this.phase === PublicKernelPhase.APP_LOGIC) {
+          this.log.debug(
+            `Reverting on ${result.execution.contractAddress.toString()}:${functionSelector} with reason: ${
+              result.revertReason
+            }`,
+          );
+          // halt immediately if the public kernel circuit has reverted.
+          // return no logs, as they should not go on-chain.
+          return [kernelOutput, kernelProof, [], result.revertReason];
+        }
 
         if (!enqueuedExecutionResult) {
           enqueuedExecutionResult = result;
@@ -255,25 +242,42 @@ export abstract class AbstractPhaseManager {
     // TODO(#3675): This should be done in a public kernel circuit
     removeRedundantPublicDataWrites(kernelOutput);
 
-    return [kernelOutput, kernelProof, newUnencryptedFunctionLogs];
+    return [kernelOutput, kernelProof, newUnencryptedFunctionLogs, undefined];
   }
 
   protected async runKernelCircuit(
-    callData: PublicCallData,
     previousOutput: PublicKernelCircuitPublicInputs,
     previousProof: Proof,
+    callData?: PublicCallData,
   ): Promise<[PublicKernelCircuitPublicInputs, Proof]> {
-    const output = await this.getKernelCircuitOutput(callData, previousOutput, previousProof);
+    const output = await this.getKernelCircuitOutput(previousOutput, previousProof, callData);
     const proof = await this.publicProver.getPublicKernelCircuitProof(output);
     return [output, proof];
   }
 
-  protected getKernelCircuitOutput(
-    callData: PublicCallData,
+  protected async getKernelCircuitOutput(
     previousOutput: PublicKernelCircuitPublicInputs,
     previousProof: Proof,
+    callData?: PublicCallData,
   ): Promise<PublicKernelCircuitPublicInputs> {
     const previousKernel = this.getPreviousKernelData(previousOutput, previousProof);
+
+    if (this.phase === PublicKernelPhase.TAIL) {
+      const { endNonRevertibleData, end } = previousOutput;
+      const nullifierReadRequestResetHints = await this.hintsBuilder.getNullifierReadRequestResetHints(
+        endNonRevertibleData.nullifierReadRequests,
+        end.nullifierReadRequests,
+        endNonRevertibleData.newNullifiers,
+        end.newNullifiers,
+      );
+      const inputs = new PublicKernelTailCircuitPrivateInputs(previousKernel, nullifierReadRequestResetHints);
+      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:
@@ -320,6 +324,11 @@ export abstract class AbstractPhaseManager {
       newNullifiers: padArrayEnd(result.newNullifiers, SideEffectLinkedToNoteHash.empty(), MAX_NEW_NULLIFIERS_PER_CALL),
       newL2ToL1Msgs: padArrayEnd(result.newL2ToL1Messages, L2ToL1Message.empty(), MAX_NEW_L2_TO_L1_MSGS_PER_CALL),
       returnValues: padArrayEnd(result.returnValues, Fr.ZERO, RETURN_VALUES_LENGTH),
+      nullifierReadRequests: padArrayEnd(
+        result.nullifierReadRequests,
+        ReadRequest.empty(),
+        MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
+      ),
       contractStorageReads: padArrayEnd(
         result.contractStorageReads,
         ContractStorageRead.empty(),
@@ -334,6 +343,7 @@ export abstract class AbstractPhaseManager {
       unencryptedLogsHash,
       unencryptedLogPreimagesLength,
       historicalHeader: this.historicalHeader,
+      reverted: result.reverted,
     });
   }
 

package/src/sequencer/app_logic_phase_manager.ts

@@ -27,42 +27,32 @@ export class AppLogicPhaseManager extends AbstractPhaseManager {
     super(db, publicExecutor, publicKernel, publicProver, globalVariables, historicalHeader, phase);
   }
 
-  async handle(
+  override async handle(
     tx: Tx,
     previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
     previousPublicKernelProof: Proof,
-  ): Promise<{
-    /**
-     * the output of the public kernel circuit for this phase
-     */
-    publicKernelOutput: PublicKernelCircuitPublicInputs;
-    /**
-     * the proof of the public kernel circuit for this phase
-     */
-    publicKernelProof: Proof;
-  }> {
+  ) {
     // add new contracts to the contracts db so that their functions may be found and called
     // 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()}`);
     await this.publicContractsDB.addNewContracts(tx);
-    this.log(`Executing enqueued public calls for tx ${tx.getTxHash()}`);
-    const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs] = await this.processEnqueuedPublicCalls(
-      tx,
-      previousPublicKernelOutput,
-      previousPublicKernelProof,
-    );
-    tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
+    const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs, revertReason] =
+      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof);
 
-    // commit the state updates from this transaction
-    await this.publicStateDB.commit();
+    if (revertReason) {
+      await this.rollback(tx, revertReason);
+    } else {
+      tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
+      await this.publicStateDB.commit();
+    }
 
-    return { publicKernelOutput, publicKernelProof };
+    return { publicKernelOutput, publicKernelProof, revertReason };
   }
 
   async rollback(tx: Tx, err: unknown): Promise<FailedTx> {
-    this.log.warn(`Error processing tx ${tx.getTxHash()}: ${err}`);
+    this.log.warn(`Rolling back changes from ${tx.getTxHash()}`);
     // remove contracts on failure
     await this.publicContractsDB.removeNewContracts(tx);
     // rollback any state updates from this failed transaction

package/src/sequencer/hints_builder.ts

@@ -0,0 +1,56 @@
+import { MerkleTreeId } from '@aztec/circuit-types';
+import {
+  Fr,
+  MAX_NEW_NULLIFIERS_PER_TX,
+  MAX_NON_REVERTIBLE_NULLIFIERS_PER_TX,
+  MAX_NULLIFIER_READ_REQUESTS_PER_TX,
+  MAX_REVERTIBLE_NULLIFIERS_PER_TX,
+  MembershipWitness,
+  NULLIFIER_TREE_HEIGHT,
+  NullifierLeafPreimage,
+  ReadRequestContext,
+  SideEffectLinkedToNoteHash,
+  buildNullifierReadRequestResetHints,
+  concatAccumulatedData,
+  mergeAccumulatedData,
+} from '@aztec/circuits.js';
+import { Tuple } from '@aztec/foundation/serialize';
+import { MerkleTreeOperations } from '@aztec/world-state';
+
+export class HintsBuilder {
+  constructor(private db: MerkleTreeOperations) {}
+
+  getNullifierReadRequestResetHints(
+    nullifierReadRequestsNonRevertible: Tuple<ReadRequestContext, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
+    nullifierReadRequestsRevertible: 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>,
+  ) {
+    return buildNullifierReadRequestResetHints(
+      this,
+      mergeAccumulatedData(
+        MAX_NULLIFIER_READ_REQUESTS_PER_TX,
+        nullifierReadRequestsNonRevertible,
+        nullifierReadRequestsRevertible,
+      ),
+      concatAccumulatedData(MAX_NEW_NULLIFIERS_PER_TX, nullifiersNonRevertible, nullifiersRevertible),
+    );
+  }
+
+  async getNullifierMembershipWitness(nullifier: Fr) {
+    const index = await this.db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
+    if (index === undefined) {
+      return;
+    }
+
+    const siblingPath = await this.db.getSiblingPath(MerkleTreeId.NULLIFIER_TREE, index);
+    const membershipWitness = new MembershipWitness(
+      NULLIFIER_TREE_HEIGHT,
+      index,
+      siblingPath.toTuple<typeof NULLIFIER_TREE_HEIGHT>(),
+    );
+    const leafPreimage = (await this.db.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index))! as NullifierLeafPreimage;
+
+    return { membershipWitness, leafPreimage };
+  }
+}

package/src/sequencer/index.ts

@@ -1,2 +1,2 @@
-export * from './sequencer.js';
 export * from './config.js';
+export * from './sequencer.js';

package/src/sequencer/phase_manager_factory.ts

@@ -9,6 +9,7 @@ import { ContractsDataSourcePublicDB } from '../simulator/public_executor.js';
 import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
 import { AppLogicPhaseManager } from './app_logic_phase_manager.js';
 import { SetupPhaseManager } from './setup_phase_manager.js';
+import { TailPhaseManager } from './tail_phase_manager.js';
 import { TeardownPhaseManager } from './teardown_phase_manager.js';
 
 export class PhaseDidNotChangeError extends Error {
@@ -115,6 +116,17 @@ export class PhaseManagerFactory {
         publicContractsDB,
         publicStateDB,
       );
+    } else if (currentPhaseManager.phase !== PublicKernelPhase.TAIL) {
+      return new TailPhaseManager(
+        db,
+        publicExecutor,
+        publicKernel,
+        publicProver,
+        globalVariables,
+        historicalHeader,
+        publicContractsDB,
+        publicStateDB,
+      );
     } else {
       return undefined;
     }

package/src/sequencer/processed_tx.ts

@@ -1,19 +1,25 @@
-import { ExtendedContractData, Tx, TxHash, TxL2Logs } from '@aztec/circuit-types';
+import { PublicDataWrite, SimulationError, Tx, TxEffect, TxHash, TxL2Logs } from '@aztec/circuit-types';
 import {
   Fr,
   Header,
+  MAX_NEW_NOTE_HASHES_PER_TX,
+  MAX_NEW_NULLIFIERS_PER_TX,
+  MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   Proof,
   PublicAccumulatedNonRevertibleData,
   PublicAccumulatedRevertibleData,
   PublicKernelCircuitPublicInputs,
+  SideEffect,
+  SideEffectLinkedToNoteHash,
   makeEmptyProof,
 } from '@aztec/circuits.js';
+import { Tuple, fromFieldsTuple } from '@aztec/foundation/serialize';
 
 /**
  * Represents a tx that has been processed by the sequencer public processor,
  * so its kernel circuit public inputs are filled in.
  */
-export type ProcessedTx = Pick<Tx, 'proof' | 'encryptedLogs' | 'unencryptedLogs' | 'newContracts'> & {
+export type ProcessedTx = Pick<Tx, 'proof' | 'encryptedLogs' | 'unencryptedLogs'> & {
   /**
    * Output of the public kernel circuit for this tx.
    */
@@ -26,8 +32,39 @@ export type ProcessedTx = Pick<Tx, 'proof' | 'encryptedLogs' | 'unencryptedLogs'
    * Flag indicating the tx is 'empty' meaning it's a padding tx to take us to a power of 2.
    */
   isEmpty: boolean;
+
+  /**
+   * Reason the tx was reverted.
+   */
+  revertReason: SimulationError | undefined;
+};
+
+export type RevertedTx = ProcessedTx & {
+  data: PublicKernelCircuitPublicInputs & {
+    reverted: true;
+  };
+
+  revertReason: SimulationError;
 };
 
+export function isRevertedTx(tx: ProcessedTx): tx is RevertedTx {
+  return tx.data.reverted;
+}
+
+export function partitionReverts(txs: ProcessedTx[]): { reverted: RevertedTx[]; nonReverted: ProcessedTx[] } {
+  return txs.reduce(
+    ({ reverted, nonReverted }, tx) => {
+      if (isRevertedTx(tx)) {
+        reverted.push(tx);
+      } else {
+        nonReverted.push(tx);
+      }
+      return { reverted, nonReverted };
+    },
+    { reverted: [], nonReverted: [] } as ReturnType<typeof partitionReverts>,
+  );
+}
+
 /**
  * Represents a tx that failed to be processed by the sequencer public processor.
  */
@@ -42,31 +79,72 @@ export type FailedTx = {
   error: Error;
 };
 
+/**
+ *
+ * @param tx - the TX being procesed
+ * @param publicKernelPublicInput - the output of the public kernel circuit, unless we just came from private
+ * @param publicKernelProof - the proof of the public kernel circuit, unless we just came from private
+ * @returns PublicKernelCircuitPublicInputs, either passed through from the input or converted from the output of the TX,
+ * and Proof, either passed through from the input or the proof of the TX
+ */
+export function getPreviousOutputAndProof(
+  tx: Tx,
+  publicKernelPublicInput?: PublicKernelCircuitPublicInputs,
+  publicKernelProof?: Proof,
+): {
+  /**
+   * the output of the public kernel circuit for this phase
+   */
+  publicKernelPublicInput: PublicKernelCircuitPublicInputs;
+  /**
+   * the proof of the public kernel circuit for this phase
+   */
+  previousProof: Proof;
+} {
+  if (publicKernelPublicInput && publicKernelProof) {
+    return {
+      publicKernelPublicInput,
+      previousProof: publicKernelProof,
+    };
+  } else {
+    const publicKernelPublicInput = new PublicKernelCircuitPublicInputs(
+      tx.data.aggregationObject,
+      PublicAccumulatedNonRevertibleData.fromPrivateAccumulatedNonRevertibleData(tx.data.endNonRevertibleData),
+      PublicAccumulatedRevertibleData.fromPrivateAccumulatedRevertibleData(tx.data.end),
+      tx.data.constants,
+      tx.data.needsSetup,
+      tx.data.needsAppLogic,
+      tx.data.needsTeardown,
+      false, // reverted
+    );
+    return {
+      publicKernelPublicInput,
+      previousProof: publicKernelProof || tx.proof,
+    };
+  }
+}
+
 /**
  * Makes a processed tx out of source tx.
  * @param tx - Source tx.
  * @param kernelOutput - Output of the kernel circuit simulation for this tx.
  * @param proof - Proof of the kernel circuit for this tx.
  */
-export function makeProcessedTx(tx: Tx, kernelOutput?: PublicKernelCircuitPublicInputs, proof?: Proof): ProcessedTx {
+export function makeProcessedTx(
+  tx: Tx,
+  kernelOutput?: PublicKernelCircuitPublicInputs,
+  proof?: Proof,
+  revertReason?: SimulationError,
+): ProcessedTx {
+  const { publicKernelPublicInput, previousProof } = getPreviousOutputAndProof(tx, kernelOutput, proof);
   return {
     hash: tx.getTxHash(),
-    data:
-      kernelOutput ??
-      new PublicKernelCircuitPublicInputs(
-        tx.data.aggregationObject,
-        PublicAccumulatedNonRevertibleData.fromPrivateAccumulatedNonRevertibleData(tx.data.endNonRevertibleData),
-        PublicAccumulatedRevertibleData.fromPrivateAccumulatedRevertibleData(tx.data.end),
-        tx.data.constants,
-        tx.data.needsSetup,
-        tx.data.needsAppLogic,
-        tx.data.needsTeardown,
-      ),
-    proof: proof ?? tx.proof,
-    encryptedLogs: tx.encryptedLogs,
-    unencryptedLogs: tx.unencryptedLogs,
-    newContracts: tx.newContracts,
+    data: publicKernelPublicInput,
+    proof: previousProof,
+    encryptedLogs: revertReason ? new TxL2Logs([]) : tx.encryptedLogs,
+    unencryptedLogs: revertReason ? new TxL2Logs([]) : tx.unencryptedLogs,
     isEmpty: false,
+    revertReason,
   };
 }
 
@@ -88,7 +166,43 @@ export function makeEmptyProcessedTx(header: Header, chainId: Fr, version: Fr):
     unencryptedLogs: new TxL2Logs([]),
     data: emptyKernelOutput,
     proof: emptyProof,
-    newContracts: [ExtendedContractData.empty()],
     isEmpty: true,
+    revertReason: undefined,
   };
 }
+
+export function toTxEffect(tx: ProcessedTx): TxEffect {
+  return new TxEffect(
+    tx.data.combinedData.newNoteHashes.map((c: SideEffect) => c.value) as Tuple<Fr, typeof MAX_NEW_NOTE_HASHES_PER_TX>,
+    tx.data.combinedData.newNullifiers.map((n: SideEffectLinkedToNoteHash) => n.value) as Tuple<
+      Fr,
+      typeof MAX_NEW_NULLIFIERS_PER_TX
+    >,
+    tx.data.combinedData.newL2ToL1Msgs,
+    tx.data.combinedData.publicDataUpdateRequests.map(t => new PublicDataWrite(t.leafSlot, t.newValue)) as Tuple<
+      PublicDataWrite,
+      typeof MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
+    >,
+    tx.encryptedLogs || new TxL2Logs([]),
+    tx.unencryptedLogs || new TxL2Logs([]),
+  );
+}
+
+function validateProcessedTxLogs(tx: ProcessedTx): void {
+  const unencryptedLogs = tx.unencryptedLogs || new TxL2Logs([]);
+  const kernelUnencryptedLogsHash = fromFieldsTuple(tx.data.combinedData.unencryptedLogsHash);
+  if (!unencryptedLogs.hash().equals(kernelUnencryptedLogsHash)) {
+    throw new Error(
+      `Unencrypted logs hash mismatch. Expected ${unencryptedLogs
+        .hash()
+        .toString('hex')}, got ${kernelUnencryptedLogsHash.toString('hex')}.
+             Processed: ${JSON.stringify(unencryptedLogs.toJSON())}
+             Kernel Length: ${tx.data.combinedData.unencryptedLogPreimagesLength}`,
+    );
+  }
+}
+
+export function validateProcessedTx(tx: ProcessedTx): void {
+  validateProcessedTxLogs(tx);
+  // TODO: validate other fields
+}