@lodestar/beacon-node 1.35.0-dev.91dadf81de → 1.35.0-dev.955e9f89ed

package/src/eth1/provider/utils.ts

@@ -1,136 +0,0 @@
-import {RootHex} from "@lodestar/types";
-import {bigIntToBytes, bytesToBigInt, fromHex, fromHexInto, toHex} from "@lodestar/utils";
-import {ErrorParseJson} 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 function numberToHex(n: number | bigint): string {
-  return "0x" + n.toString(16);
-}
-
-export function isJsonRpcTruncatedError(error: Error): boolean {
-  return (
-    // Truncated responses usually get as 200 but since it's truncated the JSON will be invalid
-    error instanceof ErrorParseJson ||
-    // Otherwise guess Infura error message of too many events
-    (error instanceof Error && error.message.includes("query returned more than 10000 results")) ||
-    // Nethermind enforces limits on JSON RPC batch calls
-    (error instanceof Error && error.message.toLowerCase().includes("batch size limit exceeded"))
-  );
-}
-
-export function bytesToHex(bytes: Uint8Array): string {
-  // Handle special case in Ethereum hex formating where hex values may include a single letter
-  // 0x0, 0x1 are valid values
-  if (bytes.length === 1 && bytes[0] <= 0xf) {
-    return "0x" + bytes[0].toString(16);
-  }
-
-  return toHex(bytes);
-}
-
-/**
- * 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;
-}
-
-/**
- * DATA as defined in ethereum execution layer JSON RPC https://eth.wiki/json-rpc/API
- */
-export function dataToRootHex(hex: DATA, id = ""): RootHex {
-  if (!rootHexRegex.test(hex)) throw Error(`Invalid hex root ${id} '${hex}'`);
-  return hex;
-}

package/src/eth1/stream.ts

@@ -1,75 +0,0 @@
-import {phase0} from "@lodestar/types";
-import {sleep} from "@lodestar/utils";
-import {BatchDepositEvents, Eth1Block, IEth1Provider, IEth1StreamParams} from "./interface.js";
-import {parseEth1Block} from "./provider/eth1Provider.js";
-import {groupDepositEventsByBlock} from "./utils/groupDepositEventsByBlock.js";
-import {optimizeNextBlockDiffForGenesis} from "./utils/optimizeNextBlockDiffForGenesis.js";
-
-/**
- * Phase 1 of genesis building.
- * Not enough validators, only stream deposits
- * @param signal Abort stream returning after a while loop cycle. Aborts internal sleep
- */
-export async function* getDepositsStream(
-  fromBlock: number,
-  provider: IEth1Provider,
-  params: IEth1StreamParams,
-  signal?: AbortSignal
-): AsyncGenerator<BatchDepositEvents> {
-  fromBlock = Math.max(fromBlock, provider.deployBlock);
-
-  while (true) {
-    const remoteFollowBlock = await getRemoteFollowBlock(provider, params);
-    const toBlock = Math.min(remoteFollowBlock, fromBlock + params.maxBlocksPerPoll);
-    const logs = await provider.getDepositEvents(fromBlock, toBlock);
-    for (const batchedDeposits of groupDepositEventsByBlock(logs)) {
-      yield batchedDeposits;
-    }
-
-    fromBlock = toBlock;
-
-    // If reached head, sleep for an eth1 block. Throws if signal is aborted
-    await sleep(toBlock >= remoteFollowBlock ? params.SECONDS_PER_ETH1_BLOCK * 1000 : 10, signal);
-  }
-}
-
-/**
- * Phase 2 of genesis building.
- * There are enough validators, stream deposits and blocks
- * @param signal Abort stream returning after a while loop cycle. Aborts internal sleep
- */
-export async function* getDepositsAndBlockStreamForGenesis(
-  fromBlock: number,
-  provider: IEth1Provider,
-  params: IEth1StreamParams,
-  signal?: AbortSignal
-): AsyncGenerator<[phase0.DepositEvent[], Eth1Block]> {
-  fromBlock = Math.max(fromBlock, provider.deployBlock);
-  fromBlock = Math.min(fromBlock, await getRemoteFollowBlock(provider, params));
-  let toBlock = fromBlock; // First, fetch only the first block
-
-  while (true) {
-    const [logs, blockRaw] = await Promise.all([
-      provider.getDepositEvents(fromBlock, toBlock),
-      provider.getBlockByNumber(toBlock),
-    ]);
-
-    if (!blockRaw) throw Error(`No block found for number ${toBlock}`);
-    const block = parseEth1Block(blockRaw);
-
-    yield [logs, block];
-
-    const remoteFollowBlock = await getRemoteFollowBlock(provider, params);
-    const nextBlockDiff = optimizeNextBlockDiffForGenesis(block, params);
-    fromBlock = toBlock;
-    toBlock = Math.min(remoteFollowBlock, fromBlock + Math.min(nextBlockDiff, params.maxBlocksPerPoll));
-
-    // If reached head, sleep for an eth1 block. Throws if signal is aborted
-    await sleep(toBlock >= remoteFollowBlock ? params.SECONDS_PER_ETH1_BLOCK * 1000 : 10, signal);
-  }
-}
-
-async function getRemoteFollowBlock(provider: IEth1Provider, params: IEth1StreamParams): Promise<number> {
-  const remoteHighestBlock = await provider.getBlockNumber();
-  return Math.max(remoteHighestBlock - params.ETH1_FOLLOW_DISTANCE, 0);
-}

package/src/eth1/utils/depositContract.ts

@@ -1,37 +0,0 @@
-import {Interface} from "@ethersproject/abi";
-import {phase0, ssz} from "@lodestar/types";
-import {fromHex} from "@lodestar/utils";
-
-const depositEventFragment =
-  "event DepositEvent(bytes pubkey, bytes withdrawal_credentials, bytes amount, bytes signature, bytes index)";
-
-const depositContractInterface = new Interface([depositEventFragment]);
-
-/**
- * Precomputed topics of DepositEvent logs
- */
-export const depositEventTopics = [depositContractInterface.getEventTopic("DepositEvent")];
-
-/**
- * Parse DepositEvent log
- */
-export function parseDepositLog(log: {blockNumber: number; data: string; topics: string[]}): phase0.DepositEvent {
-  const event = depositContractInterface.parseLog(log);
-  const values = event.args;
-  if (values === undefined) throw Error(`DepositEvent at ${log.blockNumber} has no values`);
-  return {
-    blockNumber: log.blockNumber,
-    index: parseHexNumLittleEndian(values.index),
-    depositData: {
-      pubkey: fromHex(values.pubkey),
-      withdrawalCredentials: fromHex(values.withdrawal_credentials),
-      amount: parseHexNumLittleEndian(values.amount),
-      signature: fromHex(values.signature),
-    },
-  };
-}
-
-function parseHexNumLittleEndian(hex: string): number {
-  // Can't use parseInt() because amount is a hex string in little endian
-  return ssz.UintNum64.deserialize(fromHex(hex));
-}

package/src/eth1/utils/deposits.ts

@@ -1,70 +0,0 @@
-import {Tree, toGindex} from "@chainsafe/persistent-merkle-tree";
-import {FilterOptions} from "@lodestar/db";
-import {CachedBeaconStateAllForks, getEth1DepositCount} from "@lodestar/state-transition";
-import {phase0, ssz} from "@lodestar/types";
-import {toRootHex} from "@lodestar/utils";
-import {DepositTree} from "../../db/repositories/depositDataRoot.js";
-import {Eth1Error, Eth1ErrorCode} from "../errors.js";
-
-export type DepositGetter<T> = (indexRange: FilterOptions<number>, eth1Data: phase0.Eth1Data) => Promise<T[]>;
-
-export async function getDeposits<T>(
-  // eth1_deposit_index represents the next deposit index to be added
-  state: CachedBeaconStateAllForks,
-  eth1Data: phase0.Eth1Data,
-  depositsGetter: DepositGetter<T>
-): Promise<T[]> {
-  const depositIndex = state.eth1DepositIndex;
-  const depositCount = eth1Data.depositCount;
-
-  if (depositIndex > depositCount) {
-    throw new Eth1Error({code: Eth1ErrorCode.DEPOSIT_INDEX_TOO_HIGH, depositIndex, depositCount});
-  }
-
-  const depositsLen = getEth1DepositCount(state, eth1Data);
-
-  if (depositsLen === 0) {
-    return []; // If depositsLen === 0, we can return early since no deposit with be returned from depositsGetter
-  }
-
-  const indexRange = {gte: depositIndex, lt: depositIndex + depositsLen};
-  const deposits = await depositsGetter(indexRange, eth1Data);
-
-  if (deposits.length < depositsLen) {
-    throw new Eth1Error({code: Eth1ErrorCode.NOT_ENOUGH_DEPOSITS, len: deposits.length, expectedLen: depositsLen});
-  }
-
-  if (deposits.length > depositsLen) {
-    throw new Eth1Error({code: Eth1ErrorCode.TOO_MANY_DEPOSITS, len: deposits.length, expectedLen: depositsLen});
-  }
-
-  return deposits;
-}
-
-export function getDepositsWithProofs(
-  depositEvents: phase0.DepositEvent[],
-  depositRootTree: DepositTree,
-  eth1Data: phase0.Eth1Data
-): phase0.Deposit[] {
-  // Get tree at this particular depositCount to compute correct proofs
-  const viewAtDepositCount = depositRootTree.sliceTo(eth1Data.depositCount - 1);
-
-  const depositRoot = viewAtDepositCount.hashTreeRoot();
-
-  if (!ssz.Root.equals(depositRoot, eth1Data.depositRoot)) {
-    throw new Eth1Error({
-      code: Eth1ErrorCode.WRONG_DEPOSIT_ROOT,
-      root: toRootHex(depositRoot),
-      expectedRoot: toRootHex(eth1Data.depositRoot),
-    });
-  }
-
-  // Already commited for .hashTreeRoot()
-  const treeAtDepositCount = new Tree(viewAtDepositCount.node);
-  const depositTreeDepth = viewAtDepositCount.type.depth;
-
-  return depositEvents.map((log) => ({
-    proof: treeAtDepositCount.getSingleProof(toGindex(depositTreeDepth, BigInt(log.index))),
-    data: log.depositData,
-  }));
-}

package/src/eth1/utils/eth1Data.ts

@@ -1,100 +0,0 @@
-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

@@ -1,12 +0,0 @@
-/**
- * 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

@@ -1,142 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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/builder/cache.ts

@@ -1,39 +0,0 @@
-import {BLSPubkey, Epoch, bellatrix} from "@lodestar/types";
-import {toPubkeyHex} from "@lodestar/utils";
-
-const REGISTRATION_PRESERVE_EPOCHS = 2;
-
-export type ValidatorRegistration = {
-  epoch: Epoch;
-  /** Preferred gas limit of validator */
-  gasLimit: number;
-};
-
-export class ValidatorRegistrationCache {
-  /**
-   * Map to track registrations by validator pubkey which is used here instead of
-   * validator index as `bellatrix.ValidatorRegistrationV1` does not contain the index
-   * and builder flow in general prefers to use pubkey over index.
-   */
-  private readonly registrationByValidatorPubkey: Map<string, ValidatorRegistration>;
-  constructor() {
-    this.registrationByValidatorPubkey = new Map();
-  }
-
-  add(epoch: Epoch, {pubkey, gasLimit}: bellatrix.ValidatorRegistrationV1): void {
-    this.registrationByValidatorPubkey.set(toPubkeyHex(pubkey), {epoch, gasLimit});
-  }
-
-  prune(epoch: Epoch): void {
-    for (const [pubkeyHex, registration] of this.registrationByValidatorPubkey.entries()) {
-      // We only retain an registrations for REGISTRATION_PRESERVE_EPOCHS epochs
-      if (registration.epoch + REGISTRATION_PRESERVE_EPOCHS < epoch) {
-        this.registrationByValidatorPubkey.delete(pubkeyHex);
-      }
-    }
-  }
-
-  get(pubkey: BLSPubkey): ValidatorRegistration | undefined {
-    return this.registrationByValidatorPubkey.get(toPubkeyHex(pubkey));
-  }
-}