@aztec/validator-client 0.0.0-test.1 → 0.0.1-commit.023c3e5

package/src/checkpoint_builder.ts

@@ -0,0 +1,314 @@
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { merge, pick } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import { bufferToHex } from '@aztec/foundation/string';
+import { DateProvider, elapsed } from '@aztec/foundation/timer';
+import { getDefaultAllowedSetupFunctions } from '@aztec/p2p/msg_validators';
+import { LightweightCheckpointBuilder } from '@aztec/prover-client/light';
+import {
+  GuardedMerkleTreeOperations,
+  PublicContractsDB,
+  PublicProcessor,
+  createPublicTxSimulatorForBlockBuilding,
+} from '@aztec/simulator/server';
+import { L2Block } from '@aztec/stdlib/block';
+import { Checkpoint } from '@aztec/stdlib/checkpoint';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import { Gas } from '@aztec/stdlib/gas';
+import {
+  type BuildBlockInCheckpointResult,
+  type FullNodeBlockBuilderConfig,
+  FullNodeBlockBuilderConfigKeys,
+  type ICheckpointBlockBuilder,
+  type ICheckpointsBuilder,
+  type MerkleTreeWriteOperations,
+  NoValidTxsError,
+  type PublicProcessorLimits,
+  type WorldStateSynchronizer,
+} from '@aztec/stdlib/interfaces/server';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { type CheckpointGlobalVariables, GlobalVariables, StateReference, Tx } from '@aztec/stdlib/tx';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+
+import { createValidatorForBlockBuilding } from './tx_validator/tx_validator_factory.js';
+
+// Re-export for backward compatibility
+export type { BuildBlockInCheckpointResult } from '@aztec/stdlib/interfaces/server';
+
+/**
+ * Builder for a single checkpoint. Handles building blocks within the checkpoint
+ * and completing it.
+ */
+export class CheckpointBuilder implements ICheckpointBlockBuilder {
+  private log: Logger;
+
+  constructor(
+    private checkpointBuilder: LightweightCheckpointBuilder,
+    private fork: MerkleTreeWriteOperations,
+    private config: FullNodeBlockBuilderConfig,
+    private contractDataSource: ContractDataSource,
+    private dateProvider: DateProvider,
+    private telemetryClient: TelemetryClient,
+    bindings?: LoggerBindings,
+  ) {
+    this.log = createLogger('checkpoint-builder', {
+      ...bindings,
+      instanceId: `checkpoint-${checkpointBuilder.checkpointNumber}`,
+    });
+  }
+
+  getConstantData(): CheckpointGlobalVariables {
+    return this.checkpointBuilder.constants;
+  }
+
+  /**
+   * Builds a single block within this checkpoint.
+   */
+  async buildBlock(
+    pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
+    blockNumber: BlockNumber,
+    timestamp: bigint,
+    opts: PublicProcessorLimits & { expectedEndState?: StateReference } = {},
+  ): Promise<BuildBlockInCheckpointResult> {
+    const slot = this.checkpointBuilder.constants.slotNumber;
+
+    this.log.verbose(`Building block ${blockNumber} for slot ${slot} within checkpoint`, {
+      slot,
+      blockNumber,
+      ...opts,
+      currentTime: new Date(this.dateProvider.now()),
+    });
+
+    const constants = this.checkpointBuilder.constants;
+    const globalVariables = GlobalVariables.from({
+      chainId: constants.chainId,
+      version: constants.version,
+      blockNumber,
+      slotNumber: constants.slotNumber,
+      timestamp,
+      coinbase: constants.coinbase,
+      feeRecipient: constants.feeRecipient,
+      gasFees: constants.gasFees,
+    });
+    const { processor, validator } = await this.makeBlockBuilderDeps(globalVariables, this.fork);
+
+    const [publicProcessorDuration, [processedTxs, failedTxs, usedTxs, _, usedTxBlobFields]] = await elapsed(() =>
+      processor.process(pendingTxs, opts, validator),
+    );
+
+    // Throw if we didn't collect a single valid tx and we're not allowed to build empty blocks
+    // (only the first block in a checkpoint can be empty)
+    if (processedTxs.length === 0 && this.checkpointBuilder.getBlockCount() > 0) {
+      throw new NoValidTxsError(failedTxs);
+    }
+
+    // Add block to checkpoint
+    const block = await this.checkpointBuilder.addBlock(globalVariables, processedTxs, {
+      expectedEndState: opts.expectedEndState,
+    });
+
+    // How much public gas was processed
+    const publicGas = processedTxs.reduce((acc, tx) => acc.add(tx.gasUsed.publicGas), Gas.empty());
+
+    this.log.debug('Built block within checkpoint', {
+      header: block.header.toInspect(),
+      processedTxs: processedTxs.map(tx => tx.hash.toString()),
+      failedTxs: failedTxs.map(tx => tx.tx.txHash.toString()),
+    });
+
+    return {
+      block,
+      publicGas,
+      publicProcessorDuration,
+      numTxs: processedTxs.length,
+      failedTxs,
+      usedTxs,
+      usedTxBlobFields,
+    };
+  }
+
+  /** Completes the checkpoint and returns it. */
+  async completeCheckpoint(): Promise<Checkpoint> {
+    const checkpoint = await this.checkpointBuilder.completeCheckpoint();
+
+    this.log.verbose(`Completed checkpoint ${checkpoint.number}`, {
+      checkpointNumber: checkpoint.number,
+      numBlocks: checkpoint.blocks.length,
+      archiveRoot: checkpoint.archive.root.toString(),
+    });
+
+    return checkpoint;
+  }
+
+  /** Gets the checkpoint currently in progress. */
+  getCheckpoint(): Promise<Checkpoint> {
+    return this.checkpointBuilder.clone().completeCheckpoint();
+  }
+
+  protected async makeBlockBuilderDeps(globalVariables: GlobalVariables, fork: MerkleTreeWriteOperations) {
+    const txPublicSetupAllowList = this.config.txPublicSetupAllowList ?? (await getDefaultAllowedSetupFunctions());
+    const contractsDB = new PublicContractsDB(this.contractDataSource, this.log.getBindings());
+    const guardedFork = new GuardedMerkleTreeOperations(fork);
+
+    const bindings = this.log.getBindings();
+    const publicTxSimulator = createPublicTxSimulatorForBlockBuilding(
+      guardedFork,
+      contractsDB,
+      globalVariables,
+      this.telemetryClient,
+      bindings,
+    );
+
+    const processor = new PublicProcessor(
+      globalVariables,
+      guardedFork,
+      contractsDB,
+      publicTxSimulator,
+      this.dateProvider,
+      this.telemetryClient,
+      createLogger('simulator:public-processor', bindings),
+      this.config,
+    );
+
+    const validator = createValidatorForBlockBuilding(
+      fork,
+      this.contractDataSource,
+      globalVariables,
+      txPublicSetupAllowList,
+      this.log.getBindings(),
+    );
+
+    return {
+      processor,
+      validator,
+    };
+  }
+}
+
+/** Factory for creating checkpoint builders. */
+export class FullNodeCheckpointsBuilder implements ICheckpointsBuilder {
+  private log: Logger;
+
+  constructor(
+    private config: FullNodeBlockBuilderConfig & Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'>,
+    private worldState: WorldStateSynchronizer,
+    private contractDataSource: ContractDataSource,
+    private dateProvider: DateProvider,
+    private telemetryClient: TelemetryClient = getTelemetryClient(),
+  ) {
+    this.log = createLogger('checkpoint-builder');
+  }
+
+  public getConfig(): FullNodeBlockBuilderConfig {
+    return this.config;
+  }
+
+  public updateConfig(config: Partial<FullNodeBlockBuilderConfig>) {
+    this.config = merge(this.config, pick(config, ...FullNodeBlockBuilderConfigKeys));
+  }
+
+  /**
+   * Starts a new checkpoint and returns a CheckpointBuilder to build blocks within it.
+   */
+  async startCheckpoint(
+    checkpointNumber: CheckpointNumber,
+    constants: CheckpointGlobalVariables,
+    l1ToL2Messages: Fr[],
+    previousCheckpointOutHashes: Fr[],
+    fork: MerkleTreeWriteOperations,
+    bindings?: LoggerBindings,
+  ): Promise<CheckpointBuilder> {
+    const stateReference = await fork.getStateReference();
+    const archiveTree = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
+
+    this.log.verbose(`Building new checkpoint ${checkpointNumber}`, {
+      checkpointNumber,
+      msgCount: l1ToL2Messages.length,
+      initialStateReference: stateReference.toInspect(),
+      initialArchiveRoot: bufferToHex(archiveTree.root),
+      constants,
+    });
+
+    const lightweightBuilder = await LightweightCheckpointBuilder.startNewCheckpoint(
+      checkpointNumber,
+      constants,
+      l1ToL2Messages,
+      previousCheckpointOutHashes,
+      fork,
+      bindings,
+    );
+
+    return new CheckpointBuilder(
+      lightweightBuilder,
+      fork,
+      this.config,
+      this.contractDataSource,
+      this.dateProvider,
+      this.telemetryClient,
+      bindings,
+    );
+  }
+
+  /**
+   * Opens a checkpoint, either starting fresh or resuming from existing blocks.
+   */
+  async openCheckpoint(
+    checkpointNumber: CheckpointNumber,
+    constants: CheckpointGlobalVariables,
+    l1ToL2Messages: Fr[],
+    previousCheckpointOutHashes: Fr[],
+    fork: MerkleTreeWriteOperations,
+    existingBlocks: L2Block[] = [],
+    bindings?: LoggerBindings,
+  ): Promise<CheckpointBuilder> {
+    const stateReference = await fork.getStateReference();
+    const archiveTree = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
+
+    if (existingBlocks.length === 0) {
+      return this.startCheckpoint(
+        checkpointNumber,
+        constants,
+        l1ToL2Messages,
+        previousCheckpointOutHashes,
+        fork,
+        bindings,
+      );
+    }
+
+    this.log.verbose(`Resuming checkpoint ${checkpointNumber} with ${existingBlocks.length} existing blocks`, {
+      checkpointNumber,
+      msgCount: l1ToL2Messages.length,
+      existingBlockCount: existingBlocks.length,
+      initialStateReference: stateReference.toInspect(),
+      initialArchiveRoot: bufferToHex(archiveTree.root),
+      constants,
+    });
+
+    const lightweightBuilder = await LightweightCheckpointBuilder.resumeCheckpoint(
+      checkpointNumber,
+      constants,
+      l1ToL2Messages,
+      previousCheckpointOutHashes,
+      fork,
+      existingBlocks,
+      bindings,
+    );
+
+    return new CheckpointBuilder(
+      lightweightBuilder,
+      fork,
+      this.config,
+      this.contractDataSource,
+      this.dateProvider,
+      this.telemetryClient,
+      bindings,
+    );
+  }
+
+  /** Returns a fork of the world state at the given block number. */
+  getFork(blockNumber: BlockNumber): Promise<MerkleTreeWriteOperations> {
+    return this.worldState.fork(blockNumber);
+  }
+}

package/src/config.ts

@@ -1,38 +1,48 @@
-import { NULL_KEY } from '@aztec/ethereum';
 import {
   type ConfigMappingsType,
   booleanConfigHelper,
   getConfigFromMappings,
   numberConfigHelper,
+  secretValueConfigHelper,
 } from '@aztec/foundation/config';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { ValidatorClientConfig } from '@aztec/stdlib/interfaces/server';
+import { validatorHASignerConfigMappings } from '@aztec/validator-ha-signer/config';
 
-/**
- * The Validator Configuration
- */
-export interface ValidatorClientConfig {
-  /** The private key of the validator participating in attestation duties */
-  validatorPrivateKey?: string;
-
-  /** Do not run the validator */
-  disableValidator: boolean;
-
-  /** Interval between polling for new attestations from peers */
-  attestationPollingIntervalMs: number;
-
-  /** Re-execute transactions before attesting */
-  validatorReexecute: boolean;
-}
+export type { ValidatorClientConfig };
 
 export const validatorClientConfigMappings: ConfigMappingsType<ValidatorClientConfig> = {
-  validatorPrivateKey: {
-    env: 'VALIDATOR_PRIVATE_KEY',
-    parseEnv: (val: string) => (val ? `0x${val.replace('0x', '')}` : NULL_KEY),
-    description: 'The private key of the validator participating in attestation duties',
+  validatorPrivateKeys: {
+    env: 'VALIDATOR_PRIVATE_KEYS',
+    description: 'List of private keys of the validators participating in attestation duties',
+    ...secretValueConfigHelper<`0x${string}`[]>(val =>
+      val ? val.split(',').map<`0x${string}`>(key => `0x${key.replace('0x', '')}`) : [],
+    ),
+    fallback: ['VALIDATOR_PRIVATE_KEY'],
+  },
+  validatorAddresses: {
+    env: 'VALIDATOR_ADDRESSES',
+    description: 'List of addresses of the validators to use with remote signers',
+    parseEnv: (val: string) =>
+      val
+        .split(',')
+        .filter(address => address && address.trim().length > 0)
+        .map(address => EthAddress.fromString(address.trim())),
+    defaultValue: [],
   },
   disableValidator: {
     env: 'VALIDATOR_DISABLED',
     description: 'Do not run the validator',
-    ...booleanConfigHelper(),
+    ...booleanConfigHelper(false),
+  },
+  disabledValidators: {
+    description: 'Temporarily disable these specific validator addresses',
+    parseEnv: (val: string) =>
+      val
+        .split(',')
+        .filter(address => address && address.trim().length > 0)
+        .map(address => EthAddress.fromString(address.trim())),
+    defaultValue: [],
   },
   attestationPollingIntervalMs: {
     env: 'VALIDATOR_ATTESTATIONS_POLLING_INTERVAL_MS',
@@ -44,6 +54,26 @@ export const validatorClientConfigMappings: ConfigMappingsType<ValidatorClientCo
     description: 'Re-execute transactions before attesting',
     ...booleanConfigHelper(true),
   },
+  alwaysReexecuteBlockProposals: {
+    description:
+      'Whether to always reexecute block proposals, even for non-validator nodes (useful for monitoring network status).',
+    defaultValue: true,
+  },
+  fishermanMode: {
+    env: 'FISHERMAN_MODE',
+    description:
+      'Whether to run in fisherman mode: validates all proposals and attestations but does not broadcast attestations or participate in consensus.',
+    ...booleanConfigHelper(false),
+  },
+  skipCheckpointProposalValidation: {
+    description: 'Skip checkpoint proposal validation and always attest (default: false)',
+    defaultValue: false,
+  },
+  skipPushProposedBlocksToArchiver: {
+    description: 'Skip pushing re-executed blocks to archiver (default: false)',
+    defaultValue: false,
+  },
+  ...validatorHASignerConfigMappings,
 };
 
 /**

package/src/duties/validation_service.ts

@@ -1,45 +1,219 @@
+import {
+  BlockNumber,
+  type CheckpointNumber,
+  IndexWithinCheckpoint,
+  type SlotNumber,
+} from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { keccak256 } from '@aztec/foundation/crypto';
-import type { Fr } from '@aztec/foundation/fields';
-import { BlockAttestation, BlockProposal, ConsensusPayload, SignatureDomainSeparator } from '@aztec/stdlib/p2p';
-import type { BlockHeader, TxHash } from '@aztec/stdlib/tx';
+import { keccak256 } from '@aztec/foundation/crypto/keccak';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { Signature } from '@aztec/foundation/eth-signature';
+import { createLogger } from '@aztec/foundation/log';
+import type { CommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
+import type { CreateCheckpointProposalLastBlockData } from '@aztec/stdlib/interfaces/server';
+import {
+  BlockProposal,
+  type BlockProposalOptions,
+  CheckpointAttestation,
+  CheckpointProposal,
+  type CheckpointProposalCore,
+  type CheckpointProposalOptions,
+  ConsensusPayload,
+  SignatureDomainSeparator,
+} from '@aztec/stdlib/p2p';
+import type { CheckpointHeader } from '@aztec/stdlib/rollup';
+import type { BlockHeader, Tx } from '@aztec/stdlib/tx';
+import { DutyAlreadySignedError, SlashingProtectionError } from '@aztec/validator-ha-signer/errors';
+import { DutyType, type SigningContext } from '@aztec/validator-ha-signer/types';
 
 import type { ValidatorKeyStore } from '../key_store/interface.js';
 
 export class ValidationService {
-  constructor(private keyStore: ValidatorKeyStore) {}
+  constructor(
+    private keyStore: ValidatorKeyStore,
+    private log = createLogger('validator:validation-service'),
+  ) {}
 
   /**
    * Create a block proposal with the given header, archive, and transactions
    *
-   * @param header - The block header
+   * @param blockHeader - The block header
+   * @param blockIndexWithinCheckpoint - The block index within checkpoint for HA signing context
+   * @param inHash - Hash of L1 to L2 messages for this checkpoint
    * @param archive - The archive of the current block
-   * @param txs - TxHash[] ordered list of transactions
+   * @param txs - Ordered list of transactions (Tx[])
+   * @param proposerAttesterAddress - The address of the proposer/attester, or undefined
+   * @param options - Block proposal options (including broadcastInvalidBlockProposal for testing)
    *
-   * @returns A block proposal signing the above information (not the current implementation!!!)
+   * @returns A block proposal signing the above information
+   * @throws DutyAlreadySignedError if HA signer indicates duty already signed by another node
+   * @throws SlashingProtectionError if attempting to sign different data for same slot
    */
-  createBlockProposal(header: BlockHeader, archive: Fr, txs: TxHash[]): Promise<BlockProposal> {
-    const payloadSigner = (payload: Buffer32) => this.keyStore.signMessage(payload);
+  public createBlockProposal(
+    blockHeader: BlockHeader,
+    blockIndexWithinCheckpoint: IndexWithinCheckpoint,
+    inHash: Fr,
+    archive: Fr,
+    txs: Tx[],
+    proposerAttesterAddress: EthAddress | undefined,
+    options: BlockProposalOptions,
+  ): Promise<BlockProposal> {
+    // For testing: change the new archive to trigger state_mismatch validation failure
+    if (options.broadcastInvalidBlockProposal) {
+      archive = Fr.random();
+      this.log.warn(`Creating INVALID block proposal for slot ${blockHeader.globalVariables.slotNumber}`);
+    }
 
-    return BlockProposal.createProposalFromSigner(new ConsensusPayload(header, archive, txs), payloadSigner);
+    // Create a signer that uses the appropriate address
+    const address = proposerAttesterAddress ?? this.keyStore.getAddress(0);
+    const payloadSigner = (payload: Buffer32, context: SigningContext) =>
+      this.keyStore.signMessageWithAddress(address, payload, context);
+
+    return BlockProposal.createProposalFromSigner(
+      blockHeader,
+      blockIndexWithinCheckpoint,
+      inHash,
+      archive,
+      txs.map(tx => tx.getTxHash()),
+      options.publishFullTxs ? txs : undefined,
+      payloadSigner,
+    );
+  }
+
+  /**
+   * Create a checkpoint proposal with the last block header and checkpoint header
+   *
+   * @param checkpointHeader - The checkpoint header containing aggregated data
+   * @param archive - The archive of the checkpoint
+   * @param lastBlockInfo - Info about the last block (header, index, txs) or undefined
+   * @param proposerAttesterAddress - The address of the proposer
+   * @param options - Checkpoint proposal options
+   *
+   * @returns A checkpoint proposal signing the above information
+   */
+  public createCheckpointProposal(
+    checkpointHeader: CheckpointHeader,
+    archive: Fr,
+    lastBlockInfo: CreateCheckpointProposalLastBlockData | undefined,
+    proposerAttesterAddress: EthAddress | undefined,
+    options: CheckpointProposalOptions,
+  ): Promise<CheckpointProposal> {
+    // For testing: change the archive to trigger state_mismatch validation failure
+    if (options.broadcastInvalidCheckpointProposal) {
+      archive = Fr.random();
+      this.log.warn(`Creating INVALID checkpoint proposal for slot ${checkpointHeader.slotNumber}`);
+    }
+
+    // Create a signer that takes payload and context, and uses the appropriate address
+    const payloadSigner = (payload: Buffer32, context: SigningContext) => {
+      const address = proposerAttesterAddress ?? this.keyStore.getAddress(0);
+      return this.keyStore.signMessageWithAddress(address, payload, context);
+    };
+
+    // Last block to include in the proposal
+    const lastBlock = lastBlockInfo && {
+      blockHeader: lastBlockInfo.blockHeader,
+      indexWithinCheckpoint: lastBlockInfo.indexWithinCheckpoint,
+      txHashes: lastBlockInfo.txs.map(tx => tx.getTxHash()),
+      txs: options.publishFullTxs ? lastBlockInfo.txs : undefined,
+    };
+
+    return CheckpointProposal.createProposalFromSigner(checkpointHeader, archive, lastBlock, payloadSigner);
   }
 
   /**
-   * Attest to the given block proposal constructed by the current sequencer
+   * Attest with selection of validators to the given checkpoint proposal
    *
    * NOTE: This is just a blind signing.
    *       We assume that the proposal is valid and DA guarantees have been checked previously.
    *
-   * @param proposal - The proposal to attest to
-   * @returns attestation
+   * @param proposal - The checkpoint proposal (core version without lastBlock) to attest to
+   * @param attestors - The validators to attest with
+   * @returns checkpoint attestations
+   */
+  async attestToCheckpointProposal(
+    proposal: CheckpointProposalCore,
+    attestors: EthAddress[],
+  ): Promise<CheckpointAttestation[]> {
+    // Create the attestation payload from the checkpoint proposal
+    const payload = new ConsensusPayload(proposal.checkpointHeader, proposal.archive);
+    const buf = Buffer32.fromBuffer(
+      keccak256(payload.getPayloadToSign(SignatureDomainSeparator.checkpointAttestation)),
+    );
+
+    // TODO(spy/ha): Use checkpointNumber instead of blockNumber once CheckpointHeader includes it.
+    // Currently using lastBlock.blockNumber as a proxy for checkpoint identification in HA signing.
+    // blockNumber is NOT used for the primary key so it's safe to use here.
+    // See CheckpointHeader TODO and SigningContext types documentation.
+    let blockNumber: BlockNumber;
+    try {
+      blockNumber = proposal.blockNumber;
+    } catch {
+      // Checkpoint proposal may not have lastBlock, use 0 as fallback
+      blockNumber = BlockNumber(0);
+    }
+    const context: SigningContext = {
+      slot: proposal.slotNumber,
+      blockNumber,
+      dutyType: DutyType.ATTESTATION,
+    };
+
+    // Sign each attestor in parallel, catching HA errors per-attestor
+    const results = await Promise.allSettled(
+      attestors.map(async attestor => {
+        const sig = await this.keyStore.signMessageWithAddress(attestor, buf, context);
+        // return new BlockAttestation(proposal.payload, sig, proposal.signature);
+        return new CheckpointAttestation(payload, sig, proposal.signature);
+      }),
+    );
+
+    const attestations: CheckpointAttestation[] = [];
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      if (result.status === 'fulfilled') {
+        attestations.push(result.value);
+      } else {
+        const error = result.reason;
+        if (error instanceof DutyAlreadySignedError || error instanceof SlashingProtectionError) {
+          this.log.info(
+            `Attestation for slot ${proposal.slotNumber} by ${attestors[i]} already signed by another High-Availability node`,
+          );
+          // Continue with remaining attestors
+        } else {
+          throw error;
+        }
+      }
+    }
+
+    return attestations;
+  }
+
+  /**
+   * Sign attestations and signers payload
+   * @param attestationsAndSigners - The attestations and signers to sign
+   * @param proposer - The proposer address to sign with
+   * @param slot - The slot number for HA signing context
+   * @param blockNumber - The block or checkpoint number for HA signing context
+   * @returns signature
+   * @throws DutyAlreadySignedError if already signed by another HA node
+   * @throws SlashingProtectionError if attempting to sign different data for same slot
    */
-  async attestToProposal(proposal: BlockProposal): Promise<BlockAttestation> {
-    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/7961): check that the current validator is correct
+  signAttestationsAndSigners(
+    attestationsAndSigners: CommitteeAttestationsAndSigners,
+    proposer: EthAddress,
+    slot: SlotNumber,
+    blockNumber: BlockNumber | CheckpointNumber,
+  ): Promise<Signature> {
+    const context: SigningContext = {
+      slot,
+      blockNumber,
+      dutyType: DutyType.ATTESTATIONS_AND_SIGNERS,
+    };
 
     const buf = Buffer32.fromBuffer(
-      keccak256(await proposal.payload.getPayloadToSign(SignatureDomainSeparator.blockAttestation)),
+      keccak256(attestationsAndSigners.getPayloadToSign(SignatureDomainSeparator.attestationsAndSigners)),
     );
-    const sig = await this.keyStore.signMessage(buf);
-    return new BlockAttestation(proposal.payload, sig);
+    return this.keyStore.signMessageWithAddress(proposer, buf, context);
   }
 }