@aztec/sequencer-client 0.26.5 → 0.27.0

package/src/sequencer/public_processor.ts

@@ -1,4 +1,4 @@
-import { ContractDataSource, L1ToL2MessageSource, Tx } from '@aztec/circuit-types';
+import { ContractDataSource, L1ToL2MessageSource, SimulationError, Tx } from '@aztec/circuit-types';
 import { TxSequencerProcessingStats } from '@aztec/circuit-types/stats';
 import { GlobalVariables, Header } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
@@ -14,7 +14,14 @@ import { RealPublicKernelCircuitSimulator } from '../simulator/public_kernel.js'
 import { SimulationProvider } from '../simulator/simulation_provider.js';
 import { AbstractPhaseManager } from './abstract_phase_manager.js';
 import { PhaseManagerFactory } from './phase_manager_factory.js';
-import { FailedTx, ProcessedTx, makeEmptyProcessedTx, makeProcessedTx } from './processed_tx.js';
+import {
+  FailedTx,
+  ProcessedTx,
+  getPreviousOutputAndProof,
+  makeEmptyProcessedTx,
+  makeProcessedTx,
+  validateProcessedTx,
+} from './processed_tx.js';
 
 /**
  * Creates new instances of PublicProcessor given the provided merkle tree db and contract data source.
@@ -99,17 +106,15 @@ export class PublicProcessor {
         this.publicStateDB,
       );
       this.log(`Beginning processing in phase ${phase?.phase} for tx ${tx.getTxHash()}`);
-      let { publicKernelPublicInput, publicKernelProof } = AbstractPhaseManager.getKernelOutputAndProof(
-        tx,
-        undefined,
-        undefined,
-      );
+      let { publicKernelPublicInput, previousProof: proof } = getPreviousOutputAndProof(tx, undefined, undefined);
+      let revertReason: SimulationError | undefined;
       const timer = new Timer();
       try {
         while (phase) {
-          const output = await phase.handle(tx, publicKernelPublicInput, publicKernelProof);
+          const output = await phase.handle(tx, publicKernelPublicInput, proof);
           publicKernelPublicInput = output.publicKernelOutput;
-          publicKernelProof = output.publicKernelProof;
+          proof = output.publicKernelProof;
+          revertReason ??= output.revertReason;
           phase = PhaseManagerFactory.phaseFromOutput(
             publicKernelPublicInput,
             phase,
@@ -124,7 +129,9 @@ export class PublicProcessor {
           );
         }
 
-        const processedTransaction = makeProcessedTx(tx, publicKernelPublicInput, publicKernelProof);
+        const processedTransaction = makeProcessedTx(tx, publicKernelPublicInput, proof, revertReason);
+        validateProcessedTx(processedTransaction);
+
         result.push(processedTransaction);
 
         this.log(`Processed public part of ${tx.data.endNonRevertibleData.newNullifiers[0].value}`, {
@@ -135,9 +142,14 @@ export class PublicProcessor {
             0,
           ...tx.getStats(),
         } satisfies TxSequencerProcessingStats);
-      } catch (err) {
-        const failedTx = await phase!.rollback(tx, err);
-        failed.push(failedTx);
+      } catch (err: any) {
+        const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+        this.log.warn(`Failed to process tx ${tx.getTxHash()}: ${errorMessage}`);
+
+        failed.push({
+          tx,
+          error: err instanceof Error ? err : new Error(errorMessage),
+        });
       }
     }
 

package/src/sequencer/sequencer.ts

@@ -180,7 +180,6 @@ export class Sequencer {
       this.log.info(`Building block ${newBlockNumber} with ${validTxs.length} transactions`);
       this.state = SequencerState.CREATING_BLOCK;
 
-      // Process txs and drop the ones that fail processing
       // We create a fresh processor each time to reset any cached state (eg storage writes)
       const processor = await this.publicProcessorFactory.create(historicalHeader, newGlobalVariables);
       const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() => processor.process(validTxs));
@@ -228,10 +227,6 @@ export class Sequencer {
 
       await assertBlockHeight();
 
-      await this.publishExtendedContractData(processedValidTxs, block);
-
-      await assertBlockHeight();
-
       await this.publishL2Block(block);
       this.log.info(`Submitted rollup block ${block.number} with ${processedValidTxs.length} transactions`);
     } catch (err) {
@@ -240,37 +235,6 @@ export class Sequencer {
     }
   }
 
-  /**
-   * Gets new extended contract data from the txs and publishes it on chain.
-   * @param validTxs - The set of real transactions being published as part of the block.
-   * @param block - The L2Block to be published.
-   */
-  protected async publishExtendedContractData(validTxs: ProcessedTx[], block: L2Block) {
-    // Publishes contract data for txs to the network and awaits the tx to be mined
-    this.state = SequencerState.PUBLISHING_CONTRACT_DATA;
-    const newContracts = validTxs.flatMap(tx => tx.newContracts).filter(cd => !cd.isEmpty());
-
-    if (newContracts.length === 0) {
-      this.log.debug(`No new contracts to publish in block ${block.number}`);
-      return;
-    }
-
-    const txsEffectsHash = block.body.getTxsEffectsHash();
-    this.log.info(`Publishing ${newContracts.length} contracts in block ${block.number}`);
-
-    const publishedContractData = await this.publisher.processNewContractData(
-      block.number,
-      txsEffectsHash,
-      newContracts,
-    );
-
-    if (publishedContractData) {
-      this.log(`Successfully published new contract data for block ${block.number}`);
-    } else if (!publishedContractData && newContracts.length) {
-      this.log(`Failed to publish new contract data for block ${block.number}`);
-    }
-  }
-
   /**
    * Publishes the L2Block to the rollup contract.
    * @param block - The L2Block to be published.

package/src/sequencer/setup_phase_manager.ts

@@ -27,34 +27,20 @@ export class SetupPhaseManager extends AbstractPhaseManager {
     super(db, publicExecutor, publicKernel, publicProver, globalVariables, historicalHeader, phase);
   }
 
-  // this is a no-op for now
-  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;
-  }> {
+  ) {
     this.log(`Processing tx ${tx.getTxHash()}`);
-    this.log(`Executing enqueued public calls for tx ${tx.getTxHash()}`);
-    const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs] = await this.processEnqueuedPublicCalls(
-      tx,
-      previousPublicKernelOutput,
-      previousPublicKernelProof,
-    );
+    const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs, revertReason] =
+      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof);
     tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
 
     // commit the state updates from this transaction
     await this.publicStateDB.commit();
 
-    return { publicKernelOutput, publicKernelProof };
+    return { publicKernelOutput, publicKernelProof, revertReason };
   }
 
   async rollback(tx: Tx, err: unknown): Promise<FailedTx> {

package/src/sequencer/tail_phase_manager.ts

@@ -0,0 +1,49 @@
+import { Tx } from '@aztec/circuit-types';
+import { GlobalVariables, Header, Proof, PublicKernelCircuitPublicInputs } from '@aztec/circuits.js';
+import { PublicExecutor, PublicStateDB } from '@aztec/simulator';
+import { MerkleTreeOperations } from '@aztec/world-state';
+
+import { PublicProver } from '../prover/index.js';
+import { PublicKernelCircuitSimulator } from '../simulator/index.js';
+import { ContractsDataSourcePublicDB } from '../simulator/public_executor.js';
+import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
+import { FailedTx } from './processed_tx.js';
+
+export class TailPhaseManager extends AbstractPhaseManager {
+  constructor(
+    protected db: MerkleTreeOperations,
+    protected publicExecutor: PublicExecutor,
+    protected publicKernel: PublicKernelCircuitSimulator,
+    protected publicProver: PublicProver,
+    protected globalVariables: GlobalVariables,
+    protected historicalHeader: Header,
+    protected publicContractsDB: ContractsDataSourcePublicDB,
+    protected publicStateDB: PublicStateDB,
+    public readonly phase: PublicKernelPhase = PublicKernelPhase.TAIL,
+  ) {
+    super(db, publicExecutor, publicKernel, publicProver, globalVariables, historicalHeader, phase);
+  }
+
+  async handle(tx: Tx, previousPublicKernelOutput: PublicKernelCircuitPublicInputs, previousPublicKernelProof: Proof) {
+    this.log(`Processing tx ${tx.getTxHash()}`);
+    this.log(`Executing tail circuit for tx ${tx.getTxHash()}`);
+    const [publicKernelOutput, publicKernelProof] = await this.runKernelCircuit(
+      previousPublicKernelOutput,
+      previousPublicKernelProof,
+    );
+
+    // commit the state updates from this transaction
+    await this.publicStateDB.commit();
+
+    return { publicKernelOutput, publicKernelProof, revertReason: undefined };
+  }
+
+  async rollback(tx: Tx, err: unknown): Promise<FailedTx> {
+    this.log.warn(`Error processing tx ${tx.getTxHash()}: ${err}`);
+    await this.publicStateDB.rollback();
+    return {
+      tx,
+      error: err instanceof Error ? err : new Error('Unknown error'),
+    };
+  }
+}

package/src/sequencer/teardown_phase_manager.ts

@@ -27,33 +27,20 @@ export class TeardownPhaseManager 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;
-  }> {
+  ) {
     this.log(`Processing tx ${tx.getTxHash()}`);
-    this.log(`Executing enqueued public calls for tx ${tx.getTxHash()}`);
-    const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs] = await this.processEnqueuedPublicCalls(
-      tx,
-      previousPublicKernelOutput,
-      previousPublicKernelProof,
-    );
+    const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs, revertReason] =
+      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof);
     tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
 
     // commit the state updates from this transaction
     await this.publicStateDB.commit();
 
-    return { publicKernelOutput, publicKernelProof };
+    return { publicKernelOutput, publicKernelProof, revertReason };
   }
 
   async rollback(tx: Tx, err: unknown): Promise<FailedTx> {

package/src/simulator/index.ts

@@ -4,6 +4,7 @@ import {
   MergeRollupInputs,
   PublicKernelCircuitPrivateInputs,
   PublicKernelCircuitPublicInputs,
+  PublicKernelTailCircuitPrivateInputs,
   RootRollupInputs,
   RootRollupPublicInputs,
 } from '@aztec/circuits.js';
@@ -54,5 +55,11 @@ export interface PublicKernelCircuitSimulator {
    * @returns The public inputs as outputs of the simulation.
    */
   publicKernelCircuitTeardown(inputs: PublicKernelCircuitPrivateInputs): Promise<PublicKernelCircuitPublicInputs>;
+  /**
+   * Simulates the public kernel tail circuit from its inputs.
+   * @param inputs - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  publicKernelCircuitTail(inputs: PublicKernelTailCircuitPrivateInputs): Promise<PublicKernelCircuitPublicInputs>;
 }
 export * from './acvm_wasm.js';

package/src/simulator/public_executor.ts

@@ -45,16 +45,6 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
    * @param tx - The transaction to add contracts from.
    */
   public addNewContracts(tx: Tx): Promise<void> {
-    for (const contract of tx.newContracts) {
-      const contractAddress = contract.contractData.contractAddress;
-
-      if (contractAddress.isZero()) {
-        continue;
-      }
-
-      this.cache.set(contractAddress.toString(), contract);
-    }
-
     // Extract contract class and instance data from logs and add to cache for this block
     const logs = tx.unencryptedLogs.unrollLogs().map(UnencryptedL2Log.fromBuffer);
     ContractClassRegisteredEvent.fromLogs(logs, ClassRegistererAddress).forEach(e => {
@@ -76,16 +66,6 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
    * @param tx - The tx's contracts to be removed
    */
   public removeNewContracts(tx: Tx): Promise<void> {
-    for (const contract of tx.newContracts) {
-      const contractAddress = contract.contractData.contractAddress;
-
-      if (contractAddress.isZero()) {
-        continue;
-      }
-
-      this.cache.delete(contractAddress.toString());
-    }
-
     // TODO(@spalladino): Can this inadvertently delete a valid contract added by another tx?
     // Let's say we have two txs adding the same contract on the same block. If the 2nd one reverts,
     // wouldn't that accidentally remove the contract added on the first one?

package/src/simulator/public_kernel.ts

@@ -1,17 +1,24 @@
 import { CircuitSimulationStats } from '@aztec/circuit-types/stats';
-import { PublicKernelCircuitPrivateInputs, PublicKernelCircuitPublicInputs } from '@aztec/circuits.js';
+import {
+  PublicKernelCircuitPrivateInputs,
+  PublicKernelCircuitPublicInputs,
+  PublicKernelTailCircuitPrivateInputs,
+} from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
 import {
   PublicKernelAppLogicArtifact,
   PublicKernelSetupArtifact,
+  PublicKernelTailArtifact,
   PublicKernelTeardownArtifact,
   convertPublicInnerRollupInputsToWitnessMap,
   convertPublicInnerRollupOutputFromWitnessMap,
   convertPublicSetupRollupInputsToWitnessMap,
   convertPublicSetupRollupOutputFromWitnessMap,
-  convertPublicTailRollupInputsToWitnessMap,
-  convertPublicTailRollupOutputFromWitnessMap,
+  convertPublicTailInputsToWitnessMap,
+  convertPublicTailOutputFromWitnessMap,
+  convertPublicTeardownRollupInputsToWitnessMap,
+  convertPublicTeardownRollupOutputFromWitnessMap,
 } from '@aztec/noir-protocol-circuits-types';
 
 import { PublicKernelCircuitSimulator, WASMSimulator } from './index.js';
@@ -91,11 +98,11 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
     if (!input.previousKernel.publicInputs.needsTeardown) {
       throw new Error(`Expected previous kernel inputs to need teardown`);
     }
-    const inputWitness = convertPublicTailRollupInputsToWitnessMap(input);
+    const inputWitness = convertPublicTeardownRollupInputsToWitnessMap(input);
     const [duration, witness] = await elapsed(() =>
       this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelTeardownArtifact),
     );
-    const result = convertPublicTailRollupOutputFromWitnessMap(witness);
+    const result = convertPublicTeardownRollupOutputFromWitnessMap(witness);
     this.log(`Simulated public kernel teardown circuit`, {
       eventName: 'circuit-simulation',
       circuitName: 'public-kernel-teardown',
@@ -105,4 +112,27 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
     } satisfies CircuitSimulationStats);
     return result;
   }
+
+  /**
+   * Simulates the public kernel tail circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  public async publicKernelCircuitTail(
+    input: PublicKernelTailCircuitPrivateInputs,
+  ): Promise<PublicKernelCircuitPublicInputs> {
+    const inputWitness = convertPublicTailInputsToWitnessMap(input);
+    const [duration, witness] = await elapsed(() =>
+      this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelTailArtifact),
+    );
+    const result = convertPublicTailOutputFromWitnessMap(witness);
+    this.log(`Simulated public kernel tail circuit`, {
+      eventName: 'circuit-simulation',
+      circuitName: 'public-kernel-tail',
+      duration,
+      inputSize: input.toBuffer().length,
+      outputSize: result.toBuffer().length,
+    } satisfies CircuitSimulationStats);
+    return result;
+  }
 }