@aztec-labs/validator-client 6.0.0-rc.1 → 6.0.0-rc.2

package/src/validator.ts

@@ -2,6 +2,7 @@ import type { BlobClientInterface } from '@aztec-labs/blob-client/client';
 import { type Blob, getBlobsPerL1Block } from '@aztec-labs/blob-lib';
 import type { EpochCache } from '@aztec-labs/epoch-cache';
 import { CheckpointNumber, EpochNumber, IndexWithinCheckpoint, SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { compactArray } from '@aztec-labs/foundation/collection';
 import { Fr } from '@aztec-labs/foundation/curves/bn254';
 import type { EthAddress } from '@aztec-labs/foundation/eth-address';
 import { Signature } from '@aztec-labs/foundation/eth-signature';
@@ -475,27 +476,18 @@ export class ValidatorClient extends (EventEmitter as new () => WatcherEmitter)
 
       this.log.warn(`Block proposal validation failed: ${reason}`, proposalInfo);
 
-      // Classify failure reason: bad proposal vs node issue
-      const badProposalReasons: BlockProposalValidationFailureReason[] = [
-        'invalid_proposal',
-        'state_mismatch',
-        'failed_txs',
-        'parent_block_wrong_slot',
-        'duplicate_txs',
-        'invalid_embedded_txs',
-      ];
-
-      if (badProposalReasons.includes(reason as BlockProposalValidationFailureReason)) {
+      // A slashable reject is a bad proposal, not a node issue, so branch the metric on the slashable set. A separate
+      // reason list would need every slashable reason (e.g. global_variables_mismatch) kept in sync by hand.
+      if (SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT[reason as BlockProposalValidationFailureReason]) {
         this.metrics.incFailedAttestationsBadProposal(1, reason, partOfCommittee);
       } else {
-        // Node issues so we can't validate
         this.metrics.incFailedAttestationsNodeIssue(1, reason, partOfCommittee);
       }
 
       if (
         !escapeHatchOpen &&
         validationResult.reason &&
-        SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT.includes(validationResult.reason)
+        SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT[validationResult.reason]
       ) {
         this.log.info(`Detected invalid block proposal offense`, {
           ...proposalInfo,
@@ -609,19 +601,6 @@ export class ValidatorClient extends (EventEmitter as new () => WatcherEmitter)
       },
     );
 
-    this.metrics.incSuccessfulAttestations(inCommittee.length);
-
-    // Track epoch participation per attester: count each (attester, epoch) pair at most once
-    const proposalEpoch = getEpochAtSlot(proposalSlotNumber, this.epochCache.getL1Constants());
-    for (const attester of inCommittee) {
-      const key = attester.toString();
-      const lastEpoch = this.lastAttestedEpochByAttester.get(key);
-      if (lastEpoch === undefined || proposalEpoch > lastEpoch) {
-        this.lastAttestedEpochByAttester.set(key, proposalEpoch);
-        this.metrics.incAttestedEpochCount(attester);
-      }
-    }
-
     // Determine which validators should attest
     let attestors: EthAddress[];
     if (partOfCommittee) {
@@ -644,10 +623,34 @@ export class ValidatorClient extends (EventEmitter as new () => WatcherEmitter)
         ...proposalInfo,
         attestors: attestors.map(a => a.toString()),
       });
+      this.recordAttestationParticipation(inCommittee, proposalSlotNumber);
       return undefined;
     }
 
-    return await this.createCheckpointAttestationsFromProposal(proposal, attestors, checkpointNumber);
+    const attestations = await this.createCheckpointAttestationsFromProposal(proposal, attestors, checkpointNumber);
+    // Counted from the attestations actually kept, so one refused for equivocation, discarded past the deadline, or
+    // signed by another HA node is not reported as this node's participation.
+    if (attestations) {
+      this.recordAttestationParticipation(
+        compactArray(attestations.map(attestation => attestation.getSender())),
+        proposalSlotNumber,
+      );
+    }
+    return attestations;
+  }
+
+  /** Records successful attestations and each attester's epoch participation, counting an (attester, epoch) once. */
+  private recordAttestationParticipation(attesters: EthAddress[], slot: SlotNumber): void {
+    this.metrics.incSuccessfulAttestations(attesters.length);
+    const epoch = getEpochAtSlot(slot, this.epochCache.getL1Constants());
+    for (const attester of attesters) {
+      const key = attester.toString();
+      const lastEpoch = this.lastAttestedEpochByAttester.get(key);
+      if (lastEpoch === undefined || epoch > lastEpoch) {
+        this.lastAttestedEpochByAttester.set(key, epoch);
+        this.metrics.incAttestedEpochCount(attester);
+      }
+    }
   }
 
   /**
@@ -681,15 +684,52 @@ export class ValidatorClient extends (EventEmitter as new () => WatcherEmitter)
       return undefined;
     }
 
+    // Deadline check, for the same reason and in the same place. Validation can run up to the attestation deadline
+    // and past it — the archiver sync waits are bounded by the deadline, and the Inbox endpoint gate keeps a minimum
+    // window beyond it on purpose — so it is re-read here, with nothing left between it and the signature. Finishing
+    // a late validation is still worth doing for telemetry; signing on it is not. Both the peer path and the
+    // proposer's own `collectOwnAttestations` sign through here, so this is the one place that covers both.
+    //
+    // The cutoff is the deadline itself, not the deadline widened by `maxGossipClockDisparityMs`. The deadline is the
+    // sender's obligation; that tolerance is the receiver's allowance for clock skew and propagation delay on
+    // messages sent in time, and a sender that spends it leaves none for the network. Signing late for the sake of
+    // inactivity-slashing credit is a poor trade too: a late attestation only counts if it still reaches peers inside
+    // their tolerance, and one further out is dropped, or penalized as stale, by every peer.
+    if (this.isPastAttestationDeadline(proposal, 'validation')) {
+      return undefined;
+    }
+
     const attestations = await this.validationService.attestToCheckpointProposal(proposal, attestors, checkpointNumber);
 
-    // Track the proposal we attested to (to prevent equivocation)
+    // Track the proposal we attested to (to prevent equivocation). This is recorded even when the signature is
+    // discarded below: the attestors have signed for this slot, so a second proposal for it must still be refused.
     this.lastAttestedProposal = proposal;
 
+    // Signing is not instant: a remote signer or HA coordination can take seconds. A signature produced past the
+    // deadline is discarded rather than stored and gossiped, for the reasons above.
+    if (this.isPastAttestationDeadline(proposal, 'signing')) {
+      return undefined;
+    }
+
     await this.p2pClient.addOwnCheckpointAttestations(attestations);
     return attestations;
   }
 
+  /** Whether the attestation deadline for the proposal's slot has passed, logging which step overran it if so. */
+  private isPastAttestationDeadline(proposal: CheckpointProposalCore, step: 'validation' | 'signing'): boolean {
+    const attestationDeadline = this.proposalHandler.getAttestationDeadline(proposal.slotNumber);
+    if (+attestationDeadline > this.dateProvider.now()) {
+      return false;
+    }
+    this.log.warn(`Attestation deadline for slot ${proposal.slotNumber} passed during ${step}, not attesting`, {
+      slot: proposal.slotNumber,
+      archive: proposal.archive.toString(),
+      attestationDeadline: attestationDeadline.toISOString(),
+      step,
+    });
+    return true;
+  }
+
   /**
    * Uploads blobs for a checkpoint to the filestore (fire and forget).
    */