@aztec/sequencer-client 0.0.0-test.0

package/dest/sequencer/sequencer.js

@@ -0,0 +1,623 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { omit } from '@aztec/foundation/collection';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { Timer, elapsed } from '@aztec/foundation/timer';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { Gas } from '@aztec/stdlib/gas';
+import { SequencerConfigSchema } from '@aztec/stdlib/interfaces/server';
+import { pickFromSchema } from '@aztec/stdlib/schemas';
+import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
+import { BlockHeader, ContentCommitment, StateReference, Tx } from '@aztec/stdlib/tx';
+import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
+import { VoteType } from '../publisher/sequencer-publisher.js';
+import { createValidatorsForBlockBuilding } from '../tx_validator/tx_validator_factory.js';
+import { getDefaultAllowedSetupFunctions } from './allowed.js';
+import { SequencerMetrics } from './metrics.js';
+import { SequencerTimetable, SequencerTooSlowError } from './timetable.js';
+import { SequencerState, orderAttestations } from './utils.js';
+export { SequencerState };
+/**
+ * Sequencer client
+ * - Wins a period of time to become the sequencer (depending on finalized protocol).
+ * - Chooses a set of txs from the tx pool to be in the rollup.
+ * - Simulate the rollup of txs.
+ * - Adds proof requests to the request pool (not for this milestone).
+ * - Receives results to those proofs from the network (repeats as necessary) (not for this milestone).
+ * - Publishes L1 tx(s) to the rollup contract via RollupPublisher.
+ */ export class Sequencer {
+    publisher;
+    validatorClient;
+    globalsBuilder;
+    p2pClient;
+    worldState;
+    slasherClient;
+    blockBuilderFactory;
+    l2BlockSource;
+    l1ToL2MessageSource;
+    publicProcessorFactory;
+    contractDataSource;
+    l1Constants;
+    dateProvider;
+    config;
+    log;
+    runningPromise;
+    pollingIntervalMs;
+    maxTxsPerBlock;
+    minTxsPerBlock;
+    maxL1TxInclusionTimeIntoSlot;
+    // TODO: zero values should not be allowed for the following 2 values in PROD
+    _coinbase;
+    _feeRecipient;
+    state;
+    allowedInSetup;
+    maxBlockSizeInBytes;
+    maxBlockGas;
+    metrics;
+    isFlushing;
+    /** The maximum number of seconds that the sequencer can be into a slot to transition to a particular state. */ timetable;
+    enforceTimeTable;
+    constructor(publisher, validatorClient, globalsBuilder, p2pClient, worldState, slasherClient, blockBuilderFactory, l2BlockSource, l1ToL2MessageSource, publicProcessorFactory, contractDataSource, l1Constants, dateProvider, config = {}, telemetry = getTelemetryClient(), log = createLogger('sequencer')){
+        this.publisher = publisher;
+        this.validatorClient = validatorClient;
+        this.globalsBuilder = globalsBuilder;
+        this.p2pClient = p2pClient;
+        this.worldState = worldState;
+        this.slasherClient = slasherClient;
+        this.blockBuilderFactory = blockBuilderFactory;
+        this.l2BlockSource = l2BlockSource;
+        this.l1ToL2MessageSource = l1ToL2MessageSource;
+        this.publicProcessorFactory = publicProcessorFactory;
+        this.contractDataSource = contractDataSource;
+        this.l1Constants = l1Constants;
+        this.dateProvider = dateProvider;
+        this.config = config;
+        this.log = log;
+        this.pollingIntervalMs = 1000;
+        this.maxTxsPerBlock = 32;
+        this.minTxsPerBlock = 1;
+        this.maxL1TxInclusionTimeIntoSlot = 0;
+        this._coinbase = EthAddress.ZERO;
+        this._feeRecipient = AztecAddress.ZERO;
+        this.state = SequencerState.STOPPED;
+        this.allowedInSetup = [];
+        this.maxBlockSizeInBytes = 1024 * 1024;
+        this.maxBlockGas = new Gas(100e9, 100e9);
+        this.isFlushing = false;
+        this.enforceTimeTable = false;
+        this.metrics = new SequencerMetrics(telemetry, ()=>this.state, 'Sequencer');
+        // Register the block builder with the validator client for re-execution
+        this.validatorClient?.registerBlockBuilder(this.buildBlock.bind(this));
+        // Register the slasher on the publisher to fetch slashing payloads
+        this.publisher.registerSlashPayloadGetter(this.slasherClient.getSlashPayload.bind(this.slasherClient));
+    }
+    get tracer() {
+        return this.metrics.tracer;
+    }
+    /**
+   * Updates sequencer config.
+   * @param config - New parameters.
+   */ async updateConfig(config) {
+        this.log.info(`Sequencer config set`, omit(pickFromSchema(config, SequencerConfigSchema), 'allowedInSetup'));
+        if (config.transactionPollingIntervalMS !== undefined) {
+            this.pollingIntervalMs = config.transactionPollingIntervalMS;
+        }
+        if (config.maxTxsPerBlock !== undefined) {
+            this.maxTxsPerBlock = config.maxTxsPerBlock;
+        }
+        if (config.minTxsPerBlock !== undefined) {
+            this.minTxsPerBlock = config.minTxsPerBlock;
+        }
+        if (config.maxDABlockGas !== undefined) {
+            this.maxBlockGas = new Gas(config.maxDABlockGas, this.maxBlockGas.l2Gas);
+        }
+        if (config.maxL2BlockGas !== undefined) {
+            this.maxBlockGas = new Gas(this.maxBlockGas.daGas, config.maxL2BlockGas);
+        }
+        if (config.coinbase) {
+            this._coinbase = config.coinbase;
+        }
+        if (config.feeRecipient) {
+            this._feeRecipient = config.feeRecipient;
+        }
+        if (config.allowedInSetup) {
+            this.allowedInSetup = config.allowedInSetup;
+        } else {
+            this.allowedInSetup = await getDefaultAllowedSetupFunctions();
+        }
+        if (config.maxBlockSizeInBytes !== undefined) {
+            this.maxBlockSizeInBytes = config.maxBlockSizeInBytes;
+        }
+        if (config.governanceProposerPayload) {
+            this.publisher.setGovernancePayload(config.governanceProposerPayload);
+        }
+        if (config.maxL1TxInclusionTimeIntoSlot !== undefined) {
+            this.maxL1TxInclusionTimeIntoSlot = config.maxL1TxInclusionTimeIntoSlot;
+        }
+        if (config.enforceTimeTable !== undefined) {
+            this.enforceTimeTable = config.enforceTimeTable;
+        }
+        this.setTimeTable();
+        // TODO: Just read everything from the config object as needed instead of copying everything into local vars.
+        this.config = config;
+    }
+    setTimeTable() {
+        this.timetable = new SequencerTimetable(this.l1Constants.ethereumSlotDuration, this.aztecSlotDuration, this.maxL1TxInclusionTimeIntoSlot, this.enforceTimeTable, this.metrics, this.log);
+        this.log.verbose(`Sequencer timetable updated`, {
+            enforceTimeTable: this.enforceTimeTable
+        });
+    }
+    /**
+   * Starts the sequencer and moves to IDLE state.
+   */ async start() {
+        await this.updateConfig(this.config);
+        this.runningPromise = new RunningPromise(this.work.bind(this), this.log, this.pollingIntervalMs);
+        this.setState(SequencerState.IDLE, 0n, true);
+        this.runningPromise.start();
+        this.log.info(`Sequencer started with address ${this.publisher.getSenderAddress().toString()}`);
+    }
+    /**
+   * Stops the sequencer from processing txs and moves to STOPPED state.
+   */ async stop() {
+        this.log.debug(`Stopping sequencer`);
+        await this.validatorClient?.stop();
+        await this.runningPromise?.stop();
+        this.slasherClient.stop();
+        this.publisher.interrupt();
+        this.setState(SequencerState.STOPPED, 0n, true);
+        this.log.info('Stopped sequencer');
+    }
+    /**
+   * Starts a previously stopped sequencer.
+   */ restart() {
+        this.log.info('Restarting sequencer');
+        this.publisher.restart();
+        this.runningPromise.start();
+        this.setState(SequencerState.IDLE, 0n, true);
+    }
+    /**
+   * Returns the current state of the sequencer.
+   * @returns An object with a state entry with one of SequencerState.
+   */ status() {
+        return {
+            state: this.state
+        };
+    }
+    /** Forces the sequencer to bypass all time and tx count checks for the next block and build anyway. */ flush() {
+        this.isFlushing = true;
+    }
+    /**
+   * @notice  Performs most of the sequencer duties:
+   *          - Checks if we are up to date
+   *          - If we are and we are the sequencer, collect txs and build a block
+   *          - Collect attestations for the block
+   *          - Submit block
+   *          - If our block for some reason is not included, revert the state
+   */ async doRealWork() {
+        this.setState(SequencerState.SYNCHRONIZING, 0n);
+        // Update state when the previous block has been synced
+        const chainTip = await this.getChainTip();
+        // Do not go forward with new block if the previous one has not been mined and processed
+        if (!chainTip) {
+            return;
+        }
+        this.setState(SequencerState.PROPOSER_CHECK, 0n);
+        const newBlockNumber = chainTip.blockNumber + 1;
+        // If we cannot find a tip archive, assume genesis.
+        const chainTipArchive = chainTip.archive;
+        const slot = await this.slotForProposal(chainTipArchive.toBuffer(), BigInt(newBlockNumber));
+        if (!slot) {
+            this.log.debug(`Cannot propose block ${newBlockNumber}`);
+            return;
+        }
+        this.log.debug(`Can propose block ${newBlockNumber} at slot ${slot}`);
+        const newGlobalVariables = await this.globalsBuilder.buildGlobalVariables(new Fr(newBlockNumber), this._coinbase, this._feeRecipient, slot);
+        const enqueueGovernanceVotePromise = this.publisher.enqueueCastVote(slot, newGlobalVariables.timestamp.toBigInt(), VoteType.GOVERNANCE);
+        const enqueueSlashingVotePromise = this.publisher.enqueueCastVote(slot, newGlobalVariables.timestamp.toBigInt(), VoteType.SLASHING);
+        this.setState(SequencerState.INITIALIZING_PROPOSAL, slot);
+        this.log.verbose(`Preparing proposal for block ${newBlockNumber} at slot ${slot}`, {
+            chainTipArchive,
+            blockNumber: newBlockNumber,
+            slot
+        });
+        // If I created a "partial" header here that should make our job much easier.
+        const proposalHeader = new BlockHeader(new AppendOnlyTreeSnapshot(chainTipArchive, 1), ContentCommitment.empty(), StateReference.empty(), newGlobalVariables, Fr.ZERO, Fr.ZERO);
+        let finishedFlushing = false;
+        const pendingTxCount = await this.p2pClient.getPendingTxCount();
+        if (pendingTxCount >= this.minTxsPerBlock || this.isFlushing) {
+            // We don't fetch exactly maxTxsPerBlock txs here because we may not need all of them if we hit a limit before,
+            // and also we may need to fetch more if we don't have enough valid txs.
+            const pendingTxs = this.p2pClient.iteratePendingTxs();
+            await this.buildBlockAndEnqueuePublish(pendingTxs, proposalHeader).catch((err)=>{
+                this.log.error(`Error building/enqueuing block`, err, {
+                    blockNumber: newBlockNumber,
+                    slot
+                });
+            });
+            finishedFlushing = true;
+        } else {
+            this.log.debug(`Not enough txs to build block ${newBlockNumber} at slot ${slot}: got ${pendingTxCount} txs, need ${this.minTxsPerBlock}`);
+        }
+        await enqueueGovernanceVotePromise.catch((err)=>{
+            this.log.error(`Error enqueuing governance vote`, err, {
+                blockNumber: newBlockNumber,
+                slot
+            });
+        });
+        await enqueueSlashingVotePromise.catch((err)=>{
+            this.log.error(`Error enqueuing slashing vote`, err, {
+                blockNumber: newBlockNumber,
+                slot
+            });
+        });
+        await this.publisher.sendRequests();
+        if (finishedFlushing) {
+            this.isFlushing = false;
+        }
+        this.setState(SequencerState.IDLE, 0n);
+    }
+    async work() {
+        try {
+            await this.doRealWork();
+        } catch (err) {
+            if (err instanceof SequencerTooSlowError) {
+                this.log.warn(err.message);
+            } else {
+                // Re-throw other errors
+                throw err;
+            }
+        } finally{
+            this.setState(SequencerState.IDLE, 0n);
+        }
+    }
+    getForwarderAddress() {
+        return this.publisher.getForwarderAddress();
+    }
+    /**
+   * Checks if we can propose at the next block and returns the slot number if we can.
+   * @param tipArchive - The archive of the previous block.
+   * @param proposalBlockNumber - The block number of the proposal.
+   * @returns The slot number if we can propose at the next block, otherwise undefined.
+   */ async slotForProposal(tipArchive, proposalBlockNumber) {
+        const result = await this.publisher.canProposeAtNextEthBlock(tipArchive);
+        if (!result) {
+            return undefined;
+        }
+        const [slot, blockNumber] = result;
+        if (proposalBlockNumber !== blockNumber) {
+            const msg = `Sequencer block number mismatch. Expected ${proposalBlockNumber} but got ${blockNumber}.`;
+            this.log.warn(msg);
+            throw new Error(msg);
+        }
+        return slot;
+    }
+    /**
+   * Sets the sequencer state and checks if we have enough time left in the slot to transition to the new state.
+   * @param proposedState - The new state to transition to.
+   * @param currentSlotNumber - The current slot number.
+   * @param force - Whether to force the transition even if the sequencer is stopped.
+   *
+   * @dev If the `currentSlotNumber` doesn't matter (e.g. transitioning to IDLE), pass in `0n`;
+   * it is only used to check if we have enough time left in the slot to transition to the new state.
+   */ setState(proposedState, currentSlotNumber, force = false) {
+        if (this.state === SequencerState.STOPPED && force !== true) {
+            this.log.warn(`Cannot set sequencer from ${this.state} to ${proposedState} as it is stopped.`);
+            return;
+        }
+        const secondsIntoSlot = this.getSecondsIntoSlot(currentSlotNumber);
+        this.timetable.assertTimeLeft(proposedState, secondsIntoSlot);
+        this.log.debug(`Transitioning from ${this.state} to ${proposedState}`);
+        this.state = proposedState;
+    }
+    /**
+   * Build a block
+   *
+   * Shared between the sequencer and the validator for re-execution
+   *
+   * @param pendingTxs - The pending transactions to construct the block from
+   * @param newGlobalVariables - The global variables for the new block
+   * @param historicalHeader - The historical header of the parent
+   * @param opts - Whether to just validate the block as a validator, as opposed to building it as a proposal
+   */ async buildBlock(pendingTxs, newGlobalVariables, opts = {}) {
+        const blockNumber = newGlobalVariables.blockNumber.toNumber();
+        const slot = newGlobalVariables.slotNumber.toBigInt();
+        this.log.debug(`Requesting L1 to L2 messages from contract for block ${blockNumber}`);
+        const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(BigInt(blockNumber));
+        const msgCount = l1ToL2Messages.length;
+        this.log.verbose(`Building block ${blockNumber} for slot ${slot}`, {
+            slot,
+            blockNumber,
+            msgCount,
+            validator: opts.validateOnly
+        });
+        // Sync to the previous block at least
+        await this.worldState.syncImmediate(blockNumber - 1);
+        this.log.debug(`Synced to previous block ${blockNumber - 1}`);
+        // NB: separating the dbs because both should update the state
+        const publicProcessorFork = await this.worldState.fork();
+        const orchestratorFork = await this.worldState.fork();
+        const previousBlockHeader = (await this.l2BlockSource.getBlock(blockNumber - 1))?.header ?? orchestratorFork.getInitialHeader();
+        try {
+            const processor = this.publicProcessorFactory.create(publicProcessorFork, newGlobalVariables, true);
+            const blockBuildingTimer = new Timer();
+            const blockBuilder = this.blockBuilderFactory.create(orchestratorFork);
+            await blockBuilder.startNewBlock(newGlobalVariables, l1ToL2Messages, previousBlockHeader);
+            // Deadline for processing depends on whether we're proposing a block
+            const secondsIntoSlot = this.getSecondsIntoSlot(slot);
+            const processingEndTimeWithinSlot = opts.validateOnly ? this.timetable.getValidatorReexecTimeEnd(secondsIntoSlot) : this.timetable.getBlockProposalExecTimeEnd(secondsIntoSlot);
+            // Deadline is only set if enforceTimeTable is enabled.
+            const deadline = this.enforceTimeTable ? new Date((this.getSlotStartTimestamp(slot) + processingEndTimeWithinSlot) * 1000) : undefined;
+            this.log.verbose(`Processing pending txs`, {
+                slot,
+                slotStart: new Date(this.getSlotStartTimestamp(slot) * 1000),
+                now: new Date(this.dateProvider.now()),
+                deadline
+            });
+            const validators = createValidatorsForBlockBuilding(publicProcessorFork, this.contractDataSource, newGlobalVariables, this.allowedInSetup);
+            // TODO(#11000): Public processor should just handle processing, one tx at a time. It should be responsibility
+            // of the sequencer to update world state and iterate over txs. We should refactor this along with unifying the
+            // publicProcessorFork and orchestratorFork, to avoid doing tree insertions twice when building the block.
+            const proposerLimits = {
+                maxTransactions: this.maxTxsPerBlock,
+                maxBlockSize: this.maxBlockSizeInBytes,
+                maxBlockGas: this.maxBlockGas
+            };
+            const limits = opts.validateOnly ? {
+                deadline
+            } : {
+                deadline,
+                ...proposerLimits
+            };
+            const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(()=>processor.process(pendingTxs, limits, validators));
+            if (!opts.validateOnly && failedTxs.length > 0) {
+                const failedTxData = failedTxs.map((fail)=>fail.tx);
+                const failedTxHashes = await Tx.getHashes(failedTxData);
+                this.log.verbose(`Dropping failed txs ${failedTxHashes.join(', ')}`);
+                await this.p2pClient.deleteTxs(failedTxHashes);
+            }
+            if (!opts.validateOnly && // We check for minTxCount only if we are proposing a block, not if we are validating it
+            !this.isFlushing && // And we skip the check when flushing, since we want all pending txs to go out, no matter if too few
+            this.minTxsPerBlock !== undefined && processedTxs.length < this.minTxsPerBlock) {
+                this.log.warn(`Block ${blockNumber} has too few txs to be proposed (got ${processedTxs.length} but required ${this.minTxsPerBlock})`, {
+                    slot,
+                    blockNumber,
+                    processedTxCount: processedTxs.length
+                });
+                throw new Error(`Block has too few successful txs to be proposed`);
+            }
+            const start = process.hrtime.bigint();
+            await blockBuilder.addTxs(processedTxs);
+            const end = process.hrtime.bigint();
+            const duration = Number(end - start) / 1_000;
+            this.metrics.recordBlockBuilderTreeInsertions(duration);
+            // All real transactions have been added, set the block as full and pad if needed
+            const block = await blockBuilder.setBlockCompleted();
+            // How much public gas was processed
+            const publicGas = processedTxs.reduce((acc, tx)=>acc.add(tx.gasUsed.publicGas), Gas.empty());
+            return {
+                block,
+                publicGas,
+                publicProcessorDuration,
+                numMsgs: l1ToL2Messages.length,
+                numTxs: processedTxs.length,
+                numFailedTxs: failedTxs.length,
+                blockBuildingTimer
+            };
+        } finally{
+            // We create a fresh processor each time to reset any cached state (eg storage writes)
+            // We wait a bit to close the forks since the processor may still be working on a dangling tx
+            // which was interrupted due to the processingDeadline being hit.
+            // eslint-disable-next-line @typescript-eslint/no-misused-promises
+            setTimeout(async ()=>{
+                try {
+                    await publicProcessorFork.close();
+                    await orchestratorFork.close();
+                } catch (err) {
+                    // This can happen if the sequencer is stopped before we hit this timeout.
+                    this.log.warn(`Error closing forks for block processing`, err);
+                }
+            }, 5000);
+        }
+    }
+    /**
+   * @notice  Build and propose a block to the chain
+   *
+   * @dev     MUST throw instead of exiting early to ensure that world-state
+   *          is being rolled back if the block is dropped.
+   *
+   * @param pendingTxs - Iterable of pending transactions to construct the block from
+   * @param proposalHeader - The partial header constructed for the proposal
+   */ async buildBlockAndEnqueuePublish(pendingTxs, proposalHeader) {
+        await this.publisher.validateBlockForSubmission(proposalHeader);
+        const newGlobalVariables = proposalHeader.globalVariables;
+        const blockNumber = newGlobalVariables.blockNumber.toNumber();
+        const slot = newGlobalVariables.slotNumber.toBigInt();
+        // this.metrics.recordNewBlock(blockNumber, validTxs.length);
+        const workTimer = new Timer();
+        this.setState(SequencerState.CREATING_BLOCK, slot);
+        try {
+            const buildBlockRes = await this.buildBlock(pendingTxs, newGlobalVariables);
+            const { publicGas, block, publicProcessorDuration, numTxs, numMsgs, blockBuildingTimer } = buildBlockRes;
+            this.metrics.recordBuiltBlock(workTimer.ms(), publicGas.l2Gas);
+            // TODO(@PhilWindle) We should probably periodically check for things like another
+            // block being published before ours instead of just waiting on our block
+            await this.publisher.validateBlockForSubmission(block.header);
+            const blockStats = {
+                eventName: 'l2-block-built',
+                creator: this.publisher.getSenderAddress().toString(),
+                duration: workTimer.ms(),
+                publicProcessDuration: publicProcessorDuration,
+                rollupCircuitsDuration: blockBuildingTimer.ms(),
+                ...block.getStats()
+            };
+            const blockHash = await block.hash();
+            const txHashes = block.body.txEffects.map((tx)=>tx.txHash);
+            this.log.info(`Built block ${block.number} for slot ${slot} with ${numTxs} txs and ${numMsgs} messages. ${publicGas.l2Gas / workTimer.s()} mana/s`, {
+                blockHash,
+                globalVariables: block.header.globalVariables.toInspect(),
+                txHashes,
+                ...blockStats
+            });
+            this.log.debug('Collecting attestations');
+            const stopCollectingAttestationsTimer = this.metrics.startCollectingAttestationsTimer();
+            const attestations = await this.collectAttestations(block, txHashes);
+            if (attestations !== undefined) {
+                this.log.verbose(`Collected ${attestations.length} attestations`, {
+                    blockHash,
+                    blockNumber
+                });
+            }
+            stopCollectingAttestationsTimer();
+            return this.enqueuePublishL2Block(block, attestations, txHashes);
+        } catch (err) {
+            this.metrics.recordFailedBlock();
+            throw err;
+        }
+    }
+    async collectAttestations(block, txHashes) {
+        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/7962): inefficient to have a round trip in here - this should be cached
+        const committee = await this.publisher.getCurrentEpochCommittee();
+        if (committee.length === 0) {
+            this.log.verbose(`Attesting committee is empty`);
+            return undefined;
+        } else {
+            this.log.debug(`Attesting committee length is ${committee.length}`);
+        }
+        if (!this.validatorClient) {
+            const msg = 'Missing validator client: Cannot collect attestations';
+            this.log.error(msg);
+            throw new Error(msg);
+        }
+        const numberOfRequiredAttestations = Math.floor(committee.length * 2 / 3) + 1;
+        const slotNumber = block.header.globalVariables.slotNumber.toBigInt();
+        this.setState(SequencerState.COLLECTING_ATTESTATIONS, slotNumber);
+        this.log.debug('Creating block proposal for validators');
+        const proposal = await this.validatorClient.createBlockProposal(block.header, block.archive.root, txHashes);
+        if (!proposal) {
+            const msg = `Failed to create block proposal`;
+            throw new Error(msg);
+        }
+        this.log.debug('Broadcasting block proposal to validators');
+        this.validatorClient.broadcastBlockProposal(proposal);
+        const attestationTimeAllowed = this.enforceTimeTable ? this.timetable.getMaxAllowedTime(SequencerState.PUBLISHING_BLOCK) : this.aztecSlotDuration;
+        const attestationDeadline = new Date(this.dateProvider.now() + attestationTimeAllowed * 1000);
+        const attestations = await this.validatorClient.collectAttestations(proposal, numberOfRequiredAttestations, attestationDeadline);
+        // note: the smart contract requires that the signatures are provided in the order of the committee
+        return orderAttestations(attestations, committee);
+    }
+    /**
+   * Publishes the L2Block to the rollup contract.
+   * @param block - The L2Block to be published.
+   */ async enqueuePublishL2Block(block, attestations, txHashes) {
+        // Publishes new block to the network and awaits the tx to be mined
+        this.setState(SequencerState.PUBLISHING_BLOCK, block.header.globalVariables.slotNumber.toBigInt());
+        // Time out tx at the end of the slot
+        const slot = block.header.globalVariables.slotNumber.toNumber();
+        const txTimeoutAt = new Date((this.getSlotStartTimestamp(slot) + this.aztecSlotDuration) * 1000);
+        const enqueued = await this.publisher.enqueueProposeL2Block(block, attestations, txHashes, {
+            txTimeoutAt
+        });
+        if (!enqueued) {
+            throw new Error(`Failed to enqueue publish of block ${block.number}`);
+        }
+    }
+    /**
+   * Returns whether all dependencies have caught up.
+   * We don't check against the previous block submitted since it may have been reorg'd out.
+   * @returns Boolean indicating if our dependencies are synced to the latest block.
+   */ async getChainTip() {
+        const syncedBlocks = await Promise.all([
+            this.worldState.status().then((s)=>{
+                return {
+                    number: s.syncSummary.latestBlockNumber,
+                    hash: s.syncSummary.latestBlockHash
+                };
+            }),
+            this.l2BlockSource.getL2Tips().then((t)=>t.latest),
+            this.p2pClient.getStatus().then((p2p)=>p2p.syncedToL2Block),
+            this.l1ToL2MessageSource.getBlockNumber()
+        ]);
+        const [worldState, l2BlockSource, p2p, l1ToL2MessageSource] = syncedBlocks;
+        const result = // check that world state has caught up with archiver
+        // note that the archiver reports undefined hash for the genesis block
+        // because it doesn't have access to world state to compute it (facepalm)
+        (l2BlockSource.hash === undefined || worldState.hash === l2BlockSource.hash) && // and p2p client and message source are at least at the same block
+        // this should change to hashes once p2p client handles reorgs
+        // and once we stop pretending that the l1tol2message source is not
+        // just the archiver under a different name
+        (!l2BlockSource.hash || p2p.hash === l2BlockSource.hash) && l1ToL2MessageSource === l2BlockSource.number;
+        this.log.debug(`Sequencer sync check ${result ? 'succeeded' : 'failed'}`, {
+            worldStateNumber: worldState.number,
+            worldStateHash: worldState.hash,
+            l2BlockSourceNumber: l2BlockSource.number,
+            l2BlockSourceHash: l2BlockSource.hash,
+            p2pNumber: p2p.number,
+            p2pHash: p2p.hash,
+            l1ToL2MessageSourceNumber: l1ToL2MessageSource
+        });
+        if (!result) {
+            return undefined;
+        }
+        if (worldState.number >= INITIAL_L2_BLOCK_NUM) {
+            const block = await this.l2BlockSource.getBlock(worldState.number);
+            if (!block) {
+                // this shouldn't really happen because a moment ago we checked that all components were in synch
+                return undefined;
+            }
+            return {
+                blockNumber: block.number,
+                archive: block.archive.root
+            };
+        } else {
+            const archive = new Fr((await this.worldState.getCommitted().getTreeInfo(MerkleTreeId.ARCHIVE)).root);
+            return {
+                blockNumber: INITIAL_L2_BLOCK_NUM - 1,
+                archive
+            };
+        }
+    }
+    getSlotStartTimestamp(slotNumber) {
+        return Number(this.l1Constants.l1GenesisTime) + Number(slotNumber) * this.l1Constants.slotDuration;
+    }
+    getSecondsIntoSlot(slotNumber) {
+        const slotStartTimestamp = this.getSlotStartTimestamp(slotNumber);
+        return Number((this.dateProvider.now() / 1000 - slotStartTimestamp).toFixed(3));
+    }
+    get aztecSlotDuration() {
+        return this.l1Constants.slotDuration;
+    }
+    get coinbase() {
+        return this._coinbase;
+    }
+    get feeRecipient() {
+        return this._feeRecipient;
+    }
+}
+_ts_decorate([
+    trackSpan('Sequencer.work')
+], Sequencer.prototype, "work", null);
+_ts_decorate([
+    trackSpan('Sequencer.buildBlockAndEnqueuePublish', (_validTxs, proposalHeader)=>({
+            [Attributes.BLOCK_NUMBER]: proposalHeader.globalVariables.blockNumber.toNumber()
+        }))
+], Sequencer.prototype, "buildBlockAndEnqueuePublish", null);
+_ts_decorate([
+    trackSpan('Sequencer.collectAttestations', (block, txHashes)=>({
+            [Attributes.BLOCK_NUMBER]: block.number,
+            [Attributes.BLOCK_ARCHIVE]: block.archive.toString(),
+            [Attributes.BLOCK_TXS_COUNT]: txHashes.length
+        }))
+], Sequencer.prototype, "collectAttestations", null);
+_ts_decorate([
+    trackSpan('Sequencer.enqueuePublishL2Block', (block)=>({
+            [Attributes.BLOCK_NUMBER]: block.number
+        }))
+], Sequencer.prototype, "enqueuePublishL2Block", null);

package/dest/sequencer/timetable.d.ts

@@ -0,0 +1,38 @@
+import type { SequencerMetrics } from './metrics.js';
+import { SequencerState } from './utils.js';
+export declare class SequencerTimetable {
+    private readonly ethereumSlotDuration;
+    private readonly aztecSlotDuration;
+    private readonly maxL1TxInclusionTimeIntoSlot;
+    private readonly enforce;
+    private readonly metrics?;
+    private readonly log;
+    /** How late into the slot can we be to start working */
+    readonly initialTime = 3;
+    /** How long it takes to get ready to start building */
+    readonly blockPrepareTime = 1;
+    /** How long it takes to for proposals and attestations to travel across the p2p layer (one-way) */
+    readonly attestationPropagationTime = 2;
+    /** How much time we spend validating and processing a block after building it, and assembling the proposal to send to attestors */
+    readonly blockValidationTime = 1;
+    /**
+     * 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.
+     */
+    readonly l1PublishingTime: number;
+    constructor(ethereumSlotDuration: number, aztecSlotDuration: number, maxL1TxInclusionTimeIntoSlot: number, enforce?: boolean, metrics?: SequencerMetrics | undefined, log?: import("@aztec/aztec.js").Logger);
+    private get afterBlockBuildingTimeNeededWithoutReexec();
+    getBlockProposalExecTimeEnd(secondsIntoSlot: number): number;
+    private get afterBlockReexecTimeNeeded();
+    getValidatorReexecTimeEnd(secondsIntoSlot: number): number;
+    getMaxAllowedTime(state: SequencerState): number | undefined;
+    assertTimeLeft(newState: SequencerState, secondsIntoSlot: number): void;
+}
+export declare class SequencerTooSlowError extends Error {
+    readonly proposedState: SequencerState;
+    readonly maxAllowedTime: number;
+    readonly currentTime: number;
+    constructor(proposedState: SequencerState, maxAllowedTime: number, currentTime: number);
+}
+//# sourceMappingURL=timetable.d.ts.map

package/dest/sequencer/timetable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timetable.d.ts","sourceRoot":"","sources":["../../src/sequencer/timetable.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C,qBAAa,kBAAkB;IAqB3B,OAAO,CAAC,QAAQ,CAAC,oBAAoB;IACrC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,4BAA4B;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;IACzB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAzBtB,wDAAwD;IACxD,SAAgB,WAAW,KAAK;IAEhC,uDAAuD;IACvD,SAAgB,gBAAgB,KAAK;IAErC,mGAAmG;IACnG,SAAgB,0BAA0B,KAAK;IAE/C,mIAAmI;IACnI,SAAgB,mBAAmB,KAAK;IAExC;;;;OAIG;IACH,SAAgB,gBAAgB,SAAC;gBAGd,oBAAoB,EAAE,MAAM,EAC5B,iBAAiB,EAAE,MAAM,EACzB,4BAA4B,EAAE,MAAM,EACpC,OAAO,GAAE,OAAc,EACvB,OAAO,CAAC,8BAAkB,EAC1B,GAAG,mCAAsC;IAK5D,OAAO,KAAK,yCAAyC,GAEpD;IAEM,2BAA2B,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM;IAenE,OAAO,KAAK,0BAA0B,GAErC;IAEM,yBAAyB,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM;IAU1D,iBAAiB,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,GAAG,SAAS;IAsB5D,cAAc,CAAC,QAAQ,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM;CAkBxE;AAED,qBAAa,qBAAsB,SAAQ,KAAK;aAE5B,aAAa,EAAE,cAAc;aAC7B,cAAc,EAAE,MAAM;aACtB,WAAW,EAAE,MAAM;gBAFnB,aAAa,EAAE,cAAc,EAC7B,cAAc,EAAE,MAAM,EACtB,WAAW,EAAE,MAAM;CAOtC"}