@aztec/sequencer-client 0.69.0 → 0.69.1

package/src/sequencer/sequencer.ts

@@ -4,11 +4,9 @@ import {
   type L1ToL2MessageSource,
   type L2Block,
   type L2BlockSource,
-  type ProcessedTx,
   SequencerConfigSchema,
   Tx,
   type TxHash,
-  type TxValidator,
   type WorldStateSynchronizer,
 } from '@aztec/circuit-types';
 import type { AllowedElement, Signature, WorldStateSynchronizerStatus } from '@aztec/circuit-types/interfaces';
@@ -17,7 +15,9 @@ import {
   AppendOnlyTreeSnapshot,
   BlockHeader,
   ContentCommitment,
+  type ContractDataSource,
   GENESIS_ARCHIVE_ROOT,
+  Gas,
   type GlobalVariables,
   StateReference,
 } from '@aztec/circuits.js';
@@ -36,9 +36,10 @@ import { Attributes, type TelemetryClient, type Tracer, trackSpan } from '@aztec
 import { type ValidatorClient } from '@aztec/validator-client';
 
 import { type GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
-import { type L1Publisher } from '../publisher/l1-publisher.js';
+import { type L1Publisher, VoteType } from '../publisher/l1-publisher.js';
 import { prettyLogViemErrorMsg } from '../publisher/utils.js';
-import { type TxValidatorFactory } from '../tx_validator/tx_validator_factory.js';
+import { type SlasherClient } from '../slasher/slasher_client.js';
+import { createValidatorsForBlockBuilding } from '../tx_validator/tx_validator_factory.js';
 import { getDefaultAllowedSetupFunctions } from './allowed.js';
 import { type SequencerConfig } from './config.js';
 import { SequencerMetrics } from './metrics.js';
@@ -46,12 +47,6 @@ import { SequencerState, orderAttestations } from './utils.js';
 
 export { SequencerState };
 
-export type ShouldProposeArgs = {
-  pendingTxsCount?: number;
-  validTxsCount?: number;
-  processedTxsCount?: number;
-};
-
 export class SequencerTooSlowError extends Error {
   constructor(
     public readonly currentState: SequencerState,
@@ -89,6 +84,7 @@ export class Sequencer {
   private state = SequencerState.STOPPED;
   private allowedInSetup: AllowedElement[] = getDefaultAllowedSetupFunctions();
   private maxBlockSizeInBytes: number = 1024 * 1024;
+  private maxBlockGas: Gas = new Gas(10e9, 10e9);
   private processTxTime: number = 12;
   private metrics: SequencerMetrics;
   private isFlushing: boolean = false;
@@ -106,11 +102,12 @@ export class Sequencer {
     private globalsBuilder: GlobalVariableBuilder,
     private p2pClient: P2P,
     private worldState: WorldStateSynchronizer,
+    private slasherClient: SlasherClient,
     private blockBuilderFactory: BlockBuilderFactory,
     private l2BlockSource: L2BlockSource,
     private l1ToL2MessageSource: L1ToL2MessageSource,
     private publicProcessorFactory: PublicProcessorFactory,
-    private txValidatorFactory: TxValidatorFactory,
+    private contractDataSource: ContractDataSource,
     protected l1Constants: SequencerRollupConstants,
     private dateProvider: DateProvider,
     telemetry: TelemetryClient,
@@ -122,6 +119,9 @@ export class Sequencer {
 
     // Register the block builder with the validator client for re-execution
     this.validatorClient?.registerBlockBuilder(this.buildBlock.bind(this));
+
+    // Register the slasher on the publisher to fetch slashing payloads
+    this.publisher.registerSlashPayloadGetter(this.slasherClient.getSlashPayload.bind(this.slasherClient));
   }
 
   get tracer(): Tracer {
@@ -144,6 +144,12 @@ export class Sequencer {
     if (config.minTxsPerBlock !== undefined) {
       this.minTxsPerBLock = config.minTxsPerBlock;
     }
+    if (config.maxDABlockGas !== undefined) {
+      this.maxBlockGas = new Gas(config.maxDABlockGas, this.maxBlockGas.l2Gas);
+    }
+    if (config.maxL2BlockGas !== undefined) {
+      this.maxBlockGas = new Gas(this.maxBlockGas.daGas, config.maxL2BlockGas);
+    }
     if (config.coinbase) {
       this._coinbase = config.coinbase;
     }
@@ -157,7 +163,7 @@ export class Sequencer {
       this.maxBlockSizeInBytes = config.maxBlockSizeInBytes;
     }
     if (config.governanceProposerPayload) {
-      this.publisher.setPayload(config.governanceProposerPayload);
+      this.publisher.setGovernancePayload(config.governanceProposerPayload);
     }
     if (config.maxL1TxInclusionTimeIntoSlot !== undefined) {
       this.maxL1TxInclusionTimeIntoSlot = config.maxL1TxInclusionTimeIntoSlot;
@@ -174,7 +180,7 @@ export class Sequencer {
     // How late into the slot can we be to start working
     const initialTime = 2;
 
-    // How long it takes to validate the txs collected and get ready to start building
+    // How long it takes to get ready to start building
     const blockPrepareTime = 1;
 
     // How long it takes to for attestations to travel across the p2p layer.
@@ -213,9 +219,9 @@ export class Sequencer {
       [SequencerState.SYNCHRONIZING]: this.aztecSlotDuration,
       // We always want to allow the full slot to check if we are the proposer
       [SequencerState.PROPOSER_CHECK]: this.aztecSlotDuration,
-      // First transition towards building a block
-      [SequencerState.WAITING_FOR_TXS]: initialTime,
-      // We then validate the txs and prepare to start building the block
+      // How late we can start initializing a new block proposal
+      [SequencerState.INITIALIZING_PROPOSAL]: initialTime,
+      // When we start building a block
       [SequencerState.CREATING_BLOCK]: initialTime + blockPrepareTime,
       // We start collecting attestations after building the block
       [SequencerState.COLLECTING_ATTESTATIONS]: initialTime + blockPrepareTime + processTxsTime + blockValidationTime,
@@ -245,6 +251,7 @@ export class Sequencer {
     this.log.debug(`Stopping sequencer`);
     await this.validatorClient?.stop();
     await this.runningPromise?.stop();
+    await this.slasherClient?.stop();
     this.publisher.interrupt();
     this.setState(SequencerState.STOPPED, 0n, true /** force */);
     this.log.info('Stopped sequencer');
@@ -314,27 +321,30 @@ export class Sequencer {
       slot,
     );
 
-    void this.publisher.castVote(slot, newGlobalVariables.timestamp.toBigInt());
+    void this.publisher.castVote(slot, newGlobalVariables.timestamp.toBigInt(), VoteType.GOVERNANCE);
+    void this.publisher.castVote(slot, newGlobalVariables.timestamp.toBigInt(), VoteType.SLASHING);
 
-    if (!this.shouldProposeBlock(historicalHeader, {})) {
+    // Check the pool has enough txs to build a block
+    const pendingTxCount = this.p2pClient.getPendingTxCount();
+    if (pendingTxCount < this.minTxsPerBLock && !this.isFlushing) {
+      this.log.verbose(`Not enough txs to propose block. Got ${pendingTxCount} min ${this.minTxsPerBLock}.`, {
+        slot,
+        blockNumber: newBlockNumber,
+      });
+      await this.claimEpochProofRightIfAvailable(slot);
       return;
     }
 
+    this.setState(SequencerState.INITIALIZING_PROPOSAL, slot);
     this.log.verbose(`Preparing proposal for block ${newBlockNumber} at slot ${slot}`, {
       chainTipArchive: new Fr(chainTipArchive),
       blockNumber: newBlockNumber,
       slot,
     });
 
-    this.setState(SequencerState.WAITING_FOR_TXS, slot);
-
-    // Get txs to build the new block.
-    const pendingTxs = await this.p2pClient.getPendingTxs();
-
-    if (!this.shouldProposeBlock(historicalHeader, { pendingTxsCount: pendingTxs.length })) {
-      await this.claimEpochProofRightIfAvailable(slot);
-      return;
-    }
+    // We don't fetch exactly maxTxsPerBlock txs here because we may not need all of them if we hit a limit before,
+    // and also we may need to fetch more if we don't have enough valid txs.
+    const pendingTxs = this.p2pClient.iteratePendingTxs();
 
     // If I created a "partial" header here that should make our job much easier.
     const proposalHeader = new BlockHeader(
@@ -346,35 +356,12 @@ export class Sequencer {
       Fr.ZERO,
     );
 
-    // TODO: It should be responsibility of the P2P layer to validate txs before passing them on here.
-    // TODO: We should validate only the number of txs we need to speed up this process.
-    const allValidTxs = await this.takeValidTxs(
-      pendingTxs,
-      this.txValidatorFactory.validatorForNewTxs(newGlobalVariables, this.allowedInSetup),
-    );
-
-    // TODO: We are taking the size of the tx from private-land, but we should be doing this after running
-    // public functions. Only reason why we do it here now is because the public processor and orchestrator
-    // are set up such that they require knowing the total number of txs in advance. Still, main reason for
-    // exceeding max block size in bytes is contract class registration, which happens in private-land. This
-    // may break if we start emitting lots of log data from public-land.
-    const validTxs = this.takeTxsWithinMaxSize(allValidTxs);
-
-    this.log.verbose(
-      `Collected ${validTxs.length} txs out of ${allValidTxs.length} valid txs out of ${pendingTxs.length} total pending txs for block ${newBlockNumber}`,
-    );
-
-    // Bail if we don't have enough valid txs
-    if (!this.shouldProposeBlock(historicalHeader, { validTxsCount: validTxs.length })) {
-      await this.claimEpochProofRightIfAvailable(slot);
-      return;
-    }
-
     try {
+      // TODO(palla/txs) Is the note below still valid? We don't seem to be doing any rollback in there.
       // @note  It is very important that the following function will FAIL and not just return early
       //        if it have made any state changes. If not, we won't rollback the state, and you will
       //        be in for a world of pain.
-      await this.buildBlockAndAttemptToPublish(validTxs, proposalHeader, historicalHeader);
+      await this.buildBlockAndAttemptToPublish(pendingTxs, proposalHeader, historicalHeader);
     } catch (err) {
       this.log.error(`Error assembling block`, err, { blockNumber: newBlockNumber, slot });
     }
@@ -462,64 +449,20 @@ export class Sequencer {
     this.state = proposedState;
   }
 
-  shouldProposeBlock(historicalHeader: BlockHeader | undefined, args: ShouldProposeArgs): boolean {
-    if (this.isFlushing) {
-      this.log.verbose(`Flushing all pending txs in new block`);
-      return true;
-    }
-
-    // Compute time elapsed since the previous block
-    const lastBlockTime = historicalHeader?.globalVariables.timestamp.toNumber() || 0;
-    const currentTime = Math.floor(Date.now() / 1000);
-    const elapsedSinceLastBlock = currentTime - lastBlockTime;
-    this.log.debug(
-      `Last block mined at ${lastBlockTime} current time is ${currentTime} (elapsed ${elapsedSinceLastBlock})`,
-    );
-
-    // We need to have at least minTxsPerBLock txs.
-    if (args.pendingTxsCount !== undefined && args.pendingTxsCount < this.minTxsPerBLock) {
-      this.log.verbose(
-        `Not creating block because not enough txs in the pool (got ${args.pendingTxsCount} min ${this.minTxsPerBLock})`,
-      );
-      return false;
-    }
-
-    // Bail if we don't have enough valid txs
-    if (args.validTxsCount !== undefined && args.validTxsCount < this.minTxsPerBLock) {
-      this.log.verbose(
-        `Not creating block because not enough valid txs loaded from the pool (got ${args.validTxsCount} min ${this.minTxsPerBLock})`,
-      );
-      return false;
-    }
-
-    // TODO: This check should be processedTxs.length < this.minTxsPerBLock, so we don't publish a block with
-    // less txs than the minimum. But that'd cause the entire block to be aborted and retried. Instead, we should
-    // go back to the p2p pool and load more txs until we hit our minTxsPerBLock target. Only if there are no txs
-    // we should bail.
-    if (args.processedTxsCount === 0 && this.minTxsPerBLock > 0) {
-      this.log.verbose('No txs processed correctly to build block.');
-      return false;
-    }
-
-    return true;
-  }
-
   /**
    * Build a block
    *
    * Shared between the sequencer and the validator for re-execution
    *
-   * @param validTxs - The valid transactions to construct the block from
+   * @param pendingTxs - The pending transactions to construct the block from
    * @param newGlobalVariables - The global variables for the new block
    * @param historicalHeader - The historical header of the parent
-   * @param interrupt - The interrupt callback, used to validate the block for submission and check if we should propose the block
    * @param opts - Whether to just validate the block as a validator, as opposed to building it as a proposal
    */
   private async buildBlock(
-    validTxs: Tx[],
+    pendingTxs: Iterable<Tx>,
     newGlobalVariables: GlobalVariables,
     historicalHeader?: BlockHeader,
-    interrupt?: (processedTxs: ProcessedTx[]) => Promise<void>,
     opts: { validateOnly?: boolean } = {},
   ) {
     const blockNumber = newGlobalVariables.blockNumber.toBigInt();
@@ -527,19 +470,9 @@ export class Sequencer {
 
     this.log.debug(`Requesting L1 to L2 messages from contract for block ${blockNumber}`);
     const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockNumber);
+    const msgCount = l1ToL2Messages.length;
 
-    this.log.verbose(
-      `Building block ${blockNumber} with ${validTxs.length} txs and ${l1ToL2Messages.length} messages`,
-      {
-        msgCount: l1ToL2Messages.length,
-        txCount: validTxs.length,
-        slot,
-        blockNumber,
-      },
-    );
-
-    const numRealTxs = validTxs.length;
-    const blockSize = Math.max(2, numRealTxs);
+    this.log.verbose(`Building block ${blockNumber} for slot ${slot}`, { slot, blockNumber, msgCount });
 
     // Sync to the previous block at least
     await this.worldState.syncImmediate(newGlobalVariables.blockNumber.toNumber() - 1);
@@ -563,18 +496,30 @@ export class Sequencer {
       // We set the deadline for tx processing to the start of the CREATING_BLOCK phase, plus the expected time for tx processing.
       // Deadline is only set if enforceTimeTable is enabled.
       const processingEndTimeWithinSlot = this.timeTable[SequencerState.CREATING_BLOCK] + this.processTxTime;
-      const processingDeadline = this.enforceTimeTable
+      const deadline = this.enforceTimeTable
         ? new Date((this.getSlotStartTimestamp(slot) + processingEndTimeWithinSlot) * 1000)
         : undefined;
-      this.log.verbose(`Processing ${validTxs.length} txs`, {
+      this.log.verbose(`Processing pending txs`, {
         slot,
         slotStart: new Date(this.getSlotStartTimestamp(slot) * 1000),
         now: new Date(this.dateProvider.now()),
-        deadline: processingDeadline,
+        deadline,
       });
-      const processingTxValidator = this.txValidatorFactory.validatorForProcessedTxs(publicProcessorFork);
+
+      const validators = createValidatorsForBlockBuilding(
+        publicProcessorFork,
+        this.contractDataSource,
+        newGlobalVariables,
+        !!this.config.enforceFees,
+        this.allowedInSetup,
+      );
+
+      // REFACTOR: Public processor should just handle processing, one tx at a time. It should be responsibility
+      // of the sequencer to update world state and iterate over txs. We should refactor this along with unifying the
+      // publicProcessorFork and orchestratorFork, to avoid doing tree insertions twice when building the block.
+      const limits = { deadline, maxTransactions: this.maxTxsPerBlock, maxBlockSize: this.maxBlockSizeInBytes };
       const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() =>
-        processor.process(validTxs, blockSize, processingTxValidator, processingDeadline),
+        processor.process(pendingTxs, limits, validators),
       );
 
       if (failedTxs.length > 0) {
@@ -602,8 +547,6 @@ export class Sequencer {
       const duration = Number(end - start) / 1_000;
       this.metrics.recordBlockBuilderTreeInsertions(duration);
 
-      await interrupt?.(processedTxs);
-
       // All real transactions have been added, set the block as full and pad if needed
       const block = await blockBuilder.setBlockCompleted();
 
@@ -611,7 +554,7 @@ export class Sequencer {
         block,
         publicProcessorDuration,
         numMsgs: l1ToL2Messages.length,
-        numProcessedTxs: processedTxs.length,
+        numTxs: processedTxs.length,
         blockBuildingTimer,
       };
     } finally {
@@ -635,7 +578,7 @@ export class Sequencer {
    * @dev     MUST throw instead of exiting early to ensure that world-state
    *          is being rolled back if the block is dropped.
    *
-   * @param validTxs - The valid transactions to construct the block from
+   * @param pendingTxs - Iterable of pending transactions to construct the block from
    * @param proposalHeader - The partial header constructed for the proposal
    * @param historicalHeader - The historical header of the parent
    */
@@ -643,7 +586,7 @@ export class Sequencer {
     [Attributes.BLOCK_NUMBER]: proposalHeader.globalVariables.blockNumber.toNumber(),
   }))
   private async buildBlockAndAttemptToPublish(
-    validTxs: Tx[],
+    pendingTxs: Iterable<Tx>,
     proposalHeader: BlockHeader,
     historicalHeader: BlockHeader | undefined,
   ): Promise<void> {
@@ -653,40 +596,19 @@ export class Sequencer {
     const blockNumber = newGlobalVariables.blockNumber.toNumber();
     const slot = newGlobalVariables.slotNumber.toBigInt();
 
-    this.metrics.recordNewBlock(blockNumber, validTxs.length);
+    // this.metrics.recordNewBlock(blockNumber, validTxs.length);
     const workTimer = new Timer();
     this.setState(SequencerState.CREATING_BLOCK, slot);
 
-    /**
-     * BuildBlock is shared between the sequencer and the validator for re-execution
-     * We use the interrupt callback to validate the block for submission and check if we should propose the block
-     *
-     * If we fail, we throw an error in order to roll back
-     */
-    const interrupt = async (processedTxs: ProcessedTx[]) => {
-      await this.publisher.validateBlockForSubmission(proposalHeader);
-
-      if (
-        !this.shouldProposeBlock(historicalHeader, {
-          validTxsCount: validTxs.length,
-          processedTxsCount: processedTxs.length,
-        })
-      ) {
-        // TODO: Roll back changes to world state
-        throw new Error('Should not propose the block');
-      }
-    };
-
     // Start collecting proof quotes for the previous epoch if needed in the background
     const proofQuotePromise = this.createProofClaimForPreviousEpoch(slot);
 
     try {
-      const buildBlockRes = await this.buildBlock(validTxs, newGlobalVariables, historicalHeader, interrupt);
-      const { block, publicProcessorDuration, numProcessedTxs, numMsgs, blockBuildingTimer } = buildBlockRes;
+      const buildBlockRes = await this.buildBlock(pendingTxs, newGlobalVariables, historicalHeader);
+      const { block, publicProcessorDuration, numTxs, numMsgs, blockBuildingTimer } = buildBlockRes;
 
       // TODO(@PhilWindle) We should probably periodically check for things like another
       // block being published before ours instead of just waiting on our block
-
       await this.publisher.validateBlockForSubmission(block.header);
 
       const workDuration = workTimer.ms();
@@ -700,8 +622,8 @@ export class Sequencer {
       };
 
       const blockHash = block.hash();
-      const txHashes = validTxs.map(tx => tx.getTxHash());
-      this.log.info(`Built block ${block.number} with hash ${blockHash}`, {
+      const txHashes = block.body.txEffects.map(tx => tx.txHash);
+      this.log.info(`Built block ${block.number} for slot ${slot} with ${numTxs} txs`, {
         blockHash,
         globalVariables: block.header.globalVariables.toInspect(),
         txHashes,
@@ -727,14 +649,12 @@ export class Sequencer {
       await this.publishL2Block(block, attestations, txHashes, proofQuote);
       this.metrics.recordPublishedBlock(workDuration);
       this.log.info(
-        `Published rollup block ${
-          block.number
-        } with ${numProcessedTxs} transactions and ${numMsgs} messages in ${Math.ceil(workDuration)}ms`,
+        `Published block ${block.number} with ${numTxs} txs and ${numMsgs} messages in ${Math.ceil(workDuration)}ms`,
         {
           blockNumber: block.number,
           blockHash: blockHash,
           slot,
-          txCount: numProcessedTxs,
+          txCount: txHashes.length,
           msgCount: numMsgs,
           duration: Math.ceil(workDuration),
           submitter: this.publisher.getSenderAddress().toString(),
@@ -858,36 +778,6 @@ export class Sequencer {
     }
   }
 
-  protected async takeValidTxs<T extends Tx | ProcessedTx>(txs: T[], validator: TxValidator<T>): Promise<T[]> {
-    const [valid, invalid] = await validator.validateTxs(txs);
-    if (invalid.length > 0) {
-      this.log.debug(`Dropping invalid txs from the p2p pool ${Tx.getHashes(invalid).join(', ')}`);
-      await this.p2pClient.deleteTxs(Tx.getHashes(invalid));
-    }
-
-    return valid.slice(0, this.maxTxsPerBlock);
-  }
-
-  protected takeTxsWithinMaxSize(txs: Tx[]): Tx[] {
-    const maxSize = this.maxBlockSizeInBytes;
-    let totalSize = 0;
-
-    const toReturn: Tx[] = [];
-    for (const tx of txs) {
-      const txSize = tx.getSize() - tx.clientIvcProof.clientIvcProofBuffer.length;
-      if (totalSize + txSize > maxSize) {
-        this.log.debug(
-          `Dropping tx ${tx.getTxHash()} with estimated size ${txSize} due to exceeding ${maxSize} block size limit (currently at ${totalSize})`,
-        );
-        continue;
-      }
-      toReturn.push(tx);
-      totalSize += txSize;
-    }
-
-    return toReturn;
-  }
-
   @trackSpan(
     'Sequencer.claimEpochProofRightIfAvailable',
     slotNumber => ({ [Attributes.SLOT_NUMBER]: Number(slotNumber) }),

package/src/sequencer/utils.ts

@@ -19,9 +19,9 @@ export enum SequencerState {
    */
   PROPOSER_CHECK = 'PROPOSER_CHECK',
   /**
-   * Polling the P2P module for txs to include in a block. Will move to CREATING_BLOCK if there are valid txs to include, or back to SYNCHRONIZING otherwise.
+   * Initializing the block proposal. Will move to CREATING_BLOCK if there are valid txs to include, or back to SYNCHRONIZING otherwise.
    */
-  WAITING_FOR_TXS = 'WAITING_FOR_TXS',
+  INITIALIZING_PROPOSAL = 'INITIALIZING_PROPOSAL',
   /**
    * Creating a new L2 block. Includes processing public function calls and running rollup circuits. Will move to PUBLISHING_CONTRACT_DATA.
    */

package/src/slasher/factory.ts

@@ -0,0 +1,22 @@
+import type { L2BlockSource } from '@aztec/circuit-types';
+import { type L1ContractsConfig, type L1ReaderConfig } from '@aztec/ethereum';
+import { createLogger } from '@aztec/foundation/log';
+import { type AztecKVStore } from '@aztec/kv-store';
+import { type DataStoreConfig } from '@aztec/kv-store/config';
+import { createStore } from '@aztec/kv-store/lmdb';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
+
+import { SlasherClient } from './slasher_client.js';
+import { type SlasherConfig } from './slasher_client.js';
+
+export const createSlasherClient = async (
+  _config: SlasherConfig & DataStoreConfig & L1ContractsConfig & L1ReaderConfig,
+  l2BlockSource: L2BlockSource,
+  telemetry: TelemetryClient = new NoopTelemetryClient(),
+  deps: { store?: AztecKVStore } = {},
+) => {
+  const config = { ..._config };
+  const store = deps.store ?? (await createStore('slasher', config, createLogger('slasher:lmdb')));
+  return new SlasherClient(config, store, l2BlockSource, telemetry);
+};

package/src/slasher/index.ts

@@ -0,0 +1,2 @@
+export * from './slasher_client.js';
+export { createSlasherClient } from './factory.js';