@aztec/aztec-node 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/dest/modules/node_world_state_queries.js

@@ -0,0 +1,272 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { chunkBy } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+import { sleep } from '@aztec/foundation/sleep';
+import { MembershipWitness } from '@aztec/foundation/trees';
+import { inspectBlockParameter } from '@aztec/stdlib/block';
+import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
+import { InboxLeaf } from '@aztec/stdlib/messaging';
+import { MerkleTreeId, NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
+import { WorldStateSynchronizerError } from '@aztec/world-state';
+import { normalizeBlockParameter } from './block_parameter.js';
+/** Attempts at resolving a query and syncing world state to it before giving up (see {@link NodeWorldStateQueries.getWorldState}). */ const WORLD_STATE_SYNC_ATTEMPTS = 3;
+/** Delay between world-state sync attempts. */ const WORLD_STATE_SYNC_RETRY_DELAY_MS = 100;
+/**
+ * Serves the node's Merkle-tree and membership-witness queries against committed world-state at a
+ * requested block. Extracted from `AztecNodeService` so the block-resolution and reorg-aware sync logic
+ * can be unit-tested without standing up the whole node, and to keep `server.ts` smaller.
+ */ export class NodeWorldStateQueries {
+    worldStateSynchronizer;
+    blockSource;
+    l1ToL2MessageSource;
+    log;
+    constructor(deps){
+        this.worldStateSynchronizer = deps.worldStateSynchronizer;
+        this.blockSource = deps.blockSource;
+        this.l1ToL2MessageSource = deps.l1ToL2MessageSource;
+        this.log = deps.log ?? createLogger('node:world-state-queries');
+    }
+    async findLeavesIndexes(referenceBlock, treeId, leafValues) {
+        const committedDb = await this.getWorldState(referenceBlock);
+        const maybeIndices = await committedDb.findLeafIndices(treeId, leafValues.map((x)=>x.toBuffer()));
+        // Filter out undefined values to query block numbers only for found leaves
+        const definedIndices = maybeIndices.filter((x)=>x !== undefined);
+        // Now we find the block numbers for the defined indices
+        const blockNumbers = await committedDb.getBlockNumbersForLeafIndices(treeId, definedIndices);
+        // Build a map from leaf index to block number
+        const indexToBlockNumber = new Map();
+        for(let i = 0; i < definedIndices.length; i++){
+            const blockNumber = blockNumbers[i];
+            if (blockNumber === undefined) {
+                throw new Error(`Block number is undefined for leaf index ${definedIndices[i]} in tree ${MerkleTreeId[treeId]}`);
+            }
+            indexToBlockNumber.set(definedIndices[i], blockNumber);
+        }
+        // Get unique block numbers in order to optimize num calls to getLeafValue function.
+        const uniqueBlockNumbers = [
+            ...new Set(indexToBlockNumber.values())
+        ];
+        // Now we obtain the block hashes from the archive tree (block number = leaf index in archive tree).
+        const blockHashes = await Promise.all(uniqueBlockNumbers.map((blockNumber)=>{
+            return committedDb.getLeafValue(MerkleTreeId.ARCHIVE, BigInt(blockNumber));
+        }));
+        // Build a map from block number to block hash
+        const blockNumberToHash = new Map();
+        for(let i = 0; i < uniqueBlockNumbers.length; i++){
+            const blockHash = blockHashes[i];
+            if (blockHash === undefined) {
+                throw new Error(`Block hash is undefined for block number ${uniqueBlockNumbers[i]}`);
+            }
+            blockNumberToHash.set(uniqueBlockNumbers[i], blockHash);
+        }
+        // Create DataInBlock objects by combining indices, blockNumbers and blockHashes and return them.
+        return maybeIndices.map((index)=>{
+            if (index === undefined) {
+                return undefined;
+            }
+            const blockNumber = indexToBlockNumber.get(index);
+            if (blockNumber === undefined) {
+                throw new Error(`Block number not found for leaf index ${index} in tree ${MerkleTreeId[treeId]}`);
+            }
+            const l2BlockHash = blockNumberToHash.get(blockNumber);
+            if (l2BlockHash === undefined) {
+                throw new Error(`Block hash not found for block number ${blockNumber}`);
+            }
+            return {
+                l2BlockNumber: blockNumber,
+                l2BlockHash,
+                data: index
+            };
+        });
+    }
+    async getBlockHashMembershipWitness(referenceBlock, blockHash) {
+        // The Noir circuit checks the archive membership proof against `anchor_block_header.last_archive.root`,
+        // which is the archive tree root BEFORE the anchor block was added (i.e. the state after block N-1).
+        // So we need the world state at block N-1, not block N, to produce a sibling path matching that root.
+        const referenceBlockNumber = await this.#resolveBlockNumber(referenceBlock);
+        if (referenceBlockNumber === BlockNumber.ZERO) {
+            // Block 0 (the initial block) has an empty archive, so no membership witness can exist.
+            return undefined;
+        }
+        const committedDb = await this.getWorldState(BlockNumber(referenceBlockNumber - 1));
+        const [pathAndIndex] = await committedDb.findSiblingPaths(MerkleTreeId.ARCHIVE, [
+            blockHash
+        ]);
+        return pathAndIndex === undefined ? undefined : MembershipWitness.fromSiblingPath(pathAndIndex.index, pathAndIndex.path);
+    }
+    async getNoteHashMembershipWitness(referenceBlock, noteHash) {
+        const committedDb = await this.getWorldState(referenceBlock);
+        const [pathAndIndex] = await committedDb.findSiblingPaths(MerkleTreeId.NOTE_HASH_TREE, [
+            noteHash
+        ]);
+        return pathAndIndex === undefined ? undefined : MembershipWitness.fromSiblingPath(pathAndIndex.index, pathAndIndex.path);
+    }
+    async getL1ToL2MessageMembershipWitness(referenceBlock, l1ToL2Message) {
+        const db = await this.getWorldState(referenceBlock);
+        const [witness] = await db.findSiblingPaths(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, [
+            l1ToL2Message
+        ]);
+        if (!witness) {
+            return undefined;
+        }
+        // REFACTOR: Return a MembershipWitness object
+        return [
+            witness.index,
+            witness.path
+        ];
+    }
+    async getL1ToL2MessageCheckpoint(l1ToL2Message) {
+        const messageIndex = await this.l1ToL2MessageSource.getL1ToL2MessageIndex(l1ToL2Message);
+        return messageIndex !== undefined ? InboxLeaf.checkpointNumberFromIndex(messageIndex) : undefined;
+    }
+    /**
+   * Returns all the L2 to L1 messages in an epoch (empty array if the epoch is not found). The public
+   * `AztecNodeService.getL2ToL1Messages` that delegates here is deprecated in favor of
+   * {@link getL2ToL1MembershipWitness}.
+   * @param epoch - The epoch at which to get the data.
+   */ async getL2ToL1Messages(epoch) {
+        const blocks = await this.blockSource.getBlocks({
+            epoch,
+            onlyCheckpointed: true
+        });
+        const blocksInCheckpoints = chunkBy(blocks, (block)=>block.header.globalVariables.slotNumber);
+        return blocksInCheckpoints.map((slotBlocks)=>slotBlocks.map((block)=>block.body.txEffects.map((txEffect)=>txEffect.l2ToL1Msgs)));
+    }
+    /**
+   * Returns the L2-to-L1 membership witness for a message in `txHash`. Passthrough to the
+   * archiver's locally-cached resolver — see {@link Archiver.getL2ToL1MembershipWitness}.
+   */ getL2ToL1MembershipWitness(txHash, message, messageIndexInTx) {
+        return this.blockSource.getL2ToL1MembershipWitness(txHash, message, messageIndexInTx);
+    }
+    async getNullifierMembershipWitness(referenceBlock, nullifier) {
+        const db = await this.getWorldState(referenceBlock);
+        const [witness] = await db.findSiblingPaths(MerkleTreeId.NULLIFIER_TREE, [
+            nullifier.toBuffer()
+        ]);
+        if (!witness) {
+            return undefined;
+        }
+        const { index, path } = witness;
+        const leafPreimage = await db.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index);
+        if (!leafPreimage) {
+            return undefined;
+        }
+        return new NullifierMembershipWitness(index, leafPreimage, path);
+    }
+    async getLowNullifierMembershipWitness(referenceBlock, nullifier) {
+        const committedDb = await this.getWorldState(referenceBlock);
+        const findResult = await committedDb.getPreviousValueIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBigInt());
+        if (!findResult) {
+            return undefined;
+        }
+        const { index, alreadyPresent } = findResult;
+        if (alreadyPresent) {
+            throw new Error(`Cannot prove nullifier non-inclusion: nullifier ${nullifier.toBigInt()} already exists in the tree`);
+        }
+        const preimageData = await committedDb.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index);
+        const siblingPath = await committedDb.getSiblingPath(MerkleTreeId.NULLIFIER_TREE, BigInt(index));
+        return new NullifierMembershipWitness(BigInt(index), preimageData, siblingPath);
+    }
+    async getPublicDataWitness(referenceBlock, leafSlot) {
+        const committedDb = await this.getWorldState(referenceBlock);
+        const lowLeafResult = await committedDb.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot.toBigInt());
+        if (!lowLeafResult) {
+            return undefined;
+        } else {
+            const preimage = await committedDb.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
+            const path = await committedDb.getSiblingPath(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
+            return new PublicDataWitness(lowLeafResult.index, preimage, path);
+        }
+    }
+    async getPublicStorageAt(referenceBlock, contract, slot) {
+        const committedDb = await this.getWorldState(referenceBlock);
+        const leafSlot = await computePublicDataTreeLeafSlot(contract, slot);
+        const lowLeafResult = await committedDb.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot.toBigInt());
+        if (!lowLeafResult || !lowLeafResult.alreadyPresent) {
+            return Fr.ZERO;
+        }
+        const preimage = await committedDb.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
+        return preimage.leaf.value;
+    }
+    /**
+   * Returns an instance of MerkleTreeOperations having first ensured the world state is synced to the requested
+   * block on the correct fork. Every query variant is resolved to a concrete (block number, block hash), which is
+   * threaded through both the sync and the snapshot read so a reorg that replaced the block at that height is
+   * detected rather than served silently. Transient failures — a prune landing between resolution and sync, or a
+   * fork flip caught at either the sync or the snapshot stage — are retried a few times, re-resolving the query
+   * against the updated chain each time; terminal failures — an unknown block hash at resolution, or a block whose
+   * history world state has pruned away — are thrown immediately.
+   * @param block - The block parameter (block number, block hash, or tag) at which to get the data.
+   * @returns An instance of a committed MerkleTreeOperations
+   */ async getWorldState(block) {
+        const query = normalizeBlockParameter(block);
+        for(let attempt = 1;; attempt++){
+            try {
+                return await this.#resolveWorldState(query);
+            } catch (err) {
+                if (attempt >= WORLD_STATE_SYNC_ATTEMPTS || !(err instanceof WorldStateSynchronizerError)) {
+                    throw err;
+                }
+                this.log.verbose(`Retrying world state query after sync failure: ${err.message}`, {
+                    attempt,
+                    block: inspectBlockParameter(block)
+                });
+                await sleep(WORLD_STATE_SYNC_RETRY_DELAY_MS);
+            }
+        }
+    }
+    /**
+   * Resolves `query` to a concrete (block number, block hash), syncs world state to that exact fork, and returns
+   * the committed db (for `proposed` queries) or the fork-verified snapshot at the resolved block.
+   */ async #resolveWorldState(query) {
+        // User requests 'latest on the current fork', so the committed db is returned unverified
+        if ('tag' in query && query.tag === 'proposed') {
+            this.log.debug(`Using committed db for latest block`);
+            await this.worldStateSynchronizer.syncImmediate();
+            return this.worldStateSynchronizer.getCommitted();
+        }
+        // Resolve the query against the block source BEFORE syncing to a concrete (number, hash), and drive the sync to
+        // that exact fork. Resolving after the sync races the block source: the resolved tip can advance past what world
+        // state synced while the sync is in flight. Passing the hash makes the sync reorg-aware — it barriers until the
+        // archive-tree commit for that block has landed and verifies it matches the requested fork, throwing otherwise.
+        const { blockNumber, blockHash } = await this.#resolveBlockNumberAndHash(query);
+        const blockSyncedTo = await this.worldStateSynchronizer.syncImmediate(blockNumber, blockHash);
+        // The fork could flip between it returning and the snapshot being read, so getVerifiedSnapshot pins the
+        // returned view to the resolved fork (re-resolved by the retry loop on mismatch).
+        this.log.debug(`Using verified snapshot for block ${blockNumber}, world state synced upto ${blockSyncedTo}`);
+        return await this.worldStateSynchronizer.getVerifiedSnapshot(blockNumber, blockHash);
+    }
+    /** Resolves any {@link BlockParameter} variant to its concrete `(blockNumber, blockHash)` via the block source. */ async #resolveBlockNumberAndHash(query) {
+        const blockData = await this.blockSource.getBlockData(query);
+        if (blockData === undefined) {
+            this.#throwOnUndefinedBlockData(query);
+        }
+        return {
+            blockNumber: blockData.header.getBlockNumber(),
+            blockHash: blockData.blockHash
+        };
+    }
+    /** Resolves any {@link BlockParameter} variant to a concrete block number. */ async #resolveBlockNumber(block) {
+        const blockQuery = normalizeBlockParameter(block);
+        const blockNumber = await this.blockSource.getBlockNumber(blockQuery);
+        if (blockNumber === undefined) {
+            this.#throwOnUndefinedBlockData(blockQuery);
+        }
+        return blockNumber;
+    }
+    /**
+   * Hash and archive misses are terminal (an unknown block, likely a reorg); tag and number misses are transient —
+   * the block may have been pruned between the tag->number resolution and this data read, or may simply not have
+   * arrived yet — and surface as {@link WorldStateSynchronizerError} so the retry loop re-resolves against the
+   * current chain.
+   */ #throwOnUndefinedBlockData(query) {
+        if ('hash' in query) {
+            throw new Error(`Block hash ${query.hash.toString()} not found when resolving query. If the node API has been queried with anchor block hash possibly a reorg has occurred.`);
+        }
+        if ('archive' in query) {
+            throw new Error(`Block with archive ${query.archive.toString()} not found when resolving query.`);
+        }
+        throw new WorldStateSynchronizerError(`Block not found for ${inspectBlockParameter(query)} when resolving query.`);
+    }
+}

package/dest/sentinel/config.d.ts

@@ -1,8 +1,9 @@
 import { type ConfigMappingsType } from '@aztec/foundation/config';
 export type SentinelConfig = {
     sentinelHistoryLengthInEpochs: number;
-    sentinelHistoricProvenPerformanceLengthInEpochs: number;
+    sentinelHistoricEpochPerformanceLengthInEpochs: number;
     sentinelEnabled: boolean;
+    sentinelEpochEndBufferSlots: number;
 };
 export declare const sentinelConfigMappings: ConfigMappingsType<SentinelConfig>;
-//# sourceMappingURL=config.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VudGluZWwvY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLGtCQUFrQixFQUEyQyxNQUFNLDBCQUEwQixDQUFDO0FBRTVHLE1BQU0sTUFBTSxjQUFjLEdBQUc7SUFDM0IsNkJBQTZCLEVBQUUsTUFBTSxDQUFDO0lBQ3RDLDhDQUE4QyxFQUFFLE1BQU0sQ0FBQztJQUN2RCxlQUFlLEVBQUUsT0FBTyxDQUFDO0lBQ3pCLDJCQUEyQixFQUFFLE1BQU0sQ0FBQztDQUNyQyxDQUFDO0FBRUYsZUFBTyxNQUFNLHNCQUFzQixFQUFFLGtCQUFrQixDQUFDLGNBQWMsQ0F1Q3JFLENBQUMifQ==

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

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/sentinel/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAA2C,MAAM,0BAA0B,CAAC;AAE5G,MAAM,MAAM,cAAc,GAAG;IAC3B,6BAA6B,EAAE,MAAM,CAAC;IACtC,+CAA+C,EAAE,MAAM,CAAC;IACxD,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,kBAAkB,CAAC,cAAc,CA4BrE,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/sentinel/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAA2C,MAAM,0BAA0B,CAAC;AAE5G,MAAM,MAAM,cAAc,GAAG;IAC3B,6BAA6B,EAAE,MAAM,CAAC;IACtC,8CAA8C,EAAE,MAAM,CAAC;IACvD,eAAe,EAAE,OAAO,CAAC;IACzB,2BAA2B,EAAE,MAAM,CAAC;CACrC,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,kBAAkB,CAAC,cAAc,CAuCrE,CAAC"}

package/dest/sentinel/config.js

@@ -6,8 +6,9 @@ export const sentinelConfigMappings = {
         ...numberConfigHelper(24)
     },
     /**
-   * The number of L2 epochs kept of proven performance history for each validator.
-   * This value must be large enough so that we have proven performance for every validator
+   * The number of L2 epochs kept of per-epoch performance history for each validator. End-of-epoch
+   * activity is recorded here and used to decide consecutive-epoch inactivity slashing.
+   * This value must be large enough so that we have epoch performance for every validator
    * for at least slashInactivityConsecutiveEpochThreshold. Assuming this value is 3,
    * and the committee size is 48, and we have 10k validators, then we pick 48 out of 10k each draw.
    * For any fixed element, per-draw prob = 48/10000 = 0.0048.
@@ -16,14 +17,23 @@ export const sentinelConfigMappings = {
    * - 90% chance: n = 1108
    * - 95% chance: n = 1310
    * - 99% chance: n = 1749
-   */ sentinelHistoricProvenPerformanceLengthInEpochs: {
-        description: 'The number of L2 epochs kept of proven performance history for each validator.',
-        env: 'SENTINEL_HISTORIC_PROVEN_PERFORMANCE_LENGTH_IN_EPOCHS',
+   */ sentinelHistoricEpochPerformanceLengthInEpochs: {
+        description: 'The number of L2 epochs kept of per-epoch performance history for each validator.',
+        env: 'SENTINEL_HISTORIC_EPOCH_PERFORMANCE_LENGTH_IN_EPOCHS',
         ...numberConfigHelper(2000)
     },
     sentinelEnabled: {
         description: 'Whether the sentinel is enabled or not.',
         env: 'SENTINEL_ENABLED',
         ...booleanConfigHelper(false)
+    },
+    /**
+   * Number of L2 slots to wait after the end of an epoch before computing the epoch's performance.
+   * The buffer allows P2P attestations and the local archiver to settle. Higher values reduce the
+   * risk of misjudging late-arriving activity at the cost of delayed slashing.
+   */ sentinelEpochEndBufferSlots: {
+        description: 'Number of L2 slots after the end of an epoch before the sentinel evaluates it.',
+        env: 'SENTINEL_EPOCH_END_BUFFER_SLOTS',
+        ...numberConfigHelper(2)
     }
 };

package/dest/sentinel/factory.d.ts

@@ -1,9 +1,11 @@
 import type { EpochCache } from '@aztec/epoch-cache';
-import type { DataStoreConfig } from '@aztec/kv-store/config';
 import type { P2PClient } from '@aztec/p2p';
 import type { L2BlockSource } from '@aztec/stdlib/block';
-import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
+import type { CheckpointReexecutionTracker } from '@aztec/stdlib/checkpoint';
+import type { ChainConfig } from '@aztec/stdlib/config';
+import type { SlasherConfig, ValidatorClientConfig } from '@aztec/stdlib/interfaces/server';
+import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 import type { SentinelConfig } from './config.js';
 import { Sentinel } from './sentinel.js';
-export declare function createSentinel(epochCache: EpochCache, archiver: L2BlockSource, p2p: P2PClient, config: SentinelConfig & DataStoreConfig & SlasherConfig, logger?: import("@aztec/foundation/log").Logger): Promise<Sentinel | undefined>;
-//# sourceMappingURL=factory.d.ts.map
+export declare function createSentinel(epochCache: EpochCache, archiver: L2BlockSource, p2p: P2PClient, reexecutionTracker: CheckpointReexecutionTracker, config: SentinelConfig & DataStoreConfig & SlasherConfig & Pick<ChainConfig, 'l1ChainId' | 'rollupAddress'> & Pick<ValidatorClientConfig, 'disableValidator'>, logger?: import("@aztec/foundation/log").Logger): Promise<Sentinel | undefined>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFjdG9yeS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NlbnRpbmVsL2ZhY3RvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFHckQsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0sWUFBWSxDQUFDO0FBQzVDLE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxFQUFFLDRCQUE0QixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDN0UsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDeEQsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLHFCQUFxQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDNUYsT0FBTyxLQUFLLEVBQUUsZUFBZSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFOUQsT0FBTyxLQUFLLEVBQUUsY0FBYyxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQ2xELE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFHekMsd0JBQXNCLGNBQWMsQ0FDbEMsVUFBVSxFQUFFLFVBQVUsRUFDdEIsUUFBUSxFQUFFLGFBQWEsRUFDdkIsR0FBRyxFQUFFLFNBQVMsRUFDZCxrQkFBa0IsRUFBRSw0QkFBNEIsRUFDaEQsTUFBTSxFQUFFLGNBQWMsR0FDcEIsZUFBZSxHQUNmLGFBQWEsR0FDYixJQUFJLENBQUMsV0FBVyxFQUFFLFdBQVcsR0FBRyxlQUFlLENBQUMsR0FDaEQsSUFBSSxDQUFDLHFCQUFxQixFQUFFLGtCQUFrQixDQUFDLEVBQ2pELE1BQU0seUNBQWdDLEdBQ3JDLE9BQU8sQ0FBQyxRQUFRLEdBQUcsU0FBUyxDQUFDLENBb0IvQiJ9

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

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/sentinel/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAErE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAGzC,wBAAsB,cAAc,CAClC,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,aAAa,EACvB,GAAG,EAAE,SAAS,EACd,MAAM,EAAE,cAAc,GAAG,eAAe,GAAG,aAAa,EACxD,MAAM,yCAAgC,GACrC,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CAiB/B"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/sentinel/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,0BAA0B,CAAC;AAC7E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAC5F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAGzC,wBAAsB,cAAc,CAClC,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,aAAa,EACvB,GAAG,EAAE,SAAS,EACd,kBAAkB,EAAE,4BAA4B,EAChD,MAAM,EAAE,cAAc,GACpB,eAAe,GACf,aAAa,GACb,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,eAAe,CAAC,GAChD,IAAI,CAAC,qBAAqB,EAAE,kBAAkB,CAAC,EACjD,MAAM,yCAAgC,GACrC,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CAoB/B"}

package/dest/sentinel/factory.js

@@ -2,16 +2,23 @@ import { createLogger } from '@aztec/foundation/log';
 import { createStore } from '@aztec/kv-store/lmdb-v2';
 import { Sentinel } from './sentinel.js';
 import { SentinelStore } from './store.js';
-export async function createSentinel(epochCache, archiver, p2p, config, logger = createLogger('node:sentinel')) {
-    if (!config.sentinelEnabled) {
+export async function createSentinel(epochCache, archiver, p2p, reexecutionTracker, config, logger = createLogger('node:sentinel')) {
+    const runsValidator = !config.disableValidator;
+    if (!runsValidator && !config.sentinelEnabled) {
+        logger.verbose('Sentinel is disabled');
         return undefined;
     }
-    const kvStore = await createStore('sentinel', SentinelStore.SCHEMA_VERSION, config, createLogger('node:sentinel:lmdb'));
+    if (runsValidator) {
+        logger.info('Enabling sentinel since this node runs a validator');
+    } else {
+        logger.info('Enabling sentinel from SENTINEL_ENABLED configuration');
+    }
+    const kvStore = await createStore('sentinel', SentinelStore.SCHEMA_VERSION, config, logger.getBindings());
     const storeHistoryLength = config.sentinelHistoryLengthInEpochs * epochCache.getL1Constants().epochDuration;
-    const storeHistoricProvenPerformanceLength = config.sentinelHistoricProvenPerformanceLengthInEpochs;
+    const storeHistoricEpochPerformanceLength = config.sentinelHistoricEpochPerformanceLengthInEpochs;
     const sentinelStore = new SentinelStore(kvStore, {
         historyLength: storeHistoryLength,
-        historicProvenPerformanceLength: storeHistoricProvenPerformanceLength
+        historicEpochPerformanceLength: storeHistoricEpochPerformanceLength
     });
-    return new Sentinel(epochCache, archiver, p2p, sentinelStore, config, logger);
+    return new Sentinel(epochCache, archiver, p2p, sentinelStore, reexecutionTracker, config, logger);
 }

package/dest/sentinel/index.d.ts

@@ -1,3 +1,3 @@
 export { Sentinel } from './sentinel.js';
 export type { ValidatorsStats, ValidatorStats, ValidatorStatusHistory, ValidatorStatusInSlot, } from '@aztec/stdlib/validators';
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zZW50aW5lbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpDLFlBQVksRUFDVixlQUFlLEVBQ2YsY0FBYyxFQUNkLHNCQUFzQixFQUN0QixxQkFBcUIsR0FDdEIsTUFBTSwwQkFBMEIsQ0FBQyJ9