@aztec/stdlib 6.0.0-nightly.20260604 → 6.0.0-nightly.20260721

package/src/timetable/budgets.ts

@@ -0,0 +1,87 @@
+/** Default block sub-slot duration (`D`) in seconds, used to derive how many blocks fit in a slot. */
+export const DEFAULT_BLOCK_DURATION = 3;
+
+/** Default minimum block-building duration (`min_block_duration`) in seconds. */
+export const DEFAULT_MIN_BLOCK_DURATION = 2;
+
+/** Default one-way P2P propagation time (`p2p_propagation_time`) for proposals and attestations in seconds. */
+export const DEFAULT_P2P_PROPAGATION_TIME = 2;
+
+/** Default local checkpoint proposal preparation time (`checkpoint_proposal_prepare_time`) in seconds. */
+export const DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME = 1;
+
+/** Default local tolerance for archiver orphan-prune checks when no checkpoint proposal was received. */
+export const DEFAULT_ORPHAN_PRUNE_NO_PROPOSAL_TOLERANCE = 1;
+
+/**
+ * Default proposer initialization time (`checkpoint_proposal_init_time`) in seconds: the budget reserved at
+ * the start of the build frame for sync, the proposer check, and checkpoint initialization before the first
+ * block sub-slot opens. The proposer rarely starts building exactly at `build_frame_start`; this offset
+ * shifts the sub-slot grid so the first sub-slot still has its full duration once the prologue completes.
+ */
+export const DEFAULT_CHECKPOINT_PROPOSAL_INIT_TIME = 1;
+
+/**
+ * Ethereum slot duration (seconds) below which a network is treated as a fast local/e2e profile with mocked
+ * p2p. Profiles at or above this keep the production operational budgets. Mainnet is 12s; fast anvil-style
+ * local profiles run at 4s.
+ */
+export const FAST_PROFILE_ETHEREUM_SLOT_DURATION = 8;
+
+/**
+ * Operational timing budgets for the fast local/e2e profile (mocked p2p), per the README's "Local e2e with
+ * mocked p2p" section. When `ethereum_slot_duration < FAST_PROFILE_ETHEREUM_SLOT_DURATION`, these cap the
+ * proposer's operational budgets so a fast network does not inherit the conservative production budgets,
+ * which would shrink the per-checkpoint build window and under-pack checkpoints. Explicitly configured
+ * budgets below these caps are kept as-is (the budgets are clamped down, never raised).
+ */
+export const FAST_PROFILE_P2P_PROPAGATION_TIME = 0.5;
+
+/** Fast-profile checkpoint proposal preparation budget (seconds). See {@link FAST_PROFILE_P2P_PROPAGATION_TIME}. */
+export const FAST_PROFILE_CHECKPOINT_PROPOSAL_PREPARE_TIME = 0.5;
+
+/** Fast-profile minimum block-building budget (seconds). See {@link FAST_PROFILE_P2P_PROPAGATION_TIME}. */
+export const FAST_PROFILE_MIN_BLOCK_DURATION = 1;
+
+/** Resolved operational timing budgets used to size the proposer build window. */
+export type ResolvedTimingBudgets = {
+  minBlockDuration: number;
+  p2pPropagationTime: number;
+  checkpointProposalPrepareTime: number;
+  checkpointProposalInitTime: number;
+};
+
+/** Default consensus grace for received checkpoint proposals to materialize locally. */
+export function getDefaultCheckpointProposalSyncGrace(blockDuration: number): number {
+  return 2 * blockDuration;
+}
+
+/**
+ * Resolves the operational timing budgets, applying the fast local/e2e profile when
+ * `ethereumSlotDuration < FAST_PROFILE_ETHEREUM_SLOT_DURATION`.
+ *
+ * Production profiles (`ethereumSlotDuration >= FAST_PROFILE_ETHEREUM_SLOT_DURATION`) use the configured
+ * budgets verbatim. Fast profiles clamp `p2pPropagationTime`, `checkpointProposalPrepareTime`, and
+ * `minBlockDuration` down to the fast-profile caps so a fast network (mocked p2p) gets a build window sized
+ * for local timing rather than the conservative production budgets. The clamp only lowers budgets, so an
+ * operator that explicitly configured a smaller value keeps it. `checkpointProposalInitTime` is unchanged by
+ * the profile: it is a proposer prologue budget, not a propagation/preparation budget.
+ */
+export function resolveTimingBudgets(ethereumSlotDuration: number, opts: ResolvedTimingBudgets): ResolvedTimingBudgets {
+  const { minBlockDuration, p2pPropagationTime, checkpointProposalPrepareTime, checkpointProposalInitTime } = opts;
+
+  const isFastProfile = ethereumSlotDuration < FAST_PROFILE_ETHEREUM_SLOT_DURATION;
+  if (!isFastProfile) {
+    return { minBlockDuration, p2pPropagationTime, checkpointProposalPrepareTime, checkpointProposalInitTime };
+  }
+
+  return {
+    minBlockDuration: Math.min(minBlockDuration, FAST_PROFILE_MIN_BLOCK_DURATION),
+    p2pPropagationTime: Math.min(p2pPropagationTime, FAST_PROFILE_P2P_PROPAGATION_TIME),
+    checkpointProposalPrepareTime: Math.min(
+      checkpointProposalPrepareTime,
+      FAST_PROFILE_CHECKPOINT_PROPOSAL_PREPARE_TIME,
+    ),
+    checkpointProposalInitTime,
+  };
+}

package/src/timetable/build_proposer_timetable.ts

@@ -0,0 +1,42 @@
+import {
+  DEFAULT_BLOCK_DURATION,
+  DEFAULT_CHECKPOINT_PROPOSAL_INIT_TIME,
+  DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME,
+  DEFAULT_MIN_BLOCK_DURATION,
+  DEFAULT_P2P_PROPAGATION_TIME,
+} from './budgets.js';
+import type { SlotTimingConstants } from './consensus_timetable.js';
+import { ProposerTimetable } from './proposer_timetable.js';
+
+/**
+ * Subset of the sequencer/p2p config the proposer timetable derives its operational budgets from. Both
+ * {@link SequencerConfig} and {@link P2PConfig} structurally satisfy this, so the same builder is used by
+ * the sequencer, the p2p layer, and the node's `getNodeInfo`.
+ */
+export type ProposerTimetableConfig = {
+  blockDurationMs?: number;
+  minBlockDuration?: number;
+  attestationPropagationTime?: number;
+  checkpointProposalPrepareTime?: number;
+  checkpointProposalSyncGraceSeconds?: number;
+};
+
+/**
+ * Builds the proposer timetable from a sequencer/p2p config and the slot-timing protocol constants,
+ * applying the shared stdlib budget defaults. Single source of truth shared by the sequencer, the p2p
+ * layer, and the node's `getNodeInfo` so they all derive the same `maxBlocksPerCheckpoint`.
+ */
+export function buildProposerTimetable(
+  config: ProposerTimetableConfig,
+  l1Constants: SlotTimingConstants,
+): ProposerTimetable {
+  return new ProposerTimetable({
+    l1Constants,
+    blockDuration: config.blockDurationMs !== undefined ? config.blockDurationMs / 1000 : DEFAULT_BLOCK_DURATION,
+    minBlockDuration: config.minBlockDuration ?? DEFAULT_MIN_BLOCK_DURATION,
+    p2pPropagationTime: config.attestationPropagationTime ?? DEFAULT_P2P_PROPAGATION_TIME,
+    checkpointProposalPrepareTime: config.checkpointProposalPrepareTime ?? DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME,
+    checkpointProposalInitTime: DEFAULT_CHECKPOINT_PROPOSAL_INIT_TIME,
+    checkpointProposalSyncGrace: config.checkpointProposalSyncGraceSeconds,
+  });
+}

package/src/timetable/consensus_timetable.ts

@@ -0,0 +1,126 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
+
+import { type L1RollupConstants, getTimestampForSlot } from '../epoch-helpers/index.js';
+import { getDefaultCheckpointProposalSyncGrace } from './budgets.js';
+
+/** Slot-timing protocol constants the timetables derive wall-clock times from. */
+export type SlotTimingConstants = Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'ethereumSlotDuration'>;
+
+/**
+ * Consensus acceptance bounds for the pipelined timetable.
+ *
+ * Returns the deadlines and matching receive-window lower bounds that validators and p2p use to decide
+ * whether a proposal or attestation is acceptable for a given target slot. All getters take a target slot
+ * and return an absolute wall-clock timestamp in seconds.
+ *
+ * Inputs are protocol slot-timing constants only (`genesis`, `aztec_slot_duration`,
+ * `ethereum_slot_duration`, `block_duration`, `checkpoint_proposal_sync_grace`); no operational budgets, so every
+ * node agrees on these bounds. See `stdlib/src/timetable/README.md` for the timing model.
+ */
+export class ConsensusTimetable {
+  /** Aztec slot duration (`S`) in seconds. */
+  public readonly aztecSlotDuration: number;
+
+  /** Ethereum slot duration (`E`) in seconds. */
+  public readonly ethereumSlotDuration: number;
+
+  /** Block sub-slot duration (`D`) in seconds. */
+  public readonly blockDuration: number;
+
+  /** L1 genesis timestamp in seconds (`genesis`), the anchor all slot timings derive from. */
+  public readonly genesisTime: bigint;
+
+  /** Consensus grace for received checkpoint proposals to materialize into local proposed state. */
+  public readonly checkpointProposalSyncGrace: number;
+
+  constructor(opts: { l1Constants: SlotTimingConstants; blockDuration: number; checkpointProposalSyncGrace?: number }) {
+    const { l1Constants, blockDuration } = opts;
+    const checkpointProposalSyncGrace =
+      opts.checkpointProposalSyncGrace ?? getDefaultCheckpointProposalSyncGrace(blockDuration);
+    if (l1Constants.slotDuration <= 0) {
+      throw new Error(`aztecSlotDuration must be positive (got ${l1Constants.slotDuration})`);
+    }
+    if (l1Constants.ethereumSlotDuration <= 0) {
+      throw new Error(`ethereumSlotDuration must be positive (got ${l1Constants.ethereumSlotDuration})`);
+    }
+    if (blockDuration <= 0) {
+      throw new Error(`blockDuration must be positive (got ${blockDuration})`);
+    }
+    if (checkpointProposalSyncGrace < 0) {
+      throw new Error(`checkpointProposalSyncGrace must be non-negative (got ${checkpointProposalSyncGrace})`);
+    }
+
+    this.aztecSlotDuration = l1Constants.slotDuration;
+    this.ethereumSlotDuration = l1Constants.ethereumSlotDuration;
+    this.blockDuration = blockDuration;
+    this.genesisTime = l1Constants.l1GenesisTime;
+    this.checkpointProposalSyncGrace = checkpointProposalSyncGrace;
+  }
+
+  /**
+   * Build-frame start for the target slot: `target_slot_start - S - E`. Anchors all sub-slot timings.
+   * Computed directly (not via a `slot - 1` hop) so it is well-defined for slot 0, whose build frame
+   * predates genesis; p2p validators evaluate acceptance windows for arbitrary peer-supplied slots.
+   */
+  public getBuildFrameStart(slot: SlotNumber): number {
+    return this.getTargetSlotStart(slot) - this.aztecSlotDuration - this.ethereumSlotDuration;
+  }
+
+  /** Start of the target slot: `genesis + slot * S`. */
+  public getTargetSlotStart(slot: SlotNumber): number {
+    return Number(getTimestampForSlot(slot, this.getL1Constants()));
+  }
+
+  /**
+   * Earliest acceptable arrival for a checkpoint proposal: `target_slot_start - S - E` (the build frame
+   * opening). Nothing legitimate for this slot exists before its build frame opens.
+   */
+  public getCheckpointProposalReceiveStart(slot: SlotNumber): number {
+    return this.getBuildFrameStart(slot);
+  }
+
+  /**
+   * Hard consensus receive deadline for a checkpoint proposal: `target_slot_start - E - D`. Validators
+   * reject proposals arriving after this, and the next proposer does not build on them.
+   */
+  public getCheckpointProposalReceiveDeadline(slot: SlotNumber): number {
+    return this.getTargetSlotStart(slot) - this.ethereumSlotDuration - this.blockDuration;
+  }
+
+  /**
+   * Wall-clock deadline by which a received checkpoint proposal should have materialized into local proposed
+   * state. This is `next_proposer_build_frame_start + checkpointProposalSyncGrace`, rounded up to the next
+   * integer second because L1 timestamps and archiver comparisons are second-granularity.
+   */
+  public getCheckpointProposalSyncedDeadline(slot: SlotNumber): number {
+    return Math.ceil(
+      this.getCheckpointProposalReceiveDeadline(slot) + this.blockDuration + this.checkpointProposalSyncGrace,
+    );
+  }
+
+  /**
+   * Earliest acceptable arrival for an attestation: `target_slot_start - S - E` (the build frame
+   * opening). Deliberately liberal; attestations are attributed by content, not timing.
+   */
+  public getAttestationReceiveStart(slot: SlotNumber): number {
+    return this.getBuildFrameStart(slot);
+  }
+
+  /**
+   * Single hard consensus deadline: `target_slot_start + S - 2E`. The latest the checkpoint can still
+   * land on L1 in the target slot, and the cutoff by which every block and the checkpoint must be
+   * re-executed, validated, and signed. Consensus-driven (used for inactivity/slashing decisions).
+   */
+  public getAttestationDeadline(slot: SlotNumber): number {
+    return this.getTargetSlotStart(slot) + this.aztecSlotDuration - 2 * this.ethereumSlotDuration;
+  }
+
+  /** Slot-timing protocol constants this timetable derives wall-clock times from. */
+  public getL1Constants(): SlotTimingConstants {
+    return {
+      l1GenesisTime: this.genesisTime,
+      slotDuration: this.aztecSlotDuration,
+      ethereumSlotDuration: this.ethereumSlotDuration,
+    };
+  }
+}

package/src/timetable/index.ts

@@ -1,304 +1,4 @@
-/**
- * Timetable constants used for sequencer timing calculations.
- * These define the time budgets for various phases of block production.
- *
- * The sequencer slot is divided into phases:
- * 1. Checkpoint initialization (sync + proposer check)
- * 2. Block building (execution)
- * 3. Checkpoint assembly
- * 4. P2P propagation for proposal and attestations (round-trip)
- * 5. L1 publishing
- */
-
-/** Time budget for checkpoint initialization (sync + proposer check) in seconds */
-export const CHECKPOINT_INITIALIZATION_TIME = 1;
-
-/** Time budget for assembling a checkpoint after building the last block in seconds */
-export const CHECKPOINT_ASSEMBLE_TIME = 1;
-
-/** Default one-way P2P propagation time for proposals and attestations in seconds */
-export const DEFAULT_P2P_PROPAGATION_TIME = 2;
-
-/** Default L1 publishing time (matches Ethereum slot duration on mainnet) in seconds */
-export const DEFAULT_L1_PUBLISHING_TIME = 12;
-
-/** Minimum execution time for building a block in seconds */
-export const MIN_EXECUTION_TIME = 2;
-
-export type CheckpointTimingConfig = {
-  aztecSlotDuration: number;
-  ethereumSlotDuration?: number;
-  blockDuration?: number;
-  checkpointAssembleTime?: number;
-  checkpointInitializationTime?: number;
-  l1PublishingTime?: number;
-  minExecutionTime?: number;
-  p2pPropagationTime?: number;
-};
-
-export interface CheckpointTiming {
-  readonly aztecSlotDuration: number;
-  readonly blockDuration: number | undefined;
-  readonly checkpointAssembleTime: number;
-  readonly checkpointInitializationTime: number;
-  readonly l1PublishingTime: number;
-  readonly minExecutionTime: number;
-  readonly p2pPropagationTime: number;
-  readonly checkpointFinalizationTime: number;
-  readonly pipeliningAttestationGracePeriod: number;
-  readonly timeReservedAtEnd: number;
-  readonly minimumBuildSlotWork: number;
-  readonly initializeDeadline: number;
-  readonly checkpointAssemblyDeadline: number;
-  readonly checkpointAttestationStartDeadline: number;
-  readonly checkpointAttestationDeadline: number;
-  readonly checkpointPublishingDeadline: number;
-
-  calculateMaxBlocksPerSlot(): number;
-}
-
-export interface PipelinedCheckpointTiming extends CheckpointTiming {
-  readonly proposalWindowIntoTargetSlot: number;
-  readonly attestationWindowIntoTargetSlot: number;
-}
-
-/**
- * Checkpoint timing model for proposer pipelining.
- *
- * The build work starts at the wall-clock slot boundary and the checkpoint
- * proposal is broadcast early enough that attestations complete by the end of
- * the build slot. L1 submission can then be sent at the boundary of the target
- * slot. The target-slot window getters are intended for consumers such as P2P
- * validators that need to validate pipelined messages against wallclock time.
- */
-class CheckpointTimingModel implements PipelinedCheckpointTiming {
-  public readonly aztecSlotDuration: number;
-  public readonly blockDuration: number | undefined;
-  public readonly checkpointAssembleTime: number;
-  public readonly checkpointInitializationTime: number;
-  public readonly l1PublishingTime: number;
-  public readonly minExecutionTime: number;
-  public readonly p2pPropagationTime: number;
-  private readonly ethereumSlotDuration: number;
-
-  constructor(opts: CheckpointTimingConfig) {
-    this.aztecSlotDuration = opts.aztecSlotDuration;
-    this.blockDuration = opts.blockDuration;
-
-    this.checkpointAssembleTime = opts.checkpointAssembleTime ?? CHECKPOINT_ASSEMBLE_TIME;
-    this.checkpointInitializationTime = opts.checkpointInitializationTime ?? CHECKPOINT_INITIALIZATION_TIME;
-    this.l1PublishingTime = opts.l1PublishingTime ?? DEFAULT_L1_PUBLISHING_TIME;
-    this.minExecutionTime = opts.minExecutionTime ?? MIN_EXECUTION_TIME;
-    this.p2pPropagationTime = opts.p2pPropagationTime ?? DEFAULT_P2P_PROPAGATION_TIME;
-    this.ethereumSlotDuration = opts.ethereumSlotDuration ?? this.l1PublishingTime;
-  }
-
-  public get checkpointFinalizationTime(): number {
-    // Allow enough time to
-    // - build the checkpoint
-    // - Round-trip over p2p
-    // - Publish to L1
-    return this.checkpointAssembleTime + this.p2pPropagationTime * 2 + this.l1PublishingTime;
-  }
-
-  public get proposalWindowIntoTargetSlot(): number {
-    // Proposals no longer spill into the target slot: they are broadcast early
-    // enough in the build slot that attestations complete before the boundary.
-    // Any residual tolerance into the target slot is covered by clock disparity.
-    return 0;
-  }
-
-  public get attestationWindowIntoTargetSlot(): number {
-    // Span from the target-slot start to the L1 publish deadline (12s before the last L1 block of
-    // the target slot). The p2p layer accepts slot-N attestations until right before the publish
-    // deadline so the proposer can keep collecting useful attestations up to the latest moment the
-    // checkpoint can still land on L1 in the target slot.
-    return Math.max(0, this.aztecSlotDuration - 2 * this.ethereumSlotDuration);
-  }
-
-  public get pipeliningAttestationGracePeriod(): number {
-    // Under the early-pipelining regime attestations complete inside the build slot itself. Local
-    // networks can publish much faster than the Ethereum slot geometry, so they may use the target
-    // slot attestation window without moving the L1 publish cutoff.
-    return this.l1PublishingTime < this.ethereumSlotDuration ? this.attestationWindowIntoTargetSlot : 0;
-  }
-
-  public get timeReservedAtEnd(): number {
-    // Reserve enough time at the end of the build slot for:
-    // - assembling and broadcasting the checkpoint proposal
-    // - round-trip p2p propagation (proposal out, attestations back)
-    // - validators re-executing the last block
-    return this.checkpointAssembleTime + 2 * this.p2pPropagationTime + (this.blockDuration ?? 0);
-  }
-
-  public get minimumBuildSlotWork(): number {
-    return this.checkpointInitializationTime + this.minExecutionTime * 2;
-  }
-
-  public get initializeDeadline(): number {
-    return this.aztecSlotDuration - this.minimumBuildSlotWork;
-  }
-
-  public get checkpointAssemblyDeadline(): number {
-    // Allow enough time to build all blocks and receive attestations. With
-    // `pipeliningAttestationGracePeriod = 0` this equals `aztecSlotDuration`.
-    return this.aztecSlotDuration + this.pipeliningAttestationGracePeriod;
-  }
-
-  public get checkpointAttestationStartDeadline(): number {
-    return this.checkpointAssemblyDeadline;
-  }
-
-  public get checkpointAttestationDeadline(): number {
-    // L1 publish deadline — 12s (one Ethereum slot) before the last L1 block of the target L2 slot;
-    // the latest the checkpoint can be submitted and still land on L1 in the target slot. This is an
-    // L1-geometry bound (ethereumSlotDuration), matching the publisher's send lead in sendRequestsAt
-    // (which also targets one Ethereum slot before the target slot start).
-    return this.aztecSlotDuration * 2 - this.ethereumSlotDuration;
-  }
-
-  public get checkpointPublishingDeadline(): number {
-    // L1 publish deadline — 12s (one Ethereum slot) before the last L1 block of the target L2 slot;
-    // the latest the checkpoint can be submitted and still land on L1 in the target slot.
-    return this.aztecSlotDuration * 2 - this.ethereumSlotDuration;
-  }
-
-  public calculateMaxBlocksPerSlot(): number {
-    if (!this.blockDuration) {
-      return 1;
-    }
-
-    const timeAvailableForBlocks = this.aztecSlotDuration - this.checkpointInitializationTime - this.timeReservedAtEnd;
-    return Math.floor(timeAvailableForBlocks / this.blockDuration);
-  }
-}
-
-/**
- * Creates a checkpoint timing model.
- *
- * Most callers should use this factory and depend only on the shared
- * `CheckpointTiming` interface.
- */
-export function createCheckpointTimingModel(opts: CheckpointTimingConfig): CheckpointTiming {
-  return createPipelinedCheckpointTimingModel(opts);
-}
-
-/**
- * Creates a checkpoint timing model exposing the target-slot window accessors.
- *
- * Use this when the caller specifically needs the pipelined timing surface, such
- * as proposal or attestation acceptance windows into the target slot.
- */
-export function createPipelinedCheckpointTimingModel(opts: CheckpointTimingConfig): PipelinedCheckpointTiming {
-  validateCheckpointTimingConfig(opts);
-  const normalizedOpts = normalizeCheckpointTimingConfig(opts);
-
-  const timing = new CheckpointTimingModel(normalizedOpts);
-  validateCheckpointTimingModel(timing);
-  return timing;
-}
-
-/**
- * Calculates the maximum number of blocks that can be built in a slot.
- * Used by both the sequencer timetable and p2p gossipsub scoring.
- *
- * @param aztecSlotDurationSec - Aztec slot duration in seconds
- * @param blockDurationSec - Duration per block in seconds (undefined = single block mode)
- * @param opts - Optional overrides for timing constants
- * @returns Maximum number of blocks per slot
- */
-export function calculateMaxBlocksPerSlot(
-  aztecSlotDurationSec: number,
-  blockDurationSec: number | undefined,
-  opts: {
-    checkpointInitializationTime?: number;
-    checkpointAssembleTime?: number;
-    p2pPropagationTime?: number;
-    l1PublishingTime?: number;
-  } = {},
-): number {
-  return createCheckpointTimingModel({
-    aztecSlotDuration: aztecSlotDurationSec,
-    blockDuration: blockDurationSec,
-    checkpointAssembleTime: opts.checkpointAssembleTime,
-    checkpointInitializationTime: opts.checkpointInitializationTime,
-    l1PublishingTime: opts.l1PublishingTime,
-    p2pPropagationTime: opts.p2pPropagationTime,
-  }).calculateMaxBlocksPerSlot();
-}
-
-function assertNonNegative(name: string, value: number): void {
-  if (value < 0) {
-    throw new Error(`${name} must be non-negative (got ${value})`);
-  }
-}
-
-function validateCheckpointTimingConfig(opts: CheckpointTimingConfig): void {
-  if (opts.aztecSlotDuration <= 0) {
-    throw new Error(`aztecSlotDuration must be positive (got ${opts.aztecSlotDuration})`);
-  }
-
-  if (opts.ethereumSlotDuration !== undefined && opts.ethereumSlotDuration <= 0) {
-    throw new Error(`ethereumSlotDuration must be positive when provided (got ${opts.ethereumSlotDuration})`);
-  }
-
-  if (opts.blockDuration !== undefined && opts.blockDuration <= 0) {
-    throw new Error(`blockDuration must be positive when provided (got ${opts.blockDuration})`);
-  }
-
-  if (opts.minExecutionTime !== undefined && opts.minExecutionTime <= 0) {
-    throw new Error(`minExecutionTime must be positive when provided (got ${opts.minExecutionTime})`);
-  }
-
-  if (opts.checkpointAssembleTime !== undefined) {
-    assertNonNegative('checkpointAssembleTime', opts.checkpointAssembleTime);
-  }
-  if (opts.checkpointInitializationTime !== undefined) {
-    assertNonNegative('checkpointInitializationTime', opts.checkpointInitializationTime);
-  }
-  if (opts.l1PublishingTime !== undefined) {
-    assertNonNegative('l1PublishingTime', opts.l1PublishingTime);
-  }
-  if (opts.p2pPropagationTime !== undefined) {
-    assertNonNegative('p2pPropagationTime', opts.p2pPropagationTime);
-  }
-}
-
-function normalizeCheckpointTimingConfig(opts: CheckpointTimingConfig): CheckpointTimingConfig {
-  let checkpointAssembleTime = opts.checkpointAssembleTime ?? CHECKPOINT_ASSEMBLE_TIME;
-  let checkpointInitializationTime = opts.checkpointInitializationTime ?? CHECKPOINT_INITIALIZATION_TIME;
-  let minExecutionTime = opts.minExecutionTime ?? MIN_EXECUTION_TIME;
-  let p2pPropagationTime = opts.p2pPropagationTime ?? DEFAULT_P2P_PROPAGATION_TIME;
-
-  if (opts.ethereumSlotDuration !== undefined && opts.ethereumSlotDuration < 8) {
-    p2pPropagationTime = 0;
-    checkpointAssembleTime = 0.5;
-    checkpointInitializationTime = 0.5;
-    minExecutionTime = 1;
-  }
-
-  if (opts.blockDuration !== undefined && minExecutionTime > opts.blockDuration) {
-    minExecutionTime = opts.blockDuration;
-  }
-
-  return {
-    ...opts,
-    checkpointAssembleTime,
-    checkpointInitializationTime,
-    minExecutionTime,
-    p2pPropagationTime,
-  };
-}
-
-function validateCheckpointTimingModel(model: CheckpointTiming): void {
-  if (model.blockDuration === undefined) {
-    return;
-  }
-
-  const timeAvailableForBlocks = model.aztecSlotDuration - model.checkpointInitializationTime - model.timeReservedAtEnd;
-  if (timeAvailableForBlocks < model.blockDuration) {
-    throw new Error(
-      `Invalid timing configuration: only ${timeAvailableForBlocks}s available for block building, which is less than one blockDuration (${model.blockDuration}s).`,
-    );
-  }
-}
+export * from './budgets.js';
+export * from './build_proposer_timetable.js';
+export * from './consensus_timetable.js';
+export * from './proposer_timetable.js';