@lodestar/beacon-node 1.50.0-dev.040a952dd7 → 1.50.0-dev.199b9d3a1f

package/package.json

@@ -11,7 +11,7 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.50.0-dev.040a952dd7",
+  "version": "1.50.0-dev.199b9d3a1f",
   "type": "module",
   "exports": {
     ".": {
@@ -127,17 +127,17 @@
     "@libp2p/prometheus-metrics": "^5.0.28",
     "@libp2p/tcp": "^11.0.27",
     "@libp2p/utils": "^7.4.0",
-    "@lodestar/api": "^1.50.0-dev.040a952dd7",
-    "@lodestar/config": "^1.50.0-dev.040a952dd7",
-    "@lodestar/db": "^1.50.0-dev.040a952dd7",
-    "@lodestar/fork-choice": "^1.50.0-dev.040a952dd7",
-    "@lodestar/logger": "^1.50.0-dev.040a952dd7",
-    "@lodestar/params": "^1.50.0-dev.040a952dd7",
-    "@lodestar/reqresp": "^1.50.0-dev.040a952dd7",
-    "@lodestar/state-transition": "^1.50.0-dev.040a952dd7",
-    "@lodestar/types": "^1.50.0-dev.040a952dd7",
-    "@lodestar/utils": "^1.50.0-dev.040a952dd7",
-    "@lodestar/validator": "^1.50.0-dev.040a952dd7",
+    "@lodestar/api": "^1.50.0-dev.199b9d3a1f",
+    "@lodestar/config": "^1.50.0-dev.199b9d3a1f",
+    "@lodestar/db": "^1.50.0-dev.199b9d3a1f",
+    "@lodestar/fork-choice": "^1.50.0-dev.199b9d3a1f",
+    "@lodestar/logger": "^1.50.0-dev.199b9d3a1f",
+    "@lodestar/params": "^1.50.0-dev.199b9d3a1f",
+    "@lodestar/reqresp": "^1.50.0-dev.199b9d3a1f",
+    "@lodestar/state-transition": "^1.50.0-dev.199b9d3a1f",
+    "@lodestar/types": "^1.50.0-dev.199b9d3a1f",
+    "@lodestar/utils": "^1.50.0-dev.199b9d3a1f",
+    "@lodestar/validator": "^1.50.0-dev.199b9d3a1f",
     "@multiformats/multiaddr": "^13.0.1",
     "datastore-core": "^12.0.1",
     "datastore-level": "^13.0.1",
@@ -158,8 +158,8 @@
   "devDependencies": {
     "@libp2p/interface-internal": "^3.1.12",
     "@libp2p/logger": "^6.2.13",
-    "@lodestar/spec-test-util": "^1.50.0-dev.040a952dd7",
-    "@lodestar/test-utils": "^1.50.0-dev.040a952dd7",
+    "@lodestar/spec-test-util": "^1.50.0-dev.199b9d3a1f",
+    "@lodestar/test-utils": "^1.50.0-dev.199b9d3a1f",
     "@types/js-yaml": "^4.0.5",
     "@types/qs": "^6.9.7",
     "@types/tmp": "^0.2.3",
@@ -174,5 +174,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "156629b17ad44c8a312b54015fd953e94b4874e6"
+  "gitHead": "82a54df5956f25254f0d96afe6eae94d93554b5e"
 }

package/src/chain/archiveStore/archiveStore.ts

@@ -148,7 +148,7 @@ export class ArchiveStore {
           genesisTime: this.chain.clock.genesisTime,
           dbLocation: this.opts.dbName,
           dataColumnDir: this.opts.dataColumnDir,
-          nativeStateTransition: this.opts.nativeStateTransition ?? false,
+          nativeStateView: this.opts.nativeStateView ?? false,
         },
         config: this.chain.config,
         metrics: this.metrics,

package/src/chain/archiveStore/historicalState/getHistoricalState.ts

@@ -17,7 +17,7 @@ export async function getNearestState(
   slot: number,
   config: BeaconConfig,
   db: IBeaconDb,
-  nativeStateTransition: boolean
+  nativeStateView: boolean
 ): Promise<IBeaconStateView> {
   const stateBytesArr = await db.stateArchive.binaries({limit: 1, lte: slot, reverse: true});
   if (!stateBytesArr.length) {
@@ -25,7 +25,9 @@ export async function getNearestState(
   }
 
   const stateBytes = stateBytesArr[0];
-  return createBeaconStateViewForHistoricalRegen({nativeStateTransition: nativeStateTransition, config, stateBytes});
+  return nativeStateView
+    ? createBeaconStateViewForHistoricalRegen({useNative: true, stateBytes})
+    : createBeaconStateViewForHistoricalRegen({useNative: false, config, stateBytes});
 }
 
 /**
@@ -35,13 +37,13 @@ export async function getHistoricalState(
   slot: number,
   config: BeaconConfig,
   db: IBeaconDb,
-  nativeStateTransition: boolean,
+  nativeStateView: boolean,
   metrics?: HistoricalStateRegenMetrics
 ): Promise<Uint8Array> {
   const regenTimer = metrics?.regenTime.startTimer();
 
   const loadStateTimer = metrics?.loadStateTime.startTimer();
-  let state = await getNearestState(slot, config, db, nativeStateTransition).catch((e) => {
+  let state = await getNearestState(slot, config, db, nativeStateView).catch((e) => {
     metrics?.regenErrorCount.inc({reason: RegenErrorType.loadState});
     throw e;
   });
@@ -52,7 +54,7 @@ export async function getHistoricalState(
   for await (const block of db.blockArchive.valuesStream({gt: state.slot, lte: slot})) {
     try {
       state = state.stateTransition(
-        {block},
+        block,
         {
           verifyProposer: false,
           verifySignatures: false,

package/src/chain/archiveStore/historicalState/historicalStateRegen.ts

@@ -36,7 +36,7 @@ export class HistoricalStateRegen implements HistoricalStateWorkerApi {
       dataColumnDir: modules.opts.dataColumnDir,
       metricsEnabled: Boolean(modules.metrics),
       loggerOpts: modules.logger.toOpts(),
-      nativeStateTransition: modules.opts.nativeStateTransition,
+      nativeStateView: modules.opts.nativeStateView,
     };
 
     const worker = new Worker(path.join(WORKER_DIR, "worker.js"), {

package/src/chain/archiveStore/historicalState/types.ts

@@ -8,7 +8,7 @@ export type HistoricalStateRegenInitModules = {
     genesisTime: number;
     dbLocation: string;
     dataColumnDir: string;
-    nativeStateTransition: boolean;
+    nativeStateView: boolean;
   };
   config: BeaconConfig;
   logger: LoggerNode;
@@ -29,7 +29,7 @@ export type HistoricalStateWorkerData = {
   dataColumnDir: string;
   metricsEnabled: boolean;
   loggerOpts: LoggerNodeOpts;
-  nativeStateTransition: boolean;
+  nativeStateView: boolean;
 };
 
 export type HistoricalStateWorkerApi = {

package/src/chain/archiveStore/historicalState/worker.ts

@@ -36,6 +36,7 @@ const abortController = new AbortController();
 const metricsRegister = workerData.metricsEnabled ? new RegistryMetricCreator() : null;
 let historicalStateRegenMetrics: HistoricalStateRegenMetrics | undefined;
 let queueMetrics: QueueMetrics | undefined;
+
 if (metricsRegister) {
   const closeMetrics = collectNodeJSMetrics(metricsRegister, "lodestar_historical_state_worker_");
   abortController.signal.addEventListener("abort", closeMetrics, {once: true});
@@ -64,7 +65,7 @@ const api: HistoricalStateWorkerApi = {
     historicalStateRegenMetrics?.regenRequestCount.inc();
 
     const stateBytes = await queue.push<Uint8Array>(() =>
-      getHistoricalState(slot, config, db, workerData.nativeStateTransition, historicalStateRegenMetrics)
+      getHistoricalState(slot, config, db, workerData.nativeStateView, historicalStateRegenMetrics)
     );
     const result = Transfer(stateBytes, [stateBytes.buffer]) as unknown as Uint8Array;
 

package/src/chain/archiveStore/interface.ts

@@ -25,7 +25,7 @@ export type ArchiveStoreOpts = StatesArchiveOpts & {
   archiveDataEpochs?: number;
   pruneHistory?: boolean;
   serveHistoricalState?: boolean;
-  nativeStateTransition?: boolean;
+  nativeStateView?: boolean;
 };
 
 export type ProposalStats = {

package/src/chain/blocks/verifyBlock.ts

@@ -188,7 +188,6 @@ export async function verifyBlocksInEpoch(
         blockInputs,
         // hack availability for state transition eval as availability is separately determined
         blocks.map(() => DataAvailabilityStatus.Available),
-        this.serializedCache,
         this.logger,
         this.metrics,
         this.validatorMonitor,

package/src/chain/blocks/verifyBlocksStateTransitionOnly.ts

@@ -7,7 +7,6 @@ import {
 import {ErrorAborted, Logger, byteArrayEquals} from "@lodestar/utils";
 import {Metrics} from "../../metrics/index.js";
 import {nextEventLoop} from "../../util/eventLoop.js";
-import {SerializedCache} from "../../util/serializedCache.js";
 import {BlockError, BlockErrorCode} from "../errors/index.js";
 import {BlockProcessOpts} from "../options.js";
 import {ValidatorMonitor} from "../validatorMonitor.js";
@@ -26,7 +25,6 @@ export async function verifyBlocksStateTransitionOnly(
   preState0: IBeaconStateView,
   blocks: IBlockInput[],
   dataAvailabilityStatuses: DataAvailabilityStatus[],
-  serializedCache: SerializedCache,
   logger: Logger,
   metrics: Metrics | null,
   validatorMonitor: ValidatorMonitor | null,
@@ -39,8 +37,7 @@ export async function verifyBlocksStateTransitionOnly(
 
   for (let i = 0; i < blocks.length; i++) {
     const {validProposerSignature, validSignatures} = opts;
-    const blockInput = blocks[i];
-    const block = blockInput.getBlock();
+    const block = blocks[i].getBlock();
     const preState = i === 0 ? preState0 : postStates[i - 1];
     const dataAvailabilityStatus = dataAvailabilityStatuses[i];
 
@@ -50,7 +47,7 @@ export async function verifyBlocksStateTransitionOnly(
     let postState: IBeaconStateView;
     try {
       postState = preState.stateTransition(
-        {block, ssz: serializedCache.get(block)},
+        block,
         {
           // NOTE: Assume valid for now while sending payload to execution engine in parallel
           // Latter verifyBlocksInEpoch() will make sure that payload is indeed valid
@@ -63,7 +60,7 @@ export async function verifyBlocksStateTransitionOnly(
           verifySignatures: !useBlsBatchVerify && !validSignatures,
           dontTransferCache: false,
         },
-        {metrics: metrics?.stateTransition, validatorMonitor}
+        {metrics, validatorMonitor}
       );
     } catch (e) {
       throw new BlockError(block, {

package/src/chain/chain.ts

@@ -432,7 +432,6 @@ export class BeaconChain implements IBeaconChain {
       blockStateCache,
       checkpointStateCache,
       seenBlockInputCache: this.seenBlockInputCache,
-      serializedCache: this.serializedCache,
       db,
       metrics,
       validatorMonitor,
@@ -703,26 +702,6 @@ export class BeaconChain implements IBeaconChain {
     stateRoot: RootHex,
     opts?: StateGetOpts
   ): Promise<{state: IBeaconStateView | Uint8Array; executionOptimistic: boolean; finalized: boolean} | null> {
-    const finalizedBlock = this.forkChoice.getFinalizedBlock();
-    const finalizedCheckpoint = this.forkChoice.getFinalizedCheckpoint();
-    // Checkpoint state only equals the block post-state if the block is at the epoch start slot
-    if (
-      finalizedBlock.stateRoot === stateRoot &&
-      finalizedBlock.slot === computeStartSlotAtEpoch(finalizedCheckpoint.epoch)
-    ) {
-      const state = this.regen.getCheckpointStateSync({
-        epoch: finalizedCheckpoint.epoch,
-        rootHex: finalizedCheckpoint.rootHex,
-      });
-      if (state) {
-        return {
-          state,
-          executionOptimistic: isOptimisticBlock(finalizedBlock),
-          finalized: finalizedCheckpoint.epoch !== GENESIS_EPOCH,
-        };
-      }
-    }
-
     if (opts?.allowRegen) {
       const state = await this.regen.getState(stateRoot, RegenCaller.restApi);
       const block = this.forkChoice.getBlockDefaultStatus(

package/src/chain/options.ts

@@ -52,7 +52,7 @@ export type IChainOptions = BlockProcessOpts &
     minSameMessageSignatureSetsToBatch: number;
     archiveDateEpochs?: number;
     nHistoricalStatesFileDataStore?: boolean;
-    nativeStateTransition?: boolean;
+    nativeStateView?: boolean;
     /** Builder circuit breaker fault inspection window in slots */
     faultInspectionWindow?: number;
     /** Canonical EMPTY blocks allowed per `faultInspectionWindow` observed blocks */
@@ -131,7 +131,7 @@ export const defaultChainOptions: IChainOptions = {
   //   - users can prune the persisted checkpoint state files manually to save disc space
   //   - it helps debug easier when network is unfinalized
   nHistoricalStatesFileDataStore: true,
-  nativeStateTransition: false,
+  nativeStateView: false,
   maxBlockStates: DEFAULT_MAX_BLOCK_STATES,
   maxCPStateEpochsInMemory: DEFAULT_MAX_CP_STATE_EPOCHS_IN_MEMORY,
   maxCPStateEpochsOnDisk: DEFAULT_MAX_CP_STATE_ON_DISK,

package/src/chain/produceBlock/computeNewStateRoot.ts

@@ -16,7 +16,7 @@ export function computeNewStateRoot(
   const signedBlock = {message: block, signature: EMPTY_SIGNATURE};
   const {newStateRoot, proposerReward, postState, hashTreeRootTime} = state.computeNewStateRoot(
     {block: signedBlock},
-    {metrics: metrics?.stateTransition}
+    {metrics}
   );
 
   metrics?.stateHashTreeRootTime.observe({source: StateHashTreeRootSource.computeNewStateRoot}, hashTreeRootTime);

package/src/chain/regen/regen.ts

@@ -14,7 +14,6 @@ import {Logger, fromHex, toRootHex} from "@lodestar/utils";
 import {IBeaconDb} from "../../db/index.js";
 import {Metrics} from "../../metrics/index.js";
 import {nextEventLoop} from "../../util/eventLoop.js";
-import {SerializedCache} from "../../util/serializedCache.js";
 import {getCheckpointFromState} from "../blocks/utils/checkpoint.js";
 import {ChainEvent, ChainEventEmitter} from "../emitter.js";
 import {SeenBlockInput} from "../seenCache/seenGossipBlockInput.js";
@@ -29,7 +28,6 @@ export type RegenModules = {
   blockStateCache: BlockStateCache;
   checkpointStateCache: CheckpointStateCache;
   seenBlockInputCache: SeenBlockInput;
-  serializedCache: SerializedCache;
   config: ChainForkConfig;
   emitter: ChainEventEmitter;
   logger: Logger;
@@ -237,7 +235,7 @@ export class StateRegenerator implements IStateRegeneratorInternal {
         // We are only running the state transition to get a specific state's data.
         // stateTransition() does the clone() inside, transfer cache to make the regen faster
         state = state.stateTransition(
-          {block, ssz: this.modules.serializedCache.get(block)},
+          block,
           {
             // Replay previously imported blocks, assume valid and available
             executionPayloadStatus: ExecutionPayloadStatus.valid,
@@ -247,7 +245,7 @@ export class StateRegenerator implements IStateRegeneratorInternal {
             verifySignatures: false,
             dontTransferCache: false,
           },
-          {metrics: this.modules.metrics?.stateTransition, validatorMonitor: this.modules.validatorMonitor}
+          this.modules
         );
 
         const hashTreeRootTimer = this.modules.metrics?.stateHashTreeRootTime.startTimer({
@@ -318,10 +316,7 @@ async function processSlotsByCheckpoint(
 ): Promise<IBeaconStateView> {
   let postState = await processSlotsToNearestCheckpoint(modules, preState, slot, regenCaller, opts);
   if (postState.slot < slot) {
-    postState = postState.processSlots(slot, opts, {
-      metrics: modules.metrics?.stateTransition,
-      validatorMonitor: modules.validatorMonitor,
-    });
+    postState = postState.processSlots(slot, opts, modules);
   }
   return postState;
 }
@@ -366,10 +361,7 @@ export async function processSlotsToNearestCheckpoint(
       caller: regenCaller,
     });
     // processSlots calls .clone() before mutating
-    postState = postState.processSlots(nextEpochSlot, opts, {
-      metrics: metrics?.stateTransition,
-      validatorMonitor: modules.validatorMonitor,
-    });
+    postState = postState.processSlots(nextEpochSlot, opts, modules);
     metrics?.epochTransitionByCaller.inc({caller: regenCaller});
 
     // this is usually added when we prepare for next slot or validate gossip block

package/src/chain/validatorMonitor.ts

@@ -123,11 +123,6 @@ export type ValidatorMonitorOpts = {
   validatorMonitorLogs?: boolean;
 };
 
-export type NativeValidatorMonitor = {
-  registerLocalValidator(index: ValidatorIndex): void;
-  unregisterLocalValidator(index: ValidatorIndex): void;
-};
-
 export const defaultValidatorMonitorOpts: ValidatorMonitorOpts = {
   validatorMonitorLogs: false,
 };
@@ -301,8 +296,7 @@ export function createValidatorMonitor(
   config: ChainForkConfig,
   genesisTime: number,
   logger: Logger,
-  opts: ValidatorMonitorOpts,
-  nativeValidatorMonitor: NativeValidatorMonitor | null = null
+  opts: ValidatorMonitorOpts
 ): ValidatorMonitor {
   const logLevel = opts.validatorMonitorLogs ? LogLevel.info : LogLevel.debug;
   const log: LogHandler = (message: string, context?: LogData) => {
@@ -333,23 +327,18 @@ export function createValidatorMonitor(
   }));
 
   let lastRegisteredStatusEpoch = -1;
-  let lastAttestationSummaryEpoch = -1;
 
   // Track validator additions/removals per epoch for logging
   const addedValidatorsInEpoch: Set<ValidatorIndex> = new Set();
   const removedValidatorsInEpoch: Set<ValidatorIndex> = new Set();
 
-  const shouldRegisterStateDerivedMetrics = nativeValidatorMonitor === null;
-  const validatorMonitorMetrics = metricsRegister
-    ? createValidatorMonitorMetrics(metricsRegister, shouldRegisterStateDerivedMetrics)
-    : null;
+  const validatorMonitorMetrics = metricsRegister ? createValidatorMonitorMetrics(metricsRegister) : null;
 
   const validatorMonitor: ValidatorMonitor = {
     registerLocalValidator(index) {
       const isNewValidator = !validators.has(index);
       validators.getOrDefault(index).lastRegisteredTimeMs = Date.now();
       if (isNewValidator) {
-        nativeValidatorMonitor?.registerLocalValidator(index);
         addedValidatorsInEpoch.add(index);
       }
     },
@@ -377,7 +366,7 @@ export function createValidatorMonitor(
       // Track total balance instead of per-validator balance to reduce metric cardinality
       let totalBalance = 0;
 
-      for (const index of validators.keys()) {
+      for (const [index, monitoredValidator] of validators.entries()) {
         // We subtract two from the state of the epoch that generated these summaries.
         //
         // - One to account for it being the previous epoch.
@@ -391,29 +380,68 @@ export function createValidatorMonitor(
         );
 
         if (summary.isPrevSourceAttester) {
-          validatorMonitorMetrics?.prevEpochOnChainSourceAttesterHit?.inc();
+          validatorMonitorMetrics?.prevEpochOnChainSourceAttesterHit.inc();
         } else {
-          validatorMonitorMetrics?.prevEpochOnChainSourceAttesterMiss?.inc();
+          validatorMonitorMetrics?.prevEpochOnChainSourceAttesterMiss.inc();
         }
         if (summary.isPrevHeadAttester) {
-          validatorMonitorMetrics?.prevEpochOnChainHeadAttesterHit?.inc();
+          validatorMonitorMetrics?.prevEpochOnChainHeadAttesterHit.inc();
         } else {
-          validatorMonitorMetrics?.prevEpochOnChainHeadAttesterMiss?.inc();
+          validatorMonitorMetrics?.prevEpochOnChainHeadAttesterMiss.inc();
         }
         if (summary.isPrevTargetAttester) {
-          validatorMonitorMetrics?.prevEpochOnChainTargetAttesterHit?.inc();
+          validatorMonitorMetrics?.prevEpochOnChainTargetAttesterHit.inc();
         } else {
-          validatorMonitorMetrics?.prevEpochOnChainTargetAttesterMiss?.inc();
+          validatorMonitorMetrics?.prevEpochOnChainTargetAttesterMiss.inc();
+        }
+
+        const prevEpochSummary = monitoredValidator.summaries.get(previousEpoch);
+        const attestationCorrectHead = prevEpochSummary?.attestationCorrectHead;
+        if (attestationCorrectHead !== null && attestationCorrectHead !== undefined) {
+          if (attestationCorrectHead) {
+            validatorMonitorMetrics?.prevOnChainAttesterCorrectHead.inc();
+          } else {
+            validatorMonitorMetrics?.prevOnChainAttesterIncorrectHead.inc();
+          }
+        }
+
+        const attestationMinBlockInclusionDistance = prevEpochSummary?.attestationMinBlockInclusionDistance;
+        const inclusionDistance =
+          attestationMinBlockInclusionDistance != null && attestationMinBlockInclusionDistance > 0
+            ? // altair, attestation is not missed
+              attestationMinBlockInclusionDistance
+            : summary.inclusionDistance
+              ? // phase0, this is from the state transition
+                summary.inclusionDistance
+              : null;
+
+        if (inclusionDistance !== null) {
+          validatorMonitorMetrics?.prevEpochOnChainInclusionDistance.observe(inclusionDistance);
+          validatorMonitorMetrics?.prevEpochOnChainAttesterHit.inc();
+        } else {
+          validatorMonitorMetrics?.prevEpochOnChainAttesterMiss.inc();
         }
 
         const balance = balances?.[index];
         if (balance !== undefined) {
           totalBalance += balance;
         }
+
+        if (!summary.isPrevSourceAttester || !summary.isPrevTargetAttester || !summary.isPrevHeadAttester) {
+          log("Failed attestation in previous epoch", {
+            validator: index,
+            prevEpoch: currentEpoch - 1,
+            isPrevSourceAttester: summary.isPrevSourceAttester,
+            isPrevHeadAttester: summary.isPrevHeadAttester,
+            isPrevTargetAttester: summary.isPrevTargetAttester,
+            // inclusionDistance is not available in summary since altair
+            inclusionDistance,
+          });
+        }
       }
 
       if (balances !== undefined) {
-        validatorMonitorMetrics?.prevEpochOnChainBalance?.set(totalBalance);
+        validatorMonitorMetrics?.prevEpochOnChainBalance.set(totalBalance);
       }
     },
 
@@ -704,7 +732,6 @@ export function createValidatorMonitor(
       // Prune validators not seen in a while
       for (const [index, validator] of validators.entries()) {
         if (Date.now() - validator.lastRegisteredTimeMs > retainRegisteredValidatorsMs) {
-          nativeValidatorMonitor?.unregisterLocalValidator(index);
           validators.delete(index);
           removedValidatorsInEpoch.add(index);
         }
@@ -740,38 +767,6 @@ export function createValidatorMonitor(
         return;
       }
 
-      // On-chain attestation summary of prevEpoch. Reads only the epoch summaries filled by
-      // registerAttestationInBlock(), so it works with both TS and native state transition.
-      if (prevEpoch > lastAttestationSummaryEpoch) {
-        lastAttestationSummaryEpoch = prevEpoch;
-
-        for (const monitoredValidator of validators.values()) {
-          const prevEpochSummary = monitoredValidator.summaries.get(prevEpoch);
-          const attestationCorrectHead = prevEpochSummary?.attestationCorrectHead;
-          if (attestationCorrectHead !== null && attestationCorrectHead !== undefined) {
-            if (attestationCorrectHead) {
-              validatorMonitorMetrics?.prevOnChainAttesterCorrectHead.inc();
-            } else {
-              validatorMonitorMetrics?.prevOnChainAttesterIncorrectHead.inc();
-            }
-          }
-
-          const attestationMinBlockInclusionDistance = prevEpochSummary?.attestationMinBlockInclusionDistance;
-          const inclusionDistance =
-            attestationMinBlockInclusionDistance != null && attestationMinBlockInclusionDistance > 0
-              ? // altair, attestation is not missed
-                attestationMinBlockInclusionDistance
-              : null;
-
-          if (inclusionDistance !== null) {
-            validatorMonitorMetrics?.prevEpochOnChainInclusionDistance.observe(inclusionDistance);
-            validatorMonitorMetrics?.prevEpochOnChainAttesterHit.inc();
-          } else {
-            validatorMonitorMetrics?.prevEpochOnChainAttesterMiss.inc();
-          }
-        }
-      }
-
       const rootCache = new RootHexCache(headState);
 
       if (isStatePostAltair(headState)) {
@@ -789,17 +784,6 @@ export function createValidatorMonitor(
             epoch: prevEpoch,
             summary,
           });
-
-          if (!flags.timelySource || !flags.timelyTarget || !flags.timelyHead) {
-            log("Failed attestation in previous epoch", {
-              validator: index,
-              prevEpoch,
-              isPrevSourceAttester: flags.timelySource,
-              isPrevHeadAttester: flags.timelyHead,
-              isPrevTargetAttester: flags.timelyTarget,
-              inclusionDistance: validator.summaries.get(prevEpoch)?.attestationMinBlockInclusionDistance ?? null,
-            });
-          }
         }
       }
 
@@ -1214,9 +1198,7 @@ export class RootHexCache {
   }
 }
 
-function createValidatorMonitorMetrics(register: RegistryMetricCreator, registerStateDerivedMetrics = true) {
-  const stateDerivedRegister = registerStateDerivedMetrics ? register : null;
-
+function createValidatorMonitorMetrics(register: RegistryMetricCreator) {
   return {
     validatorsConnected: register.gauge({
       name: "validator_monitor_validators",
@@ -1235,7 +1217,7 @@ function createValidatorMonitorMetrics(register: RegistryMetricCreator, register
     }),
 
     // Validator Monitor Metrics (per-epoch summaries)
-    prevEpochOnChainBalance: stateDerivedRegister?.gauge({
+    prevEpochOnChainBalance: register.gauge({
       name: "validator_monitor_prev_epoch_on_chain_balance",
       help: "Total balance of all monitored validators after an epoch",
     }),
@@ -1247,19 +1229,19 @@ function createValidatorMonitorMetrics(register: RegistryMetricCreator, register
       name: "validator_monitor_prev_epoch_on_chain_attester_miss_total",
       help: "Incremented if validator's submitted attestation is not included in any blocks",
     }),
-    prevEpochOnChainSourceAttesterHit: stateDerivedRegister?.gauge({
+    prevEpochOnChainSourceAttesterHit: register.gauge({
       name: "validator_monitor_prev_epoch_on_chain_source_attester_hit_total",
       help: "Incremented if the validator is flagged as a previous epoch source attester during per epoch processing",
     }),
-    prevEpochOnChainSourceAttesterMiss: stateDerivedRegister?.gauge({
+    prevEpochOnChainSourceAttesterMiss: register.gauge({
       name: "validator_monitor_prev_epoch_on_chain_source_attester_miss_total",
       help: "Incremented if the validator is not flagged as a previous epoch source attester during per epoch processing",
     }),
-    prevEpochOnChainHeadAttesterHit: stateDerivedRegister?.gauge({
+    prevEpochOnChainHeadAttesterHit: register.gauge({
       name: "validator_monitor_prev_epoch_on_chain_head_attester_hit_total",
       help: "Incremented if the validator is flagged as a previous epoch head attester during per epoch processing",
     }),
-    prevEpochOnChainHeadAttesterMiss: stateDerivedRegister?.gauge({
+    prevEpochOnChainHeadAttesterMiss: register.gauge({
       name: "validator_monitor_prev_epoch_on_chain_head_attester_miss_total",
       help: "Incremented if the validator is not flagged as a previous epoch head attester during per epoch processing",
     }),
@@ -1271,11 +1253,11 @@ function createValidatorMonitorMetrics(register: RegistryMetricCreator, register
       name: "validator_monitor_prev_epoch_on_chain_attester_incorrect_head_total",
       help: "Total count of times a validator votes incorrect head",
     }),
-    prevEpochOnChainTargetAttesterHit: stateDerivedRegister?.gauge({
+    prevEpochOnChainTargetAttesterHit: register.gauge({
       name: "validator_monitor_prev_epoch_on_chain_target_attester_hit_total",
       help: "Incremented if the validator is flagged as a previous epoch target attester during per epoch processing",
     }),
-    prevEpochOnChainTargetAttesterMiss: stateDerivedRegister?.gauge({
+    prevEpochOnChainTargetAttesterMiss: register.gauge({
       name: "validator_monitor_prev_epoch_on_chain_target_attester_miss_total",
       help: "Incremented if the validator is not flagged as a previous epoch target attester during per epoch processing",
     }),

package/src/metrics/metrics.ts

@@ -9,42 +9,27 @@ import {RegistryMetricCreator} from "./utils/registryMetricCreator.js";
 
 export type Metrics = BeaconMetrics &
   ForkChoiceMetrics &
-  LodestarMetrics & {
-    /** Null when we use native state transition metrics instead */
-    stateTransition: BeaconStateTransitionMetrics | null;
-    register: RegistryMetricCreator;
-    close: () => void;
-  };
-
-export type CreateMetricsOptions = {
-  /*
-   * Toggle inclusion of state transition metrics.
-   *
-   * False when native state transition is used, so we
-   * can grab metrics from the native implementation instead.
-   * */
-  includeStateTransitionMetrics?: boolean;
-  collectNodeMetrics?: boolean;
-};
+  BeaconStateTransitionMetrics &
+  LodestarMetrics & {register: RegistryMetricCreator; close: () => void};
 
 export function createMetrics(
   opts: MetricsOptions,
   genesisTime: number,
   externalRegistries: Registry[] = [],
-  createOpts: CreateMetricsOptions = {}
+  {collectNodeMetrics = true}: {collectNodeMetrics?: boolean} = {}
 ): Metrics {
   const register = new RegistryMetricCreator();
   const beacon = createBeaconMetrics(register);
   const forkChoice = getForkChoiceMetrics(register);
   const lodestar = createLodestarMetrics(register, opts.metadata, genesisTime);
-  const stateTransition = createOpts.includeStateTransitionMetrics === false ? null : getMetrics(register);
+  const stateTransition = getMetrics(register);
 
   const onUnhandledRejection = (_error: unknown): void => {
     lodestar.unhandledPromiseRejections.inc();
   };
   process.on("unhandledRejection", onUnhandledRejection);
 
-  const nodeJsMetricsClose = createOpts.collectNodeMetrics === false ? (): void => {} : collectNodeJSMetrics(register);
+  const nodeJsMetricsClose = collectNodeMetrics ? collectNodeJSMetrics(register) : (): void => {};
   const close = (): void => {
     process.removeListener("unhandledRejection", onUnhandledRejection);
     nodeJsMetricsClose();
@@ -61,7 +46,7 @@ export function createMetrics(
     ...beacon,
     ...forkChoice,
     ...lodestar,
-    stateTransition,
+    ...stateTransition,
     register,
     close,
   };