@aztec/validator-client 0.0.0-test.1 → 0.0.1-commit.001888fc

package/dest/checkpoint_builder.d.ts

@@ -0,0 +1,77 @@
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type LoggerBindings } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
+import { LightweightCheckpointBuilder } from '@aztec/prover-client/light';
+import { PublicProcessor } from '@aztec/simulator/server';
+import { L2Block } from '@aztec/stdlib/block';
+import { Checkpoint } from '@aztec/stdlib/checkpoint';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import { type BuildBlockInCheckpointResult, type FullNodeBlockBuilderConfig, type ICheckpointBlockBuilder, type ICheckpointsBuilder, type MerkleTreeWriteOperations, type PublicProcessorLimits, type WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import { type DebugLogStore } from '@aztec/stdlib/logs';
+import { type CheckpointGlobalVariables, GlobalVariables, StateReference, Tx } from '@aztec/stdlib/tx';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+export type { BuildBlockInCheckpointResult } from '@aztec/stdlib/interfaces/server';
+/**
+ * Builder for a single checkpoint. Handles building blocks within the checkpoint
+ * and completing it.
+ */
+export declare class CheckpointBuilder implements ICheckpointBlockBuilder {
+    private checkpointBuilder;
+    private fork;
+    private config;
+    private contractDataSource;
+    private dateProvider;
+    private telemetryClient;
+    private debugLogStore;
+    private log;
+    constructor(checkpointBuilder: LightweightCheckpointBuilder, fork: MerkleTreeWriteOperations, config: FullNodeBlockBuilderConfig, contractDataSource: ContractDataSource, dateProvider: DateProvider, telemetryClient: TelemetryClient, bindings?: LoggerBindings, debugLogStore?: DebugLogStore);
+    getConstantData(): CheckpointGlobalVariables;
+    /**
+     * Builds a single block within this checkpoint.
+     * Automatically caps gas and blob field limits based on checkpoint-level budgets and prior blocks.
+     */
+    buildBlock(pendingTxs: Iterable<Tx> | AsyncIterable<Tx>, blockNumber: BlockNumber, timestamp: bigint, opts?: PublicProcessorLimits & {
+        expectedEndState?: StateReference;
+        minValidTxs?: number;
+    }): Promise<BuildBlockInCheckpointResult>;
+    /** Completes the checkpoint and returns it. */
+    completeCheckpoint(): Promise<Checkpoint>;
+    /** Gets the checkpoint currently in progress. */
+    getCheckpoint(): Promise<Checkpoint>;
+    /**
+     * Caps per-block gas and blob field limits by remaining checkpoint-level budgets.
+     * Computes remaining L2 gas (mana), DA gas, and blob fields from blocks already added to the checkpoint,
+     * then returns opts with maxBlockGas and maxBlobFields capped accordingly.
+     */
+    protected capLimitsByCheckpointBudgets(opts: PublicProcessorLimits): Pick<PublicProcessorLimits, 'maxBlockGas' | 'maxBlobFields' | 'maxTransactions'>;
+    protected makeBlockBuilderDeps(globalVariables: GlobalVariables, fork: MerkleTreeWriteOperations): Promise<{
+        processor: PublicProcessor;
+        validator: import("@aztec/stdlib/interfaces/server").PublicProcessorValidator;
+    }>;
+}
+/** Factory for creating checkpoint builders. */
+export declare class FullNodeCheckpointsBuilder implements ICheckpointsBuilder {
+    private config;
+    private worldState;
+    private contractDataSource;
+    private dateProvider;
+    private telemetryClient;
+    private debugLogStore;
+    private log;
+    constructor(config: FullNodeBlockBuilderConfig & Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'>, worldState: WorldStateSynchronizer, contractDataSource: ContractDataSource, dateProvider: DateProvider, telemetryClient?: TelemetryClient, debugLogStore?: DebugLogStore);
+    getConfig(): FullNodeBlockBuilderConfig;
+    updateConfig(config: Partial<FullNodeBlockBuilderConfig>): void;
+    /**
+     * Starts a new checkpoint and returns a CheckpointBuilder to build blocks within it.
+     */
+    startCheckpoint(checkpointNumber: CheckpointNumber, constants: CheckpointGlobalVariables, feeAssetPriceModifier: bigint, l1ToL2Messages: Fr[], previousCheckpointOutHashes: Fr[], fork: MerkleTreeWriteOperations, bindings?: LoggerBindings): Promise<CheckpointBuilder>;
+    /**
+     * Opens a checkpoint, either starting fresh or resuming from existing blocks.
+     */
+    openCheckpoint(checkpointNumber: CheckpointNumber, constants: CheckpointGlobalVariables, feeAssetPriceModifier: bigint, l1ToL2Messages: Fr[], previousCheckpointOutHashes: Fr[], fork: MerkleTreeWriteOperations, existingBlocks?: L2Block[], bindings?: LoggerBindings): Promise<CheckpointBuilder>;
+    /** Returns a fork of the world state at the given block number. */
+    getFork(blockNumber: BlockNumber): Promise<MerkleTreeWriteOperations>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/checkpoint_builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint_builder.d.ts","sourceRoot":"","sources":["../src/checkpoint_builder.ts"],"names":[],"mappings":"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"}

package/dest/checkpoint_builder.js

@@ -0,0 +1,250 @@
+import { NUM_CHECKPOINT_END_MARKER_FIELDS, getNumBlockEndBlobFields } from '@aztec/blob-lib/encoding';
+import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB, MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT } from '@aztec/constants';
+import { merge, pick, sum } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+import { bufferToHex } from '@aztec/foundation/string';
+import { elapsed } from '@aztec/foundation/timer';
+import { createTxValidatorForBlockBuilding, getDefaultAllowedSetupFunctions } from '@aztec/p2p/msg_validators';
+import { LightweightCheckpointBuilder } from '@aztec/prover-client/light';
+import { GuardedMerkleTreeOperations, PublicContractsDB, PublicProcessor, createPublicTxSimulatorForBlockBuilding } from '@aztec/simulator/server';
+import { Gas } from '@aztec/stdlib/gas';
+import { FullNodeBlockBuilderConfigKeys, InsufficientValidTxsError } from '@aztec/stdlib/interfaces/server';
+import { NullDebugLogStore } from '@aztec/stdlib/logs';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { GlobalVariables } from '@aztec/stdlib/tx';
+import { getTelemetryClient } from '@aztec/telemetry-client';
+import { ForkCheckpoint } from '@aztec/world-state';
+/**
+ * Builder for a single checkpoint. Handles building blocks within the checkpoint
+ * and completing it.
+ */ export class CheckpointBuilder {
+    checkpointBuilder;
+    fork;
+    config;
+    contractDataSource;
+    dateProvider;
+    telemetryClient;
+    debugLogStore;
+    log;
+    constructor(checkpointBuilder, fork, config, contractDataSource, dateProvider, telemetryClient, bindings, debugLogStore = new NullDebugLogStore()){
+        this.checkpointBuilder = checkpointBuilder;
+        this.fork = fork;
+        this.config = config;
+        this.contractDataSource = contractDataSource;
+        this.dateProvider = dateProvider;
+        this.telemetryClient = telemetryClient;
+        this.debugLogStore = debugLogStore;
+        this.log = createLogger('checkpoint-builder', {
+            ...bindings,
+            instanceId: `checkpoint-${checkpointBuilder.checkpointNumber}`
+        });
+    }
+    getConstantData() {
+        return this.checkpointBuilder.constants;
+    }
+    /**
+   * Builds a single block within this checkpoint.
+   * Automatically caps gas and blob field limits based on checkpoint-level budgets and prior blocks.
+   */ async buildBlock(pendingTxs, blockNumber, timestamp, opts = {}) {
+        const slot = this.checkpointBuilder.constants.slotNumber;
+        this.log.verbose(`Building block ${blockNumber} for slot ${slot} within checkpoint`, {
+            slot,
+            blockNumber,
+            ...opts,
+            currentTime: new Date(this.dateProvider.now())
+        });
+        const constants = this.checkpointBuilder.constants;
+        const globalVariables = GlobalVariables.from({
+            chainId: constants.chainId,
+            version: constants.version,
+            blockNumber,
+            slotNumber: constants.slotNumber,
+            timestamp,
+            coinbase: constants.coinbase,
+            feeRecipient: constants.feeRecipient,
+            gasFees: constants.gasFees
+        });
+        const { processor, validator } = await this.makeBlockBuilderDeps(globalVariables, this.fork);
+        // Cap gas limits amd available blob fields by remaining checkpoint-level budgets
+        const cappedOpts = {
+            ...opts,
+            ...this.capLimitsByCheckpointBudgets(opts)
+        };
+        // We execute all merkle tree operations on a world state fork checkpoint
+        // This enables us to discard all modifications in the event that we fail to successfully process sufficient transactions
+        const forkCheckpoint = await ForkCheckpoint.new(this.fork);
+        try {
+            const [publicProcessorDuration, [processedTxs, failedTxs, usedTxs]] = await elapsed(()=>processor.process(pendingTxs, cappedOpts, validator));
+            // Throw before updating state if we don't have enough valid txs
+            const minValidTxs = opts.minValidTxs ?? 0;
+            if (processedTxs.length < minValidTxs) {
+                throw new InsufficientValidTxsError(processedTxs.length, minValidTxs, failedTxs);
+            }
+            // Commit the fork checkpoint
+            await forkCheckpoint.commit();
+            // Add block to checkpoint
+            const { block } = await this.checkpointBuilder.addBlock(globalVariables, processedTxs, {
+                expectedEndState: opts.expectedEndState
+            });
+            this.log.debug('Built block within checkpoint', {
+                header: block.header.toInspect(),
+                processedTxs: processedTxs.map((tx)=>tx.hash.toString()),
+                failedTxs: failedTxs.map((tx)=>tx.tx.txHash.toString())
+            });
+            return {
+                block,
+                publicProcessorDuration,
+                numTxs: processedTxs.length,
+                failedTxs,
+                usedTxs
+            };
+        } catch (err) {
+            // If we reached the point of committing the checkpoint, this does nothing
+            // Otherwise it reverts any changes made to the fork for this failed block
+            await forkCheckpoint.revert();
+            throw err;
+        }
+    }
+    /** Completes the checkpoint and returns it. */ async completeCheckpoint() {
+        const checkpoint = await this.checkpointBuilder.completeCheckpoint();
+        this.log.verbose(`Completed checkpoint ${checkpoint.number}`, {
+            checkpointNumber: checkpoint.number,
+            numBlocks: checkpoint.blocks.length,
+            archiveRoot: checkpoint.archive.root.toString()
+        });
+        return checkpoint;
+    }
+    /** Gets the checkpoint currently in progress. */ getCheckpoint() {
+        return this.checkpointBuilder.clone().completeCheckpoint();
+    }
+    /**
+   * Caps per-block gas and blob field limits by remaining checkpoint-level budgets.
+   * Computes remaining L2 gas (mana), DA gas, and blob fields from blocks already added to the checkpoint,
+   * then returns opts with maxBlockGas and maxBlobFields capped accordingly.
+   */ capLimitsByCheckpointBudgets(opts) {
+        const existingBlocks = this.checkpointBuilder.getBlocks();
+        // Remaining L2 gas (mana)
+        // IMPORTANT: This assumes mana is computed solely based on L2 gas used in transactions.
+        // This may change in the future.
+        const usedMana = sum(existingBlocks.map((b)=>b.header.totalManaUsed.toNumber()));
+        const remainingMana = this.config.rollupManaLimit - usedMana;
+        // Remaining DA gas
+        const usedDAGas = sum(existingBlocks.map((b)=>b.computeDAGasUsed())) ?? 0;
+        const remainingDAGas = MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT - usedDAGas;
+        // Remaining blob fields (block blob fields include both tx data and block-end overhead)
+        const usedBlobFields = sum(existingBlocks.map((b)=>b.toBlobFields().length));
+        const totalBlobCapacity = BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB - NUM_CHECKPOINT_END_MARKER_FIELDS;
+        const isFirstBlock = existingBlocks.length === 0;
+        const blockEndOverhead = getNumBlockEndBlobFields(isFirstBlock);
+        const maxBlobFieldsForTxs = totalBlobCapacity - usedBlobFields - blockEndOverhead;
+        // When redistributeCheckpointBudget is enabled (default), compute a fair share of remaining budget
+        // across remaining blocks scaled by the multiplier, instead of letting one block consume it all.
+        const redistribute = this.config.redistributeCheckpointBudget !== false;
+        const remainingBlocks = Math.max(1, (this.config.maxBlocksPerCheckpoint ?? 1) - existingBlocks.length);
+        const multiplier = this.config.perBlockAllocationMultiplier ?? 1.2;
+        // Cap L2 gas by remaining checkpoint mana (with fair share when redistributing)
+        const fairShareL2 = redistribute ? Math.ceil(remainingMana / remainingBlocks * multiplier) : Infinity;
+        const cappedL2Gas = Math.min(opts.maxBlockGas?.l2Gas ?? Infinity, fairShareL2, remainingMana);
+        // Cap DA gas by remaining checkpoint DA gas budget (with fair share when redistributing)
+        const fairShareDA = redistribute ? Math.ceil(remainingDAGas / remainingBlocks * multiplier) : Infinity;
+        const cappedDAGas = Math.min(opts.maxBlockGas?.daGas ?? remainingDAGas, fairShareDA, remainingDAGas);
+        // Cap blob fields by remaining checkpoint blob capacity (with fair share when redistributing)
+        const fairShareBlobs = redistribute ? Math.ceil(maxBlobFieldsForTxs / remainingBlocks * multiplier) : Infinity;
+        const cappedBlobFields = Math.min(opts.maxBlobFields ?? Infinity, fairShareBlobs, maxBlobFieldsForTxs);
+        // Cap transaction count by remaining checkpoint tx budget (with fair share when redistributing)
+        let cappedMaxTransactions;
+        if (this.config.maxTxsPerCheckpoint !== undefined) {
+            const usedTxs = sum(existingBlocks.map((b)=>b.body.txEffects.length));
+            const remainingTxs = Math.max(0, this.config.maxTxsPerCheckpoint - usedTxs);
+            const fairShareTxs = redistribute ? Math.ceil(remainingTxs / remainingBlocks * multiplier) : Infinity;
+            cappedMaxTransactions = Math.min(opts.maxTransactions ?? Infinity, fairShareTxs, remainingTxs);
+        } else {
+            cappedMaxTransactions = opts.maxTransactions;
+        }
+        return {
+            maxBlockGas: new Gas(cappedDAGas, cappedL2Gas),
+            maxBlobFields: cappedBlobFields,
+            maxTransactions: cappedMaxTransactions
+        };
+    }
+    async makeBlockBuilderDeps(globalVariables, fork) {
+        const txPublicSetupAllowList = [
+            ...await getDefaultAllowedSetupFunctions(),
+            ...this.config.txPublicSetupAllowListExtend ?? []
+        ];
+        const contractsDB = new PublicContractsDB(this.contractDataSource, this.log.getBindings());
+        const guardedFork = new GuardedMerkleTreeOperations(fork);
+        const collectDebugLogs = this.debugLogStore.isEnabled;
+        const bindings = this.log.getBindings();
+        const publicTxSimulator = createPublicTxSimulatorForBlockBuilding(guardedFork, contractsDB, globalVariables, this.telemetryClient, bindings, collectDebugLogs);
+        const processor = new PublicProcessor(globalVariables, guardedFork, contractsDB, publicTxSimulator, this.dateProvider, this.telemetryClient, createLogger('simulator:public-processor', bindings), this.config, this.debugLogStore);
+        const validator = createTxValidatorForBlockBuilding(fork, this.contractDataSource, globalVariables, txPublicSetupAllowList, this.log.getBindings());
+        return {
+            processor,
+            validator
+        };
+    }
+}
+/** Factory for creating checkpoint builders. */ export class FullNodeCheckpointsBuilder {
+    config;
+    worldState;
+    contractDataSource;
+    dateProvider;
+    telemetryClient;
+    debugLogStore;
+    log;
+    constructor(config, worldState, contractDataSource, dateProvider, telemetryClient = getTelemetryClient(), debugLogStore = new NullDebugLogStore()){
+        this.config = config;
+        this.worldState = worldState;
+        this.contractDataSource = contractDataSource;
+        this.dateProvider = dateProvider;
+        this.telemetryClient = telemetryClient;
+        this.debugLogStore = debugLogStore;
+        this.log = createLogger('checkpoint-builder');
+    }
+    getConfig() {
+        return this.config;
+    }
+    updateConfig(config) {
+        this.config = merge(this.config, pick(config, ...FullNodeBlockBuilderConfigKeys));
+    }
+    /**
+   * Starts a new checkpoint and returns a CheckpointBuilder to build blocks within it.
+   */ async startCheckpoint(checkpointNumber, constants, feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, fork, bindings) {
+        const stateReference = await fork.getStateReference();
+        const archiveTree = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
+        this.log.verbose(`Building new checkpoint ${checkpointNumber}`, {
+            checkpointNumber,
+            msgCount: l1ToL2Messages.length,
+            initialStateReference: stateReference.toInspect(),
+            initialArchiveRoot: bufferToHex(archiveTree.root),
+            constants,
+            feeAssetPriceModifier
+        });
+        const lightweightBuilder = await LightweightCheckpointBuilder.startNewCheckpoint(checkpointNumber, constants, l1ToL2Messages, previousCheckpointOutHashes, fork, bindings, feeAssetPriceModifier);
+        return new CheckpointBuilder(lightweightBuilder, fork, this.config, this.contractDataSource, this.dateProvider, this.telemetryClient, bindings, this.debugLogStore);
+    }
+    /**
+   * Opens a checkpoint, either starting fresh or resuming from existing blocks.
+   */ async openCheckpoint(checkpointNumber, constants, feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, fork, existingBlocks = [], bindings) {
+        const stateReference = await fork.getStateReference();
+        const archiveTree = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
+        if (existingBlocks.length === 0) {
+            return this.startCheckpoint(checkpointNumber, constants, feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, fork, bindings);
+        }
+        this.log.verbose(`Resuming checkpoint ${checkpointNumber} with ${existingBlocks.length} existing blocks`, {
+            checkpointNumber,
+            msgCount: l1ToL2Messages.length,
+            existingBlockCount: existingBlocks.length,
+            initialStateReference: stateReference.toInspect(),
+            initialArchiveRoot: bufferToHex(archiveTree.root),
+            constants,
+            feeAssetPriceModifier
+        });
+        const lightweightBuilder = await LightweightCheckpointBuilder.resumeCheckpoint(checkpointNumber, constants, feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, fork, existingBlocks, bindings);
+        return new CheckpointBuilder(lightweightBuilder, fork, this.config, this.contractDataSource, this.dateProvider, this.telemetryClient, bindings, this.debugLogStore);
+    }
+    /** Returns a fork of the world state at the given block number. */ getFork(blockNumber) {
+        return this.worldState.fork(blockNumber);
+    }
+}

package/dest/config.d.ts

@@ -1,17 +1,6 @@
 import { type ConfigMappingsType } from '@aztec/foundation/config';
-/**
- * The Validator Configuration
- */
-export interface ValidatorClientConfig {
-    /** The private key of the validator participating in attestation duties */
-    validatorPrivateKey?: string;
-    /** Do not run the validator */
-    disableValidator: boolean;
-    /** Interval between polling for new attestations from peers */
-    attestationPollingIntervalMs: number;
-    /** Re-execute transactions before attesting */
-    validatorReexecute: boolean;
-}
+import type { ValidatorClientConfig } from '@aztec/stdlib/interfaces/server';
+export type { ValidatorClientConfig };
 export declare const validatorClientConfigMappings: ConfigMappingsType<ValidatorClientConfig>;
 /**
  * Returns the prover configuration from the environment variables.
@@ -19,4 +8,4 @@ export declare const validatorClientConfigMappings: ConfigMappingsType<Validator
  * @returns The validator configuration.
  */
 export declare function getProverEnvVars(): ValidatorClientConfig;
-//# sourceMappingURL=config.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxLQUFLLGtCQUFrQixFQUt4QixNQUFNLDBCQUEwQixDQUFDO0FBR2xDLE9BQU8sS0FBSyxFQUFFLHFCQUFxQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFFN0UsWUFBWSxFQUFFLHFCQUFxQixFQUFFLENBQUM7QUFFdEMsZUFBTyxNQUFNLDZCQUE2QixFQUFFLGtCQUFrQixDQUFDLHFCQUFxQixDQXdGbkYsQ0FBQztBQUVGOzs7O0dBSUc7QUFDSCx3QkFBZ0IsZ0JBQWdCLElBQUkscUJBQXFCLENBRXhEIn0=

package/dest/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,kBAAkB,EAIxB,MAAM,0BAA0B,CAAC;AAElC;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,2EAA2E;IAC3E,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAE7B,+BAA+B;IAC/B,gBAAgB,EAAE,OAAO,CAAC;IAE1B,+DAA+D;IAC/D,4BAA4B,EAAE,MAAM,CAAC;IAErC,+CAA+C;IAC/C,kBAAkB,EAAE,OAAO,CAAC;CAC7B;AAED,eAAO,MAAM,6BAA6B,EAAE,kBAAkB,CAAC,qBAAqB,CAqBnF,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,qBAAqB,CAExD"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EAKxB,MAAM,0BAA0B,CAAC;AAGlC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAE7E,YAAY,EAAE,qBAAqB,EAAE,CAAC;AAEtC,eAAO,MAAM,6BAA6B,EAAE,kBAAkB,CAAC,qBAAqB,CAwFnF,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,qBAAqB,CAExD"}

package/dest/config.js

@@ -1,15 +1,30 @@
-import { NULL_KEY } from '@aztec/ethereum';
-import { booleanConfigHelper, getConfigFromMappings, numberConfigHelper } from '@aztec/foundation/config';
+import { booleanConfigHelper, getConfigFromMappings, numberConfigHelper, secretValueConfigHelper } from '@aztec/foundation/config';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { localSignerConfigMappings, validatorHASignerConfigMappings } from '@aztec/stdlib/ha-signing';
 export const validatorClientConfigMappings = {
-    validatorPrivateKey: {
-        env: 'VALIDATOR_PRIVATE_KEY',
-        parseEnv: (val)=>val ? `0x${val.replace('0x', '')}` : NULL_KEY,
-        description: 'The private key of the validator participating in attestation duties'
+    validatorPrivateKeys: {
+        env: 'VALIDATOR_PRIVATE_KEYS',
+        description: 'List of private keys of the validators participating in attestation duties',
+        ...secretValueConfigHelper((val)=>val ? val.split(',').map((key)=>`0x${key.replace('0x', '')}`) : []),
+        fallback: [
+            'VALIDATOR_PRIVATE_KEY'
+        ]
+    },
+    validatorAddresses: {
+        env: 'VALIDATOR_ADDRESSES',
+        description: 'List of addresses of the validators to use with remote signers',
+        parseEnv: (val)=>val.split(',').filter((address)=>address && address.trim().length > 0).map((address)=>EthAddress.fromString(address.trim())),
+        defaultValue: []
     },
     disableValidator: {
         env: 'VALIDATOR_DISABLED',
         description: 'Do not run the validator',
-        ...booleanConfigHelper()
+        ...booleanConfigHelper(false)
+    },
+    disabledValidators: {
+        description: 'Temporarily disable these specific validator addresses',
+        parseEnv: (val)=>val.split(',').filter((address)=>address && address.trim().length > 0).map((address)=>EthAddress.fromString(address.trim())),
+        defaultValue: []
     },
     attestationPollingIntervalMs: {
         env: 'VALIDATOR_ATTESTATIONS_POLLING_INTERVAL_MS',
@@ -20,7 +35,50 @@ export const validatorClientConfigMappings = {
         env: 'VALIDATOR_REEXECUTE',
         description: 'Re-execute transactions before attesting',
         ...booleanConfigHelper(true)
-    }
+    },
+    alwaysReexecuteBlockProposals: {
+        description: 'Whether to always reexecute block proposals, even for non-validator nodes (useful for monitoring network status).',
+        defaultValue: true
+    },
+    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)
+    },
+    skipCheckpointProposalValidation: {
+        description: 'Skip checkpoint proposal validation and always attest (default: false)',
+        defaultValue: false
+    },
+    skipPushProposedBlocksToArchiver: {
+        description: 'Skip pushing re-executed blocks to archiver (default: false)',
+        defaultValue: false
+    },
+    attestToEquivocatedProposals: {
+        description: 'Agree to attest to equivocated checkpoint proposals (for testing purposes only)',
+        ...booleanConfigHelper(false)
+    },
+    validateMaxL2BlockGas: {
+        env: 'VALIDATOR_MAX_L2_BLOCK_GAS',
+        description: 'Maximum L2 block gas for validation. Proposals exceeding this limit are rejected.',
+        parseEnv: (val)=>val ? parseInt(val, 10) : undefined
+    },
+    validateMaxDABlockGas: {
+        env: 'VALIDATOR_MAX_DA_BLOCK_GAS',
+        description: 'Maximum DA block gas for validation. Proposals exceeding this limit are rejected.',
+        parseEnv: (val)=>val ? parseInt(val, 10) : undefined
+    },
+    validateMaxTxsPerBlock: {
+        env: 'VALIDATOR_MAX_TX_PER_BLOCK',
+        description: 'Maximum transactions per block for validation. Proposals exceeding this limit are rejected.',
+        parseEnv: (val)=>val ? parseInt(val, 10) : undefined
+    },
+    validateMaxTxsPerCheckpoint: {
+        env: 'VALIDATOR_MAX_TX_PER_CHECKPOINT',
+        description: 'Maximum transactions per checkpoint for validation. Proposals exceeding this limit are rejected.',
+        parseEnv: (val)=>val ? parseInt(val, 10) : undefined
+    },
+    ...localSignerConfigMappings,
+    ...validatorHASignerConfigMappings
 };
 /**
  * Returns the prover configuration from the environment variables.

package/dest/duties/validation_service.d.ts

@@ -1,29 +1,66 @@
-import type { Fr } from '@aztec/foundation/fields';
-import { BlockAttestation, BlockProposal } from '@aztec/stdlib/p2p';
-import type { BlockHeader, TxHash } from '@aztec/stdlib/tx';
+import { BlockNumber, type CheckpointNumber, IndexWithinCheckpoint, type SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { Signature } from '@aztec/foundation/eth-signature';
+import type { CommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
+import type { CreateCheckpointProposalLastBlockData } from '@aztec/stdlib/interfaces/server';
+import { BlockProposal, type BlockProposalOptions, CheckpointAttestation, CheckpointProposal, type CheckpointProposalCore, type CheckpointProposalOptions } from '@aztec/stdlib/p2p';
+import type { CheckpointHeader } from '@aztec/stdlib/rollup';
+import type { BlockHeader, Tx } from '@aztec/stdlib/tx';
 import type { ValidatorKeyStore } from '../key_store/interface.js';
 export declare class ValidationService {
     private keyStore;
-    constructor(keyStore: ValidatorKeyStore);
+    private log;
+    constructor(keyStore: ValidatorKeyStore, log?: import("@aztec/foundation/log").Logger);
     /**
      * Create a block proposal with the given header, archive, and transactions
      *
-     * @param header - The block header
+     * @param blockHeader - The block header
+     * @param blockIndexWithinCheckpoint - The block index within checkpoint for HA signing context
+     * @param inHash - Hash of L1 to L2 messages for this checkpoint
      * @param archive - The archive of the current block
-     * @param txs - TxHash[] ordered list of transactions
+     * @param txs - Ordered list of transactions (Tx[])
+     * @param proposerAttesterAddress - The address of the proposer/attester, or undefined
+     * @param options - Block proposal options (including broadcastInvalidBlockProposal for testing)
      *
-     * @returns A block proposal signing the above information (not the current implementation!!!)
+     * @returns A block proposal signing the above information
+     * @throws DutyAlreadySignedError if HA signer indicates duty already signed by another node
+     * @throws SlashingProtectionError if attempting to sign different data for same slot
      */
-    createBlockProposal(header: BlockHeader, archive: Fr, txs: TxHash[]): Promise<BlockProposal>;
+    createBlockProposal(blockHeader: BlockHeader, blockIndexWithinCheckpoint: IndexWithinCheckpoint, inHash: Fr, archive: Fr, txs: Tx[], proposerAttesterAddress: EthAddress | undefined, options: BlockProposalOptions): Promise<BlockProposal>;
     /**
-     * Attest to the given block proposal constructed by the current sequencer
+     * Create a checkpoint proposal with the last block header and checkpoint header
+     *
+     * @param checkpointHeader - The checkpoint header containing aggregated data
+     * @param archive - The archive of the checkpoint
+     * @param lastBlockInfo - Info about the last block (header, index, txs) or undefined
+     * @param proposerAttesterAddress - The address of the proposer
+     * @param options - Checkpoint proposal options
+     *
+     * @returns A checkpoint proposal signing the above information
+     */
+    createCheckpointProposal(checkpointHeader: CheckpointHeader, archive: Fr, feeAssetPriceModifier: bigint, lastBlockInfo: CreateCheckpointProposalLastBlockData | undefined, proposerAttesterAddress: EthAddress | undefined, options: CheckpointProposalOptions): Promise<CheckpointProposal>;
+    /**
+     * Attest with selection of validators to the given checkpoint proposal
      *
      * NOTE: This is just a blind signing.
      *       We assume that the proposal is valid and DA guarantees have been checked previously.
      *
-     * @param proposal - The proposal to attest to
-     * @returns attestation
+     * @param proposal - The checkpoint proposal (core version without lastBlock) to attest to
+     * @param attestors - The validators to attest with
+     * @returns checkpoint attestations
+     */
+    attestToCheckpointProposal(proposal: CheckpointProposalCore, attestors: EthAddress[]): Promise<CheckpointAttestation[]>;
+    /**
+     * Sign attestations and signers payload
+     * @param attestationsAndSigners - The attestations and signers to sign
+     * @param proposer - The proposer address to sign with
+     * @param slot - The slot number for HA signing context
+     * @param blockNumber - The block or checkpoint number for HA signing context
+     * @returns signature
+     * @throws DutyAlreadySignedError if already signed by another HA node
+     * @throws SlashingProtectionError if attempting to sign different data for same slot
      */
-    attestToProposal(proposal: BlockProposal): Promise<BlockAttestation>;
+    signAttestationsAndSigners(attestationsAndSigners: CommitteeAttestationsAndSigners, proposer: EthAddress, slot: SlotNumber, blockNumber: BlockNumber | CheckpointNumber): Promise<Signature>;
 }
-//# sourceMappingURL=validation_service.d.ts.map
+//# sourceMappingURL=data:application/json;base64,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

package/dest/duties/validation_service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation_service.d.ts","sourceRoot":"","sources":["../../src/duties/validation_service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAA8C,MAAM,mBAAmB,CAAC;AAChH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAEnE,qBAAa,iBAAiB;IAChB,OAAO,CAAC,QAAQ;gBAAR,QAAQ,EAAE,iBAAiB;IAE/C;;;;;;;;OAQG;IACH,mBAAmB,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,aAAa,CAAC;IAM5F;;;;;;;;OAQG;IACG,gBAAgB,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAS3E"}
+{"version":3,"file":"validation_service.d.ts","sourceRoot":"","sources":["../../src/duties/validation_service.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,KAAK,gBAAgB,EACrB,qBAAqB,EACrB,KAAK,UAAU,EAChB,MAAM,iCAAiC,CAAC;AAGzC,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAEjE,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,KAAK,EAAE,qCAAqC,EAAE,MAAM,iCAAiC,CAAC;AAC7F,OAAO,EACL,aAAa,EACb,KAAK,oBAAoB,EACzB,qBAAqB,EACrB,kBAAkB,EAClB,KAAK,sBAAsB,EAC3B,KAAK,yBAAyB,EAG/B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAIxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAEnE,qBAAa,iBAAiB;IAE1B,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,GAAG;IAFb,YACU,QAAQ,EAAE,iBAAiB,EAC3B,GAAG,yCAA+C,EACxD;IAEJ;;;;;;;;;;;;;;OAcG;IACI,mBAAmB,CACxB,WAAW,EAAE,WAAW,EACxB,0BAA0B,EAAE,qBAAqB,EACjD,MAAM,EAAE,EAAE,EACV,OAAO,EAAE,EAAE,EACX,GAAG,EAAE,EAAE,EAAE,EACT,uBAAuB,EAAE,UAAU,GAAG,SAAS,EAC/C,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,aAAa,CAAC,CAqBxB;IAED;;;;;;;;;;OAUG;IACI,wBAAwB,CAC7B,gBAAgB,EAAE,gBAAgB,EAClC,OAAO,EAAE,EAAE,EACX,qBAAqB,EAAE,MAAM,EAC7B,aAAa,EAAE,qCAAqC,GAAG,SAAS,EAChE,uBAAuB,EAAE,UAAU,GAAG,SAAS,EAC/C,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,kBAAkB,CAAC,CA4B7B;IAED;;;;;;;;;OASG;IACG,0BAA0B,CAC9B,QAAQ,EAAE,sBAAsB,EAChC,SAAS,EAAE,UAAU,EAAE,GACtB,OAAO,CAAC,qBAAqB,EAAE,CAAC,CA8ClC;IAED;;;;;;;;;OASG;IACH,0BAA0B,CACxB,sBAAsB,EAAE,+BAA+B,EACvD,QAAQ,EAAE,UAAU,EACpB,IAAI,EAAE,UAAU,EAChB,WAAW,EAAE,WAAW,GAAG,gBAAgB,GAC1C,OAAO,CAAC,SAAS,CAAC,CAWpB;CACF"}