@aztec/aztec-node 0.82.2-alpha-testnet.4 → 0.82.3

package/dest/sentinel/sentinel.js

@@ -0,0 +1,246 @@
+import { countWhile } from '@aztec/foundation/collection';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { L2TipsMemoryStore } from '@aztec/kv-store/stores';
+import { L2BlockStream } from '@aztec/stdlib/block';
+import { getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+export class Sentinel {
+    epochCache;
+    archiver;
+    p2p;
+    store;
+    logger;
+    runningPromise;
+    blockStream;
+    l2TipsStore;
+    initialSlot;
+    lastProcessedSlot;
+    slotNumberToArchive;
+    constructor(epochCache, archiver, p2p, store, logger = createLogger('node:sentinel')){
+        this.epochCache = epochCache;
+        this.archiver = archiver;
+        this.p2p = p2p;
+        this.store = store;
+        this.logger = logger;
+        this.slotNumberToArchive = new Map();
+        this.l2TipsStore = new L2TipsMemoryStore();
+        const interval = epochCache.getL1Constants().ethereumSlotDuration * 1000 / 4;
+        this.runningPromise = new RunningPromise(this.work.bind(this), logger, interval);
+    }
+    async start() {
+        await this.init();
+        this.runningPromise.start();
+    }
+    /** Loads initial slot and initializes blockstream. We will not process anything at or before the initial slot. */ async init() {
+        this.initialSlot = this.epochCache.getEpochAndSlotNow().slot;
+        const startingBlock = await this.archiver.getBlockNumber();
+        this.blockStream = new L2BlockStream(this.archiver, this.l2TipsStore, this, this.logger, {
+            startingBlock
+        });
+    }
+    stop() {
+        return this.runningPromise.stop();
+    }
+    async handleBlockStreamEvent(event) {
+        await this.l2TipsStore.handleBlockStreamEvent(event);
+        if (event.type === 'blocks-added') {
+            // Store mapping from slot to archive
+            for (const block of event.blocks){
+                this.slotNumberToArchive.set(block.block.header.getSlot(), block.block.archive.root.toString());
+            }
+            // Prune the archive map to only keep at most N entries
+            const historyLength = this.store.getHistoryLength();
+            if (this.slotNumberToArchive.size > historyLength) {
+                const toDelete = Array.from(this.slotNumberToArchive.keys()).sort((a, b)=>Number(a - b)).slice(0, this.slotNumberToArchive.size - historyLength);
+                for (const key of toDelete){
+                    this.slotNumberToArchive.delete(key);
+                }
+            }
+        }
+    }
+    /**
+   * Process data for two L2 slots ago.
+   * Note that we do not process historical data, since we rely on p2p data for processing,
+   * and we don't have that data if we were offline during the period.
+   */ async work() {
+        const { slot: currentSlot } = this.epochCache.getEpochAndSlotNow();
+        try {
+            // Manually sync the block stream to ensure we have the latest data.
+            // Note we never `start` the blockstream, so it loops at the same pace as we do.
+            await this.blockStream.sync();
+            // Check if we are ready to process data for two L2 slots ago.
+            const targetSlot = await this.isReadyToProcess(currentSlot);
+            // And process it if we are.
+            if (targetSlot !== false) {
+                await this.processSlot(targetSlot);
+            }
+        } catch (err) {
+            this.logger.error(`Failed to process slot ${currentSlot}`, err);
+        }
+    }
+    /**
+   * Check if we are ready to process data for two L2 slots ago, so we allow plenty of time for p2p to process all in-flight attestations.
+   * We also don't move past the archiver last synced L2 slot, as we don't want to process data that is not yet available.
+   * Last, we check the p2p is synced with the archiver, so it has pulled all attestations from it.
+   */ async isReadyToProcess(currentSlot) {
+        const targetSlot = currentSlot - 2n;
+        if (this.lastProcessedSlot && this.lastProcessedSlot >= targetSlot) {
+            this.logger.trace(`Already processed slot ${targetSlot}`, {
+                lastProcessedSlot: this.lastProcessedSlot
+            });
+            return false;
+        }
+        if (this.initialSlot === undefined) {
+            this.logger.error(`Initial slot not loaded.`);
+            return false;
+        }
+        if (targetSlot <= this.initialSlot) {
+            this.logger.debug(`Refusing to process slot ${targetSlot} given initial slot ${this.initialSlot}`);
+            return false;
+        }
+        const archiverSlot = await this.archiver.getL2SlotNumber();
+        if (archiverSlot < targetSlot) {
+            this.logger.debug(`Waiting for archiver to sync with L2 slot ${targetSlot}`, {
+                archiverSlot,
+                targetSlot
+            });
+            return false;
+        }
+        const archiverLastBlockHash = await this.l2TipsStore.getL2Tips().then((tip)=>tip.latest.hash);
+        const p2pLastBlockHash = await this.p2p.getL2Tips().then((tips)=>tips.latest.hash);
+        const isP2pSynced = archiverLastBlockHash === p2pLastBlockHash;
+        if (!isP2pSynced) {
+            this.logger.debug(`Waiting for P2P client to sync with archiver`, {
+                archiverLastBlockHash,
+                p2pLastBlockHash
+            });
+            return false;
+        }
+        return targetSlot;
+    }
+    /**
+   * Gathers committee and proposer data for a given slot, computes slot stats,
+   * and updates overall stats.
+   */ async processSlot(slot) {
+        const { epoch, seed, committee } = await this.epochCache.getCommittee(slot);
+        if (committee.length === 0) {
+            this.logger.warn(`No committee found for slot ${slot} at epoch ${epoch}`);
+            this.lastProcessedSlot = slot;
+            return;
+        }
+        const proposerIndex = this.epochCache.computeProposerIndex(slot, epoch, seed, BigInt(committee.length));
+        const proposer = committee[Number(proposerIndex)];
+        const stats = await this.getSlotActivity(slot, epoch, proposer, committee);
+        this.logger.verbose(`Updating L2 slot ${slot} observed activity`, stats);
+        await this.updateValidators(slot, stats);
+        this.lastProcessedSlot = slot;
+    }
+    /** Computes activity for a given slot. */ async getSlotActivity(slot, epoch, proposer, committee) {
+        this.logger.debug(`Computing stats for slot ${slot} at epoch ${epoch}`, {
+            slot,
+            epoch,
+            proposer,
+            committee
+        });
+        // Check if there is an L2 block in L1 for this L2 slot
+        // Here we get all attestations for the block mined at the given slot,
+        // or all attestations for all proposals in the slot if no block was mined.
+        const archive = this.slotNumberToArchive.get(slot);
+        const attested = await this.p2p.getAttestationsForSlot(slot, archive);
+        const attestors = new Set(await Promise.all(attested.map((a)=>a.getSender().then((a)=>a.toString()))));
+        // We assume that there was a block proposal if at least one of the validators attested to it.
+        // It could be the case that every single validator failed, and we could differentiate it by having
+        // this node re-execute every block proposal it sees and storing it in the attestation pool.
+        // But we'll leave that corner case out to reduce pressure on the node.
+        const blockStatus = archive ? 'mined' : attestors.size > 0 ? 'proposed' : 'missed';
+        this.logger.debug(`Block for slot ${slot} was ${blockStatus}`, {
+            archive,
+            slot
+        });
+        // Get attestors that failed their duties for this block, but only if there was a block proposed
+        const missedAttestors = new Set(blockStatus === 'missed' ? [] : committee.filter((v)=>!attestors.has(v.toString()) && !proposer.equals(v)).map((v)=>v.toString()));
+        this.logger.debug(`Retrieved ${attestors.size} attestors out of ${committee.length} for slot ${slot}`, {
+            blockStatus,
+            proposer: proposer.toString(),
+            archive,
+            slot,
+            attestors: [
+                ...attestors
+            ],
+            missedAttestors: [
+                ...missedAttestors
+            ],
+            committee: committee.map((c)=>c.toString())
+        });
+        // Compute the status for each validator in the committee
+        const statusFor = (who)=>{
+            if (who === proposer.toString()) {
+                return `block-${blockStatus}`;
+            } else if (attestors.has(who)) {
+                return 'attestation-sent';
+            } else if (missedAttestors.has(who)) {
+                return 'attestation-missed';
+            } else {
+                return undefined;
+            }
+        };
+        return Object.fromEntries(committee.map((v)=>v.toString()).map((who)=>[
+                who,
+                statusFor(who)
+            ]));
+    }
+    /** Push the status for each slot for each validator. */ updateValidators(slot, stats) {
+        return this.store.updateValidators(slot, stats);
+    }
+    /** Computes stats to be returned based on stored data. */ async computeStats() {
+        const histories = await this.store.getHistories();
+        const slotNow = this.epochCache.getEpochAndSlotNow().slot;
+        const fromSlot = (this.lastProcessedSlot ?? slotNow) - BigInt(this.store.getHistoryLength());
+        const result = {};
+        for (const [address, history] of Object.entries(histories)){
+            const validatorAddress = address;
+            result[validatorAddress] = this.computeStatsForValidator(validatorAddress, history, fromSlot);
+        }
+        return {
+            stats: result,
+            lastProcessedSlot: this.lastProcessedSlot,
+            initialSlot: this.initialSlot,
+            slotWindow: this.store.getHistoryLength()
+        };
+    }
+    computeStatsForValidator(address, allHistory, fromSlot) {
+        const history = fromSlot ? allHistory.filter((h)=>h.slot >= fromSlot) : allHistory;
+        return {
+            address: EthAddress.fromString(address),
+            lastProposal: this.computeFromSlot(history.filter((h)=>h.status === 'block-proposed' || h.status === 'block-mined').at(-1)?.slot),
+            lastAttestation: this.computeFromSlot(history.filter((h)=>h.status === 'attestation-sent').at(-1)?.slot),
+            totalSlots: history.length,
+            missedProposals: this.computeMissed(history, 'block', 'block-missed'),
+            missedAttestations: this.computeMissed(history, 'attestation', 'attestation-missed'),
+            history
+        };
+    }
+    computeMissed(history, computeOverPrefix, filter) {
+        const relevantHistory = history.filter((h)=>h.status.startsWith(computeOverPrefix));
+        const filteredHistory = relevantHistory.filter((h)=>h.status === filter);
+        return {
+            currentStreak: countWhile([
+                ...relevantHistory
+            ].reverse(), (h)=>h.status === filter),
+            rate: filteredHistory.length / relevantHistory.length,
+            count: filteredHistory.length
+        };
+    }
+    computeFromSlot(slot) {
+        if (slot === undefined) {
+            return undefined;
+        }
+        const timestamp = getTimestampForSlot(slot, this.epochCache.getL1Constants());
+        return {
+            timestamp,
+            slot,
+            date: new Date(Number(timestamp) * 1000).toISOString()
+        };
+    }
+}

package/dest/sentinel/store.d.ts

@@ -0,0 +1,21 @@
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { ValidatorStatusHistory, ValidatorStatusInSlot } from '@aztec/stdlib/validators';
+export declare class SentinelStore {
+    private store;
+    private config;
+    static readonly SCHEMA_VERSION = 1;
+    private readonly map;
+    constructor(store: AztecAsyncKVStore, config: {
+        historyLength: number;
+    });
+    getHistoryLength(): number;
+    updateValidators(slot: bigint, statuses: Record<`0x${string}`, ValidatorStatusInSlot | undefined>): Promise<void>;
+    private pushValidatorStatusForSlot;
+    getHistories(): Promise<Record<`0x${string}`, ValidatorStatusHistory>>;
+    private getHistory;
+    private serializeHistory;
+    private deserializeHistory;
+    private statusToNumber;
+    private statusFromNumber;
+}
+//# sourceMappingURL=store.d.ts.map

package/dest/sentinel/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/sentinel/store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAE9F,qBAAa,aAAa;IAKZ,OAAO,CAAC,KAAK;IAAqB,OAAO,CAAC,MAAM;IAJ5D,gBAAuB,cAAc,KAAK;IAE1C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAuC;gBAEvC,KAAK,EAAE,iBAAiB,EAAU,MAAM,EAAE;QAAE,aAAa,EAAE,MAAM,CAAA;KAAE;IAIhF,gBAAgB;IAIV,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,KAAK,MAAM,EAAE,EAAE,qBAAqB,GAAG,SAAS,CAAC;YAUhG,0BAA0B;IAU3B,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,KAAK,MAAM,EAAE,EAAE,sBAAsB,CAAC,CAAC;YAQrE,UAAU;IAKxB,OAAO,CAAC,gBAAgB;IAMxB,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,cAAc;IAmBtB,OAAO,CAAC,gBAAgB;CAgBzB"}

package/dest/sentinel/store.js

@@ -0,0 +1,100 @@
+import { BufferReader, numToUInt8, numToUInt32BE, serializeToBuffer } from '@aztec/foundation/serialize';
+export class SentinelStore {
+    store;
+    config;
+    static SCHEMA_VERSION = 1;
+    map;
+    constructor(store, config){
+        this.store = store;
+        this.config = config;
+        this.map = store.openMap('sentinel-validator-status');
+    }
+    getHistoryLength() {
+        return this.config.historyLength;
+    }
+    async updateValidators(slot, statuses) {
+        await this.store.transactionAsync(async ()=>{
+            for (const [who, status] of Object.entries(statuses)){
+                if (status) {
+                    await this.pushValidatorStatusForSlot(who, slot, status);
+                }
+            }
+        });
+    }
+    async pushValidatorStatusForSlot(who, slot, status) {
+        const currentHistory = await this.getHistory(who) ?? [];
+        const newHistory = [
+            ...currentHistory,
+            {
+                slot,
+                status
+            }
+        ].slice(-this.config.historyLength);
+        await this.map.set(who, this.serializeHistory(newHistory));
+    }
+    async getHistories() {
+        const histories = {};
+        for await (const [address, history] of this.map.entriesAsync()){
+            histories[address] = this.deserializeHistory(history);
+        }
+        return histories;
+    }
+    async getHistory(address) {
+        const data = await this.map.getAsync(address);
+        return data && this.deserializeHistory(data);
+    }
+    serializeHistory(history) {
+        return serializeToBuffer(history.map((h)=>[
+                numToUInt32BE(Number(h.slot)),
+                numToUInt8(this.statusToNumber(h.status))
+            ]));
+    }
+    deserializeHistory(buffer) {
+        const reader = new BufferReader(buffer);
+        const history = [];
+        while(!reader.isEmpty()){
+            const slot = BigInt(reader.readNumber());
+            const status = this.statusFromNumber(reader.readUInt8());
+            history.push({
+                slot,
+                status
+            });
+        }
+        return history;
+    }
+    statusToNumber(status) {
+        switch(status){
+            case 'block-mined':
+                return 1;
+            case 'block-proposed':
+                return 2;
+            case 'block-missed':
+                return 3;
+            case 'attestation-sent':
+                return 4;
+            case 'attestation-missed':
+                return 5;
+            default:
+                {
+                    const _exhaustive = status;
+                    throw new Error(`Unknown status: ${status}`);
+                }
+        }
+    }
+    statusFromNumber(status) {
+        switch(status){
+            case 1:
+                return 'block-mined';
+            case 2:
+                return 'block-proposed';
+            case 3:
+                return 'block-missed';
+            case 4:
+                return 'attestation-sent';
+            case 5:
+                return 'attestation-missed';
+            default:
+                throw new Error(`Unknown status: ${status}`);
+        }
+    }
+}

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@aztec/aztec-node",
-  "version": "0.82.2-alpha-testnet.4",
+  "version": "0.82.3",
   "main": "dest/index.js",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
-    "./config": "./dest/aztec-node/config.js"
+    "./config": "./dest/aztec-node/config.js",
+    "./sentinel": "./dest/aztec-node/sentinel.js"
   },
   "bin": "./dest/bin/index.js",
   "typedocOptions": {
@@ -62,24 +63,25 @@
     ]
   },
   "dependencies": {
-    "@aztec/archiver": "0.82.2-alpha-testnet.4",
-    "@aztec/bb-prover": "0.82.2-alpha-testnet.4",
-    "@aztec/blob-sink": "0.82.2-alpha-testnet.4",
-    "@aztec/constants": "0.82.2-alpha-testnet.4",
-    "@aztec/epoch-cache": "0.82.2-alpha-testnet.4",
-    "@aztec/ethereum": "0.82.2-alpha-testnet.4",
-    "@aztec/foundation": "0.82.2-alpha-testnet.4",
-    "@aztec/kv-store": "0.82.2-alpha-testnet.4",
-    "@aztec/merkle-tree": "0.82.2-alpha-testnet.4",
-    "@aztec/p2p": "0.82.2-alpha-testnet.4",
-    "@aztec/protocol-contracts": "0.82.2-alpha-testnet.4",
-    "@aztec/prover-client": "0.82.2-alpha-testnet.4",
-    "@aztec/sequencer-client": "0.82.2-alpha-testnet.4",
-    "@aztec/simulator": "0.82.2-alpha-testnet.4",
-    "@aztec/stdlib": "0.82.2-alpha-testnet.4",
-    "@aztec/telemetry-client": "0.82.2-alpha-testnet.4",
-    "@aztec/validator-client": "0.82.2-alpha-testnet.4",
-    "@aztec/world-state": "0.82.2-alpha-testnet.4",
+    "@aztec/archiver": "0.82.3",
+    "@aztec/bb-prover": "0.82.3",
+    "@aztec/blob-sink": "0.82.3",
+    "@aztec/constants": "0.82.3",
+    "@aztec/epoch-cache": "0.82.3",
+    "@aztec/ethereum": "0.82.3",
+    "@aztec/foundation": "0.82.3",
+    "@aztec/kv-store": "0.82.3",
+    "@aztec/merkle-tree": "0.82.3",
+    "@aztec/node-lib": "0.82.3",
+    "@aztec/p2p": "0.82.3",
+    "@aztec/protocol-contracts": "0.82.3",
+    "@aztec/prover-client": "0.82.3",
+    "@aztec/sequencer-client": "0.82.3",
+    "@aztec/simulator": "0.82.3",
+    "@aztec/stdlib": "0.82.3",
+    "@aztec/telemetry-client": "0.82.3",
+    "@aztec/validator-client": "0.82.3",
+    "@aztec/world-state": "0.82.3",
     "koa": "^2.14.2",
     "koa-router": "^12.0.0",
     "tslib": "^2.4.0"

package/src/aztec-node/config.ts

@@ -1,12 +1,8 @@
 import { type ArchiverConfig, archiverConfigMappings } from '@aztec/archiver/config';
-import {
-  type GenesisStateConfig,
-  type L1ContractAddresses,
-  genesisStateConfigMappings,
-  l1ContractAddressesMapping,
-} from '@aztec/ethereum';
+import { type L1ContractAddresses, l1ContractAddressesMapping } from '@aztec/ethereum';
 import { type ConfigMappingsType, booleanConfigHelper, getConfigFromMappings } from '@aztec/foundation/config';
 import { type DataStoreConfig, dataConfigMappings } from '@aztec/kv-store/config';
+import { type SharedNodeConfig, sharedNodeConfigMappings } from '@aztec/node-lib/config';
 import { type P2PConfig, p2pConfigMappings } from '@aztec/p2p/config';
 import { type ProverClientConfig, proverClientConfigMappings } from '@aztec/prover-client/config';
 import { type SequencerClientConfig, sequencerClientConfigMappings } from '@aztec/sequencer-client/config';
@@ -17,6 +13,8 @@ import { readFileSync } from 'fs';
 import { dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 
+import { type SentinelConfig, sentinelConfigMappings } from '../sentinel/config.js';
+
 export { sequencerClientConfigMappings, type SequencerClientConfig };
 
 /**
@@ -30,11 +28,12 @@ export type AztecNodeConfig = ArchiverConfig &
   Pick<ProverClientConfig, 'bbBinaryPath' | 'bbWorkingDirectory' | 'realProofs'> &
   P2PConfig &
   DataStoreConfig &
-  GenesisStateConfig & {
+  SentinelConfig &
+  SharedNodeConfig & {
+    /** L1 contracts addresses */
+    l1Contracts: L1ContractAddresses;
     /** Whether the validator is disabled for this node */
     disableValidator: boolean;
-  } & {
-    l1Contracts: L1ContractAddresses;
   };
 
 export const aztecNodeConfigMappings: ConfigMappingsType<AztecNodeConfig> = {
@@ -45,7 +44,8 @@ export const aztecNodeConfigMappings: ConfigMappingsType<AztecNodeConfig> = {
   ...proverClientConfigMappings,
   ...worldStateConfigMappings,
   ...p2pConfigMappings,
-  ...genesisStateConfigMappings,
+  ...sentinelConfigMappings,
+  ...sharedNodeConfigMappings,
   l1Contracts: {
     description: 'The deployed L1 contract addresses',
     nested: l1ContractAddressesMapping,

package/src/aztec-node/server.ts

@@ -1,4 +1,4 @@
-import { createArchiver } from '@aztec/archiver';
+import { Archiver, createArchiver } from '@aztec/archiver';
 import { BBCircuitVerifier, TestCircuitVerifier } from '@aztec/bb-prover';
 import { type BlobSinkClientInterface, createBlobSinkClient } from '@aztec/blob-sink/client';
 import {
@@ -21,6 +21,7 @@ import { SiblingPath } from '@aztec/foundation/trees';
 import type { AztecKVStore } from '@aztec/kv-store';
 import { openTmpStore } from '@aztec/kv-store/lmdb';
 import { SHA256Trunc, StandardTree, UnbalancedTree } from '@aztec/merkle-tree';
+import { trySnapshotSync, uploadSnapshot } from '@aztec/node-lib/actions';
 import { type P2P, createP2PClient } from '@aztec/p2p';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import {
@@ -74,6 +75,7 @@ import {
   TxStatus,
   type TxValidationResult,
 } from '@aztec/stdlib/tx';
+import type { ValidatorsStats } from '@aztec/stdlib/validators';
 import {
   Attributes,
   type TelemetryClient,
@@ -85,6 +87,8 @@ import {
 import { createValidatorClient } from '@aztec/validator-client';
 import { createWorldStateSynchronizer } from '@aztec/world-state';
 
+import { createSentinel } from '../sentinel/factory.js';
+import { Sentinel } from '../sentinel/sentinel.js';
 import { type AztecNodeConfig, getPackageVersion } from './config.js';
 import { NodeMetrics } from './node_metrics.js';
 
@@ -95,6 +99,9 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
   private packageVersion: string;
   private metrics: NodeMetrics;
 
+  // Prevent two snapshot operations to happen simultaneously
+  private isUploadingSnapshot = false;
+
   // Serial queue to ensure that we only send one tx at a time
   private txQueue: SerialQueue = new SerialQueue();
 
@@ -109,6 +116,7 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
     protected readonly l1ToL2MessageSource: L1ToL2MessageSource,
     protected readonly worldStateSynchronizer: WorldStateSynchronizer,
     protected readonly sequencer: SequencerClient | undefined,
+    protected readonly validatorsSentinel: Sentinel | undefined,
     protected readonly l1ChainId: number,
     protected readonly version: number,
     protected readonly globalVariableBuilder: GlobalVariableBuilder,
@@ -157,13 +165,17 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
     const dateProvider = deps.dateProvider ?? new DateProvider();
     const blobSinkClient = deps.blobSinkClient ?? createBlobSinkClient(config);
     const ethereumChain = createEthereumChain(config.l1RpcUrls, config.l1ChainId);
-    //validate that the actual chain id matches that specified in configuration
+
+    // validate that the actual chain id matches that specified in configuration
     if (config.l1ChainId !== ethereumChain.chainInfo.id) {
       throw new Error(
         `RPC URL configured for chain id ${ethereumChain.chainInfo.id} but expected id ${config.l1ChainId}`,
       );
     }
 
+    // attempt snapshot sync if possible
+    await trySnapshotSync(config, log);
+
     const archiver = await createArchiver(config, blobSinkClient, { blockUntilSync: true }, telemetry);
 
     // now create the merkle trees and the world state synchronizer
@@ -199,6 +211,9 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
 
     const validatorClient = createValidatorClient(config, { p2pClient, telemetry, dateProvider, epochCache });
 
+    const validatorsSentinel = await createSentinel(epochCache, archiver, p2pClient, config);
+    await validatorsSentinel?.start();
+
     // now create the sequencer
     const sequencer = config.disableValidator
       ? undefined
@@ -225,6 +240,7 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
       archiver,
       worldStateSynchronizer,
       sequencer,
+      validatorsSentinel,
       ethereumChain.chainInfo.id,
       config.version,
       new GlobalVariableBuilder(config),
@@ -471,6 +487,7 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
   public async stop() {
     this.log.info(`Stopping`);
     await this.txQueue.end();
+    await this.validatorsSentinel?.stop();
     await this.sequencer?.stop();
     await this.p2pClient.stop();
     await this.worldStateSynchronizer.stop();
@@ -978,6 +995,47 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
     return Promise.resolve();
   }
 
+  public getValidatorsStats(): Promise<ValidatorsStats> {
+    return this.validatorsSentinel?.computeStats() ?? Promise.resolve({ stats: {}, slotWindow: 0 });
+  }
+
+  public async startSnapshotUpload(location: string): Promise<void> {
+    // Note that we are forcefully casting the blocksource as an archiver
+    // We break support for archiver running remotely to the node
+    const archiver = this.blockSource as Archiver;
+    if (!('backupTo' in archiver)) {
+      throw new Error('Archiver implementation does not support backups. Cannot generate snapshot.');
+    }
+
+    // Test that the archiver has done an initial sync.
+    if (!archiver.isInitialSyncComplete()) {
+      throw new Error(`Archiver initial sync not complete. Cannot start snapshot.`);
+    }
+
+    // And it has an L2 block hash
+    const l2BlockHash = await archiver.getL2Tips().then(tips => tips.latest.hash);
+    if (!l2BlockHash) {
+      throw new Error(`Archiver has no latest L2 block hash downloaded. Cannot start snapshot.`);
+    }
+
+    if (this.isUploadingSnapshot) {
+      throw new Error(`Snapshot upload already in progress. Cannot start another one until complete.`);
+    }
+
+    // Do not wait for the upload to be complete to return to the caller, but flag that an operation is in progress
+    this.isUploadingSnapshot = true;
+    void uploadSnapshot(location, this.blockSource as Archiver, this.worldStateSynchronizer, this.config, this.log)
+      .then(() => {
+        this.isUploadingSnapshot = false;
+      })
+      .catch(err => {
+        this.isUploadingSnapshot = false;
+        this.log.error(`Error uploading snapshot: ${err}`);
+      });
+
+    return Promise.resolve();
+  }
+
   /**
    * Returns an instance of MerkleTreeOperations having first ensured the world state is fully synched
    * @param blockNumber - The block number at which to get the data.

package/src/sentinel/config.ts

@@ -0,0 +1,19 @@
+import { type ConfigMappingsType, booleanConfigHelper, numberConfigHelper } from '@aztec/foundation/config';
+
+export type SentinelConfig = {
+  sentinelHistoryLengthInEpochs: number;
+  sentinelEnabled: boolean;
+};
+
+export const sentinelConfigMappings: ConfigMappingsType<SentinelConfig> = {
+  sentinelHistoryLengthInEpochs: {
+    description: 'The number of L2 epochs kept of history for each validator for computing their stats.',
+    env: 'SENTINEL_HISTORY_LENGTH_IN_EPOCHS',
+    ...numberConfigHelper(24),
+  },
+  sentinelEnabled: {
+    description: 'Whether the sentinel is enabled or not.',
+    env: 'SENTINEL_ENABLED',
+    ...booleanConfigHelper(true),
+  },
+};

package/src/sentinel/factory.ts

@@ -0,0 +1,31 @@
+import type { EpochCache } from '@aztec/epoch-cache';
+import { createLogger } from '@aztec/foundation/log';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
+import { createStore } from '@aztec/kv-store/lmdb-v2';
+import type { P2PClient } from '@aztec/p2p';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+
+import type { SentinelConfig } from './config.js';
+import { Sentinel } from './sentinel.js';
+import { SentinelStore } from './store.js';
+
+export async function createSentinel(
+  epochCache: EpochCache,
+  archiver: L2BlockSource,
+  p2p: P2PClient,
+  config: SentinelConfig & DataStoreConfig,
+  logger = createLogger('node:sentinel'),
+): Promise<Sentinel | undefined> {
+  if (!config.sentinelEnabled) {
+    return undefined;
+  }
+  const kvStore = await createStore(
+    'sentinel',
+    SentinelStore.SCHEMA_VERSION,
+    config,
+    createLogger('node:sentinel:lmdb'),
+  );
+  const storeHistoryLength = config.sentinelHistoryLengthInEpochs * epochCache.getL1Constants().epochDuration;
+  const sentinelStore = new SentinelStore(kvStore, { historyLength: storeHistoryLength });
+  return new Sentinel(epochCache, archiver, p2p, sentinelStore, logger);
+}