@aztec/sequencer-client 0.0.0-test.1 → 0.0.1-commit.0b941701

package/src/client/sequencer-client.ts

@@ -1,43 +1,42 @@
-import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
+import type { BlobClientInterface } from '@aztec/blob-client/client';
 import { EpochCache } from '@aztec/epoch-cache';
-import {
-  ForwarderContract,
-  GovernanceProposerContract,
-  RollupContract,
-  SlashingProposerContract,
-  createEthereumChain,
-  createL1Clients,
-  isAnvilTestChain,
-} from '@aztec/ethereum';
+import { isAnvilTestChain } from '@aztec/ethereum/chain';
+import { getPublicClient } from '@aztec/ethereum/client';
+import { GovernanceProposerContract, RollupContract } from '@aztec/ethereum/contracts';
 import { L1TxUtilsWithBlobs } from '@aztec/ethereum/l1-tx-utils-with-blobs';
+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 { 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';
 
 /**
  * Encapsulates the full sequencer and publisher.
  */
 export class SequencerClient {
-  constructor(protected sequencer: Sequencer) {}
+  constructor(
+    protected publisherManager: PublisherManager<L1TxUtilsWithBlobs>,
+    protected sequencer: Sequencer,
+    protected checkpointsBuilder: FullNodeCheckpointsBuilder,
+    protected validatorClient?: ValidatorClient,
+    private l1Metrics?: L1Metrics,
+  ) {}
 
   /**
-   * 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 +45,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: L1TxUtilsWithBlobs[];
+      nodeKeyStore: KeystoreManager;
     },
   ) {
     const {
@@ -72,42 +71,33 @@ 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, config);
     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 +106,92 @@ 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;
+    const l1Constants = { l1GenesisTime, slotDuration: Number(slotDuration), ethereumSlotDuration };
+
+    const globalsBuilder = new GlobalVariableBuilder({ ...config, ...l1Constants, rollupVersion });
 
-    // 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.
+    let sequencerManaLimit = config.maxL2BlockGas ?? rollupManaLimit;
+    if (sequencerManaLimit > rollupManaLimit) {
+      log.warn(
+        `Provided maxL2BlockGas ${sequencerManaLimit} is greater than the max allowed by L1. Setting limit to ${rollupManaLimit}.`,
+      );
+      sequencerManaLimit = rollupManaLimit;
+    }
+
+    // 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 l1Constants = {
-      l1GenesisTime,
-      slotDuration: Number(slotDuration),
-      ethereumSlotDuration,
-    };
+    const l1PublishingTimeBasedOnChain = isAnvilTestChain(config.l1ChainId) ? 1 : ethereumSlotDuration;
+    const l1PublishingTime = config.l1PublishingTime ?? l1PublishingTimeBasedOnChain;
 
     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: sequencerManaLimit },
       telemetryClient,
+      log,
     );
-    await validatorClient?.start();
-    await sequencer.start();
-    return new SequencerClient(sequencer);
+
+    await sequencer.init();
+
+    return new SequencerClient(publisherManager, sequencer, checkpointsBuilder, validatorClient, l1Metrics);
   }
 
   /**
-   * 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 +199,20 @@ 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();
-  }
-
-  /**
-   * Restarts the sequencer after being stopped.
-   */
-  public restart() {
-    this.sequencer.restart();
-  }
-
-  get coinbase(): EthAddress {
-    return this.sequencer.coinbase;
+  public getSequencer(): Sequencer {
+    return this.sequencer;
   }
 
-  get feeRecipient(): AztecAddress {
-    return this.sequencer.feeRecipient;
+  get validatorAddresses(): EthAddress[] | undefined {
+    return this.sequencer.getValidatorAddresses();
   }
 
-  get forwarderAddress(): EthAddress {
-    return this.sequencer.getForwarderAddress();
+  get maxL2BlockGas(): number | undefined {
+    return this.sequencer.maxL2BlockGas;
   }
 }

package/src/config.ts

@@ -1,9 +1,5 @@
-import {
-  type L1ContractsConfig,
-  type L1ReaderConfig,
-  l1ContractsConfigMappings,
-  l1ReaderConfigMappings,
-} from '@aztec/ethereum';
+import { type L1ContractsConfig, l1ContractsConfigMappings } from '@aztec/ethereum/config';
+import { type L1ReaderConfig, l1ReaderConfigMappings } from '@aztec/ethereum/l1-reader';
 import {
   type ConfigMappingsType,
   booleanConfigHelper,
@@ -12,10 +8,12 @@ import {
   pickConfigMappings,
 } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
-import { FunctionSelector } from '@aztec/stdlib/abi';
+import { type KeyStoreConfig, keyStoreConfigMappings } from '@aztec/node-keystore/config';
+import { type P2PConfig, p2pConfigMappings } from '@aztec/p2p/config';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { type AllowedElement, type ChainConfig, type SequencerConfig, chainConfigMappings } from '@aztec/stdlib/config';
+import { type ChainConfig, type SequencerConfig, chainConfigMappings } from '@aztec/stdlib/config';
+import type { ResolvedSequencerConfig } from '@aztec/stdlib/interfaces/server';
+import { type ValidatorClientConfig, validatorClientConfigMappings } from '@aztec/validator-client/config';
 
 import {
   type PublisherConfig,
@@ -27,41 +25,81 @@ import {
 export * from './publisher/config.js';
 export type { SequencerConfig };
 
+export const DEFAULT_ATTESTATION_PROPAGATION_TIME = 2;
+
+/**
+ * Default values for SequencerConfig.
+ * Centralized location for all sequencer configuration defaults.
+ */
+export const DefaultSequencerConfig: ResolvedSequencerConfig = {
+  sequencerPollingIntervalMS: 500,
+  maxTxsPerBlock: 32,
+  minTxsPerBlock: 1,
+  buildCheckpointIfEmpty: false,
+  publishTxsWithProposals: false,
+  maxL2BlockGas: 10e9,
+  maxDABlockGas: 10e9,
+  maxBlockSizeInBytes: 1024 * 1024,
+  enforceTimeTable: true,
+  attestationPropagationTime: DEFAULT_ATTESTATION_PROPAGATION_TIME,
+  secondsBeforeInvalidatingBlockAsCommitteeMember: 144, // 12 L1 blocks
+  secondsBeforeInvalidatingBlockAsNonCommitteeMember: 432, // 36 L1 blocks
+  skipCollectingAttestations: false,
+  skipInvalidateBlockAsProposer: false,
+  broadcastInvalidBlockProposal: false,
+  injectFakeAttestation: false,
+  fishermanMode: false,
+  shuffleAttestationOrdering: false,
+  skipPushProposedBlocksToArchiver: false,
+};
+
 /**
  * Configuration settings for the SequencerClient.
  */
 export type SequencerClientConfig = PublisherConfig &
+  KeyStoreConfig &
+  ValidatorClientConfig &
   TxSenderConfig &
   SequencerConfig &
   L1ReaderConfig &
   ChainConfig &
+  Pick<P2PConfig, 'txPublicSetupAllowList'> &
   Pick<L1ContractsConfig, 'ethereumSlotDuration' | 'aztecSlotDuration' | 'aztecEpochDuration'>;
 
 export const sequencerConfigMappings: ConfigMappingsType<SequencerConfig> = {
-  transactionPollingIntervalMS: {
-    env: 'SEQ_TX_POLLING_INTERVAL_MS',
-    description: 'The number of ms to wait between polling for pending txs.',
-    ...numberConfigHelper(500),
+  sequencerPollingIntervalMS: {
+    env: 'SEQ_POLLING_INTERVAL_MS',
+    description: 'The number of ms to wait between polling for checking to build on the next slot.',
+    ...numberConfigHelper(DefaultSequencerConfig.sequencerPollingIntervalMS),
   },
   maxTxsPerBlock: {
     env: 'SEQ_MAX_TX_PER_BLOCK',
     description: 'The maximum number of txs to include in a block.',
-    ...numberConfigHelper(32),
+    ...numberConfigHelper(DefaultSequencerConfig.maxTxsPerBlock),
   },
   minTxsPerBlock: {
     env: 'SEQ_MIN_TX_PER_BLOCK',
     description: 'The minimum number of txs to include in a block.',
-    ...numberConfigHelper(1),
+    ...numberConfigHelper(DefaultSequencerConfig.minTxsPerBlock),
+  },
+  minValidTxsPerBlock: {
+    description:
+      'The minimum number of valid txs (after execution) to include in a block. If not set, falls back to minTxsPerBlock.',
+  },
+  publishTxsWithProposals: {
+    env: 'SEQ_PUBLISH_TXS_WITH_PROPOSALS',
+    description: 'Whether to publish txs with proposals.',
+    ...booleanConfigHelper(DefaultSequencerConfig.publishTxsWithProposals),
   },
   maxL2BlockGas: {
     env: 'SEQ_MAX_L2_BLOCK_GAS',
     description: 'The maximum L2 block gas.',
-    ...numberConfigHelper(10e9),
+    ...numberConfigHelper(DefaultSequencerConfig.maxL2BlockGas),
   },
   maxDABlockGas: {
     env: 'SEQ_MAX_DA_BLOCK_GAS',
     description: 'The maximum DA block gas.',
-    ...numberConfigHelper(10e9),
+    ...numberConfigHelper(DefaultSequencerConfig.maxDABlockGas),
   },
   coinbase: {
     env: 'COINBASE',
@@ -81,39 +119,101 @@ export const sequencerConfigMappings: ConfigMappingsType<SequencerConfig> = {
     env: 'ACVM_BINARY_PATH',
     description: 'The path to the ACVM binary',
   },
-  allowedInSetup: {
-    env: 'SEQ_ALLOWED_SETUP_FN',
-    parseEnv: (val: string) => parseSequencerAllowList(val),
-    description: 'The list of functions calls allowed to run in setup',
-    printDefault: () =>
-      'AuthRegistry, FeeJuice.increase_public_balance, Token.increase_public_balance, FPC.prepare_fee',
-  },
   maxBlockSizeInBytes: {
     env: 'SEQ_MAX_BLOCK_SIZE_IN_BYTES',
     description: 'Max block size',
-    ...numberConfigHelper(1024 * 1024),
+    ...numberConfigHelper(DefaultSequencerConfig.maxBlockSizeInBytes),
   },
   enforceTimeTable: {
     env: 'SEQ_ENFORCE_TIME_TABLE',
     description: 'Whether to enforce the time table when building blocks',
-    ...booleanConfigHelper(),
-    defaultValue: false,
+    ...booleanConfigHelper(DefaultSequencerConfig.enforceTimeTable),
   },
   governanceProposerPayload: {
     env: 'GOVERNANCE_PROPOSER_PAYLOAD_ADDRESS',
     description: 'The address of the payload for the governanceProposer',
     parseEnv: (val: string) => EthAddress.fromString(val),
-    defaultValue: EthAddress.ZERO,
   },
-  maxL1TxInclusionTimeIntoSlot: {
-    env: 'SEQ_MAX_L1_TX_INCLUSION_TIME_INTO_SLOT',
-    description: 'How many seconds into an L1 slot we can still send a tx and get it mined.',
+  l1PublishingTime: {
+    env: 'SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT',
+    description: 'How much time (in seconds) we allow in the slot for publishing the L1 tx (defaults to 1 L1 slot).',
+    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
+  },
+  attestationPropagationTime: {
+    env: 'SEQ_ATTESTATION_PROPAGATION_TIME',
+    description: 'How many seconds it takes for proposals and attestations to travel across the p2p layer (one-way)',
+    ...numberConfigHelper(DefaultSequencerConfig.attestationPropagationTime),
+  },
+  fakeProcessingDelayPerTxMs: {
+    description: 'Used for testing to introduce a fake delay after processing each tx',
+  },
+  fakeThrowAfterProcessingTxCount: {
+    description: 'Used for testing to throw an error after processing N txs',
+  },
+  secondsBeforeInvalidatingBlockAsCommitteeMember: {
+    env: 'SEQ_SECONDS_BEFORE_INVALIDATING_BLOCK_AS_COMMITTEE_MEMBER',
+    description:
+      'How many seconds to wait before trying to invalidate a block from the pending chain as a committee member (zero to never invalidate).' +
+      ' The next proposer is expected to invalidate, so the committee acts as a fallback.',
+    ...numberConfigHelper(DefaultSequencerConfig.secondsBeforeInvalidatingBlockAsCommitteeMember),
+  },
+  secondsBeforeInvalidatingBlockAsNonCommitteeMember: {
+    env: 'SEQ_SECONDS_BEFORE_INVALIDATING_BLOCK_AS_NON_COMMITTEE_MEMBER',
+    description:
+      'How many seconds to wait before trying to invalidate a block from the pending chain as a non-committee member (zero to never invalidate).' +
+      ' The next proposer is expected to invalidate, then the committee, so other sequencers act as a fallback.',
+    ...numberConfigHelper(DefaultSequencerConfig.secondsBeforeInvalidatingBlockAsNonCommitteeMember),
+  },
+  skipCollectingAttestations: {
+    description:
+      'Whether to skip collecting attestations from validators and only use self-attestations (for testing only)',
+    ...booleanConfigHelper(DefaultSequencerConfig.skipCollectingAttestations),
+  },
+  skipInvalidateBlockAsProposer: {
+    description: 'Do not invalidate the previous block if invalid when we are the proposer (for testing only)',
+    ...booleanConfigHelper(DefaultSequencerConfig.skipInvalidateBlockAsProposer),
+  },
+  broadcastInvalidBlockProposal: {
+    description: 'Broadcast invalid block proposals with corrupted state (for testing only)',
+    ...booleanConfigHelper(DefaultSequencerConfig.broadcastInvalidBlockProposal),
+  },
+  injectFakeAttestation: {
+    description: 'Inject a fake attestation (for testing only)',
+    ...booleanConfigHelper(DefaultSequencerConfig.injectFakeAttestation),
+  },
+  fishermanMode: {
+    env: 'FISHERMAN_MODE',
+    description:
+      'Whether to run in fisherman mode: builds blocks on every slot for validation without publishing to L1',
+    ...booleanConfigHelper(DefaultSequencerConfig.fishermanMode),
+  },
+  shuffleAttestationOrdering: {
+    description: 'Shuffle attestation ordering to create invalid ordering (for testing only)',
+    ...booleanConfigHelper(DefaultSequencerConfig.shuffleAttestationOrdering),
+  },
+  blockDurationMs: {
+    env: 'SEQ_BLOCK_DURATION_MS',
+    description:
+      'Duration per block in milliseconds when building multiple blocks per slot. ' +
+      'If undefined (default), builds a single block per slot using the full slot duration.',
     parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
   },
+  buildCheckpointIfEmpty: {
+    env: 'SEQ_BUILD_CHECKPOINT_IF_EMPTY',
+    description: 'Have sequencer build and publish an empty checkpoint if there are no txs',
+    ...booleanConfigHelper(DefaultSequencerConfig.buildCheckpointIfEmpty),
+  },
+  skipPushProposedBlocksToArchiver: {
+    description: 'Skip pushing proposed blocks to archiver (default: true)',
+    ...booleanConfigHelper(DefaultSequencerConfig.skipPushProposedBlocksToArchiver),
+  },
+  ...pickConfigMappings(p2pConfigMappings, ['txPublicSetupAllowList']),
 };
 
 export const sequencerClientConfigMappings: ConfigMappingsType<SequencerClientConfig> = {
+  ...validatorClientConfigMappings,
   ...sequencerConfigMappings,
+  ...keyStoreConfigMappings,
   ...l1ReaderConfigMappings,
   ...getTxSenderConfigMappings('SEQ'),
   ...getPublisherConfigMappings('SEQ'),
@@ -127,53 +227,3 @@ export const sequencerClientConfigMappings: ConfigMappingsType<SequencerClientCo
 export function getConfigEnvVars(): SequencerClientConfig {
   return getConfigFromMappings<SequencerClientConfig>(sequencerClientConfigMappings);
 }
-
-/**
- * Parses a string to a list of allowed elements.
- * Each encoded is expected to be of one of the following formats
- * `I:${address}`
- * `I:${address}:${selector}`
- * `C:${classId}`
- * `C:${classId}:${selector}`
- *
- * @param value The string to parse
- * @returns A list of allowed elements
- */
-export function parseSequencerAllowList(value: string): AllowedElement[] {
-  const entries: AllowedElement[] = [];
-
-  if (!value) {
-    return entries;
-  }
-
-  for (const val of value.split(',')) {
-    const [typeString, identifierString, selectorString] = val.split(':');
-    const selector = selectorString !== undefined ? FunctionSelector.fromString(selectorString) : undefined;
-
-    if (typeString === 'I') {
-      if (selector) {
-        entries.push({
-          address: AztecAddress.fromString(identifierString),
-          selector,
-        });
-      } else {
-        entries.push({
-          address: AztecAddress.fromString(identifierString),
-        });
-      }
-    } else if (typeString === 'C') {
-      if (selector) {
-        entries.push({
-          classId: Fr.fromHexString(identifierString),
-          selector,
-        });
-      } else {
-        entries.push({
-          classId: Fr.fromHexString(identifierString),
-        });
-      }
-    }
-  }
-
-  return entries;
-}