@aztec/aztec-node 0.0.1-commit.3fd054f6 → 0.0.1-commit.431c48d

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;
+    holdOff;
+    log;
+    constructor(deps){
+        this.worldStateSynchronizer = deps.worldStateSynchronizer;
+        this.blockSource = deps.blockSource;
+        this.l1ToL2MessageSource = deps.l1ToL2MessageSource;
+        this.holdOff = deps.holdOff;
+        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 { blockNumber: referenceBlockNumber } = await this.#resolveBlockNumberAndHash(normalizeBlockParameter(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 sync 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 — a query that resolves to no block, 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);
+        // 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, so the sync can be driven to a concrete
+        // (number, hash). Resolving after the sync races the block source: the resolved tip can advance past what world
+        // state synced while the sync is in flight. Resolving here rather than inside the retry loop also keeps a
+        // retry from re-entering the hold-off, which would multiply the wait a client experiences by the attempt count.
+        let resolved = await this.#resolveBlockNumberAndHash(query);
+        for(let attempt = 1;; attempt++){
+            try {
+                return await this.#resolveWorldState(resolved);
+            } 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);
+                resolved = await this.#resolveBlockNumberAndHash(query, {
+                    holdOff: false
+                });
+            }
+        }
+    }
+    /**
+   * Syncs world state to the resolved fork and returns the fork-verified snapshot at that block. 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.
+   */ async #resolveWorldState({ blockNumber, blockHash }) {
+        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)`, holding the query
+   * briefly (unless the caller opts out) when it references a block the node is about to see.
+   */ async #resolveBlockNumberAndHash(query, opts = {}) {
+        const blockData = await this.holdOff.getBlockData(query, opts);
+        if (blockData === undefined) {
+            this.#throwOnUndefinedBlockData(query);
+        }
+        return {
+            blockNumber: blockData.header.getBlockNumber(),
+            blockHash: blockData.blockHash
+        };
+    }
+    /**
+   * Hash and archive misses report an unknown block (likely a reorg); tag and number misses report a transient
+   * condition — the block may have been pruned, or may simply not have arrived yet — and are distinguished to the
+   * caller as a {@link WorldStateSynchronizerError}.
+   */ #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/modules/unseen_block_hold_off.d.ts

@@ -0,0 +1,52 @@
+import { type Logger } from '@aztec/foundation/log';
+import { type BlockData, type L2Block, type L2BlockSource, type L2BlockSourceEventEmitter, type NormalizedBlockParameter } from '@aztec/stdlib/block';
+/** Max requests held simultaneously. Beyond this, misses fail fast as if the hold-off were disabled. */
+export declare const MAX_CONCURRENT_HOLDS = 100;
+/** Wait budgets for {@link UnseenBlockHoldOff}, in milliseconds. Zero (or negative) disables a budget. */
+export type UnseenBlockHoldOffConfig = {
+    /** Budget for a query anchored on the block number right after the node's proposed tip. */
+    byNumberWaitMs: number;
+    /** Budget for a query anchored on a block hash or archive root the node does not know. */
+    byHashWaitMs: number;
+};
+/** Options for a single {@link UnseenBlockHoldOff} query. */
+export type UnseenBlockHoldOffOptions = {
+    /** Set to false to resolve without ever waiting (used by callers that already spent their budget). */
+    holdOff?: boolean;
+};
+/**
+ * Resolves RPC block anchors against the block source, briefly holding a request whose anchor the node is about to
+ * see instead of failing it immediately.
+ *
+ * Behind a load balancer a client can sync to block N+1 through one node and then anchor follow-up queries against
+ * another node that is still at block N. Failing those queries aborts a whole client flow over a skew that resolves
+ * in under a block time, so a miss on an anchor that plausibly lies just ahead of the tip is retried for a bounded
+ * budget. Everything else — a tag, a number far past the tip, a budget of zero, or too many requests already held —
+ * resolves exactly as the bare block source would.
+ *
+ * Held requests do not poll at a rate of their own choosing: they all sleep on one wake-up that the block source
+ * triggers when it reports it moved, so the source is read when there is something new to read and, failing that, at
+ * most once per {@link MAX_SLEEP_MS}. A source that reports no updates cannot wake them, so it never holds anything
+ * off.
+ */
+export declare class UnseenBlockHoldOff {
+    #private;
+    private readonly blockSource;
+    private readonly config;
+    private activeHolds;
+    private readonly log;
+    /** Shared by every held request; interrupted on a source update. Undefined for a source that reports none. */
+    private readonly wakeup;
+    constructor(blockSource: L2BlockSource | L2BlockSourceEventEmitter, config: UnseenBlockHoldOffConfig, log?: Logger);
+    /** Number of requests currently held waiting for their anchor block. Exposed for tests and diagnostics. */
+    get holds(): number;
+    /**
+     * Resolves `query` to block metadata, holding off briefly when it references a block the node is about to see.
+     * Returns undefined on a miss, so callers keep whatever behavior they had before (throwing or returning
+     * undefined) — the hold-off only delays that outcome.
+     */
+    getBlockData(query: NormalizedBlockParameter, opts?: UnseenBlockHoldOffOptions): Promise<BlockData | undefined>;
+    /** Resolves `query` to a full block with its transactions, holding off as {@link getBlockData} does. */
+    getBlock(query: NormalizedBlockParameter, opts?: UnseenBlockHoldOffOptions): Promise<L2Block | undefined>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5zZWVuX2Jsb2NrX2hvbGRfb2ZmLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbW9kdWxlcy91bnNlZW5fYmxvY2tfaG9sZF9vZmYudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFnQixNQUFNLHVCQUF1QixDQUFDO0FBR2xFLE9BQU8sRUFDTCxLQUFLLFNBQVMsRUFFZCxLQUFLLE9BQU8sRUFDWixLQUFLLGFBQWEsRUFDbEIsS0FBSyx5QkFBeUIsRUFFOUIsS0FBSyx3QkFBd0IsRUFHOUIsTUFBTSxxQkFBcUIsQ0FBQztBQVM3Qix3R0FBd0c7QUFDeEcsZUFBTyxNQUFNLG9CQUFvQixNQUFNLENBQUM7QUFFeEMsMEdBQTBHO0FBQzFHLE1BQU0sTUFBTSx3QkFBd0IsR0FBRztJQUNyQywyRkFBMkY7SUFDM0YsY0FBYyxFQUFFLE1BQU0sQ0FBQztJQUN2QiwwRkFBMEY7SUFDMUYsWUFBWSxFQUFFLE1BQU0sQ0FBQztDQUN0QixDQUFDO0FBRUYsNkRBQTZEO0FBQzdELE1BQU0sTUFBTSx5QkFBeUIsR0FBRztJQUN0QyxzR0FBc0c7SUFDdEcsT0FBTyxDQUFDLEVBQUUsT0FBTyxDQUFDO0NBQ25CLENBQUM7QUFFRjs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUNILHFCQUFhLGtCQUFrQjs7SUFPM0IsT0FBTyxDQUFDLFFBQVEsQ0FBQyxXQUFXO0lBQzVCLE9BQU8sQ0FBQyxRQUFRLENBQUMsTUFBTTtJQVB6QixPQUFPLENBQUMsV0FBVyxDQUFLO0lBQ3hCLE9BQU8sQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFTO0lBQzdCLDhHQUE4RztJQUM5RyxPQUFPLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBaUM7SUFFeEQsWUFDbUIsV0FBVyxFQUFFLGFBQWEsR0FBRyx5QkFBeUIsRUFDdEQsTUFBTSxFQUFFLHdCQUF3QixFQUNqRCxHQUFHLENBQUMsRUFBRSxNQUFNLEVBV2I7SUFFRCwyR0FBMkc7SUFDM0csSUFBVyxLQUFLLElBQUksTUFBTSxDQUV6QjtJQUVEOzs7O09BSUc7SUFDSSxZQUFZLENBQ2pCLEtBQUssRUFBRSx3QkFBd0IsRUFDL0IsSUFBSSxHQUFFLHlCQUE4QixHQUNuQyxPQUFPLENBQUMsU0FBUyxHQUFHLFNBQVMsQ0FBQyxDQUVoQztJQUVELHdHQUF3RztJQUNqRyxRQUFRLENBQUMsS0FBSyxFQUFFLHdCQUF3QixFQUFFLElBQUksR0FBRSx5QkFBOEIsR0FBRyxPQUFPLENBQUMsT0FBTyxHQUFHLFNBQVMsQ0FBQyxDQUVuSDtDQXNHRiJ9

package/dest/modules/unseen_block_hold_off.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unseen_block_hold_off.d.ts","sourceRoot":"","sources":["../../src/modules/unseen_block_hold_off.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAGlE,OAAO,EACL,KAAK,SAAS,EAEd,KAAK,OAAO,EACZ,KAAK,aAAa,EAClB,KAAK,yBAAyB,EAE9B,KAAK,wBAAwB,EAG9B,MAAM,qBAAqB,CAAC;AAS7B,wGAAwG;AACxG,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAExC,0GAA0G;AAC1G,MAAM,MAAM,wBAAwB,GAAG;IACrC,2FAA2F;IAC3F,cAAc,EAAE,MAAM,CAAC;IACvB,0FAA0F;IAC1F,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,6DAA6D;AAC7D,MAAM,MAAM,yBAAyB,GAAG;IACtC,sGAAsG;IACtG,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,qBAAa,kBAAkB;;IAO3B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAPzB,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,8GAA8G;IAC9G,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiC;IAExD,YACmB,WAAW,EAAE,aAAa,GAAG,yBAAyB,EACtD,MAAM,EAAE,wBAAwB,EACjD,GAAG,CAAC,EAAE,MAAM,EAWb;IAED,2GAA2G;IAC3G,IAAW,KAAK,IAAI,MAAM,CAEzB;IAED;;;;OAIG;IACI,YAAY,CACjB,KAAK,EAAE,wBAAwB,EAC/B,IAAI,GAAE,yBAA8B,GACnC,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAEhC;IAED,wGAAwG;IACjG,QAAQ,CAAC,KAAK,EAAE,wBAAwB,EAAE,IAAI,GAAE,yBAA8B,GAAG,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAEnH;CAsGF"}

package/dest/modules/unseen_block_hold_off.js

@@ -0,0 +1,150 @@
+import { createLogger } from '@aztec/foundation/log';
+import { InterruptibleSleep } from '@aztec/foundation/sleep';
+import { Timer } from '@aztec/foundation/timer';
+import { L2BlockSourceEvents, getBlockSourceEmitter, inspectBlockParameter } from '@aztec/stdlib/block';
+/**
+ * Longest a held request sleeps before re-reading the block source anyway. Held requests are woken by the source
+ * reporting an update, so this only bounds how long one waits when it misses the update that added its block: the
+ * source can commit between a request's read and its sleep, and a request that is not sleeping yet is not woken.
+ */ const MAX_SLEEP_MS = 1000;
+/** Max requests held simultaneously. Beyond this, misses fail fast as if the hold-off were disabled. */ export const MAX_CONCURRENT_HOLDS = 100;
+/**
+ * Resolves RPC block anchors against the block source, briefly holding a request whose anchor the node is about to
+ * see instead of failing it immediately.
+ *
+ * Behind a load balancer a client can sync to block N+1 through one node and then anchor follow-up queries against
+ * another node that is still at block N. Failing those queries aborts a whole client flow over a skew that resolves
+ * in under a block time, so a miss on an anchor that plausibly lies just ahead of the tip is retried for a bounded
+ * budget. Everything else — a tag, a number far past the tip, a budget of zero, or too many requests already held —
+ * resolves exactly as the bare block source would.
+ *
+ * Held requests do not poll at a rate of their own choosing: they all sleep on one wake-up that the block source
+ * triggers when it reports it moved, so the source is read when there is something new to read and, failing that, at
+ * most once per {@link MAX_SLEEP_MS}. A source that reports no updates cannot wake them, so it never holds anything
+ * off.
+ */ export class UnseenBlockHoldOff {
+    blockSource;
+    config;
+    activeHolds;
+    log;
+    /** Shared by every held request; interrupted on a source update. Undefined for a source that reports none. */ wakeup;
+    constructor(blockSource, config, log){
+        this.blockSource = blockSource;
+        this.config = config;
+        this.activeHolds = 0;
+        this.log = log ?? createLogger('node:unseen-block-hold-off');
+        const emitter = getBlockSourceEmitter(blockSource);
+        if (emitter === undefined) {
+            this.log.verbose(`Block source reports no updates, queries for unseen blocks will not be held off`);
+        } else {
+            const wakeup = new InterruptibleSleep();
+            this.wakeup = wakeup;
+            emitter.on(L2BlockSourceEvents.L2BlockSourceUpdated, ()=>wakeup.interrupt());
+        }
+    }
+    /** Number of requests currently held waiting for their anchor block. Exposed for tests and diagnostics. */ get holds() {
+        return this.activeHolds;
+    }
+    /**
+   * Resolves `query` to block metadata, holding off briefly when it references a block the node is about to see.
+   * Returns undefined on a miss, so callers keep whatever behavior they had before (throwing or returning
+   * undefined) — the hold-off only delays that outcome.
+   */ getBlockData(query, opts = {}) {
+        return this.#readWithHoldOff(query, (q)=>this.blockSource.getBlockData(q), opts);
+    }
+    /** Resolves `query` to a full block with its transactions, holding off as {@link getBlockData} does. */ getBlock(query, opts = {}) {
+        return this.#readWithHoldOff(query, (q)=>this.blockSource.getBlock(q), opts);
+    }
+    /**
+   * Reads `query` through `read`, and on a miss waits for the block it names before reading once more. Subject to the
+   * concurrent-hold cap: once it is saturated a miss resolves without waiting, as it would with the hold-off
+   * disabled.
+   */ async #readWithHoldOff(query, read, opts) {
+        const value = await read(query);
+        if (value !== undefined || opts.holdOff === false) {
+            return value;
+        }
+        const arrived = await this.#waitForBlock(query, await this.#resolveWaitBudgetMs(query));
+        return arrived ? await read(query) : undefined;
+    }
+    /**
+   * Waits for the block `query` names to show up on the block source, for at most `waitMs`, and reports whether it
+   * did. Returns false without waiting when the source reports no updates, when the budget is empty, or when the
+   * concurrent-hold cap is saturated, so a miss fails as fast as it would with the hold-off disabled.
+   *
+   * Arrival is checked on block metadata rather than through the caller's read, so a held request costs a metadata
+   * read per wake-up whatever it asked for: a held `getBlock` would otherwise reconstruct a whole block with its
+   * transactions on every wake-up only to find it is not the one it is waiting for.
+   *
+   * A budget is approximate: the deadline is only re-checked after a sleep, so the actual wait can exceed it by the
+   * read's own latency.
+   */ async #waitForBlock(query, waitMs) {
+        const wakeup = this.wakeup;
+        if (wakeup === undefined || !Number.isFinite(waitMs) || waitMs <= 0) {
+            return false;
+        }
+        const blockParameter = inspectBlockParameter(query);
+        if (this.activeHolds >= MAX_CONCURRENT_HOLDS) {
+            this.log.verbose(`Not holding off query for unseen block, too many requests already held`, {
+                blockParameter,
+                holds: this.activeHolds
+            });
+            return false;
+        }
+        this.activeHolds++;
+        const timer = new Timer();
+        try {
+            this.log.verbose(`Holding off query for unseen block`, {
+                blockParameter,
+                waitMs,
+                holds: this.activeHolds
+            });
+            while(timer.ms() < waitMs){
+                await wakeup.sleep(Math.min(waitMs - timer.ms(), MAX_SLEEP_MS));
+                const data = await this.blockSource.getBlockData(query);
+                if (data !== undefined) {
+                    this.log.verbose(`Unseen block arrived after ${timer.ms()}ms`, {
+                        blockParameter,
+                        blockNumber: data.header.getBlockNumber(),
+                        elapsedMs: timer.ms()
+                    });
+                    return true;
+                }
+            }
+            this.log.verbose(`Gave up waiting for unseen block after ${timer.ms()}ms`, {
+                blockParameter,
+                waitMs,
+                elapsedMs: timer.ms()
+            });
+            return false;
+        } finally{
+            this.activeHolds--;
+        }
+    }
+    /**
+   * Budget for waiting on a missing anchor, decided once on entry rather than per wake-up. A tag always resolves
+   * against the current tip, so a tag miss is never a skew. A number is only worth waiting on when it is the very
+   * next block: further ahead the client is not merely one block in front, and at or below the tip the block was
+   * pruned or reorged away. A hash or archive root carries no height, so "one ahead" and "reorged away" are
+   * indistinguishable and both get the shorter hash budget.
+   *
+   * The genesis block hash is the one hash never worth waiting on: a client anchors on it before it has synced any
+   * block (as a PXE does for its first tagged-log queries), and the block is synthetic, so a source that does not
+   * answer for it now never will.
+   */ async #resolveWaitBudgetMs(query) {
+        if ('tag' in query) {
+            return 0;
+        }
+        if ('number' in query) {
+            const tip = await this.blockSource.getBlockNumber();
+            return query.number === tip + 1 ? this.config.byNumberWaitMs : 0;
+        }
+        if ('hash' in query && this.#isGenesisBlockHash(query.hash)) {
+            return 0;
+        }
+        return this.config.byHashWaitMs;
+    }
+    /** True when `hash` names the synthetic genesis block, which never arrives and so is never waited for. */ #isGenesisBlockHash(hash) {
+        return hash.equals(this.blockSource.getGenesisBlockHash());
+    }
+}

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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VudGluZWwvY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLGtCQUFrQixFQUEyQyxNQUFNLDBCQUEwQixDQUFDO0FBRTVHLE1BQU0sTUFBTSxjQUFjLEdBQUc7SUFDM0IsNkJBQTZCLEVBQUUsTUFBTSxDQUFDO0lBQ3RDLCtDQUErQyxFQUFFLE1BQU0sQ0FBQztJQUN4RCxlQUFlLEVBQUUsT0FBTyxDQUFDO0NBQzFCLENBQUM7QUFFRixlQUFPLE1BQU0sc0JBQXNCLEVBQUUsa0JBQWtCLENBQUMsY0FBYyxDQTRCckUsQ0FBQyJ9
+//# 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 { 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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFjdG9yeS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NlbnRpbmVsL2ZhY3RvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFHckQsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0sWUFBWSxDQUFDO0FBQzVDLE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ3JFLE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRTlELE9BQU8sS0FBSyxFQUFFLGNBQWMsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUNsRCxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBR3pDLHdCQUFzQixjQUFjLENBQ2xDLFVBQVUsRUFBRSxVQUFVLEVBQ3RCLFFBQVEsRUFBRSxhQUFhLEVBQ3ZCLEdBQUcsRUFBRSxTQUFTLEVBQ2QsTUFBTSxFQUFFLGNBQWMsR0FBRyxlQUFlLEdBQUcsYUFBYSxFQUN4RCxNQUFNLHlDQUFnQyxHQUNyQyxPQUFPLENBQUMsUUFBUSxHQUFHLFNBQVMsQ0FBQyxDQVkvQiJ9
+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;AAGrD,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;AACrE,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,MAAM,EAAE,cAAc,GAAG,eAAe,GAAG,aAAa,EACxD,MAAM,yCAAgC,GACrC,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CAY/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;
     }
+    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);
 }