@aztec/validator-client 2.1.0-rc.3 → 2.1.0-rc.31

package/dest/validator.js

@@ -91,7 +91,9 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
     }
     static new(config, blockBuilder, epochCache, p2pClient, blockSource, l1ToL2MessageSource, txProvider, keyStoreManager, dateProvider = new DateProvider(), telemetry = getTelemetryClient()) {
         const metrics = new ValidatorMetrics(telemetry);
-        const blockProposalValidator = new BlockProposalValidator(epochCache);
+        const blockProposalValidator = new BlockProposalValidator(epochCache, {
+            txsPermitted: !config.disableTransactions
+        });
         const blockProposalHandler = new BlockProposalHandler(blockBuilder, blockSource, l1ToL2MessageSource, txProvider, blockProposalValidator, config, metrics, dateProvider, telemetry);
         const validator = new ValidatorClient(NodeKeystoreAdapter.fromKeyStoreManager(keyStoreManager), epochCache, p2pClient, blockProposalHandler, config, dateProvider, telemetry);
         return validator;
@@ -103,8 +105,8 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
         return this.blockProposalHandler;
     }
     // Proxy method for backwards compatibility with tests
-    reExecuteTransactions(proposal, txs, l1ToL2Messages) {
-        return this.blockProposalHandler.reexecuteTransactions(proposal, txs, l1ToL2Messages);
+    reExecuteTransactions(proposal, blockNumber, txs, l1ToL2Messages) {
+        return this.blockProposalHandler.reexecuteTransactions(proposal, blockNumber, txs, l1ToL2Messages);
     }
     signWithAddress(addr, msg) {
         return this.keyStore.signTypedDataWithAddress(addr, msg);
@@ -157,15 +159,19 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
     async attestToProposal(proposal, proposalSender) {
         const slotNumber = proposal.slotNumber.toBigInt();
         const proposer = proposal.getSender();
+        // Reject proposals with invalid signatures
+        if (!proposer) {
+            this.log.warn(`Received proposal with invalid signature for slot ${slotNumber}`);
+            return undefined;
+        }
         // Check that I have any address in current committee before attesting
         const inCommittee = await this.epochCache.filterInCommittee(slotNumber, this.getValidatorAddresses());
         const partOfCommittee = inCommittee.length > 0;
-        const incFailedAttestation = (reason)=>this.metrics.incFailedAttestations(1, reason, partOfCommittee);
         const proposalInfo = {
             ...proposal.toBlockInfo(),
             proposer: proposer.toString()
         };
-        this.log.info(`Received proposal for block ${proposal.blockNumber} at slot ${slotNumber}`, {
+        this.log.info(`Received proposal for slot ${slotNumber}`, {
             ...proposalInfo,
             txHashes: proposal.txHashes.map((t)=>t.toString())
         });
@@ -176,8 +182,22 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
         const validationResult = await this.blockProposalHandler.handleBlockProposal(proposal, proposalSender, !!shouldReexecute);
         if (!validationResult.isValid) {
             this.log.warn(`Proposal validation failed: ${validationResult.reason}`, proposalInfo);
-            incFailedAttestation(validationResult.reason || 'unknown');
-            // Slash invalid block proposals
+            const reason = validationResult.reason || 'unknown';
+            // Classify failure reason: bad proposal vs node issue
+            const badProposalReasons = [
+                'invalid_proposal',
+                'state_mismatch',
+                'failed_txs',
+                'in_hash_mismatch',
+                'parent_block_wrong_slot'
+            ];
+            if (badProposalReasons.includes(reason)) {
+                this.metrics.incFailedAttestationsBadProposal(1, reason, partOfCommittee);
+            } else {
+                // Node issues so we can't attest
+                this.metrics.incFailedAttestationsNodeIssue(1, reason, partOfCommittee);
+            }
+            // Slash invalid block proposals (can happen even when not in committee)
             if (validationResult.reason && SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT.includes(validationResult.reason) && slashBroadcastedInvalidBlockPenalty > 0n) {
                 this.log.warn(`Slashing proposer for invalid block proposal`, proposalInfo);
                 this.slashInvalidBlock(proposal);
@@ -190,13 +210,18 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             return undefined;
         }
         // Provided all of the above checks pass, we can attest to the proposal
-        this.log.info(`Attesting to proposal for block ${proposal.blockNumber} at slot ${slotNumber}`, proposalInfo);
-        this.metrics.incAttestations(inCommittee.length);
+        this.log.info(`Attesting to proposal for block at slot ${slotNumber}`, proposalInfo);
+        this.metrics.incSuccessfulAttestations(inCommittee.length);
         // If the above function does not throw an error, then we can attest to the proposal
         return this.createBlockAttestationsFromProposal(proposal, inCommittee);
     }
     slashInvalidBlock(proposal) {
         const proposer = proposal.getSender();
+        // Skip if signature is invalid (shouldn't happen since we validate earlier)
+        if (!proposer) {
+            this.log.warn(`Cannot slash proposal with invalid signature`);
+            return;
+        }
         // Trim the set if it's too big.
         if (this.proposersOfInvalidBlocks.size > MAX_PROPOSERS_OF_INVALID_BLOCKS) {
             // remove oldest proposer. `values` is guaranteed to be in insertion order.
@@ -217,7 +242,7 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             this.log.verbose(`Already made a proposal for the same slot, skipping proposal`);
             return Promise.resolve(undefined);
         }
-        const newProposal = await this.validationService.createBlockProposal(blockNumber, header, archive, stateReference, txs, proposerAddress, options);
+        const newProposal = await this.validationService.createBlockProposal(header, archive, stateReference, txs, proposerAddress, options);
         this.previousProposal = newProposal;
         return newProposal;
     }
@@ -248,11 +273,28 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
         const myAddresses = this.getValidatorAddresses();
         let attestations = [];
         while(true){
-            const collectedAttestations = await this.p2pClient.getAttestationsForSlot(slot, proposalId);
+            // Filter out attestations with a mismatching payload. This should NOT happen since we have verified
+            // the proposer signature (ie our own) before accepting the attestation into the pool via the p2p client.
+            const collectedAttestations = (await this.p2pClient.getAttestationsForSlot(slot, proposalId)).filter((attestation)=>{
+                if (!attestation.payload.equals(proposal.payload)) {
+                    this.log.warn(`Received attestation for slot ${slot} with mismatched payload from ${attestation.getSender()?.toString()}`, {
+                        attestationPayload: attestation.payload,
+                        proposalPayload: proposal.payload
+                    });
+                    return false;
+                }
+                return true;
+            });
+            // Log new attestations we collected
             const oldSenders = attestations.map((attestation)=>attestation.getSender());
             for (const collected of collectedAttestations){
                 const collectedSender = collected.getSender();
-                if (!myAddresses.some((address)=>address.equals(collectedSender)) && !oldSenders.some((sender)=>sender.equals(collectedSender))) {
+                // Skip attestations with invalid signatures
+                if (!collectedSender) {
+                    this.log.warn(`Skipping attestation with invalid signature for slot ${slot}`);
+                    continue;
+                }
+                if (!myAddresses.some((address)=>address.equals(collectedSender)) && !oldSenders.some((sender)=>sender?.equals(collectedSender))) {
                     this.log.debug(`Received attestation for slot ${slot} from ${collectedSender.toString()}`);
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/validator-client",
-  "version": "2.1.0-rc.3",
+  "version": "2.1.0-rc.31",
   "main": "dest/index.js",
   "type": "module",
   "exports": {
@@ -64,20 +64,20 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "2.1.0-rc.3",
-    "@aztec/epoch-cache": "2.1.0-rc.3",
-    "@aztec/ethereum": "2.1.0-rc.3",
-    "@aztec/foundation": "2.1.0-rc.3",
-    "@aztec/node-keystore": "2.1.0-rc.3",
-    "@aztec/p2p": "2.1.0-rc.3",
-    "@aztec/prover-client": "2.1.0-rc.3",
-    "@aztec/slasher": "2.1.0-rc.3",
-    "@aztec/stdlib": "2.1.0-rc.3",
-    "@aztec/telemetry-client": "2.1.0-rc.3",
+    "@aztec/constants": "2.1.0-rc.31",
+    "@aztec/epoch-cache": "2.1.0-rc.31",
+    "@aztec/ethereum": "2.1.0-rc.31",
+    "@aztec/foundation": "2.1.0-rc.31",
+    "@aztec/node-keystore": "2.1.0-rc.31",
+    "@aztec/p2p": "2.1.0-rc.31",
+    "@aztec/prover-client": "2.1.0-rc.31",
+    "@aztec/slasher": "2.1.0-rc.31",
+    "@aztec/stdlib": "2.1.0-rc.31",
+    "@aztec/telemetry-client": "2.1.0-rc.31",
     "koa": "^2.16.1",
     "koa-router": "^13.1.1",
     "tslib": "^2.4.0",
-    "viem": "2.23.7"
+    "viem": "npm:@spalladino/viem@2.38.2-eip7594.0"
   },
   "devDependencies": {
     "@jest/globals": "^30.0.0",

package/src/block_proposal_handler.ts

@@ -1,4 +1,5 @@
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { TimeoutError } from '@aztec/foundation/error';
 import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
@@ -7,12 +8,12 @@ import type { P2P, PeerId } from '@aztec/p2p';
 import { TxProvider } from '@aztec/p2p';
 import { BlockProposalValidator } from '@aztec/p2p/msg_validators';
 import { computeInHashFromL1ToL2Messages } from '@aztec/prover-client/helpers';
-import type { L2BlockSource } from '@aztec/stdlib/block';
+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 } from '@aztec/stdlib/messaging';
 import { type BlockProposal, ConsensusPayload } from '@aztec/stdlib/p2p';
-import { type FailedTx, GlobalVariables, type Tx } from '@aztec/stdlib/tx';
+import { BlockHeader, type FailedTx, GlobalVariables, type Tx } from '@aztec/stdlib/tx';
 import {
   ReExFailedTxsError,
   ReExStateMismatchError,
@@ -26,7 +27,7 @@ import type { ValidatorMetrics } from './metrics.js';
 export type BlockProposalValidationFailureReason =
   | 'invalid_proposal'
   | 'parent_block_not_found'
-  | 'parent_block_does_not_match'
+  | 'parent_block_wrong_slot'
   | 'in_hash_mismatch'
   | 'block_number_already_exists'
   | 'txs_not_available'
@@ -35,16 +36,27 @@ export type BlockProposalValidationFailureReason =
   | 'timeout'
   | 'unknown_error';
 
-export interface BlockProposalValidationResult {
-  isValid: boolean;
-  reason?: BlockProposalValidationFailureReason;
-  reexecutionResult?: {
-    block: any;
-    failedTxs: FailedTx[];
-    reexecutionTimeMs: number;
-    totalManaUsed: number;
-  };
-}
+type ReexecuteTransactionsResult = {
+  block: L2Block;
+  failedTxs: FailedTx[];
+  reexecutionTimeMs: number;
+  totalManaUsed: number;
+};
+
+export type BlockProposalValidationSuccessResult = {
+  isValid: true;
+  blockNumber: number;
+  reexecutionResult?: ReexecuteTransactionsResult;
+};
+
+export type BlockProposalValidationFailureResult = {
+  isValid: false;
+  reason: BlockProposalValidationFailureReason;
+  blockNumber?: number;
+  reexecutionResult?: ReexecuteTransactionsResult;
+};
+
+export type BlockProposalValidationResult = BlockProposalValidationSuccessResult | BlockProposalValidationFailureResult;
 
 export class BlockProposalHandler {
   public readonly tracer: Tracer;
@@ -68,16 +80,16 @@ export class BlockProposalHandler {
     const handler = async (proposal: BlockProposal, proposalSender: PeerId) => {
       try {
         const result = await this.handleBlockProposal(proposal, proposalSender, true);
-        if (result.isValid && result.reexecutionResult) {
+        if (result.isValid) {
           this.log.info(`Non-validator reexecution completed for slot ${proposal.slotNumber.toBigInt()}`, {
-            blockNumber: proposal.blockNumber,
-            reexecutionTimeMs: result.reexecutionResult.reexecutionTimeMs,
-            totalManaUsed: result.reexecutionResult.totalManaUsed,
-            numTxs: result.reexecutionResult.block?.body?.txEffects?.length ?? 0,
+            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.toBigInt()}`, {
-            blockNumber: proposal.blockNumber,
+            blockNumber: result.blockNumber,
             reason: result.reason,
           });
         }
@@ -97,8 +109,14 @@ export class BlockProposalHandler {
     shouldReexecute: boolean,
   ): Promise<BlockProposalValidationResult> {
     const slotNumber = proposal.slotNumber.toBigInt();
-    const blockNumber = proposal.blockNumber;
     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}`, {
@@ -114,52 +132,40 @@ export class BlockProposalHandler {
       return { isValid: false, reason: 'invalid_proposal' };
     }
 
-    // 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 config = this.blockBuilder.getConfig();
-    const { txs, missingTxs } = await this.txProvider.getTxsForBlockProposal(proposal, {
-      pinnedPeer: proposalSender,
-      deadline: this.getReexecutionDeadline(proposal, config),
-    });
-
     // Check that the parent proposal is a block we know, otherwise reexecution would fail
-    if (blockNumber > INITIAL_L2_BLOCK_NUM) {
-      const deadline = this.getReexecutionDeadline(proposal, config);
-      const currentTime = this.dateProvider.now();
-      const timeoutDurationMs = deadline.getTime() - currentTime;
-      const parentBlock =
-        timeoutDurationMs <= 0
-          ? undefined
-          : await retryUntil(
-              async () => {
-                const block = await this.blockSource.getBlock(blockNumber - 1);
-                if (block) {
-                  return block;
-                }
-                await this.blockSource.syncImmediate();
-                return await this.blockSource.getBlock(blockNumber - 1);
-              },
-              'Force Archiver Sync',
-              timeoutDurationMs / 1000,
-              0.5,
-            );
+    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' };
+    }
 
-      if (parentBlock === undefined) {
-        this.log.warn(`Parent block for ${blockNumber} 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' };
+    }
 
-      if (!proposal.payload.header.lastArchiveRoot.equals(parentBlock.archive.root)) {
-        this.log.warn(`Parent block archive root for proposal does not match, skipping processing`, {
-          proposalLastArchiveRoot: proposal.payload.header.lastArchiveRoot.toString(),
-          parentBlockArchiveRoot: parentBlock.archive.root.toString(),
-          ...proposalInfo,
-        });
-        return { isValid: false, reason: 'parent_block_does_not_match' };
-      }
+    // Compute the block number based on the parent block
+    const blockNumber = parentBlockHeader === 'genesis' ? INITIAL_L2_BLOCK_NUM : 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(blockNumber);
     const computedInHash = await computeInHashFromL1ToL2Messages(l1ToL2Messages);
@@ -170,20 +176,13 @@ export class BlockProposalHandler {
         computedInHash: computedInHash.toString(),
         ...proposalInfo,
       });
-      return { isValid: false, reason: 'in_hash_mismatch' };
-    }
-
-    // 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, reason: 'block_number_already_exists' };
+      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, reason: 'txs_not_available' };
+      return { isValid: false, blockNumber, reason: 'txs_not_available' };
     }
 
     // Try re-executing the transactions in the proposal if needed
@@ -191,23 +190,57 @@ export class BlockProposalHandler {
     if (shouldReexecute) {
       try {
         this.log.verbose(`Re-executing transactions in the proposal`, proposalInfo);
-        reexecutionResult = await this.reexecuteTransactions(proposal, txs, l1ToL2Messages);
+        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, reason, reexecutionResult };
+        return { isValid: false, blockNumber, reason, reexecutionResult };
       }
     }
 
     this.log.info(`Successfully processed proposal for slot ${slotNumber}`, proposalInfo);
-    return { isValid: true, reexecutionResult };
+    return { isValid: true, blockNumber, reexecutionResult };
   }
 
-  private getReexecutionDeadline(
-    proposal: BlockProposal,
-    config: { l1GenesisTime: bigint; slotDuration: number },
-  ): Date {
-    const nextSlotTimestampSeconds = Number(getTimestampForSlot(proposal.slotNumber.toBigInt() + 1n, config));
+  private async getParentBlock(proposal: BlockProposal): Promise<'genesis' | BlockHeader | undefined> {
+    const parentArchive = proposal.payload.header.lastArchiveRoot;
+    const slot = proposal.slotNumber.toBigInt();
+    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: bigint, config: { l1GenesisTime: bigint; slotDuration: number }): Date {
+    const nextSlotTimestampSeconds = Number(getTimestampForSlot(slot + 1n, config));
     const msNeededForPropagationAndPublishing = this.config.validatorReexecuteDeadlineMs;
     return new Date(nextSlotTimestampSeconds * 1000 - msNeededForPropagationAndPublishing);
   }
@@ -219,21 +252,17 @@ export class BlockProposalHandler {
       return 'failed_txs';
     } else if (err instanceof ReExTimeoutError) {
       return 'timeout';
-    } else if (err instanceof Error) {
+    } else {
       return 'unknown_error';
     }
   }
 
   async reexecuteTransactions(
     proposal: BlockProposal,
+    blockNumber: number,
     txs: Tx[],
     l1ToL2Messages: Fr[],
-  ): Promise<{
-    block: any;
-    failedTxs: FailedTx[];
-    reexecutionTimeMs: number;
-    totalManaUsed: number;
-  }> {
+  ): Promise<ReexecuteTransactionsResult> {
     const { header } = proposal.payload;
     const { txHashes } = proposal;
 
@@ -254,14 +283,14 @@ export class BlockProposalHandler {
       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: proposal.blockNumber, // checked blockNumber-1 exists in archiver but blockNumber doesnt
+      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, config),
+      deadline: this.getReexecutionDeadline(proposal.payload.header.slotNumber.toBigInt(), config),
     });
 
     const numFailedTxs = failedTxs.length;

package/src/duties/validation_service.ts

@@ -21,7 +21,6 @@ export class ValidationService {
   /**
    * 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
@@ -29,7 +28,6 @@ export class ValidationService {
    * @returns A block proposal signing the above information (not the current implementation!!!)
    */
   async createBlockProposal(
-    blockNumber: number,
     header: ProposedBlockHeader,
     archive: Fr,
     stateReference: StateReference,
@@ -49,7 +47,6 @@ export class ValidationService {
     const txHashes = await Promise.all(txs.map(tx => tx.getTxHash()));
 
     return BlockProposal.createProposalFromSigner(
-      blockNumber,
       new ConsensusPayload(header, archive, stateReference),
       txHashes,
       options.publishFullTxs ? txs : undefined,
@@ -74,8 +71,7 @@ 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(

package/src/factory.ts

@@ -24,7 +24,9 @@ export function createBlockProposalHandler(
   },
 ) {
   const metrics = new ValidatorMetrics(deps.telemetry);
-  const blockProposalValidator = new BlockProposalValidator(deps.epochCache);
+  const blockProposalValidator = new BlockProposalValidator(deps.epochCache, {
+    txsPermitted: !config.disableTransactions,
+  });
   return new BlockProposalHandler(
     deps.blockBuilder,
     deps.blockSource,

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';
 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}`));
   }
 }

package/src/metrics.ts

@@ -10,8 +10,9 @@ import {
 
 export class ValidatorMetrics {
   private failedReexecutionCounter: UpDownCounter;
-  private attestationsCount: UpDownCounter;
-  private failedAttestationsCount: UpDownCounter;
+  private successfulAttestationsCount: UpDownCounter;
+  private failedAttestationsBadProposalCount: UpDownCounter;
+  private failedAttestationsNodeIssueCount: UpDownCounter;
 
   private reexMana: Histogram;
   private reexTx: Histogram;
@@ -26,15 +27,26 @@ export class ValidatorMetrics {
       valueType: ValueType.INT,
     });
 
-    this.attestationsCount = meter.createUpDownCounter(Metrics.VALIDATOR_ATTESTATION_COUNT, {
-      description: 'The number of attestations',
+    this.successfulAttestationsCount = meter.createUpDownCounter(Metrics.VALIDATOR_ATTESTATION_SUCCESS_COUNT, {
+      description: 'The number of successful attestations',
       valueType: ValueType.INT,
     });
 
-    this.failedAttestationsCount = meter.createUpDownCounter(Metrics.VALIDATOR_FAILED_ATTESTATION_COUNT, {
-      description: 'The number of failed attestations',
-      valueType: ValueType.INT,
-    });
+    this.failedAttestationsBadProposalCount = meter.createUpDownCounter(
+      Metrics.VALIDATOR_ATTESTATION_FAILED_BAD_PROPOSAL_COUNT,
+      {
+        description: 'The number of failed attestations due to invalid block proposals',
+        valueType: ValueType.INT,
+      },
+    );
+
+    this.failedAttestationsNodeIssueCount = meter.createUpDownCounter(
+      Metrics.VALIDATOR_ATTESTATION_FAILED_NODE_ISSUE_COUNT,
+      {
+        description: 'The number of failed attestations due to node issues (timeout, missing data, etc.)',
+        valueType: ValueType.INT,
+      },
+    );
 
     this.reexMana = meter.createHistogram(Metrics.VALIDATOR_RE_EXECUTION_MANA, {
       description: 'The mana consumed by blocks',
@@ -62,20 +74,28 @@ export class ValidatorMetrics {
   }
 
   public recordFailedReexecution(proposal: BlockProposal) {
+    const proposer = proposal.getSender();
     this.failedReexecutionCounter.add(1, {
       [Attributes.STATUS]: 'failed',
-      [Attributes.BLOCK_PROPOSER]: proposal.getSender().toString(),
+      [Attributes.BLOCK_PROPOSER]: proposer?.toString() ?? 'unknown',
     });
   }
 
-  public incAttestations(num: number) {
-    this.attestationsCount.add(num);
+  public incSuccessfulAttestations(num: number) {
+    this.successfulAttestationsCount.add(num);
+  }
+
+  public incFailedAttestationsBadProposal(num: number, reason: string, inCommittee: boolean) {
+    this.failedAttestationsBadProposalCount.add(num, {
+      [Attributes.ERROR_TYPE]: reason,
+      [Attributes.IS_COMMITTEE_MEMBER]: inCommittee,
+    });
   }
 
-  public incFailedAttestations(num: number, reason: string, inCommittee: boolean) {
-    this.failedAttestationsCount.add(num, {
+  public incFailedAttestationsNodeIssue(num: number, reason: string, inCommittee: boolean) {
+    this.failedAttestationsNodeIssueCount.add(num, {
       [Attributes.ERROR_TYPE]: reason,
-      [Attributes.VALIDATOR_STATUS]: inCommittee ? 'in-committee' : 'none',
+      [Attributes.IS_COMMITTEE_MEMBER]: inCommittee,
     });
   }
 }