@aztec/sequencer-client 0.0.0-test.0 → 0.0.1-commit.001888fc

package/src/client/sequencer-client.ts

@@ -1,43 +1,49 @@
-import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
+import type { BlobClientInterface } from '@aztec/blob-client/client';
+import { MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT } from '@aztec/constants';
 import { EpochCache } from '@aztec/epoch-cache';
-import {
-  ForwarderContract,
-  GovernanceProposerContract,
-  RollupContract,
-  SlashingProposerContract,
-  createEthereumChain,
-  createL1Clients,
-  isAnvilTestChain,
-} from '@aztec/ethereum';
-import { L1TxUtilsWithBlobs } from '@aztec/ethereum/l1-tx-utils-with-blobs';
+import { isAnvilTestChain } from '@aztec/ethereum/chain';
+import { getPublicClient } from '@aztec/ethereum/client';
+import { GovernanceProposerContract, RollupContract } from '@aztec/ethereum/contracts';
+import { type Delayer, L1TxUtils } from '@aztec/ethereum/l1-tx-utils';
+import { PublisherManager } from '@aztec/ethereum/publisher-manager';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import type { DateProvider } from '@aztec/foundation/timer';
+import type { KeystoreManager } from '@aztec/node-keystore';
 import type { P2P } from '@aztec/p2p';
-import { LightweightBlockBuilderFactory } from '@aztec/prover-client/block-builder';
-import { PublicProcessorFactory } from '@aztec/simulator/server';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2BlockSource } from '@aztec/stdlib/block';
-import type { ContractDataSource } from '@aztec/stdlib/contract';
-import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import type { SlasherClientInterface } from '@aztec/slasher';
+import type { L2BlockSink, L2BlockSource } from '@aztec/stdlib/block';
+import type { ValidatorClientFullConfig, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
-import type { TelemetryClient } from '@aztec/telemetry-client';
-import type { ValidatorClient } from '@aztec/validator-client';
+import { L1Metrics, type TelemetryClient } from '@aztec/telemetry-client';
+import { FullNodeCheckpointsBuilder, NodeKeystoreAdapter, type ValidatorClient } from '@aztec/validator-client';
 
-import type { SequencerClientConfig } from '../config.js';
+import {
+  DefaultSequencerConfig,
+  type SequencerClientConfig,
+  getPublisherConfigFromSequencerConfig,
+} from '../config.js';
 import { GlobalVariableBuilder } from '../global_variable_builder/index.js';
-import { SequencerPublisher } from '../publisher/index.js';
+import { SequencerPublisherFactory } from '../publisher/sequencer-publisher-factory.js';
 import { Sequencer, type SequencerConfig } from '../sequencer/index.js';
-import type { SlasherClient } from '../slasher/index.js';
+import { SequencerTimetable } from '../sequencer/timetable.js';
 
 /**
  * Encapsulates the full sequencer and publisher.
  */
 export class SequencerClient {
-  constructor(protected sequencer: Sequencer) {}
+  constructor(
+    protected publisherManager: PublisherManager<L1TxUtils>,
+    protected sequencer: Sequencer,
+    protected checkpointsBuilder: FullNodeCheckpointsBuilder,
+    protected validatorClient?: ValidatorClient,
+    private l1Metrics?: L1Metrics,
+    private delayer_?: Delayer,
+  ) {}
 
   /**
-   * Initializes and starts a new instance.
+   * Initializes a new instance.
    * @param config - Configuration for the sequencer, publisher, and L1 tx sender.
    * @param p2pClient - P2P client that provides the txs to be sequenced.
    * @param validatorClient - Validator client performs attestation duties when rotating proposers.
@@ -46,25 +52,25 @@ export class SequencerClient {
    * @param l2BlockSource - Provides information about the previously published blocks.
    * @param l1ToL2MessageSource - Provides access to L1 to L2 messages.
    * @param prover - An instance of a block prover
-   * @param simulationProvider - An instance of a simulation provider
    * @returns A new running instance.
    */
   public static async new(
     config: SequencerClientConfig,
     deps: {
-      validatorClient: ValidatorClient | undefined; // allowed to be undefined while we migrate
+      validatorClient: ValidatorClient;
       p2pClient: P2P;
       worldStateSynchronizer: WorldStateSynchronizer;
-      slasherClient: SlasherClient;
-      contractDataSource: ContractDataSource;
-      l2BlockSource: L2BlockSource;
+      slasherClient: SlasherClientInterface | undefined;
+      checkpointsBuilder: FullNodeCheckpointsBuilder;
+      l2BlockSource: L2BlockSource & L2BlockSink;
       l1ToL2MessageSource: L1ToL2MessageSource;
       telemetry: TelemetryClient;
-      publisher?: SequencerPublisher;
-      blobSinkClient?: BlobSinkClientInterface;
+      publisherFactory?: SequencerPublisherFactory;
+      blobClient: BlobClientInterface;
       dateProvider: DateProvider;
       epochCache?: EpochCache;
-      l1TxUtils?: L1TxUtilsWithBlobs;
+      l1TxUtils: L1TxUtils[];
+      nodeKeyStore: KeystoreManager;
     },
   ) {
     const {
@@ -72,42 +78,37 @@ export class SequencerClient {
       p2pClient,
       worldStateSynchronizer,
       slasherClient,
-      contractDataSource,
+      checkpointsBuilder,
       l2BlockSource,
       l1ToL2MessageSource,
       telemetry: telemetryClient,
     } = deps;
-    const { l1RpcUrls: rpcUrls, l1ChainId: chainId, publisherPrivateKey } = config;
-    const chain = createEthereumChain(rpcUrls, chainId);
-    const log = createLogger('sequencer-client');
-    const { publicClient, walletClient } = createL1Clients(rpcUrls, publisherPrivateKey, chain.chainInfo);
-    const l1TxUtils = deps.l1TxUtils ?? new L1TxUtilsWithBlobs(publicClient, walletClient, log, config);
+    const { l1RpcUrls: rpcUrls, l1ChainId: chainId } = config;
+    const log = createLogger('sequencer');
+    const publicClient = getPublicClient(config);
+    const l1TxUtils = deps.l1TxUtils;
+    const l1Metrics = new L1Metrics(
+      telemetryClient.getMeter('L1PublisherMetrics'),
+      publicClient,
+      l1TxUtils.map(x => x.getSenderAddress()),
+    );
+    const publisherManager = new PublisherManager(
+      l1TxUtils,
+      getPublisherConfigFromSequencerConfig(config),
+      log.getBindings(),
+    );
     const rollupContract = new RollupContract(publicClient, config.l1Contracts.rollupAddress.toString());
-    const [l1GenesisTime, slotDuration] = await Promise.all([
+    const [l1GenesisTime, slotDuration, rollupVersion, rollupManaLimit] = await Promise.all([
       rollupContract.getL1GenesisTime(),
       rollupContract.getSlotDuration(),
+      rollupContract.getVersion(),
+      rollupContract.getManaLimit().then(Number),
     ] as const);
-    const forwarderContract =
-      config.customForwarderContractAddress && config.customForwarderContractAddress !== EthAddress.ZERO
-        ? new ForwarderContract(
-            publicClient,
-            config.customForwarderContractAddress.toString(),
-            config.l1Contracts.rollupAddress.toString(),
-          )
-        : await ForwarderContract.create(
-            walletClient.account.address,
-            walletClient,
-            publicClient,
-            log,
-            config.l1Contracts.rollupAddress.toString(),
-          );
 
     const governanceProposerContract = new GovernanceProposerContract(
       publicClient,
       config.l1Contracts.governanceProposerAddress.toString(),
     );
-    const slashingProposerAddress = await rollupContract.getSlashingProposerAddress();
-    const slashingProposerContract = new SlashingProposerContract(publicClient, slashingProposerAddress.toString());
     const epochCache =
       deps.epochCache ??
       (await EpochCache.create(
@@ -116,74 +117,101 @@ export class SequencerClient {
           l1RpcUrls: rpcUrls,
           l1ChainId: chainId,
           viemPollingIntervalMS: config.viemPollingIntervalMS,
-          aztecSlotDuration: config.aztecSlotDuration,
           ethereumSlotDuration: config.ethereumSlotDuration,
-          aztecEpochDuration: config.aztecEpochDuration,
         },
         { dateProvider: deps.dateProvider },
       ));
 
-    const publisher =
-      deps.publisher ??
-      new SequencerPublisher(config, {
-        l1TxUtils,
+    const slashFactoryContract = new SlashFactoryContract(
+      publicClient,
+      config.l1Contracts.slashFactoryAddress?.toString() ?? EthAddress.ZERO.toString(),
+    );
+
+    const publisherFactory =
+      deps.publisherFactory ??
+      new SequencerPublisherFactory(config, {
         telemetry: telemetryClient,
-        blobSinkClient: deps.blobSinkClient,
-        rollupContract,
+        blobClient: deps.blobClient,
         epochCache,
-        forwarderContract,
         governanceProposerContract,
-        slashingProposerContract,
+        slashFactoryContract,
+        rollupContract,
+        dateProvider: deps.dateProvider,
+        publisherManager,
+        nodeKeyStore: NodeKeystoreAdapter.fromKeyStoreManager(deps.nodeKeyStore),
+        logger: log,
       });
-    const globalsBuilder = new GlobalVariableBuilder(config);
-
-    const publicProcessorFactory = new PublicProcessorFactory(contractDataSource, deps.dateProvider, telemetryClient);
 
     const ethereumSlotDuration = config.ethereumSlotDuration;
 
-    // When running in anvil, assume we can post a tx up until the very last second of an L1 slot.
-    // Otherwise, assume we must have broadcasted the tx before the slot started (we use a default
-    // maxL1TxInclusionTimeIntoSlot of zero) to get the tx into that L1 slot.
-    // In theory, the L1 slot has an initial 4s phase where the block is propagated, so we could
-    // make it with a propagation time into slot equal to 4s. However, we prefer being conservative.
-    // See https://www.blocknative.com/blog/anatomy-of-a-slot#7 for more info.
-    const maxL1TxInclusionTimeIntoSlot =
-      config.maxL1TxInclusionTimeIntoSlot ?? isAnvilTestChain(config.l1ChainId) ? ethereumSlotDuration : 0;
-
-    const l1Constants = {
+    const globalsBuilder = new GlobalVariableBuilder({
+      ...config,
       l1GenesisTime,
       slotDuration: Number(slotDuration),
       ethereumSlotDuration,
-    };
+      rollupVersion,
+    });
+
+    // When running in anvil, assume we can post a tx up until one second before the end of an L1 slot.
+    // Otherwise, we need the full L1 slot duration for publishing to ensure inclusion.
+    // In theory, the L1 slot has an initial 4s phase where the block is propagated, so we could
+    // reduce the publishing time allowance. However, we prefer being conservative.
+    // See https://www.blocknative.com/blog/anatomy-of-a-slot#7 for more info.
+    const l1PublishingTimeBasedOnChain = isAnvilTestChain(config.l1ChainId) ? 1 : ethereumSlotDuration;
+    const l1PublishingTime = config.l1PublishingTime ?? l1PublishingTimeBasedOnChain;
+
+    const { maxL2BlockGas, maxDABlockGas, maxTxsPerBlock, maxBlocksPerCheckpoint } = computeBlockLimits(
+      config,
+      rollupManaLimit,
+      l1PublishingTime,
+      log,
+    );
+
+    const l1Constants = { l1GenesisTime, slotDuration: Number(slotDuration), ethereumSlotDuration, rollupManaLimit };
 
     const sequencer = new Sequencer(
-      publisher,
+      publisherFactory,
       validatorClient,
       globalsBuilder,
       p2pClient,
       worldStateSynchronizer,
       slasherClient,
-      new LightweightBlockBuilderFactory(telemetryClient),
       l2BlockSource,
       l1ToL2MessageSource,
-      publicProcessorFactory,
-      contractDataSource,
+      checkpointsBuilder,
       l1Constants,
       deps.dateProvider,
-      { ...config, maxL1TxInclusionTimeIntoSlot },
+      epochCache,
+      rollupContract,
+      { ...config, l1PublishingTime, maxL2BlockGas, maxDABlockGas, maxTxsPerBlock, maxBlocksPerCheckpoint },
       telemetryClient,
+      log,
     );
-    await validatorClient?.start();
-    await sequencer.start();
-    return new SequencerClient(sequencer);
+
+    sequencer.init();
+
+    // Extract the shared delayer from the first L1TxUtils instance (all instances share the same delayer)
+    const delayer = l1TxUtils[0]?.delayer;
+
+    return new SequencerClient(publisherManager, sequencer, checkpointsBuilder, validatorClient, l1Metrics, delayer);
   }
 
   /**
-   * Updates sequencer config.
+   * Updates sequencer and validator client config.
    * @param config - New parameters.
    */
-  public updateSequencerConfig(config: SequencerConfig) {
-    return this.sequencer.updateConfig(config);
+  public updateConfig(config: SequencerConfig & Partial<ValidatorClientFullConfig>) {
+    this.sequencer.updateConfig(config);
+    this.checkpointsBuilder.updateConfig(config);
+    this.validatorClient?.updateConfig(config);
+  }
+
+  /** Starts the sequencer. */
+  public async start() {
+    await this.validatorClient?.start();
+    this.sequencer.start();
+    this.l1Metrics?.start();
+    await this.publisherManager.loadState();
   }
 
   /**
@@ -191,29 +219,117 @@ export class SequencerClient {
    */
   public async stop() {
     await this.sequencer.stop();
+    await this.validatorClient?.stop();
+    this.publisherManager.interrupt();
+    this.l1Metrics?.stop();
   }
 
-  /** Forces the sequencer to bypass all time and tx count checks for the next block and build anyway. */
-  public flush() {
-    this.sequencer.flush();
+  public getSequencer(): Sequencer {
+    return this.sequencer;
   }
 
-  /**
-   * Restarts the sequencer after being stopped.
-   */
-  public restart() {
-    this.sequencer.restart();
+  /** Updates the publisher factory's node keystore adapter after a keystore reload. */
+  public updatePublisherNodeKeyStore(adapter: NodeKeystoreAdapter): void {
+    this.sequencer.updatePublisherNodeKeyStore(adapter);
+  }
+
+  /** Returns the shared tx delayer for sequencer L1 txs, if enabled. Test-only. */
+  getDelayer(): Delayer | undefined {
+    return this.delayer_;
+  }
+
+  get validatorAddresses(): EthAddress[] | undefined {
+    return this.sequencer.getValidatorAddresses();
   }
 
-  get coinbase(): EthAddress {
-    return this.sequencer.coinbase;
+  get maxL2BlockGas(): number | undefined {
+    return this.sequencer.maxL2BlockGas;
   }
+}
+
+/**
+ * Computes per-block L2 gas, DA gas, and TX count budgets based on the L1 rollup limits and the timetable.
+ * If the user explicitly set a limit, it is capped at the corresponding checkpoint limit.
+ * Otherwise, derives it as (checkpointLimit / maxBlocks) * multiplier, capped at the checkpoint limit.
+ */
+export function computeBlockLimits(
+  config: SequencerClientConfig,
+  rollupManaLimit: number,
+  l1PublishingTime: number,
+  log: ReturnType<typeof createLogger>,
+): { maxL2BlockGas: number; maxDABlockGas: number; maxTxsPerBlock: number; maxBlocksPerCheckpoint: number } {
+  const maxNumberOfBlocks = new SequencerTimetable({
+    ethereumSlotDuration: config.ethereumSlotDuration,
+    aztecSlotDuration: config.aztecSlotDuration,
+    l1PublishingTime,
+    p2pPropagationTime: config.attestationPropagationTime,
+    blockDurationMs: config.blockDurationMs,
+    enforce: config.enforceTimeTable ?? DefaultSequencerConfig.enforceTimeTable,
+  }).maxNumberOfBlocks;
+
+  const multiplier = config.perBlockAllocationMultiplier ?? DefaultSequencerConfig.perBlockAllocationMultiplier;
 
-  get feeRecipient(): AztecAddress {
-    return this.sequencer.feeRecipient;
+  // Compute maxL2BlockGas
+  let maxL2BlockGas: number;
+  if (config.maxL2BlockGas !== undefined) {
+    if (config.maxL2BlockGas > rollupManaLimit) {
+      log.warn(
+        `Provided MAX_L2_BLOCK_GAS ${config.maxL2BlockGas} exceeds L1 rollup mana limit ${rollupManaLimit} (capping)`,
+      );
+      maxL2BlockGas = rollupManaLimit;
+    } else {
+      maxL2BlockGas = config.maxL2BlockGas;
+    }
+  } else {
+    maxL2BlockGas = Math.min(rollupManaLimit, Math.ceil((rollupManaLimit / maxNumberOfBlocks) * multiplier));
   }
 
-  get forwarderAddress(): EthAddress {
-    return this.sequencer.getForwarderAddress();
+  // Compute maxDABlockGas
+  const daCheckpointLimit = MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT;
+  let maxDABlockGas: number;
+  if (config.maxDABlockGas !== undefined) {
+    if (config.maxDABlockGas > daCheckpointLimit) {
+      log.warn(
+        `Provided MAX_DA_BLOCK_GAS ${config.maxDABlockGas} exceeds DA checkpoint limit ${daCheckpointLimit} (capping)`,
+      );
+      maxDABlockGas = daCheckpointLimit;
+    } else {
+      maxDABlockGas = config.maxDABlockGas;
+    }
+  } else {
+    maxDABlockGas = Math.min(daCheckpointLimit, Math.ceil((daCheckpointLimit / maxNumberOfBlocks) * multiplier));
   }
+
+  // Compute maxTxsPerBlock
+  const defaultMaxTxsPerBlock = 32;
+  let maxTxsPerBlock: number;
+  if (config.maxTxsPerBlock !== undefined) {
+    if (config.maxTxsPerCheckpoint !== undefined && config.maxTxsPerBlock > config.maxTxsPerCheckpoint) {
+      log.warn(
+        `Provided MAX_TX_PER_BLOCK ${config.maxTxsPerBlock} exceeds MAX_TX_PER_CHECKPOINT ${config.maxTxsPerCheckpoint} (capping)`,
+      );
+      maxTxsPerBlock = config.maxTxsPerCheckpoint;
+    } else {
+      maxTxsPerBlock = config.maxTxsPerBlock;
+    }
+  } else if (config.maxTxsPerCheckpoint !== undefined) {
+    maxTxsPerBlock = Math.min(
+      config.maxTxsPerCheckpoint,
+      Math.ceil((config.maxTxsPerCheckpoint / maxNumberOfBlocks) * multiplier),
+    );
+  } else {
+    maxTxsPerBlock = defaultMaxTxsPerBlock;
+  }
+
+  log.info(`Computed block limits L2=${maxL2BlockGas} DA=${maxDABlockGas} maxTxs=${maxTxsPerBlock}`, {
+    maxL2BlockGas,
+    maxDABlockGas,
+    maxTxsPerBlock,
+    rollupManaLimit,
+    daCheckpointLimit,
+    maxNumberOfBlocks,
+    multiplier,
+  });
+
+  return { maxL2BlockGas, maxDABlockGas, maxTxsPerBlock, maxBlocksPerCheckpoint: maxNumberOfBlocks };
 }