@aztec/sequencer-client 0.42.0 → 0.44.0

package/dest/sequencer/sequencer.js

@@ -1,3 +1,4 @@
+import { __esDecorate, __runInitializers } from "tslib";
 import { Tx, } from '@aztec/circuit-types';
 import { BlockProofError, PROVING_STATUS, } from '@aztec/circuit-types/interfaces';
 import { AztecAddress, EthAddress } from '@aztec/circuits.js';
@@ -5,6 +6,7 @@ import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import { Timer, elapsed } from '@aztec/foundation/timer';
+import { Attributes, trackSpan } from '@aztec/telemetry-client';
 /**
  * Sequencer client
  * - Wins a period of time to become the sequencer (depending on finalized protocol).
@@ -14,273 +16,300 @@ import { Timer, elapsed } from '@aztec/foundation/timer';
  * - 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 {
-    constructor(publisher, globalsBuilder, p2pClient, worldState, prover, l2BlockSource, l1ToL2MessageSource, publicProcessorFactory, txValidatorFactory, config = {}, log = createDebugLogger('aztec:sequencer')) {
-        this.publisher = publisher;
-        this.globalsBuilder = globalsBuilder;
-        this.p2pClient = p2pClient;
-        this.worldState = worldState;
-        this.prover = prover;
-        this.l2BlockSource = l2BlockSource;
-        this.l1ToL2MessageSource = l1ToL2MessageSource;
-        this.publicProcessorFactory = publicProcessorFactory;
-        this.txValidatorFactory = txValidatorFactory;
-        this.log = log;
-        this.pollingIntervalMs = 1000;
-        this.maxTxsPerBlock = 32;
-        this.minTxsPerBLock = 1;
-        // TODO: zero values should not be allowed for the following 2 values in PROD
-        this._coinbase = EthAddress.ZERO;
-        this._feeRecipient = AztecAddress.ZERO;
-        this.lastPublishedBlock = 0;
-        this.state = SequencerState.STOPPED;
-        this.allowedFunctionsInSetup = [];
-        this.allowedFunctionsInTeardown = [];
-        this.maxBlockSizeInBytes = 1024 * 1024;
-        this.updateConfig(config);
-        this.log.verbose(`Initialized sequencer with ${this.minTxsPerBLock}-${this.maxTxsPerBlock} txs per block.`);
-    }
-    /**
-     * Updates sequencer config.
-     * @param config - New parameters.
-     */
-    updateConfig(config) {
-        if (config.transactionPollingIntervalMS) {
-            this.pollingIntervalMs = config.transactionPollingIntervalMS;
-        }
-        if (config.maxTxsPerBlock) {
-            this.maxTxsPerBlock = config.maxTxsPerBlock;
-        }
-        if (config.minTxsPerBlock) {
-            this.minTxsPerBLock = config.minTxsPerBlock;
-        }
-        if (config.coinbase) {
-            this._coinbase = config.coinbase;
-        }
-        if (config.feeRecipient) {
-            this._feeRecipient = config.feeRecipient;
-        }
-        if (config.allowedFunctionsInSetup) {
-            this.allowedFunctionsInSetup = config.allowedFunctionsInSetup;
-        }
-        if (config.maxBlockSizeInBytes) {
-            this.maxBlockSizeInBytes = config.maxBlockSizeInBytes;
-        }
-        // TODO(#5917) remove this. it is no longer needed since we don't need to whitelist functions in teardown
-        if (config.allowedFunctionsInTeardown) {
-            this.allowedFunctionsInTeardown = config.allowedFunctionsInTeardown;
-        }
-    }
-    /**
-     * Starts the sequencer and moves to IDLE state. Blocks until the initial sync is complete.
-     */
-    async start() {
-        await this.initialSync();
-        this.runningPromise = new RunningPromise(this.work.bind(this), this.pollingIntervalMs);
-        this.runningPromise.start();
-        this.state = SequencerState.IDLE;
-        this.log.info('Sequencer started');
-    }
-    /**
-     * Stops the sequencer from processing txs and moves to STOPPED state.
-     */
-    async stop() {
-        this.log.debug(`Stopping sequencer`);
-        await this.runningPromise?.stop();
-        this.publisher.interrupt();
-        this.state = SequencerState.STOPPED;
-        this.log.info('Stopped sequencer');
-    }
-    /**
-     * Starts a previously stopped sequencer.
-     */
-    restart() {
-        this.log.info('Restarting sequencer');
-        this.publisher.restart();
-        this.runningPromise.start();
-        this.state = SequencerState.IDLE;
-    }
-    /**
-     * Returns the current state of the sequencer.
-     * @returns An object with a state entry with one of SequencerState.
-     */
-    status() {
-        return { state: this.state };
-    }
-    async initialSync() {
-        // TODO: Should we wait for world state to be ready, or is the caller expected to run await start?
-        this.lastPublishedBlock = await this.worldState.status().then((s) => s.syncedToL2Block);
-    }
-    /**
-     * Grabs up to maxTxsPerBlock from the p2p client, constructs a block, and pushes it to L1.
-     */
-    async work() {
-        try {
-            // Update state when the previous block has been synced
-            const prevBlockSynced = await this.isBlockSynced();
-            if (prevBlockSynced && this.state === SequencerState.PUBLISHING_BLOCK) {
-                this.log.debug(`Block has been synced`);
+let Sequencer = (() => {
+    var _a;
+    let _instanceExtraInitializers = [];
+    let _buildBlockAndPublish_decorators;
+    let _publishL2Block_decorators;
+    return _a = class Sequencer {
+            constructor(publisher, globalsBuilder, p2pClient, worldState, prover, l2BlockSource, l1ToL2MessageSource, publicProcessorFactory, txValidatorFactory, telemetry, config = {}, log = createDebugLogger('aztec:sequencer')) {
+                this.publisher = (__runInitializers(this, _instanceExtraInitializers), publisher);
+                this.globalsBuilder = globalsBuilder;
+                this.p2pClient = p2pClient;
+                this.worldState = worldState;
+                this.prover = prover;
+                this.l2BlockSource = l2BlockSource;
+                this.l1ToL2MessageSource = l1ToL2MessageSource;
+                this.publicProcessorFactory = publicProcessorFactory;
+                this.txValidatorFactory = txValidatorFactory;
+                this.log = log;
+                this.pollingIntervalMs = 1000;
+                this.maxTxsPerBlock = 32;
+                this.minTxsPerBLock = 1;
+                // TODO: zero values should not be allowed for the following 2 values in PROD
+                this._coinbase = EthAddress.ZERO;
+                this._feeRecipient = AztecAddress.ZERO;
+                this.lastPublishedBlock = 0;
+                this.state = SequencerState.STOPPED;
+                this.allowedInSetup = [];
+                this.allowedInTeardown = [];
+                this.maxBlockSizeInBytes = 1024 * 1024;
+                this.updateConfig(config);
+                this.tracer = telemetry.getTracer('Sequencer');
+                this.log.verbose(`Initialized sequencer with ${this.minTxsPerBLock}-${this.maxTxsPerBlock} txs per block.`);
+            }
+            /**
+             * Updates sequencer config.
+             * @param config - New parameters.
+             */
+            updateConfig(config) {
+                if (config.transactionPollingIntervalMS) {
+                    this.pollingIntervalMs = config.transactionPollingIntervalMS;
+                }
+                if (config.maxTxsPerBlock) {
+                    this.maxTxsPerBlock = config.maxTxsPerBlock;
+                }
+                if (config.minTxsPerBlock) {
+                    this.minTxsPerBLock = config.minTxsPerBlock;
+                }
+                if (config.coinbase) {
+                    this._coinbase = config.coinbase;
+                }
+                if (config.feeRecipient) {
+                    this._feeRecipient = config.feeRecipient;
+                }
+                if (config.allowedInSetup) {
+                    this.allowedInSetup = config.allowedInSetup;
+                }
+                if (config.maxBlockSizeInBytes) {
+                    this.maxBlockSizeInBytes = config.maxBlockSizeInBytes;
+                }
+                // TODO(#5917) remove this. it is no longer needed since we don't need to whitelist functions in teardown
+                if (config.allowedInTeardown) {
+                    this.allowedInTeardown = config.allowedInTeardown;
+                }
+            }
+            /**
+             * Starts the sequencer and moves to IDLE state. Blocks until the initial sync is complete.
+             */
+            async start() {
+                await this.initialSync();
+                this.runningPromise = new RunningPromise(this.work.bind(this), this.pollingIntervalMs);
+                this.runningPromise.start();
                 this.state = SequencerState.IDLE;
+                this.log.info('Sequencer started');
             }
-            // Do not go forward with new block if the previous one has not been mined and processed
-            if (!prevBlockSynced) {
-                return;
+            /**
+             * Stops the sequencer from processing txs and moves to STOPPED state.
+             */
+            async stop() {
+                this.log.debug(`Stopping sequencer`);
+                await this.runningPromise?.stop();
+                this.publisher.interrupt();
+                this.state = SequencerState.STOPPED;
+                this.log.info('Stopped sequencer');
+            }
+            /**
+             * Starts a previously stopped sequencer.
+             */
+            restart() {
+                this.log.info('Restarting sequencer');
+                this.publisher.restart();
+                this.runningPromise.start();
+                this.state = SequencerState.IDLE;
+            }
+            /**
+             * Returns the current state of the sequencer.
+             * @returns An object with a state entry with one of SequencerState.
+             */
+            status() {
+                return { state: this.state };
+            }
+            async initialSync() {
+                // TODO: Should we wait for world state to be ready, or is the caller expected to run await start?
+                this.lastPublishedBlock = await this.worldState.status().then((s) => s.syncedToL2Block);
+            }
+            /**
+             * Grabs up to maxTxsPerBlock from the p2p client, constructs a block, and pushes it to L1.
+             */
+            async work() {
+                try {
+                    // Update state when the previous block has been synced
+                    const prevBlockSynced = await this.isBlockSynced();
+                    if (prevBlockSynced && this.state === SequencerState.PUBLISHING_BLOCK) {
+                        this.log.debug(`Block has been synced`);
+                        this.state = SequencerState.IDLE;
+                    }
+                    // Do not go forward with new block if the previous one has not been mined and processed
+                    if (!prevBlockSynced) {
+                        return;
+                    }
+                    const historicalHeader = (await this.l2BlockSource.getBlock(-1))?.header;
+                    const newBlockNumber = (historicalHeader === undefined
+                        ? await this.l2BlockSource.getBlockNumber()
+                        : Number(historicalHeader.globalVariables.blockNumber.toBigInt())) + 1;
+                    // Do not go forward with new block if not my turn
+                    if (!(await this.publisher.isItMyTurnToSubmit(newBlockNumber))) {
+                        this.log.verbose('Not my turn to submit block');
+                        return;
+                    }
+                    this.state = SequencerState.WAITING_FOR_TXS;
+                    // Get txs to build the new block
+                    const pendingTxs = await this.p2pClient.getTxs();
+                    if (pendingTxs.length < this.minTxsPerBLock) {
+                        return;
+                    }
+                    this.log.debug(`Retrieved ${pendingTxs.length} txs from P2P pool`);
+                    const newGlobalVariables = await this.globalsBuilder.buildGlobalVariables(new Fr(newBlockNumber), this._coinbase, this._feeRecipient);
+                    // TODO: It should be responsibility of the P2P layer to validate txs before passing them on here
+                    const allValidTxs = await this.takeValidTxs(pendingTxs, this.txValidatorFactory.validatorForNewTxs(newGlobalVariables, this.allowedInSetup));
+                    // TODO: We are taking the size of the tx from private-land, but we should be doing this after running
+                    // public functions. Only reason why we do it here now is because the public processor and orchestrator
+                    // are set up such that they require knowing the total number of txs in advance. Still, main reason for
+                    // exceeding max block size in bytes is contract class registration, which happens in private-land. This
+                    // may break if we start emitting lots of log data from public-land.
+                    const validTxs = this.takeTxsWithinMaxSize(allValidTxs);
+                    if (validTxs.length < this.minTxsPerBLock) {
+                        return;
+                    }
+                    await this.buildBlockAndPublish(validTxs, newGlobalVariables, historicalHeader);
+                }
+                catch (err) {
+                    if (BlockProofError.isBlockProofError(err)) {
+                        const txHashes = err.txHashes.filter(h => !h.isZero());
+                        this.log.warn(`Proving block failed, removing ${txHashes.length} txs from pool`);
+                        await this.p2pClient.deleteTxs(txHashes);
+                    }
+                    this.log.error(`Rolling back world state DB due to error assembling block`, err.stack);
+                    // Cancel any further proving on the block
+                    this.prover?.cancelBlock();
+                    await this.worldState.getLatest().rollback();
+                }
             }
-            const workTimer = new Timer();
-            this.state = SequencerState.WAITING_FOR_TXS;
-            // Get txs to build the new block
-            const pendingTxs = await this.p2pClient.getTxs();
-            if (pendingTxs.length < this.minTxsPerBLock) {
-                return;
+            async buildBlockAndPublish(validTxs, newGlobalVariables, historicalHeader) {
+                const workTimer = new Timer();
+                this.state = SequencerState.CREATING_BLOCK;
+                this.log.info(`Building block ${newGlobalVariables.blockNumber.toNumber()} with ${validTxs.length} transactions`);
+                const assertBlockHeight = async () => {
+                    const currentBlockNumber = await this.l2BlockSource.getBlockNumber();
+                    if (currentBlockNumber + 1 !== newGlobalVariables.blockNumber.toNumber()) {
+                        throw new Error('New block was emitted while building block');
+                    }
+                    if (!(await this.publisher.isItMyTurnToSubmit(newGlobalVariables.blockNumber.toNumber()))) {
+                        throw new Error(`Not this sequencer turn to submit block`);
+                    }
+                };
+                // Get l1 to l2 messages from the contract
+                this.log.debug('Requesting L1 to L2 messages from contract');
+                const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(newGlobalVariables.blockNumber.toBigInt());
+                this.log.verbose(`Retrieved ${l1ToL2Messages.length} L1 to L2 messages for block ${newGlobalVariables.blockNumber.toNumber()}`);
+                // We create a fresh processor each time to reset any cached state (eg storage writes)
+                const processor = await this.publicProcessorFactory.create(historicalHeader, newGlobalVariables);
+                const numRealTxs = validTxs.length;
+                const pow2 = Math.log2(numRealTxs);
+                const totalTxs = 2 ** Math.ceil(pow2);
+                const blockSize = Math.max(2, totalTxs);
+                const blockBuildingTimer = new Timer();
+                const blockTicket = await this.prover.startNewBlock(blockSize, newGlobalVariables, l1ToL2Messages);
+                const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() => processor.process(validTxs, blockSize, this.prover, this.txValidatorFactory.validatorForProcessedTxs()));
+                if (failedTxs.length > 0) {
+                    const failedTxData = failedTxs.map(fail => fail.tx);
+                    this.log.debug(`Dropping failed txs ${Tx.getHashes(failedTxData).join(', ')}`);
+                    await this.p2pClient.deleteTxs(Tx.getHashes(failedTxData));
+                }
+                if (processedTxs.length === 0) {
+                    this.log.verbose('No txs processed correctly to build block. Exiting');
+                    this.prover.cancelBlock();
+                    return;
+                }
+                await assertBlockHeight();
+                // All real transactions have been added, set the block as full and complete the proving.
+                await this.prover.setBlockCompleted();
+                // Here we are now waiting for the block to be proven.
+                // TODO(@PhilWindle) We should probably periodically check for things like another
+                // block being published before ours instead of just waiting on our block
+                const result = await blockTicket.provingPromise;
+                if (result.status === PROVING_STATUS.FAILURE) {
+                    throw new Error(`Block proving failed, reason: ${result.reason}`);
+                }
+                await assertBlockHeight();
+                // Block is proven, now finalise and publish!
+                const { block, aggregationObject, proof } = await this.prover.finaliseBlock();
+                await assertBlockHeight();
+                this.log.verbose(`Assembled block ${block.number}`, {
+                    eventName: 'l2-block-built',
+                    duration: workTimer.ms(),
+                    publicProcessDuration: publicProcessorDuration,
+                    rollupCircuitsDuration: blockBuildingTimer.ms(),
+                    ...block.getStats(),
+                });
+                await this.publishL2Block(block, aggregationObject, proof);
+                this.log.info(`Submitted rollup block ${block.number} with ${processedTxs.length} transactions`);
             }
-            this.log.debug(`Retrieved ${pendingTxs.length} txs from P2P pool`);
-            const historicalHeader = (await this.l2BlockSource.getBlock(-1))?.header;
-            const newBlockNumber = (historicalHeader === undefined
-                ? await this.l2BlockSource.getBlockNumber()
-                : Number(historicalHeader.globalVariables.blockNumber.toBigInt())) + 1;
             /**
-             * We'll call this function before running expensive operations to avoid wasted work.
+             * Publishes the L2Block to the rollup contract.
+             * @param block - The L2Block to be published.
              */
-            const assertBlockHeight = async () => {
-                const currentBlockNumber = await this.l2BlockSource.getBlockNumber();
-                if (currentBlockNumber + 1 !== newBlockNumber) {
-                    throw new Error('New block was emitted while building block');
+            async publishL2Block(block, aggregationObject, proof) {
+                // Publishes new block to the network and awaits the tx to be mined
+                this.state = SequencerState.PUBLISHING_BLOCK;
+                const publishedL2Block = await this.publisher.processL2Block(block, aggregationObject, proof);
+                if (publishedL2Block) {
+                    this.lastPublishedBlock = block.number;
+                }
+                else {
+                    throw new Error(`Failed to publish block`);
                 }
-            };
-            const newGlobalVariables = await this.globalsBuilder.buildGlobalVariables(new Fr(newBlockNumber), this._coinbase, this._feeRecipient);
-            // TODO: It should be responsibility of the P2P layer to validate txs before passing them on here
-            const allValidTxs = await this.takeValidTxs(pendingTxs, this.txValidatorFactory.validatorForNewTxs(newGlobalVariables, this.allowedFunctionsInSetup));
-            // TODO: We are taking the size of the tx from private-land, but we should be doing this after running
-            // public functions. Only reason why we do it here now is because the public processor and orchestrator
-            // are set up such that they require knowing the total number of txs in advance. Still, main reason for
-            // exceeding max block size in bytes is contract class registration, which happens in private-land. This
-            // may break if we start emitting lots of log data from public-land.
-            const validTxs = this.takeTxsWithinMaxSize(allValidTxs);
-            if (validTxs.length < this.minTxsPerBLock) {
-                return;
             }
-            this.log.info(`Building block ${newBlockNumber} with ${validTxs.length} transactions`);
-            this.state = SequencerState.CREATING_BLOCK;
-            // Get l1 to l2 messages from the contract
-            this.log.debug('Requesting L1 to L2 messages from contract');
-            const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(BigInt(newBlockNumber));
-            this.log.verbose(`Retrieved ${l1ToL2Messages.length} L1 to L2 messages for block ${newBlockNumber}`);
-            // We create a fresh processor each time to reset any cached state (eg storage writes)
-            const processor = await this.publicProcessorFactory.create(historicalHeader, newGlobalVariables);
-            const blockBuildingTimer = new Timer();
-            // We must initialise the block to be a power of 2 in size
-            const numRealTxs = validTxs.length;
-            const pow2 = Math.log2(numRealTxs);
-            // TODO turn this back into a Math.ceil once we can pad blocks to the next-power-of-2 with empty txs
-            const totalTxs = 2 ** Math.ceil(pow2);
-            const blockSize = Math.max(2, totalTxs);
-            const blockTicket = await this.prover.startNewBlock(blockSize, newGlobalVariables, l1ToL2Messages);
-            const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() => processor.process(validTxs, blockSize, this.prover, this.txValidatorFactory.validatorForProcessedTxs()));
-            if (failedTxs.length > 0) {
-                const failedTxData = failedTxs.map(fail => fail.tx);
-                this.log.debug(`Dropping failed txs ${Tx.getHashes(failedTxData).join(', ')}`);
-                await this.p2pClient.deleteTxs(Tx.getHashes(failedTxData));
+            async takeValidTxs(txs, validator) {
+                const [valid, invalid] = await validator.validateTxs(txs);
+                if (invalid.length > 0) {
+                    this.log.debug(`Dropping invalid txs from the p2p pool ${Tx.getHashes(invalid).join(', ')}`);
+                    await this.p2pClient.deleteTxs(Tx.getHashes(invalid));
+                }
+                return valid.slice(0, this.maxTxsPerBlock);
             }
-            if (processedTxs.length === 0) {
-                this.log.verbose('No txs processed correctly to build block. Exiting');
-                this.prover.cancelBlock();
-                return;
+            takeTxsWithinMaxSize(txs) {
+                const maxSize = this.maxBlockSizeInBytes;
+                let totalSize = 0;
+                const toReturn = [];
+                for (const tx of txs) {
+                    const txSize = tx.getSize() - tx.proof.toBuffer().length;
+                    if (totalSize + txSize > maxSize) {
+                        this.log.warn(`Dropping tx ${tx.getTxHash()} with estimated size ${txSize} due to exceeding ${maxSize} block size limit (currently at ${totalSize})`);
+                        continue;
+                    }
+                    toReturn.push(tx);
+                    totalSize += txSize;
+                }
+                return toReturn;
             }
-            await assertBlockHeight();
-            // All real transactions have been added, set the block as full and complete the proving.
-            await this.prover.setBlockCompleted();
-            // Here we are now waiting for the block to be proven.
-            // TODO(@PhilWindle) We should probably periodically check for things like another
-            // block being published before ours instead of just waiting on our block
-            const result = await blockTicket.provingPromise;
-            if (result.status === PROVING_STATUS.FAILURE) {
-                throw new Error(`Block proving failed, reason: ${result.reason}`);
+            /**
+             * Returns whether the previous block sent has been mined, and all dependencies have caught up with it.
+             * @returns Boolean indicating if our dependencies are synced to the latest block.
+             */
+            async isBlockSynced() {
+                const syncedBlocks = await Promise.all([
+                    this.worldState.status().then((s) => s.syncedToL2Block),
+                    this.p2pClient.getStatus().then(s => s.syncedToL2Block),
+                    this.l2BlockSource.getBlockNumber(),
+                    this.l1ToL2MessageSource.getBlockNumber(),
+                ]);
+                const min = Math.min(...syncedBlocks);
+                return min >= this.lastPublishedBlock;
             }
-            await assertBlockHeight();
-            // Block is proven, now finalise and publish!
-            const { block, aggregationObject, proof } = await this.prover.finaliseBlock();
-            await assertBlockHeight();
-            this.log.verbose(`Assembled block ${block.number}`, {
-                eventName: 'l2-block-built',
-                duration: workTimer.ms(),
-                publicProcessDuration: publicProcessorDuration,
-                rollupCircuitsDuration: blockBuildingTimer.ms(),
-                ...block.getStats(),
-            });
-            await this.publishL2Block(block, aggregationObject, proof);
-            this.log.info(`Submitted rollup block ${block.number} with ${processedTxs.length} transactions`);
-        }
-        catch (err) {
-            if (BlockProofError.isBlockProofError(err)) {
-                const txHashes = err.txHashes.filter(h => !h.isZero());
-                this.log.warn(`Proving block failed, removing ${txHashes.length} txs from pool`);
-                await this.p2pClient.deleteTxs(txHashes);
+            get coinbase() {
+                return this._coinbase;
             }
-            this.log.error(`Rolling back world state DB due to error assembling block`, err.stack);
-            // Cancel any further proving on the block
-            this.prover?.cancelBlock();
-            await this.worldState.getLatest().rollback();
-        }
-    }
-    /**
-     * Publishes the L2Block to the rollup contract.
-     * @param block - The L2Block to be published.
-     */
-    async publishL2Block(block, aggregationObject, proof) {
-        // Publishes new block to the network and awaits the tx to be mined
-        this.state = SequencerState.PUBLISHING_BLOCK;
-        const publishedL2Block = await this.publisher.processL2Block(block, aggregationObject, proof);
-        if (publishedL2Block) {
-            this.lastPublishedBlock = block.number;
-        }
-        else {
-            throw new Error(`Failed to publish block`);
-        }
-    }
-    async takeValidTxs(txs, validator) {
-        const [valid, invalid] = await validator.validateTxs(txs);
-        if (invalid.length > 0) {
-            this.log.debug(`Dropping invalid txs from the p2p pool ${Tx.getHashes(invalid).join(', ')}`);
-            await this.p2pClient.deleteTxs(Tx.getHashes(invalid));
-        }
-        return valid.slice(0, this.maxTxsPerBlock);
-    }
-    takeTxsWithinMaxSize(txs) {
-        const maxSize = this.maxBlockSizeInBytes;
-        let totalSize = 0;
-        const toReturn = [];
-        for (const tx of txs) {
-            const txSize = tx.getStats().size - tx.proof.toBuffer().length;
-            if (totalSize + txSize > maxSize) {
-                this.log.warn(`Dropping tx ${tx.getTxHash()} with size ${txSize} due to exceeding ${maxSize} block size limit (currently at ${totalSize})`);
-                continue;
+            get feeRecipient() {
+                return this._feeRecipient;
             }
-            toReturn.push(tx);
-            totalSize += txSize;
-        }
-        return toReturn;
-    }
-    /**
-     * Returns whether the previous block sent has been mined, and all dependencies have caught up with it.
-     * @returns Boolean indicating if our dependencies are synced to the latest block.
-     */
-    async isBlockSynced() {
-        const syncedBlocks = await Promise.all([
-            this.worldState.status().then((s) => s.syncedToL2Block),
-            this.p2pClient.getStatus().then(s => s.syncedToL2Block),
-            this.l2BlockSource.getBlockNumber(),
-            this.l1ToL2MessageSource.getBlockNumber(),
-        ]);
-        const min = Math.min(...syncedBlocks);
-        return min >= this.lastPublishedBlock;
-    }
-    get coinbase() {
-        return this._coinbase;
-    }
-    get feeRecipient() {
-        return this._feeRecipient;
-    }
-}
+        },
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _buildBlockAndPublish_decorators = [trackSpan('Sequencer.buildBlockAndPublish', (_validTxs, newGlobalVariables, _historicalHeader) => ({
+                    [Attributes.BLOCK_NUMBER]: newGlobalVariables.blockNumber.toNumber(),
+                }))];
+            _publishL2Block_decorators = [trackSpan('Sequencer.publishL2Block', block => ({
+                    [Attributes.BLOCK_NUMBER]: block.number,
+                }))];
+            __esDecorate(_a, null, _buildBlockAndPublish_decorators, { kind: "method", name: "buildBlockAndPublish", static: false, private: false, access: { has: obj => "buildBlockAndPublish" in obj, get: obj => obj.buildBlockAndPublish }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _publishL2Block_decorators, { kind: "method", name: "publishL2Block", static: false, private: false, access: { has: obj => "publishL2Block" in obj, get: obj => obj.publishL2Block }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+export { Sequencer };
 /**
  * State of the sequencer.
  */
@@ -311,4 +340,4 @@ export var SequencerState;
      */
     SequencerState[SequencerState["STOPPED"] = 5] = "STOPPED";
 })(SequencerState || (SequencerState = {}));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sequencer.js","sourceRoot":"","sources":["../../src/sequencer/sequencer.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sequencer.js","sourceRoot":"","sources":["../../src/sequencer/sequencer.ts"],"names":[],"mappings":"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"}