@aztec/validator-client 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

package/src/key_store/interface.ts

@@ -3,6 +3,7 @@ import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { Signature } from '@aztec/foundation/eth-signature';
 import type { EthRemoteSignerConfig } from '@aztec/node-keystore';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { SigningContext } from '@aztec/validator-ha-signer/types';
 
 import type { TypedDataDefinition } from 'viem';
 
@@ -26,17 +27,45 @@ export interface ValidatorKeyStore {
    */
   getAddresses(): EthAddress[];
 
-  signTypedData(typedData: TypedDataDefinition): Promise<Signature[]>;
-  signTypedDataWithAddress(address: EthAddress, typedData: TypedDataDefinition): Promise<Signature>;
+  /**
+   * Sign typed data with all keystore private keys
+   * @param typedData - The complete EIP-712 typed data structure
+   * @param context - Signing context for HA slashing protection
+   * @returns signatures (when context provided with HA, only successfully claimed signatures are returned)
+   */
+  signTypedData(typedData: TypedDataDefinition, context: SigningContext): Promise<Signature[]>;
+
+  /**
+   * Sign typed data with a specific address's private key
+   * @param address - The address of the signer to use
+   * @param typedData - The complete EIP-712 typed data structure
+   * @param context - Signing context for HA slashing protection
+   * @returns signature
+   */
+  signTypedDataWithAddress(
+    address: EthAddress,
+    typedData: TypedDataDefinition,
+    context: SigningContext,
+  ): Promise<Signature>;
+
   /**
    * Flavor of sign message that followed EIP-712 eth signed message prefix
    * Note: this is only required when we are using ecdsa signatures over secp256k1
    *
    * @param message - The message to sign.
-   * @returns The signatures.
+   * @param context - Signing context for HA slashing protection
+   * @returns The signatures (when context provided with HA, only successfully claimed signatures are returned).
    */
-  signMessage(message: Buffer32): Promise<Signature[]>;
-  signMessageWithAddress(address: EthAddress, message: Buffer32): Promise<Signature>;
+  signMessage(message: Buffer32, context: SigningContext): Promise<Signature[]>;
+
+  /**
+   * Sign a message with a specific address's private key
+   * @param address - The address of the signer to use
+   * @param message - The message to sign
+   * @param context - Signing context for HA slashing protection
+   * @returns signature
+   */
+  signMessageWithAddress(address: EthAddress, message: Buffer32, context: SigningContext): Promise<Signature>;
 }
 
 /**
@@ -79,4 +108,14 @@ export interface ExtendedValidatorKeyStore extends ValidatorKeyStore {
    * @returns the remote signer configuration or undefined
    */
   getRemoteSignerConfig(attesterAddress: EthAddress): EthRemoteSignerConfig | undefined;
+
+  /**
+   * Start the key store
+   */
+  start(): Promise<void>;
+
+  /**
+   * Stop the key store
+   */
+  stop(): Promise<void>;
 }

package/src/key_store/local_key_store.ts

@@ -1,7 +1,8 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { Secp256k1Signer } from '@aztec/foundation/crypto';
+import { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { Signature } from '@aztec/foundation/eth-signature';
+import type { SigningContext } from '@aztec/validator-ha-signer/types';
 
 import { type TypedDataDefinition, hashTypedData } from 'viem';
 
@@ -46,9 +47,10 @@ export class LocalKeyStore implements ValidatorKeyStore {
   /**
    * Sign a message with all keystore private keys
    * @param typedData - The complete EIP-712 typed data structure (domain, types, primaryType, message)
+   * @param _context - Signing context (ignored by LocalKeyStore, used for HA protection)
    * @return signature
    */
-  public signTypedData(typedData: TypedDataDefinition): Promise<Signature[]> {
+  public signTypedData(typedData: TypedDataDefinition, _context: SigningContext): Promise<Signature[]> {
     const digest = hashTypedData(typedData);
     return Promise.all(this.signers.map(signer => signer.sign(Buffer32.fromString(digest))));
   }
@@ -57,10 +59,15 @@ export class LocalKeyStore implements ValidatorKeyStore {
    * Sign a message with a specific address's private key
    * @param address - The address of the signer to use
    * @param typedData - The complete EIP-712 typed data structure (domain, types, primaryType, message)
+   * @param _context - Signing context (ignored by LocalKeyStore, used for HA protection)
    * @returns signature for the specified address
    * @throws Error if the address is not found in the keystore
    */
-  public signTypedDataWithAddress(address: EthAddress, typedData: TypedDataDefinition): Promise<Signature> {
+  public signTypedDataWithAddress(
+    address: EthAddress,
+    typedData: TypedDataDefinition,
+    _context: SigningContext,
+  ): Promise<Signature> {
     const signer = this.signersByAddress.get(address.toString());
     if (!signer) {
       throw new Error(`No signer found for address ${address.toString()}`);
@@ -73,9 +80,10 @@ export class LocalKeyStore implements ValidatorKeyStore {
    * Sign a message using eth_sign with all keystore private keys
    *
    * @param message - The message to sign
+   * @param _context - Signing context (ignored by LocalKeyStore, used for HA protection)
    * @return signatures
    */
-  public signMessage(message: Buffer32): Promise<Signature[]> {
+  public signMessage(message: Buffer32, _context: SigningContext): Promise<Signature[]> {
     return Promise.all(this.signers.map(signer => signer.signMessage(message)));
   }
 
@@ -83,10 +91,11 @@ export class LocalKeyStore implements ValidatorKeyStore {
    * Sign a message using eth_sign with a specific address's private key
    * @param address - The address of the signer to use
    * @param message - The message to sign
+   * @param _context - Signing context (ignored by LocalKeyStore, used for HA protection)
    * @returns signature for the specified address
    * @throws Error if the address is not found in the keystore
    */
-  public signMessageWithAddress(address: EthAddress, message: Buffer32): Promise<Signature> {
+  public signMessageWithAddress(address: EthAddress, message: Buffer32, _context: SigningContext): Promise<Signature> {
     const signer = this.signersByAddress.get(address.toString());
     if (!signer) {
       throw new Error(`No signer found for address ${address.toString()}`);

package/src/key_store/node_keystore_adapter.ts

@@ -1,4 +1,4 @@
-import type { EthSigner } from '@aztec/ethereum';
+import type { EthSigner } from '@aztec/ethereum/eth-signer';
 import type { Buffer32 } from '@aztec/foundation/buffer';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { Signature } from '@aztec/foundation/eth-signature';
@@ -6,6 +6,7 @@ import { KeystoreManager, loadKeystoreFile } from '@aztec/node-keystore';
 import type { EthRemoteSignerConfig } from '@aztec/node-keystore';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { InvalidValidatorPrivateKeyError } from '@aztec/stdlib/validators';
+import type { SigningContext } from '@aztec/validator-ha-signer/types';
 
 import type { TypedDataDefinition } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
@@ -230,9 +231,10 @@ export class NodeKeystoreAdapter implements ExtendedValidatorKeyStore {
   /**
    * Sign typed data with all attester signers across validators.
    * @param typedData EIP-712 typed data
+   * @param _context Signing context (ignored by NodeKeystoreAdapter, used for HA protection)
    * @returns Array of signatures in validator order, flattened
    */
-  async signTypedData(typedData: TypedDataDefinition): Promise<Signature[]> {
+  async signTypedData(typedData: TypedDataDefinition, _context: SigningContext): Promise<Signature[]> {
     const jobs: Promise<Signature>[] = [];
     for (const i of this.validatorIndices()) {
       const v = this.ensureValidator(i);
@@ -246,9 +248,10 @@ export class NodeKeystoreAdapter implements ExtendedValidatorKeyStore {
   /**
    * Sign a message with all attester signers across validators.
    * @param message 32-byte message (already hashed/padded as needed)
+   * @param _context Signing context (ignored by NodeKeystoreAdapter, used for HA protection)
    * @returns Array of signatures in validator order, flattened
    */
-  async signMessage(message: Buffer32): Promise<Signature[]> {
+  async signMessage(message: Buffer32, _context: SigningContext): Promise<Signature[]> {
     const jobs: Promise<Signature>[] = [];
     for (const i of this.validatorIndices()) {
       const v = this.ensureValidator(i);
@@ -264,10 +267,15 @@ export class NodeKeystoreAdapter implements ExtendedValidatorKeyStore {
    * Hydrates caches on-demand when the address is first seen.
    * @param address Address to sign with
    * @param typedData EIP-712 typed data
+   * @param _context Signing context (ignored by NodeKeystoreAdapter, used for HA protection)
    * @returns Signature from the signer matching the address
    * @throws Error when no signer exists for the address
    */
-  async signTypedDataWithAddress(address: EthAddress, typedData: TypedDataDefinition): Promise<Signature> {
+  async signTypedDataWithAddress(
+    address: EthAddress,
+    typedData: TypedDataDefinition,
+    _context: SigningContext,
+  ): Promise<Signature> {
     const entry = this.addressIndex.get(NodeKeystoreAdapter.key(address));
     if (entry) {
       return await this.keystoreManager.signTypedData(entry.signer, typedData);
@@ -290,10 +298,11 @@ export class NodeKeystoreAdapter implements ExtendedValidatorKeyStore {
    * Hydrates caches on-demand when the address is first seen.
    * @param address Address to sign with
    * @param message 32-byte message
+   * @param _context Signing context (ignored by NodeKeystoreAdapter, used for HA protection)
    * @returns Signature from the signer matching the address
    * @throws Error when no signer exists for the address
    */
-  async signMessageWithAddress(address: EthAddress, message: Buffer32): Promise<Signature> {
+  async signMessageWithAddress(address: EthAddress, message: Buffer32, _context: SigningContext): Promise<Signature> {
     const entry = this.addressIndex.get(NodeKeystoreAdapter.key(address));
     if (entry) {
       return await this.keystoreManager.signMessage(entry.signer, message);
@@ -372,4 +381,18 @@ export class NodeKeystoreAdapter implements ExtendedValidatorKeyStore {
     const validatorIndex = this.findValidatorIndexForAttester(attesterAddress);
     return this.keystoreManager.getEffectiveRemoteSignerConfig(validatorIndex, attesterAddress);
   }
+
+  /**
+   * Start the key store - no-op
+   */
+  start(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  /**
+   * Stop the key store - no-op
+   */
+  stop(): Promise<void> {
+    return Promise.resolve();
+  }
 }

package/src/key_store/web3signer_key_store.ts

@@ -1,12 +1,16 @@
 import type { Buffer32 } from '@aztec/foundation/buffer';
-import { normalizeSignature } from '@aztec/foundation/crypto';
+import { normalizeSignature } from '@aztec/foundation/crypto/secp256k1-signer';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
+import type { SigningContext } from '@aztec/validator-ha-signer/types';
 
 import type { TypedDataDefinition } from 'viem';
 
 import type { ValidatorKeyStore } from './interface.js';
 
+/** Default hard timeout (ms) applied to each Web3Signer HTTP request. */
+const DEFAULT_WEB3SIGNER_REQUEST_TIMEOUT_MS = 30_000;
+
 /**
  * Web3Signer Key Store
  *
@@ -14,10 +18,15 @@ import type { ValidatorKeyStore } from './interface.js';
  * This implementation uses the Web3Signer JSON-RPC API for secp256k1 signatures.
  */
 export class Web3SignerKeyStore implements ValidatorKeyStore {
+  private readonly requestTimeoutMs: number;
+
   constructor(
     private addresses: EthAddress[],
     private baseUrl: string,
-  ) {}
+    requestTimeoutMs: number = DEFAULT_WEB3SIGNER_REQUEST_TIMEOUT_MS,
+  ) {
+    this.requestTimeoutMs = requestTimeoutMs;
+  }
 
   /**
    * Get the address of a signer by index
@@ -44,9 +53,10 @@ export class Web3SignerKeyStore implements ValidatorKeyStore {
   /**
    * Sign EIP-712 typed data with all keystore addresses
    * @param typedData - The complete EIP-712 typed data structure (domain, types, primaryType, message)
+   * @param _context - Signing context (ignored by Web3SignerKeyStore, used for HA protection)
    * @return signatures
    */
-  public signTypedData(typedData: TypedDataDefinition): Promise<Signature[]> {
+  public signTypedData(typedData: TypedDataDefinition, _context: SigningContext): Promise<Signature[]> {
     return Promise.all(this.addresses.map(address => this.makeJsonRpcSignTypedDataRequest(address, typedData)));
   }
 
@@ -54,10 +64,15 @@ export class Web3SignerKeyStore implements ValidatorKeyStore {
    * Sign EIP-712 typed data with a specific address
    * @param address - The address of the signer to use
    * @param typedData - The complete EIP-712 typed data structure (domain, types, primaryType, message)
+   * @param _context - Signing context (ignored by Web3SignerKeyStore, used for HA protection)
    * @returns signature for the specified address
    * @throws Error if the address is not found in the keystore or signing fails
    */
-  public async signTypedDataWithAddress(address: EthAddress, typedData: TypedDataDefinition): Promise<Signature> {
+  public async signTypedDataWithAddress(
+    address: EthAddress,
+    typedData: TypedDataDefinition,
+    _context: SigningContext,
+  ): Promise<Signature> {
     if (!this.addresses.some(addr => addr.equals(address))) {
       throw new Error(`Address ${address.toString()} not found in keystore`);
     }
@@ -69,9 +84,10 @@ export class Web3SignerKeyStore implements ValidatorKeyStore {
    * Sign a message with all keystore addresses using EIP-191 prefix
    *
    * @param message - The message to sign
+   * @param _context - Signing context (ignored by Web3SignerKeyStore, used for HA protection)
    * @return signatures
    */
-  public signMessage(message: Buffer32): Promise<Signature[]> {
+  public signMessage(message: Buffer32, _context: SigningContext): Promise<Signature[]> {
     return Promise.all(this.addresses.map(address => this.makeJsonRpcSignRequest(address, message)));
   }
 
@@ -79,10 +95,15 @@ export class Web3SignerKeyStore implements ValidatorKeyStore {
    * Sign a message with a specific address using EIP-191 prefix
    * @param address - The address of the signer to use
    * @param message - The message to sign
+   * @param _context - Signing context (ignored by Web3SignerKeyStore, used for HA protection)
    * @returns signature for the specified address
    * @throws Error if the address is not found in the keystore or signing fails
    */
-  public async signMessageWithAddress(address: EthAddress, message: Buffer32): Promise<Signature> {
+  public async signMessageWithAddress(
+    address: EthAddress,
+    message: Buffer32,
+    _context: SigningContext,
+  ): Promise<Signature> {
     if (!this.addresses.some(addr => addr.equals(address))) {
       throw new Error(`Address ${address.toString()} not found in keystore`);
     }
@@ -95,75 +116,50 @@ export class Web3SignerKeyStore implements ValidatorKeyStore {
    * @param data - The data to sign
    * @returns The signature
    */
-  private async makeJsonRpcSignRequest(address: EthAddress, data: Buffer32): Promise<Signature> {
-    const url = this.baseUrl;
-
-    // Use JSON-RPC eth_sign method which automatically applies Ethereum message prefixing
-    const body = {
+  private makeJsonRpcSignRequest(address: EthAddress, data: Buffer32): Promise<Signature> {
+    // eth_sign automatically applies Ethereum message prefixing to the raw data.
+    return this.sendSignRequest({
       jsonrpc: '2.0',
       method: 'eth_sign',
-      params: [
-        address.toString(), // Ethereum address as identifier
-        data.toString(), // Raw data to sign (eth_sign will apply Ethereum message prefix)
-      ],
+      params: [address.toString(), data.toString()],
       id: 1,
-    };
-
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify(body),
     });
-
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`Web3Signer request failed: ${response.status} ${response.statusText} - ${errorText}`);
-    }
-
-    const result = await response.json();
-
-    // Handle JSON-RPC response format
-    if (result.error) {
-      throw new Error(`Web3Signer JSON-RPC error: ${result.error.code} - ${result.error.message}`);
-    }
-
-    if (!result.result) {
-      throw new Error('Invalid response from Web3Signer: no result found');
-    }
-
-    let signatureHex = result.result;
-
-    // Ensure the signature has the 0x prefix
-    if (!signatureHex.startsWith('0x')) {
-      signatureHex = '0x' + signatureHex;
-    }
-
-    // Parse the signature from the hex string
-    return normalizeSignature(Signature.fromString(signatureHex as `0x${string}`));
   }
 
-  private async makeJsonRpcSignTypedDataRequest(
-    address: EthAddress,
-    typedData: TypedDataDefinition,
-  ): Promise<Signature> {
-    const url = this.baseUrl;
-
-    const body = {
+  private makeJsonRpcSignTypedDataRequest(address: EthAddress, typedData: TypedDataDefinition): Promise<Signature> {
+    return this.sendSignRequest({
       jsonrpc: '2.0',
       method: 'eth_signTypedData',
       params: [address.toString(), JSON.stringify(typedData)],
       id: 1,
-    };
-
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify(body),
     });
+  }
+
+  /**
+   * Send a JSON-RPC request to Web3Signer under a hard request timeout and parse the signature.
+   * A timed-out or aborted request is surfaced as a clear timeout error rather than hanging, so a
+   * slow or unreachable signer cannot stall an HA signing operation past its own timeout budget.
+   */
+  private async sendSignRequest(body: object): Promise<Signature> {
+    let response: Response;
+    try {
+      response = await fetch(this.baseUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(this.requestTimeoutMs),
+      });
+    } catch (err) {
+      if (
+        (err instanceof Error || err instanceof DOMException) &&
+        (err.name === 'TimeoutError' || err.name === 'AbortError')
+      ) {
+        throw new Error(`Web3Signer request timed out after ${this.requestTimeoutMs}ms`);
+      }
+      throw err;
+    }
 
     if (!response.ok) {
       const errorText = await response.text();
@@ -172,6 +168,7 @@ export class Web3SignerKeyStore implements ValidatorKeyStore {
 
     const result = await response.json();
 
+    // Handle JSON-RPC response format
     if (result.error) {
       throw new Error(`Web3Signer JSON-RPC error: ${result.error.code} - ${result.error.message}`);
     }

package/src/metrics.ts

@@ -1,70 +1,90 @@
+import type { EpochNumber } from '@aztec/foundation/branded-types';
+import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { BlockProposal } from '@aztec/stdlib/p2p';
 import {
   Attributes,
+  type Gauge,
   type Histogram,
   Metrics,
   type TelemetryClient,
   type UpDownCounter,
-  ValueType,
+  createUpDownCounterWithDefault,
 } from '@aztec/telemetry-client';
 
+import type { BlockProposalValidationFailureReason } from './proposal_handler.js';
+
 export class ValidatorMetrics {
   private failedReexecutionCounter: UpDownCounter;
   private successfulAttestationsCount: UpDownCounter;
   private failedAttestationsBadProposalCount: UpDownCounter;
   private failedAttestationsNodeIssueCount: UpDownCounter;
+  private currentEpoch: Gauge;
+  private attestedEpochCount: UpDownCounter;
 
   private reexMana: Histogram;
   private reexTx: Histogram;
-  private reexDuration: Histogram;
+  private reexDuration: Gauge;
+  private checkpointProposalToPipelinedStateDuration: Histogram;
+  private checkpointProposalReceiveOffsetFromNextSlotBoundary: Histogram;
 
   constructor(telemetryClient: TelemetryClient) {
     const meter = telemetryClient.getMeter('Validator');
 
-    this.failedReexecutionCounter = meter.createUpDownCounter(Metrics.VALIDATOR_FAILED_REEXECUTION_COUNT, {
-      description: 'The number of failed re-executions',
-      unit: 'count',
-      valueType: ValueType.INT,
+    this.failedReexecutionCounter = createUpDownCounterWithDefault(meter, Metrics.VALIDATOR_FAILED_REEXECUTION_COUNT, {
+      [Attributes.STATUS]: ['failed'],
     });
 
-    this.successfulAttestationsCount = meter.createUpDownCounter(Metrics.VALIDATOR_ATTESTATION_SUCCESS_COUNT, {
-      description: 'The number of successful attestations',
-      valueType: ValueType.INT,
-    });
+    this.successfulAttestationsCount = createUpDownCounterWithDefault(
+      meter,
+      Metrics.VALIDATOR_ATTESTATION_SUCCESS_COUNT,
+    );
 
-    this.failedAttestationsBadProposalCount = meter.createUpDownCounter(
+    this.failedAttestationsBadProposalCount = createUpDownCounterWithDefault(
+      meter,
       Metrics.VALIDATOR_ATTESTATION_FAILED_BAD_PROPOSAL_COUNT,
       {
-        description: 'The number of failed attestations due to invalid block proposals',
-        valueType: ValueType.INT,
+        [Attributes.ERROR_TYPE]: [
+          'invalid_proposal',
+          'state_mismatch',
+          'failed_txs',
+          'in_hash_mismatch',
+          'parent_block_wrong_slot',
+        ],
+        [Attributes.IS_COMMITTEE_MEMBER]: [true, false],
       },
     );
 
-    this.failedAttestationsNodeIssueCount = meter.createUpDownCounter(
+    this.failedAttestationsNodeIssueCount = createUpDownCounterWithDefault(
+      meter,
       Metrics.VALIDATOR_ATTESTATION_FAILED_NODE_ISSUE_COUNT,
       {
-        description: 'The number of failed attestations due to node issues (timeout, missing data, etc.)',
-        valueType: ValueType.INT,
+        [Attributes.ERROR_TYPE]: [
+          'parent_block_not_found',
+          'global_variables_mismatch',
+          'block_number_already_exists',
+          'txs_not_available',
+          'timeout',
+          'unknown_error',
+        ],
+        [Attributes.IS_COMMITTEE_MEMBER]: [true, false],
       },
     );
 
-    this.reexMana = meter.createHistogram(Metrics.VALIDATOR_RE_EXECUTION_MANA, {
-      description: 'The mana consumed by blocks',
-      valueType: ValueType.DOUBLE,
-      unit: 'Mmana',
-    });
+    this.currentEpoch = meter.createGauge(Metrics.VALIDATOR_CURRENT_EPOCH);
 
-    this.reexTx = meter.createHistogram(Metrics.VALIDATOR_RE_EXECUTION_TX_COUNT, {
-      description: 'The number of txs in a block proposal',
-      valueType: ValueType.INT,
-      unit: 'tx',
-    });
+    this.attestedEpochCount = createUpDownCounterWithDefault(meter, Metrics.VALIDATOR_ATTESTED_EPOCH_COUNT);
 
-    this.reexDuration = meter.createGauge(Metrics.VALIDATOR_RE_EXECUTION_TIME, {
-      description: 'The time taken to re-execute a transaction',
-      unit: 'ms',
-      valueType: ValueType.INT,
-    });
+    this.reexMana = meter.createHistogram(Metrics.VALIDATOR_RE_EXECUTION_MANA);
+
+    this.reexTx = meter.createHistogram(Metrics.VALIDATOR_RE_EXECUTION_TX_COUNT);
+
+    this.reexDuration = meter.createGauge(Metrics.VALIDATOR_RE_EXECUTION_TIME);
+    this.checkpointProposalToPipelinedStateDuration = meter.createHistogram(
+      Metrics.VALIDATOR_CHECKPOINT_PROPOSAL_TO_PIPELINED_STATE_DURATION,
+    );
+    this.checkpointProposalReceiveOffsetFromNextSlotBoundary = meter.createHistogram(
+      Metrics.VALIDATOR_CHECKPOINT_PROPOSAL_RECEIVE_OFFSET_FROM_NEXT_SLOT_BOUNDARY,
+    );
   }
 
   public recordReex(time: number, txs: number, mManaTotal: number) {
@@ -73,6 +93,16 @@ export class ValidatorMetrics {
     this.reexMana.record(mManaTotal);
   }
 
+  public recordCheckpointProposalToPipelinedStateDuration(durationMs: number) {
+    this.checkpointProposalToPipelinedStateDuration.record(Math.ceil(durationMs));
+  }
+
+  public recordCheckpointProposalReceiveOffsetFromNextSlotBoundary(offsetMs: number) {
+    this.checkpointProposalReceiveOffsetFromNextSlotBoundary.record(Math.ceil(Math.abs(offsetMs)), {
+      [Attributes.SLOT_BOUNDARY_SIDE]: offsetMs < 0 ? 'before' : 'after',
+    });
+  }
+
   public recordFailedReexecution(proposal: BlockProposal) {
     const proposer = proposal.getSender();
     this.failedReexecutionCounter.add(1, {
@@ -85,17 +115,35 @@ export class ValidatorMetrics {
     this.successfulAttestationsCount.add(num);
   }
 
-  public incFailedAttestationsBadProposal(num: number, reason: string, inCommittee: boolean) {
+  public incFailedAttestationsBadProposal(
+    num: number,
+    reason: BlockProposalValidationFailureReason,
+    inCommittee: boolean,
+  ) {
     this.failedAttestationsBadProposalCount.add(num, {
       [Attributes.ERROR_TYPE]: reason,
       [Attributes.IS_COMMITTEE_MEMBER]: inCommittee,
     });
   }
 
-  public incFailedAttestationsNodeIssue(num: number, reason: string, inCommittee: boolean) {
+  public incFailedAttestationsNodeIssue(
+    num: number,
+    reason: BlockProposalValidationFailureReason,
+    inCommittee: boolean,
+  ) {
     this.failedAttestationsNodeIssueCount.add(num, {
       [Attributes.ERROR_TYPE]: reason,
       [Attributes.IS_COMMITTEE_MEMBER]: inCommittee,
     });
   }
+
+  /** Update the gauge tracking the current epoch number (proxy for total epochs elapsed). */
+  public setCurrentEpoch(epoch: EpochNumber) {
+    this.currentEpoch.record(Number(epoch));
+  }
+
+  /** Increment the count of epochs in which the given attester submitted at least one attestation. */
+  public incAttestedEpochCount(attester: EthAddress) {
+    this.attestedEpochCount.add(1, { [Attributes.ATTESTER_ADDRESS]: attester.toString() });
+  }
 }