@lodestar/beacon-node 1.39.0-dev.aceb5b7416 → 1.39.0-dev.b37f2bd1bd

package/src/eth1/utils/eth1Data.ts

@@ -0,0 +1,100 @@
+import {Root, phase0} from "@lodestar/types";
+import {DepositTree} from "../../db/repositories/depositDataRoot.js";
+import {binarySearchLte} from "../../util/binarySearch.js";
+import {Eth1Error, Eth1ErrorCode} from "../errors.js";
+import {Eth1Block} from "../interface.js";
+
+type BlockNumber = number;
+
+/**
+ * Appends partial eth1 data (depositRoot, depositCount) in a sequence of blocks
+ * eth1 data deposit is inferred from sparse eth1 data obtained from the deposit logs
+ */
+export async function getEth1DataForBlocks(
+  blocks: Eth1Block[],
+  depositDescendingStream: AsyncIterable<phase0.DepositEvent>,
+  depositRootTree: DepositTree,
+  lastProcessedDepositBlockNumber: BlockNumber | null
+): Promise<(phase0.Eth1Data & Eth1Block)[]> {
+  // Exclude blocks for which there is no valid eth1 data deposit
+  if (lastProcessedDepositBlockNumber !== null) {
+    blocks = blocks.filter((block) => block.blockNumber <= lastProcessedDepositBlockNumber);
+  }
+
+  // A valid block can be constructed using previous `state.eth1Data`, don't throw
+  if (blocks.length === 0) {
+    return [];
+  }
+
+  // Collect the latest deposit of each blockNumber in a block number range
+  const fromBlock = blocks[0].blockNumber;
+  const toBlock = blocks.at(-1)?.blockNumber as number;
+  const depositsByBlockNumber = await getDepositsByBlockNumber(fromBlock, toBlock, depositDescendingStream);
+  if (depositsByBlockNumber.length === 0) {
+    throw new Eth1Error({code: Eth1ErrorCode.NO_DEPOSITS_FOR_BLOCK_RANGE, fromBlock, toBlock});
+  }
+
+  // Precompute a map of depositCount => depositRoot (from depositRootTree)
+  const depositCounts = depositsByBlockNumber.map((event) => event.index + 1);
+  const depositRootByDepositCount = getDepositRootByDepositCount(depositCounts, depositRootTree);
+
+  const eth1Datas: (phase0.Eth1Data & Eth1Block)[] = [];
+  for (const block of blocks) {
+    const deposit = binarySearchLte(depositsByBlockNumber, block.blockNumber, (event) => event.blockNumber);
+    const depositCount = deposit.index + 1;
+    const depositRoot = depositRootByDepositCount.get(depositCount);
+    if (depositRoot === undefined) {
+      throw new Eth1Error({code: Eth1ErrorCode.NO_DEPOSIT_ROOT, depositCount});
+    }
+    eth1Datas.push({...block, depositCount, depositRoot});
+  }
+  return eth1Datas;
+}
+
+/**
+ * Collect depositCount by blockNumber from a stream matching a block number range
+ * For a given blockNumber it's depositCount is equal to the index + 1 of the
+ * closest deposit event whose deposit.blockNumber <= blockNumber
+ * @returns array ascending by blockNumber
+ */
+export async function getDepositsByBlockNumber(
+  fromBlock: BlockNumber,
+  toBlock: BlockNumber,
+  depositEventDescendingStream: AsyncIterable<phase0.DepositEvent>
+): Promise<phase0.DepositEvent[]> {
+  const depositCountMap = new Map<BlockNumber, phase0.DepositEvent>();
+  // Take blocks until the block under the range lower bound (included)
+  for await (const deposit of depositEventDescendingStream) {
+    if (deposit.blockNumber <= toBlock && !depositCountMap.has(deposit.blockNumber)) {
+      depositCountMap.set(deposit.blockNumber, deposit);
+    }
+    if (deposit.blockNumber < fromBlock) {
+      break;
+    }
+  }
+
+  return Array.from(depositCountMap.values()).sort((a, b) => a.blockNumber - b.blockNumber);
+}
+
+/**
+ * Precompute a map of depositCount => depositRoot from a depositRootTree filled beforehand
+ */
+export function getDepositRootByDepositCount(depositCounts: number[], depositRootTree: DepositTree): Map<number, Root> {
+  // Unique + sort numerically in descending order
+  depositCounts = [...new Set(depositCounts)].sort((a, b) => b - a);
+
+  if (depositCounts.length > 0) {
+    const maxIndex = depositCounts[0] - 1;
+    const treeLength = depositRootTree.length - 1;
+    if (maxIndex > treeLength) {
+      throw new Eth1Error({code: Eth1ErrorCode.NOT_ENOUGH_DEPOSIT_ROOTS, index: maxIndex, treeLength});
+    }
+  }
+
+  const depositRootByDepositCount = new Map<number, Root>();
+  for (const depositCount of depositCounts) {
+    depositRootTree = depositRootTree.sliceTo(depositCount - 1);
+    depositRootByDepositCount.set(depositCount, depositRootTree.hashTreeRoot());
+  }
+  return depositRootByDepositCount;
+}

package/src/eth1/utils/eth1DepositEvent.ts

@@ -0,0 +1,12 @@
+/**
+ * Assert that an array of deposits are consecutive and ascending
+ */
+export function assertConsecutiveDeposits(depositEvents: {index: number}[]): void {
+  for (let i = 0; i < depositEvents.length - 1; i++) {
+    const indexLeft = depositEvents[i].index;
+    const indexRight = depositEvents[i + 1].index;
+    if (indexLeft !== indexRight - 1) {
+      throw Error(`Non consecutive deposits. deposit[${i}] = ${indexLeft}, deposit[${i + 1}] ${indexRight}`);
+    }
+  }
+}

package/src/eth1/utils/eth1Vote.ts

@@ -0,0 +1,142 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {EPOCHS_PER_ETH1_VOTING_PERIOD, SLOTS_PER_EPOCH, isForkPostElectra} from "@lodestar/params";
+import {BeaconStateAllForks, BeaconStateElectra, computeTimeAtSlot} from "@lodestar/state-transition";
+import {RootHex, phase0} from "@lodestar/types";
+import {toRootHex} from "@lodestar/utils";
+
+export type Eth1DataGetter = ({
+  timestampRange,
+}: {
+  timestampRange: {gte: number; lte: number};
+}) => Promise<phase0.Eth1Data[]>;
+
+export async function getEth1VotesToConsider(
+  config: ChainForkConfig,
+  state: BeaconStateAllForks,
+  eth1DataGetter: Eth1DataGetter
+): Promise<phase0.Eth1Data[]> {
+  const fork = config.getForkName(state.slot);
+  if (isForkPostElectra(fork)) {
+    const {eth1DepositIndex, depositRequestsStartIndex} = state as BeaconStateElectra;
+    if (eth1DepositIndex === Number(depositRequestsStartIndex)) {
+      return state.eth1DataVotes.getAllReadonly();
+    }
+  }
+
+  const periodStart = votingPeriodStartTime(config, state);
+  const {SECONDS_PER_ETH1_BLOCK, ETH1_FOLLOW_DISTANCE} = config;
+
+  // Modified version of the spec function to fetch the required range directly from the DB
+  return (
+    await eth1DataGetter({
+      timestampRange: {
+        // Spec v0.12.2
+        // is_candidate_block =
+        //   block.timestamp + SECONDS_PER_ETH1_BLOCK * ETH1_FOLLOW_DISTANCE <= period_start &&
+        //   block.timestamp + SECONDS_PER_ETH1_BLOCK * ETH1_FOLLOW_DISTANCE * 2 >= period_start
+        lte: periodStart - SECONDS_PER_ETH1_BLOCK * ETH1_FOLLOW_DISTANCE,
+        gte: periodStart - SECONDS_PER_ETH1_BLOCK * ETH1_FOLLOW_DISTANCE * 2,
+      },
+    })
+  ).filter((eth1Data) => eth1Data.depositCount >= state.eth1Data.depositCount);
+}
+
+export function pickEth1Vote(state: BeaconStateAllForks, votesToConsider: phase0.Eth1Data[]): phase0.Eth1Data {
+  const votesToConsiderKeys = new Set<string>();
+  for (const eth1Data of votesToConsider) {
+    votesToConsiderKeys.add(getEth1DataKey(eth1Data));
+  }
+
+  const eth1DataHashToEth1Data = new Map<RootHex, phase0.Eth1Data>();
+  const eth1DataVoteCountByRoot = new Map<RootHex, number>();
+  const eth1DataVotesOrder: RootHex[] = [];
+
+  // BeaconStateAllForks is always represented as a tree with a hashing cache.
+  // To check equality its cheaper to use hashTreeRoot as keys.
+  // However `votesToConsider` is an array of values since those are read from DB.
+  // TODO: Optimize cache of known votes, to prevent re-hashing stored values.
+  // Note: for low validator counts it's not very important, since this runs once per proposal
+  const eth1DataVotes = state.eth1DataVotes.getAllReadonly();
+  for (const eth1DataVote of eth1DataVotes) {
+    const rootHex = getEth1DataKey(eth1DataVote);
+
+    if (votesToConsiderKeys.has(rootHex)) {
+      const prevVoteCount = eth1DataVoteCountByRoot.get(rootHex);
+      eth1DataVoteCountByRoot.set(rootHex, 1 + (prevVoteCount ?? 0));
+
+      // Cache eth1DataVote to root Map only once per root
+      if (prevVoteCount === undefined) {
+        eth1DataHashToEth1Data.set(rootHex, eth1DataVote);
+        eth1DataVotesOrder.push(rootHex);
+      }
+    }
+  }
+
+  const eth1DataRootsMaxVotes = getKeysWithMaxValue(eth1DataVoteCountByRoot);
+
+  // No votes, vote for the last valid vote
+  if (eth1DataRootsMaxVotes.length === 0) {
+    return votesToConsider.at(-1) ?? state.eth1Data;
+  }
+
+  // If there's a single winning vote with a majority vote that one
+  if (eth1DataRootsMaxVotes.length === 1) {
+    return eth1DataHashToEth1Data.get(eth1DataRootsMaxVotes[0]) ?? state.eth1Data;
+  }
+
+  // If there are multiple winning votes, vote for the latest one
+  const latestMostVotedRoot =
+    eth1DataVotesOrder[Math.max(...eth1DataRootsMaxVotes.map((root) => eth1DataVotesOrder.indexOf(root)))];
+  return eth1DataHashToEth1Data.get(latestMostVotedRoot) ?? state.eth1Data;
+}
+
+/**
+ * Returns the array of keys with max value. May return 0, 1 or more keys
+ */
+function getKeysWithMaxValue<T>(map: Map<T, number>): T[] {
+  const entries = Array.from(map.entries());
+  let keysMax: T[] = [];
+  let valueMax = -Infinity;
+
+  for (const [key, value] of entries) {
+    if (value > valueMax) {
+      keysMax = [key];
+      valueMax = value;
+    } else if (value === valueMax) {
+      keysMax.push(key);
+    }
+  }
+
+  return keysMax;
+}
+
+/**
+ * Key-ed by fastSerializeEth1Data(). votesToConsider is read from DB as struct and always has a length of 2048.
+ * `state.eth1DataVotes` has a length between 0 and ETH1_FOLLOW_DISTANCE with an equal probability of each value.
+ * So to get the average faster time to key both votesToConsider and state.eth1DataVotes it's better to use
+ * fastSerializeEth1Data(). However, a long term solution is to cache valid votes in memory and prevent having
+ * to recompute their key on every proposal.
+ *
+ * With `fastSerializeEth1Data()`: avg time 20 ms/op
+ * ✓ pickEth1Vote - no votes                                             233.0587 ops/s    4.290764 ms/op        -        121 runs   1.02 s
+ * ✓ pickEth1Vote - max votes                                            29.21546 ops/s    34.22845 ms/op        -         25 runs   1.38 s
+ *
+ * With `toHexString(ssz.phase0.Eth1Data.hashTreeRoot(eth1Data))`: avg time 23 ms/op
+ * ✓ pickEth1Vote - no votes                                             46.12341 ops/s    21.68096 ms/op        -        133 runs   3.40 s
+ * ✓ pickEth1Vote - max votes                                            37.89912 ops/s    26.38583 ms/op        -         29 runs   1.27 s
+ */
+function getEth1DataKey(eth1Data: phase0.Eth1Data): string {
+  return fastSerializeEth1Data(eth1Data);
+}
+
+/**
+ * Serialize eth1Data types to a unique string ID. It is only used for comparison.
+ */
+export function fastSerializeEth1Data(eth1Data: phase0.Eth1Data): string {
+  return toRootHex(eth1Data.blockHash) + eth1Data.depositCount.toString(16) + toRootHex(eth1Data.depositRoot);
+}
+
+export function votingPeriodStartTime(config: ChainForkConfig, state: BeaconStateAllForks): number {
+  const eth1VotingPeriodStartSlot = state.slot - (state.slot % (EPOCHS_PER_ETH1_VOTING_PERIOD * SLOTS_PER_EPOCH));
+  return computeTimeAtSlot(config, eth1VotingPeriodStartSlot, state.genesisTime);
+}

package/src/eth1/utils/groupDepositEventsByBlock.ts

@@ -0,0 +1,19 @@
+import {phase0} from "@lodestar/types";
+import {BatchDepositEvents} from "../interface.js";
+
+/**
+ * Return deposit events of blocks grouped/sorted by block number and deposit index
+ * Blocks without events are omitted
+ * @param depositEvents range deposit events
+ */
+export function groupDepositEventsByBlock(depositEvents: phase0.DepositEvent[]): BatchDepositEvents[] {
+  depositEvents.sort((event1, event2) => event1.index - event2.index);
+  const depositsByBlockMap = new Map<number, phase0.DepositEvent[]>();
+  for (const deposit of depositEvents) {
+    depositsByBlockMap.set(deposit.blockNumber, [...(depositsByBlockMap.get(deposit.blockNumber) || []), deposit]);
+  }
+  return Array.from(depositsByBlockMap.entries()).map(([blockNumber, depositEvents]) => ({
+    blockNumber,
+    depositEvents,
+  }));
+}

package/src/eth1/utils/optimizeNextBlockDiffForGenesis.ts

@@ -0,0 +1,18 @@
+import {ChainConfig} from "@lodestar/config";
+
+/**
+ * Utility for fetching genesis min genesis time block
+ * Returns an approximation of the next block diff to fetch to progressively
+ * get closer to the block that satisfies min genesis time condition
+ */
+export function optimizeNextBlockDiffForGenesis(
+  lastFetchedBlock: {timestamp: number},
+  params: Pick<ChainConfig, "MIN_GENESIS_TIME" | "GENESIS_DELAY" | "SECONDS_PER_ETH1_BLOCK">
+): number {
+  const timeToGenesis = params.MIN_GENESIS_TIME - params.GENESIS_DELAY - lastFetchedBlock.timestamp;
+  const numBlocksToGenesis = Math.floor(timeToGenesis / params.SECONDS_PER_ETH1_BLOCK);
+  if (numBlocksToGenesis <= 2) {
+    return 1;
+  }
+  return Math.max(1, Math.floor(numBlocksToGenesis / 2));
+}

package/src/execution/engine/http.ts

@@ -4,6 +4,14 @@ import {BlobsBundle, ExecutionPayload, ExecutionRequests, Root, RootHex, Wei} fr
 import {BlobAndProof} from "@lodestar/types/deneb";
 import {BlobAndProofV2} from "@lodestar/types/fulu";
 import {strip0xPrefix} from "@lodestar/utils";
+import {
+  ErrorJsonRpcResponse,
+  HttpRpcError,
+  IJsonRpcHttpClient,
+  JsonRpcHttpClientEvent,
+  ReqOpts,
+} from "../../eth1/provider/jsonRpcHttpClient.js";
+import {bytesToData, numToQuantity} from "../../eth1/provider/utils.js";
 import {Metrics} from "../../metrics/index.js";
 import {EPOCHS_PER_BATCH} from "../../sync/constants.js";
 import {getLodestarClientVersion} from "../../util/metadata.js";
@@ -19,13 +27,6 @@ import {
   PayloadId,
   VersionedHashes,
 } from "./interface.js";
-import {
-  ErrorJsonRpcResponse,
-  HttpRpcError,
-  IJsonRpcHttpClient,
-  JsonRpcHttpClientEvent,
-  ReqOpts,
-} from "./jsonRpcHttpClient.js";
 import {PayloadIdCache} from "./payloadIdCache.js";
 import {
   BLOB_AND_PROOF_V2_RPC_BYTES,
@@ -44,7 +45,7 @@ import {
   serializePayloadAttributes,
   serializeVersionedHashes,
 } from "./types.js";
-import {bytesToData, getExecutionEngineState, numToQuantity} from "./utils.js";
+import {getExecutionEngineState} from "./utils.js";
 
 export type ExecutionEngineModules = {
   signal: AbortSignal;

package/src/execution/engine/index.ts

@@ -1,4 +1,5 @@
 import {fromHex, toPrintableUrl} from "@lodestar/utils";
+import {JsonRpcHttpClient} from "../../eth1/provider/jsonRpcHttpClient.js";
 import {ExecutionEngineDisabled} from "./disabled.js";
 import {
   ExecutionEngineHttp,
@@ -7,7 +8,6 @@ import {
   defaultExecutionEngineHttpOpts,
 } from "./http.js";
 import {IExecutionEngine} from "./interface.js";
-import {JsonRpcHttpClient} from "./jsonRpcHttpClient.js";
 import {ExecutionEngineMockBackend, ExecutionEngineMockOpts} from "./mock.js";
 import {ExecutionEngineMockJsonRpcClient, JsonRpcBackend} from "./utils.js";
 

package/src/execution/engine/interface.ts

@@ -9,9 +9,9 @@ import {
 import {BlobsBundle, ExecutionPayload, ExecutionRequests, Root, RootHex, Wei, capella} from "@lodestar/types";
 import {BlobAndProof} from "@lodestar/types/deneb";
 import {BlobAndProofV2} from "@lodestar/types/fulu";
+import {DATA} from "../../eth1/provider/utils.js";
 import {PayloadId, PayloadIdCache, WithdrawalV1} from "./payloadIdCache.js";
 import {ExecutionPayloadBody} from "./types.js";
-import {DATA} from "./utils.js";
 
 export {PayloadIdCache, type PayloadId, type WithdrawalV1};
 

package/src/execution/engine/mock.ts

@@ -11,6 +11,7 @@ import {
 import {ExecutionPayload, RootHex, bellatrix, deneb, ssz} from "@lodestar/types";
 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";
 import {kzgCommitmentToVersionedHash} from "../../util/blobs.js";
 import {kzg} from "../../util/kzg.js";
@@ -28,7 +29,7 @@ import {
   serializeExecutionPayload,
   serializeExecutionRequests,
 } from "./types.js";
-import {JsonRpcBackend, quantityToNum} from "./utils.js";
+import {JsonRpcBackend} from "./utils.js";
 
 const INTEROP_GAS_LIMIT = 30e6;
 const PRUNE_PAYLOAD_ID_AFTER_MS = 5000;

package/src/execution/engine/payloadIdCache.ts

@@ -1,7 +1,7 @@
 import {SLOTS_PER_EPOCH} from "@lodestar/params";
 import {pruneSetToMax} from "@lodestar/utils";
+import {DATA, QUANTITY} from "../../eth1/provider/utils.js";
 import {PayloadAttributesRpc} from "./types.js";
-import {DATA, QUANTITY} from "./utils.js";
 
 // Idealy this only need to be set to the max head reorgs number
 const MAX_PAYLOAD_IDS = SLOTS_PER_EPOCH;

package/src/execution/engine/types.ts

@@ -23,14 +23,6 @@ import {
 } from "@lodestar/types";
 import {BlobAndProof} from "@lodestar/types/deneb";
 import {BlobAndProofV2} from "@lodestar/types/fulu";
-import {
-  ExecutionPayloadStatus,
-  ExecutionRequestType,
-  PayloadAttributes,
-  VersionedHashes,
-  isExecutionRequestType,
-} from "./interface.js";
-import {WithdrawalV1} from "./payloadIdCache.js";
 import {
   DATA,
   QUANTITY,
@@ -40,7 +32,15 @@ import {
   numToQuantity,
   quantityToBigint,
   quantityToNum,
-} from "./utils.js";
+} from "../../eth1/provider/utils.js";
+import {
+  ExecutionPayloadStatus,
+  ExecutionRequestType,
+  PayloadAttributes,
+  VersionedHashes,
+  isExecutionRequestType,
+} from "./interface.js";
+import {WithdrawalV1} from "./payloadIdCache.js";
 
 export type EngineApiRpcParamTypes = {
   /**

package/src/execution/engine/utils.ts

@@ -1,120 +1,14 @@
-import {bigIntToBytes, bytesToBigInt, fromHex, fromHexInto, isErrorAborted, isFetchError, toHex} from "@lodestar/utils";
-import {isQueueErrorAborted} from "../../util/queue/errors.js";
-import {ExecutionEngineState, ExecutionPayloadStatus} from "./interface.js";
+import {isErrorAborted, isFetchError} from "@lodestar/utils";
+import {IJson, RpcPayload} from "../../eth1/interface.js";
 import {
   ErrorJsonRpcResponse,
   HttpRpcError,
   IJsonRpcHttpClient,
   JsonRpcHttpClientEvent,
   JsonRpcHttpClientEventEmitter,
-} from "./jsonRpcHttpClient.js";
-
-/** QUANTITY as defined in ethereum execution layer JSON RPC https://eth.wiki/json-rpc/API */
-export type QUANTITY = string;
-/** DATA as defined in ethereum execution layer JSON RPC https://eth.wiki/json-rpc/API */
-export type DATA = string;
-
-export const rootHexRegex = /^0x[a-fA-F0-9]{64}$/;
-
-export type IJson = string | number | boolean | undefined | IJson[] | {[key: string]: IJson};
-
-export interface RpcPayload<P = IJson[]> {
-  method: string;
-  params: P;
-}
-
-/**
- * QUANTITY as defined in ethereum execution layer JSON RPC https://eth.wiki/json-rpc/API
- *
- * When encoding QUANTITIES (integers, numbers): encode as hex, prefix with “0x”, the most compact representation (slight exception: zero should be represented as “0x0”). Examples:
- * - 0x41 (65 in decimal)
- * - 0x400 (1024 in decimal)
- * - WRONG: 0x (should always have at least one digit - zero is “0x0”)
- * - WRONG: 0x0400 (no leading zeroes allowed)
- * - WRONG: ff (must be prefixed 0x)
- */
-export function numToQuantity(num: number | bigint): QUANTITY {
-  return "0x" + num.toString(16);
-}
-
-/**
- * QUANTITY as defined in ethereum execution layer JSON RPC https://eth.wiki/json-rpc/API
- */
-export function quantityToNum(hex: QUANTITY, id = ""): number {
-  const num = parseInt(hex, 16);
-  if (Number.isNaN(num) || num < 0) throw Error(`Invalid hex decimal ${id} '${hex}'`);
-  return num;
-}
-
-/**
- * QUANTITY as defined in ethereum execution layer JSON RPC https://eth.wiki/json-rpc/API.
- * Typesafe fn to convert hex string to bigint. The BigInt constructor param is any
- */
-export function quantityToBigint(hex: QUANTITY, id = ""): bigint {
-  try {
-    return BigInt(hex);
-  } catch (e) {
-    throw Error(`Invalid hex bigint ${id} '${hex}': ${(e as Error).message}`);
-  }
-}
-
-/**
- * QUANTITY as defined in ethereum execution layer JSON RPC https://eth.wiki/json-rpc/API.
- */
-export function quantityToBytes(hex: QUANTITY): Uint8Array {
-  const bn = quantityToBigint(hex);
-  return bigIntToBytes(bn, 32, "le");
-}
-
-/**
- * QUANTITY as defined in ethereum execution layer JSON RPC https://eth.wiki/json-rpc/API.
- * Compress a 32 ByteVector into a QUANTITY
- */
-export function bytesToQuantity(bytes: Uint8Array): QUANTITY {
-  const bn = bytesToBigInt(bytes, "le");
-  return numToQuantity(bn);
-}
-
-/**
- * DATA as defined in ethereum execution layer JSON RPC https://eth.wiki/json-rpc/API
- *
- * When encoding UNFORMATTED DATA (byte arrays, account addresses, hashes, bytecode arrays): encode as hex, prefix with
- * “0x”, two hex digits per byte. Examples:
- *
- * - 0x41 (size 1, “A”)
- * - 0x004200 (size 3, “\0B\0”)
- * - 0x (size 0, “”)
- * - WRONG: 0xf0f0f (must be even number of digits)
- * - WRONG: 004200 (must be prefixed 0x)
- */
-export function bytesToData(bytes: Uint8Array): DATA {
-  return toHex(bytes);
-}
-
-/**
- * DATA as defined in ethereum execution layer JSON RPC https://eth.wiki/json-rpc/API
- */
-export function dataToBytes(hex: DATA, fixedLength: number | null): Uint8Array {
-  try {
-    const bytes = fromHex(hex);
-    if (fixedLength != null && bytes.length !== fixedLength) {
-      throw Error(`Wrong data length ${bytes.length} expected ${fixedLength}`);
-    }
-    return bytes;
-  } catch (e) {
-    (e as Error).message = `Invalid hex string: ${(e as Error).message}`;
-    throw e;
-  }
-}
-
-/**
- * Convert DATA into a preallocated buffer
- * fromHexInto will throw if buffer's length is not the same as the decoded hex length
- */
-export function dataIntoBytes(hex: DATA, buffer: Uint8Array): Uint8Array {
-  fromHexInto(hex, buffer);
-  return buffer;
-}
+} from "../../eth1/provider/jsonRpcHttpClient.js";
+import {isQueueErrorAborted} from "../../util/queue/errors.js";
+import {ExecutionEngineState, ExecutionPayloadStatus} from "./interface.js";
 
 export type JsonRpcBackend = {
   // biome-ignore lint/suspicious/noExplicitAny: We need to use `any` type here

package/src/index.ts

@@ -2,10 +2,11 @@
 
 export type {RestApiServerMetrics, RestApiServerModules, RestApiServerOpts} from "./api/rest/base.js";
 export {RestApiServer} from "./api/rest/base.js";
-export {checkAndPersistAnchorState, initStateFromDb} from "./chain/index.js";
+export {checkAndPersistAnchorState, initStateFromDb, initStateFromEth1} from "./chain/index.js";
 export {DbCPStateDatastore} from "./chain/stateCache/datastore/db.js";
 export {FileCPStateDatastore} from "./chain/stateCache/datastore/file.js";
 export {BeaconDb, type IBeaconDb} from "./db/index.js";
+export {Eth1Provider, type IEth1Provider} from "./eth1/index.js";
 // Export metrics utilities to de-duplicate validator metrics
 export {
   type HttpMetricsServer,

package/src/metrics/metrics/lodestar.ts

@@ -1619,6 +1619,98 @@ export function createLodestarMetrics(
       }),
     },
 
+    eth1: {
+      depositTrackerIsCaughtup: register.gauge({
+        name: "lodestar_eth1_deposit_tracker_is_caughtup",
+        help: "Eth1 deposit is caught up 0=false 1=true",
+      }),
+      depositTrackerUpdateErrors: register.gauge({
+        name: "lodestar_eth1_deposit_tracker_update_errors_total",
+        help: "Eth1 deposit update loop errors total",
+      }),
+      remoteHighestBlock: register.gauge({
+        name: "lodestar_eth1_remote_highest_block",
+        help: "Eth1 current highest block number",
+      }),
+      depositEventsFetched: register.gauge({
+        name: "lodestar_eth1_deposit_events_fetched_total",
+        help: "Eth1 deposit events fetched total",
+      }),
+      lastProcessedDepositBlockNumber: register.gauge({
+        name: "lodestar_eth1_last_processed_deposit_block_number",
+        help: "Eth1 deposit tracker lastProcessedDepositBlockNumber",
+      }),
+      blocksFetched: register.gauge({
+        name: "lodestar_eth1_blocks_fetched_total",
+        help: "Eth1 blocks fetched total",
+      }),
+      lastFetchedBlockBlockNumber: register.gauge({
+        name: "lodestar_eth1_last_fetched_block_block_number",
+        help: "Eth1 deposit tracker last fetched block's block number",
+      }),
+      lastFetchedBlockTimestamp: register.gauge({
+        name: "lodestar_eth1_last_fetched_block_timestamp",
+        help: "Eth1 deposit tracker last fetched block's timestamp",
+      }),
+      eth1FollowDistanceSecondsConfig: register.gauge({
+        name: "lodestar_eth1_follow_distance_seconds_config",
+        help: "Constant with value = SECONDS_PER_ETH1_BLOCK * ETH1_FOLLOW_DISTANCE",
+      }),
+      eth1FollowDistanceDynamic: register.gauge({
+        name: "lodestar_eth1_follow_distance_dynamic",
+        help: "Eth1 dynamic follow distance changed by the deposit tracker if blocks are slow",
+      }),
+      eth1GetBlocksBatchSizeDynamic: register.gauge({
+        name: "lodestar_eth1_blocks_batch_size_dynamic",
+        help: "Dynamic batch size to fetch blocks",
+      }),
+      eth1GetLogsBatchSizeDynamic: register.gauge({
+        name: "lodestar_eth1_logs_batch_size_dynamic",
+        help: "Dynamic batch size to fetch deposit logs",
+      }),
+    },
+
+    eth1HttpClient: {
+      requestTime: register.histogram<{routeId: string}>({
+        name: "lodestar_eth1_http_client_request_time_seconds",
+        help: "eth1 JsonHttpClient - histogram or roundtrip request times",
+        labelNames: ["routeId"],
+        // Provide max resolution on problematic values around 1 second
+        buckets: [0.1, 0.5, 1, 2, 5, 15],
+      }),
+      streamTime: register.histogram<{routeId: string}>({
+        name: "lodestar_eth1_http_client_stream_time_seconds",
+        help: "eth1 JsonHttpClient - streaming time by routeId",
+        labelNames: ["routeId"],
+        // Provide max resolution on problematic values around 1 second
+        buckets: [0.1, 0.5, 1, 2, 5, 15],
+      }),
+      requestErrors: register.gauge<{routeId: string}>({
+        name: "lodestar_eth1_http_client_request_errors_total",
+        help: "eth1 JsonHttpClient - total count of request errors",
+        labelNames: ["routeId"],
+      }),
+      retryCount: register.gauge<{routeId: string}>({
+        name: "lodestar_eth1_http_client_request_retries_total",
+        help: "eth1 JsonHttpClient - total count of request retries",
+        labelNames: ["routeId"],
+      }),
+      requestUsedFallbackUrl: register.gauge<{routeId: string}>({
+        name: "lodestar_eth1_http_client_request_used_fallback_url_total",
+        help: "eth1 JsonHttpClient - total count of requests on fallback url(s)",
+        labelNames: ["routeId"],
+      }),
+      activeRequests: register.gauge<{routeId: string}>({
+        name: "lodestar_eth1_http_client_active_requests",
+        help: "eth1 JsonHttpClient - current count of active requests",
+        labelNames: ["routeId"],
+      }),
+      configUrlsCount: register.gauge({
+        name: "lodestar_eth1_http_client_config_urls_count",
+        help: "eth1 JsonHttpClient - static config urls count",
+      }),
+    },
+
     executionEnginerHttpClient: {
       requestTime: register.histogram<{routeId: string}>({
         name: "lodestar_execution_engine_http_client_request_time_seconds",