@aztec-labs/sequencer-client 6.0.0-nightly.20260829

package/dest/test/utils.js

@@ -0,0 +1,121 @@
+import { CheckpointNumber, IndexWithinCheckpoint } from '@aztec-labs/foundation/branded-types';
+import { times } from '@aztec-labs/foundation/collection';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { Signature } from '@aztec-labs/foundation/eth-signature';
+import { PublicDataWrite } from '@aztec-labs/stdlib/avm';
+import { Body, CommitteeAttestation, L2Block } from '@aztec-labs/stdlib/block';
+import { DEFAULT_BLOCK_DURATION_MS } from '@aztec-labs/stdlib/config';
+import { BlockProposal, CheckpointAttestation, CheckpointProposal, ConsensusPayload } from '@aztec-labs/stdlib/p2p';
+import { CheckpointHeader } from '@aztec-labs/stdlib/rollup';
+import { TEST_COORDINATION_SIGNATURE_CONTEXT, makeAppendOnlyTreeSnapshot, mockTxForRollup } from '@aztec-labs/stdlib/testing';
+import { DEFAULT_CHECKPOINT_PROPOSAL_INIT_TIME, DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME, DEFAULT_MIN_BLOCK_DURATION, DEFAULT_P2P_PROPAGATION_TIME, ProposerTimetable } from '@aztec-labs/stdlib/timetable';
+import { BlockHeader, makeProcessedTxFromPrivateOnlyTx } from '@aztec-labs/stdlib/tx';
+// Re-export mock classes from their dedicated file
+export { MockCheckpointBuilder, MockCheckpointsBuilder } from './mock_checkpoint_builder.js';
+/**
+ * Builds a {@link ProposerTimetable} for tests from a millisecond block duration and optional budgets,
+ * filling unset budgets with the shared `DEFAULT_*` values the sequencer config layer applies. Mirrors how
+ * the sequencer constructs its timetable so tests exercise the same budget resolution.
+ */ export function makeProposerTimetable(opts) {
+    return new ProposerTimetable({
+        l1Constants: opts.l1Constants,
+        blockDuration: (opts.blockDurationMs ?? DEFAULT_BLOCK_DURATION_MS) / 1000,
+        minBlockDuration: opts.minBlockDuration ?? DEFAULT_MIN_BLOCK_DURATION,
+        p2pPropagationTime: opts.p2pPropagationTime ?? DEFAULT_P2P_PROPAGATION_TIME,
+        checkpointProposalPrepareTime: opts.checkpointProposalPrepareTime ?? DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME,
+        checkpointProposalInitTime: DEFAULT_CHECKPOINT_PROPOSAL_INIT_TIME
+    });
+}
+/**
+ * Creates a mock transaction with a specific seed for deterministic testing
+ */ export async function makeTx(seed, chainId) {
+    const tx = await mockTxForRollup(seed);
+    if (chainId) {
+        tx.data.constants.txContext.chainId = chainId;
+    }
+    return tx;
+}
+/**
+ * Creates an L2Block from transactions and global variables
+ */ export async function makeBlock(txs, globalVariables) {
+    const processedTxs = await Promise.all(txs.map((tx)=>makeProcessedTxFromPrivateOnlyTx(tx, Fr.ZERO, new PublicDataWrite(Fr.random(), Fr.random()), globalVariables)));
+    const body = new Body(processedTxs.map((tx)=>tx.txEffect));
+    const header = BlockHeader.empty({
+        globalVariables
+    });
+    const archive = makeAppendOnlyTreeSnapshot(globalVariables.blockNumber + 1);
+    return new L2Block(archive, header, body, CheckpointNumber.fromBlockNumber(globalVariables.blockNumber), IndexWithinCheckpoint(0));
+}
+/**
+ * Mocks the P2P client to return specific pending transactions
+ */ export function mockPendingTxs(p2p, txs) {
+    p2p.getPendingTxCount.mockResolvedValue(txs.length);
+    p2p.hasEligiblePendingTxs.mockImplementation((minCount)=>Promise.resolve(txs.length >= minCount));
+    p2p.iteratePendingTxs.mockImplementation(()=>mockTxIterator(Promise.resolve(txs)));
+    p2p.iterateEligiblePendingTxs.mockImplementation(()=>mockTxIterator(Promise.resolve(txs)));
+}
+/**
+ * Creates an async iterator for transactions
+ */ export async function* mockTxIterator(txs) {
+    for (const tx of (await txs)){
+        yield tx;
+    }
+}
+/**
+ * Creates mock committee attestations from a signer
+ */ export function createMockSignatures(signer) {
+    const mockedSig = Signature.random();
+    return [
+        new CommitteeAttestation(signer.address, mockedSig)
+    ];
+}
+/**
+ * Creates a CheckpointHeader from an L2Block for testing purposes.
+ * Uses mock values for blockHeadersHash and blobsHash since L2Block doesn't have these fields.
+ */ function createCheckpointHeaderFromBlock(block) {
+    const gv = block.header.globalVariables;
+    return new CheckpointHeader(block.header.lastArchive.root, Fr.random(), Fr.random(), Fr.random(), Fr.random(), gv.slotNumber, gv.timestamp, gv.coinbase, gv.feeRecipient, gv.gasFees, block.header.totalManaUsed, block.header.totalFees);
+}
+/**
+ * Creates a block proposal from a block and signature
+ */ export function createBlockProposal(block, signature) {
+    const txHashes = block.body.txEffects.map((tx)=>tx.txHash);
+    return new BlockProposal(block.header, block.indexWithinCheckpoint, block.archive.root, txHashes, signature, TEST_COORDINATION_SIGNATURE_CONTEXT);
+}
+/**
+ * Creates a checkpoint proposal from a block and signature
+ */ export function createCheckpointProposal(block, checkpointSignature, blockSignature, feeAssetPriceModifier = 0n) {
+    const txHashes = block.body.txEffects.map((tx)=>tx.txHash);
+    const checkpointHeader = createCheckpointHeaderFromBlock(block);
+    return new CheckpointProposal(checkpointHeader, block.archive.root, feeAssetPriceModifier, checkpointSignature, TEST_COORDINATION_SIGNATURE_CONTEXT, {
+        blockHeader: block.header,
+        indexWithinCheckpoint: block.indexWithinCheckpoint,
+        txHashes,
+        signature: blockSignature ?? checkpointSignature
+    });
+}
+/**
+ * Creates a checkpoint attestation from a block and signature.
+ * Note: We manually set the sender since we use random signatures in tests.
+ * In production, the sender is recovered from the signature.
+ */ export function createCheckpointAttestation(block, signature, sender, feeAssetPriceModifier = 0n) {
+    const checkpointHeader = createCheckpointHeaderFromBlock(block);
+    const payload = new ConsensusPayload(checkpointHeader, block.archive.root, feeAssetPriceModifier, TEST_COORDINATION_SIGNATURE_CONTEXT);
+    const attestation = new CheckpointAttestation(payload, signature, signature);
+    // Bypass signature recovery for testing since we use random signatures
+    attestation.getSender = ()=>sender;
+    attestation.getProposer = ()=>sender;
+    return attestation;
+}
+/**
+ * Creates transactions and a block, and mocks P2P to return them.
+ * Helper for tests that need to set up a block with transactions.
+ */ export async function setupTxsAndBlock(p2p, globalVariables, txCount, chainId) {
+    const txs = await Promise.all(times(txCount, (i)=>makeTx(i + 1, chainId)));
+    const block = await makeBlock(txs, globalVariables);
+    mockPendingTxs(p2p, txs);
+    return {
+        txs,
+        block
+    };
+}

package/package.json

@@ -0,0 +1,118 @@
+{
+  "name": "@aztec-labs/sequencer-client",
+  "version": "6.0.0-nightly.20260829",
+  "type": "module",
+  "exports": {
+    ".": "./dest/index.js",
+    "./automine": "./dest/sequencer/automine/index.js",
+    "./config": "./dest/config.js",
+    "./test": "./dest/test/index.js"
+  },
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/index.ts"
+    ],
+    "name": "Sequencer Client",
+    "tsconfig": "./tsconfig.json"
+  },
+  "inherits": [
+    "../package.common.json"
+  ],
+  "scripts": {
+    "build": "yarn clean && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}",
+    "test:integration": "concurrently -k -s first -c reset,dim -n test,anvil \"yarn test:integration:run\" \"anvil\"",
+    "test:integration:run": "NODE_NO_WARNINGS=1 node --experimental-vm-modules $(yarn bin jest) --no-cache --config jest.integration.config.json"
+  },
+  "dependencies": {
+    "@aztec-labs/archiver": "6.0.0-nightly.20260829",
+    "@aztec-labs/blob-client": "6.0.0-nightly.20260829",
+    "@aztec-labs/blob-lib": "6.0.0-nightly.20260829",
+    "@aztec-labs/constants": "6.0.0-nightly.20260829",
+    "@aztec-labs/epoch-cache": "6.0.0-nightly.20260829",
+    "@aztec-labs/ethereum": "6.0.0-nightly.20260829",
+    "@aztec-labs/foundation": "6.0.0-nightly.20260829",
+    "@aztec-labs/node-keystore": "6.0.0-nightly.20260829",
+    "@aztec-labs/p2p": "6.0.0-nightly.20260829",
+    "@aztec-labs/prover-client": "6.0.0-nightly.20260829",
+    "@aztec-labs/simulator": "6.0.0-nightly.20260829",
+    "@aztec-labs/slasher": "6.0.0-nightly.20260829",
+    "@aztec-labs/stdlib": "6.0.0-nightly.20260829",
+    "@aztec-labs/telemetry-client": "6.0.0-nightly.20260829",
+    "@aztec-labs/validator-client": "6.0.0-nightly.20260829",
+    "@aztec-labs/validator-ha-signer": "6.0.0-nightly.20260829",
+    "@aztec/l1-artifacts": "6.0.0-nightly.20260826",
+    "lodash.chunk": "^4.2.0",
+    "tslib": "^2.4.0",
+    "viem": "npm:@aztec/viem@2.38.2",
+    "zod": "^4"
+  },
+  "devDependencies": {
+    "@aztec-labs/noir-protocol-circuits-types": "6.0.0-nightly.20260829",
+    "@aztec-labs/protocol-contracts": "6.0.0-nightly.20260829",
+    "@aztec-labs/world-state": "6.0.0-nightly.20260829",
+    "@electric-sql/pglite": "^0.3.14",
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/lodash.chunk": "^4.2.7",
+    "@types/lodash.pick": "^4.4.7",
+    "@types/node": "^22.15.17",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
+    "concurrently": "^7.6.0",
+    "eslint": "^9.26.0",
+    "express": "^4.21.2",
+    "jest": "^30.0.0",
+    "jest-mock-extended": "^4.0.0",
+    "prettier": "^3.5.3",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.3"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/index.d.ts",
+  "engines": {
+    "node": ">=20.10"
+  },
+  "jest": {
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
+    ]
+  }
+}

package/src/client/index.ts

@@ -0,0 +1 @@
+export * from './sequencer-client.js';

package/src/client/sequencer-client.ts

@@ -0,0 +1,281 @@
+import type { BlobClientInterface } from '@aztec-labs/blob-client/client';
+import { MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT } from '@aztec-labs/constants';
+import { EpochCache } from '@aztec-labs/epoch-cache';
+import { getPublicClient } from '@aztec-labs/ethereum/client';
+import { GovernanceProposerContract, RollupContract } from '@aztec-labs/ethereum/contracts';
+import { type Delayer, L1TxUtils } from '@aztec-labs/ethereum/l1-tx-utils';
+import { PublisherManager } from '@aztec-labs/ethereum/publisher-manager';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { createLogger } from '@aztec-labs/foundation/log';
+import type { DateProvider } from '@aztec-labs/foundation/timer';
+import type { KeystoreManager } from '@aztec-labs/node-keystore';
+import type { P2P } from '@aztec-labs/p2p';
+import type { SlasherClientInterface } from '@aztec-labs/slasher';
+import type { L2BlockSink, L2BlockSource, ProposedCheckpointSink } from '@aztec-labs/stdlib/block';
+import type { ValidatorClientFullConfig, WorldStateSynchronizer } from '@aztec-labs/stdlib/interfaces/server';
+import type { L1ToL2MessageSource } from '@aztec-labs/stdlib/messaging';
+import { L1Metrics, type TelemetryClient } from '@aztec-labs/telemetry-client';
+import { FullNodeCheckpointsBuilder, NodeKeystoreAdapter, type ValidatorClient } from '@aztec-labs/validator-client';
+
+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';
+
+/**
+ * Encapsulates the full sequencer and publisher.
+ */
+export class SequencerClient {
+  constructor(
+    protected publisherManager: PublisherManager<L1TxUtils>,
+    protected sequencer: Sequencer,
+    protected checkpointsBuilder: FullNodeCheckpointsBuilder,
+    protected validatorClient?: ValidatorClient,
+    private l1Metrics?: L1Metrics,
+    private delayer_?: Delayer,
+  ) {}
+
+  /**
+   * 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.
+   * @param worldStateSynchronizer - Provides access to world state.
+   * @param contractDataSource - Provides access to contract bytecode for public executions.
+   * @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
+   * @returns A new running instance.
+   */
+  public static async new(
+    config: SequencerClientConfig,
+    deps: {
+      validatorClient: ValidatorClient;
+      p2pClient: P2P;
+      worldStateSynchronizer: WorldStateSynchronizer;
+      slasherClient: SlasherClientInterface | undefined;
+      checkpointsBuilder: FullNodeCheckpointsBuilder;
+      l2BlockSource: L2BlockSource & L2BlockSink & ProposedCheckpointSink;
+      l1ToL2MessageSource: L1ToL2MessageSource;
+      telemetry: TelemetryClient;
+      publisherFactory?: SequencerPublisherFactory;
+      blobClient: BlobClientInterface;
+      dateProvider: DateProvider;
+      epochCache?: EpochCache;
+      l1TxUtils: L1TxUtils[];
+      funderL1TxUtils?: L1TxUtils;
+      nodeKeyStore: KeystoreManager;
+      globalVariableBuilder: GlobalVariableBuilder;
+    },
+  ) {
+    const {
+      validatorClient,
+      p2pClient,
+      worldStateSynchronizer,
+      slasherClient,
+      checkpointsBuilder,
+      l2BlockSource,
+      l1ToL2MessageSource,
+      telemetry: telemetryClient,
+    } = deps;
+    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 governanceProposerContract = new GovernanceProposerContract(
+      publicClient,
+      config.governanceProposerAddress.toString(),
+    );
+    const epochCache =
+      deps.epochCache ??
+      (await EpochCache.create(
+        config.rollupAddress,
+        {
+          l1RpcUrls: rpcUrls,
+          l1ChainId: chainId,
+          viemPollingIntervalMS: config.viemPollingIntervalMS,
+          ethereumSlotDuration: config.ethereumSlotDuration,
+        },
+        { dateProvider: deps.dateProvider },
+      ));
+
+    const publisherFactory =
+      deps.publisherFactory ??
+      new SequencerPublisherFactory(config, {
+        telemetry: telemetryClient,
+        blobClient: deps.blobClient,
+        epochCache,
+        governanceProposerContract,
+        rollupContract,
+        dateProvider: deps.dateProvider,
+        publisherManager,
+        nodeKeyStore: NodeKeystoreAdapter.fromKeyStoreManager(deps.nodeKeyStore),
+        logger: log,
+      });
+
+    const ethereumSlotDuration = config.ethereumSlotDuration;
+
+    const globalsBuilder = deps.globalVariableBuilder;
+
+    const { maxL2BlockGas, maxDABlockGas, maxTxsPerBlock } = capPerBlockLimits(config, rollupManaLimit, log);
+
+    const l1Constants = {
+      l1GenesisTime,
+      slotDuration: Number(slotDuration),
+      ethereumSlotDuration,
+      rollupManaLimit,
+      epochDuration: config.aztecEpochDuration,
+    };
+
+    const sequencer = new Sequencer(
+      publisherFactory,
+      validatorClient,
+      globalsBuilder,
+      p2pClient,
+      worldStateSynchronizer,
+      slasherClient,
+      l2BlockSource,
+      l1ToL2MessageSource,
+      checkpointsBuilder,
+      l1Constants,
+      deps.dateProvider,
+      epochCache,
+      rollupContract,
+      { ...config, maxL2BlockGas, maxDABlockGas, maxTxsPerBlock },
+      telemetryClient,
+      log,
+    );
+
+    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 and validator client config.
+   * @param config - New parameters.
+   */
+  public updateConfig(config: SequencerConfig & Partial<ValidatorClientFullConfig>) {
+    this.sequencer.updateConfig(config);
+    this.checkpointsBuilder.updateConfig(config);
+    this.validatorClient?.updateConfig(config);
+  }
+
+  /**
+   * Starts (or resumes) the sequencer, validator, publishers, and metrics. Each underlying start is
+   * idempotent, so this is safe to call after a previous {@link pause} to resume building and publishing.
+   * The publisher manager is started before the sequencer's poll loop so publishing is ready before the
+   * sequencer first tries to publish to L1.
+   */
+  public async start() {
+    await this.validatorClient?.start();
+    await this.publisherManager.start();
+    this.sequencer.start();
+    this.l1Metrics?.start();
+  }
+
+  /**
+   * Stops the sequencer, validator, publishers, and metrics for good, draining in-flight work. This is the
+   * final teardown path: stopping the validator client closes its slashing-protection database. For a
+   * restartable pause (e.g. around a test clock warp) use {@link pause} instead.
+   */
+  public async stop() {
+    await this.sequencer.stop();
+    await this.validatorClient?.stop();
+    await this.publisherManager.stop();
+    this.l1Metrics?.stop();
+  }
+
+  /**
+   * Gracefully pauses block production, waiting for in-flight work to finish rather than interrupting it,
+   * while leaving the validator, publishers, and metrics running so the sequencer can be resumed with
+   * {@link start}. Used by tests that pause sequencers around an L1 clock warp.
+   */
+  public async pause() {
+    await this.sequencer.pause();
+  }
+
+  /** Triggers an immediate run of the sequencer, bypassing the polling interval. */
+  public trigger() {
+    return this.sequencer.trigger();
+  }
+
+  public getSequencer(): Sequencer {
+    return this.sequencer;
+  }
+
+  /** 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 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 };
+}