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

package/dest/block_proposal_handler.d.ts

@@ -0,0 +1,52 @@
+import { Fr } from '@aztec/foundation/fields';
+import { DateProvider } from '@aztec/foundation/timer';
+import type { P2P, PeerId } from '@aztec/p2p';
+import { TxProvider } from '@aztec/p2p';
+import { BlockProposalValidator } from '@aztec/p2p/msg_validators';
+import type { L2Block, L2BlockSource } from '@aztec/stdlib/block';
+import type { IFullNodeBlockBuilder, ValidatorClientFullConfig } from '@aztec/stdlib/interfaces/server';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import { type BlockProposal } from '@aztec/stdlib/p2p';
+import { type FailedTx, type Tx } from '@aztec/stdlib/tx';
+import { type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
+import type { ValidatorMetrics } from './metrics.js';
+export type BlockProposalValidationFailureReason = 'invalid_proposal' | 'parent_block_not_found' | 'parent_block_wrong_slot' | 'in_hash_mismatch' | 'block_number_already_exists' | 'txs_not_available' | 'state_mismatch' | 'failed_txs' | 'timeout' | 'unknown_error';
+type ReexecuteTransactionsResult = {
+    block: L2Block;
+    failedTxs: FailedTx[];
+    reexecutionTimeMs: number;
+    totalManaUsed: number;
+};
+export type BlockProposalValidationSuccessResult = {
+    isValid: true;
+    blockNumber: number;
+    reexecutionResult?: ReexecuteTransactionsResult;
+};
+export type BlockProposalValidationFailureResult = {
+    isValid: false;
+    reason: BlockProposalValidationFailureReason;
+    blockNumber?: number;
+    reexecutionResult?: ReexecuteTransactionsResult;
+};
+export type BlockProposalValidationResult = BlockProposalValidationSuccessResult | BlockProposalValidationFailureResult;
+export declare class BlockProposalHandler {
+    private blockBuilder;
+    private blockSource;
+    private l1ToL2MessageSource;
+    private txProvider;
+    private blockProposalValidator;
+    private config;
+    private metrics?;
+    private dateProvider;
+    private log;
+    readonly tracer: Tracer;
+    constructor(blockBuilder: IFullNodeBlockBuilder, blockSource: L2BlockSource, l1ToL2MessageSource: L1ToL2MessageSource, txProvider: TxProvider, blockProposalValidator: BlockProposalValidator, config: ValidatorClientFullConfig, metrics?: ValidatorMetrics | undefined, dateProvider?: DateProvider, telemetry?: TelemetryClient, log?: import("@aztec/foundation/log").Logger);
+    registerForReexecution(p2pClient: P2P): BlockProposalHandler;
+    handleBlockProposal(proposal: BlockProposal, proposalSender: PeerId, shouldReexecute: boolean): Promise<BlockProposalValidationResult>;
+    private getParentBlock;
+    private getReexecutionDeadline;
+    private getReexecuteFailureReason;
+    reexecuteTransactions(proposal: BlockProposal, blockNumber: number, txs: Tx[], l1ToL2Messages: Fr[]): Promise<ReexecuteTransactionsResult>;
+}
+export {};
+//# sourceMappingURL=block_proposal_handler.d.ts.map

package/dest/block_proposal_handler.d.ts.map

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

package/dest/block_proposal_handler.js

@@ -0,0 +1,286 @@
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { TimeoutError } from '@aztec/foundation/error';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
+import { DateProvider, Timer } from '@aztec/foundation/timer';
+import { computeInHashFromL1ToL2Messages } from '@aztec/prover-client/helpers';
+import { getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import { ConsensusPayload } from '@aztec/stdlib/p2p';
+import { GlobalVariables } from '@aztec/stdlib/tx';
+import { ReExFailedTxsError, ReExStateMismatchError, ReExTimeoutError, TransactionsNotAvailableError } from '@aztec/stdlib/validators';
+import { getTelemetryClient } from '@aztec/telemetry-client';
+export class BlockProposalHandler {
+    blockBuilder;
+    blockSource;
+    l1ToL2MessageSource;
+    txProvider;
+    blockProposalValidator;
+    config;
+    metrics;
+    dateProvider;
+    log;
+    tracer;
+    constructor(blockBuilder, blockSource, l1ToL2MessageSource, txProvider, blockProposalValidator, config, metrics, dateProvider = new DateProvider(), telemetry = getTelemetryClient(), log = createLogger('validator:block-proposal-handler')){
+        this.blockBuilder = blockBuilder;
+        this.blockSource = blockSource;
+        this.l1ToL2MessageSource = l1ToL2MessageSource;
+        this.txProvider = txProvider;
+        this.blockProposalValidator = blockProposalValidator;
+        this.config = config;
+        this.metrics = metrics;
+        this.dateProvider = dateProvider;
+        this.log = log;
+        this.tracer = telemetry.getTracer('BlockProposalHandler');
+    }
+    registerForReexecution(p2pClient) {
+        const handler = async (proposal, proposalSender)=>{
+            try {
+                const result = await this.handleBlockProposal(proposal, proposalSender, true);
+                if (result.isValid) {
+                    this.log.info(`Non-validator reexecution completed for slot ${proposal.slotNumber.toBigInt()}`, {
+                        blockNumber: result.blockNumber,
+                        reexecutionTimeMs: result.reexecutionResult?.reexecutionTimeMs,
+                        totalManaUsed: result.reexecutionResult?.totalManaUsed,
+                        numTxs: result.reexecutionResult?.block?.body?.txEffects?.length ?? 0
+                    });
+                } else {
+                    this.log.warn(`Non-validator reexecution failed for slot ${proposal.slotNumber.toBigInt()}`, {
+                        blockNumber: result.blockNumber,
+                        reason: result.reason
+                    });
+                }
+            } catch (error) {
+                this.log.error('Error processing block proposal in non-validator handler', error);
+            }
+            return undefined; // Non-validator nodes don't return attestations
+        };
+        p2pClient.registerBlockProposalHandler(handler);
+        return this;
+    }
+    async handleBlockProposal(proposal, proposalSender, shouldReexecute) {
+        const slotNumber = proposal.slotNumber.toBigInt();
+        const proposer = proposal.getSender();
+        const config = this.blockBuilder.getConfig();
+        // Reject proposals with invalid signatures
+        if (!proposer) {
+            this.log.warn(`Received proposal with invalid signature for slot ${slotNumber}`);
+            return {
+                isValid: false,
+                reason: 'invalid_proposal'
+            };
+        }
+        const proposalInfo = {
+            ...proposal.toBlockInfo(),
+            proposer: proposer.toString()
+        };
+        this.log.info(`Processing proposal for slot ${slotNumber}`, {
+            ...proposalInfo,
+            txHashes: proposal.txHashes.map((t)=>t.toString())
+        });
+        // Check that the proposal is from the current proposer, or the next proposer
+        // This should have been handled by the p2p layer, but we double check here out of caution
+        const invalidProposal = await this.blockProposalValidator.validate(proposal);
+        if (invalidProposal) {
+            this.log.warn(`Proposal is not valid, skipping processing`, proposalInfo);
+            return {
+                isValid: false,
+                reason: 'invalid_proposal'
+            };
+        }
+        // Check that the parent proposal is a block we know, otherwise reexecution would fail
+        const parentBlockHeader = await this.getParentBlock(proposal);
+        if (parentBlockHeader === undefined) {
+            this.log.warn(`Parent block for proposal not found, skipping processing`, proposalInfo);
+            return {
+                isValid: false,
+                reason: 'parent_block_not_found'
+            };
+        }
+        // Check that the parent block's slot is less than the proposal's slot (should not happen, but we check anyway)
+        if (parentBlockHeader !== 'genesis' && parentBlockHeader.getSlot() >= slotNumber) {
+            this.log.warn(`Parent block slot is greater than or equal to proposal slot, skipping processing`, {
+                parentBlockSlot: parentBlockHeader.getSlot().toString(),
+                proposalSlot: slotNumber.toString(),
+                ...proposalInfo
+            });
+            return {
+                isValid: false,
+                reason: 'parent_block_wrong_slot'
+            };
+        }
+        // Compute the block number based on the parent block
+        const blockNumber = parentBlockHeader === 'genesis' ? INITIAL_L2_BLOCK_NUM : parentBlockHeader.getBlockNumber() + 1;
+        // Check that this block number does not exist already
+        const existingBlock = await this.blockSource.getBlockHeader(blockNumber);
+        if (existingBlock) {
+            this.log.warn(`Block number ${blockNumber} already exists, skipping processing`, proposalInfo);
+            return {
+                isValid: false,
+                blockNumber,
+                reason: 'block_number_already_exists'
+            };
+        }
+        // Collect txs from the proposal. We start doing this as early as possible,
+        // and we do it even if we don't plan to re-execute the txs, so that we have them if another node needs them.
+        const { txs, missingTxs } = await this.txProvider.getTxsForBlockProposal(proposal, blockNumber, {
+            pinnedPeer: proposalSender,
+            deadline: this.getReexecutionDeadline(slotNumber, config)
+        });
+        // Check that I have the same set of l1ToL2Messages as the proposal
+        const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockNumber);
+        const computedInHash = await computeInHashFromL1ToL2Messages(l1ToL2Messages);
+        const proposalInHash = proposal.payload.header.contentCommitment.inHash;
+        if (!computedInHash.equals(proposalInHash)) {
+            this.log.warn(`L1 to L2 messages in hash mismatch, skipping processing`, {
+                proposalInHash: proposalInHash.toString(),
+                computedInHash: computedInHash.toString(),
+                ...proposalInfo
+            });
+            return {
+                isValid: false,
+                blockNumber,
+                reason: 'in_hash_mismatch'
+            };
+        }
+        // Check that all of the transactions in the proposal are available
+        if (missingTxs.length > 0) {
+            this.log.warn(`Missing ${missingTxs.length} txs to process proposal`, {
+                ...proposalInfo,
+                missingTxs
+            });
+            return {
+                isValid: false,
+                blockNumber,
+                reason: 'txs_not_available'
+            };
+        }
+        // Try re-executing the transactions in the proposal if needed
+        let reexecutionResult;
+        if (shouldReexecute) {
+            try {
+                this.log.verbose(`Re-executing transactions in the proposal`, proposalInfo);
+                reexecutionResult = await this.reexecuteTransactions(proposal, blockNumber, txs, l1ToL2Messages);
+            } catch (error) {
+                this.log.error(`Error reexecuting txs while processing block proposal`, error, proposalInfo);
+                const reason = this.getReexecuteFailureReason(error);
+                return {
+                    isValid: false,
+                    blockNumber,
+                    reason,
+                    reexecutionResult
+                };
+            }
+        }
+        this.log.info(`Successfully processed proposal for slot ${slotNumber}`, proposalInfo);
+        return {
+            isValid: true,
+            blockNumber,
+            reexecutionResult
+        };
+    }
+    async getParentBlock(proposal) {
+        const parentArchive = proposal.payload.header.lastArchiveRoot;
+        const slot = proposal.slotNumber.toBigInt();
+        const config = this.blockBuilder.getConfig();
+        const { genesisArchiveRoot } = await this.blockSource.getGenesisValues();
+        if (parentArchive.equals(genesisArchiveRoot)) {
+            return 'genesis';
+        }
+        const deadline = this.getReexecutionDeadline(slot, config);
+        const currentTime = this.dateProvider.now();
+        const timeoutDurationMs = deadline.getTime() - currentTime;
+        try {
+            return await this.blockSource.getBlockHeaderByArchive(parentArchive) ?? (timeoutDurationMs <= 0 ? undefined : await retryUntil(()=>this.blockSource.syncImmediate().then(()=>this.blockSource.getBlockHeaderByArchive(parentArchive)), 'force archiver sync', timeoutDurationMs / 1000, 0.5));
+        } catch (err) {
+            if (err instanceof TimeoutError) {
+                this.log.debug(`Timed out getting parent block by archive root`, {
+                    parentArchive
+                });
+            } else {
+                this.log.error('Error getting parent block by archive root', err, {
+                    parentArchive
+                });
+            }
+            return undefined;
+        }
+    }
+    getReexecutionDeadline(slot, config) {
+        const nextSlotTimestampSeconds = Number(getTimestampForSlot(slot + 1n, config));
+        const msNeededForPropagationAndPublishing = this.config.validatorReexecuteDeadlineMs;
+        return new Date(nextSlotTimestampSeconds * 1000 - msNeededForPropagationAndPublishing);
+    }
+    getReexecuteFailureReason(err) {
+        if (err instanceof ReExStateMismatchError) {
+            return 'state_mismatch';
+        } else if (err instanceof ReExFailedTxsError) {
+            return 'failed_txs';
+        } else if (err instanceof ReExTimeoutError) {
+            return 'timeout';
+        } else {
+            return 'unknown_error';
+        }
+    }
+    async reexecuteTransactions(proposal, blockNumber, 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();
+        // We source most global variables from the proposal
+        const globalVariables = GlobalVariables.from({
+            slotNumber: proposal.payload.header.slotNumber,
+            coinbase: proposal.payload.header.coinbase,
+            feeRecipient: proposal.payload.header.feeRecipient,
+            gasFees: proposal.payload.header.gasFees,
+            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.payload.header.slotNumber.toBigInt(), config)
+        });
+        const numFailedTxs = failedTxs.length;
+        const slot = proposal.slotNumber.toBigInt();
+        this.log.verbose(`Transaction re-execution complete for slot ${slot}`, {
+            numFailedTxs,
+            numProposalTxs: txHashes.length,
+            numProcessedTxs: block.body.txEffects.length,
+            slot
+        });
+        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();
+        }
+        // Throw a ReExStateMismatchError error if state updates do not match
+        const blockPayload = ConsensusPayload.fromBlock(block);
+        if (!blockPayload.equals(proposal.payload)) {
+            this.log.warn(`Re-execution state mismatch for slot ${slot}`, {
+                expected: blockPayload.toInspect(),
+                actual: proposal.payload.toInspect()
+            });
+            this.metrics?.recordFailedReexecution(proposal);
+            throw new ReExStateMismatchError(proposal.archive, block.archive.root, proposal.payload.stateReference, block.header.state);
+        }
+        const reexecutionTimeMs = timer.ms();
+        const totalManaUsed = block.header.totalManaUsed.toNumber() / 1e6;
+        this.metrics?.recordReex(reexecutionTimeMs, txs.length, totalManaUsed);
+        return {
+            block,
+            failedTxs,
+            reexecutionTimeMs,
+            totalManaUsed
+        };
+    }
+}

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.

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;AAElC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAE7E,YAAY,EAAE,qBAAqB,EAAE,CAAC;AAEtC,eAAO,MAAM,6BAA6B,EAAE,kBAAkB,CAAC,qBAAqB,CAsDnF,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,qBAAqB,CAExD"}

package/dest/config.js

@@ -1,15 +1,29 @@
-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';
 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,6 +34,16 @@ export const validatorClientConfigMappings = {
         env: 'VALIDATOR_REEXECUTE',
         description: 'Re-execute transactions before attesting',
         ...booleanConfigHelper(true)
+    },
+    validatorReexecuteDeadlineMs: {
+        env: 'VALIDATOR_REEXECUTE_DEADLINE_MS',
+        description: 'Will re-execute until this many milliseconds are left in the slot',
+        ...numberConfigHelper(6000)
+    },
+    alwaysReexecuteBlockProposals: {
+        env: 'ALWAYS_REEXECUTE_BLOCK_PROPOSALS',
+        description: 'Whether to always reexecute block proposals, even for non-validator nodes (useful for monitoring network status).',
+        ...booleanConfigHelper(false)
     }
 };
 /**

package/dest/duties/validation_service.d.ts

@@ -1,29 +1,37 @@
-import type { Fr } from '@aztec/foundation/fields';
-import { BlockAttestation, BlockProposal } from '@aztec/stdlib/p2p';
-import type { BlockHeader, TxHash } from '@aztec/stdlib/tx';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { Signature } from '@aztec/foundation/eth-signature';
+import { Fr } from '@aztec/foundation/fields';
+import type { CommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
+import { BlockAttestation, BlockProposal, type BlockProposalOptions } from '@aztec/stdlib/p2p';
+import type { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { StateReference, type 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 archive - The archive of the current block
      * @param txs - TxHash[] ordered list of transactions
+     * @param options - Block proposal options (including broadcastInvalidBlockProposal for testing)
      *
      * @returns A block proposal signing the above information (not the current implementation!!!)
      */
-    createBlockProposal(header: BlockHeader, archive: Fr, txs: TxHash[]): Promise<BlockProposal>;
+    createBlockProposal(header: CheckpointHeader, archive: Fr, stateReference: StateReference, txs: Tx[], proposerAttesterAddress: EthAddress | undefined, options: BlockProposalOptions): Promise<BlockProposal>;
     /**
-     * Attest to the given block proposal constructed by the current sequencer
+     * Attest with selection of validators to the given block proposal, constructed by the current sequencer
      *
      * 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 attestors - The validators to attest with
+     * @returns attestations
      */
-    attestToProposal(proposal: BlockProposal): Promise<BlockAttestation>;
+    attestToProposal(proposal: BlockProposal, attestors: EthAddress[]): Promise<BlockAttestation[]>;
+    signAttestationsAndSigners(attestationsAndSigners: CommitteeAttestationsAndSigners, proposer: EthAddress): Promise<Signature>;
 }
 //# sourceMappingURL=validation_service.d.ts.map

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":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAG9C,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,EACL,gBAAgB,EAChB,aAAa,EACb,KAAK,oBAAoB,EAG1B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAE3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAEnE,qBAAa,iBAAiB;IAE1B,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,GAAG;gBADH,QAAQ,EAAE,iBAAiB,EAC3B,GAAG,yCAA+C;IAG5D;;;;;;;;;OASG;IACG,mBAAmB,CACvB,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,EAAE,EACX,cAAc,EAAE,cAAc,EAC9B,GAAG,EAAE,EAAE,EAAE,EACT,uBAAuB,EAAE,UAAU,GAAG,SAAS,EAC/C,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,aAAa,CAAC;IA0BzB;;;;;;;;;OASG;IACG,gBAAgB,CAAC,QAAQ,EAAE,aAAa,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAU/F,0BAA0B,CAC9B,sBAAsB,EAAE,+BAA+B,EACvD,QAAQ,EAAE,UAAU,GACnB,OAAO,CAAC,SAAS,CAAC;CAMtB"}

package/dest/duties/validation_service.js

@@ -1,10 +1,15 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { keccak256 } from '@aztec/foundation/crypto';
+import { createLogger } from '@aztec/foundation/log';
+import { unfreeze } from '@aztec/foundation/types';
 import { BlockAttestation, BlockProposal, ConsensusPayload, SignatureDomainSeparator } from '@aztec/stdlib/p2p';
+import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
 export class ValidationService {
     keyStore;
-    constructor(keyStore){
+    log;
+    constructor(keyStore, log = createLogger('validator:validation-service')){
         this.keyStore = keyStore;
+        this.log = log;
     }
     /**
    * Create a block proposal with the given header, archive, and transactions
@@ -12,24 +17,43 @@ export class ValidationService {
    * @param header - The block header
    * @param archive - The archive of the current block
    * @param txs - TxHash[] ordered list of transactions
+   * @param options - Block proposal options (including broadcastInvalidBlockProposal for testing)
    *
    * @returns A block proposal signing the above information (not the current implementation!!!)
-   */ createBlockProposal(header, archive, txs) {
-        const payloadSigner = (payload)=>this.keyStore.signMessage(payload);
-        return BlockProposal.createProposalFromSigner(new ConsensusPayload(header, archive, txs), payloadSigner);
+   */ async createBlockProposal(header, archive, stateReference, txs, proposerAttesterAddress, options) {
+        let payloadSigner;
+        if (proposerAttesterAddress !== undefined) {
+            payloadSigner = (payload)=>this.keyStore.signMessageWithAddress(proposerAttesterAddress, payload);
+        } else {
+            // if there is no proposer attester address, just use the first signer
+            const signer = this.keyStore.getAddress(0);
+            payloadSigner = (payload)=>this.keyStore.signMessageWithAddress(signer, payload);
+        }
+        // TODO: check if this is calculated earlier / can not be recomputed
+        const txHashes = await Promise.all(txs.map((tx)=>tx.getTxHash()));
+        // For testing: corrupt the state reference to trigger state_mismatch validation failure
+        if (options.broadcastInvalidBlockProposal) {
+            unfreeze(stateReference.partial).noteHashTree = AppendOnlyTreeSnapshot.random();
+            this.log.warn(`Creating INVALID block proposal for slot ${header.slotNumber.toBigInt()}`);
+        }
+        return BlockProposal.createProposalFromSigner(new ConsensusPayload(header, archive, stateReference), txHashes, options.publishFullTxs ? txs : undefined, payloadSigner);
     }
     /**
-   * Attest to the given block proposal constructed by the current sequencer
+   * Attest with selection of validators to the given block proposal, constructed by the current sequencer
    *
    * 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
-   */ async attestToProposal(proposal) {
-        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/7961): check that the current validator is correct
-        const buf = Buffer32.fromBuffer(keccak256(await proposal.payload.getPayloadToSign(SignatureDomainSeparator.blockAttestation)));
-        const sig = await this.keyStore.signMessage(buf);
-        return new BlockAttestation(proposal.payload, sig);
+   * @param attestors - The validators to attest with
+   * @returns attestations
+   */ async attestToProposal(proposal, attestors) {
+        const buf = Buffer32.fromBuffer(keccak256(proposal.payload.getPayloadToSign(SignatureDomainSeparator.blockAttestation)));
+        const signatures = await Promise.all(attestors.map((attestor)=>this.keyStore.signMessageWithAddress(attestor, buf)));
+        return signatures.map((sig)=>new BlockAttestation(proposal.payload, sig, proposal.signature));
+    }
+    async signAttestationsAndSigners(attestationsAndSigners, proposer) {
+        const buf = Buffer32.fromBuffer(keccak256(attestationsAndSigners.getPayloadToSign(SignatureDomainSeparator.attestationsAndSigners)));
+        return await this.keyStore.signMessageWithAddress(proposer, buf);
     }
 }

package/dest/factory.d.ts

@@ -1,13 +1,30 @@
 import type { EpochCache } from '@aztec/epoch-cache';
 import type { DateProvider } from '@aztec/foundation/timer';
-import type { P2P } from '@aztec/p2p';
+import type { KeystoreManager } from '@aztec/node-keystore';
+import { type P2PClient } from '@aztec/p2p';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { IFullNodeBlockBuilder, ValidatorClientFullConfig } from '@aztec/stdlib/interfaces/server';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 import type { TelemetryClient } from '@aztec/telemetry-client';
-import type { ValidatorClientConfig } from './config.js';
+import { BlockProposalHandler } from './block_proposal_handler.js';
 import { ValidatorClient } from './validator.js';
-export declare function createValidatorClient(config: ValidatorClientConfig, deps: {
-    p2pClient: P2P;
+export declare function createBlockProposalHandler(config: ValidatorClientFullConfig, deps: {
+    blockBuilder: IFullNodeBlockBuilder;
+    blockSource: L2BlockSource;
+    l1ToL2MessageSource: L1ToL2MessageSource;
+    p2pClient: P2PClient;
+    epochCache: EpochCache;
+    dateProvider: DateProvider;
+    telemetry: TelemetryClient;
+}): BlockProposalHandler;
+export declare function createValidatorClient(config: ValidatorClientFullConfig, deps: {
+    blockBuilder: IFullNodeBlockBuilder;
+    p2pClient: P2PClient;
+    blockSource: L2BlockSource;
+    l1ToL2MessageSource: L1ToL2MessageSource;
     telemetry: TelemetryClient;
     dateProvider: DateProvider;
     epochCache: EpochCache;
+    keyStoreManager: KeystoreManager | undefined;
 }): ValidatorClient | undefined;
 //# sourceMappingURL=factory.d.ts.map

package/dest/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAI/D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,qBAAqB,EAC7B,IAAI,EAAE;IACJ,SAAS,EAAE,GAAG,CAAC;IACf,SAAS,EAAE,eAAe,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,UAAU,EAAE,UAAU,CAAC;CACxB,+BAUF"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAA0B,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,qBAAqB,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AACxG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,yBAAyB,EACjC,IAAI,EAAE;IACJ,YAAY,EAAE,qBAAqB,CAAC;IACpC,WAAW,EAAE,aAAa,CAAC;IAC3B,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,SAAS,EAAE,SAAS,CAAC;IACrB,UAAU,EAAE,UAAU,CAAC;IACvB,YAAY,EAAE,YAAY,CAAC;IAC3B,SAAS,EAAE,eAAe,CAAC;CAC5B,wBAiBF;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,yBAAyB,EACjC,IAAI,EAAE;IACJ,YAAY,EAAE,qBAAqB,CAAC;IACpC,SAAS,EAAE,SAAS,CAAC;IACrB,WAAW,EAAE,aAAa,CAAC;IAC3B,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,SAAS,EAAE,eAAe,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,UAAU,EAAE,UAAU,CAAC;IACvB,eAAe,EAAE,eAAe,GAAG,SAAS,CAAC;CAC9C,+BAmBF"}

package/dest/factory.js

@@ -1,11 +1,18 @@
-import { generatePrivateKey } from 'viem/accounts';
+import { BlockProposalValidator } from '@aztec/p2p';
+import { BlockProposalHandler } from './block_proposal_handler.js';
+import { ValidatorMetrics } from './metrics.js';
 import { ValidatorClient } from './validator.js';
+export function createBlockProposalHandler(config, deps) {
+    const metrics = new ValidatorMetrics(deps.telemetry);
+    const blockProposalValidator = new BlockProposalValidator(deps.epochCache, {
+        txsPermitted: !config.disableTransactions
+    });
+    return new BlockProposalHandler(deps.blockBuilder, deps.blockSource, deps.l1ToL2MessageSource, deps.p2pClient.getTxProvider(), blockProposalValidator, config, metrics, deps.dateProvider, deps.telemetry);
+}
 export function createValidatorClient(config, deps) {
-    if (config.disableValidator) {
+    if (config.disableValidator || !deps.keyStoreManager) {
         return undefined;
     }
-    if (config.validatorPrivateKey === undefined || config.validatorPrivateKey === '') {
-        config.validatorPrivateKey = generatePrivateKey();
-    }
-    return ValidatorClient.new(config, deps.epochCache, deps.p2pClient, deps.dateProvider, deps.telemetry);
+    const txProvider = deps.p2pClient.getTxProvider();
+    return ValidatorClient.new(config, deps.blockBuilder, deps.epochCache, deps.p2pClient, deps.blockSource, deps.l1ToL2MessageSource, txProvider, deps.keyStoreManager, deps.dateProvider, deps.telemetry);
 }

package/dest/index.d.ts

@@ -1,4 +1,6 @@
+export * from './block_proposal_handler.js';
 export * from './config.js';
-export * from './validator.js';
 export * from './factory.js';
+export * from './validator.js';
+export * from './key_store/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dest/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC"}

package/dest/index.js

@@ -1,3 +1,5 @@
+export * from './block_proposal_handler.js';
 export * from './config.js';
-export * from './validator.js';
 export * from './factory.js';
+export * from './validator.js';
+export * from './key_store/index.js';