@aztec/sequencer-client 0.0.1-commit.e6bd8901 → 0.0.1-commit.ee80a48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/sequencer-client",
-  "version": "0.0.1-commit.e6bd8901",
+  "version": "0.0.1-commit.ee80a48",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -26,38 +26,38 @@
     "test:integration:run": "NODE_NO_WARNINGS=1 node --experimental-vm-modules $(yarn bin jest) --no-cache --config jest.integration.config.json"
   },
   "dependencies": {
-    "@aztec/aztec.js": "0.0.1-commit.e6bd8901",
-    "@aztec/bb-prover": "0.0.1-commit.e6bd8901",
-    "@aztec/blob-client": "0.0.1-commit.e6bd8901",
-    "@aztec/blob-lib": "0.0.1-commit.e6bd8901",
-    "@aztec/constants": "0.0.1-commit.e6bd8901",
-    "@aztec/epoch-cache": "0.0.1-commit.e6bd8901",
-    "@aztec/ethereum": "0.0.1-commit.e6bd8901",
-    "@aztec/foundation": "0.0.1-commit.e6bd8901",
-    "@aztec/l1-artifacts": "0.0.1-commit.e6bd8901",
-    "@aztec/merkle-tree": "0.0.1-commit.e6bd8901",
-    "@aztec/node-keystore": "0.0.1-commit.e6bd8901",
-    "@aztec/noir-acvm_js": "0.0.1-commit.e6bd8901",
-    "@aztec/noir-contracts.js": "0.0.1-commit.e6bd8901",
-    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.e6bd8901",
-    "@aztec/noir-types": "0.0.1-commit.e6bd8901",
-    "@aztec/p2p": "0.0.1-commit.e6bd8901",
-    "@aztec/protocol-contracts": "0.0.1-commit.e6bd8901",
-    "@aztec/prover-client": "0.0.1-commit.e6bd8901",
-    "@aztec/simulator": "0.0.1-commit.e6bd8901",
-    "@aztec/slasher": "0.0.1-commit.e6bd8901",
-    "@aztec/stdlib": "0.0.1-commit.e6bd8901",
-    "@aztec/telemetry-client": "0.0.1-commit.e6bd8901",
-    "@aztec/validator-client": "0.0.1-commit.e6bd8901",
-    "@aztec/validator-ha-signer": "0.0.1-commit.e6bd8901",
-    "@aztec/world-state": "0.0.1-commit.e6bd8901",
+    "@aztec/aztec.js": "0.0.1-commit.ee80a48",
+    "@aztec/bb-prover": "0.0.1-commit.ee80a48",
+    "@aztec/blob-client": "0.0.1-commit.ee80a48",
+    "@aztec/blob-lib": "0.0.1-commit.ee80a48",
+    "@aztec/constants": "0.0.1-commit.ee80a48",
+    "@aztec/epoch-cache": "0.0.1-commit.ee80a48",
+    "@aztec/ethereum": "0.0.1-commit.ee80a48",
+    "@aztec/foundation": "0.0.1-commit.ee80a48",
+    "@aztec/l1-artifacts": "0.0.1-commit.ee80a48",
+    "@aztec/merkle-tree": "0.0.1-commit.ee80a48",
+    "@aztec/node-keystore": "0.0.1-commit.ee80a48",
+    "@aztec/noir-acvm_js": "0.0.1-commit.ee80a48",
+    "@aztec/noir-contracts.js": "0.0.1-commit.ee80a48",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.ee80a48",
+    "@aztec/noir-types": "0.0.1-commit.ee80a48",
+    "@aztec/p2p": "0.0.1-commit.ee80a48",
+    "@aztec/protocol-contracts": "0.0.1-commit.ee80a48",
+    "@aztec/prover-client": "0.0.1-commit.ee80a48",
+    "@aztec/simulator": "0.0.1-commit.ee80a48",
+    "@aztec/slasher": "0.0.1-commit.ee80a48",
+    "@aztec/stdlib": "0.0.1-commit.ee80a48",
+    "@aztec/telemetry-client": "0.0.1-commit.ee80a48",
+    "@aztec/validator-client": "0.0.1-commit.ee80a48",
+    "@aztec/validator-ha-signer": "0.0.1-commit.ee80a48",
+    "@aztec/world-state": "0.0.1-commit.ee80a48",
     "lodash.chunk": "^4.2.0",
     "tslib": "^2.4.0",
     "viem": "npm:@aztec/viem@2.38.2"
   },
   "devDependencies": {
-    "@aztec/archiver": "0.0.1-commit.e6bd8901",
-    "@aztec/kv-store": "0.0.1-commit.e6bd8901",
+    "@aztec/archiver": "0.0.1-commit.ee80a48",
+    "@aztec/kv-store": "0.0.1-commit.ee80a48",
     "@electric-sql/pglite": "^0.3.14",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",

package/src/client/sequencer-client.ts

@@ -85,7 +85,7 @@ export class SequencerClient {
       publicClient,
       l1TxUtils.map(x => x.getSenderAddress()),
     );
-    const publisherManager = new PublisherManager(l1TxUtils, config);
+    const publisherManager = new PublisherManager(l1TxUtils, config, log.getBindings());
     const rollupContract = new RollupContract(publicClient, config.l1Contracts.rollupAddress.toString());
     const [l1GenesisTime, slotDuration, rollupVersion, rollupManaLimit] = await Promise.all([
       rollupContract.getL1GenesisTime(),

package/src/publisher/sequencer-publisher-metrics.ts

@@ -7,6 +7,7 @@ import {
   Metrics,
   type TelemetryClient,
   type UpDownCounter,
+  createUpDownCounterWithDefault,
 } from '@aztec/telemetry-client';
 
 import { formatEther } from 'viem/utils';
@@ -41,7 +42,10 @@ export class SequencerPublisherMetrics {
 
     this.gasPrice = meter.createHistogram(Metrics.L1_PUBLISHER_GAS_PRICE);
 
-    this.txCount = meter.createUpDownCounter(Metrics.L1_PUBLISHER_TX_COUNT);
+    this.txCount = createUpDownCounterWithDefault(meter, Metrics.L1_PUBLISHER_TX_COUNT, {
+      [Attributes.L1_TX_TYPE]: ['process'],
+      [Attributes.OK]: [true, false],
+    });
 
     this.txDuration = meter.createHistogram(Metrics.L1_PUBLISHER_TX_DURATION);
 
@@ -59,9 +63,9 @@ export class SequencerPublisherMetrics {
 
     this.blobInclusionBlocksHistogram = meter.createHistogram(Metrics.L1_PUBLISHER_BLOB_INCLUSION_BLOCKS);
 
-    this.blobTxSuccessCounter = meter.createUpDownCounter(Metrics.L1_PUBLISHER_BLOB_TX_SUCCESS);
+    this.blobTxSuccessCounter = createUpDownCounterWithDefault(meter, Metrics.L1_PUBLISHER_BLOB_TX_SUCCESS);
 
-    this.blobTxFailureCounter = meter.createUpDownCounter(Metrics.L1_PUBLISHER_BLOB_TX_FAILURE);
+    this.blobTxFailureCounter = createUpDownCounterWithDefault(meter, Metrics.L1_PUBLISHER_BLOB_TX_FAILURE);
 
     this.txTotalFee = meter.createHistogram(Metrics.L1_PUBLISHER_TX_TOTAL_FEE);
 

package/src/publisher/sequencer-publisher.ts

@@ -18,11 +18,12 @@ import {
   type L1BlobInputs,
   type L1TxConfig,
   type L1TxRequest,
+  MAX_L1_TX_LIMIT,
   type TransactionStats,
   WEI_CONST,
 } from '@aztec/ethereum/l1-tx-utils';
 import type { L1TxUtilsWithBlobs } from '@aztec/ethereum/l1-tx-utils-with-blobs';
-import { FormattedViemError, formatViemError, tryExtractEvent } from '@aztec/ethereum/utils';
+import { FormattedViemError, formatViemError, mergeAbis, tryExtractEvent } from '@aztec/ethereum/utils';
 import { sumBigint } from '@aztec/foundation/bigint';
 import { toHex as toPaddedHex } from '@aztec/foundation/bigint-buffer';
 import { CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
@@ -122,11 +123,6 @@ export class SequencerPublisher {
 
   /** L1 fee analyzer for fisherman mode */
   private l1FeeAnalyzer?: L1FeeAnalyzer;
-  // @note - with blobs, the below estimate seems too large.
-  // Total used for full block from int_l1_pub e2e test: 1m (of which 86k is 1x blob)
-  // Total used for emptier block from above test: 429k (of which 84k is 1x blob)
-  public static PROPOSE_GAS_GUESS: bigint = 12_000_000n;
-
   // A CALL to a cold address is 2700 gas
   public static MULTICALL_OVERHEAD_GAS_GUESS = 5000n;
 
@@ -273,7 +269,7 @@ export class SequencerPublisher {
     // Start the analysis
     const analysisId = await this.l1FeeAnalyzer.startAnalysis(
       l2SlotNumber,
-      gasLimit > 0n ? gasLimit : SequencerPublisher.PROPOSE_GAS_GUESS,
+      gasLimit > 0n ? gasLimit : MAX_L1_TX_LIMIT,
       l1Requests,
       blobConfig,
       onComplete,
@@ -346,7 +342,16 @@ export class SequencerPublisher {
 
     // Merge gasConfigs. Yields the sum of gasLimits, and the earliest txTimeoutAt, or undefined if no gasConfig sets them.
     const gasLimits = gasConfigs.map(g => g?.gasLimit).filter((g): g is bigint => g !== undefined);
-    const gasLimit = gasLimits.length > 0 ? sumBigint(gasLimits) : undefined; // sum
+    let gasLimit = gasLimits.length > 0 ? sumBigint(gasLimits) : undefined; // sum
+    // Cap at L1 block gas limit so the node accepts the tx ("gas limit too high" otherwise).
+    const maxGas = MAX_L1_TX_LIMIT;
+    if (gasLimit !== undefined && gasLimit > maxGas) {
+      this.log.debug('Capping bundled tx gas limit to L1 max', {
+        requested: gasLimit,
+        capped: maxGas,
+      });
+      gasLimit = maxGas;
+    }
     const txTimeoutAts = gasConfigs.map(g => g?.txTimeoutAt).filter((g): g is Date => g !== undefined);
     const txTimeoutAt = txTimeoutAts.length > 0 ? new Date(Math.min(...txTimeoutAts.map(g => g.getTime()))) : undefined; // earliest
     const txConfig: RequestWithExpiry['gasConfig'] = { gasLimit, txTimeoutAt };
@@ -517,7 +522,12 @@ export class SequencerPublisher {
     this.log.debug(`Simulating invalidate checkpoint ${checkpointNumber}`, { ...logData, request });
 
     try {
-      const { gasUsed } = await this.l1TxUtils.simulate(request, undefined, undefined, ErrorsAbi);
+      const { gasUsed } = await this.l1TxUtils.simulate(
+        request,
+        undefined,
+        undefined,
+        mergeAbis([request.abi ?? [], ErrorsAbi]),
+      );
       this.log.verbose(`Simulation for invalidate checkpoint ${checkpointNumber} succeeded`, {
         ...logData,
         request,
@@ -536,7 +546,7 @@ export class SequencerPublisher {
 
       // If the error is due to the checkpoint not being in the pending chain, and it was indeed removed by someone else,
       // we can safely ignore it and return undefined so we go ahead with checkpoint building.
-      if (viemError.message?.includes('Rollup__BlockNotInPendingChain')) {
+      if (viemError.message?.includes('Rollup__CheckpointNotInPendingChain')) {
         this.log.verbose(
           `Simulation for invalidate checkpoint ${checkpointNumber} failed due to checkpoint not being in pending chain`,
           { ...logData, request, error: viemError.message },
@@ -700,7 +710,7 @@ export class SequencerPublisher {
     });
 
     try {
-      await this.l1TxUtils.simulate(request, { time: timestamp }, [], ErrorsAbi);
+      await this.l1TxUtils.simulate(request, { time: timestamp }, [], mergeAbis([request.abi ?? [], ErrorsAbi]));
       this.log.debug(`Simulation for ${action} at slot ${slotNumber} succeeded`, { request });
     } catch (err) {
       this.log.error(`Failed simulation for ${action} at slot ${slotNumber} (enqueuing the action anyway)`, err);
@@ -999,12 +1009,14 @@ export class SequencerPublisher {
     this.log.debug(`Simulating ${action} for slot ${slotNumber}`, logData);
 
     let gasUsed: bigint;
+    const simulateAbi = mergeAbis([request.abi ?? [], ErrorsAbi]);
     try {
-      ({ gasUsed } = await this.l1TxUtils.simulate(request, { time: timestamp }, [], ErrorsAbi)); // TODO(palla/slash): Check the timestamp logic
+      ({ gasUsed } = await this.l1TxUtils.simulate(request, { time: timestamp }, [], simulateAbi)); // TODO(palla/slash): Check the timestamp logic
       this.log.verbose(`Simulation for ${action} succeeded`, { ...logData, request, gasUsed });
     } catch (err) {
-      const viemError = formatViemError(err);
+      const viemError = formatViemError(err, simulateAbi);
       this.log.error(`Simulation for ${action} at ${slotNumber} failed`, viemError, logData);
+
       return false;
     }
 
@@ -1012,10 +1024,14 @@ export class SequencerPublisher {
     const gasLimit = this.l1TxUtils.bumpGasLimit(BigInt(Math.ceil((Number(gasUsed) * 64) / 63)));
     logData.gasLimit = gasLimit;
 
+    // Store the ABI used for simulation on the request so Multicall3.forward can decode errors
+    // when the tx is sent and a revert is diagnosed via simulation.
+    const requestWithAbi = { ...request, abi: simulateAbi };
+
     this.log.debug(`Enqueuing ${action}`, logData);
     this.addRequest({
       action,
-      request,
+      request: requestWithAbi,
       gasConfig: { gasLimit },
       lastValidL2Slot: slotNumber,
       checkSuccess: (_req, result) => {
@@ -1171,20 +1187,20 @@ export class SequencerPublisher {
         {
           to: this.rollupContract.address,
           data: rollupData,
-          gas: SequencerPublisher.PROPOSE_GAS_GUESS,
+          gas: MAX_L1_TX_LIMIT,
           ...(this.proposerAddressForSimulation && { from: this.proposerAddressForSimulation.toString() }),
         },
         {
           // @note we add 1n to the timestamp because geth implementation doesn't like simulation timestamp to be equal to the current block timestamp
           time: timestamp + 1n,
           // @note reth should have a 30m gas limit per block but throws errors that this tx is beyond limit so we increase here
-          gasLimit: SequencerPublisher.PROPOSE_GAS_GUESS * 2n,
+          gasLimit: MAX_L1_TX_LIMIT * 2n,
         },
         stateOverrides,
         RollupAbi,
         {
           // @note fallback gas estimate to use if the node doesn't support simulation API
-          fallbackGasEstimate: SequencerPublisher.PROPOSE_GAS_GUESS,
+          fallbackGasEstimate: MAX_L1_TX_LIMIT,
         },
       )
       .catch(err => {
@@ -1194,7 +1210,7 @@ export class SequencerPublisher {
           this.log.debug(`Ignoring expected ValidatorSelection__MissingProposerSignature error in fisherman mode`);
           // Return a minimal simulation result with the fallback gas estimate
           return {
-            gasUsed: SequencerPublisher.PROPOSE_GAS_GUESS,
+            gasUsed: MAX_L1_TX_LIMIT,
             logs: [],
           };
         }

package/src/sequencer/checkpoint_proposal_job.ts

@@ -1,16 +1,22 @@
 import { NUM_CHECKPOINT_END_MARKER_FIELDS, getNumBlockEndBlobFields } from '@aztec/blob-lib/encoding';
 import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB } from '@aztec/constants';
 import type { EpochCache } from '@aztec/epoch-cache';
-import { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import {
+  BlockNumber,
+  CheckpointNumber,
+  EpochNumber,
+  IndexWithinCheckpoint,
+  SlotNumber,
+} from '@aztec/foundation/branded-types';
 import { randomInt } from '@aztec/foundation/crypto/random';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { filter } from '@aztec/foundation/iterator';
-import type { Logger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { sleep, sleepUntil } from '@aztec/foundation/sleep';
 import { type DateProvider, Timer } from '@aztec/foundation/timer';
-import { type TypedEventEmitter, unfreeze } from '@aztec/foundation/types';
+import { type TypedEventEmitter, isErrorClass, unfreeze } from '@aztec/foundation/types';
 import type { P2P } from '@aztec/p2p';
 import type { SlasherClientInterface } from '@aztec/slasher';
 import {
@@ -24,10 +30,11 @@ import {
 import type { Checkpoint } from '@aztec/stdlib/checkpoint';
 import { getSlotStartBuildTimestamp } from '@aztec/stdlib/epoch-helpers';
 import { Gas } from '@aztec/stdlib/gas';
-import type {
-  PublicProcessorLimits,
-  ResolvedSequencerConfig,
-  WorldStateSynchronizer,
+import {
+  NoValidTxsError,
+  type PublicProcessorLimits,
+  type ResolvedSequencerConfig,
+  type WorldStateSynchronizer,
 } from '@aztec/stdlib/interfaces/server';
 import { type L1ToL2MessageSource, computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
 import type { BlockProposalOptions, CheckpointProposal, CheckpointProposalOptions } from '@aztec/stdlib/p2p';
@@ -59,6 +66,8 @@ const TXS_POLLING_MS = 500;
  * the Sequencer once the check for being the proposer for the slot has succeeded.
  */
 export class CheckpointProposalJob implements Traceable {
+  protected readonly log: Logger;
+
   constructor(
     private readonly epoch: EpochNumber,
     private readonly slot: SlotNumber,
@@ -86,9 +95,11 @@ export class CheckpointProposalJob implements Traceable {
     private readonly metrics: SequencerMetrics,
     private readonly eventEmitter: TypedEventEmitter<SequencerEvents>,
     private readonly setStateFn: (state: SequencerState, slot?: SlotNumber) => void,
-    protected readonly log: Logger,
     public readonly tracer: Tracer,
-  ) {}
+    bindings?: LoggerBindings,
+  ) {
+    this.log = createLogger('sequencer:checkpoint-proposal', { ...bindings, instanceId: `slot-${slot}` });
+  }
 
   /**
    * Executes the checkpoint proposal job.
@@ -190,6 +201,7 @@ export class CheckpointProposalJob implements Traceable {
         l1ToL2Messages,
         previousCheckpointOutHashes,
         fork,
+        this.log.getBindings(),
       );
 
       // Options for the validator client when creating block and checkpoint proposals
@@ -220,19 +232,7 @@ export class CheckpointProposalJob implements Traceable {
         // These errors are expected in HA mode, so we yield and let another HA node handle the slot
         // The only distinction between the 2 errors is SlashingProtectionError throws when the payload is different,
         // which is normal for block building (may have picked different txs)
-        if (err instanceof DutyAlreadySignedError) {
-          this.log.info(`Checkpoint proposal for slot ${this.slot} already signed by another HA node, yielding`, {
-            slot: this.slot,
-            signedByNode: err.signedByNode,
-          });
-          return undefined;
-        }
-        if (err instanceof SlashingProtectionError) {
-          this.log.info(`Checkpoint proposal for slot ${this.slot} blocked by slashing protection, yielding`, {
-            slot: this.slot,
-            existingMessageHash: err.existingMessageHash,
-            attemptedMessageHash: err.attemptedMessageHash,
-          });
+        if (this.handleHASigningError(err, 'Block proposal')) {
           return undefined;
         }
         throw err;
@@ -301,20 +301,8 @@ export class CheckpointProposalJob implements Traceable {
         );
       } catch (err) {
         // We shouldn't really get here since we yield to another HA node
-        // as soon as we see these errors when creating block proposals.
-        if (err instanceof DutyAlreadySignedError) {
-          this.log.info(`Attestations signature for slot ${this.slot} already signed by another HA node, yielding`, {
-            slot: this.slot,
-            signedByNode: err.signedByNode,
-          });
-          return undefined;
-        }
-        if (err instanceof SlashingProtectionError) {
-          this.log.info(`Attestations signature for slot ${this.slot} blocked by slashing protection, yielding`, {
-            slot: this.slot,
-            existingMessageHash: err.existingMessageHash,
-            attemptedMessageHash: err.attemptedMessageHash,
-          });
+        // as soon as we see these errors when creating block or checkpoint proposals.
+        if (this.handleHASigningError(err, 'Attestations signature')) {
           return undefined;
         }
         throw err;
@@ -367,7 +355,7 @@ export class CheckpointProposalJob implements Traceable {
 
     while (true) {
       const blocksBuilt = blocksInCheckpoint.length;
-      const indexWithinCheckpoint = blocksBuilt;
+      const indexWithinCheckpoint = IndexWithinCheckpoint(blocksBuilt);
       const blockNumber = BlockNumber(initialBlockNumber + blocksBuilt);
 
       const secondsIntoSlot = this.getSecondsIntoSlot();
@@ -397,6 +385,7 @@ export class CheckpointProposalJob implements Traceable {
         remainingBlobFields,
       });
 
+      // TODO(palla/mbps): Review these conditions. We may want to keep trying in some scenarios.
       if (!buildResult && timingInfo.isLastBlock) {
         // If no block was produced due to not enough txs and this was the last subslot, exit
         break;
@@ -433,6 +422,8 @@ export class CheckpointProposalJob implements Traceable {
         this.log.error(`Failed to sync proposed block ${block.number} to archiver`, { blockNumber: block.number, err });
       });
 
+      usedTxs.forEach(tx => txHashesAlreadyIncluded.add(tx.txHash.toString()));
+
       // If this is the last block, exit the loop now so we start collecting attestations
       if (timingInfo.isLastBlock) {
         this.log.verbose(`Completed final block ${blockNumber} for slot ${this.slot}`, {
@@ -481,13 +472,13 @@ export class CheckpointProposalJob implements Traceable {
 
   /** Builds a single block. Called from the main block building loop. */
   @trackSpan('CheckpointProposalJob.buildSingleBlock')
-  private async buildSingleBlock(
+  protected async buildSingleBlock(
     checkpointBuilder: CheckpointBuilder,
     opts: {
       forceCreate?: boolean;
       blockTimestamp: bigint;
       blockNumber: BlockNumber;
-      indexWithinCheckpoint: number;
+      indexWithinCheckpoint: IndexWithinCheckpoint;
       buildDeadline: Date | undefined;
       txHashesAlreadyIncluded: Set<string>;
       remainingBlobFields: number;
@@ -548,45 +539,38 @@ export class CheckpointProposalJob implements Traceable {
       };
 
       // Actually build the block by executing txs
-      const workTimer = new Timer();
-      const {
-        publicGas,
-        block,
-        publicProcessorDuration,
-        numTxs,
-        blockBuildingTimer,
-        usedTxs,
-        failedTxs,
-        usedTxBlobFields,
-      } = await checkpointBuilder.buildBlock(pendingTxs, blockNumber, blockTimestamp, blockBuilderOptions);
-      const blockBuildDuration = workTimer.ms();
+      const buildResult = await this.buildSingleBlockWithCheckpointBuilder(
+        checkpointBuilder,
+        pendingTxs,
+        blockNumber,
+        blockTimestamp,
+        blockBuilderOptions,
+      );
 
       // If any txs failed during execution, drop them from the mempool so we don't pick them up again
-      await this.dropFailedTxsFromP2P(failedTxs);
+      await this.dropFailedTxsFromP2P(buildResult.failedTxs);
 
       // Check if we have created a block with enough txs. If there were invalid txs in the pool, or if execution took
       // too long, then we may not get to minTxsPerBlock after executing public functions.
       const minValidTxs = this.config.minValidTxsPerBlock ?? minTxs;
-      if (!forceCreate && numTxs < minValidTxs) {
+      const numTxs = buildResult.status === 'no-valid-txs' ? 0 : buildResult.numTxs;
+      if (buildResult.status === 'no-valid-txs' || (!forceCreate && numTxs < minValidTxs)) {
         this.log.warn(
-          `Block ${blockNumber} at index ${indexWithinCheckpoint} on slot ${this.slot} has too few valid txs to be proposed (got ${numTxs} but required ${minValidTxs})`,
-          { slot: this.slot, blockNumber, numTxs, indexWithinCheckpoint },
+          `Block ${blockNumber} at index ${indexWithinCheckpoint} on slot ${this.slot} has too few valid txs to be proposed`,
+          { slot: this.slot, blockNumber, numTxs, indexWithinCheckpoint, minValidTxs, buildResult: buildResult.status },
         );
-        this.eventEmitter.emit('block-tx-count-check-failed', {
-          minTxs: minValidTxs,
-          availableTxs: numTxs,
-          slot: this.slot,
-        });
+        this.eventEmitter.emit('block-build-failed', { reason: `Insufficient valid txs`, slot: this.slot });
         this.metrics.recordBlockProposalFailed('insufficient_valid_txs');
         return undefined;
       }
 
       // Block creation succeeded, emit stats and metrics
+      const { publicGas, block, publicProcessorDuration, usedTxs, usedTxBlobFields, blockBuildDuration } = buildResult;
+
       const blockStats = {
         eventName: 'l2-block-built',
         duration: blockBuildDuration,
         publicProcessDuration: publicProcessorDuration,
-        rollupCircuitsDuration: blockBuildingTimer.ms(),
         ...block.getStats(),
       } satisfies L2BlockBuiltStats;
 
@@ -612,17 +596,40 @@ export class CheckpointProposalJob implements Traceable {
     }
   }
 
+  /** Uses the checkpoint builder to build a block, catching specific txs */
+  private async buildSingleBlockWithCheckpointBuilder(
+    checkpointBuilder: CheckpointBuilder,
+    pendingTxs: AsyncIterable<Tx>,
+    blockNumber: BlockNumber,
+    blockTimestamp: bigint,
+    blockBuilderOptions: PublicProcessorLimits,
+  ) {
+    try {
+      const workTimer = new Timer();
+      const result = await checkpointBuilder.buildBlock(pendingTxs, blockNumber, blockTimestamp, blockBuilderOptions);
+      const blockBuildDuration = workTimer.ms();
+      return { ...result, blockBuildDuration, status: 'success' as const };
+    } catch (err: unknown) {
+      if (isErrorClass(err, NoValidTxsError)) {
+        return { failedTxs: err.failedTxs, status: 'no-valid-txs' as const };
+      }
+      throw err;
+    }
+  }
+
   /** Waits until minTxs are available on the pool for building a block. */
   @trackSpan('CheckpointProposalJob.waitForMinTxs')
   private async waitForMinTxs(opts: {
     forceCreate?: boolean;
     blockNumber: BlockNumber;
-    indexWithinCheckpoint: number;
+    indexWithinCheckpoint: IndexWithinCheckpoint;
     buildDeadline: Date | undefined;
   }): Promise<{ canStartBuilding: boolean; availableTxs: number }> {
-    const minTxs = this.config.minTxsPerBlock;
     const { indexWithinCheckpoint, blockNumber, buildDeadline, forceCreate } = opts;
 
+    // We only allow a block with 0 txs in the first block of the checkpoint
+    const minTxs = indexWithinCheckpoint > 0 && this.config.minTxsPerBlock === 0 ? 1 : this.config.minTxsPerBlock;
+
     // Deadline is undefined if we are not enforcing the timetable, meaning we'll exit immediately when out of time
     const startBuildingDeadline = buildDeadline
       ? new Date(buildDeadline.getTime() - this.timetable.minExecutionTime * 1000)
@@ -684,7 +691,7 @@ export class CheckpointProposalJob implements Traceable {
     const attestationTimeAllowed = this.config.enforceTimeTable
       ? this.timetable.getMaxAllowedTime(SequencerState.PUBLISHING_CHECKPOINT)!
       : this.l1Constants.slotDuration;
-    const attestationDeadline = new Date(this.dateProvider.now() + attestationTimeAllowed * 1000);
+    const attestationDeadline = new Date((this.getSlotStartBuildTimestamp() + attestationTimeAllowed) * 1000);
 
     this.metrics.recordRequiredAttestations(numberOfRequiredAttestations, attestationTimeAllowed);
 
@@ -820,6 +827,28 @@ export class CheckpointProposalJob implements Traceable {
     this.publisher.clearPendingRequests();
   }
 
+  /**
+   * Helper to handle HA double-signing errors. Returns true if the error was handled (caller should yield).
+   */
+  private handleHASigningError(err: any, errorContext: string): boolean {
+    if (err instanceof DutyAlreadySignedError) {
+      this.log.info(`${errorContext} for slot ${this.slot} already signed by another HA node, yielding`, {
+        slot: this.slot,
+        signedByNode: err.signedByNode,
+      });
+      return true;
+    }
+    if (err instanceof SlashingProtectionError) {
+      this.log.info(`${errorContext} for slot ${this.slot} blocked by slashing protection, yielding`, {
+        slot: this.slot,
+        existingMessageHash: err.existingMessageHash,
+        attemptedMessageHash: err.attemptedMessageHash,
+      });
+      return true;
+    }
+    return false;
+  }
+
   /** Waits until a specific time within the current slot */
   @trackSpan('CheckpointProposalJob.waitUntilTimeInSlot')
   protected async waitUntilTimeInSlot(targetSecondsIntoSlot: number): Promise<void> {

package/src/sequencer/metrics.ts

@@ -11,6 +11,7 @@ import {
   type TelemetryClient,
   type Tracer,
   type UpDownCounter,
+  createUpDownCounterWithDefault,
 } from '@aztec/telemetry-client';
 
 import { type Hex, formatUnits } from 'viem';
@@ -67,7 +68,9 @@ export class SequencerMetrics {
     this.meter = client.getMeter(name);
     this.tracer = client.getTracer(name);
 
-    this.blockCounter = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_COUNT);
+    this.blockCounter = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_BLOCK_COUNT, {
+      [Attributes.STATUS]: ['failed', 'built'],
+    });
 
     this.blockBuildDuration = this.meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_DURATION);
 
@@ -77,23 +80,15 @@ export class SequencerMetrics {
 
     this.checkpointAttestationDelay = this.meter.createHistogram(Metrics.SEQUENCER_CHECKPOINT_ATTESTATION_DELAY);
 
-    // Init gauges and counters
-    this.blockCounter.add(0, {
-      [Attributes.STATUS]: 'failed',
-    });
-    this.blockCounter.add(0, {
-      [Attributes.STATUS]: 'built',
-    });
-
     this.rewards = this.meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_REWARDS);
 
-    this.slots = this.meter.createUpDownCounter(Metrics.SEQUENCER_SLOT_COUNT);
+    this.slots = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_SLOT_COUNT);
 
     /**
      * NOTE: we do not track missed slots as a separate metric. That would be difficult to determine
      * Instead, use a computed metric, `slots - filledSlots` to get the number of slots a sequencer has missed.
      */
-    this.filledSlots = this.meter.createUpDownCounter(Metrics.SEQUENCER_FILLED_SLOT_COUNT);
+    this.filledSlots = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_FILLED_SLOT_COUNT);
 
     this.timeToCollectAttestations = this.meter.createGauge(Metrics.SEQUENCER_COLLECT_ATTESTATIONS_DURATION);
 
@@ -103,20 +98,41 @@ export class SequencerMetrics {
 
     this.collectedAttestions = this.meter.createGauge(Metrics.SEQUENCER_COLLECTED_ATTESTATIONS_COUNT);
 
-    this.blockProposalFailed = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_PROPOSAL_FAILED_COUNT);
+    this.blockProposalFailed = createUpDownCounterWithDefault(
+      this.meter,
+      Metrics.SEQUENCER_BLOCK_PROPOSAL_FAILED_COUNT,
+    );
 
-    this.blockProposalSuccess = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_PROPOSAL_SUCCESS_COUNT);
+    this.blockProposalSuccess = createUpDownCounterWithDefault(
+      this.meter,
+      Metrics.SEQUENCER_BLOCK_PROPOSAL_SUCCESS_COUNT,
+    );
 
-    this.checkpointSuccess = this.meter.createUpDownCounter(Metrics.SEQUENCER_CHECKPOINT_SUCCESS_COUNT);
+    this.checkpointSuccess = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_CHECKPOINT_SUCCESS_COUNT);
 
-    this.blockProposalPrecheckFailed = this.meter.createUpDownCounter(
+    this.blockProposalPrecheckFailed = createUpDownCounterWithDefault(
+      this.meter,
       Metrics.SEQUENCER_BLOCK_PROPOSAL_PRECHECK_FAILED_COUNT,
+      {
+        [Attributes.ERROR_TYPE]: [
+          'slot_already_taken',
+          'rollup_contract_check_failed',
+          'slot_mismatch',
+          'block_number_mismatch',
+        ],
+      },
     );
 
-    this.slashingAttempts = this.meter.createUpDownCounter(Metrics.SEQUENCER_SLASHING_ATTEMPTS_COUNT);
+    this.slashingAttempts = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_SLASHING_ATTEMPTS_COUNT);
 
     // Fisherman fee analysis metrics
-    this.fishermanWouldBeIncluded = this.meter.createUpDownCounter(Metrics.FISHERMAN_FEE_ANALYSIS_WOULD_BE_INCLUDED);
+    this.fishermanWouldBeIncluded = createUpDownCounterWithDefault(
+      this.meter,
+      Metrics.FISHERMAN_FEE_ANALYSIS_WOULD_BE_INCLUDED,
+      {
+        [Attributes.OK]: [true, false],
+      },
+    );
 
     this.fishermanTimeBeforeBlock = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_TIME_BEFORE_BLOCK);
 
@@ -231,7 +247,9 @@ export class SequencerMetrics {
     this.blockProposalSuccess.add(1);
   }
 
-  recordBlockProposalPrecheckFailed(checkType: string) {
+  recordBlockProposalPrecheckFailed(
+    checkType: 'slot_already_taken' | 'rollup_contract_check_failed' | 'slot_mismatch' | 'block_number_mismatch',
+  ) {
     this.blockProposalPrecheckFailed.add(1, {
       [Attributes.ERROR_TYPE]: checkType,
     });