@aztec/sequencer-client 0.0.1-commit.2ed92850 → 0.0.1-commit.3100065

package/dest/sequencer/timetable.js

@@ -1,226 +0,0 @@
-import { createLogger } from '@aztec/aztec.js/log';
-import { DEFAULT_ATTESTATION_PROPAGATION_TIME as DEFAULT_P2P_PROPAGATION_TIME } from '../config.js';
-import { SequencerTooSlowError } from './errors.js';
-import { SequencerState } from './utils.js';
-export const MIN_EXECUTION_TIME = 2;
-export const CHECKPOINT_INITIALIZATION_TIME = 1;
-export const CHECKPOINT_ASSEMBLE_TIME = 1;
-export class SequencerTimetable {
-    metrics;
-    log;
-    /**
-   * How late into the slot can we be to start working. Computed as the total time needed for assembling and publishing a block,
-   * assuming an execution time equal to `minExecutionTime`, subtracted from the slot duration. This means that, if the proposer
-   * starts building at this time, and all times hold, it will have at least `minExecutionTime` to execute txs for the block.
-   */ initializeDeadline;
-    /**
-   * Fixed time offset (in seconds) when the first sub-slot starts, used as baseline for all block deadlines.
-   * This is an estimate of how long initialization (sync + proposer check) typically takes.
-   * If actual initialization takes longer/shorter, blocks just get less/more time accordingly.
-   */ initializationOffset;
-    /**
-   * Total time needed to finalize and publish a checkpoint, including:
-   * - Assembling the checkpoint
-   * - Round-trip p2p propagation for the checkpoint proposal and its corresponding attestations
-   * - Publishing to L1
-   */ checkpointFinalizationTime;
-    /**
-   * How long it takes to get a published block into L1. L1 builders typically accept txs up to 4 seconds into their slot,
-   * but we'll timeout sooner to give it more time to propagate (remember we also have blobs!). Still, when working in anvil,
-   * we can just post in the very last second of the L1 slot and still expect the tx to be accepted.
-   */ l1PublishingTime;
-    /**
-   * What's the minimum time we want to leave available for execution and reexecution (used to derive init deadline)
-   * Defaults to half of the block duration if set, otherwise a constant.
-   */ minExecutionTime;
-    /** How long it takes to get ready to start building */ checkpointInitializationTime;
-    /** How long it takes to for proposals and attestations to travel across the p2p layer (one-way) */ p2pPropagationTime;
-    /** How much time we spend assembling a checkpoint after building the last block */ checkpointAssembleTime;
-    /** Ethereum slot duration in seconds */ ethereumSlotDuration;
-    /** Aztec slot duration in seconds (must be multiple of ethereum slot duration) */ aztecSlotDuration;
-    /** Whether assertTimeLeft will throw if not enough time. */ enforce;
-    /** Duration per block when building multiple blocks per slot (undefined = single block per slot) */ blockDuration;
-    /** Maximum number of blocks that can be built in this slot configuration */ maxNumberOfBlocks;
-    constructor(opts, metrics, log = createLogger('sequencer:timetable')){
-        this.metrics = metrics;
-        this.log = log;
-        this.minExecutionTime = MIN_EXECUTION_TIME;
-        this.checkpointInitializationTime = CHECKPOINT_INITIALIZATION_TIME;
-        this.checkpointAssembleTime = CHECKPOINT_ASSEMBLE_TIME;
-        this.ethereumSlotDuration = opts.ethereumSlotDuration;
-        this.aztecSlotDuration = opts.aztecSlotDuration;
-        this.l1PublishingTime = opts.l1PublishingTime;
-        this.p2pPropagationTime = opts.p2pPropagationTime ?? DEFAULT_P2P_PROPAGATION_TIME;
-        this.blockDuration = opts.blockDurationMs ? opts.blockDurationMs / 1000 : undefined;
-        this.enforce = opts.enforce;
-        // Assume zero-cost propagation time and faster runs in test environments where L1 slot duration is shortened
-        if (this.ethereumSlotDuration < 8) {
-            this.p2pPropagationTime = 0;
-            this.checkpointAssembleTime = 0.5;
-            this.checkpointInitializationTime = 0.5;
-            this.minExecutionTime = 1;
-        }
-        // Min execution time cannot be less than the block duration if set
-        if (this.blockDuration !== undefined && this.minExecutionTime > this.blockDuration) {
-            this.minExecutionTime = this.blockDuration;
-        }
-        // Calculate initialization offset - estimate of time needed for sync + proposer check
-        // This is the baseline for all sub-slot deadlines
-        this.initializationOffset = this.checkpointInitializationTime;
-        // Calculate total checkpoint finalization time (assembly + attestations + L1 publishing)
-        this.checkpointFinalizationTime = this.checkpointAssembleTime + this.p2pPropagationTime * 2 + // Round-trip propagation
-        this.l1PublishingTime; // L1 publishing
-        // Calculate maximum number of blocks that fit in this slot
-        if (!this.blockDuration) {
-            this.maxNumberOfBlocks = 1; // Single block per slot
-        } else {
-            const timeReservedAtEnd = this.blockDuration + // Last sub-slot for validator re-execution
-            this.checkpointFinalizationTime; // Checkpoint finalization
-            const timeAvailableForBlocks = this.aztecSlotDuration - this.initializationOffset - timeReservedAtEnd;
-            this.maxNumberOfBlocks = Math.floor(timeAvailableForBlocks / this.blockDuration);
-        }
-        // Minimum work to do within a slot for building a block with the minimum time for execution and publishing its checkpoint
-        const minWorkToDo = this.initializationOffset + this.minExecutionTime * 2 + // Execution and reexecution
-        this.checkpointFinalizationTime;
-        const initializeDeadline = this.aztecSlotDuration - minWorkToDo;
-        this.initializeDeadline = initializeDeadline;
-        this.log.verbose(`Sequencer timetable initialized with ${this.maxNumberOfBlocks} blocks per slot (${this.enforce ? 'enforced' : 'not enforced'})`, {
-            ethereumSlotDuration: this.ethereumSlotDuration,
-            aztecSlotDuration: this.aztecSlotDuration,
-            l1PublishingTime: this.l1PublishingTime,
-            minExecutionTime: this.minExecutionTime,
-            blockPrepareTime: this.checkpointInitializationTime,
-            p2pPropagationTime: this.p2pPropagationTime,
-            blockAssembleTime: this.checkpointAssembleTime,
-            initializeDeadline: this.initializeDeadline,
-            enforce: this.enforce,
-            minWorkToDo,
-            blockDuration: this.blockDuration,
-            maxNumberOfBlocks: this.maxNumberOfBlocks
-        });
-        if (initializeDeadline <= 0) {
-            throw new Error(`Block proposal initialize deadline cannot be negative (got ${initializeDeadline} from total time needed ${minWorkToDo} and a slot duration of ${this.aztecSlotDuration}).`);
-        }
-    }
-    getMaxAllowedTime(state) {
-        switch(state){
-            case SequencerState.STOPPED:
-            case SequencerState.STOPPING:
-            case SequencerState.IDLE:
-            case SequencerState.SYNCHRONIZING:
-                return; // We don't really care about times for this states
-            case SequencerState.PROPOSER_CHECK:
-            case SequencerState.INITIALIZING_CHECKPOINT:
-                return this.initializeDeadline;
-            case SequencerState.WAITING_FOR_TXS:
-            case SequencerState.CREATING_BLOCK:
-            case SequencerState.WAITING_UNTIL_NEXT_BLOCK:
-                return this.initializeDeadline + this.checkpointInitializationTime;
-            case SequencerState.ASSEMBLING_CHECKPOINT:
-            case SequencerState.COLLECTING_ATTESTATIONS:
-                return this.aztecSlotDuration - this.l1PublishingTime - 2 * this.p2pPropagationTime;
-            case SequencerState.PUBLISHING_CHECKPOINT:
-                return this.aztecSlotDuration - this.l1PublishingTime;
-            default:
-                {
-                    const _exhaustiveCheck = state;
-                    throw new Error(`Unexpected state: ${state}`);
-                }
-        }
-    }
-    assertTimeLeft(newState, secondsIntoSlot) {
-        if (!this.enforce) {
-            return;
-        }
-        const maxAllowedTime = this.getMaxAllowedTime(newState);
-        if (maxAllowedTime === undefined) {
-            return;
-        }
-        const bufferSeconds = maxAllowedTime - secondsIntoSlot;
-        if (bufferSeconds < 0) {
-            throw new SequencerTooSlowError(newState, maxAllowedTime, secondsIntoSlot);
-        }
-        this.metrics?.recordStateTransitionBufferMs(Math.floor(bufferSeconds * 1000), newState);
-        this.log.trace(`Enough time to transition to ${newState}`, {
-            maxAllowedTime,
-            secondsIntoSlot
-        });
-    }
-    /**
-   * Determines if we can start building the next block and returns its deadline.
-   *
-   * The timetable divides the slot into fixed sub-slots. This method finds the next
-   * available sub-slot that has enough time remaining to build a block.
-   *
-   * @param secondsIntoSlot - Current time (seconds into the slot)
-   * @returns Object with canStart flag, deadline, and whether this is the last block
-   */ canStartNextBlock(secondsIntoSlot) {
-        // When timetable enforcement is disabled, always allow starting,
-        // and build a single block with no deadline. This is here just to
-        // satisfy a subset of e2e tests and the sandbox that assume that the
-        // sequencer is permanently mining every tx sent.
-        if (!this.enforce) {
-            return {
-                canStart: true,
-                deadline: undefined,
-                isLastBlock: true
-            };
-        }
-        // If no block duration is set, then we're in single-block mode, which
-        // is handled for backwards compatibility towards another subset of e2e tests.
-        if (this.blockDuration === undefined) {
-            // In single block mode, execution and re-execution happen sequentially, so we need to
-            // split the available time between them. After building, we need time for attestations and L1.
-            const maxAllowed = this.aztecSlotDuration - this.checkpointFinalizationTime;
-            const available = (maxAllowed - secondsIntoSlot) / 2; // Split remaining time: half for execution, half for re-execution
-            const canStart = available >= this.minExecutionTime;
-            const deadline = secondsIntoSlot + available;
-            this.log.verbose(`${canStart ? 'Can' : 'Cannot'} start single-block checkpoint at ${secondsIntoSlot}s into slot`, {
-                secondsIntoSlot,
-                maxAllowed,
-                available,
-                deadline
-            });
-            return {
-                canStart,
-                deadline,
-                isLastBlock: true
-            };
-        }
-        // Otherwise, we're in multi-block-per-slot mode, the default when running in production
-        // Find the next available sub-slot that has enough time remaining
-        for(let subSlot = 1; subSlot <= this.maxNumberOfBlocks; subSlot++){
-            // Calculate end for this sub-slot
-            const deadline = this.initializationOffset + subSlot * this.blockDuration;
-            // Check if we have enough time to build a block with this deadline
-            const timeUntilDeadline = deadline - secondsIntoSlot;
-            if (timeUntilDeadline >= this.minExecutionTime) {
-                // Found an available sub-slot! Is this the last one?
-                const isLastBlock = subSlot === this.maxNumberOfBlocks;
-                this.log.verbose(`Can start ${isLastBlock ? 'last block' : 'block'} in sub-slot ${subSlot} with deadline ${deadline}s`, {
-                    secondsIntoSlot,
-                    deadline,
-                    timeUntilDeadline,
-                    subSlot,
-                    maxBlocks: this.maxNumberOfBlocks
-                });
-                return {
-                    canStart: true,
-                    deadline,
-                    isLastBlock
-                };
-            }
-        }
-        // No sub-slots available with enough time
-        this.log.verbose(`No time left to start any more blocks`, {
-            secondsIntoSlot,
-            maxBlocks: this.maxNumberOfBlocks,
-            initializationOffset: this.initializationOffset
-        });
-        return {
-            canStart: false,
-            deadline: undefined,
-            isLastBlock: false
-        };
-    }
-}