@aztec/validator-client 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/validator-client",
-  "version": "4.0.0-nightly.20250907",
+  "version": "4.0.0-nightly.20260108",
   "main": "dest/index.js",
   "type": "module",
   "exports": {
@@ -18,8 +18,8 @@
   },
   "scripts": {
     "start": "node --no-warnings ./dest/bin",
-    "build": "yarn clean && tsc -b",
-    "build:dev": "tsc -b --watch",
+    "build": "yarn clean && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
     "clean": "rm -rf ./dest .tsbuildinfo",
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
@@ -64,25 +64,27 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "4.0.0-nightly.20250907",
-    "@aztec/epoch-cache": "4.0.0-nightly.20250907",
-    "@aztec/ethereum": "4.0.0-nightly.20250907",
-    "@aztec/foundation": "4.0.0-nightly.20250907",
-    "@aztec/node-keystore": "4.0.0-nightly.20250907",
-    "@aztec/p2p": "4.0.0-nightly.20250907",
-    "@aztec/prover-client": "4.0.0-nightly.20250907",
-    "@aztec/slasher": "4.0.0-nightly.20250907",
-    "@aztec/stdlib": "4.0.0-nightly.20250907",
-    "@aztec/telemetry-client": "4.0.0-nightly.20250907",
+    "@aztec/blob-client": "4.0.0-nightly.20260108",
+    "@aztec/blob-lib": "4.0.0-nightly.20260108",
+    "@aztec/constants": "4.0.0-nightly.20260108",
+    "@aztec/epoch-cache": "4.0.0-nightly.20260108",
+    "@aztec/ethereum": "4.0.0-nightly.20260108",
+    "@aztec/foundation": "4.0.0-nightly.20260108",
+    "@aztec/node-keystore": "4.0.0-nightly.20260108",
+    "@aztec/p2p": "4.0.0-nightly.20260108",
+    "@aztec/slasher": "4.0.0-nightly.20260108",
+    "@aztec/stdlib": "4.0.0-nightly.20260108",
+    "@aztec/telemetry-client": "4.0.0-nightly.20260108",
     "koa": "^2.16.1",
-    "koa-router": "^12.0.0",
+    "koa-router": "^13.1.1",
     "tslib": "^2.4.0",
-    "viem": "2.23.7"
+    "viem": "npm:@aztec/viem@2.38.2"
   },
   "devDependencies": {
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",
+    "@typescript/native-preview": "7.0.0-dev.20251126.1",
     "jest": "^30.0.0",
     "jest-mock-extended": "^4.0.0",
     "ts-node": "^10.9.1",

package/src/block_proposal_handler.ts

@@ -0,0 +1,346 @@
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { TimeoutError } from '@aztec/foundation/error';
+import { createLogger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
+import { DateProvider, Timer } from '@aztec/foundation/timer';
+import type { P2P, PeerId } from '@aztec/p2p';
+import { TxProvider } from '@aztec/p2p';
+import { BlockProposalValidator } from '@aztec/p2p/msg_validators';
+import type { L2Block, L2BlockSource } from '@aztec/stdlib/block';
+import { getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import type { IFullNodeBlockBuilder, ValidatorClientFullConfig } from '@aztec/stdlib/interfaces/server';
+import { type L1ToL2MessageSource, computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
+import { type BlockProposal, ConsensusPayload } from '@aztec/stdlib/p2p';
+import { BlockHeader, type FailedTx, GlobalVariables, type Tx } from '@aztec/stdlib/tx';
+import {
+  ReExFailedTxsError,
+  ReExStateMismatchError,
+  ReExTimeoutError,
+  TransactionsNotAvailableError,
+} from '@aztec/stdlib/validators';
+import { type TelemetryClient, type Tracer, getTelemetryClient } from '@aztec/telemetry-client';
+
+import type { ValidatorMetrics } from './metrics.js';
+
+export type BlockProposalValidationFailureReason =
+  | 'invalid_proposal'
+  | 'parent_block_not_found'
+  | 'parent_block_wrong_slot'
+  | 'in_hash_mismatch'
+  | 'block_number_already_exists'
+  | 'txs_not_available'
+  | 'state_mismatch'
+  | 'failed_txs'
+  | 'timeout'
+  | 'unknown_error';
+
+type ReexecuteTransactionsResult = {
+  block: L2Block;
+  failedTxs: FailedTx[];
+  reexecutionTimeMs: number;
+  totalManaUsed: number;
+};
+
+export type BlockProposalValidationSuccessResult = {
+  isValid: true;
+  blockNumber: BlockNumber;
+  reexecutionResult?: ReexecuteTransactionsResult;
+};
+
+export type BlockProposalValidationFailureResult = {
+  isValid: false;
+  reason: BlockProposalValidationFailureReason;
+  blockNumber?: BlockNumber;
+  reexecutionResult?: ReexecuteTransactionsResult;
+};
+
+export type BlockProposalValidationResult = BlockProposalValidationSuccessResult | BlockProposalValidationFailureResult;
+
+export class BlockProposalHandler {
+  public readonly tracer: Tracer;
+
+  constructor(
+    private blockBuilder: IFullNodeBlockBuilder,
+    private blockSource: L2BlockSource,
+    private l1ToL2MessageSource: L1ToL2MessageSource,
+    private txProvider: TxProvider,
+    private blockProposalValidator: BlockProposalValidator,
+    private config: ValidatorClientFullConfig,
+    private metrics?: ValidatorMetrics,
+    private dateProvider: DateProvider = new DateProvider(),
+    telemetry: TelemetryClient = getTelemetryClient(),
+    private log = createLogger('validator:block-proposal-handler'),
+  ) {
+    if (config.fishermanMode) {
+      this.log = this.log.createChild('[FISHERMAN]');
+    }
+    this.tracer = telemetry.getTracer('BlockProposalHandler');
+  }
+
+  registerForReexecution(p2pClient: P2P): BlockProposalHandler {
+    const handler = async (proposal: BlockProposal, proposalSender: PeerId) => {
+      try {
+        const result = await this.handleBlockProposal(proposal, proposalSender, true);
+        if (result.isValid) {
+          this.log.info(`Non-validator reexecution completed for slot ${proposal.slotNumber}`, {
+            blockNumber: result.blockNumber,
+            reexecutionTimeMs: result.reexecutionResult?.reexecutionTimeMs,
+            totalManaUsed: result.reexecutionResult?.totalManaUsed,
+            numTxs: result.reexecutionResult?.block?.body?.txEffects?.length ?? 0,
+          });
+        } else {
+          this.log.warn(`Non-validator reexecution failed for slot ${proposal.slotNumber}`, {
+            blockNumber: result.blockNumber,
+            reason: result.reason,
+          });
+        }
+      } catch (error) {
+        this.log.error('Error processing block proposal in non-validator handler', error);
+      }
+      return undefined; // Non-validator nodes don't return attestations
+    };
+
+    p2pClient.registerBlockProposalHandler(handler);
+    return this;
+  }
+
+  async handleBlockProposal(
+    proposal: BlockProposal,
+    proposalSender: PeerId,
+    shouldReexecute: boolean,
+  ): Promise<BlockProposalValidationResult> {
+    const slotNumber = proposal.slotNumber;
+    const proposer = proposal.getSender();
+    const config = this.blockBuilder.getConfig();
+
+    // Reject proposals with invalid signatures
+    if (!proposer) {
+      this.log.warn(`Received proposal with invalid signature for slot ${slotNumber}`);
+      return { isValid: false, reason: 'invalid_proposal' };
+    }
+
+    const proposalInfo = { ...proposal.toBlockInfo(), proposer: proposer.toString() };
+    this.log.info(`Processing proposal for slot ${slotNumber}`, {
+      ...proposalInfo,
+      txHashes: proposal.txHashes.map(t => t.toString()),
+    });
+
+    // Check that the proposal is from the current proposer, or the next proposer
+    // This should have been handled by the p2p layer, but we double check here out of caution
+    const invalidProposal = await this.blockProposalValidator.validate(proposal);
+    if (invalidProposal) {
+      this.log.warn(`Proposal is not valid, skipping processing`, proposalInfo);
+      return { isValid: false, reason: 'invalid_proposal' };
+    }
+
+    // Check that the parent proposal is a block we know, otherwise reexecution would fail
+    const parentBlockHeader = await this.getParentBlock(proposal);
+    if (parentBlockHeader === undefined) {
+      this.log.warn(`Parent block for proposal not found, skipping processing`, proposalInfo);
+      return { isValid: false, reason: 'parent_block_not_found' };
+    }
+
+    // Check that the parent block's slot is less than the proposal's slot (should not happen, but we check anyway)
+    if (parentBlockHeader !== 'genesis' && parentBlockHeader.getSlot() >= slotNumber) {
+      this.log.warn(`Parent block slot is greater than or equal to proposal slot, skipping processing`, {
+        parentBlockSlot: parentBlockHeader.getSlot().toString(),
+        proposalSlot: slotNumber.toString(),
+        ...proposalInfo,
+      });
+      return { isValid: false, reason: 'parent_block_wrong_slot' };
+    }
+
+    // Compute the block number based on the parent block
+    const blockNumber =
+      parentBlockHeader === 'genesis'
+        ? BlockNumber(INITIAL_L2_BLOCK_NUM)
+        : BlockNumber(parentBlockHeader.getBlockNumber() + 1);
+
+    // Check that this block number does not exist already
+    const existingBlock = await this.blockSource.getBlockHeader(blockNumber);
+    if (existingBlock) {
+      this.log.warn(`Block number ${blockNumber} already exists, skipping processing`, proposalInfo);
+      return { isValid: false, blockNumber, reason: 'block_number_already_exists' };
+    }
+
+    // Collect txs from the proposal. We start doing this as early as possible,
+    // and we do it even if we don't plan to re-execute the txs, so that we have them if another node needs them.
+    const { txs, missingTxs } = await this.txProvider.getTxsForBlockProposal(proposal, blockNumber, {
+      pinnedPeer: proposalSender,
+      deadline: this.getReexecutionDeadline(slotNumber, config),
+    });
+
+    // Check that I have the same set of l1ToL2Messages as the proposal
+    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(
+      CheckpointNumber.fromBlockNumber(blockNumber),
+    );
+    const computedInHash = computeInHashFromL1ToL2Messages(l1ToL2Messages);
+    const proposalInHash = proposal.payload.header.contentCommitment.inHash;
+    if (!computedInHash.equals(proposalInHash)) {
+      this.log.warn(`L1 to L2 messages in hash mismatch, skipping processing`, {
+        proposalInHash: proposalInHash.toString(),
+        computedInHash: computedInHash.toString(),
+        ...proposalInfo,
+      });
+      return { isValid: false, blockNumber, reason: 'in_hash_mismatch' };
+    }
+
+    // Check that all of the transactions in the proposal are available
+    if (missingTxs.length > 0) {
+      this.log.warn(`Missing ${missingTxs.length} txs to process proposal`, { ...proposalInfo, missingTxs });
+      return { isValid: false, blockNumber, reason: 'txs_not_available' };
+    }
+
+    // Try re-executing the transactions in the proposal if needed
+    let reexecutionResult;
+    if (shouldReexecute) {
+      try {
+        this.log.verbose(`Re-executing transactions in the proposal`, proposalInfo);
+        reexecutionResult = await this.reexecuteTransactions(proposal, blockNumber, txs, l1ToL2Messages);
+      } catch (error) {
+        this.log.error(`Error reexecuting txs while processing block proposal`, error, proposalInfo);
+        const reason = this.getReexecuteFailureReason(error);
+        return { isValid: false, blockNumber, reason, reexecutionResult };
+      }
+    }
+
+    this.log.info(`Successfully processed proposal for slot ${slotNumber}`, proposalInfo);
+    return { isValid: true, blockNumber, reexecutionResult };
+  }
+
+  private async getParentBlock(proposal: BlockProposal): Promise<'genesis' | BlockHeader | undefined> {
+    const parentArchive = proposal.payload.header.lastArchiveRoot;
+    const slot = proposal.slotNumber;
+    const config = this.blockBuilder.getConfig();
+    const { genesisArchiveRoot } = await this.blockSource.getGenesisValues();
+
+    if (parentArchive.equals(genesisArchiveRoot)) {
+      return 'genesis';
+    }
+
+    const deadline = this.getReexecutionDeadline(slot, config);
+    const currentTime = this.dateProvider.now();
+    const timeoutDurationMs = deadline.getTime() - currentTime;
+
+    try {
+      return (
+        (await this.blockSource.getBlockHeaderByArchive(parentArchive)) ??
+        (timeoutDurationMs <= 0
+          ? undefined
+          : await retryUntil(
+              () =>
+                this.blockSource.syncImmediate().then(() => this.blockSource.getBlockHeaderByArchive(parentArchive)),
+              'force archiver sync',
+              timeoutDurationMs / 1000,
+              0.5,
+            ))
+      );
+    } catch (err) {
+      if (err instanceof TimeoutError) {
+        this.log.debug(`Timed out getting parent block by archive root`, { parentArchive });
+      } else {
+        this.log.error('Error getting parent block by archive root', err, { parentArchive });
+      }
+      return undefined;
+    }
+  }
+
+  private getReexecutionDeadline(slot: SlotNumber, config: { l1GenesisTime: bigint; slotDuration: number }): Date {
+    const nextSlotTimestampSeconds = Number(getTimestampForSlot(SlotNumber(slot + 1), config));
+    const msNeededForPropagationAndPublishing = this.config.validatorReexecuteDeadlineMs;
+    return new Date(nextSlotTimestampSeconds * 1000 - msNeededForPropagationAndPublishing);
+  }
+
+  private getReexecuteFailureReason(err: any) {
+    if (err instanceof ReExStateMismatchError) {
+      return 'state_mismatch';
+    } else if (err instanceof ReExFailedTxsError) {
+      return 'failed_txs';
+    } else if (err instanceof ReExTimeoutError) {
+      return 'timeout';
+    } else {
+      return 'unknown_error';
+    }
+  }
+
+  async reexecuteTransactions(
+    proposal: BlockProposal,
+    blockNumber: BlockNumber,
+    txs: Tx[],
+    l1ToL2Messages: Fr[],
+  ): Promise<ReexecuteTransactionsResult> {
+    const { header } = proposal.payload;
+    const { txHashes } = proposal;
+
+    // If we do not have all of the transactions, then we should fail
+    if (txs.length !== txHashes.length) {
+      const foundTxHashes = txs.map(tx => tx.getTxHash());
+      const missingTxHashes = txHashes.filter(txHash => !foundTxHashes.includes(txHash));
+      throw new TransactionsNotAvailableError(missingTxHashes);
+    }
+
+    // Use the sequencer's block building logic to re-execute the transactions
+    const timer = new Timer();
+    const config = this.blockBuilder.getConfig();
+
+    // We source most global variables from the proposal
+    const globalVariables = GlobalVariables.from({
+      slotNumber: proposal.payload.header.slotNumber, // checked in the block proposal validator
+      coinbase: proposal.payload.header.coinbase, // set arbitrarily by the proposer
+      feeRecipient: proposal.payload.header.feeRecipient, // set arbitrarily by the proposer
+      gasFees: proposal.payload.header.gasFees, // validated by the rollup contract
+      blockNumber, // computed from the parent block and checked it does not exist in archiver
+      timestamp: header.timestamp, // checked in the rollup contract against the slot number
+      chainId: new Fr(config.l1ChainId),
+      version: new Fr(config.rollupVersion),
+    });
+
+    const { block, failedTxs } = await this.blockBuilder.buildBlock(txs, l1ToL2Messages, globalVariables, {
+      deadline: this.getReexecutionDeadline(proposal.payload.header.slotNumber, config),
+    });
+
+    const numFailedTxs = failedTxs.length;
+    const slot = proposal.slotNumber;
+    this.log.verbose(`Transaction re-execution complete for slot ${slot}`, {
+      numFailedTxs,
+      numProposalTxs: txHashes.length,
+      numProcessedTxs: block.body.txEffects.length,
+      slot,
+    });
+
+    if (numFailedTxs > 0) {
+      this.metrics?.recordFailedReexecution(proposal);
+      throw new ReExFailedTxsError(numFailedTxs);
+    }
+
+    if (block.body.txEffects.length !== txHashes.length) {
+      this.metrics?.recordFailedReexecution(proposal);
+      throw new ReExTimeoutError();
+    }
+
+    // Throw a ReExStateMismatchError error if state updates do not match
+    const blockPayload = ConsensusPayload.fromBlock(block);
+    if (!blockPayload.equals(proposal.payload)) {
+      this.log.warn(`Re-execution state mismatch for slot ${slot}`, {
+        expected: blockPayload.toInspect(),
+        actual: proposal.payload.toInspect(),
+      });
+      this.metrics?.recordFailedReexecution(proposal);
+      throw new ReExStateMismatchError(proposal.archive, block.archive.root);
+    }
+
+    const reexecutionTimeMs = timer.ms();
+    const totalManaUsed = block.header.totalManaUsed.toNumber() / 1e6;
+
+    this.metrics?.recordReex(reexecutionTimeMs, txs.length, totalManaUsed);
+
+    return {
+      block,
+      failedTxs,
+      reexecutionTimeMs,
+      totalManaUsed,
+    };
+  }
+}

package/src/config.ts

@@ -58,6 +58,18 @@ export const validatorClientConfigMappings: ConfigMappingsType<ValidatorClientCo
     description: 'Will re-execute until this many milliseconds are left in the slot',
     ...numberConfigHelper(6000),
   },
+  alwaysReexecuteBlockProposals: {
+    env: 'ALWAYS_REEXECUTE_BLOCK_PROPOSALS',
+    description:
+      'Whether to always reexecute block proposals, even for non-validator nodes (useful for monitoring network status).',
+    ...booleanConfigHelper(false),
+  },
+  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),
+  },
 };
 
 /**

package/src/duties/validation_service.ts

@@ -1,8 +1,10 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { keccak256 } from '@aztec/foundation/crypto';
+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 type { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import type { CommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
 import {
   BlockAttestation,
   BlockProposal,
@@ -10,28 +12,30 @@ import {
   ConsensusPayload,
   SignatureDomainSeparator,
 } from '@aztec/stdlib/p2p';
-import type { ProposedBlockHeader, StateReference, Tx } from '@aztec/stdlib/tx';
+import type { CheckpointHeader } from '@aztec/stdlib/rollup';
+import type { Tx } from '@aztec/stdlib/tx';
 
 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 blockNumber - The block number this proposal is for
    * @param header - The block header
    * @param archive - The archive of the current block
    * @param txs - TxHash[] ordered list of transactions
+   * @param options - Block proposal options (including broadcastInvalidBlockProposal for testing)
    *
    * @returns A block proposal signing the above information (not the current implementation!!!)
    */
   async createBlockProposal(
-    blockNumber: number,
-    header: ProposedBlockHeader,
+    header: CheckpointHeader,
     archive: Fr,
-    stateReference: StateReference,
     txs: Tx[],
     proposerAttesterAddress: EthAddress | undefined,
     options: BlockProposalOptions,
@@ -47,9 +51,14 @@ export class ValidationService {
     // TODO: check if this is calculated earlier / can not be recomputed
     const txHashes = await Promise.all(txs.map(tx => tx.getTxHash()));
 
+    // 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 ${header.slotNumber}`);
+    }
+
     return BlockProposal.createProposalFromSigner(
-      blockNumber,
-      new ConsensusPayload(header, archive, stateReference),
+      new ConsensusPayload(header, archive),
       txHashes,
       options.publishFullTxs ? txs : undefined,
       payloadSigner,
@@ -73,7 +82,16 @@ export class ValidationService {
     const signatures = await Promise.all(
       attestors.map(attestor => this.keyStore.signMessageWithAddress(attestor, buf)),
     );
-    //await this.keyStore.signMessage(buf);
-    return signatures.map(sig => new BlockAttestation(proposal.blockNumber, proposal.payload, sig));
+    return signatures.map(sig => new BlockAttestation(proposal.payload, sig, proposal.signature));
+  }
+
+  async signAttestationsAndSigners(
+    attestationsAndSigners: CommitteeAttestationsAndSigners,
+    proposer: EthAddress,
+  ): Promise<Signature> {
+    const buf = Buffer32.fromBuffer(
+      keccak256(attestationsAndSigners.getPayloadToSign(SignatureDomainSeparator.attestationsAndSigners)),
+    );
+    return await this.keyStore.signMessageWithAddress(proposer, buf);
   }
 }

package/src/factory.ts

@@ -1,17 +1,48 @@
+import type { BlobClientInterface } from '@aztec/blob-client/client';
 import type { EpochCache } from '@aztec/epoch-cache';
 import type { DateProvider } from '@aztec/foundation/timer';
 import type { KeystoreManager } from '@aztec/node-keystore';
-import type { P2PClient } from '@aztec/p2p';
+import { BlockProposalValidator, type P2PClient } from '@aztec/p2p';
 import type { L2BlockSource } from '@aztec/stdlib/block';
-import type { IFullNodeBlockBuilder, SlasherConfig } from '@aztec/stdlib/interfaces/server';
+import type { IFullNodeBlockBuilder, ValidatorClientFullConfig } from '@aztec/stdlib/interfaces/server';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 import type { TelemetryClient } from '@aztec/telemetry-client';
 
-import type { ValidatorClientConfig } from './config.js';
+import { BlockProposalHandler } from './block_proposal_handler.js';
+import { ValidatorMetrics } from './metrics.js';
 import { ValidatorClient } from './validator.js';
 
+export function createBlockProposalHandler(
+  config: ValidatorClientFullConfig,
+  deps: {
+    blockBuilder: IFullNodeBlockBuilder;
+    blockSource: L2BlockSource;
+    l1ToL2MessageSource: L1ToL2MessageSource;
+    p2pClient: P2PClient;
+    epochCache: EpochCache;
+    dateProvider: DateProvider;
+    telemetry: TelemetryClient;
+  },
+) {
+  const metrics = new ValidatorMetrics(deps.telemetry);
+  const blockProposalValidator = new BlockProposalValidator(deps.epochCache, {
+    txsPermitted: !config.disableTransactions,
+  });
+  return new BlockProposalHandler(
+    deps.blockBuilder,
+    deps.blockSource,
+    deps.l1ToL2MessageSource,
+    deps.p2pClient.getTxProvider(),
+    blockProposalValidator,
+    config,
+    metrics,
+    deps.dateProvider,
+    deps.telemetry,
+  );
+}
+
 export function createValidatorClient(
-  config: ValidatorClientConfig & Pick<SlasherConfig, 'slashBroadcastedInvalidBlockPenalty'>,
+  config: ValidatorClientFullConfig,
   deps: {
     blockBuilder: IFullNodeBlockBuilder;
     p2pClient: P2PClient;
@@ -21,6 +52,7 @@ export function createValidatorClient(
     dateProvider: DateProvider;
     epochCache: EpochCache;
     keyStoreManager: KeystoreManager | undefined;
+    blobClient: BlobClientInterface;
   },
 ) {
   if (config.disableValidator || !deps.keyStoreManager) {
@@ -37,6 +69,7 @@ export function createValidatorClient(
     deps.l1ToL2MessageSource,
     txProvider,
     deps.keyStoreManager,
+    deps.blobClient,
     deps.dateProvider,
     deps.telemetry,
   );

package/src/index.ts

@@ -1,3 +1,4 @@
+export * from './block_proposal_handler.js';
 export * from './config.js';
 export * from './factory.js';
 export * from './validator.js';

package/src/key_store/local_key_store.ts

@@ -1,5 +1,5 @@
 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';
 

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';
@@ -324,7 +324,7 @@ export class NodeKeystoreAdapter implements ExtendedValidatorKeyStore {
    */
   getCoinbaseAddress(attesterAddress: EthAddress): EthAddress {
     const validatorIndex = this.findValidatorIndexForAttester(attesterAddress);
-    return this.keystoreManager.getCoinbaseAddress(validatorIndex);
+    return this.keystoreManager.getCoinbaseAddress(validatorIndex, attesterAddress);
   }
 
   /**
@@ -358,8 +358,7 @@ export class NodeKeystoreAdapter implements ExtendedValidatorKeyStore {
    */
   getFeeRecipient(attesterAddress: EthAddress): AztecAddress {
     const validatorIndex = this.findValidatorIndexForAttester(attesterAddress);
-    const feeRecipientHex = this.keystoreManager.getFeeRecipient(validatorIndex);
-    return AztecAddress.fromString(feeRecipientHex);
+    return this.keystoreManager.getFeeRecipient(validatorIndex);
   }
 
   /**

package/src/key_store/web3signer_key_store.ts

@@ -1,4 +1,5 @@
 import type { Buffer32 } from '@aztec/foundation/buffer';
+import { normalizeSignature } from '@aztec/foundation/crypto/secp256k1-signer';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 
@@ -45,11 +46,8 @@ export class Web3SignerKeyStore implements ValidatorKeyStore {
    * @param typedData - The complete EIP-712 typed data structure (domain, types, primaryType, message)
    * @return signatures
    */
-  public async signTypedData(typedData: TypedDataDefinition): Promise<Signature[]> {
-    const signatures = await Promise.all(
-      this.addresses.map(address => this.makeJsonRpcSignTypedDataRequest(address, typedData)),
-    );
-    return signatures;
+  public signTypedData(typedData: TypedDataDefinition): Promise<Signature[]> {
+    return Promise.all(this.addresses.map(address => this.makeJsonRpcSignTypedDataRequest(address, typedData)));
   }
 
   /**
@@ -73,9 +71,8 @@ export class Web3SignerKeyStore implements ValidatorKeyStore {
    * @param message - The message to sign
    * @return signatures
    */
-  public async signMessage(message: Buffer32): Promise<Signature[]> {
-    const signatures = await Promise.all(this.addresses.map(address => this.makeJsonRpcSignRequest(address, message)));
-    return signatures;
+  public signMessage(message: Buffer32): Promise<Signature[]> {
+    return Promise.all(this.addresses.map(address => this.makeJsonRpcSignRequest(address, message)));
   }
 
   /**
@@ -144,7 +141,7 @@ export class Web3SignerKeyStore implements ValidatorKeyStore {
     }
 
     // Parse the signature from the hex string
-    return Signature.fromString(signatureHex as `0x${string}`);
+    return normalizeSignature(Signature.fromString(signatureHex as `0x${string}`));
   }
 
   private async makeJsonRpcSignTypedDataRequest(
@@ -190,6 +187,6 @@ export class Web3SignerKeyStore implements ValidatorKeyStore {
       signatureHex = '0x' + signatureHex;
     }
 
-    return Signature.fromString(signatureHex as `0x${string}`);
+    return normalizeSignature(Signature.fromString(signatureHex as `0x${string}`));
   }
 }