@aztec-labs/validator-client 6.0.0-nightly.20260829

package/dest/checkpoint_builder.js

@@ -0,0 +1,272 @@
+import { NUM_CHECKPOINT_END_MARKER_FIELDS, getNumBlockEndBlobFields } from '@aztec-labs/blob-lib/encoding';
+import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB, MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT } from '@aztec-labs/constants';
+import { merge, pick, sum } from '@aztec-labs/foundation/collection';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { bufferToHex } from '@aztec-labs/foundation/string';
+import { elapsed } from '@aztec-labs/foundation/timer';
+import { createTxValidatorForBlockBuilding, getDefaultAllowedSetupFunctions } from '@aztec-labs/p2p/msg_validators';
+import { LightweightCheckpointBuilder } from '@aztec-labs/prover-client/light';
+import { GuardedMerkleTreeOperations, PublicContractsDB, PublicProcessor, createPublicTxSimulatorForBlockBuilding } from '@aztec-labs/simulator/server';
+import { Gas } from '@aztec-labs/stdlib/gas';
+import { FullNodeBlockBuilderConfigKeys, InsufficientValidTxsError } from '@aztec-labs/stdlib/interfaces/server';
+import { NullDebugLogStore } from '@aztec-labs/stdlib/logs';
+import { MerkleTreeId } from '@aztec-labs/stdlib/trees';
+import { GlobalVariables } from '@aztec-labs/stdlib/tx';
+import { getTelemetryClient } from '@aztec-labs/telemetry-client';
+import { ForkCheckpoint } from '@aztec-labs/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;
+    avmSimulator;
+    debugLogStore;
+    log;
+    /** Persistent contracts DB shared across all blocks in this checkpoint. */ contractsDB;
+    constructor(checkpointBuilder, fork, config, contractDataSource, dateProvider, telemetryClient, avmSimulator, bindings, debugLogStore = new NullDebugLogStore()){
+        this.checkpointBuilder = checkpointBuilder;
+        this.fork = fork;
+        this.config = config;
+        this.contractDataSource = contractDataSource;
+        this.dateProvider = dateProvider;
+        this.telemetryClient = telemetryClient;
+        this.avmSimulator = avmSimulator;
+        this.debugLogStore = debugLogStore;
+        this.log = createLogger('checkpoint-builder', {
+            ...bindings,
+            instanceId: `checkpoint-${checkpointBuilder.checkpointNumber}`
+        });
+        this.contractsDB = new PublicContractsDB(this.contractDataSource, this.log.getBindings());
+    }
+    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)
+        };
+        // Create a block-level checkpoint on the contracts DB so we can roll back on failure
+        this.contractsDB.createCheckpoint();
+        // 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, inserting this block's streaming L1-to-L2 message bundle (if any) into the fork.
+            const { block } = await this.checkpointBuilder.addBlock(globalVariables, processedTxs, opts.l1ToL2Messages ?? [], {
+                expectedEndState: opts.expectedEndState
+            });
+            this.contractsDB.commitCheckpoint();
+            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) {
+            // Revert all changes to contracts db
+            this.contractsDB.revertCheckpoint();
+            // 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.
+   * When building a proposal (isBuildingProposal=true), computes a fair share of remaining budget
+   * across remaining blocks scaled by the multiplier. When validating, only caps by per-block limit
+   * and remaining checkpoint budget (no redistribution or multiplier).
+   */ 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 blockEndOverhead = getNumBlockEndBlobFields();
+        const maxBlobFieldsForTxs = totalBlobCapacity - usedBlobFields - blockEndOverhead;
+        // Remaining txs
+        const usedTxs = sum(existingBlocks.map((b)=>b.body.txEffects.length));
+        const remainingTxs = Math.max(0, (this.config.maxTxsPerCheckpoint ?? Infinity) - usedTxs);
+        // Cap by per-block limit + remaining checkpoint budget
+        let cappedL2Gas = Math.min(opts.maxBlockGas?.l2Gas ?? Infinity, remainingMana);
+        let cappedDAGas = Math.min(opts.maxBlockGas?.daGas ?? Infinity, remainingDAGas);
+        let cappedBlobFields = Math.min(opts.maxBlobFields ?? Infinity, maxBlobFieldsForTxs);
+        let cappedMaxTransactions = Math.min(opts.maxTransactions ?? Infinity, remainingTxs);
+        // Proposer mode: further cap by fair share of remaining budget across remaining blocks
+        if (opts.isBuildingProposal) {
+            const remainingBlocks = Math.max(1, opts.maxBlocksPerCheckpoint - existingBlocks.length);
+            const multiplier = opts.perBlockAllocationMultiplier;
+            // DA gas and blob fields use a higher multiplier so the largest contract class deploy fits a block.
+            const daMultiplier = opts.perBlockDAAllocationMultiplier ?? multiplier;
+            cappedL2Gas = Math.min(cappedL2Gas, Math.ceil(remainingMana / remainingBlocks * multiplier));
+            cappedDAGas = Math.min(cappedDAGas, Math.ceil(remainingDAGas / remainingBlocks * daMultiplier));
+            cappedBlobFields = Math.min(cappedBlobFields, Math.ceil(maxBlobFieldsForTxs / remainingBlocks * daMultiplier));
+            cappedMaxTransactions = Math.min(cappedMaxTransactions, Math.ceil(remainingTxs / remainingBlocks * multiplier));
+        }
+        return {
+            maxBlockGas: new Gas(cappedDAGas, cappedL2Gas),
+            maxBlobFields: cappedBlobFields,
+            maxTransactions: Number.isFinite(cappedMaxTransactions) ? cappedMaxTransactions : undefined
+        };
+    }
+    async makeBlockBuilderDeps(globalVariables, fork) {
+        const txPublicSetupAllowList = [
+            ...await getDefaultAllowedSetupFunctions(),
+            ...this.config.txPublicSetupAllowListExtend ?? []
+        ];
+        const contractsDB = this.contractsDB;
+        const guardedFork = new GuardedMerkleTreeOperations(fork);
+        const bindings = this.log.getBindings();
+        // Extract the WSDB fork ID so the C++ AVM can modify the same fork in-place; the simulator reads
+        // contract data from `contractsDB`, scoped to this fork for the duration of each simulation.
+        const wsdbForkId = fork.getRevision().forkId;
+        const publicTxSimulator = createPublicTxSimulatorForBlockBuilding(this.avmSimulator, globalVariables, contractsDB, wsdbForkId, this.telemetryClient, bindings, this.debugLogStore?.isEnabled ?? false);
+        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;
+    avmSimulator;
+    telemetryClient;
+    debugLogStore;
+    log;
+    constructor(config, worldState, contractDataSource, dateProvider, avmSimulator, telemetryClient = getTelemetryClient(), debugLogStore = new NullDebugLogStore()){
+        this.config = config;
+        this.worldState = worldState;
+        this.contractDataSource = contractDataSource;
+        this.dateProvider = dateProvider;
+        this.avmSimulator = avmSimulator;
+        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, previousCheckpointOutHashes, previousInboxRollingHash, fork, bindings) {
+        const stateReference = await fork.getStateReference();
+        const archiveTree = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
+        this.log.verbose(`Building new checkpoint ${checkpointNumber}`, {
+            checkpointNumber,
+            initialStateReference: stateReference.toInspect(),
+            initialArchiveRoot: bufferToHex(archiveTree.root),
+            constants,
+            feeAssetPriceModifier
+        });
+        const lightweightBuilder = LightweightCheckpointBuilder.startNewCheckpoint(checkpointNumber, constants, previousCheckpointOutHashes, previousInboxRollingHash, fork, bindings, feeAssetPriceModifier);
+        return new CheckpointBuilder(lightweightBuilder, fork, this.config, this.contractDataSource, this.dateProvider, this.telemetryClient, this.avmSimulator, bindings, this.debugLogStore);
+    }
+    /**
+   * Opens a checkpoint, either starting fresh or resuming from existing blocks.
+   * @param l1ToL2Messages - Messages the existing blocks already consumed, which seed the resumed checkpoint's
+   * rolling hash. Must be empty when starting fresh: a fresh checkpoint takes its messages per block, via
+   * `buildBlock`.
+   */ async openCheckpoint(checkpointNumber, constants, feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, previousInboxRollingHash, fork, existingBlocks = [], bindings) {
+        const stateReference = await fork.getStateReference();
+        const archiveTree = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
+        if (existingBlocks.length === 0) {
+            if (l1ToL2Messages.length > 0) {
+                throw new Error(`Cannot open checkpoint ${checkpointNumber} with ${l1ToL2Messages.length} messages and no existing blocks: ` + `a fresh checkpoint consumes its messages per block`);
+            }
+            return this.startCheckpoint(checkpointNumber, constants, feeAssetPriceModifier, previousCheckpointOutHashes, previousInboxRollingHash, 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, previousInboxRollingHash, fork, existingBlocks, bindings);
+        return new CheckpointBuilder(lightweightBuilder, fork, this.config, this.contractDataSource, this.dateProvider, this.telemetryClient, this.avmSimulator, bindings, this.debugLogStore);
+    }
+    /**
+   * Syncs world state to the given block number and returns a fork of it at that block.
+   *
+   * Syncing first is required: the block source (archiver) can already hold a block while world state
+   * still trails it, and forking a not-yet-applied block throws a raw "initialize from future block"
+   * tree error. syncImmediate blocks until world state reaches the block, or throws a typed error if it
+   * genuinely cannot. When `blockHash` is provided it is verified against the synced block, triggering a
+   * resync on mismatch (reorg detection).
+   */ async getFork(blockNumber, blockHash) {
+        await this.worldState.syncImmediate(blockNumber, blockHash);
+        return this.worldState.fork(blockNumber);
+    }
+}

package/dest/config.d.ts

@@ -0,0 +1,17 @@
+import { type ConfigMappingsType } from '@aztec-labs/foundation/config';
+import { type SequencerConfig } from '@aztec-labs/stdlib/config';
+import type { ValidatorClientConfig } from '@aztec-labs/stdlib/interfaces/server';
+export type { ValidatorClientConfig };
+/**
+ * Default clock-disparity tolerance (ms) for proposal/attestation receive windows, mirroring the p2p config
+ * default. Used by the validator-client validators when the merged node config does not carry the value.
+ */
+export declare const DEFAULT_MAX_GOSSIP_CLOCK_DISPARITY_MS = 500;
+export declare const validatorClientConfigMappings: ConfigMappingsType<ValidatorClientConfig & Pick<SequencerConfig, 'blockDurationMs'>>;
+/**
+ * Returns the prover configuration from the environment variables.
+ * Note: If an environment variable is not set, the default value is used.
+ * @returns The validator configuration.
+ */
+export declare function getProverEnvVars(): ValidatorClientConfig & Pick<SequencerConfig, 'blockDurationMs'>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxLQUFLLGtCQUFrQixFQU94QixNQUFNLCtCQUErQixDQUFDO0FBRXZDLE9BQU8sRUFBRSxLQUFLLGVBQWUsRUFBaUMsTUFBTSwyQkFBMkIsQ0FBQztBQUVoRyxPQUFPLEtBQUssRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBRWxGLFlBQVksRUFBRSxxQkFBcUIsRUFBRSxDQUFDO0FBRXRDOzs7R0FHRztBQUNILGVBQU8sTUFBTSxxQ0FBcUMsTUFBTSxDQUFDO0FBRXpELGVBQU8sTUFBTSw2QkFBNkIsRUFBRSxrQkFBa0IsQ0FDNUQscUJBQXFCLEdBQUcsSUFBSSxDQUFDLGVBQWUsRUFBRSxpQkFBaUIsQ0FBQyxDQStGakUsQ0FBQztBQUVGOzs7O0dBSUc7QUFDSCx3QkFBZ0IsZ0JBQWdCLElBQUkscUJBQXFCLEdBQUcsSUFBSSxDQUFDLGVBQWUsRUFBRSxpQkFBaUIsQ0FBQyxDQUluRyJ9

package/dest/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EAOxB,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAAE,KAAK,eAAe,EAAiC,MAAM,2BAA2B,CAAC;AAEhG,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;AAElF,YAAY,EAAE,qBAAqB,EAAE,CAAC;AAEtC;;;GAGG;AACH,eAAO,MAAM,qCAAqC,MAAM,CAAC;AAEzD,eAAO,MAAM,6BAA6B,EAAE,kBAAkB,CAC5D,qBAAqB,GAAG,IAAI,CAAC,eAAe,EAAE,iBAAiB,CAAC,CA+FjE,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,qBAAqB,GAAG,IAAI,CAAC,eAAe,EAAE,iBAAiB,CAAC,CAInG"}

package/dest/config.js

@@ -0,0 +1,102 @@
+import { booleanConfigHelper, getConfigFromMappings, numberConfigHelper, optionalNumberConfigHelper, pickConfigMappings, secretValueConfigHelper } from '@aztec-labs/foundation/config';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { sharedSequencerConfigMappings } from '@aztec-labs/stdlib/config';
+import { localSignerConfigMappings, validatorHASignerConfigMappings } from '@aztec-labs/stdlib/ha-signing';
+/**
+ * Default clock-disparity tolerance (ms) for proposal/attestation receive windows, mirroring the p2p config
+ * default. Used by the validator-client validators when the merged node config does not carry the value.
+ */ export const DEFAULT_MAX_GOSSIP_CLOCK_DISPARITY_MS = 500;
+export const validatorClientConfigMappings = {
+    ...pickConfigMappings(sharedSequencerConfigMappings, [
+        'blockDurationMs'
+    ]),
+    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: []
+    },
+    l1ChainId: {
+        env: 'L1_CHAIN_ID',
+        description: 'The chain ID of the ethereum host.',
+        parseEnv: (val)=>+val,
+        defaultValue: 31337
+    },
+    disableValidator: {
+        env: 'VALIDATOR_DISABLED',
+        description: 'Do not run the validator',
+        ...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',
+        description: 'Interval between polling for new attestations',
+        ...numberConfigHelper(200)
+    },
+    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)
+    },
+    skipProposalSlotValidation: {
+        description: 'Accept proposal validation regardless of slot timing (for testing only)',
+        ...booleanConfigHelper(false)
+    },
+    validateMaxL2BlockGas: {
+        env: 'VALIDATOR_MAX_L2_BLOCK_GAS',
+        description: 'Maximum L2 block gas for validation. Proposals exceeding this limit are rejected.',
+        ...optionalNumberConfigHelper()
+    },
+    validateMaxDABlockGas: {
+        env: 'VALIDATOR_MAX_DA_BLOCK_GAS',
+        description: 'Maximum DA block gas for validation. Proposals exceeding this limit are rejected.',
+        ...optionalNumberConfigHelper()
+    },
+    validateMaxTxsPerBlock: {
+        env: 'VALIDATOR_MAX_TX_PER_BLOCK',
+        description: 'Maximum transactions per block for validation. Proposals exceeding this limit are rejected.',
+        ...optionalNumberConfigHelper()
+    },
+    validateMaxTxsPerCheckpoint: {
+        env: 'VALIDATOR_MAX_TX_PER_CHECKPOINT',
+        description: 'Maximum transactions per checkpoint for validation. Proposals exceeding this limit are rejected.',
+        ...optionalNumberConfigHelper()
+    },
+    ...localSignerConfigMappings,
+    ...validatorHASignerConfigMappings
+};
+/**
+ * Returns the prover configuration from the environment variables.
+ * Note: If an environment variable is not set, the default value is used.
+ * @returns The validator configuration.
+ */ export function getProverEnvVars() {
+    return getConfigFromMappings(validatorClientConfigMappings);
+}

package/dest/duties/validation_service.d.ts

@@ -0,0 +1,65 @@
+import { type CheckpointNumber, IndexWithinCheckpoint, type SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import type { Signature } from '@aztec-labs/foundation/eth-signature';
+import { CommitteeAttestationsAndSigners } from '@aztec-labs/stdlib/block';
+import type { InboxBucketRef } from '@aztec-labs/stdlib/messaging';
+import { BlockProposal, type BlockProposalOptions, CheckpointAttestation, CheckpointProposal, type CheckpointProposalCore, type CheckpointProposalOptions, type CoordinationSignatureContext } from '@aztec-labs/stdlib/p2p';
+import { CheckpointHeader } from '@aztec-labs/stdlib/rollup';
+import type { BlockHeader, Tx } from '@aztec-labs/stdlib/tx';
+import type { ValidatorKeyStore } from '../key_store/interface.js';
+export declare class ValidationService {
+    private keyStore;
+    private signatureContext;
+    private log;
+    constructor(keyStore: ValidatorKeyStore, signatureContext: CoordinationSignatureContext, log?: import("@aztec-labs/foundation/log").Logger);
+    /**
+     * Create a block proposal with the given header, archive, and transactions
+     *
+     * @param blockHeader - The block header
+     * @param blockIndexWithinCheckpoint - The block index within checkpoint for HA signing context
+     * @param archive - The archive of the current block
+     * @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
+     * @throws DutyAlreadySignedError if HA signer indicates duty already signed by another node
+     * @throws SlashingProtectionError if attempting to sign different data for same slot
+     */
+    createBlockProposal(blockHeader: BlockHeader, checkpointNumber: CheckpointNumber, blockIndexWithinCheckpoint: IndexWithinCheckpoint, archive: Fr, txs: Tx[], proposerAttesterAddress: EthAddress | undefined, options: BlockProposalOptions, bucketRef?: InboxBucketRef): Promise<BlockProposal>;
+    /**
+     * 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 lastBlockProposal - Signed block proposal for the last block in the checkpoint, 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, checkpointNumber: CheckpointNumber, feeAssetPriceModifier: bigint, lastBlockProposal: BlockProposal | 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 checkpoint proposal (core version without lastBlock) to attest to
+     * @param attestors - The validators to attest with
+     * @returns checkpoint attestations
+     */
+    attestToCheckpointProposal(proposal: CheckpointProposalCore, attestors: EthAddress[], checkpointNumber: CheckpointNumber): 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
+     * @returns signature
+     * @throws DutyAlreadySignedError if already signed by another HA node
+     * @throws SlashingProtectionError if attempting to sign different data for same slot
+     */
+    signAttestationsAndSigners(attestationsAndSigners: CommitteeAttestationsAndSigners, proposer: EthAddress, slot: SlotNumber, checkpointNumber: CheckpointNumber): Promise<Signature>;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"validation_service.d.ts","sourceRoot":"","sources":["../../src/duties/validation_service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAE,qBAAqB,EAAE,KAAK,UAAU,EAAE,MAAM,sCAAsC,CAAC;AACrH,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAEtE,OAAO,EAAE,+BAA+B,EAAE,MAAM,0BAA0B,CAAC;AAC3E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EACL,aAAa,EACb,KAAK,oBAAoB,EACzB,qBAAqB,EACrB,kBAAkB,EAClB,KAAK,sBAAsB,EAC3B,KAAK,yBAAyB,EAE9B,KAAK,4BAA4B,EAElC,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,uBAAuB,CAAC;AAI7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAEnE,qBAAa,iBAAiB;IAE1B,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,GAAG;IAHb,YACU,QAAQ,EAAE,iBAAiB,EAC3B,gBAAgB,EAAE,4BAA4B,EAC9C,GAAG,8CAA+C,EACxD;IAEJ;;;;;;;;;;;;;OAaG;IACI,mBAAmB,CACxB,WAAW,EAAE,WAAW,EACxB,gBAAgB,EAAE,gBAAgB,EAClC,0BAA0B,EAAE,qBAAqB,EACjD,OAAO,EAAE,EAAE,EACX,GAAG,EAAE,EAAE,EAAE,EACT,uBAAuB,EAAE,UAAU,GAAG,SAAS,EAC/C,OAAO,EAAE,oBAAoB,EAC7B,SAAS,CAAC,EAAE,cAAc,GACzB,OAAO,CAAC,aAAa,CAAC,CA8BxB;IAED;;;;;;;;;;OAUG;IACI,wBAAwB,CAC7B,gBAAgB,EAAE,gBAAgB,EAClC,OAAO,EAAE,EAAE,EACX,gBAAgB,EAAE,gBAAgB,EAClC,qBAAqB,EAAE,MAAM,EAC7B,iBAAiB,EAAE,aAAa,GAAG,SAAS,EAC5C,uBAAuB,EAAE,UAAU,GAAG,SAAS,EAC/C,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,kBAAkB,CAAC,CAgC7B;IAED;;;;;;;;;OASG;IACG,0BAA0B,CAC9B,QAAQ,EAAE,sBAAsB,EAChC,SAAS,EAAE,UAAU,EAAE,EACvB,gBAAgB,EAAE,gBAAgB,GACjC,OAAO,CAAC,qBAAqB,EAAE,CAAC,CA2ClC;IAED;;;;;;;;OAQG;IACH,0BAA0B,CACxB,sBAAsB,EAAE,+BAA+B,EACvD,QAAQ,EAAE,UAAU,EACpB,IAAI,EAAE,UAAU,EAChB,gBAAgB,EAAE,gBAAgB,GACjC,OAAO,CAAC,SAAS,CAAC,CASpB;CACF"}

package/dest/duties/validation_service.js

@@ -0,0 +1,128 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { BlockProposal, CheckpointAttestation, CheckpointProposal, ConsensusPayload, getCoordinationSignatureTypedData } from '@aztec-labs/stdlib/p2p';
+import { CheckpointHeader } from '@aztec-labs/stdlib/rollup';
+import { DutyAlreadySignedError, SlashingProtectionError } from '@aztec-labs/validator-ha-signer/errors';
+import { DutyType } from '@aztec-labs/validator-ha-signer/types';
+export class ValidationService {
+    keyStore;
+    signatureContext;
+    log;
+    constructor(keyStore, signatureContext, log = createLogger('validator:validation-service')){
+        this.keyStore = keyStore;
+        this.signatureContext = signatureContext;
+        this.log = log;
+    }
+    /**
+   * Create a block proposal with the given header, archive, and transactions
+   *
+   * @param blockHeader - The block header
+   * @param blockIndexWithinCheckpoint - The block index within checkpoint for HA signing context
+   * @param archive - The archive of the current block
+   * @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
+   * @throws DutyAlreadySignedError if HA signer indicates duty already signed by another node
+   * @throws SlashingProtectionError if attempting to sign different data for same slot
+   */ createBlockProposal(blockHeader, checkpointNumber, blockIndexWithinCheckpoint, archive, txs, proposerAttesterAddress, options, bucketRef) {
+        // For testing: change the new archive to trigger state_mismatch validation failure
+        if (options.broadcastInvalidBlockProposal) {
+            archive = Fr.random();
+            this.log.warn(`Creating INVALID block proposal for slot ${blockHeader.globalVariables.slotNumber}`);
+        }
+        // Create a signer that uses the appropriate address
+        const address = proposerAttesterAddress ?? this.keyStore.getAddress(0);
+        const payloadSigner = (typedData, context)=>this.keyStore.signTypedDataWithAddress(address, typedData, context);
+        const txsSigner = (typedData, context)=>this.keyStore.signTypedDataWithAddress(address, typedData, context);
+        return BlockProposal.createProposalFromSigner(blockHeader, checkpointNumber, blockIndexWithinCheckpoint, archive, txs.map((tx)=>tx.getTxHash()), options.publishFullTxs ? txs : undefined, this.signatureContext, payloadSigner, txsSigner, bucketRef);
+    }
+    /**
+   * 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 lastBlockProposal - Signed block proposal for the last block in the checkpoint, or undefined
+   * @param proposerAttesterAddress - The address of the proposer
+   * @param options - Checkpoint proposal options
+   *
+   * @returns A checkpoint proposal signing the above information
+   */ createCheckpointProposal(checkpointHeader, archive, checkpointNumber, feeAssetPriceModifier, lastBlockProposal, proposerAttesterAddress, options) {
+        // For testing: corrupt the checkpoint so observers' checkpoint validation fails.
+        //
+        // Keep `archive` aligned with `lastBlockProposal.archiveRoot` so the archive-based lookup
+        // in `validateCheckpointProposal` (`getBlockData({ archive })`) still succeeds
+        if (options.broadcastInvalidCheckpointProposal) {
+            archive = lastBlockProposal?.archiveRoot ?? Fr.random();
+            checkpointHeader = CheckpointHeader.from({
+                ...checkpointHeader,
+                epochOutHash: Fr.random()
+            });
+            this.log.warn(`Creating INVALID checkpoint proposal for slot ${checkpointHeader.slotNumber}`);
+        }
+        // Create a signer that takes payload and context, and uses the appropriate address
+        const payloadSigner = (typedData, context)=>{
+            const address = proposerAttesterAddress ?? this.keyStore.getAddress(0);
+            return this.keyStore.signTypedDataWithAddress(address, typedData, context);
+        };
+        return CheckpointProposal.createProposalFromSigner(checkpointHeader, archive, checkpointNumber, feeAssetPriceModifier, lastBlockProposal, this.signatureContext, payloadSigner);
+    }
+    /**
+   * 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 checkpoint proposal (core version without lastBlock) to attest to
+   * @param attestors - The validators to attest with
+   * @returns checkpoint attestations
+   */ async attestToCheckpointProposal(proposal, attestors, checkpointNumber) {
+        // Create the attestation payload from the checkpoint proposal
+        const payload = new ConsensusPayload(proposal.checkpointHeader, proposal.archive, proposal.feeAssetPriceModifier, this.signatureContext);
+        const typedData = getCoordinationSignatureTypedData(payload);
+        const context = {
+            slot: proposal.slotNumber,
+            checkpointNumber,
+            dutyType: DutyType.ATTESTATION
+        };
+        // Sign each attestor in parallel, catching HA errors per-attestor
+        const results = await Promise.allSettled(attestors.map(async (attestor)=>{
+            const sig = await this.keyStore.signTypedDataWithAddress(attestor, typedData, context);
+            return new CheckpointAttestation(payload, sig, proposal.signature);
+        }));
+        const attestations = [];
+        for(let i = 0; i < results.length; i++){
+            const result = results[i];
+            if (result.status === 'fulfilled') {
+                attestations.push(result.value);
+            } else {
+                const error = result.reason;
+                if (error instanceof DutyAlreadySignedError || error instanceof SlashingProtectionError) {
+                    this.log.verbose(`Attestation for slot ${proposal.slotNumber} by ${attestors[i]} already signed by another High-Availability node`);
+                // Continue with remaining attestors
+                } else {
+                    throw error;
+                }
+            }
+        }
+        return attestations;
+    }
+    /**
+   * 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
+   * @returns signature
+   * @throws DutyAlreadySignedError if already signed by another HA node
+   * @throws SlashingProtectionError if attempting to sign different data for same slot
+   */ signAttestationsAndSigners(attestationsAndSigners, proposer, slot, checkpointNumber) {
+        const context = {
+            slot,
+            checkpointNumber,
+            dutyType: DutyType.ATTESTATIONS_AND_SIGNERS
+        };
+        const typedData = getCoordinationSignatureTypedData(attestationsAndSigners);
+        return this.keyStore.signTypedDataWithAddress(proposer, typedData, context);
+    }
+}

package/dest/factory.d.ts

@@ -0,0 +1,41 @@
+import type { BlobClientInterface } from '@aztec-labs/blob-client/client';
+import type { EpochCache } from '@aztec-labs/epoch-cache';
+import type { DateProvider } from '@aztec-labs/foundation/timer';
+import type { KeystoreManager } from '@aztec-labs/node-keystore';
+import type { P2PClient } from '@aztec-labs/p2p';
+import type { L2BlockSink, L2BlockSource } from '@aztec-labs/stdlib/block';
+import type { CheckpointReexecutionTracker } from '@aztec-labs/stdlib/checkpoint';
+import type { ValidatorClientFullConfig, WorldStateSynchronizer } from '@aztec-labs/stdlib/interfaces/server';
+import type { L1ToL2MessageSource } from '@aztec-labs/stdlib/messaging';
+import type { TelemetryClient } from '@aztec-labs/telemetry-client';
+import type { SlashingProtectionDatabase } from '@aztec-labs/validator-ha-signer/types';
+import type { FullNodeCheckpointsBuilder } from './checkpoint_builder.js';
+import { ProposalHandler } from './proposal_handler.js';
+import { ValidatorClient } from './validator.js';
+export declare function createProposalHandler(config: ValidatorClientFullConfig, deps: {
+    checkpointsBuilder: FullNodeCheckpointsBuilder;
+    worldState: WorldStateSynchronizer;
+    blockSource: L2BlockSource & L2BlockSink;
+    l1ToL2MessageSource: L1ToL2MessageSource;
+    p2pClient: P2PClient;
+    epochCache: EpochCache;
+    blobClient: BlobClientInterface;
+    dateProvider: DateProvider;
+    telemetry: TelemetryClient;
+    reexecutionTracker: CheckpointReexecutionTracker;
+}): ProposalHandler;
+export declare function createValidatorClient(config: ValidatorClientFullConfig, deps: {
+    checkpointsBuilder: FullNodeCheckpointsBuilder;
+    worldState: WorldStateSynchronizer;
+    p2pClient: P2PClient;
+    blockSource: L2BlockSource & L2BlockSink;
+    l1ToL2MessageSource: L1ToL2MessageSource;
+    telemetry: TelemetryClient;
+    dateProvider: DateProvider;
+    epochCache: EpochCache;
+    keyStoreManager: KeystoreManager | undefined;
+    blobClient: BlobClientInterface;
+    reexecutionTracker: CheckpointReexecutionTracker;
+    slashingProtectionDb?: SlashingProtectionDatabase;
+}): Promise<ValidatorClient> | undefined;
+//# sourceMappingURL=data:application/json;base64,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