@aztec/sequencer-client 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/client/sequencer-client.ts

@@ -1,43 +1,43 @@
-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, ProposedCheckpointSink } from '@aztec/stdlib/block';
+import type { ValidatorClientFullConfig, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 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 { GlobalVariableBuilder } from '../global_variable_builder/index.js';
-import { SequencerPublisher } from '../publisher/index.js';
+import { type SequencerClientConfig, getPublisherConfigFromSequencerConfig } from '../config.js';
+import type { GlobalVariableBuilder } from '../global_variable_builder/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';
 
 /**
  * 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 +46,27 @@ 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 & ProposedCheckpointSink;
       l1ToL2MessageSource: L1ToL2MessageSource;
       telemetry: TelemetryClient;
-      publisher?: SequencerPublisher;
-      blobSinkClient?: BlobSinkClientInterface;
+      publisherFactory?: SequencerPublisherFactory;
+      blobClient: BlobClientInterface;
       dateProvider: DateProvider;
       epochCache?: EpochCache;
-      l1TxUtils?: L1TxUtilsWithBlobs;
+      l1TxUtils: L1TxUtils[];
+      funderL1TxUtils?: L1TxUtils;
+      nodeKeyStore: KeystoreManager;
+      globalVariableBuilder: GlobalVariableBuilder;
     },
   ) {
     const {
@@ -72,118 +74,127 @@ 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 rollupContract = new RollupContract(publicClient, config.l1Contracts.rollupAddress.toString());
-    const [l1GenesisTime, slotDuration] = await Promise.all([
+    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), {
+      bindings: log.getBindings(),
+      funder: deps.funderL1TxUtils,
+    });
+    const rollupContract = new RollupContract(publicClient, config.rollupAddress.toString());
+    const [l1GenesisTime, slotDuration, rollupManaLimit] = await Promise.all([
       rollupContract.getL1GenesisTime(),
       rollupContract.getSlotDuration(),
+      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(),
+      config.governanceProposerAddress.toString(),
     );
-    const slashingProposerAddress = await rollupContract.getSlashingProposerAddress();
-    const slashingProposerContract = new SlashingProposerContract(publicClient, slashingProposerAddress.toString());
     const epochCache =
       deps.epochCache ??
       (await EpochCache.create(
-        config.l1Contracts.rollupAddress,
+        config.rollupAddress,
         {
           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 publisherFactory =
+      deps.publisherFactory ??
+      new SequencerPublisherFactory(config, {
         telemetry: telemetryClient,
-        blobSinkClient: deps.blobSinkClient,
-        rollupContract,
+        blobClient: deps.blobClient,
         epochCache,
-        forwarderContract,
         governanceProposerContract,
-        slashingProposerContract,
+        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.
+    const globalsBuilder = deps.globalVariableBuilder;
+
+    // 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
-    // make it with a propagation time into slot equal to 4s. However, we prefer being conservative.
+    // 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 maxL1TxInclusionTimeIntoSlot =
-      config.maxL1TxInclusionTimeIntoSlot ?? isAnvilTestChain(config.l1ChainId) ? ethereumSlotDuration : 0;
+    const l1PublishingTimeBasedOnChain = isAnvilTestChain(config.l1ChainId) ? 1 : ethereumSlotDuration;
+    const l1PublishingTime = config.l1PublishingTime ?? l1PublishingTimeBasedOnChain;
+
+    const { maxL2BlockGas, maxDABlockGas, maxTxsPerBlock } = capPerBlockLimits(config, rollupManaLimit, log);
 
     const l1Constants = {
       l1GenesisTime,
       slotDuration: Number(slotDuration),
       ethereumSlotDuration,
+      rollupManaLimit,
+      epochDuration: config.aztecEpochDuration,
     };
 
     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 },
       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.start();
   }
 
   /**
@@ -191,29 +202,73 @@ export class SequencerClient {
    */
   public async stop() {
     await this.sequencer.stop();
+    await this.validatorClient?.stop();
+    await this.publisherManager.stop();
+    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();
+  /** Triggers an immediate run of the sequencer, bypassing the polling interval. */
+  public trigger() {
+    return this.sequencer.trigger();
   }
 
-  /**
-   * Restarts the sequencer after being stopped.
-   */
-  public restart() {
-    this.sequencer.restart();
+  public getSequencer(): Sequencer {
+    return this.sequencer;
   }
 
-  get coinbase(): EthAddress {
-    return this.sequencer.coinbase;
+  /** Updates the publisher factory's node keystore adapter after a keystore reload. */
+  public updatePublisherNodeKeyStore(adapter: NodeKeystoreAdapter): void {
+    this.sequencer.updatePublisherNodeKeyStore(adapter);
   }
 
-  get feeRecipient(): AztecAddress {
-    return this.sequencer.feeRecipient;
+  /** Returns the shared tx delayer for sequencer L1 txs, if enabled. Test-only. */
+  getDelayer(): Delayer | undefined {
+    return this.delayer_;
   }
 
-  get forwarderAddress(): EthAddress {
-    return this.sequencer.getForwarderAddress();
+  get validatorAddresses(): EthAddress[] | undefined {
+    return this.sequencer.getValidatorAddresses();
   }
+
+  get maxL2BlockGas(): number | undefined {
+    return this.sequencer.maxL2BlockGas;
+  }
+}
+
+/**
+ * Caps operator-provided per-block limits at checkpoint-level limits.
+ * Returns undefined for any limit the operator didn't set — the checkpoint builder handles redistribution.
+ */
+function capPerBlockLimits(
+  config: SequencerClientConfig,
+  rollupManaLimit: number,
+  log: ReturnType<typeof createLogger>,
+): { maxL2BlockGas: number | undefined; maxDABlockGas: number | undefined; maxTxsPerBlock: number | undefined } {
+  let maxL2BlockGas = config.maxL2BlockGas;
+  if (maxL2BlockGas !== undefined && maxL2BlockGas > rollupManaLimit) {
+    log.warn(`Provided MAX_L2_BLOCK_GAS ${maxL2BlockGas} exceeds rollup mana limit ${rollupManaLimit} (capping)`);
+    maxL2BlockGas = rollupManaLimit;
+  }
+
+  let maxDABlockGas = config.maxDABlockGas;
+  if (maxDABlockGas !== undefined && maxDABlockGas > MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT) {
+    log.warn(
+      `Provided MAX_DA_BLOCK_GAS ${maxDABlockGas} exceeds DA checkpoint limit ${MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT} (capping)`,
+    );
+    maxDABlockGas = MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT;
+  }
+
+  let maxTxsPerBlock = config.maxTxsPerBlock;
+  if (
+    maxTxsPerBlock !== undefined &&
+    config.maxTxsPerCheckpoint !== undefined &&
+    maxTxsPerBlock > config.maxTxsPerCheckpoint
+  ) {
+    log.warn(
+      `Provided MAX_TX_PER_BLOCK ${maxTxsPerBlock} exceeds MAX_TX_PER_CHECKPOINT ${config.maxTxsPerCheckpoint} (capping)`,
+    );
+    maxTxsPerBlock = config.maxTxsPerCheckpoint;
+  }
+
+  return { maxL2BlockGas, maxDABlockGas, maxTxsPerBlock };
 }