@aztec/sequencer-client 3.0.0-nightly.20251221 → 3.0.0-nightly.20251223

package/src/publisher/sequencer-publisher.ts

@@ -1,6 +1,5 @@
-import { L2Block } from '@aztec/aztec.js/block';
+import { type BlobClientInterface, createBlobClient } from '@aztec/blob-client/client';
 import { Blob, getBlobsPerL1Block, getPrefixedEthBlobCommitments } from '@aztec/blob-lib';
-import { type BlobSinkClientInterface, createBlobSinkClient } from '@aztec/blob-sink/client';
 import type { EpochCache } from '@aztec/epoch-cache';
 import type { L1ContractsConfig } from '@aztec/ethereum/config';
 import {
@@ -27,6 +26,7 @@ import { FormattedViemError, formatViemError, tryExtractEvent } from '@aztec/eth
 import { sumBigint } from '@aztec/foundation/bigint';
 import { toHex as toPaddedHex } from '@aztec/foundation/bigint-buffer';
 import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { pick } from '@aztec/foundation/collection';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature, type ViemSignature } from '@aztec/foundation/eth-signature';
@@ -35,10 +35,11 @@ import { bufferToHex } from '@aztec/foundation/string';
 import { DateProvider, Timer } from '@aztec/foundation/timer';
 import { EmpireBaseAbi, ErrorsAbi, RollupAbi } from '@aztec/l1-artifacts';
 import { type ProposerSlashAction, encodeSlashConsensusVotes } from '@aztec/slasher';
-import { CommitteeAttestation, CommitteeAttestationsAndSigners, type ValidateBlockResult } from '@aztec/stdlib/block';
+import { CommitteeAttestationsAndSigners, type ValidateBlockResult } from '@aztec/stdlib/block';
+import type { Checkpoint } from '@aztec/stdlib/checkpoint';
 import { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
 import type { CheckpointHeader } from '@aztec/stdlib/rollup';
-import type { L1PublishBlockStats } from '@aztec/stdlib/stats';
+import type { L1PublishCheckpointStats } from '@aztec/stdlib/stats';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import { type StateOverride, type TransactionReceipt, type TypedDataDefinition, encodeFunctionData, toHex } from 'viem';
@@ -114,7 +115,7 @@ export class SequencerPublisher {
   protected log: Logger;
   protected ethereumSlotDuration: bigint;
 
-  private blobSinkClient: BlobSinkClientInterface;
+  private blobClient: BlobClientInterface;
 
   /** Address to use for simulations in fisherman mode (actual proposer's address) */
   private proposerAddressForSimulation?: EthAddress;
@@ -144,7 +145,7 @@ export class SequencerPublisher {
     private config: TxSenderConfig & PublisherConfig & Pick<L1ContractsConfig, 'ethereumSlotDuration'>,
     deps: {
       telemetry?: TelemetryClient;
-      blobSinkClient?: BlobSinkClientInterface;
+      blobClient?: BlobClientInterface;
       l1TxUtils: L1TxUtilsWithBlobs;
       rollupContract: RollupContract;
       slashingProposerContract: EmpireSlashingProposerContract | TallySlashingProposerContract | undefined;
@@ -162,8 +163,8 @@ export class SequencerPublisher {
     this.epochCache = deps.epochCache;
     this.lastActions = deps.lastActions;
 
-    this.blobSinkClient =
-      deps.blobSinkClient ?? createBlobSinkClient(config, { logger: createLogger('sequencer:blob-sink:client') });
+    this.blobClient =
+      deps.blobClient ?? createBlobClient(config, { logger: createLogger('sequencer:blob-client:client') });
 
     const telemetry = deps.telemetry ?? getTelemetryClient();
     this.metrics = deps.metrics ?? new SequencerPublisherMetrics(telemetry, 'SequencerPublisher');
@@ -241,7 +242,7 @@ export class SequencerPublisher {
    * @returns The analysis result (incomplete until block mines), or undefined if no requests
    */
   public async analyzeL1Fees(
-    l2SlotNumber: bigint,
+    l2SlotNumber: SlotNumber,
     onComplete?: (analysis: L1FeeAnalysisResult) => void,
   ): Promise<L1FeeAnalysisResult | undefined> {
     if (!this.l1FeeAnalyzer) {
@@ -299,7 +300,7 @@ export class SequencerPublisher {
   public async sendRequests() {
     const requestsToProcess = [...this.requests];
     this.requests = [];
-    if (this.interrupted) {
+    if (this.interrupted || requestsToProcess.length === 0) {
       return undefined;
     }
     const currentL2Slot = this.getCurrentL2Slot();
@@ -587,45 +588,38 @@ export class SequencerPublisher {
     }
   }
 
-  /**
-   * @notice  Will simulate `propose` to make sure that the block is valid for submission
-   *
-   * @dev     Throws if unable to propose
-   *
-   * @param block - The block to propose
-   * @param attestationData - The block's attestation data
-   *
-   */
-  public async validateBlockForSubmission(
-    block: L2Block,
+  /** Simulates `propose` to make sure that the checkpoint is valid for submission */
+  public async validateCheckpointForSubmission(
+    checkpoint: Checkpoint,
     attestationsAndSigners: CommitteeAttestationsAndSigners,
     attestationsAndSignersSignature: Signature,
-    options: { forcePendingBlockNumber?: BlockNumber },
+    options: { forcePendingBlockNumber?: BlockNumber }, // TODO(palla/mbps): Should this be forcePendingCheckpointNumber?
   ): Promise<bigint> {
     const ts = BigInt((await this.l1TxUtils.getBlock()).timestamp + this.ethereumSlotDuration);
 
+    // TODO(palla/mbps): This should not be needed, there's no flow where we propose with zero attestations. Or is there?
     // If we have no attestations, we still need to provide the empty attestations
     // so that the committee is recalculated correctly
-    const ignoreSignatures = attestationsAndSigners.attestations.length === 0;
-    if (ignoreSignatures) {
-      const { committee } = await this.epochCache.getCommittee(block.header.globalVariables.slotNumber);
-      if (!committee) {
-        this.log.warn(`No committee found for slot ${block.header.globalVariables.slotNumber}`);
-        throw new Error(`No committee found for slot ${block.header.globalVariables.slotNumber}`);
-      }
-      attestationsAndSigners.attestations = committee.map(committeeMember =>
-        CommitteeAttestation.fromAddress(committeeMember),
-      );
-    }
-
-    const blobFields = block.getCheckpointBlobFields();
+    // const ignoreSignatures = attestationsAndSigners.attestations.length === 0;
+    // if (ignoreSignatures) {
+    //   const { committee } = await this.epochCache.getCommittee(block.header.globalVariables.slotNumber);
+    //   if (!committee) {
+    //     this.log.warn(`No committee found for slot ${block.header.globalVariables.slotNumber}`);
+    //     throw new Error(`No committee found for slot ${block.header.globalVariables.slotNumber}`);
+    //   }
+    //   attestationsAndSigners.attestations = committee.map(committeeMember =>
+    //     CommitteeAttestation.fromAddress(committeeMember),
+    //   );
+    // }
+
+    const blobFields = checkpoint.toBlobFields();
     const blobs = getBlobsPerL1Block(blobFields);
     const blobInput = getPrefixedEthBlobCommitments(blobs);
 
     const args = [
       {
-        header: block.getCheckpointHeader().toViem(),
-        archive: toHex(block.archive.root.toBuffer()),
+        header: checkpoint.header.toViem(),
+        archive: toHex(checkpoint.archive.root.toBuffer()),
         oracleInput: {
           feeAssetPriceModifier: 0n,
         },
@@ -718,14 +712,14 @@ export class SequencerPublisher {
         const logData = { ...result, slotNumber, round, payload: payload.toString() };
         if (!success) {
           this.log.error(
-            `Signaling in [${action}] for ${payload} at slot ${slotNumber} in round ${round} failed`,
+            `Signaling in ${action} for ${payload} at slot ${slotNumber} in round ${round} failed`,
             logData,
           );
           this.lastActions[signalType] = cachedLastVote;
           return false;
         } else {
           this.log.info(
-            `Signaling in [${action}] for ${payload} at slot ${slotNumber} in round ${round} succeeded`,
+            `Signaling in ${action} for ${payload} at slot ${slotNumber} in round ${round} succeeded`,
             logData,
           );
           return true;
@@ -893,27 +887,21 @@ export class SequencerPublisher {
     return true;
   }
 
-  /**
-   * Proposes a L2 block on L1.
-   *
-   * @param block - L2 block to propose.
-   * @returns True if the tx has been enqueued, throws otherwise. See #9315
-   */
-  public async enqueueProposeL2Block(
-    block: L2Block,
+  /** Simulates and enqueues a proposal for a checkpoint on L1 */
+  public async enqueueProposeCheckpoint(
+    checkpoint: Checkpoint,
     attestationsAndSigners: CommitteeAttestationsAndSigners,
     attestationsAndSignersSignature: Signature,
     opts: { txTimeoutAt?: Date; forcePendingBlockNumber?: BlockNumber } = {},
-  ): Promise<boolean> {
-    const checkpointHeader = block.getCheckpointHeader();
+  ): Promise<void> {
+    const checkpointHeader = checkpoint.header;
 
-    const blobFields = block.getCheckpointBlobFields();
+    const blobFields = checkpoint.toBlobFields();
     const blobs = getBlobsPerL1Block(blobFields);
 
     const proposeTxArgs = {
       header: checkpointHeader,
-      archive: block.archive.root.toBuffer(),
-      body: block.body.toBuffer(),
+      archive: checkpoint.archive.root.toBuffer(),
       blobs,
       attestationsAndSigners,
       attestationsAndSignersSignature,
@@ -927,19 +915,23 @@ export class SequencerPublisher {
       //        By simulation issue, I mean the fact that the block.timestamp is equal to the last block, not the next, which
       //        make time consistency checks break.
       // TODO(palla): Check whether we're validating twice, once here and once within addProposeTx, since we call simulateProposeTx in both places.
-      ts = await this.validateBlockForSubmission(block, attestationsAndSigners, attestationsAndSignersSignature, opts);
+      ts = await this.validateCheckpointForSubmission(
+        checkpoint,
+        attestationsAndSigners,
+        attestationsAndSignersSignature,
+        opts,
+      );
     } catch (err: any) {
-      this.log.error(`Block validation failed. ${err instanceof Error ? err.message : 'No error message'}`, err, {
-        ...block.getStats(),
-        slotNumber: block.header.globalVariables.slotNumber,
+      this.log.error(`Checkpoint validation failed. ${err instanceof Error ? err.message : 'No error message'}`, err, {
+        ...checkpoint.getStats(),
+        slotNumber: checkpoint.header.slotNumber,
         forcePendingBlockNumber: opts.forcePendingBlockNumber,
       });
       throw err;
     }
 
-    this.log.verbose(`Enqueuing block propose transaction`, { ...block.toBlockInfo(), ...opts });
-    await this.addProposeTx(block, proposeTxArgs, opts, ts);
-    return true;
+    this.log.verbose(`Enqueuing checkpoint propose transaction`, { ...checkpoint.toCheckpointInfo(), ...opts });
+    await this.addProposeTx(checkpoint, proposeTxArgs, opts, ts);
   }
 
   public enqueueInvalidateBlock(request: InvalidateBlockRequest | undefined, opts: { txTimeoutAt?: Date } = {}) {
@@ -1204,11 +1196,12 @@ export class SequencerPublisher {
   }
 
   private async addProposeTx(
-    block: L2Block,
+    checkpoint: Checkpoint,
     encodedData: L1ProcessArgs,
     opts: { txTimeoutAt?: Date; forcePendingBlockNumber?: BlockNumber } = {},
     timestamp: bigint,
   ): Promise<void> {
+    const slot = checkpoint.header.slotNumber;
     const timer = new Timer();
     const kzg = Blob.getViemKzgInstance();
     const { rollupData, simulationResult, blobEvaluationGas } = await this.prepareProposeTx(
@@ -1223,11 +1216,11 @@ export class SequencerPublisher {
         SequencerPublisher.MULTICALL_OVERHEAD_GAS_GUESS, // We issue the simulation against the rollup contract, so we need to account for the overhead of the multicall3
     );
 
-    // Send the blobs to the blob sink preemptively. This helps in tests where the sequencer mistakingly thinks that the propose
-    // tx fails but it does get mined. We make sure that the blobs are sent to the blob sink regardless of the tx outcome.
+    // Send the blobs to the blob client preemptively. This helps in tests where the sequencer mistakingly thinks that the propose
+    // tx fails but it does get mined. We make sure that the blobs are sent to the blob client regardless of the tx outcome.
     void Promise.resolve().then(() =>
-      this.blobSinkClient.sendBlobsToBlobSink(encodedData.blobs).catch(_err => {
-        this.log.error('Failed to send blobs to blob sink');
+      this.blobClient.sendBlobsToFilestore(encodedData.blobs).catch(_err => {
+        this.log.error('Failed to send blobs to blob client');
       }),
     );
 
@@ -1237,7 +1230,7 @@ export class SequencerPublisher {
         to: this.rollupContract.address,
         data: rollupData,
       },
-      lastValidL2Slot: block.header.globalVariables.slotNumber,
+      lastValidL2Slot: checkpoint.header.slotNumber,
       gasConfig: { ...opts, gasLimit },
       blobConfig: {
         blobs: encodedData.blobs.map(b => b.data),
@@ -1252,11 +1245,12 @@ export class SequencerPublisher {
           receipt &&
           receipt.status === 'success' &&
           tryExtractEvent(receipt.logs, this.rollupContract.address, RollupAbi, 'CheckpointProposed');
+
         if (success) {
           const endBlock = receipt.blockNumber;
           const inclusionBlocks = Number(endBlock - startBlock);
           const { calldataGas, calldataSize, sender } = stats!;
-          const publishStats: L1PublishBlockStats = {
+          const publishStats: L1PublishCheckpointStats = {
             gasPrice: receipt.effectiveGasPrice,
             gasUsed: receipt.gasUsed,
             blobGasUsed: receipt.blobGasUsed ?? 0n,
@@ -1265,23 +1259,26 @@ export class SequencerPublisher {
             calldataGas,
             calldataSize,
             sender,
-            ...block.getStats(),
+            ...checkpoint.getStats(),
             eventName: 'rollup-published-to-l1',
             blobCount: encodedData.blobs.length,
             inclusionBlocks,
           };
-          this.log.info(`Published L2 block to L1 rollup contract`, { ...stats, ...block.getStats(), ...receipt });
+          this.log.info(`Published checkpoint ${checkpoint.number} at slot ${slot} to rollup contract`, {
+            ...stats,
+            ...checkpoint.getStats(),
+            ...pick(receipt, 'transactionHash', 'blockHash'),
+          });
           this.metrics.recordProcessBlockTx(timer.ms(), publishStats);
 
           return true;
         } else {
           this.metrics.recordFailedTx('process');
-          this.log.error(`Rollup process tx failed: ${errorMsg ?? 'no error message'}`, undefined, {
-            ...block.getStats(),
-            receipt,
-            txHash: receipt.transactionHash,
-            slotNumber: block.header.globalVariables.slotNumber,
-          });
+          this.log.error(
+            `Publishing checkpoint at slot ${slot} failed with ${errorMsg ?? 'no error message'}`,
+            undefined,
+            { ...checkpoint.getStats(), ...receipt },
+          );
           return false;
         }
       },

package/src/sequencer/block_builder.ts

@@ -33,7 +33,8 @@ import { createValidatorForBlockBuilding } from '../tx_validator/tx_validator_fa
 
 const log = createLogger('block-builder');
 
-export async function buildBlock(
+/** Builds a block out of pending txs */
+async function buildBlock(
   pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
   l1ToL2Messages: Fr[],
   newGlobalVariables: GlobalVariables,
@@ -97,8 +98,10 @@ const FullNodeBlockBuilderConfigKeys = [
   'rollupVersion',
   'txPublicSetupAllowList',
   'fakeProcessingDelayPerTxMs',
+  'fakeThrowAfterProcessingTxCount',
 ] as const;
 
+// TODO(palla/mbps): Try killing this in favor of the CheckpointsBuilder
 export class FullNodeBlockBuilder implements IFullNodeBlockBuilder {
   constructor(
     private config: FullNodeBlockBuilderConfig,

package/src/sequencer/checkpoint_builder.ts

@@ -0,0 +1,217 @@
+import { MerkleTreeId } from '@aztec/aztec.js/trees';
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { merge, pick } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+import { bufferToHex } from '@aztec/foundation/string';
+import { DateProvider, Timer, elapsed } from '@aztec/foundation/timer';
+import { getDefaultAllowedSetupFunctions } from '@aztec/p2p/msg_validators';
+import { LightweightCheckpointBuilder } from '@aztec/prover-client/light';
+import {
+  GuardedMerkleTreeOperations,
+  PublicContractsDB,
+  PublicProcessor,
+  createPublicTxSimulatorForBlockBuilding,
+} from '@aztec/simulator/server';
+import { L2BlockNew } from '@aztec/stdlib/block';
+import { Checkpoint } from '@aztec/stdlib/checkpoint';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import { Gas } from '@aztec/stdlib/gas';
+import {
+  type FullNodeBlockBuilderConfig,
+  FullNodeBlockBuilderConfigKeys,
+  type MerkleTreeWriteOperations,
+  type PublicProcessorLimits,
+} from '@aztec/stdlib/interfaces/server';
+import { type CheckpointGlobalVariables, type FailedTx, GlobalVariables, Tx } from '@aztec/stdlib/tx';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+
+import { createValidatorForBlockBuilding } from '../tx_validator/tx_validator_factory.js';
+
+const log = createLogger('checkpoint-builder');
+
+export interface BuildBlockInCheckpointResult {
+  block: L2BlockNew;
+  publicGas: Gas;
+  publicProcessorDuration: number;
+  numTxs: number;
+  failedTxs: FailedTx[];
+  blockBuildingTimer: Timer;
+  usedTxs: Tx[];
+}
+
+/**
+ * Builder for a single checkpoint. Handles building blocks within the checkpoint
+ * and completing it.
+ */
+export class CheckpointBuilder {
+  constructor(
+    private checkpointBuilder: LightweightCheckpointBuilder,
+    private fork: MerkleTreeWriteOperations,
+    private config: FullNodeBlockBuilderConfig,
+    private contractDataSource: ContractDataSource,
+    private dateProvider: DateProvider,
+    private telemetryClient: TelemetryClient,
+  ) {}
+
+  getConstantData(): CheckpointGlobalVariables {
+    return this.checkpointBuilder.constants;
+  }
+
+  /**
+   * Builds a single block within this checkpoint.
+   */
+  async buildBlock(
+    pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
+    blockNumber: BlockNumber,
+    timestamp: bigint,
+    opts: PublicProcessorLimits,
+  ): Promise<BuildBlockInCheckpointResult> {
+    const blockBuildingTimer = new Timer();
+    const slot = this.checkpointBuilder.constants.slotNumber;
+
+    log.verbose(`Building block ${blockNumber} for slot ${slot} within checkpoint`, { slot, blockNumber, ...opts });
+
+    const constants = this.checkpointBuilder.constants;
+    const globalVariables = GlobalVariables.from({
+      chainId: constants.chainId,
+      version: constants.version,
+      blockNumber,
+      slotNumber: constants.slotNumber,
+      timestamp,
+      coinbase: constants.coinbase,
+      feeRecipient: constants.feeRecipient,
+      gasFees: constants.gasFees,
+    });
+    const { processor, validator } = await this.makeBlockBuilderDeps(globalVariables, this.fork);
+
+    const [publicProcessorDuration, [processedTxs, failedTxs, usedTxs]] = await elapsed(() =>
+      processor.process(pendingTxs, opts, validator),
+    );
+
+    // Add block to checkpoint
+    const block = await this.checkpointBuilder.addBlock(globalVariables, processedTxs);
+
+    // How much public gas was processed
+    const publicGas = processedTxs.reduce((acc, tx) => acc.add(tx.gasUsed.publicGas), Gas.empty());
+
+    const res = {
+      block,
+      publicGas,
+      publicProcessorDuration,
+      numTxs: processedTxs.length,
+      failedTxs,
+      blockBuildingTimer,
+      usedTxs,
+    };
+    log.debug('Built block within checkpoint', res.block.header);
+    return res;
+  }
+
+  /** Completes the checkpoint and returns it. */
+  async completeCheckpoint(): Promise<Checkpoint> {
+    const checkpoint = await this.checkpointBuilder.completeCheckpoint();
+
+    log.verbose(`Completed checkpoint ${checkpoint.number}`, {
+      checkpointNumber: checkpoint.number,
+      numBlocks: checkpoint.blocks.length,
+      archiveRoot: checkpoint.archive.root.toString(),
+    });
+
+    return checkpoint;
+  }
+
+  /** Gets the checkpoint currently in progress. */
+  getCheckpoint(): Promise<Checkpoint> {
+    return this.checkpointBuilder.clone().completeCheckpoint();
+  }
+
+  protected async makeBlockBuilderDeps(globalVariables: GlobalVariables, fork: MerkleTreeWriteOperations) {
+    const txPublicSetupAllowList = this.config.txPublicSetupAllowList ?? (await getDefaultAllowedSetupFunctions());
+    const contractsDB = new PublicContractsDB(this.contractDataSource);
+    const guardedFork = new GuardedMerkleTreeOperations(fork);
+
+    const publicTxSimulator = createPublicTxSimulatorForBlockBuilding(
+      guardedFork,
+      contractsDB,
+      globalVariables,
+      this.telemetryClient,
+    );
+
+    const processor = new PublicProcessor(
+      globalVariables,
+      guardedFork,
+      contractsDB,
+      publicTxSimulator,
+      this.dateProvider,
+      this.telemetryClient,
+      undefined,
+      this.config,
+    );
+
+    const validator = createValidatorForBlockBuilding(
+      fork,
+      this.contractDataSource,
+      globalVariables,
+      txPublicSetupAllowList,
+    );
+
+    return {
+      processor,
+      validator,
+    };
+  }
+}
+
+/**
+ * Factory for creating checkpoint builders.
+ */
+export class FullNodeCheckpointsBuilder {
+  constructor(
+    private config: FullNodeBlockBuilderConfig,
+    private contractDataSource: ContractDataSource,
+    private dateProvider: DateProvider,
+    private telemetryClient: TelemetryClient = getTelemetryClient(),
+  ) {}
+
+  public updateConfig(config: Partial<FullNodeBlockBuilderConfig>) {
+    this.config = merge(this.config, pick(config, ...FullNodeBlockBuilderConfigKeys));
+  }
+
+  /**
+   * Starts a new checkpoint and returns a CheckpointBuilder to build blocks within it.
+   */
+  async startCheckpoint(
+    checkpointNumber: CheckpointNumber,
+    constants: CheckpointGlobalVariables,
+    l1ToL2Messages: Fr[],
+    fork: MerkleTreeWriteOperations,
+  ): Promise<CheckpointBuilder> {
+    const stateReference = await fork.getStateReference();
+    const archiveTree = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
+
+    log.verbose(`Building checkpoint ${checkpointNumber}`, {
+      checkpointNumber,
+      msgCount: l1ToL2Messages.length,
+      initialStateReference: stateReference.toInspect(),
+      initialArchiveRoot: bufferToHex(archiveTree.root),
+      constants,
+    });
+
+    const lightweightBuilder = await LightweightCheckpointBuilder.startNewCheckpoint(
+      checkpointNumber,
+      constants,
+      l1ToL2Messages,
+      fork,
+    );
+
+    return new CheckpointBuilder(
+      lightweightBuilder,
+      fork,
+      this.config,
+      this.contractDataSource,
+      this.dateProvider,
+      this.telemetryClient,
+    );
+  }
+}