@lodestar/beacon-node 1.38.0 → 1.39.0-dev.3bf4734ba9

package/src/eth1/interface.ts

@@ -1,6 +1,6 @@
 import {BeaconConfig} from "@lodestar/config";
 import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
-import {Root, RootHex, phase0} from "@lodestar/types";
+import {phase0} from "@lodestar/types";
 
 export type EthJsonRpcBlockRaw = {
   /** the block number. null when its pending block. `"0x1b4"` */
@@ -47,22 +47,6 @@ export type Eth1DataAndDeposits = {
 export interface IEth1ForBlockProduction {
   getEth1DataAndDeposits(state: CachedBeaconStateAllForks): Promise<Eth1DataAndDeposits>;
 
-  /** Returns the most recent POW block that satisfies the merge block condition */
-  getTerminalPowBlock(): Promise<Root | null>;
-  /** Get a POW block by hash checking the local cache first */
-  getPowBlock(powBlockHash: string): Promise<PowMergeBlock | null>;
-
-  /** Get current TD progress for log notifier */
-  getTDProgress(): TDProgress | null;
-
-  /**
-   * Should only start polling for mergeBlock if:
-   * - after BELLATRIX_FORK_EPOCH
-   * - Beacon node synced
-   * - head state not isMergeTransitionComplete
-   */
-  startPollingMergeBlock(): void;
-
   isPollingEth1Data(): boolean;
 
   /**
@@ -78,34 +62,6 @@ export type Eth1Block = {
   timestamp: number;
 };
 
-export type PowMergeBlock = {
-  number: number;
-  blockHash: RootHex;
-  parentHash: RootHex;
-  totalDifficulty: bigint;
-};
-
-export type PowMergeBlockTimestamp = PowMergeBlock & {
-  /** in seconds */
-  timestamp: number;
-};
-
-export type TDProgress =
-  | {
-      ttdHit: false;
-      /** Power of ten by which tdDiffScaled is scaled down */
-      tdFactor: bigint;
-      /** (TERMINAL_TOTAL_DIFFICULTY - block.totalDifficulty) / tdFactor */
-      tdDiffScaled: number;
-      /** TERMINAL_TOTAL_DIFFICULTY */
-      ttd: bigint;
-      /** totalDifficulty of latest fetched eth1 block */
-      td: bigint;
-      /** timestamp in sec of latest fetched eth1 block */
-      timestamp: number;
-    }
-  | {ttdHit: true};
-
 export type BatchDepositEvents = {
   depositEvents: phase0.DepositEvent[];
   blockNumber: number;

package/src/execution/engine/http.ts

@@ -194,15 +194,12 @@ export class ExecutionEngineHttp implements IExecutionEngine {
    *   1. {status: INVALID_BLOCK_HASH, latestValidHash: null, validationError:
    *      errorMessage | null} if the blockHash validation has failed
    *
-   *   2. {status: INVALID_TERMINAL_BLOCK, latestValidHash: null, validationError:
-   *      errorMessage | null} if terminal block conditions are not satisfied
-   *
-   *   3. {status: SYNCING, latestValidHash: null, validationError: null} if the payload
+   *   2. {status: SYNCING, latestValidHash: null, validationError: null} if the payload
    *      extends the canonical chain and requisite data for its validation is missing
    *      with the payload status obtained from the Payload validation process if the payload
    *      has been fully validated while processing the call
    *
-   *   4. {status: ACCEPTED, latestValidHash: null, validationError: null} if the
+   *   3. {status: ACCEPTED, latestValidHash: null, validationError: null} if the
    *      following conditions are met:
    *        i) the blockHash of the payload is valid
    *        ii) the payload doesn't extend the canonical chain
@@ -330,16 +327,11 @@ export class ExecutionEngineHttp implements IExecutionEngine {
    *      errorMessage | null}, payloadId: null}
    *      obtained from the Payload validation process if the payload is deemed INVALID
    *
-   *   3. {payloadStatus: {status: INVALID_TERMINAL_BLOCK, latestValidHash: null,
-   *      validationError: errorMessage | null}, payloadId: null}
-   *      either obtained from the Payload validation process or as a result of validating a
-   *      PoW block referenced by forkchoiceState.headBlockHash
-   *
-   *   4. {payloadStatus: {status: VALID, latestValidHash: forkchoiceState.headBlockHash,
+   *   3. {payloadStatus: {status: VALID, latestValidHash: forkchoiceState.headBlockHash,
    *      validationError: null}, payloadId: null}
    *      if the payload is deemed VALID and a build process hasn't been started
    *
-   *   5. {payloadStatus: {status: VALID, latestValidHash: forkchoiceState.headBlockHash,
+   *   4. {payloadStatus: {status: VALID, latestValidHash: forkchoiceState.headBlockHash,
    *      validationError: null}, payloadId: buildProcessId}
    *      if the payload is deemed VALID and the build process has begun.
    *

package/src/execution/engine/mock.ts

@@ -9,7 +9,7 @@ import {
   ForkSeq,
 } from "@lodestar/params";
 import {ExecutionPayload, RootHex, bellatrix, deneb, ssz} from "@lodestar/types";
-import {fromHex, toHex, toRootHex} from "@lodestar/utils";
+import {fromHex, toRootHex} from "@lodestar/utils";
 import {ZERO_HASH_HEX} from "../../constants/index.js";
 import {quantityToNum} from "../../eth1/provider/utils.js";
 import {INTEROP_BLOCK_HASH} from "../../node/utils/interop/state.js";
@@ -70,7 +70,7 @@ export class ExecutionEngineMockBackend implements JsonRpcBackend {
   finalizedBlockHash = ZERO_HASH_HEX;
   readonly payloadIdCache = new PayloadIdCache();
 
-  /** Known valid blocks, both pre-merge and post-merge */
+  /** Known valid blocks */
   private readonly validBlocks = new Map<RootHex, ExecutionBlock>();
   /** Preparing payloads to be retrieved via engine_getPayloadV1 */
   private readonly preparingPayloads = new Map<number, PreparedPayload>();
@@ -135,18 +135,6 @@ export class ExecutionEngineMockBackend implements JsonRpcBackend {
     return [] as ExecutionPayloadBodyRpc[];
   }
 
-  /**
-   * Mock manipulator to add more known blocks to this mock.
-   */
-  addPowBlock(powBlock: bellatrix.PowBlock): void {
-    this.validBlocks.set(toHex(powBlock.blockHash), {
-      parentHash: toHex(powBlock.parentHash),
-      blockHash: toHex(powBlock.blockHash),
-      timestamp: 0,
-      blockNumber: 0,
-    });
-  }
-
   /**
    * Mock manipulator to add predefined responses before execution engine client calls
    */
@@ -258,7 +246,7 @@ export class ExecutionEngineMockBackend implements JsonRpcBackend {
     //    section of the EIP. Additionally, if this validation fails, client software MUST NOT update the forkchoice
     //    state and MUST NOT begin a payload build process.
     //
-    // > TODO
+    // > N/A: All networks have completed the merge transition
 
     // 4. Before updating the forkchoice state, client software MUST ensure the validity of the payload referenced by
     //    forkchoiceState.headBlockHash, and MAY validate the payload while processing the call. The validation process

package/src/metrics/metrics/lodestar.ts

@@ -1668,58 +1668,6 @@ export function createLodestarMetrics(
         name: "lodestar_eth1_logs_batch_size_dynamic",
         help: "Dynamic batch size to fetch deposit logs",
       }),
-
-      // Merge Search info
-      eth1MergeStatus: register.gauge({
-        name: "lodestar_eth1_merge_status",
-        help: "Eth1 Merge Status 0 PRE_MERGE 1 SEARCHING 2 FOUND 3 POST_MERGE",
-      }),
-      eth1MergeTDFactor: register.gauge({
-        name: "lodestar_eth1_merge_td_factor",
-        help: "TTD set for the merge",
-      }),
-      eth1MergeTTD: register.gauge({
-        name: "lodestar_eth1_merge_ttd",
-        help: "TTD set for the merge scaled down by td_factor",
-      }),
-
-      eth1PollMergeBlockErrors: register.gauge({
-        name: "lodestar_eth1_poll_merge_block_errors_total",
-        help: "Total count of errors polling merge block",
-      }),
-      getTerminalPowBlockPromiseCacheHit: register.gauge({
-        name: "lodestar_eth1_get_terminal_pow_block_promise_cache_hit_total",
-        help: "Total count of skipped runs in poll merge block, because a previous promise existed",
-      }),
-      eth1ParentBlocksFetched: register.gauge({
-        name: "lodestar_eth1_parent_blocks_fetched_total",
-        help: "Total count of parent blocks fetched searching for merge block",
-      }),
-
-      // Latest block details
-      eth1LatestBlockTD: register.gauge({
-        name: "lodestar_eth1_latest_block_ttd",
-        help: "Eth1 latest Block td scaled down by td_factor",
-      }),
-      eth1LatestBlockNumber: register.gauge({
-        name: "lodestar_eth1_latest_block_number",
-        help: "Eth1 latest block number",
-      }),
-      eth1LatestBlockTimestamp: register.gauge({
-        name: "lodestar_eth1_latest_block_timestamp",
-        help: "Eth1 latest block timestamp",
-      }),
-
-      // Merge details
-      eth1MergeBlockDetails: register.gauge<{
-        terminalBlockHash: string;
-        terminalBlockNumber: string;
-        terminalBlockTD: string;
-      }>({
-        name: "lodestar_eth1_merge_block_details",
-        help: "If found then 1 with terminal block details",
-        labelNames: ["terminalBlockHash", "terminalBlockNumber", "terminalBlockTD"],
-      }),
     },
 
     eth1HttpClient: {

package/src/node/notifier.ts

@@ -6,7 +6,6 @@ import {
   computeEpochAtSlot,
   computeStartSlotAtEpoch,
   isExecutionCachedStateType,
-  isMergeTransitionComplete,
 } from "@lodestar/state-transition";
 import {Epoch} from "@lodestar/types";
 import {ErrorAborted, Logger, prettyBytes, prettyBytesShort, sleep} from "@lodestar/utils";
@@ -36,7 +35,6 @@ export async function runNodeNotifier(modules: NodeNotifierModules): Promise<voi
   const {network, chain, sync, config, logger, signal} = modules;
 
   const headSlotTimeSeries = new TimeSeries({maxPoints: 10});
-  const tdTimeSeries = new TimeSeries({maxPoints: 50});
 
   const SLOTS_PER_SYNC_COMMITTEE_PERIOD = SLOTS_PER_EPOCH * EPOCHS_PER_SYNC_COMMITTEE_PERIOD;
   let hasLowPeerCount = false;
@@ -87,21 +85,6 @@ export async function runNodeNotifier(modules: NodeNotifierModules): Promise<voi
       const executionInfo = getHeadExecutionInfo(config, clockEpoch, headState, headInfo);
       const finalizedCheckpointRow = `finalized: ${prettyBytes(finalizedRoot)}:${finalizedEpoch}`;
 
-      // Log in TD progress in separate line to not clutter regular status update.
-      // This line will only exist between BELLATRIX_FORK_EPOCH and TTD, a window of some days / weeks max.
-      // Notifier log lines must be kept at a reasonable max width otherwise it's very hard to read
-      const tdProgress = chain.eth1.getTDProgress();
-      if (tdProgress !== null && !tdProgress.ttdHit) {
-        tdTimeSeries.addPoint(tdProgress.tdDiffScaled, tdProgress.timestamp);
-
-        const timestampTDD = tdTimeSeries.computeY0Point();
-        // It is possible to get ttd estimate with an error at imminent merge
-        const secToTTD = Math.max(Math.floor(timestampTDD - Date.now() / 1000), 0);
-        const timeLeft = Number.isFinite(secToTTD) ? prettyTimeDiffSec(secToTTD) : "?";
-
-        logger.info(`TTD in ${timeLeft} current TD ${tdProgress.td} / ${tdProgress.ttd}`);
-      }
-
       let nodeState: string[];
       switch (sync.state) {
         case SyncState.SyncingFinalized:
@@ -188,18 +171,13 @@ function getHeadExecutionInfo(
 
   // Add execution status to notifier only if head is on/post bellatrix
   if (isExecutionCachedStateType(headState)) {
-    if (isMergeTransitionComplete(headState)) {
-      const executionPayloadHashInfo =
-        headInfo.executionStatus !== ExecutionStatus.PreMerge ? headInfo.executionPayloadBlockHash : "empty";
-      const executionPayloadNumberInfo =
-        headInfo.executionStatus !== ExecutionStatus.PreMerge ? headInfo.executionPayloadNumber : NaN;
-      return [
-        `exec-block: ${executionStatusStr}(${executionPayloadNumberInfo} ${prettyBytesShort(
-          executionPayloadHashInfo
-        )})`,
-      ];
-    }
-    return [`exec-block: ${executionStatusStr}`];
+    const executionPayloadHashInfo =
+      headInfo.executionStatus !== ExecutionStatus.PreMerge ? headInfo.executionPayloadBlockHash : "empty";
+    const executionPayloadNumberInfo =
+      headInfo.executionStatus !== ExecutionStatus.PreMerge ? headInfo.executionPayloadNumber : NaN;
+    return [
+      `exec-block: ${executionStatusStr}(${executionPayloadNumberInfo} ${prettyBytesShort(executionPayloadHashInfo)})`,
+    ];
   }
 
   return [];

package/src/sync/backfill/backfill.ts

@@ -750,7 +750,9 @@ export class BackfillSync extends (EventEmitter as {new (): BackfillSyncEmitter}
 
     // GENESIS_SLOT doesn't has valid signature
     if (anchorBlock.message.slot === GENESIS_SLOT) return;
-    await verifyBlockProposerSignature(this.chain.bls, this.chain.getHeadState(), [anchorBlock]);
+    await verifyBlockProposerSignature(this.chain.index2pubkey, this.chain.bls, this.chain.getHeadState(), [
+      anchorBlock,
+    ]);
 
     // We can write to the disk if this is ahead of prevFinalizedCheckpointBlock otherwise
     // we will need to go make checks on the top of sync loop before writing as it might
@@ -815,7 +817,12 @@ export class BackfillSync extends (EventEmitter as {new (): BackfillSyncEmitter}
 
     // If any of the block's proposer signature fail, we can't trust this peer at all
     if (verifiedBlocks.length > 0) {
-      await verifyBlockProposerSignature(this.chain.bls, this.chain.getHeadState(), verifiedBlocks);
+      await verifyBlockProposerSignature(
+        this.chain.index2pubkey,
+        this.chain.bls,
+        this.chain.getHeadState(),
+        verifiedBlocks
+      );
 
       // This is bad, like super bad. Abort the backfill
       if (!nextAnchor)

package/src/sync/backfill/verify.ts

@@ -1,6 +1,11 @@
 import {BeaconConfig} from "@lodestar/config";
 import {GENESIS_SLOT} from "@lodestar/params";
-import {CachedBeaconStateAllForks, ISignatureSet, getBlockProposerSignatureSet} from "@lodestar/state-transition";
+import {
+  CachedBeaconStateAllForks,
+  ISignatureSet,
+  Index2PubkeyCache,
+  getBlockProposerSignatureSet,
+} from "@lodestar/state-transition";
 import {Root, SignedBeaconBlock, Slot, ssz} from "@lodestar/types";
 import {IBlsVerifier} from "../../chain/bls/index.js";
 import {BackfillSyncError, BackfillSyncErrorCode} from "./errors.js";
@@ -41,6 +46,7 @@ export function verifyBlockSequence(
 }
 
 export async function verifyBlockProposerSignature(
+  index2pubkey: Index2PubkeyCache,
   bls: IBlsVerifier,
   state: CachedBeaconStateAllForks,
   blocks: SignedBeaconBlock[]
@@ -48,7 +54,7 @@ export async function verifyBlockProposerSignature(
   if (blocks.length === 1 && blocks[0].message.slot === GENESIS_SLOT) return;
   const signatures = blocks.reduce((sigs: ISignatureSet[], block) => {
     // genesis block doesn't have valid signature
-    if (block.message.slot !== GENESIS_SLOT) sigs.push(getBlockProposerSignatureSet(state, block));
+    if (block.message.slot !== GENESIS_SLOT) sigs.push(getBlockProposerSignatureSet(index2pubkey, state, block));
     return sigs;
   }, []);
 

package/lib/eth1/eth1MergeBlockTracker.d.ts

@@ -1,65 +0,0 @@
-import { ChainConfig } from "@lodestar/config";
-import { Logger } from "@lodestar/utils";
-import { Metrics } from "../metrics/index.js";
-import { EthJsonRpcBlockRaw, IEth1Provider, PowMergeBlock, TDProgress } from "./interface.js";
-export declare enum StatusCode {
-    STOPPED = "STOPPED",
-    SEARCHING = "SEARCHING",
-    FOUND = "FOUND"
-}
-export type Eth1MergeBlockTrackerModules = {
-    config: ChainConfig;
-    logger: Logger;
-    signal: AbortSignal;
-    metrics: Metrics | null;
-};
-/**
- * Follows the eth1 chain to find a (or multiple?) merge blocks that cross the threshold of total terminal difficulty
- *
- * Finding the mergeBlock could be done in demand when proposing pre-merge blocks. However, that would slow block
- * production during the weeks between BELLATRIX_EPOCH and TTD.
- */
-export declare class Eth1MergeBlockTracker {
-    private readonly eth1Provider;
-    private readonly config;
-    private readonly logger;
-    private readonly metrics;
-    private readonly blocksByHashCache;
-    private readonly intervals;
-    private status;
-    private latestEth1Block;
-    private getTerminalPowBlockFromEth1Promise;
-    private readonly safeTDFactor;
-    constructor({ config, logger, signal, metrics }: Eth1MergeBlockTrackerModules, eth1Provider: IEth1Provider);
-    /**
-     * Returns the most recent POW block that satisfies the merge block condition
-     */
-    getTerminalPowBlock(): Promise<PowMergeBlock | null>;
-    getTDProgress(): TDProgress | null;
-    /**
-     * Get a POW block by hash checking the local cache first
-     */
-    getPowBlock(powBlockHash: string): Promise<PowMergeBlock | null>;
-    /**
-     * Should only start polling for mergeBlock if:
-     * - after BELLATRIX_FORK_EPOCH
-     * - Beacon node synced
-     * - head state not isMergeTransitionComplete
-     */
-    startPollingMergeBlock(): void;
-    private close;
-    private getTerminalPowBlockFromEth1;
-    /**
-     * **internal** + **unsafe** since it can create multiple backward searches that overload the eth1 client.
-     * Must be called in a wrapper to ensure that there's only once concurrent call to this fn.
-     */
-    private internalGetTerminalPowBlockFromEth1;
-    private cacheBlock;
-}
-export declare function toPowBlock(block: EthJsonRpcBlockRaw): PowMergeBlock;
-/**
- * TTD values can be very large, for xDAI > 1e45. So scale down.
- * To be good, TTD should be rendered as a number < Number.MAX_TD_RENDER_VALUE ~= 9e15
- */
-export declare function getSafeTDFactor(ttd: bigint): bigint;
-//# sourceMappingURL=eth1MergeBlockTracker.d.ts.map

package/lib/eth1/eth1MergeBlockTracker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"eth1MergeBlockTracker.d.ts","sourceRoot":"","sources":["../../src/eth1/eth1MergeBlockTracker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAC,MAAM,kBAAkB,CAAC;AAE7C,OAAO,EAAC,MAAM,EAA2B,MAAM,iBAAiB,CAAC;AAEjE,OAAO,EAAC,OAAO,EAAC,MAAM,qBAAqB,CAAC;AAE5C,OAAO,EAAC,kBAAkB,EAAE,aAAa,EAAE,aAAa,EAA0B,UAAU,EAAC,MAAM,gBAAgB,CAAC;AAGpH,oBAAY,UAAU;IACpB,OAAO,YAAY;IACnB,SAAS,cAAc;IACvB,KAAK,UAAU;CAChB;AAkBD,MAAM,MAAM,4BAA4B,GAAG;IACzC,MAAM,EAAE,WAAW,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;CACzB,CAAC;AAIF;;;;;GAKG;AACH,qBAAa,qBAAqB;IAe9B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAd/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiB;IAEzC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAqC;IACvE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwB;IAElD,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,eAAe,CAAuC;IAC9D,OAAO,CAAC,kCAAkC,CAA8C;IACxF,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;gBAGpC,EAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAC,EAAE,4BAA4B,EAC9C,YAAY,EAAE,aAAa;IAiC9C;;OAEG;IACG,mBAAmB,IAAI,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAe1D,aAAa,IAAI,UAAU,GAAG,IAAI;IAsBlC;;OAEG;IACG,WAAW,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAkBtE;;;;;OAKG;IACH,sBAAsB,IAAI,IAAI;IAsB9B,OAAO,CAAC,KAAK;YAIC,2BAA2B;IA4CzC;;;OAGG;YACW,mCAAmC;IA6DjD,OAAO,CAAC,UAAU;CAInB;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,kBAAkB,GAAG,aAAa,CAQnE;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAWnD"}

package/lib/eth1/eth1MergeBlockTracker.js

@@ -1,262 +0,0 @@
-import { pruneSetToMax, toRootHex } from "@lodestar/utils";
-import { ZERO_HASH_HEX } from "../constants/index.js";
-import { enumToIndexMap } from "../util/enum.js";
-import { dataToRootHex, quantityToBigint, quantityToNum } from "./provider/utils.js";
-export var StatusCode;
-(function (StatusCode) {
-    StatusCode["STOPPED"] = "STOPPED";
-    StatusCode["SEARCHING"] = "SEARCHING";
-    StatusCode["FOUND"] = "FOUND";
-})(StatusCode || (StatusCode = {}));
-/** For metrics, index order = declaration order of StatusCode  */
-const statusCodeIdx = enumToIndexMap(StatusCode);
-/**
- * Bounds `blocksByHashCache` cache, imposing a max distance between highest and lowest block numbers.
- * In case of extreme forking the cache might grow unbounded.
- */
-const MAX_CACHE_POW_BLOCKS = 1024;
-const MAX_TD_RENDER_VALUE = Number.MAX_SAFE_INTEGER;
-// get_pow_block_at_total_difficulty
-/**
- * Follows the eth1 chain to find a (or multiple?) merge blocks that cross the threshold of total terminal difficulty
- *
- * Finding the mergeBlock could be done in demand when proposing pre-merge blocks. However, that would slow block
- * production during the weeks between BELLATRIX_EPOCH and TTD.
- */
-export class Eth1MergeBlockTracker {
-    eth1Provider;
-    config;
-    logger;
-    metrics;
-    blocksByHashCache = new Map();
-    intervals = [];
-    status;
-    latestEth1Block = null;
-    getTerminalPowBlockFromEth1Promise = null;
-    safeTDFactor;
-    constructor({ config, logger, signal, metrics }, eth1Provider) {
-        this.eth1Provider = eth1Provider;
-        this.config = config;
-        this.logger = logger;
-        this.metrics = metrics;
-        this.status = { code: StatusCode.STOPPED };
-        signal.addEventListener("abort", () => this.close(), { once: true });
-        this.safeTDFactor = getSafeTDFactor(this.config.TERMINAL_TOTAL_DIFFICULTY);
-        const scaledTTD = this.config.TERMINAL_TOTAL_DIFFICULTY / this.safeTDFactor;
-        // Only run metrics if necessary
-        if (metrics) {
-            // TTD can't be dynamically changed during execution, register metric once
-            metrics.eth1.eth1MergeTTD.set(Number(scaledTTD));
-            metrics.eth1.eth1MergeTDFactor.set(Number(this.safeTDFactor));
-            metrics.eth1.eth1MergeStatus.addCollect(() => {
-                // Set merge ttd, merge status and merge block status
-                metrics.eth1.eth1MergeStatus.set(statusCodeIdx[this.status.code]);
-                if (this.latestEth1Block !== null) {
-                    // Set latestBlock stats
-                    metrics.eth1.eth1LatestBlockNumber.set(this.latestEth1Block.number);
-                    metrics.eth1.eth1LatestBlockTD.set(Number(this.latestEth1Block.totalDifficulty / this.safeTDFactor));
-                    metrics.eth1.eth1LatestBlockTimestamp.set(this.latestEth1Block.timestamp);
-                }
-            });
-        }
-    }
-    /**
-     * Returns the most recent POW block that satisfies the merge block condition
-     */
-    async getTerminalPowBlock() {
-        switch (this.status.code) {
-            case StatusCode.STOPPED:
-                // If not module is not polling fetch the mergeBlock explicitly
-                return this.getTerminalPowBlockFromEth1();
-            case StatusCode.SEARCHING:
-                // Assume that polling would have found the block
-                return null;
-            case StatusCode.FOUND:
-                return this.status.mergeBlock;
-        }
-    }
-    getTDProgress() {
-        if (this.latestEth1Block === null) {
-            return this.latestEth1Block;
-        }
-        const tdDiff = this.config.TERMINAL_TOTAL_DIFFICULTY - this.latestEth1Block.totalDifficulty;
-        if (tdDiff > BigInt(0)) {
-            return {
-                ttdHit: false,
-                tdFactor: this.safeTDFactor,
-                tdDiffScaled: Number((tdDiff / this.safeTDFactor)),
-                ttd: this.config.TERMINAL_TOTAL_DIFFICULTY,
-                td: this.latestEth1Block.totalDifficulty,
-                timestamp: this.latestEth1Block.timestamp,
-            };
-        }
-        return {
-            ttdHit: true,
-        };
-    }
-    /**
-     * Get a POW block by hash checking the local cache first
-     */
-    async getPowBlock(powBlockHash) {
-        // Check cache first
-        const cachedBlock = this.blocksByHashCache.get(powBlockHash);
-        if (cachedBlock) {
-            return cachedBlock;
-        }
-        // Fetch from node
-        const blockRaw = await this.eth1Provider.getBlockByHash(powBlockHash);
-        if (blockRaw) {
-            const block = toPowBlock(blockRaw);
-            this.cacheBlock(block);
-            return block;
-        }
-        return null;
-    }
-    /**
-     * Should only start polling for mergeBlock if:
-     * - after BELLATRIX_FORK_EPOCH
-     * - Beacon node synced
-     * - head state not isMergeTransitionComplete
-     */
-    startPollingMergeBlock() {
-        if (this.status.code !== StatusCode.STOPPED) {
-            return;
-        }
-        this.status = { code: StatusCode.SEARCHING };
-        this.logger.info("Starting search for terminal POW block", {
-            TERMINAL_TOTAL_DIFFICULTY: this.config.TERMINAL_TOTAL_DIFFICULTY,
-        });
-        const interval = setInterval(() => {
-            // Preemptively try to find merge block and cache it if found.
-            // Future callers of getTerminalPowBlock() will re-use the cached found mergeBlock.
-            this.getTerminalPowBlockFromEth1().catch((e) => {
-                this.logger.error("Error on findMergeBlock", {}, e);
-                this.metrics?.eth1.eth1PollMergeBlockErrors.inc();
-            });
-        }, this.config.SECONDS_PER_ETH1_BLOCK * 1000);
-        this.intervals.push(interval);
-    }
-    close() {
-        this.intervals.forEach(clearInterval);
-    }
-    async getTerminalPowBlockFromEth1() {
-        if (!this.getTerminalPowBlockFromEth1Promise) {
-            this.getTerminalPowBlockFromEth1Promise = this.internalGetTerminalPowBlockFromEth1()
-                .then((mergeBlock) => {
-                // Persist found merge block here to affect both caller paths:
-                // - internal searcher
-                // - external caller if STOPPED
-                if (mergeBlock && this.status.code !== StatusCode.FOUND) {
-                    if (this.status.code === StatusCode.SEARCHING) {
-                        this.close();
-                    }
-                    this.logger.info("Terminal POW block found!", {
-                        hash: mergeBlock.blockHash,
-                        number: mergeBlock.number,
-                        totalDifficulty: mergeBlock.totalDifficulty,
-                    });
-                    this.status = { code: StatusCode.FOUND, mergeBlock };
-                    this.metrics?.eth1.eth1MergeBlockDetails.set({
-                        terminalBlockHash: mergeBlock.blockHash,
-                        // Convert all number/bigints to string labels
-                        terminalBlockNumber: mergeBlock.number.toString(10),
-                        terminalBlockTD: mergeBlock.totalDifficulty.toString(10),
-                    }, 1);
-                }
-                return mergeBlock;
-            })
-                .finally(() => {
-                this.getTerminalPowBlockFromEth1Promise = null;
-            });
-        }
-        else {
-            // This should no happen, since getTerminalPowBlockFromEth1() should resolve faster than SECONDS_PER_ETH1_BLOCK.
-            // else something is wrong: the el-cl comms are two slow, or the backsearch got stuck in a deep search.
-            this.metrics?.eth1.getTerminalPowBlockPromiseCacheHit.inc();
-        }
-        return this.getTerminalPowBlockFromEth1Promise;
-    }
-    /**
-     * **internal** + **unsafe** since it can create multiple backward searches that overload the eth1 client.
-     * Must be called in a wrapper to ensure that there's only once concurrent call to this fn.
-     */
-    async internalGetTerminalPowBlockFromEth1() {
-        // Search merge block by hash
-        // Terminal block hash override takes precedence over terminal total difficulty
-        const terminalBlockHash = toRootHex(this.config.TERMINAL_BLOCK_HASH);
-        if (terminalBlockHash !== ZERO_HASH_HEX) {
-            const block = await this.getPowBlock(terminalBlockHash);
-            if (block) {
-                return block;
-            }
-            // if a TERMINAL_BLOCK_HASH other than ZERO_HASH is configured and we can't find it, return NONE
-            return null;
-        }
-        // Search merge block by TTD
-        const latestBlockRaw = await this.eth1Provider.getBlockByNumber("latest");
-        if (!latestBlockRaw) {
-            throw Error("getBlockByNumber('latest') returned null");
-        }
-        let block = toPowBlock(latestBlockRaw);
-        this.latestEth1Block = { ...block, timestamp: quantityToNum(latestBlockRaw.timestamp) };
-        this.cacheBlock(block);
-        // This code path to look backwards for the merge block is only necessary if:
-        // - The network has not yet found the merge block
-        // - There are descendants of the merge block in the eth1 chain
-        // For the search below to require more than a few hops, multiple block proposers in a row must fail to detect
-        // an existing merge block. Such situation is extremely unlikely, so this search is left un-optimized. Since
-        // this class can start eagerly looking for the merge block when not necessary, startPollingMergeBlock() should
-        // only be called when there is certainty that a mergeBlock search is necessary.
-        while (true) {
-            if (block.totalDifficulty < this.config.TERMINAL_TOTAL_DIFFICULTY) {
-                // TTD not reached yet
-                return null;
-            }
-            // else block.totalDifficulty >= this.config.TERMINAL_TOTAL_DIFFICULTY
-            // Potential mergeBlock! Must find the first block that passes TTD
-            // Allow genesis block to reach TTD https://github.com/ethereum/consensus-specs/pull/2719
-            if (block.parentHash === ZERO_HASH_HEX) {
-                return block;
-            }
-            const parent = await this.getPowBlock(block.parentHash);
-            if (!parent) {
-                throw Error(`Unknown parent of block with TD>TTD ${block.parentHash}`);
-            }
-            this.metrics?.eth1.eth1ParentBlocksFetched.inc();
-            // block.td > TTD && parent.td < TTD => block is mergeBlock
-            if (parent.totalDifficulty < this.config.TERMINAL_TOTAL_DIFFICULTY) {
-                // Is terminal total difficulty block AND has verified block -> parent relationship
-                return block;
-            }
-            block = parent;
-        }
-    }
-    cacheBlock(block) {
-        this.blocksByHashCache.set(block.blockHash, block);
-        pruneSetToMax(this.blocksByHashCache, MAX_CACHE_POW_BLOCKS);
-    }
-}
-export function toPowBlock(block) {
-    // Validate untrusted data from API
-    return {
-        number: quantityToNum(block.number),
-        blockHash: dataToRootHex(block.hash),
-        parentHash: dataToRootHex(block.parentHash),
-        totalDifficulty: quantityToBigint(block.totalDifficulty),
-    };
-}
-/**
- * TTD values can be very large, for xDAI > 1e45. So scale down.
- * To be good, TTD should be rendered as a number < Number.MAX_TD_RENDER_VALUE ~= 9e15
- */
-export function getSafeTDFactor(ttd) {
-    const safeIntegerMult = ttd / BigInt(MAX_TD_RENDER_VALUE);
-    // TTD < MAX_TD_RENDER_VALUE, no need to scale down
-    if (safeIntegerMult === BigInt(0)) {
-        return BigInt(1);
-    }
-    // Return closest power of 10 to ensure TD < max
-    const safeIntegerMultDigits = safeIntegerMult.toString(10).length;
-    return BigInt(10) ** BigInt(safeIntegerMultDigits);
-}
-//# sourceMappingURL=eth1MergeBlockTracker.js.map