@lodestar/beacon-node 1.35.0-dev.f80d2d52da → 1.35.0-dev.fd1dac853d

package/src/eth1/provider/utils.ts

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

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

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

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

@@ -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/builder/cache.ts

@@ -0,0 +1,39 @@
+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));
+  }
+}