@aztec/sequencer-client 0.66.0 → 0.67.1-devnet

package/src/sequencer/sequencer.ts

@@ -4,6 +4,7 @@ import {
   type L2Block,
   type L2BlockSource,
   type ProcessedTx,
+  SequencerConfigSchema,
   Tx,
   type TxHash,
   type TxValidator,
@@ -13,17 +14,19 @@ 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';
@@ -31,12 +34,11 @@ 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 GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
 import { type L1Publisher } from '../publisher/l1-publisher.js';
 import { prettyLogViemErrorMsg } from '../publisher/utils.js';
 import { type TxValidatorFactory } from '../tx_validator/tx_validator_factory.js';
+import { getDefaultAllowedSetupFunctions } from './allowed.js';
 import { type SequencerConfig } from './config.js';
 import { SequencerMetrics } from './metrics.js';
 import { SequencerState, getSecondsIntoSlot, orderAttestations } from './utils.js';
@@ -75,13 +77,11 @@ export class Sequencer {
   private pollingIntervalMs: number = 1000;
   private maxTxsPerBlock = 32;
   private minTxsPerBLock = 1;
-  private minSecondsBetweenBlocks = 0;
-  private maxSecondsBetweenBlocks = 0;
   // TODO: zero values should not be allowed for the following 2 values in PROD
   private _coinbase = EthAddress.ZERO;
   private _feeRecipient = AztecAddress.ZERO;
   private state = SequencerState.STOPPED;
-  private allowedInSetup: AllowedElement[] = [];
+  private allowedInSetup: AllowedElement[] = getDefaultAllowedSetupFunctions();
   private maxBlockSizeInBytes: number = 1024 * 1024;
   private metrics: SequencerMetrics;
   private isFlushing: boolean = false;
@@ -108,11 +108,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 +126,8 @@ export class Sequencer {
    * @param config - New parameters.
    */
   public updateConfig(config: SequencerConfig) {
+    this.log.info(`Sequencer config set`, omit(pickFromSchema(config, SequencerConfigSchema), 'allowedInSetup'));
+
     if (config.transactionPollingIntervalMS !== undefined) {
       this.pollingIntervalMs = config.transactionPollingIntervalMS;
     }
@@ -136,12 +137,6 @@ export class Sequencer {
     if (config.minTxsPerBlock !== undefined) {
       this.minTxsPerBLock = config.minTxsPerBlock;
     }
-    if (config.minSecondsBetweenBlocks !== undefined) {
-      this.minSecondsBetweenBlocks = config.minSecondsBetweenBlocks;
-    }
-    if (config.maxSecondsBetweenBlocks !== undefined) {
-      this.maxSecondsBetweenBlocks = config.maxSecondsBetweenBlocks;
-    }
     if (config.coinbase) {
       this._coinbase = config.coinbase;
     }
@@ -187,10 +182,10 @@ export class Sequencer {
    * Starts the sequencer and moves to IDLE state.
    */
   public start() {
-    this.runningPromise = new RunningPromise(this.work.bind(this), this.pollingIntervalMs);
-    this.runningPromise.start();
+    this.runningPromise = new RunningPromise(this.work.bind(this), this.log, this.pollingIntervalMs);
     this.setState(SequencerState.IDLE, 0n, true /** force */);
-    this.log.info('Sequencer started');
+    this.runningPromise.start();
+    this.log.info(`Sequencer started with address ${this.publisher.getSenderAddress().toString()}`);
     return Promise.resolve();
   }
 
@@ -199,6 +194,7 @@ 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, 0n, true /** force */);
@@ -237,12 +233,9 @@ export class Sequencer {
     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, 0n);
 
     const chainTip = await this.l2BlockSource.getBlock(-1);
@@ -278,18 +271,23 @@ export class Sequencer {
       return;
     }
 
+    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(),
@@ -311,6 +309,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;
@@ -322,11 +324,12 @@ 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, 0n);
   }
 
+  @trackSpan('Sequencer.work')
   protected async work() {
     try {
       await this.doRealWork();
@@ -342,33 +345,20 @@ export class Sequencer {
     }
   }
 
-  /** 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 {
-    const lastBlockTime = historicalHeader?.globalVariables.timestamp.toNumber() || 0;
-    const currentTime = Math.floor(Date.now() / 1000);
-    const elapsed = currentTime - lastBlockTime;
-
-    return this.maxSecondsBetweenBlocks > 0 && elapsed >= this.maxSecondsBetweenBlocks;
-  }
-
   async mayProposeBlock(tipArchive: Buffer, proposalBlockNumber: bigint): Promise<bigint> {
     // This checks that we can propose, and gives us the slot that we are to propose for
     try {
       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}`, {
-        publisherAddress: this.publisher.publisherAddress,
-      });
       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;
@@ -385,7 +375,6 @@ export class Sequencer {
     }
 
     const bufferSeconds = this.timeTable[proposedState] - secondsIntoSlot;
-    this.metrics.recordStateTransitionBufferMs(bufferSeconds * 1000, proposedState);
 
     if (bufferSeconds < 0) {
       this.log.warn(
@@ -393,6 +382,9 @@ 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`,
     );
@@ -410,19 +402,18 @@ export class Sequencer {
    */
   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;
@@ -436,53 +427,29 @@ export class Sequencer {
       `Last block mined at ${lastBlockTime} current time is ${currentTime} (elapsed ${elapsedSinceLastBlock})`,
     );
 
-    // 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(
-        `Not creating block because not enough time ${this.minSecondsBetweenBlocks} has passed since last block`,
+    // We need to have at least minTxsPerBLock txs.
+    if (args.pendingTxsCount != undefined && args.pendingTxsCount < this.minTxsPerBLock) {
+      this.log.verbose(
+        `Not creating block because not enough txs in the pool (got ${args.pendingTxsCount} min ${this.minTxsPerBLock})`,
       );
       return false;
     }
 
-    const skipCheck = this.skipMinTxsPerBlockCheck(historicalHeader);
-
-    // If we haven't hit the maxSecondsBetweenBlocks, we need to have at least minTxsPerBLock txs.
-    if (args.pendingTxsCount != undefined) {
-      if (args.pendingTxsCount < this.minTxsPerBLock) {
-        if (skipCheck) {
-          this.log.debug(
-            `Creating block with only ${args.pendingTxsCount} txs as more than ${this.maxSecondsBetweenBlocks}s have passed since last block`,
-          );
-        } else {
-          this.log.debug(
-            `Not creating block because not enough txs in the pool (got ${args.pendingTxsCount} min ${this.minTxsPerBLock})`,
-          );
-          return false;
-        }
-      }
-    }
-
     // Bail if we don't have enough valid txs
-    if (args.validTxsCount != undefined) {
-      // Bail if we don't have enough valid txs
-      if (!skipCheck && args.validTxsCount < this.minTxsPerBLock) {
-        this.log.debug(
-          `Not creating block because not enough valid txs loaded from the pool (got ${args.validTxsCount} min ${this.minTxsPerBLock})`,
-        );
-        return false;
-      }
+    if (args.validTxsCount != undefined && args.validTxsCount < this.minTxsPerBLock) {
+      this.log.verbose(
+        `Not creating block because not enough valid txs loaded from the pool (got ${args.validTxsCount} min ${this.minTxsPerBLock})`,
+      );
+      return false;
     }
 
     // TODO: This check should be processedTxs.length < this.minTxsPerBLock, so we don't publish a block with
     // less txs than the minimum. But that'd cause the entire block to be aborted and retried. Instead, we should
     // go back to the p2p pool and load more txs until we hit our minTxsPerBLock target. Only if there are no txs
     // 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');
-        return false;
-      }
+    if (args.processedTxsCount === 0 && this.minTxsPerBLock > 0) {
+      this.log.verbose('No txs processed correctly to build block.');
+      return false;
     }
 
     return true;
@@ -501,13 +468,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;
@@ -515,7 +492,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();
@@ -525,28 +502,30 @@ export class Sequencer {
       const processor = this.publicProcessorFactory.create(publicProcessorFork, historicalHeader, newGlobalVariables);
       const blockBuildingTimer = new Timer();
       const blockBuilder = this.blockBuilderFactory.create(orchestratorFork);
-      await blockBuilder.startNewBlock(blockSize, newGlobalVariables, l1ToL2Messages);
+      await blockBuilder.startNewBlock(newGlobalVariables, l1ToL2Messages);
 
       const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() =>
-        processor.process(
-          validTxs,
-          blockSize,
-          blockBuilder,
-          this.txValidatorFactory.validatorForProcessedTxs(publicProcessorFork),
-        ),
+        processor.process(validTxs, blockSize, this.txValidatorFactory.validatorForProcessedTxs(publicProcessorFork)),
       );
       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));
       }
+      await blockBuilder.addTxs(processedTxs);
 
       await interrupt?.(processedTxs);
 
       // 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();
@@ -569,21 +548,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();
-    this.setState(SequencerState.CREATING_BLOCK, newGlobalVariables.slotNumber.toBigInt());
-    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
@@ -606,12 +582,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
@@ -619,43 +591,55 @@ 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}`, {
+        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();
@@ -676,11 +660,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) {
@@ -691,22 +676,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.verbose(`Failed to create block proposal, skipping`);
+      this.log.warn(`Failed to create block proposal, skipping collecting attestations`);
       return undefined;
     }
 
     const slotNumber = block.header.globalVariables.slotNumber.toBigInt();
 
     this.setState(SequencerState.PUBLISHING_BLOCK_TO_PEERS, slotNumber);
-    this.log.info('Broadcasting block proposal to validators');
+    this.log.debug('Broadcasting block proposal to validators');
     this.validatorClient.broadcastBlockProposal(proposal);
 
     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 +701,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 +726,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;
     }
   }
@@ -788,7 +775,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;
@@ -825,7 +812,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,