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

package/dest/validator.js

@@ -1,67 +1,455 @@
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+function applyDecs2203RFactory() {
+    function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+        return function addInitializer(initializer) {
+            assertNotFinished(decoratorFinishedRef, "addInitializer");
+            assertCallable(initializer, "An initializer");
+            initializers.push(initializer);
+        };
+    }
+    function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+        var kindStr;
+        switch(kind){
+            case 1:
+                kindStr = "accessor";
+                break;
+            case 2:
+                kindStr = "method";
+                break;
+            case 3:
+                kindStr = "getter";
+                break;
+            case 4:
+                kindStr = "setter";
+                break;
+            default:
+                kindStr = "field";
+        }
+        var ctx = {
+            kind: kindStr,
+            name: isPrivate ? "#" + name : name,
+            static: isStatic,
+            private: isPrivate,
+            metadata: metadata
+        };
+        var decoratorFinishedRef = {
+            v: false
+        };
+        ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+        var get, set;
+        if (kind === 0) {
+            if (isPrivate) {
+                get = desc.get;
+                set = desc.set;
+            } else {
+                get = function() {
+                    return this[name];
+                };
+                set = function(v) {
+                    this[name] = v;
+                };
+            }
+        } else if (kind === 2) {
+            get = function() {
+                return desc.value;
+            };
+        } else {
+            if (kind === 1 || kind === 3) {
+                get = function() {
+                    return desc.get.call(this);
+                };
+            }
+            if (kind === 1 || kind === 4) {
+                set = function(v) {
+                    desc.set.call(this, v);
+                };
+            }
+        }
+        ctx.access = get && set ? {
+            get: get,
+            set: set
+        } : get ? {
+            get: get
+        } : {
+            set: set
+        };
+        try {
+            return dec(value, ctx);
+        } finally{
+            decoratorFinishedRef.v = true;
+        }
+    }
+    function assertNotFinished(decoratorFinishedRef, fnName) {
+        if (decoratorFinishedRef.v) {
+            throw new Error("attempted to call " + fnName + " after decoration was finished");
+        }
+    }
+    function assertCallable(fn, hint) {
+        if (typeof fn !== "function") {
+            throw new TypeError(hint + " must be a function");
+        }
+    }
+    function assertValidReturnValue(kind, value) {
+        var type = typeof value;
+        if (kind === 1) {
+            if (type !== "object" || value === null) {
+                throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+            }
+            if (value.get !== undefined) {
+                assertCallable(value.get, "accessor.get");
+            }
+            if (value.set !== undefined) {
+                assertCallable(value.set, "accessor.set");
+            }
+            if (value.init !== undefined) {
+                assertCallable(value.init, "accessor.init");
+            }
+        } else if (type !== "function") {
+            var hint;
+            if (kind === 0) {
+                hint = "field";
+            } else if (kind === 10) {
+                hint = "class";
+            } else {
+                hint = "method";
+            }
+            throw new TypeError(hint + " decorators must return a function or void 0");
+        }
+    }
+    function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+        var decs = decInfo[0];
+        var desc, init, value;
+        if (isPrivate) {
+            if (kind === 0 || kind === 1) {
+                desc = {
+                    get: decInfo[3],
+                    set: decInfo[4]
+                };
+            } else if (kind === 3) {
+                desc = {
+                    get: decInfo[3]
+                };
+            } else if (kind === 4) {
+                desc = {
+                    set: decInfo[3]
+                };
+            } else {
+                desc = {
+                    value: decInfo[3]
+                };
+            }
+        } else if (kind !== 0) {
+            desc = Object.getOwnPropertyDescriptor(base, name);
+        }
+        if (kind === 1) {
+            value = {
+                get: desc.get,
+                set: desc.set
+            };
+        } else if (kind === 2) {
+            value = desc.value;
+        } else if (kind === 3) {
+            value = desc.get;
+        } else if (kind === 4) {
+            value = desc.set;
+        }
+        var newValue, get, set;
+        if (typeof decs === "function") {
+            newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+            if (newValue !== void 0) {
+                assertValidReturnValue(kind, newValue);
+                if (kind === 0) {
+                    init = newValue;
+                } else if (kind === 1) {
+                    init = newValue.init;
+                    get = newValue.get || value.get;
+                    set = newValue.set || value.set;
+                    value = {
+                        get: get,
+                        set: set
+                    };
+                } else {
+                    value = newValue;
+                }
+            }
+        } else {
+            for(var i = decs.length - 1; i >= 0; i--){
+                var dec = decs[i];
+                newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+                if (newValue !== void 0) {
+                    assertValidReturnValue(kind, newValue);
+                    var newInit;
+                    if (kind === 0) {
+                        newInit = newValue;
+                    } else if (kind === 1) {
+                        newInit = newValue.init;
+                        get = newValue.get || value.get;
+                        set = newValue.set || value.set;
+                        value = {
+                            get: get,
+                            set: set
+                        };
+                    } else {
+                        value = newValue;
+                    }
+                    if (newInit !== void 0) {
+                        if (init === void 0) {
+                            init = newInit;
+                        } else if (typeof init === "function") {
+                            init = [
+                                init,
+                                newInit
+                            ];
+                        } else {
+                            init.push(newInit);
+                        }
+                    }
+                }
+            }
+        }
+        if (kind === 0 || kind === 1) {
+            if (init === void 0) {
+                init = function(instance, init) {
+                    return init;
+                };
+            } else if (typeof init !== "function") {
+                var ownInitializers = init;
+                init = function(instance, init) {
+                    var value = init;
+                    for(var i = 0; i < ownInitializers.length; i++){
+                        value = ownInitializers[i].call(instance, value);
+                    }
+                    return value;
+                };
+            } else {
+                var originalInitializer = init;
+                init = function(instance, init) {
+                    return originalInitializer.call(instance, init);
+                };
+            }
+            ret.push(init);
+        }
+        if (kind !== 0) {
+            if (kind === 1) {
+                desc.get = value.get;
+                desc.set = value.set;
+            } else if (kind === 2) {
+                desc.value = value;
+            } else if (kind === 3) {
+                desc.get = value;
+            } else if (kind === 4) {
+                desc.set = value;
+            }
+            if (isPrivate) {
+                if (kind === 1) {
+                    ret.push(function(instance, args) {
+                        return value.get.call(instance, args);
+                    });
+                    ret.push(function(instance, args) {
+                        return value.set.call(instance, args);
+                    });
+                } else if (kind === 2) {
+                    ret.push(value);
+                } else {
+                    ret.push(function(instance, args) {
+                        return value.call(instance, args);
+                    });
+                }
+            } else {
+                Object.defineProperty(base, name, desc);
+            }
+        }
+    }
+    function applyMemberDecs(Class, decInfos, metadata) {
+        var ret = [];
+        var protoInitializers;
+        var staticInitializers;
+        var existingProtoNonFields = new Map();
+        var existingStaticNonFields = new Map();
+        for(var i = 0; i < decInfos.length; i++){
+            var decInfo = decInfos[i];
+            if (!Array.isArray(decInfo)) continue;
+            var kind = decInfo[1];
+            var name = decInfo[2];
+            var isPrivate = decInfo.length > 3;
+            var isStatic = kind >= 5;
+            var base;
+            var initializers;
+            if (isStatic) {
+                base = Class;
+                kind = kind - 5;
+                staticInitializers = staticInitializers || [];
+                initializers = staticInitializers;
+            } else {
+                base = Class.prototype;
+                protoInitializers = protoInitializers || [];
+                initializers = protoInitializers;
+            }
+            if (kind !== 0 && !isPrivate) {
+                var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+                var existingKind = existingNonFields.get(name) || 0;
+                if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) {
+                    throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+                } else if (!existingKind && kind > 2) {
+                    existingNonFields.set(name, kind);
+                } else {
+                    existingNonFields.set(name, true);
+                }
+            }
+            applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+        }
+        pushInitializers(ret, protoInitializers);
+        pushInitializers(ret, staticInitializers);
+        return ret;
+    }
+    function pushInitializers(ret, initializers) {
+        if (initializers) {
+            ret.push(function(instance) {
+                for(var i = 0; i < initializers.length; i++){
+                    initializers[i].call(instance);
+                }
+                return instance;
+            });
+        }
+    }
+    function applyClassDecs(targetClass, classDecs, metadata) {
+        if (classDecs.length > 0) {
+            var initializers = [];
+            var newClass = targetClass;
+            var name = targetClass.name;
+            for(var i = classDecs.length - 1; i >= 0; i--){
+                var decoratorFinishedRef = {
+                    v: false
+                };
+                try {
+                    var nextNewClass = classDecs[i](newClass, {
+                        kind: "class",
+                        name: name,
+                        addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+                        metadata
+                    });
+                } finally{
+                    decoratorFinishedRef.v = true;
+                }
+                if (nextNewClass !== undefined) {
+                    assertValidReturnValue(10, nextNewClass);
+                    newClass = nextNewClass;
+                }
+            }
+            return [
+                defineMetadata(newClass, metadata),
+                function() {
+                    for(var i = 0; i < initializers.length; i++){
+                        initializers[i].call(newClass);
+                    }
+                }
+            ];
+        }
+    }
+    function defineMetadata(Class, metadata) {
+        return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+            configurable: true,
+            enumerable: true,
+            value: metadata
+        });
+    }
+    return function applyDecs2203R(targetClass, memberDecs, classDecs, parentClass) {
+        if (parentClass !== void 0) {
+            var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+        }
+        var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+        var e = applyMemberDecs(targetClass, memberDecs, metadata);
+        if (!classDecs.length) defineMetadata(targetClass, metadata);
+        return {
+            e: e,
+            get c () {
+                return applyClassDecs(targetClass, classDecs, metadata);
+            }
+        };
+    };
+}
+function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+    return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _dec, _initProto;
+import { getBlobsPerL1Block } from '@aztec/blob-lib';
 import { createLogger } from '@aztec/foundation/log';
-import { retryUntil } from '@aztec/foundation/retry';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import { sleep } from '@aztec/foundation/sleep';
-import { DateProvider, Timer } from '@aztec/foundation/timer';
-import { AuthRequest, AuthResponse, ReqRespSubProtocol } from '@aztec/p2p';
-import { BlockProposalValidator } from '@aztec/p2p/msg_validators';
-import { computeInHashFromL1ToL2Messages } from '@aztec/prover-client/helpers';
+import { DateProvider } from '@aztec/foundation/timer';
+import { AuthRequest, AuthResponse, BlockProposalValidator, ReqRespSubProtocol } from '@aztec/p2p';
 import { OffenseType, WANT_TO_SLASH_EVENT } from '@aztec/slasher';
-import { getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
-import { GlobalVariables } from '@aztec/stdlib/tx';
-import { AttestationTimeoutError, ReExFailedTxsError, ReExStateMismatchError, ReExTimeoutError, TransactionsNotAvailableError } from '@aztec/stdlib/validators';
-import { getTelemetryClient } from '@aztec/telemetry-client';
+import { AttestationTimeoutError } from '@aztec/stdlib/validators';
+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';
 import { NodeKeystoreAdapter } from './key_store/node_keystore_adapter.js';
 import { ValidatorMetrics } from './metrics.js';
 // We maintain a set of proposers who have proposed invalid blocks.
 // Just cap the set to avoid unbounded growth.
 const MAX_PROPOSERS_OF_INVALID_BLOCKS = 1000;
+// What errors from the block proposal handler result in slashing
+const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
+    'state_mismatch',
+    'failed_txs'
+];
+_dec = trackSpan('validator.attestToProposal', (proposal, proposalSender)=>({
+        [Attributes.BLOCK_HASH]: proposal.payload.header.hash.toString(),
+        [Attributes.PEER_ID]: proposalSender.toString()
+    }));
 /**
  * Validator Client
  */ export class ValidatorClient extends EventEmitter {
-    blockBuilder;
     keyStore;
     epochCache;
     p2pClient;
-    blockSource;
-    l1ToL2MessageSource;
-    txProvider;
+    blockProposalHandler;
     config;
+    blobClient;
     dateProvider;
-    log;
+    static{
+        ({ e: [_initProto] } = _apply_decs_2203_r(this, [
+            [
+                _dec,
+                2,
+                "attestToProposal"
+            ]
+        ], []));
+    }
     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
     previousProposal;
     lastEpochForCommitteeUpdateLoop;
     epochCacheUpdateLoop;
-    blockProposalValidator;
     proposersOfInvalidBlocks;
-    constructor(blockBuilder, keyStore, epochCache, p2pClient, blockSource, l1ToL2MessageSource, txProvider, config, dateProvider = new DateProvider(), telemetry = getTelemetryClient(), log = createLogger('validator')){
-        super(), this.blockBuilder = blockBuilder, this.keyStore = keyStore, this.epochCache = epochCache, this.p2pClient = p2pClient, this.blockSource = blockSource, this.l1ToL2MessageSource = l1ToL2MessageSource, this.txProvider = txProvider, this.config = config, this.dateProvider = dateProvider, this.log = log, this.proposersOfInvalidBlocks = new Set();
+    constructor(keyStore, epochCache, p2pClient, blockProposalHandler, config, blobClient, 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.blobClient = blobClient, this.dateProvider = dateProvider, this.hasRegisteredHandlers = (_initProto(this), 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);
-        this.blockProposalValidator = new BlockProposalValidator(epochCache);
+        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(', ')}`);
     }
-    static validateKeyStoreConfiguration(keyStoreManager) {
+    static validateKeyStoreConfiguration(keyStoreManager, logger) {
         const validatorKeyStore = NodeKeystoreAdapter.fromKeyStoreManager(keyStoreManager);
         const validatorAddresses = validatorKeyStore.getAddresses();
         // Verify that we can retrieve all required data from the key store
         for (const address of validatorAddresses){
             // Functions throw if required data is not available
+            let coinbase;
+            let feeRecipient;
             try {
-                validatorKeyStore.getCoinbaseAddress(address);
-                validatorKeyStore.getFeeRecipient(address);
+                coinbase = validatorKeyStore.getCoinbaseAddress(address);
+                feeRecipient = validatorKeyStore.getFeeRecipient(address);
             } catch (error) {
                 throw new Error(`Failed to retrieve required data for validator address ${address}, error: ${error}`);
             }
@@ -69,6 +457,7 @@ const MAX_PROPOSERS_OF_INVALID_BLOCKS = 1000;
             if (!publisherAddresses.length) {
                 throw new Error(`No publisher addresses found for validator address ${address}`);
             }
+            logger?.debug(`Validator ${address.toString()} configured with coinbase ${coinbase.toString()}, feeRecipient ${feeRecipient.toString()} and publishers ${publisherAddresses.map((x)=>x.toString()).join()}`);
         }
     }
     async handleEpochCommitteeUpdate() {
@@ -93,15 +482,25 @@ const MAX_PROPOSERS_OF_INVALID_BLOCKS = 1000;
             this.log.error(`Error updating epoch committee`, err);
         }
     }
-    static new(config, blockBuilder, epochCache, p2pClient, blockSource, l1ToL2MessageSource, txProvider, keyStoreManager, dateProvider = new DateProvider(), telemetry = getTelemetryClient()) {
-        const validator = new ValidatorClient(blockBuilder, NodeKeystoreAdapter.fromKeyStoreManager(keyStoreManager), epochCache, p2pClient, blockSource, l1ToL2MessageSource, txProvider, config, dateProvider, telemetry);
-        // TODO(PhilWindle): This seems like it could/should be done inside start()
-        validator.registerBlockProposalHandler();
+    static new(config, blockBuilder, epochCache, p2pClient, blockSource, l1ToL2MessageSource, txProvider, keyStoreManager, blobClient, 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, blobClient, dateProvider, telemetry);
         return validator;
     }
     getValidatorAddresses() {
         return this.keyStore.getAddresses().filter((addr)=>!this.config.disabledValidators.some((disabled)=>disabled.equals(addr)));
     }
+    getBlockProposalHandler() {
+        return this.blockProposalHandler;
+    }
+    // Proxy method for backwards compatibility with tests
+    reExecuteTransactions(proposal, blockNumber, txs, l1ToL2Messages) {
+        return this.blockProposalHandler.reexecuteTransactions(proposal, blockNumber, txs, l1ToL2Messages);
+    }
     signWithAddress(addr, msg) {
         return this.keyStore.signTypedDataWithAddress(addr, msg);
     }
@@ -121,31 +520,42 @@ const MAX_PROPOSERS_OF_INVALID_BLOCKS = 1000;
         };
     }
     async start() {
-        // Sync the committee from the smart contract
-        // https://github.com/AztecProtocol/aztec-packages/issues/7962
+        if (this.epochCacheUpdateLoop.isRunning()) {
+            this.log.warn(`Validator client already started`);
+            return;
+        }
+        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();
-        this.p2pClient.registerThisValidatorAddresses(myAddresses);
-        await this.p2pClient.addReqRespSubProtocol(ReqRespSubProtocol.AUTH, this.handleAuthRequest.bind(this));
         return Promise.resolve();
     }
     async stop() {
         await this.epochCacheUpdateLoop.stop();
     }
-    registerBlockProposalHandler() {
-        const handler = (block, proposalSender)=>this.attestToProposal(block, proposalSender);
-        this.p2pClient.registerBlockProposalHandler(handler);
+    /** Register handlers on the p2p client */ async registerHandlers() {
+        if (!this.hasRegisteredHandlers) {
+            this.hasRegisteredHandlers = true;
+            this.log.debug(`Registering validator handlers for p2p client`);
+            const handler = (block, proposalSender)=>this.attestToProposal(block, proposalSender);
+            this.p2pClient.registerBlockProposalHandler(handler);
+            const myAddresses = this.getValidatorAddresses();
+            this.p2pClient.registerThisValidatorAddresses(myAddresses);
+            await this.p2pClient.addReqRespSubProtocol(ReqRespSubProtocol.AUTH, this.handleAuthRequest.bind(this));
+        }
     }
     async attestToProposal(proposal, proposalSender) {
-        const slotNumber = proposal.slotNumber.toBigInt();
-        const blockNumber = proposal.blockNumber;
+        const slotNumber = proposal.slotNumber;
         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;
@@ -155,164 +565,97 @@ const MAX_PROPOSERS_OF_INVALID_BLOCKS = 1000;
         };
         this.log.info(`Received proposal for slot ${slotNumber}`, {
             ...proposalInfo,
-            txHashes: proposal.txHashes.map((txHash)=>txHash.toString())
-        });
-        // Collect txs from the proposal. Note that we do this before checking if we have an address in the
-        // current committee, since we want to collect txs anyway to facilitate propagation.
-        const { txs, missingTxs } = await this.txProvider.getTxsForBlockProposal(proposal, {
-            pinnedPeer: proposalSender,
-            deadline: this.getReexecutionDeadline(proposal, this.blockBuilder.getConfig())
+            txHashes: proposal.txHashes.map((t)=>t.toString()),
+            fishermanMode: this.config.fishermanMode || false
         });
-        // Check that I have any address in current committee before attesting
-        if (!partOfCommittee) {
-            this.log.verbose(`No validator in the current committee, skipping attestation`, proposalInfo);
+        // 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.
+        // 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.blobClient.canUpload();
+        const validationResult = await this.blockProposalHandler.handleBlockProposal(proposal, proposalSender, !!shouldReexecute);
+        if (!validationResult.isValid) {
+            this.log.warn(`Proposal validation failed: ${validationResult.reason}`, proposalInfo);
+            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);
+            }
             return undefined;
         }
-        // Check that the proposal is from the current proposer, or the next proposer.
-        // Q: Should this be moved to the block proposal validator, so we disregard proposals from anyone?
-        const invalidProposal = await this.blockProposalValidator.validate(proposal);
-        if (invalidProposal) {
-            this.log.warn(`Proposal is not valid, skipping attestation`, proposalInfo);
-            if (partOfCommittee) {
-                this.metrics.incFailedAttestations(1, 'invalid_proposal');
-            }
+        // Check that I have any address in current committee before attesting
+        // 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;
         }
-        // Check that the parent proposal is a block we know, otherwise reexecution would fail.
-        // Q: Should we move this to the block proposal validator? If there, then p2p would check it
-        // before re-broadcasting it. This means that proposals built on top of an L1-reorg'ed-out block
-        // would not be rebroadcasted. But it also means that nodes that have not fully synced would
-        // not rebroadcast the proposal.
-        if (blockNumber > INITIAL_L2_BLOCK_NUM) {
-            const config = this.blockBuilder.getConfig();
-            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);
-            if (parentBlock === undefined) {
-                this.log.warn(`Parent block for ${blockNumber} not found, skipping attestation`, proposalInfo);
-                if (partOfCommittee) {
-                    this.metrics.incFailedAttestations(1, 'parent_block_not_found');
-                }
-                return undefined;
-            }
-            if (!proposal.payload.header.lastArchiveRoot.equals(parentBlock.archive.root)) {
-                this.log.warn(`Parent block archive root for proposal does not match, skipping attestation`, {
-                    proposalLastArchiveRoot: proposal.payload.header.lastArchiveRoot.toString(),
-                    parentBlockArchiveRoot: parentBlock.archive.root.toString(),
-                    ...proposalInfo
-                });
-                if (partOfCommittee) {
-                    this.metrics.incFailedAttestations(1, 'parent_block_does_not_match');
+        // Provided all of the above checks pass, we can attest to the proposal
+        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.blobClient.canUpload()) {
+            void Promise.resolve().then(async ()=>{
+                try {
+                    const blobFields = validationResult.reexecutionResult.block.getCheckpointBlobFields();
+                    const blobs = getBlobsPerL1Block(blobFields);
+                    await this.blobClient.sendBlobsToFilestore(blobs);
+                    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);
                 }
-                return undefined;
-            }
-        }
-        // Check that I have the same set of l1ToL2Messages as the proposal
-        // Q: Same as above, should this be part of p2p validation?
-        const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockNumber);
-        const computedInHash = await computeInHashFromL1ToL2Messages(l1ToL2Messages);
-        const proposalInHash = proposal.payload.header.contentCommitment.inHash;
-        if (!computedInHash.equals(proposalInHash)) {
-            this.log.warn(`L1 to L2 messages in hash mismatch, skipping attestation`, {
-                proposalInHash: proposalInHash.toString(),
-                computedInHash: computedInHash.toString(),
-                ...proposalInfo
             });
-            if (partOfCommittee) {
-                this.metrics.incFailedAttestations(1, 'in_hash_mismatch');
-            }
+        }
+        // If the above function does not throw an error, then we can attest to the proposal
+        // 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;
         }
-        // Check that all of the transactions in the proposal are available in the tx pool before attesting
-        if (missingTxs.length > 0) {
-            this.log.warn(`Missing ${missingTxs.length} txs to attest to proposal`, {
+        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,
-                missingTxs
+                attestors: attestors.map((a)=>a.toString())
             });
-            if (partOfCommittee) {
-                this.metrics.incFailedAttestations(1, 'TransactionsNotAvailableError');
-            }
             return undefined;
         }
-        // Try re-executing the transactions in the proposal
-        try {
-            this.log.verbose(`Processing attestation for slot ${slotNumber}`, proposalInfo);
-            if (this.config.validatorReexecute) {
-                this.log.verbose(`Re-executing transactions in the proposal before attesting`);
-                await this.reExecuteTransactions(proposal, txs, l1ToL2Messages);
-            }
-        } catch (error) {
-            this.metrics.incFailedAttestations(1, error instanceof Error ? error.name : 'unknown');
-            this.log.error(`Error reexecuting txs while processing block proposal`, error, proposalInfo);
-            if (error instanceof ReExStateMismatchError && this.config.slashBroadcastedInvalidBlockPenalty > 0n) {
-                this.log.warn(`Slashing proposer for invalid block proposal`, proposalInfo);
-                this.slashInvalidBlock(proposal);
-            }
-            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.metrics.incAttestations(inCommittee.length);
-        // If the above function does not throw an error, then we can attest to the proposal
-        return this.doAttestToProposal(proposal, inCommittee);
-    }
-    getReexecutionDeadline(proposal, config) {
-        const nextSlotTimestampSeconds = Number(getTimestampForSlot(proposal.slotNumber.toBigInt() + 1n, config));
-        const msNeededForPropagationAndPublishing = this.config.validatorReexecuteDeadlineMs;
-        return new Date(nextSlotTimestampSeconds * 1000 - msNeededForPropagationAndPublishing);
-    }
-    /**
-   * Re-execute the transactions in the proposal and check that the state updates match the header state
-   * @param proposal - The proposal to re-execute
-   */ async reExecuteTransactions(proposal, txs, l1ToL2Messages) {
-        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();
-        const globalVariables = GlobalVariables.from({
-            ...proposal.payload.header,
-            blockNumber: proposal.blockNumber,
-            timestamp: header.timestamp,
-            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)
-        });
-        this.log.verbose(`Transaction re-execution complete`);
-        const numFailedTxs = failedTxs.length;
-        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();
-        }
-        // This function will throw an error if state updates do not match
-        if (!block.archive.root.equals(proposal.archive)) {
-            this.metrics.recordFailedReexecution(proposal);
-            throw new ReExStateMismatchError(proposal.archive, block.archive.root, proposal.payload.stateReference, block.header.state);
-        }
-        this.metrics.recordReex(timer.ms(), txs.length, block.header.totalManaUsed.toNumber() / 1e6);
+        return this.createBlockAttestationsFromProposal(proposal, attestors);
     }
     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.
@@ -324,33 +667,54 @@ const MAX_PROPOSERS_OF_INVALID_BLOCKS = 1000;
                 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(blockNumber, header, archive, stateReference, txs, proposerAddress, options);
+    // 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);
     }
+    async signAttestationsAndSigners(attestationsAndSigners, proposer) {
+        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.doAttestToProposal(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`);
@@ -361,11 +725,28 @@ const MAX_PROPOSERS_OF_INVALID_BLOCKS = 1000;
         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()}`);
                 }
             }
@@ -378,11 +759,11 @@ const MAX_PROPOSERS_OF_INVALID_BLOCKS = 1000;
                 this.log.error(`Timeout ${deadline.toISOString()} waiting for ${required} attestations for slot ${slot}`);
                 throw new AttestationTimeoutError(attestations.length, required, slot);
             }
-            this.log.debug(`Collected ${attestations.length} attestations so far`);
+            this.log.debug(`Collected ${attestations.length} of ${required} attestations so far`);
             await sleep(this.config.attestationPollingIntervalMs);
         }
     }
-    async doAttestToProposal(proposal, attestors = []) {
+    async createBlockAttestationsFromProposal(proposal, attestors = []) {
         const attestations = await this.validationService.attestToProposal(proposal, attestors);
         await this.p2pClient.addAttestations(attestations);
         return attestations;
@@ -405,4 +786,4 @@ const MAX_PROPOSERS_OF_INVALID_BLOCKS = 1000;
         const authResponse = new AuthResponse(statusMessage, signature);
         return authResponse.toBuffer();
     }
-} // Conversion helpers moved into NodeKeystoreAdapter.
+}