@aztec/validator-client 0.0.1-commit.b655e406 → 0.0.1-commit.c7c42ec

package/dest/validator.js

@@ -1,3 +1,10 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { getBlobsPerL1Block } from '@aztec/blob-lib';
 import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import { sleep } from '@aztec/foundation/sleep';
@@ -5,7 +12,7 @@ import { DateProvider } from '@aztec/foundation/timer';
 import { AuthRequest, AuthResponse, BlockProposalValidator, ReqRespSubProtocol } from '@aztec/p2p';
 import { OffenseType, WANT_TO_SLASH_EVENT } from '@aztec/slasher';
 import { AttestationTimeoutError } from '@aztec/stdlib/validators';
-import { getTelemetryClient } from '@aztec/telemetry-client';
+import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 import { EventEmitter } from 'events';
 import { BlockProposalHandler } from './block_proposal_handler.js';
 import { ValidationService } from './duties/validation_service.js';
@@ -27,11 +34,12 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
     p2pClient;
     blockProposalHandler;
     config;
+    fileStoreBlobUploadClient;
     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
@@ -39,13 +47,15 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
     lastEpochForCommitteeUpdateLoop;
     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();
+    constructor(keyStore, epochCache, p2pClient, blockProposalHandler, config, fileStoreBlobUploadClient, 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.fileStoreBlobUploadClient = fileStoreBlobUploadClient, 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(', ')}`);
     }
@@ -92,13 +102,13 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             this.log.error(`Error updating epoch committee`, err);
         }
     }
-    static new(config, blockBuilder, epochCache, p2pClient, blockSource, l1ToL2MessageSource, txProvider, keyStoreManager, dateProvider = new DateProvider(), telemetry = getTelemetryClient()) {
+    static new(config, blockBuilder, epochCache, p2pClient, blockSource, l1ToL2MessageSource, txProvider, keyStoreManager, fileStoreBlobUploadClient, dateProvider = new DateProvider(), telemetry = getTelemetryClient()) {
         const metrics = new ValidatorMetrics(telemetry);
         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);
+        const validator = new ValidatorClient(NodeKeystoreAdapter.fromKeyStoreManager(keyStoreManager), epochCache, p2pClient, blockProposalHandler, config, fileStoreBlobUploadClient, dateProvider, telemetry);
         return validator;
     }
     getValidatorAddresses() {
@@ -137,10 +147,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 +169,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,12 +185,14 @@ 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 || this.fileStoreBlobUploadClient;
         const validationResult = await this.blockProposalHandler.handleBlockProposal(proposal, proposalSender, !!shouldReexecute);
         if (!validationResult.isValid) {
             this.log.warn(`Proposal validation failed: ${validationResult.reason}`, proposalInfo);
@@ -208,15 +219,55 @@ 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);
+        // Upload blobs to filestore after successful re-execution (fire-and-forget)
+        if (validationResult.reexecutionResult?.block && this.fileStoreBlobUploadClient) {
+            void Promise.resolve().then(async ()=>{
+                try {
+                    const blobFields = validationResult.reexecutionResult.block.getCheckpointBlobFields();
+                    const blobs = getBlobsPerL1Block(blobFields);
+                    await this.fileStoreBlobUploadClient.saveBlobs(blobs, true);
+                    this.log.debug(`Uploaded ${blobs.length} blobs to filestore from re-execution`, proposalInfo);
+                } catch (err) {
+                    this.log.warn(`Failed to upload blobs from re-execution`, err);
+                }
+            });
+        }
         // 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();
@@ -236,22 +287,30 @@ 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)) {
-            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, {
+    // TODO(palla/mbps): Block proposal should not require a checkpoint proposal
+    async createBlockProposal(blockNumber, header, archive, txs, proposerAddress, options) {
+        // TODO(palla/mbps): Prevent double proposals properly
+        // if (this.previousProposal?.slotNumber === header.slotNumber) {
+        //   this.log.verbose(`Already made a proposal for the same slot, skipping proposal`);
+        //   return Promise.resolve(undefined);
+        // }
+        this.log.info(`Assembling block proposal for block ${blockNumber} slot ${header.slotNumber}`);
+        const newProposal = await this.validationService.createBlockProposal(header, archive, txs, proposerAddress, {
             ...options,
             broadcastInvalidBlockProposal: this.config.broadcastInvalidBlockProposal
         });
         this.previousProposal = newProposal;
         return newProposal;
     }
+    // TODO(palla/mbps): Effectively create a checkpoint proposal different from a block proposal
+    createCheckpointProposal(header, archive, txs, proposerAddress, options) {
+        this.log.info(`Assembling checkpoint proposal for slot ${header.slotNumber}`);
+        return this.createBlockProposal(0, header, archive, txs, proposerAddress, options);
+    }
     async broadcastBlockProposal(proposal) {
         await this.p2pClient.broadcastProposal(proposal);
     }
@@ -259,16 +318,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`);
@@ -341,3 +407,9 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
         return authResponse.toBuffer();
     }
 }
+_ts_decorate([
+    trackSpan('validator.attestToProposal', (proposal, proposalSender)=>({
+            [Attributes.BLOCK_HASH]: proposal.payload.header.hash.toString(),
+            [Attributes.PEER_ID]: proposalSender.toString()
+        }))
+], ValidatorClient.prototype, "attestToProposal", null);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/validator-client",
-  "version": "0.0.1-commit.b655e406",
+  "version": "0.0.1-commit.c7c42ec",
   "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": "0.0.1-commit.b655e406",
-    "@aztec/epoch-cache": "0.0.1-commit.b655e406",
-    "@aztec/ethereum": "0.0.1-commit.b655e406",
-    "@aztec/foundation": "0.0.1-commit.b655e406",
-    "@aztec/node-keystore": "0.0.1-commit.b655e406",
-    "@aztec/p2p": "0.0.1-commit.b655e406",
-    "@aztec/prover-client": "0.0.1-commit.b655e406",
-    "@aztec/slasher": "0.0.1-commit.b655e406",
-    "@aztec/stdlib": "0.0.1-commit.b655e406",
-    "@aztec/telemetry-client": "0.0.1-commit.b655e406",
+    "@aztec/blob-client": "0.0.1-commit.c7c42ec",
+    "@aztec/blob-lib": "0.0.1-commit.c7c42ec",
+    "@aztec/constants": "0.0.1-commit.c7c42ec",
+    "@aztec/epoch-cache": "0.0.1-commit.c7c42ec",
+    "@aztec/ethereum": "0.0.1-commit.c7c42ec",
+    "@aztec/foundation": "0.0.1-commit.c7c42ec",
+    "@aztec/node-keystore": "0.0.1-commit.c7c42ec",
+    "@aztec/p2p": "0.0.1-commit.c7c42ec",
+    "@aztec/slasher": "0.0.1-commit.c7c42ec",
+    "@aztec/stdlib": "0.0.1-commit.c7c42ec",
+    "@aztec/telemetry-client": "0.0.1-commit.c7c42ec",
     "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/factory.ts

@@ -1,3 +1,4 @@
+import type { FileStoreBlobClient } from '@aztec/blob-client/filestore';
 import type { EpochCache } from '@aztec/epoch-cache';
 import type { DateProvider } from '@aztec/foundation/timer';
 import type { KeystoreManager } from '@aztec/node-keystore';
@@ -51,6 +52,7 @@ export function createValidatorClient(
     dateProvider: DateProvider;
     epochCache: EpochCache;
     keyStoreManager: KeystoreManager | undefined;
+    fileStoreBlobUploadClient?: FileStoreBlobClient;
   },
 ) {
   if (config.disableValidator || !deps.keyStoreManager) {
@@ -67,6 +69,7 @@ export function createValidatorClient(
     deps.l1ToL2MessageSource,
     txProvider,
     deps.keyStoreManager,
+    deps.fileStoreBlobUploadClient,
     deps.dateProvider,
     deps.telemetry,
   );

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,5 +1,5 @@
 import type { Buffer32 } from '@aztec/foundation/buffer';
-import { normalizeSignature } from '@aztec/foundation/crypto';
+import { normalizeSignature } from '@aztec/foundation/crypto/secp256k1-signer';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';