@aztec/sequencer-client 0.0.1-commit.c7c42ec → 0.0.1-commit.f295ac2

package/src/sequencer/checkpoint_proposal_job.ts

@@ -1,7 +1,9 @@
+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 { 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';
@@ -15,6 +17,8 @@ import {
   CommitteeAttestation,
   CommitteeAttestationsAndSigners,
   L2BlockNew,
+  type L2BlockSink,
+  type L2BlockSource,
   MaliciousCommitteeAttestationsAndSigners,
 } from '@aztec/stdlib/block';
 import type { Checkpoint } from '@aztec/stdlib/checkpoint';
@@ -25,18 +29,18 @@ import type {
   ResolvedSequencerConfig,
   WorldStateSynchronizer,
 } from '@aztec/stdlib/interfaces/server';
-import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
-import type { BlockProposal, BlockProposalOptions } from '@aztec/stdlib/p2p';
+import { type L1ToL2MessageSource, computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
+import type { BlockProposalOptions, CheckpointProposal, CheckpointProposalOptions } from '@aztec/stdlib/p2p';
 import { orderAttestations } from '@aztec/stdlib/p2p';
-import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import type { L2BlockBuiltStats } from '@aztec/stdlib/stats';
 import { type FailedTx, Tx } from '@aztec/stdlib/tx';
 import { AttestationTimeoutError } from '@aztec/stdlib/validators';
-import type { ValidatorClient } from '@aztec/validator-client';
+import { Attributes, type Traceable, type Tracer, trackSpan } from '@aztec/telemetry-client';
+import { CheckpointBuilder, type FullNodeCheckpointsBuilder, type ValidatorClient } from '@aztec/validator-client';
+import { DutyAlreadySignedError, SlashingProtectionError } from '@aztec/validator-ha-signer/errors';
 
 import type { GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
-import type { InvalidateBlockRequest, SequencerPublisher } from '../publisher/sequencer-publisher.js';
-import { CheckpointBuilder, type FullNodeCheckpointsBuilder } from './checkpoint_builder.js';
+import type { InvalidateCheckpointRequest, SequencerPublisher } from '../publisher/sequencer-publisher.js';
 import { CheckpointVoter } from './checkpoint_voter.js';
 import { SequencerInterruptedError } from './errors.js';
 import type { SequencerEvents } from './events.js';
@@ -54,8 +58,9 @@ const TXS_POLLING_MS = 500;
  * as well as enqueueing votes for slashing and governance proposals. This class is created from
  * the Sequencer once the check for being the proposer for the slot has succeeded.
  */
-export class CheckpointProposalJob {
+export class CheckpointProposalJob implements Traceable {
   constructor(
+    private readonly epoch: EpochNumber,
     private readonly slot: SlotNumber,
     private readonly checkpointNumber: CheckpointNumber,
     private readonly syncedToBlockNumber: BlockNumber,
@@ -63,13 +68,15 @@ export class CheckpointProposalJob {
     private readonly proposer: EthAddress | undefined,
     private readonly publisher: SequencerPublisher,
     private readonly attestorAddress: EthAddress,
-    private readonly invalidateBlock: InvalidateBlockRequest | undefined,
+    private readonly invalidateCheckpoint: InvalidateCheckpointRequest | undefined,
     private readonly validatorClient: ValidatorClient,
     private readonly globalsBuilder: GlobalVariableBuilder,
     private readonly p2pClient: P2P,
     private readonly worldState: WorldStateSynchronizer,
     private readonly l1ToL2MessageSource: L1ToL2MessageSource,
+    private readonly l2BlockSource: L2BlockSource,
     private readonly checkpointsBuilder: FullNodeCheckpointsBuilder,
+    private readonly blockSink: L2BlockSink,
     private readonly l1Constants: SequencerRollupConstants,
     protected config: ResolvedSequencerConfig,
     protected timetable: SequencerTimetable,
@@ -80,12 +87,14 @@ export class CheckpointProposalJob {
     private readonly eventEmitter: TypedEventEmitter<SequencerEvents>,
     private readonly setStateFn: (state: SequencerState, slot?: SlotNumber) => void,
     protected readonly log: Logger,
+    public readonly tracer: Tracer,
   ) {}
 
   /**
    * Executes the checkpoint proposal job.
    * Returns the published checkpoint if successful, undefined otherwise.
    */
+  @trackSpan('CheckpointProposalJob.execute')
   public async execute(): Promise<Checkpoint | undefined> {
     // Enqueue governance and slashing votes (returns promises that will be awaited later)
     // In fisherman mode, we simulate slashing but don't actually publish to L1
@@ -132,6 +141,13 @@ export class CheckpointProposalJob {
     }
   }
 
+  @trackSpan('CheckpointProposalJob.proposeCheckpoint', function () {
+    return {
+      // nullish operator needed for tests
+      [Attributes.COINBASE]: this.validatorClient.getCoinbaseForAttestor(this.attestorAddress)?.toString(),
+      [Attributes.SLOT_NUMBER]: this.slot,
+    };
+  })
   private async proposeCheckpoint(): Promise<Checkpoint | undefined> {
     try {
       // Get operator configured coinbase and fee recipient for this attestor
@@ -142,9 +158,9 @@ export class CheckpointProposalJob {
       this.setStateFn(SequencerState.INITIALIZING_CHECKPOINT, this.slot);
       this.metrics.incOpenSlot(this.slot, this.proposer?.toString() ?? 'unknown');
 
-      // Enqueues block invalidation (constant for the whole slot)
-      if (this.invalidateBlock && !this.config.skipInvalidateBlockAsProposer) {
-        this.publisher.enqueueInvalidateBlock(this.invalidateBlock);
+      // Enqueues checkpoint invalidation (constant for the whole slot)
+      if (this.invalidateCheckpoint && !this.config.skipInvalidateBlockAsProposer) {
+        this.publisher.enqueueInvalidateCheckpoint(this.invalidateCheckpoint);
       }
 
       // Create checkpoint builder for the slot
@@ -154,8 +170,15 @@ export class CheckpointProposalJob {
         this.slot,
       );
 
-      // Collect L1 to L2 messages for the checkpoint
+      // Collect L1 to L2 messages for the checkpoint and compute their hash
       const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(this.checkpointNumber);
+      const inHash = computeInHashFromL1ToL2Messages(l1ToL2Messages);
+
+      // Collect the out hashes of all the checkpoints before this one in the same epoch
+      const previousCheckpoints = (await this.l2BlockSource.getCheckpointsForEpoch(this.epoch)).filter(
+        c => c.number < this.checkpointNumber,
+      );
+      const previousCheckpointOutHashes = previousCheckpoints.map(c => c.getCheckpointOutHash());
 
       // Create a long-lived forked world state for the checkpoint builder
       using fork = await this.worldState.fork(this.syncedToBlockNumber, { closeDelayMs: 12_000 });
@@ -165,6 +188,7 @@ export class CheckpointProposalJob {
         this.checkpointNumber,
         checkpointGlobalVariables,
         l1ToL2Messages,
+        previousCheckpointOutHashes,
         fork,
       );
 
@@ -174,12 +198,45 @@ export class CheckpointProposalJob {
         broadcastInvalidBlockProposal: this.config.broadcastInvalidBlockProposal,
       };
 
-      // Main loop: build blocks for the checkpoint
-      const { blocksInCheckpoint, pendingBroadcast } = await this.buildBlocksForCheckpoint(
-        checkpointBuilder,
-        checkpointGlobalVariables.timestamp,
-        blockProposalOptions,
-      );
+      const checkpointProposalOptions: CheckpointProposalOptions = {
+        publishFullTxs: !!this.config.publishTxsWithProposals,
+        broadcastInvalidCheckpointProposal: this.config.broadcastInvalidBlockProposal,
+      };
+
+      let blocksInCheckpoint: L2BlockNew[] = [];
+      let blockPendingBroadcast: { block: L2BlockNew; txs: Tx[] } | undefined = undefined;
+
+      try {
+        // Main loop: build blocks for the checkpoint
+        const result = await this.buildBlocksForCheckpoint(
+          checkpointBuilder,
+          checkpointGlobalVariables.timestamp,
+          inHash,
+          blockProposalOptions,
+        );
+        blocksInCheckpoint = result.blocksInCheckpoint;
+        blockPendingBroadcast = result.blockPendingBroadcast;
+      } catch (err) {
+        // 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,
+          });
+          return undefined;
+        }
+        throw err;
+      }
 
       if (blocksInCheckpoint.length === 0) {
         this.log.warn(`No blocks were built for slot ${this.slot}`, { slot: this.slot });
@@ -207,26 +264,61 @@ export class CheckpointProposalJob {
         return checkpoint;
       }
 
-      // TODO(palla/mbps): Wire this to the new p2p API once available, including the pendingBroadcast.block
+      // Include the block pending broadcast in the checkpoint proposal if any
+      const lastBlock = blockPendingBroadcast && {
+        blockHeader: blockPendingBroadcast.block.header,
+        indexWithinCheckpoint: blockPendingBroadcast.block.indexWithinCheckpoint,
+        txs: blockPendingBroadcast.txs,
+      };
+
+      // Create the checkpoint proposal and broadcast it
       const proposal = await this.validatorClient.createCheckpointProposal(
         checkpoint.header,
         checkpoint.archive.root,
-        pendingBroadcast?.txs ?? [],
+        lastBlock,
         this.proposer,
-        blockProposalOptions,
+        checkpointProposalOptions,
       );
+
       const blockProposedAt = this.dateProvider.now();
-      await this.p2pClient.broadcastProposal(proposal);
+      await this.p2pClient.broadcastCheckpointProposal(proposal);
 
       this.setStateFn(SequencerState.COLLECTING_ATTESTATIONS, this.slot);
       const attestations = await this.waitForAttestations(proposal);
       const blockAttestedAt = this.dateProvider.now();
 
-      this.metrics.recordBlockAttestationDelay(blockAttestedAt - blockProposedAt);
+      this.metrics.recordCheckpointAttestationDelay(blockAttestedAt - blockProposedAt);
 
       // Proposer must sign over the attestations before pushing them to L1
       const signer = this.proposer ?? this.publisher.getSenderAddress();
-      const attestationsSignature = await this.validatorClient.signAttestationsAndSigners(attestations, signer);
+      let attestationsSignature: Signature;
+      try {
+        attestationsSignature = await this.validatorClient.signAttestationsAndSigners(
+          attestations,
+          signer,
+          this.slot,
+          this.checkpointNumber,
+        );
+      } 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,
+          });
+          return undefined;
+        }
+        throw err;
+      }
 
       // Enqueue publishing the checkpoint to L1
       this.setStateFn(SequencerState.PUBLISHING_CHECKPOINT, this.slot);
@@ -235,7 +327,7 @@ export class CheckpointProposalJob {
       const txTimeoutAt = new Date((slotStartBuildTimestamp + aztecSlotDuration) * 1000);
       await this.publisher.enqueueProposeCheckpoint(checkpoint, attestations, attestationsSignature, {
         txTimeoutAt,
-        forcePendingBlockNumber: this.invalidateBlock?.forcePendingBlockNumber,
+        forcePendingCheckpointNumber: this.invalidateCheckpoint?.forcePendingCheckpointNumber,
       });
 
       return checkpoint;
@@ -248,20 +340,25 @@ export class CheckpointProposalJob {
   /**
    * Builds blocks for a checkpoint within the current slot.
    */
+  @trackSpan('CheckpointProposalJob.buildBlocksForCheckpoint')
   private async buildBlocksForCheckpoint(
     checkpointBuilder: CheckpointBuilder,
     timestamp: bigint,
+    inHash: Fr,
     blockProposalOptions: BlockProposalOptions,
   ): Promise<{
     blocksInCheckpoint: L2BlockNew[];
-    pendingBroadcast: { block: L2BlockNew; txs: Tx[] } | undefined;
+    blockPendingBroadcast: { block: L2BlockNew; txs: Tx[] } | undefined;
   }> {
     const blocksInCheckpoint: L2BlockNew[] = [];
     const txHashesAlreadyIncluded = new Set<string>();
     const initialBlockNumber = BlockNumber(this.syncedToBlockNumber + 1);
 
+    // Remaining blob fields available for blocks (checkpoint end marker already subtracted)
+    let remainingBlobFields = BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB - NUM_CHECKPOINT_END_MARKER_FIELDS;
+
     // Last block in the checkpoint will usually be flagged as pending broadcast, so we send it along with the checkpoint proposal
-    let pendingBroadcast: { block: L2BlockNew; txs: Tx[] } | undefined = undefined;
+    let blockPendingBroadcast: { block: L2BlockNew; txs: Tx[] } | undefined = undefined;
 
     while (true) {
       const blocksBuilt = blocksInCheckpoint.length;
@@ -292,6 +389,7 @@ export class CheckpointProposalJob {
         blockNumber,
         indexWithinCheckpoint,
         txHashesAlreadyIncluded,
+        remainingBlobFields,
       });
 
       if (!buildResult && timingInfo.isLastBlock) {
@@ -316,9 +414,12 @@ export class CheckpointProposalJob {
         break;
       }
 
-      const { block, usedTxs } = buildResult;
+      const { block, usedTxs, remainingBlobFields: newRemainingBlobFields } = buildResult;
       blocksInCheckpoint.push(block);
 
+      // Update remaining blob fields for the next block
+      remainingBlobFields = newRemainingBlobFields;
+
       // Sync the proposed block to the archiver to make it available
       // Note that the checkpoint builder uses its own fork so it should not need to wait for this syncing
       // Eventually we should refactor the checkpoint builder to not need a separate long-lived fork
@@ -331,17 +432,17 @@ export class CheckpointProposalJob {
           blockNumber,
           blocksBuilt,
         });
-        pendingBroadcast = { block, txs: usedTxs };
+        blockPendingBroadcast = { block, txs: usedTxs };
         break;
       }
 
       // For non-last blocks, broadcast the block proposal (unless we're in fisherman mode)
       // If the block is the last one, we'll broadcast it along with the checkpoint at the end of the loop
       if (!this.config.fishermanMode) {
-        // TODO(palla/mbps): Wire this to the new p2p API once available
         const proposal = await this.validatorClient.createBlockProposal(
-          block.header.globalVariables.blockNumber,
-          (await checkpointBuilder.getCheckpoint()).header,
+          block.header,
+          block.indexWithinCheckpoint,
+          inHash,
           block.archive.root,
           usedTxs,
           this.proposer,
@@ -359,13 +460,11 @@ export class CheckpointProposalJob {
       blocksBuilt: blocksInCheckpoint.length,
     });
 
-    return {
-      blocksInCheckpoint,
-      pendingBroadcast,
-    };
+    return { blocksInCheckpoint, blockPendingBroadcast };
   }
 
   /** Sleeps until it is time to produce the next block in the slot */
+  @trackSpan('CheckpointProposalJob.waitUntilNextSubslot')
   private async waitUntilNextSubslot(nextSubslotStart: number) {
     this.setStateFn(SequencerState.WAITING_UNTIL_NEXT_BLOCK, this.slot);
     this.log.verbose(`Waiting until time for the next block at ${nextSubslotStart}s into slot`, { slot: this.slot });
@@ -373,6 +472,7 @@ export class CheckpointProposalJob {
   }
 
   /** Builds a single block. Called from the main block building loop. */
+  @trackSpan('CheckpointProposalJob.buildSingleBlock')
   private async buildSingleBlock(
     checkpointBuilder: CheckpointBuilder,
     opts: {
@@ -382,10 +482,18 @@ export class CheckpointProposalJob {
       indexWithinCheckpoint: number;
       buildDeadline: Date | undefined;
       txHashesAlreadyIncluded: Set<string>;
+      remainingBlobFields: number;
     },
-  ): Promise<{ block: L2BlockNew; usedTxs: Tx[] } | { error: Error } | undefined> {
-    const { blockTimestamp, forceCreate, blockNumber, indexWithinCheckpoint, buildDeadline, txHashesAlreadyIncluded } =
-      opts;
+  ): Promise<{ block: L2BlockNew; usedTxs: Tx[]; remainingBlobFields: number } | { error: Error } | undefined> {
+    const {
+      blockTimestamp,
+      forceCreate,
+      blockNumber,
+      indexWithinCheckpoint,
+      buildDeadline,
+      txHashesAlreadyIncluded,
+      remainingBlobFields,
+    } = opts;
 
     this.log.verbose(
       `Preparing block ${blockNumber} index ${indexWithinCheckpoint} at checkpoint ${this.checkpointNumber} for slot ${this.slot}`,
@@ -418,18 +526,31 @@ export class CheckpointProposalJob {
         { slot: this.slot, blockNumber, indexWithinCheckpoint },
       );
       this.setStateFn(SequencerState.CREATING_BLOCK, this.slot);
+
+      // Calculate blob fields limit for txs (remaining capacity - this block's end overhead)
+      const blockEndOverhead = getNumBlockEndBlobFields(indexWithinCheckpoint === 0);
+      const maxBlobFieldsForTxs = remainingBlobFields - blockEndOverhead;
+
       const blockBuilderOptions: PublicProcessorLimits = {
         maxTransactions: this.config.maxTxsPerBlock,
         maxBlockSize: this.config.maxBlockSizeInBytes,
         maxBlockGas: new Gas(this.config.maxDABlockGas, this.config.maxL2BlockGas),
-        maxBlobFields: BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB,
+        maxBlobFields: maxBlobFieldsForTxs,
         deadline: buildDeadline,
       };
 
       // Actually build the block by executing txs
       const workTimer = new Timer();
-      const { publicGas, block, publicProcessorDuration, numTxs, blockBuildingTimer, usedTxs, failedTxs } =
-        await checkpointBuilder.buildBlock(pendingTxs, blockNumber, blockTimestamp, blockBuilderOptions);
+      const {
+        publicGas,
+        block,
+        publicProcessorDuration,
+        numTxs,
+        blockBuildingTimer,
+        usedTxs,
+        failedTxs,
+        usedTxBlobFields,
+      } = await checkpointBuilder.buildBlock(pendingTxs, blockNumber, blockTimestamp, blockBuilderOptions);
       const blockBuildDuration = workTimer.ms();
 
       // If any txs failed during execution, drop them from the mempool so we don't pick them up again
@@ -473,7 +594,7 @@ export class CheckpointProposalJob {
       this.eventEmitter.emit('block-proposed', { blockNumber: block.number, slot: this.slot });
       this.metrics.recordBuiltBlock(blockBuildDuration, publicGas.l2Gas);
 
-      return { block, usedTxs };
+      return { block, usedTxs, remainingBlobFields: maxBlobFieldsForTxs - usedTxBlobFields };
     } catch (err: any) {
       this.eventEmitter.emit('block-build-failed', { reason: err.message, slot: this.slot });
       this.log.error(`Error building block`, err, { blockNumber, slot: this.slot });
@@ -484,6 +605,7 @@ export class CheckpointProposalJob {
   }
 
   /** Waits until minTxs are available on the pool for building a block. */
+  @trackSpan('CheckpointProposalJob.waitForMinTxs')
   private async waitForMinTxs(opts: {
     forceCreate?: boolean;
     blockNumber: BlockNumber;
@@ -524,7 +646,8 @@ export class CheckpointProposalJob {
    * Waits for enough attestations to be collected via p2p.
    * This is run after all blocks for the checkpoint have been built.
    */
-  private async waitForAttestations(proposal: BlockProposal): Promise<CommitteeAttestationsAndSigners> {
+  @trackSpan('CheckpointProposalJob.waitForAttestations')
+  private async waitForAttestations(proposal: CheckpointProposal): Promise<CommitteeAttestationsAndSigners> {
     if (this.config.fishermanMode) {
       this.log.debug('Skipping attestation collection in fisherman mode');
       return CommitteeAttestationsAndSigners.empty();
@@ -573,8 +696,7 @@ export class CheckpointProposalJob {
 
       // Manipulate the attestations if we've been configured to do so
       if (this.config.injectFakeAttestation || this.config.shuffleAttestationOrdering) {
-        const checkpoint = proposal.payload.header;
-        return this.manipulateAttestations(checkpoint, epoch, seed, committee, sorted);
+        return this.manipulateAttestations(proposal.slotNumber, epoch, seed, committee, sorted);
       }
 
       return new CommitteeAttestationsAndSigners(sorted);
@@ -590,7 +712,7 @@ export class CheckpointProposalJob {
 
   /** Breaks the attestations before publishing based on attack configs */
   private manipulateAttestations(
-    checkpoint: CheckpointHeader,
+    slotNumber: SlotNumber,
     epoch: EpochNumber,
     seed: bigint,
     committee: EthAddress[],
@@ -598,7 +720,6 @@ export class CheckpointProposalJob {
   ) {
     // Compute the proposer index in the committee, since we dont want to tweak it.
     // Otherwise, the L1 rollup contract will reject the block outright.
-    const { slotNumber } = checkpoint;
     const proposerIndex = Number(
       this.epochCache.computeProposerIndex(slotNumber, epoch, seed, BigInt(committee.length)),
     );
@@ -647,16 +768,24 @@ export class CheckpointProposalJob {
   }
 
   /**
-   * Placeholder for pushing block to archiver and waiting for sync.
-   * To be implemented when archiver and world-state support proposed blocks.
+   * Adds the proposed block to the archiver so it's available via P2P.
+   * Gossip doesn't echo messages back to the sender, so the proposer's archiver/world-state
+   * would never receive its own block without this explicit sync.
    */
   private async syncProposedBlockToArchiver(block: L2BlockNew): Promise<void> {
-    this.log.debug(`Syncing proposed block ${block.number}`, {
+    // TODO(palla/mbps): Change default to false once block sync is stable.
+    if (this.config.skipPushProposedBlocksToArchiver !== false) {
+      this.log.warn(`Skipping push of proposed block ${block.number} to archiver`, {
+        blockNumber: block.number,
+        slot: block.header.globalVariables.slotNumber,
+      });
+      return;
+    }
+    this.log.debug(`Syncing proposed block ${block.number} to archiver`, {
       blockNumber: block.number,
       slot: block.header.globalVariables.slotNumber,
     });
-    // TODO(palla/mbps): Implement actual sync to archiver and world-state
-    await Promise.resolve();
+    await this.blockSink.addBlock(block);
   }
 
   /** Runs fee analysis and logs checkpoint outcome as fisherman */
@@ -685,6 +814,7 @@ export class CheckpointProposalJob {
   }
 
   /** Waits until a specific time within the current slot */
+  @trackSpan('CheckpointProposalJob.waitUntilTimeInSlot')
   protected async waitUntilTimeInSlot(targetSecondsIntoSlot: number): Promise<void> {
     const slotStartTimestamp = this.getSlotStartBuildTimestamp();
     const targetTimestamp = slotStartTimestamp + targetSecondsIntoSlot;

package/src/sequencer/checkpoint_voter.ts

@@ -5,6 +5,8 @@ import type { SlasherClientInterface } from '@aztec/slasher';
 import { getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
 import type { ResolvedSequencerConfig } from '@aztec/stdlib/interfaces/server';
 import type { ValidatorClient } from '@aztec/validator-client';
+import { DutyAlreadySignedError } from '@aztec/validator-ha-signer/errors';
+import { DutyType, type SigningContext } from '@aztec/validator-ha-signer/types';
 
 import type { TypedDataDefinition } from 'viem';
 
@@ -17,7 +19,8 @@ import type { SequencerRollupConstants } from './types.js';
  */
 export class CheckpointVoter {
   private slotTimestamp: bigint;
-  private signer: (msg: TypedDataDefinition) => Promise<`0x${string}`>;
+  private governanceSigner: (msg: TypedDataDefinition) => Promise<`0x${string}`>;
+  private slashingSigner: (msg: TypedDataDefinition) => Promise<`0x${string}`>;
 
   constructor(
     private readonly slot: SlotNumber,
@@ -31,8 +34,16 @@ export class CheckpointVoter {
     private readonly log: Logger,
   ) {
     this.slotTimestamp = getTimestampForSlot(this.slot, this.l1Constants);
-    this.signer = (msg: TypedDataDefinition) =>
-      this.validatorClient.signWithAddress(this.attestorAddress, msg).then(s => s.toString());
+
+    // Create separate signers with appropriate duty contexts for governance and slashing votes
+    // These use HA protection to ensure only one node signs per slot/duty
+    const governanceContext: SigningContext = { slot: this.slot, dutyType: DutyType.GOVERNANCE_VOTE };
+    this.governanceSigner = (msg: TypedDataDefinition) =>
+      this.validatorClient.signWithAddress(this.attestorAddress, msg, governanceContext).then(s => s.toString());
+
+    const slashingContext: SigningContext = { slot: this.slot, dutyType: DutyType.SLASHING_VOTE };
+    this.slashingSigner = (msg: TypedDataDefinition) =>
+      this.validatorClient.signWithAddress(this.attestorAddress, msg, slashingContext).then(s => s.toString());
   }
 
   /**
@@ -68,10 +79,17 @@ export class CheckpointVoter {
         this.slot,
         this.slotTimestamp,
         this.attestorAddress,
-        this.signer,
+        this.governanceSigner,
       );
     } catch (err) {
-      this.log.error(`Error enqueuing governance vote`, err, { slot: this.slot });
+      if (err instanceof DutyAlreadySignedError) {
+        this.log.info(`Governance vote already signed by another node`, {
+          slot: this.slot,
+          signedByNode: err.signedByNode,
+        });
+      } else {
+        this.log.error(`Error enqueueing governance vote`, err);
+      }
       return false;
     }
   }
@@ -95,10 +113,17 @@ export class CheckpointVoter {
         this.slot,
         this.slotTimestamp,
         this.attestorAddress,
-        this.signer,
+        this.slashingSigner,
       );
     } catch (err) {
-      this.log.error(`Error enqueuing slashing vote`, err, { slot: this.slot });
+      if (err instanceof DutyAlreadySignedError) {
+        this.log.info(`Slashing vote already signed by another node`, {
+          slot: this.slot,
+          signedByNode: err.signedByNode,
+        });
+      } else {
+        this.log.error(`Error enqueueing slashing vote`, err);
+      }
       return false;
     }
   }

package/src/sequencer/index.ts

@@ -1,5 +1,3 @@
-export * from './block_builder.js';
-export * from './checkpoint_builder.js';
 export * from './checkpoint_proposal_job.js';
 export * from './checkpoint_voter.js';
 export * from './config.js';