@aztec/validator-client 3.0.0-devnet.2 → 3.0.0-devnet.2-patch.1

package/dest/validator.js

@@ -28,10 +28,10 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
     blockProposalHandler;
     config;
     dateProvider;
-    log;
     tracer;
     validationService;
     metrics;
+    log;
     // Whether it has already registered handlers on the p2p client
     hasRegisteredHandlers;
     // Used to check if we are sending the same proposal twice
@@ -40,12 +40,14 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
     epochCacheUpdateLoop;
     proposersOfInvalidBlocks;
     constructor(keyStore, epochCache, p2pClient, blockProposalHandler, config, dateProvider = new DateProvider(), telemetry = getTelemetryClient(), log = createLogger('validator')){
-        super(), this.keyStore = keyStore, this.epochCache = epochCache, this.p2pClient = p2pClient, this.blockProposalHandler = blockProposalHandler, this.config = config, this.dateProvider = dateProvider, this.log = log, this.hasRegisteredHandlers = false, this.proposersOfInvalidBlocks = new Set();
+        super(), this.keyStore = keyStore, this.epochCache = epochCache, this.p2pClient = p2pClient, this.blockProposalHandler = blockProposalHandler, this.config = config, this.dateProvider = dateProvider, this.hasRegisteredHandlers = false, this.proposersOfInvalidBlocks = new Set();
+        // Create child logger with fisherman prefix if in fisherman mode
+        this.log = config.fishermanMode ? log.createChild('[FISHERMAN]') : log;
         this.tracer = telemetry.getTracer('Validator');
         this.metrics = new ValidatorMetrics(telemetry);
-        this.validationService = new ValidationService(keyStore, log.createChild('validation-service'));
+        this.validationService = new ValidationService(keyStore, this.log.createChild('validation-service'));
         // Refresh epoch cache every second to trigger alert if participation in committee changes
-        this.epochCacheUpdateLoop = new RunningPromise(this.handleEpochCommitteeUpdate.bind(this), log, 1000);
+        this.epochCacheUpdateLoop = new RunningPromise(this.handleEpochCommitteeUpdate.bind(this), this.log, 1000);
         const myAddresses = this.getValidatorAddresses();
         this.log.verbose(`Initialized validator with addresses: ${myAddresses.map((a)=>a.toString()).join(', ')}`);
     }
@@ -137,10 +139,9 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
         await this.registerHandlers();
         const myAddresses = this.getValidatorAddresses();
         const inCommittee = await this.epochCache.filterInCommittee('now', myAddresses);
+        this.log.info(`Started validator with addresses: ${myAddresses.map((a)=>a.toString()).join(', ')}`);
         if (inCommittee.length > 0) {
-            this.log.info(`Started validator with addresses in current validator committee: ${inCommittee.map((a)=>a.toString()).join(', ')}`);
-        } else {
-            this.log.info(`Started validator with addresses: ${myAddresses.map((a)=>a.toString()).join(', ')}`);
+            this.log.info(`Addresses in current validator committee: ${inCommittee.map((a)=>a.toString()).join(', ')}`);
         }
         this.epochCacheUpdateLoop.start();
         return Promise.resolve();
@@ -160,7 +161,7 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
         }
     }
     async attestToProposal(proposal, proposalSender) {
-        const slotNumber = proposal.slotNumber.toBigInt();
+        const slotNumber = proposal.slotNumber;
         const proposer = proposal.getSender();
         // Reject proposals with invalid signatures
         if (!proposer) {
@@ -176,32 +177,31 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
         };
         this.log.info(`Received proposal for slot ${slotNumber}`, {
             ...proposalInfo,
-            txHashes: proposal.txHashes.map((t)=>t.toString())
+            txHashes: proposal.txHashes.map((t)=>t.toString()),
+            fishermanMode: this.config.fishermanMode || false
         });
         // Reexecute txs if we are part of the committee so we can attest, or if slashing is enabled so we can slash
         // invalid proposals even when not in the committee, or if we are configured to always reexecute for monitoring purposes.
-        const { validatorReexecute, slashBroadcastedInvalidBlockPenalty, alwaysReexecuteBlockProposals } = this.config;
-        const shouldReexecute = slashBroadcastedInvalidBlockPenalty > 0n && validatorReexecute || partOfCommittee && validatorReexecute || alwaysReexecuteBlockProposals;
+        // In fisherman mode, we always reexecute to validate proposals.
+        const { validatorReexecute, slashBroadcastedInvalidBlockPenalty, alwaysReexecuteBlockProposals, fishermanMode } = this.config;
+        const shouldReexecute = fishermanMode || slashBroadcastedInvalidBlockPenalty > 0n && validatorReexecute || partOfCommittee && validatorReexecute || alwaysReexecuteBlockProposals;
         const validationResult = await this.blockProposalHandler.handleBlockProposal(proposal, proposalSender, !!shouldReexecute);
         if (!validationResult.isValid) {
             this.log.warn(`Proposal validation failed: ${validationResult.reason}`, proposalInfo);
-            // Only track attestation failure metrics if we're actually in the committee
-            if (partOfCommittee) {
-                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);
-                } else {
-                    // Node issues: parent_block_not_found, block_number_already_exists, txs_not_available, timeout, unknown_error
-                    this.metrics.incFailedAttestationsNodeIssue(1, reason);
-                }
+            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) {
@@ -211,15 +211,42 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             return undefined;
         }
         // Check that I have any address in current committee before attesting
-        if (!partOfCommittee) {
+        // In fisherman mode, we still create attestations for validation even if not in committee
+        if (!partOfCommittee && !this.config.fishermanMode) {
             this.log.verbose(`No validator in the current committee, skipping attestation`, proposalInfo);
             return undefined;
         }
         // Provided all of the above checks pass, we can attest to the proposal
-        this.log.info(`Attesting to proposal for slot ${slotNumber}`, proposalInfo);
+        this.log.info(`${partOfCommittee ? 'Attesting to' : 'Validated'} proposal for slot ${slotNumber}`, {
+            ...proposalInfo,
+            inCommittee: partOfCommittee,
+            fishermanMode: this.config.fishermanMode || false
+        });
         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);
+        // Determine which validators should attest
+        let attestors;
+        if (partOfCommittee) {
+            attestors = inCommittee;
+        } else if (this.config.fishermanMode) {
+            // In fisherman mode, create attestations for validation purposes even if not in committee. These won't be broadcast.
+            attestors = this.getValidatorAddresses();
+        } else {
+            attestors = [];
+        }
+        // Only create attestations if we have attestors
+        if (attestors.length === 0) {
+            return undefined;
+        }
+        if (this.config.fishermanMode) {
+            // bail out early and don't save attestations to the pool in fisherman mode
+            this.log.info(`Creating attestations for proposal for slot ${slotNumber}`, {
+                ...proposalInfo,
+                attestors: attestors.map((a)=>a.toString())
+            });
+            return undefined;
+        }
+        return this.createBlockAttestationsFromProposal(proposal, attestors);
     }
     slashInvalidBlock(proposal) {
         const proposer = proposal.getSender();
@@ -239,16 +266,16 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
                 validator: proposer,
                 amount: this.config.slashBroadcastedInvalidBlockPenalty,
                 offenseType: OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL,
-                epochOrSlot: proposal.slotNumber.toBigInt()
+                epochOrSlot: BigInt(proposal.slotNumber)
             }
         ]);
     }
-    async createBlockProposal(blockNumber, header, archive, stateReference, txs, proposerAddress, options) {
-        if (this.previousProposal?.slotNumber.equals(header.slotNumber)) {
+    async createBlockProposal(blockNumber, header, archive, txs, proposerAddress, options) {
+        if (this.previousProposal?.slotNumber === header.slotNumber) {
             this.log.verbose(`Already made a proposal for the same slot, skipping proposal`);
             return Promise.resolve(undefined);
         }
-        const newProposal = await this.validationService.createBlockProposal(header, archive, stateReference, txs, proposerAddress, {
+        const newProposal = await this.validationService.createBlockProposal(header, archive, txs, proposerAddress, {
             ...options,
             broadcastInvalidBlockProposal: this.config.broadcastInvalidBlockProposal
         });
@@ -262,16 +289,23 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
         return await this.validationService.signAttestationsAndSigners(attestationsAndSigners, proposer);
     }
     async collectOwnAttestations(proposal) {
-        const slot = proposal.payload.header.slotNumber.toBigInt();
+        const slot = proposal.payload.header.slotNumber;
         const inCommittee = await this.epochCache.filterInCommittee(slot, this.getValidatorAddresses());
         this.log.debug(`Collecting ${inCommittee.length} self-attestations for slot ${slot}`, {
             inCommittee
         });
-        return this.createBlockAttestationsFromProposal(proposal, inCommittee);
+        const attestations = await this.createBlockAttestationsFromProposal(proposal, inCommittee);
+        // We broadcast our own attestations to our peers so, in case our block does not get mined on L1,
+        // other nodes can see that our validators did attest to this block proposal, and do not slash us
+        // due to inactivity for missed attestations.
+        void this.p2pClient.broadcastAttestations(attestations).catch((err)=>{
+            this.log.error(`Failed to broadcast self-attestations for slot ${slot}`, err);
+        });
+        return attestations;
     }
     async collectAttestations(proposal, required, deadline) {
         // Wait and poll the p2pClient's attestation pool for this block until we have enough attestations
-        const slot = proposal.payload.header.slotNumber.toBigInt();
+        const slot = proposal.payload.header.slotNumber;
         this.log.debug(`Collecting ${required} attestations for slot ${slot} with deadline ${deadline.toISOString()}`);
         if (+deadline < this.dateProvider.now()) {
             this.log.error(`Deadline ${deadline.toISOString()} for collecting ${required} attestations for slot ${slot} is in the past`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/validator-client",
-  "version": "3.0.0-devnet.2",
+  "version": "3.0.0-devnet.2-patch.1",
   "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,25 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "3.0.0-devnet.2",
-    "@aztec/epoch-cache": "3.0.0-devnet.2",
-    "@aztec/ethereum": "3.0.0-devnet.2",
-    "@aztec/foundation": "3.0.0-devnet.2",
-    "@aztec/node-keystore": "3.0.0-devnet.2",
-    "@aztec/p2p": "3.0.0-devnet.2",
-    "@aztec/prover-client": "3.0.0-devnet.2",
-    "@aztec/slasher": "3.0.0-devnet.2",
-    "@aztec/stdlib": "3.0.0-devnet.2",
-    "@aztec/telemetry-client": "3.0.0-devnet.2",
+    "@aztec/constants": "3.0.0-devnet.2-patch.1",
+    "@aztec/epoch-cache": "3.0.0-devnet.2-patch.1",
+    "@aztec/ethereum": "3.0.0-devnet.2-patch.1",
+    "@aztec/foundation": "3.0.0-devnet.2-patch.1",
+    "@aztec/node-keystore": "3.0.0-devnet.2-patch.1",
+    "@aztec/p2p": "3.0.0-devnet.2-patch.1",
+    "@aztec/slasher": "3.0.0-devnet.2-patch.1",
+    "@aztec/stdlib": "3.0.0-devnet.2-patch.1",
+    "@aztec/telemetry-client": "3.0.0-devnet.2-patch.1",
     "koa": "^2.16.1",
     "koa-router": "^13.1.1",
     "tslib": "^2.4.0",
-    "viem": "npm:@spalladino/viem@2.38.2-eip7594.0"
+    "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

@@ -1,17 +1,17 @@
 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 { Fr } from '@aztec/foundation/fields';
 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 { computeInHashFromL1ToL2Messages } from '@aztec/prover-client/helpers';
 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 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 {
@@ -45,14 +45,14 @@ type ReexecuteTransactionsResult = {
 
 export type BlockProposalValidationSuccessResult = {
   isValid: true;
-  blockNumber: number;
+  blockNumber: BlockNumber;
   reexecutionResult?: ReexecuteTransactionsResult;
 };
 
 export type BlockProposalValidationFailureResult = {
   isValid: false;
   reason: BlockProposalValidationFailureReason;
-  blockNumber?: number;
+  blockNumber?: BlockNumber;
   reexecutionResult?: ReexecuteTransactionsResult;
 };
 
@@ -73,6 +73,9 @@ export class BlockProposalHandler {
     telemetry: TelemetryClient = getTelemetryClient(),
     private log = createLogger('validator:block-proposal-handler'),
   ) {
+    if (config.fishermanMode) {
+      this.log = this.log.createChild('[FISHERMAN]');
+    }
     this.tracer = telemetry.getTracer('BlockProposalHandler');
   }
 
@@ -81,14 +84,14 @@ export class BlockProposalHandler {
       try {
         const result = await this.handleBlockProposal(proposal, proposalSender, true);
         if (result.isValid) {
-          this.log.info(`Non-validator reexecution completed for slot ${proposal.slotNumber.toBigInt()}`, {
+          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.toBigInt()}`, {
+          this.log.warn(`Non-validator reexecution failed for slot ${proposal.slotNumber}`, {
             blockNumber: result.blockNumber,
             reason: result.reason,
           });
@@ -108,7 +111,7 @@ export class BlockProposalHandler {
     proposalSender: PeerId,
     shouldReexecute: boolean,
   ): Promise<BlockProposalValidationResult> {
-    const slotNumber = proposal.slotNumber.toBigInt();
+    const slotNumber = proposal.slotNumber;
     const proposer = proposal.getSender();
     const config = this.blockBuilder.getConfig();
 
@@ -150,7 +153,10 @@ export class BlockProposalHandler {
     }
 
     // Compute the block number based on the parent block
-    const blockNumber = parentBlockHeader === 'genesis' ? INITIAL_L2_BLOCK_NUM : parentBlockHeader.getBlockNumber() + 1;
+    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);
@@ -167,8 +173,10 @@ export class BlockProposalHandler {
     });
 
     // Check that I have the same set of l1ToL2Messages as the proposal
-    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockNumber);
-    const computedInHash = await computeInHashFromL1ToL2Messages(l1ToL2Messages);
+    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`, {
@@ -204,7 +212,7 @@ export class BlockProposalHandler {
 
   private async getParentBlock(proposal: BlockProposal): Promise<'genesis' | BlockHeader | undefined> {
     const parentArchive = proposal.payload.header.lastArchiveRoot;
-    const slot = proposal.slotNumber.toBigInt();
+    const slot = proposal.slotNumber;
     const config = this.blockBuilder.getConfig();
     const { genesisArchiveRoot } = await this.blockSource.getGenesisValues();
 
@@ -239,8 +247,8 @@ export class BlockProposalHandler {
     }
   }
 
-  private getReexecutionDeadline(slot: bigint, config: { l1GenesisTime: bigint; slotDuration: number }): Date {
-    const nextSlotTimestampSeconds = Number(getTimestampForSlot(slot + 1n, config));
+  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);
   }
@@ -259,7 +267,7 @@ export class BlockProposalHandler {
 
   async reexecuteTransactions(
     proposal: BlockProposal,
-    blockNumber: number,
+    blockNumber: BlockNumber,
     txs: Tx[],
     l1ToL2Messages: Fr[],
   ): Promise<ReexecuteTransactionsResult> {
@@ -290,11 +298,11 @@ export class BlockProposalHandler {
     });
 
     const { block, failedTxs } = await this.blockBuilder.buildBlock(txs, l1ToL2Messages, globalVariables, {
-      deadline: this.getReexecutionDeadline(proposal.payload.header.slotNumber.toBigInt(), config),
+      deadline: this.getReexecutionDeadline(proposal.payload.header.slotNumber, config),
     });
 
     const numFailedTxs = failedTxs.length;
-    const slot = proposal.slotNumber.toBigInt();
+    const slot = proposal.slotNumber;
     this.log.verbose(`Transaction re-execution complete for slot ${slot}`, {
       numFailedTxs,
       numProposalTxs: txHashes.length,
@@ -320,12 +328,7 @@ export class BlockProposalHandler {
         actual: proposal.payload.toInspect(),
       });
       this.metrics?.recordFailedReexecution(proposal);
-      throw new ReExStateMismatchError(
-        proposal.archive,
-        block.archive.root,
-        proposal.payload.stateReference,
-        block.header.state,
-      );
+      throw new ReExStateMismatchError(proposal.archive, block.archive.root);
     }
 
     const reexecutionTimeMs = timer.ms();

package/src/config.ts

@@ -64,6 +64,12 @@ export const validatorClientConfigMappings: ConfigMappingsType<ValidatorClientCo
       '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,10 +1,9 @@
 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 { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
-import { unfreeze } from '@aztec/foundation/types';
 import type { CommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
 import {
   BlockAttestation,
@@ -14,8 +13,7 @@ import {
   SignatureDomainSeparator,
 } from '@aztec/stdlib/p2p';
 import type { CheckpointHeader } from '@aztec/stdlib/rollup';
-import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
-import { StateReference, type Tx } from '@aztec/stdlib/tx';
+import type { Tx } from '@aztec/stdlib/tx';
 
 import type { ValidatorKeyStore } from '../key_store/interface.js';
 
@@ -38,7 +36,6 @@ export class ValidationService {
   async createBlockProposal(
     header: CheckpointHeader,
     archive: Fr,
-    stateReference: StateReference,
     txs: Tx[],
     proposerAttesterAddress: EthAddress | undefined,
     options: BlockProposalOptions,
@@ -54,14 +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: corrupt the state reference to trigger state_mismatch validation failure
+    // For testing: change the new archive to trigger state_mismatch validation failure
     if (options.broadcastInvalidBlockProposal) {
-      unfreeze(stateReference.partial).noteHashTree = AppendOnlyTreeSnapshot.random();
-      this.log.warn(`Creating INVALID block proposal for slot ${header.slotNumber.toBigInt()}`);
+      archive = Fr.random();
+      this.log.warn(`Creating INVALID block proposal for slot ${header.slotNumber}`);
     }
 
     return BlockProposal.createProposalFromSigner(
-      new ConsensusPayload(header, archive, stateReference),
+      new ConsensusPayload(header, archive),
       txHashes,
       options.publishFullTxs ? txs : undefined,
       payloadSigner,

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';

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

package/src/metrics.ts

@@ -85,15 +85,17 @@ export class ValidatorMetrics {
     this.successfulAttestationsCount.add(num);
   }
 
-  public incFailedAttestationsBadProposal(num: number, reason: string) {
+  public incFailedAttestationsBadProposal(num: number, reason: string, inCommittee: boolean) {
     this.failedAttestationsBadProposalCount.add(num, {
       [Attributes.ERROR_TYPE]: reason,
+      [Attributes.IS_COMMITTEE_MEMBER]: inCommittee,
     });
   }
 
-  public incFailedAttestationsNodeIssue(num: number, reason: string) {
+  public incFailedAttestationsNodeIssue(num: number, reason: string, inCommittee: boolean) {
     this.failedAttestationsNodeIssueCount.add(num, {
       [Attributes.ERROR_TYPE]: reason,
+      [Attributes.IS_COMMITTEE_MEMBER]: inCommittee,
     });
   }
 }