@aztec/sequencer-client 4.0.0-nightly.20250907 → 4.0.0-nightly.20260107

package/src/client/sequencer-client.ts

@@ -1,13 +1,10 @@
-import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
+import type { BlobClientInterface } from '@aztec/blob-client/client';
 import { EpochCache } from '@aztec/epoch-cache';
-import {
-  GovernanceProposerContract,
-  PublisherManager,
-  RollupContract,
-  getPublicClient,
-  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';
@@ -15,11 +12,7 @@ import type { KeystoreManager } from '@aztec/node-keystore';
 import type { P2P } from '@aztec/p2p';
 import type { SlasherClientInterface } from '@aztec/slasher';
 import type { L2BlockSource } from '@aztec/stdlib/block';
-import type {
-  IFullNodeBlockBuilder,
-  ValidatorClientFullConfig,
-  WorldStateSynchronizer,
-} from '@aztec/stdlib/interfaces/server';
+import type { ValidatorClientFullConfig, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 import { L1Metrics, type TelemetryClient } from '@aztec/telemetry-client';
@@ -28,6 +21,7 @@ import { NodeKeystoreAdapter, type ValidatorClient } from '@aztec/validator-clie
 import type { SequencerClientConfig } from '../config.js';
 import { GlobalVariableBuilder } from '../global_variable_builder/index.js';
 import { SequencerPublisherFactory } from '../publisher/sequencer-publisher-factory.js';
+import { FullNodeCheckpointsBuilder } from '../sequencer/checkpoint_builder.js';
 import { Sequencer, type SequencerConfig } from '../sequencer/index.js';
 
 /**
@@ -37,6 +31,7 @@ export class SequencerClient {
   constructor(
     protected publisherManager: PublisherManager<L1TxUtilsWithBlobs>,
     protected sequencer: Sequencer,
+    protected checkpointsBuilder: FullNodeCheckpointsBuilder,
     protected validatorClient?: ValidatorClient,
     private l1Metrics?: L1Metrics,
   ) {}
@@ -56,16 +51,16 @@ export class SequencerClient {
   public static async new(
     config: SequencerClientConfig,
     deps: {
-      validatorClient: ValidatorClient | undefined; // allowed to be undefined while we migrate
+      validatorClient: ValidatorClient;
       p2pClient: P2P;
       worldStateSynchronizer: WorldStateSynchronizer;
       slasherClient: SlasherClientInterface | undefined;
-      blockBuilder: IFullNodeBlockBuilder;
+      checkpointsBuilder: FullNodeCheckpointsBuilder;
       l2BlockSource: L2BlockSource;
       l1ToL2MessageSource: L1ToL2MessageSource;
       telemetry: TelemetryClient;
       publisherFactory?: SequencerPublisherFactory;
-      blobSinkClient?: BlobSinkClientInterface;
+      blobClient: BlobClientInterface;
       dateProvider: DateProvider;
       epochCache?: EpochCache;
       l1TxUtils: L1TxUtilsWithBlobs[];
@@ -77,13 +72,13 @@ export class SequencerClient {
       p2pClient,
       worldStateSynchronizer,
       slasherClient,
-      blockBuilder,
+      checkpointsBuilder,
       l2BlockSource,
       l1ToL2MessageSource,
       telemetry: telemetryClient,
     } = deps;
     const { l1RpcUrls: rpcUrls, l1ChainId: chainId } = config;
-    const log = createLogger('sequencer-client');
+    const log = createLogger('sequencer');
     const publicClient = getPublicClient(config);
     const l1TxUtils = deps.l1TxUtils;
     const l1Metrics = new L1Metrics(
@@ -91,11 +86,13 @@ export class SequencerClient {
       publicClient,
       l1TxUtils.map(x => x.getSenderAddress()),
     );
-    const publisherManager = new PublisherManager(l1TxUtils);
+    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 governanceProposerContract = new GovernanceProposerContract(
@@ -110,9 +107,7 @@ export class SequencerClient {
           l1RpcUrls: rpcUrls,
           l1ChainId: chainId,
           viemPollingIntervalMS: config.viemPollingIntervalMS,
-          aztecSlotDuration: config.aztecSlotDuration,
           ethereumSlotDuration: config.ethereumSlotDuration,
-          aztecEpochDuration: config.aztecEpochDuration,
         },
         { dateProvider: deps.dateProvider },
       ));
@@ -126,7 +121,7 @@ export class SequencerClient {
       deps.publisherFactory ??
       new SequencerPublisherFactory(config, {
         telemetry: telemetryClient,
-        blobSinkClient: deps.blobSinkClient,
+        blobClient: deps.blobClient,
         epochCache,
         governanceProposerContract,
         slashFactoryContract,
@@ -134,34 +129,29 @@ export class SequencerClient {
         dateProvider: deps.dateProvider,
         publisherManager,
         nodeKeyStore: NodeKeystoreAdapter.fromKeyStoreManager(deps.nodeKeyStore),
+        logger: log,
       });
-    const globalsBuilder = new GlobalVariableBuilder(config);
 
     const ethereumSlotDuration = config.ethereumSlotDuration;
+    const l1Constants = { l1GenesisTime, slotDuration: Number(slotDuration), ethereumSlotDuration };
+
+    const globalsBuilder = new GlobalVariableBuilder({ ...config, ...l1Constants, rollupVersion });
 
-    const rollupManaLimit = Number(await rollupContract.getManaLimit());
     let sequencerManaLimit = config.maxL2BlockGas ?? rollupManaLimit;
     if (sequencerManaLimit > rollupManaLimit) {
       log.warn(
-        `Provided maxL2BlockGas of ${sequencerManaLimit} is greater than the maximum allowed by the L1 (${rollupManaLimit}), setting limit to ${rollupManaLimit}`,
+        `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, 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.
+    // 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 - 1 : 0;
-
-    const l1Constants = {
-      l1GenesisTime,
-      slotDuration: Number(slotDuration),
-      ethereumSlotDuration,
-    };
+    const l1PublishingTimeBasedOnChain = isAnvilTestChain(config.l1ChainId) ? 1 : ethereumSlotDuration;
+    const l1PublishingTime = config.l1PublishingTime ?? l1PublishingTimeBasedOnChain;
 
     const sequencer = new Sequencer(
       publisherFactory,
@@ -172,18 +162,19 @@ export class SequencerClient {
       slasherClient,
       l2BlockSource,
       l1ToL2MessageSource,
-      blockBuilder,
+      checkpointsBuilder,
       l1Constants,
       deps.dateProvider,
       epochCache,
       rollupContract,
-      { ...config, maxL1TxInclusionTimeIntoSlot, maxL2BlockGas: sequencerManaLimit },
+      { ...config, l1PublishingTime, maxL2BlockGas: sequencerManaLimit },
       telemetryClient,
+      log,
     );
 
     await sequencer.init();
 
-    return new SequencerClient(publisherManager, sequencer, validatorClient, l1Metrics);
+    return new SequencerClient(publisherManager, sequencer, checkpointsBuilder, validatorClient, l1Metrics);
   }
 
   /**
@@ -192,6 +183,7 @@ export class SequencerClient {
    */
   public updateConfig(config: SequencerConfig & Partial<ValidatorClientFullConfig>) {
     this.sequencer.updateConfig(config);
+    this.checkpointsBuilder.updateConfig(config);
     this.validatorClient?.updateConfig(config);
   }
 
@@ -200,6 +192,7 @@ export class SequencerClient {
     await this.validatorClient?.start();
     this.sequencer.start();
     this.l1Metrics?.start();
+    await this.publisherManager.loadState();
   }
 
   /**
@@ -207,6 +200,7 @@ export class SequencerClient {
    */
   public async stop() {
     await this.sequencer.stop();
+    await this.validatorClient?.stop();
     this.publisherManager.interrupt();
     this.l1Metrics?.stop();
   }

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 { type P2PConfig, p2pConfigMappings } from '@aztec/p2p';
+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 ChainConfig, type SequencerConfig, chainConfigMappings } from '@aztec/stdlib/config';
-import { type ValidatorClientConfig, validatorClientConfigMappings } from '@aztec/validator-client';
+import type { ResolvedSequencerConfig } from '@aztec/stdlib/interfaces/server';
+import { type ValidatorClientConfig, validatorClientConfigMappings } from '@aztec/validator-client/config';
 
 import {
   type PublisherConfig,
@@ -29,10 +27,36 @@ 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,
+};
+
 /**
  * Configuration settings for the SequencerClient.
  */
 export type SequencerClientConfig = PublisherConfig &
+  KeyStoreConfig &
   ValidatorClientConfig &
   TxSenderConfig &
   SequencerConfig &
@@ -42,35 +66,39 @@ export type SequencerClientConfig = PublisherConfig &
   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(false),
+    ...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',
@@ -93,55 +121,86 @@ export const sequencerConfigMappings: ConfigMappingsType<SequencerConfig> = {
   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: true,
+    ...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(DEFAULT_ATTESTATION_PROPAGATION_TIME),
+    ...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(144), // 12 L1 blocks
+    ...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(432), // 36 L1 blocks
+    ...numberConfigHelper(DefaultSequencerConfig.secondsBeforeInvalidatingBlockAsNonCommitteeMember),
   },
   skipCollectingAttestations: {
     description:
       'Whether to skip collecting attestations from validators and only use self-attestations (for testing only)',
-    ...booleanConfigHelper(false),
+    ...booleanConfigHelper(DefaultSequencerConfig.skipCollectingAttestations),
   },
   skipInvalidateBlockAsProposer: {
     description: 'Do not invalidate the previous block if invalid when we are the proposer (for testing only)',
-    ...booleanConfigHelper(false),
+    ...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),
   },
   ...pickConfigMappings(p2pConfigMappings, ['txPublicSetupAllowList']),
 };
@@ -149,6 +208,7 @@ export const sequencerConfigMappings: ConfigMappingsType<SequencerConfig> = {
 export const sequencerClientConfigMappings: ConfigMappingsType<SequencerClientConfig> = {
   ...validatorClientConfigMappings,
   ...sequencerConfigMappings,
+  ...keyStoreConfigMappings,
   ...l1ReaderConfigMappings,
   ...getTxSenderConfigMappings('SEQ'),
   ...getPublisherConfigMappings('SEQ'),

package/src/global_variable_builder/global_builder.ts

@@ -1,16 +1,19 @@
-import {
-  type L1ContractsConfig,
-  type L1ReaderConfig,
-  RollupContract,
-  type ViemPublicClient,
-  createEthereumChain,
-} from '@aztec/ethereum';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import type { L1ContractsConfig } from '@aztec/ethereum/config';
+import { RollupContract } from '@aztec/ethereum/contracts';
+import type { L1ReaderConfig } from '@aztec/ethereum/l1-reader';
+import type { ViemPublicClient } from '@aztec/ethereum/types';
+import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type L1RollupConstants, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
 import { GasFees } from '@aztec/stdlib/gas';
-import type { GlobalVariableBuilder as GlobalVariableBuilderInterface } from '@aztec/stdlib/tx';
+import type {
+  CheckpointGlobalVariables,
+  GlobalVariableBuilder as GlobalVariableBuilderInterface,
+} from '@aztec/stdlib/tx';
 import { GlobalVariables } from '@aztec/stdlib/tx';
 
 import { createPublicClient, fallback, http } from 'viem';
@@ -26,20 +29,31 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
   private readonly rollupContract: RollupContract;
   private readonly publicClient: ViemPublicClient;
   private readonly ethereumSlotDuration: number;
+  private readonly aztecSlotDuration: number;
+  private readonly l1GenesisTime: bigint;
 
-  private chainId?: Fr;
-  private version?: Fr;
+  private chainId: Fr;
+  private version: Fr;
 
-  constructor(config: L1ReaderConfig & Pick<L1ContractsConfig, 'ethereumSlotDuration'>) {
+  constructor(
+    config: L1ReaderConfig &
+      Pick<L1ContractsConfig, 'ethereumSlotDuration'> &
+      Pick<L1RollupConstants, 'slotDuration' | 'l1GenesisTime'> & { rollupVersion: bigint },
+  ) {
     const { l1RpcUrls, l1ChainId: chainId, l1Contracts } = config;
 
     const chain = createEthereumChain(l1RpcUrls, chainId);
 
+    this.version = new Fr(config.rollupVersion);
+    this.chainId = new Fr(chainId);
+
     this.ethereumSlotDuration = config.ethereumSlotDuration;
+    this.aztecSlotDuration = config.slotDuration;
+    this.l1GenesisTime = config.l1GenesisTime;
 
     this.publicClient = createPublicClient({
       chain: chain.chainInfo,
-      transport: fallback(chain.rpcUrls.map(url => http(url))),
+      transport: fallback(chain.rpcUrls.map(url => http(url, { batch: false }))),
       pollingInterval: config.viemPollingIntervalMS,
     });
 
@@ -55,8 +69,10 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
     // we need to fetch the last block written, and estimate the earliest timestamp for the next block.
     // The timestamp of that last block will act as a lower bound for the next block.
 
-    const lastBlock = await this.rollupContract.getBlock(await this.rollupContract.getBlockNumber());
-    const earliestTimestamp = await this.rollupContract.getTimestampForSlot(lastBlock.slotNumber + 1n);
+    const lastBlock = await this.rollupContract.getPendingCheckpoint();
+    const earliestTimestamp = await this.rollupContract.getTimestampForSlot(
+      SlotNumber.fromBigInt(BigInt(lastBlock.slotNumber) + 1n),
+    );
     const nextEthTimestamp = BigInt((await this.publicClient.getBlock()).timestamp + BigInt(this.ethereumSlotDuration));
     const timestamp = earliestTimestamp > nextEthTimestamp ? earliestTimestamp : nextEthTimestamp;
 
@@ -75,18 +91,8 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
     return this.currentBaseFees;
   }
 
-  public async getGlobalConstantVariables(): Promise<Pick<GlobalVariables, 'chainId' | 'version'>> {
-    if (!this.chainId) {
-      this.chainId = new Fr(this.publicClient.chain.id);
-    }
-    if (!this.version) {
-      this.version = new Fr(await this.rollupContract.getVersion());
-    }
-    return { chainId: this.chainId, version: this.version };
-  }
-
   /**
-   * Simple builder of global variables that use the minimum time possible.
+   * Simple builder of global variables.
    * @param blockNumber - The block number to build global variables for.
    * @param coinbase - The address to receive block reward.
    * @param feeRecipient - The address to receive fees.
@@ -94,36 +100,38 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
    * @returns The global variables for the given block number.
    */
   public async buildGlobalVariables(
-    blockNumber: number,
+    blockNumber: BlockNumber,
     coinbase: EthAddress,
     feeRecipient: AztecAddress,
-    slotNumber?: bigint,
+    maybeSlot?: SlotNumber,
   ): Promise<GlobalVariables> {
-    const { chainId, version } = await this.getGlobalConstantVariables();
-
-    if (slotNumber === undefined) {
-      const ts = BigInt((await this.publicClient.getBlock()).timestamp + BigInt(this.ethereumSlotDuration));
-      slotNumber = await this.rollupContract.getSlotAt(ts);
-    }
+    const slot: SlotNumber =
+      maybeSlot ??
+      (await this.rollupContract.getSlotAt(
+        BigInt((await this.publicClient.getBlock()).timestamp + BigInt(this.ethereumSlotDuration)),
+      ));
+
+    const checkpointGlobalVariables = await this.buildCheckpointGlobalVariables(coinbase, feeRecipient, slot);
+    return GlobalVariables.from({ blockNumber, ...checkpointGlobalVariables });
+  }
 
-    const timestamp = await this.rollupContract.getTimestampForSlot(slotNumber);
+  /** Builds global variables that are constant throughout a checkpoint. */
+  public async buildCheckpointGlobalVariables(
+    coinbase: EthAddress,
+    feeRecipient: AztecAddress,
+    slotNumber: SlotNumber,
+  ): Promise<CheckpointGlobalVariables & { timestamp: bigint }> {
+    const { chainId, version } = this;
 
-    const slotFr = new Fr(slotNumber);
+    const timestamp = getTimestampForSlot(slotNumber, {
+      slotDuration: this.aztecSlotDuration,
+      l1GenesisTime: this.l1GenesisTime,
+    });
 
     // We can skip much of the logic in getCurrentBaseFees since it we already check that we are not within a slot elsewhere.
+    // TODO(palla/mbps): Can we use a cached value here?
     const gasFees = new GasFees(0, await this.rollupContract.getManaBaseFeeAt(timestamp, true));
 
-    const globalVariables = new GlobalVariables(
-      chainId,
-      version,
-      blockNumber,
-      slotFr,
-      timestamp,
-      coinbase,
-      feeRecipient,
-      gasFees,
-    );
-
-    return globalVariables;
+    return { chainId, version, slotNumber, timestamp, coinbase, feeRecipient, gasFees };
   }
 }

package/src/index.ts

@@ -3,6 +3,8 @@ export * from './config.js';
 export * from './publisher/index.js';
 export {
   FullNodeBlockBuilder as BlockBuilder,
+  FullNodeCheckpointsBuilder as CheckpointsBuilder,
+  CheckpointBuilder,
   Sequencer,
   SequencerState,
   type SequencerEvents,