@aztec/sequencer-client 0.65.2 → 0.67.0

package/src/sequencer/metrics.ts

@@ -7,7 +7,6 @@ import {
   type Tracer,
   type UpDownCounter,
   ValueType,
-  millisecondBuckets,
 } from '@aztec/telemetry-client';
 
 import { type SequencerState, type SequencerStateCallback, sequencerStateToNumber } from './utils.js';
@@ -32,18 +31,12 @@ export class SequencerMetrics {
       unit: 'ms',
       description: 'Duration to build a block',
       valueType: ValueType.INT,
-      advice: {
-        explicitBucketBoundaries: millisecondBuckets(2),
-      },
     });
     this.stateTransitionBufferDuration = meter.createHistogram(Metrics.SEQUENCER_STATE_TRANSITION_BUFFER_DURATION, {
       unit: 'ms',
       description:
         'The time difference between when the sequencer needed to transition to a new state and when it actually did.',
       valueType: ValueType.INT,
-      advice: {
-        explicitBucketBoundaries: millisecondBuckets(2),
-      },
     });
 
     const currentState = meter.createObservableGauge(Metrics.SEQUENCER_CURRENT_STATE, {

package/src/sequencer/sequencer.ts

@@ -4,6 +4,7 @@ import {
   type L2Block,
   type L2BlockSource,
   type ProcessedTx,
+  SequencerConfigSchema,
   Tx,
   type TxHash,
   type TxValidator,
@@ -13,26 +14,26 @@ import type { AllowedElement, Signature, WorldStateSynchronizerStatus } from '@a
 import { type L2BlockBuiltStats } from '@aztec/circuit-types/stats';
 import {
   AppendOnlyTreeSnapshot,
+  BlockHeader,
   ContentCommitment,
   GENESIS_ARCHIVE_ROOT,
   type GlobalVariables,
-  Header,
   StateReference,
 } from '@aztec/circuits.js';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { omit } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
+import { pickFromSchema } from '@aztec/foundation/schemas';
 import { Timer, elapsed } from '@aztec/foundation/timer';
 import { type P2P } from '@aztec/p2p';
+import { type BlockBuilderFactory } from '@aztec/prover-client/block-builder';
 import { type PublicProcessorFactory } from '@aztec/simulator';
 import { Attributes, type TelemetryClient, type Tracer, trackSpan } from '@aztec/telemetry-client';
 import { type ValidatorClient } from '@aztec/validator-client';
 
-import { inspect } from 'util';
-
-import { type BlockBuilderFactory } from '../block_builder/index.js';
 import { type GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
 import { type L1Publisher } from '../publisher/l1-publisher.js';
 import { prettyLogViemErrorMsg } from '../publisher/utils.js';
@@ -108,11 +109,10 @@ export class Sequencer {
     private aztecSlotDuration: number,
     telemetry: TelemetryClient,
     private config: SequencerConfig = {},
-    private log = createDebugLogger('aztec:sequencer'),
+    private log = createLogger('sequencer'),
   ) {
     this.updateConfig(config);
     this.metrics = new SequencerMetrics(telemetry, () => this.state, 'Sequencer');
-    this.log.verbose(`Initialized sequencer with ${this.minTxsPerBLock}-${this.maxTxsPerBlock} txs per block.`);
 
     // Register the block builder with the validator client for re-execution
     this.validatorClient?.registerBlockBuilder(this.buildBlock.bind(this));
@@ -127,6 +127,11 @@ export class Sequencer {
    * @param config - New parameters.
    */
   public updateConfig(config: SequencerConfig) {
+    this.log.info(
+      `Sequencer config set`,
+      omit(pickFromSchema(this.config, SequencerConfigSchema), 'allowedInSetup', 'allowedInTeardown'),
+    );
+
     if (config.transactionPollingIntervalMS !== undefined) {
       this.pollingIntervalMs = config.transactionPollingIntervalMS;
     }
@@ -188,9 +193,9 @@ export class Sequencer {
    */
   public start() {
     this.runningPromise = new RunningPromise(this.work.bind(this), this.pollingIntervalMs);
+    this.setState(SequencerState.IDLE, 0n, true /** force */);
     this.runningPromise.start();
-    this.setState(SequencerState.IDLE, 0, true /** force */);
-    this.log.info('Sequencer started');
+    this.log.info(`Sequencer started with address ${this.publisher.getSenderAddress().toString()}`);
     return Promise.resolve();
   }
 
@@ -199,9 +204,10 @@ export class Sequencer {
    */
   public async stop(): Promise<void> {
     this.log.debug(`Stopping sequencer`);
+    await this.validatorClient?.stop();
     await this.runningPromise?.stop();
     this.publisher.interrupt();
-    this.setState(SequencerState.STOPPED, 0, true /** force */);
+    this.setState(SequencerState.STOPPED, 0n, true /** force */);
     this.log.info('Stopped sequencer');
   }
 
@@ -212,7 +218,7 @@ export class Sequencer {
     this.log.info('Restarting sequencer');
     this.publisher.restart();
     this.runningPromise!.start();
-    this.setState(SequencerState.IDLE, 0, true /** force */);
+    this.setState(SequencerState.IDLE, 0n, true /** force */);
   }
 
   /**
@@ -232,18 +238,15 @@ export class Sequencer {
    *          - If our block for some reason is not included, revert the state
    */
   protected async doRealWork() {
-    this.setState(SequencerState.SYNCHRONIZING, 0);
+    this.setState(SequencerState.SYNCHRONIZING, 0n);
     // Update state when the previous block has been synced
     const prevBlockSynced = await this.isBlockSynced();
     // Do not go forward with new block if the previous one has not been mined and processed
     if (!prevBlockSynced) {
-      this.log.debug('Previous block has not been mined and processed yet');
       return;
     }
 
-    this.log.debug('Previous block has been mined and processed');
-
-    this.setState(SequencerState.PROPOSER_CHECK, 0);
+    this.setState(SequencerState.PROPOSER_CHECK, 0n);
 
     const chainTip = await this.l2BlockSource.getBlock(-1);
     const historicalHeader = chainTip?.header;
@@ -277,20 +280,24 @@ export class Sequencer {
     if (!this.shouldProposeBlock(historicalHeader, {})) {
       return;
     }
-    const secondsIntoSlot = getSecondsIntoSlot(this.l1GenesisTime, this.aztecSlotDuration, Number(slot));
 
-    this.setState(SequencerState.WAITING_FOR_TXS, secondsIntoSlot);
+    this.log.verbose(`Preparing proposal for block ${newBlockNumber} at slot ${slot}`, {
+      chainTipArchive: new Fr(chainTipArchive),
+      blockNumber: newBlockNumber,
+      slot,
+    });
+
+    this.setState(SequencerState.WAITING_FOR_TXS, slot);
 
     // Get txs to build the new block.
-    const pendingTxs = this.p2pClient.getTxs('pending');
+    const pendingTxs = await this.p2pClient.getPendingTxs();
 
     if (!this.shouldProposeBlock(historicalHeader, { pendingTxsCount: pendingTxs.length })) {
       return;
     }
-    this.log.debug(`Retrieved ${pendingTxs.length} txs from P2P pool`);
 
     // If I created a "partial" header here that should make our job much easier.
-    const proposalHeader = new Header(
+    const proposalHeader = new BlockHeader(
       new AppendOnlyTreeSnapshot(Fr.fromBuffer(chainTipArchive), 1),
       ContentCommitment.empty(),
       StateReference.empty(),
@@ -312,6 +319,10 @@ export class Sequencer {
     // may break if we start emitting lots of log data from public-land.
     const validTxs = this.takeTxsWithinMaxSize(allValidTxs);
 
+    this.log.verbose(
+      `Collected ${validTxs.length} txs out of ${allValidTxs.length} valid txs out of ${pendingTxs.length} total pending txs for block ${newBlockNumber}`,
+    );
+
     // Bail if we don't have enough valid txs
     if (!this.shouldProposeBlock(historicalHeader, { validTxsCount: validTxs.length })) {
       return;
@@ -323,9 +334,9 @@ export class Sequencer {
       //        be in for a world of pain.
       await this.buildBlockAndAttemptToPublish(validTxs, proposalHeader, historicalHeader);
     } catch (err) {
-      this.log.error(`Error assembling block`, (err as any).stack);
+      this.log.error(`Error assembling block`, err, { blockNumber: newBlockNumber, slot });
     }
-    this.setState(SequencerState.IDLE, 0);
+    this.setState(SequencerState.IDLE, 0n);
   }
 
   protected async work() {
@@ -339,12 +350,12 @@ export class Sequencer {
         throw err;
       }
     } finally {
-      this.setState(SequencerState.IDLE, 0);
+      this.setState(SequencerState.IDLE, 0n);
     }
   }
 
   /** Whether to skip the check of min txs per block if more than maxSecondsBetweenBlocks has passed since the previous block. */
-  private skipMinTxsPerBlockCheck(historicalHeader: Header | undefined): boolean {
+  private skipMinTxsPerBlockCheck(historicalHeader: BlockHeader | undefined): boolean {
     const lastBlockTime = historicalHeader?.globalVariables.timestamp.toNumber() || 0;
     const currentTime = Math.floor(Date.now() / 1000);
     const elapsed = currentTime - lastBlockTime;
@@ -358,16 +369,14 @@ export class Sequencer {
       const [slot, blockNumber] = await this.publisher.canProposeAtNextEthBlock(tipArchive);
 
       if (proposalBlockNumber !== blockNumber) {
-        const msg = `Block number mismatch. Expected ${proposalBlockNumber} but got ${blockNumber}`;
-        this.log.debug(msg);
+        const msg = `Sequencer block number mismatch. Expected ${proposalBlockNumber} but got ${blockNumber}.`;
+        this.log.warn(msg);
         throw new Error(msg);
       }
-
-      this.log.verbose(`Can propose block ${proposalBlockNumber} at slot ${slot}`);
       return slot;
     } catch (err) {
       const msg = prettyLogViemErrorMsg(err);
-      this.log.verbose(
+      this.log.debug(
         `Rejected from being able to propose at next block with ${tipArchive.toString('hex')}: ${msg ? `${msg}` : ''}`,
       );
       throw err;
@@ -384,7 +393,6 @@ export class Sequencer {
     }
 
     const bufferSeconds = this.timeTable[proposedState] - secondsIntoSlot;
-    this.metrics.recordStateTransitionBufferMs(bufferSeconds * 1000, proposedState);
 
     if (bufferSeconds < 0) {
       this.log.warn(
@@ -392,26 +400,38 @@ export class Sequencer {
       );
       return false;
     }
+
+    this.metrics.recordStateTransitionBufferMs(Math.floor(bufferSeconds * 1000), proposedState);
+
     this.log.debug(
       `Enough time to transition to ${proposedState}, max allowed: ${this.timeTable[proposedState]}s, time into slot: ${secondsIntoSlot}s`,
     );
     return true;
   }
 
-  setState(proposedState: SequencerState, secondsIntoSlot: number, force: boolean = false) {
+  /**
+   * 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: SequencerState, currentSlotNumber: bigint, force: boolean = false) {
     if (this.state === SequencerState.STOPPED && force !== true) {
-      this.log.warn(
-        `Cannot set sequencer from ${this.state} to ${proposedState} as it is stopped. Set force=true to override.`,
-      );
+      this.log.warn(`Cannot set sequencer from ${this.state} to ${proposedState} as it is stopped.`);
       return;
     }
+    const secondsIntoSlot = getSecondsIntoSlot(this.l1GenesisTime, this.aztecSlotDuration, Number(currentSlotNumber));
     if (!this.doIHaveEnoughTimeLeft(proposedState, secondsIntoSlot)) {
       throw new SequencerTooSlowError(this.state, proposedState, this.timeTable[proposedState], secondsIntoSlot);
     }
+    this.log.debug(`Transitioning from ${this.state} to ${proposedState}`);
     this.state = proposedState;
   }
 
-  shouldProposeBlock(historicalHeader: Header | undefined, args: ShouldProposeArgs): boolean {
+  shouldProposeBlock(historicalHeader: BlockHeader | undefined, args: ShouldProposeArgs): boolean {
     if (this.isFlushing) {
       this.log.verbose(`Flushing all pending txs in new block`);
       return true;
@@ -428,7 +448,7 @@ export class Sequencer {
     // If we haven't hit the maxSecondsBetweenBlocks, we need to have at least minTxsPerBLock txs.
     // Do not go forward with new block if not enough time has passed since last block
     if (this.minSecondsBetweenBlocks > 0 && elapsedSinceLastBlock < this.minSecondsBetweenBlocks) {
-      this.log.debug(
+      this.log.verbose(
         `Not creating block because not enough time ${this.minSecondsBetweenBlocks} has passed since last block`,
       );
       return false;
@@ -444,7 +464,7 @@ export class Sequencer {
             `Creating block with only ${args.pendingTxsCount} txs as more than ${this.maxSecondsBetweenBlocks}s have passed since last block`,
           );
         } else {
-          this.log.debug(
+          this.log.verbose(
             `Not creating block because not enough txs in the pool (got ${args.pendingTxsCount} min ${this.minTxsPerBLock})`,
           );
           return false;
@@ -456,7 +476,7 @@ export class Sequencer {
     if (args.validTxsCount != undefined) {
       // Bail if we don't have enough valid txs
       if (!skipCheck && args.validTxsCount < this.minTxsPerBLock) {
-        this.log.debug(
+        this.log.verbose(
           `Not creating block because not enough valid txs loaded from the pool (got ${args.validTxsCount} min ${this.minTxsPerBLock})`,
         );
         return false;
@@ -469,7 +489,7 @@ export class Sequencer {
     // we should bail.
     if (args.processedTxsCount != undefined) {
       if (args.processedTxsCount === 0 && !skipCheck && this.minTxsPerBLock > 0) {
-        this.log.verbose('No txs processed correctly to build block. Exiting');
+        this.log.verbose('No txs processed correctly to build block.');
         return false;
       }
     }
@@ -490,13 +510,23 @@ export class Sequencer {
   private async buildBlock(
     validTxs: Tx[],
     newGlobalVariables: GlobalVariables,
-    historicalHeader?: Header,
+    historicalHeader?: BlockHeader,
     interrupt?: (processedTxs: ProcessedTx[]) => Promise<void>,
   ) {
-    this.log.debug('Requesting L1 to L2 messages from contract');
-    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(newGlobalVariables.blockNumber.toBigInt());
+    const blockNumber = newGlobalVariables.blockNumber.toBigInt();
+    const slot = newGlobalVariables.slotNumber.toBigInt();
+
+    this.log.debug(`Requesting L1 to L2 messages from contract for block ${blockNumber}`);
+    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockNumber);
+
     this.log.verbose(
-      `Retrieved ${l1ToL2Messages.length} L1 to L2 messages for block ${newGlobalVariables.blockNumber.toNumber()}`,
+      `Building block ${blockNumber} with ${validTxs.length} txs and ${l1ToL2Messages.length} messages`,
+      {
+        msgCount: l1ToL2Messages.length,
+        txCount: validTxs.length,
+        slot,
+        blockNumber,
+      },
     );
 
     const numRealTxs = validTxs.length;
@@ -504,7 +534,7 @@ export class Sequencer {
 
     // Sync to the previous block at least
     await this.worldState.syncImmediate(newGlobalVariables.blockNumber.toNumber() - 1);
-    this.log.verbose(`Synced to previous block ${newGlobalVariables.blockNumber.toNumber() - 1}`);
+    this.log.debug(`Synced to previous block ${newGlobalVariables.blockNumber.toNumber() - 1}`);
 
     // NB: separating the dbs because both should update the state
     const publicProcessorFork = await this.worldState.fork();
@@ -526,7 +556,7 @@ export class Sequencer {
       );
       if (failedTxs.length > 0) {
         const failedTxData = failedTxs.map(fail => fail.tx);
-        this.log.debug(`Dropping failed txs ${Tx.getHashes(failedTxData).join(', ')}`);
+        this.log.verbose(`Dropping failed txs ${Tx.getHashes(failedTxData).join(', ')}`);
         await this.p2pClient.deleteTxs(Tx.getHashes(failedTxData));
       }
 
@@ -535,7 +565,13 @@ export class Sequencer {
       // All real transactions have been added, set the block as full and complete the proving.
       const block = await blockBuilder.setBlockCompleted();
 
-      return { block, publicProcessorDuration, numProcessedTxs: processedTxs.length, blockBuildingTimer };
+      return {
+        block,
+        publicProcessorDuration,
+        numMsgs: l1ToL2Messages.length,
+        numProcessedTxs: processedTxs.length,
+        blockBuildingTimer,
+      };
     } finally {
       // We create a fresh processor each time to reset any cached state (eg storage writes)
       await publicProcessorFork.close();
@@ -558,26 +594,18 @@ export class Sequencer {
   }))
   private async buildBlockAndAttemptToPublish(
     validTxs: Tx[],
-    proposalHeader: Header,
-    historicalHeader: Header | undefined,
+    proposalHeader: BlockHeader,
+    historicalHeader: BlockHeader | undefined,
   ): Promise<void> {
     await this.publisher.validateBlockForSubmission(proposalHeader);
 
     const newGlobalVariables = proposalHeader.globalVariables;
+    const blockNumber = newGlobalVariables.blockNumber.toNumber();
+    const slot = newGlobalVariables.slotNumber.toBigInt();
 
-    this.metrics.recordNewBlock(newGlobalVariables.blockNumber.toNumber(), validTxs.length);
+    this.metrics.recordNewBlock(blockNumber, validTxs.length);
     const workTimer = new Timer();
-    const secondsIntoSlot = getSecondsIntoSlot(
-      this.l1GenesisTime,
-      this.aztecSlotDuration,
-      newGlobalVariables.slotNumber.toNumber(),
-    );
-    this.setState(SequencerState.CREATING_BLOCK, secondsIntoSlot);
-    this.log.info(
-      `Building blockNumber=${newGlobalVariables.blockNumber.toNumber()} txCount=${
-        validTxs.length
-      } slotNumber=${newGlobalVariables.slotNumber.toNumber()}`,
-    );
+    this.setState(SequencerState.CREATING_BLOCK, slot);
 
     /**
      * BuildBlock is shared between the sequencer and the validator for re-execution
@@ -600,12 +628,8 @@ export class Sequencer {
     };
 
     try {
-      const { block, publicProcessorDuration, numProcessedTxs, blockBuildingTimer } = await this.buildBlock(
-        validTxs,
-        newGlobalVariables,
-        historicalHeader,
-        interrupt,
-      );
+      const buildBlockRes = await this.buildBlock(validTxs, newGlobalVariables, historicalHeader, interrupt);
+      const { block, publicProcessorDuration, numProcessedTxs, numMsgs, blockBuildingTimer } = buildBlockRes;
 
       // TODO(@PhilWindle) We should probably periodically check for things like another
       // block being published before ours instead of just waiting on our block
@@ -613,43 +637,56 @@ export class Sequencer {
       await this.publisher.validateBlockForSubmission(block.header);
 
       const workDuration = workTimer.ms();
-      this.log.info(
-        `Assembled block ${block.number} (txEffectsHash: ${block.header.contentCommitment.txsEffectsHash.toString(
-          'hex',
-        )})`,
-        {
-          eventName: 'l2-block-built',
-          creator: this.publisher.getSenderAddress().toString(),
-          duration: workDuration,
-          publicProcessDuration: publicProcessorDuration,
-          rollupCircuitsDuration: blockBuildingTimer.ms(),
-          ...block.getStats(),
-        } satisfies L2BlockBuiltStats,
-      );
+      const blockStats: L2BlockBuiltStats = {
+        eventName: 'l2-block-built',
+        creator: this.publisher.getSenderAddress().toString(),
+        duration: workDuration,
+        publicProcessDuration: publicProcessorDuration,
+        rollupCircuitsDuration: blockBuildingTimer.ms(),
+        ...block.getStats(),
+      };
+
+      const blockHash = block.hash();
+      const txHashes = validTxs.map(tx => tx.getTxHash());
+      this.log.info(`Built block ${block.number} with hash ${blockHash}`, {
+        txEffectsHash: block.header.contentCommitment.txsEffectsHash.toString('hex'),
+        blockHash,
+        globalVariables: block.header.globalVariables.toInspect(),
+        txHashes,
+        ...blockStats,
+      });
 
       if (this.isFlushing) {
-        this.log.info(`Flushing completed`);
+        this.log.verbose(`Sequencer flushing completed`);
       }
 
-      const txHashes = validTxs.map(tx => tx.getTxHash());
-
       this.isFlushing = false;
-      this.log.verbose('Collecting attestations');
+      this.log.debug('Collecting attestations');
       const stopCollectingAttestationsTimer = this.metrics.startCollectingAttestationsTimer();
       const attestations = await this.collectAttestations(block, txHashes);
-      this.log.verbose('Attestations collected');
+      if (attestations !== undefined) {
+        this.log.verbose(`Collected ${attestations.length} attestations`);
+      }
       stopCollectingAttestationsTimer();
-      this.log.verbose('Collecting proof quotes');
 
+      this.log.debug('Collecting proof quotes');
       const proofQuote = await this.createProofClaimForPreviousEpoch(newGlobalVariables.slotNumber.toBigInt());
-      this.log.info(proofQuote ? `Using proof quote ${inspect(proofQuote.payload)}` : 'No proof quote available');
 
       await this.publishL2Block(block, attestations, txHashes, proofQuote);
       this.metrics.recordPublishedBlock(workDuration);
       this.log.info(
-        `Submitted rollup block ${block.number} with ${numProcessedTxs} transactions duration=${Math.ceil(
-          workDuration,
-        )}ms (Submitter: ${this.publisher.getSenderAddress()})`,
+        `Published rollup block ${
+          block.number
+        } with ${numProcessedTxs} transactions and ${numMsgs} messages in ${Math.ceil(workDuration)}ms`,
+        {
+          blockNumber: block.number,
+          blockHash: blockHash,
+          slot,
+          txCount: numProcessedTxs,
+          msgCount: numMsgs,
+          duration: Math.ceil(workDuration),
+          submitter: this.publisher.getSenderAddress().toString(),
+        },
       );
     } catch (err) {
       this.metrics.recordFailedBlock();
@@ -670,11 +707,12 @@ export class Sequencer {
   protected async collectAttestations(block: L2Block, txHashes: TxHash[]): Promise<Signature[] | undefined> {
     // 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();
-    this.log.debug(`Attesting committee length ${committee.length}`);
 
     if (committee.length === 0) {
-      this.log.verbose(`Attesting committee length is 0, skipping`);
+      this.log.verbose(`Attesting committee is empty`);
       return undefined;
+    } else {
+      this.log.debug(`Attesting committee length is ${committee.length}`);
     }
 
     if (!this.validatorClient) {
@@ -685,28 +723,21 @@ export class Sequencer {
 
     const numberOfRequiredAttestations = Math.floor((committee.length * 2) / 3) + 1;
 
-    this.log.info('Creating block proposal');
+    this.log.debug('Creating block proposal');
     const proposal = await this.validatorClient.createBlockProposal(block.header, block.archive.root, txHashes);
+    if (!proposal) {
+      this.log.warn(`Failed to create block proposal, skipping collecting attestations`);
+      return undefined;
+    }
 
-    let secondsIntoSlot = getSecondsIntoSlot(
-      this.l1GenesisTime,
-      this.aztecSlotDuration,
-      block.header.globalVariables.slotNumber.toNumber(),
-    );
+    const slotNumber = block.header.globalVariables.slotNumber.toBigInt();
 
-    this.setState(SequencerState.PUBLISHING_BLOCK_TO_PEERS, secondsIntoSlot);
-    this.log.info('Broadcasting block proposal to validators');
+    this.setState(SequencerState.PUBLISHING_BLOCK_TO_PEERS, slotNumber);
+    this.log.debug('Broadcasting block proposal to validators');
     this.validatorClient.broadcastBlockProposal(proposal);
 
-    secondsIntoSlot = getSecondsIntoSlot(
-      this.l1GenesisTime,
-      this.aztecSlotDuration,
-      block.header.globalVariables.slotNumber.toNumber(),
-    );
-
-    this.setState(SequencerState.WAITING_FOR_ATTESTATIONS, secondsIntoSlot);
+    this.setState(SequencerState.WAITING_FOR_ATTESTATIONS, slotNumber);
     const attestations = await this.validatorClient.collectAttestations(proposal, numberOfRequiredAttestations);
-    this.log.info(`Collected attestations from validators, number of attestations: ${attestations.length}`);
 
     // note: the smart contract requires that the signatures are provided in the order of the committee
     return orderAttestations(attestations, committee);
@@ -717,16 +748,17 @@ export class Sequencer {
       // Find out which epoch we are currently in
       const epochToProve = await this.publisher.getClaimableEpoch();
       if (epochToProve === undefined) {
-        this.log.verbose(`No epoch to prove`);
+        this.log.debug(`No epoch to prove`);
         return undefined;
       }
 
       // Get quotes for the epoch to be proven
       const quotes = await this.p2pClient.getEpochProofQuotes(epochToProve);
-      this.log.info(`Retrieved ${quotes.length} quotes, slot: ${slotNumber}, epoch to prove: ${epochToProve}`);
-      for (const quote of quotes) {
-        this.log.verbose(inspect(quote.payload));
-      }
+      this.log.verbose(`Retrieved ${quotes.length} quotes for slot ${slotNumber} epoch ${epochToProve}`, {
+        epochToProve,
+        slotNumber,
+        quotes: quotes.map(q => q.payload),
+      });
       // ensure these quotes are still valid for the slot and have the contract validate them
       const validQuotesPromise = Promise.all(
         quotes.filter(x => x.payload.validUntilSlot >= slotNumber).map(x => this.publisher.validateProofQuote(x)),
@@ -741,9 +773,11 @@ export class Sequencer {
       const sortedQuotes = validQuotes.sort(
         (a: EpochProofQuote, b: EpochProofQuote) => a.payload.basisPointFee - b.payload.basisPointFee,
       );
-      return sortedQuotes[0];
+      const quote = sortedQuotes[0];
+      this.log.info(`Selected proof quote for proof claim`, quote.payload);
+      return quote;
     } catch (err) {
-      this.log.error(`Failed to create proof claim for previous epoch: ${err}`);
+      this.log.error(`Failed to create proof claim for previous epoch`, err, { slotNumber });
       return undefined;
     }
   }
@@ -761,13 +795,8 @@ export class Sequencer {
     txHashes?: TxHash[],
     proofQuote?: EpochProofQuote,
   ) {
-    const secondsIntoSlot = getSecondsIntoSlot(
-      this.l1GenesisTime,
-      this.aztecSlotDuration,
-      block.header.globalVariables.slotNumber.toNumber(),
-    );
     // Publishes new block to the network and awaits the tx to be mined
-    this.setState(SequencerState.PUBLISHING_BLOCK, secondsIntoSlot);
+    this.setState(SequencerState.PUBLISHING_BLOCK, block.header.globalVariables.slotNumber.toBigInt());
 
     const publishedL2Block = await this.publisher.proposeL2Block(block, attestations, txHashes, proofQuote);
     if (!publishedL2Block) {
@@ -793,7 +822,7 @@ export class Sequencer {
     for (const tx of txs) {
       const txSize = tx.getSize() - tx.clientIvcProof.clientIvcProofBuffer.length;
       if (totalSize + txSize > maxSize) {
-        this.log.warn(
+        this.log.debug(
           `Dropping tx ${tx.getTxHash()} with estimated size ${txSize} due to exceeding ${maxSize} block size limit (currently at ${totalSize})`,
         );
         continue;
@@ -830,7 +859,7 @@ export class Sequencer {
       p2p >= l2BlockSource.number &&
       l1ToL2MessageSource >= l2BlockSource.number;
 
-    this.log.verbose(`Sequencer sync check ${result ? 'succeeded' : 'failed'}`, {
+    this.log.debug(`Sequencer sync check ${result ? 'succeeded' : 'failed'}`, {
       worldStateNumber: worldState.number,
       worldStateHash: worldState.hash,
       l2BlockSourceNumber: l2BlockSource.number,

package/src/sequencer/utils.ts

@@ -75,5 +75,5 @@ export function orderAttestations(attestations: BlockAttestation[], orderAddress
 
 export function getSecondsIntoSlot(l1GenesisTime: number, aztecSlotDuration: number, slotNumber: number): number {
   const slotStartTimestamp = l1GenesisTime + slotNumber * aztecSlotDuration;
-  return Date.now() / 1000 - slotStartTimestamp;
+  return Number((Date.now() / 1000 - slotStartTimestamp).toFixed(3));
 }

package/src/tx_validator/gas_validator.ts

@@ -1,6 +1,6 @@
 import { type Tx, TxExecutionPhase, type TxValidator } from '@aztec/circuit-types';
 import { type AztecAddress, type Fr, FunctionSelector } from '@aztec/circuits.js';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 import { computeFeePayerBalanceStorageSlot, getExecutionRequestsByPhase } from '@aztec/simulator';
 
 /** Provides a view into public contract state */
@@ -9,7 +9,7 @@ export interface PublicStateSource {
 }
 
 export class GasTxValidator implements TxValidator<Tx> {
-  #log = createDebugLogger('aztec:sequencer:tx_validator:tx_gas');
+  #log = createLogger('sequencer:tx_validator:tx_gas');
   #publicDataSource: PublicStateSource;
   #feeJuiceAddress: AztecAddress;
 

package/src/tx_validator/phases_validator.ts

@@ -6,11 +6,11 @@ import {
   type TxValidator,
 } from '@aztec/circuit-types';
 import { type ContractDataSource } from '@aztec/circuits.js';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 import { ContractsDataSourcePublicDB, getExecutionRequestsByPhase } from '@aztec/simulator';
 
 export class PhasesTxValidator implements TxValidator<Tx> {
-  #log = createDebugLogger('aztec:sequencer:tx_validator:tx_phases');
+  #log = createLogger('sequencer:tx_validator:tx_phases');
   private contractDataSource: ContractsDataSourcePublicDB;
 
   constructor(contracts: ContractDataSource, private setupAllowList: AllowedElement[]) {

package/dest/block_builder/index.d.ts

@@ -1,7 +0,0 @@
-import { type BlockBuilder, type MerkleTreeReadOperations } from '@aztec/circuit-types';
-export * from './orchestrator.js';
-export * from './light.js';
-export interface BlockBuilderFactory {
-    create(db: MerkleTreeReadOperations): BlockBuilder;
-}
-//# sourceMappingURL=index.d.ts.map