@lodestar/beacon-node 1.38.0 → 1.39.0-dev.39dac0f03d

package/src/eth1/provider/eth1Provider.ts

@@ -1,229 +0,0 @@
-import {ChainConfig} from "@lodestar/config";
-import {Logger} from "@lodestar/logger";
-import {phase0} from "@lodestar/types";
-import {
-  FetchError,
-  createElapsedTimeTracker,
-  fromHex,
-  isErrorAborted,
-  isFetchError,
-  toHex,
-  toPrintableUrl,
-} from "@lodestar/utils";
-import {HTTP_CONNECTION_ERROR_CODES, HTTP_FATAL_ERROR_CODES} from "../../execution/engine/utils.js";
-import {isValidAddress} from "../../util/address.js";
-import {linspace} from "../../util/numpy.js";
-import {Eth1Block, Eth1ProviderState, EthJsonRpcBlockRaw, IEth1Provider} from "../interface.js";
-import {DEFAULT_PROVIDER_URLS, Eth1Options} from "../options.js";
-import {depositEventTopics, parseDepositLog} from "../utils/depositContract.js";
-import {
-  ErrorJsonRpcResponse,
-  HttpRpcError,
-  JsonRpcHttpClient,
-  JsonRpcHttpClientEvent,
-  JsonRpcHttpClientMetrics,
-  ReqOpts,
-} from "./jsonRpcHttpClient.js";
-import {dataToBytes, isJsonRpcTruncatedError, numToQuantity, quantityToNum} from "./utils.js";
-
-/**
- * Binds return types to Ethereum JSON RPC methods
- */
-type EthJsonRpcReturnTypes = {
-  eth_getBlockByNumber: EthJsonRpcBlockRaw | null;
-  eth_getBlockByHash: EthJsonRpcBlockRaw | null;
-  eth_blockNumber: string;
-  eth_getCode: string;
-  eth_getLogs: {
-    removed: boolean;
-    logIndex: string;
-    transactionIndex: string;
-    transactionHash: string;
-    blockHash: string;
-    blockNumber: string;
-    address: string;
-    data: string;
-    topics: string[];
-  }[];
-};
-
-// Define static options once to prevent extra allocations
-const getBlocksByNumberOpts: ReqOpts = {routeId: "getBlockByNumber_batched"};
-const getBlockByNumberOpts: ReqOpts = {routeId: "getBlockByNumber"};
-const getBlockByHashOpts: ReqOpts = {routeId: "getBlockByHash"};
-const getBlockNumberOpts: ReqOpts = {routeId: "getBlockNumber"};
-const getLogsOpts: ReqOpts = {routeId: "getLogs"};
-
-const isOneMinutePassed = createElapsedTimeTracker({minElapsedTime: 60_000});
-
-export class Eth1Provider implements IEth1Provider {
-  readonly deployBlock: number;
-  private readonly depositContractAddress: string;
-  private readonly rpc: JsonRpcHttpClient;
-  // The default state is ONLINE, it will be updated to offline if we receive a http error
-  private state: Eth1ProviderState = Eth1ProviderState.ONLINE;
-  private logger?: Logger;
-
-  constructor(
-    config: Pick<ChainConfig, "DEPOSIT_CONTRACT_ADDRESS">,
-    opts: Pick<Eth1Options, "depositContractDeployBlock" | "providerUrls" | "jwtSecretHex" | "jwtId" | "jwtVersion"> & {
-      logger?: Logger;
-    },
-    signal?: AbortSignal,
-    metrics?: JsonRpcHttpClientMetrics | null
-  ) {
-    this.logger = opts.logger;
-    this.deployBlock = opts.depositContractDeployBlock ?? 0;
-    this.depositContractAddress = toHex(config.DEPOSIT_CONTRACT_ADDRESS);
-
-    const providerUrls = opts.providerUrls ?? DEFAULT_PROVIDER_URLS;
-    this.rpc = new JsonRpcHttpClient(providerUrls, {
-      signal,
-      // Don't fallback with is truncated error. Throw early and let the retry on this class handle it
-      shouldNotFallback: isJsonRpcTruncatedError,
-      jwtSecret: opts.jwtSecretHex ? fromHex(opts.jwtSecretHex) : undefined,
-      jwtId: opts.jwtId,
-      jwtVersion: opts.jwtVersion,
-      metrics: metrics,
-    });
-    this.logger?.info("Eth1 provider", {urls: providerUrls.map(toPrintableUrl).toString()});
-
-    this.rpc.emitter.on(JsonRpcHttpClientEvent.RESPONSE, () => {
-      const oldState = this.state;
-      this.state = Eth1ProviderState.ONLINE;
-
-      if (oldState !== Eth1ProviderState.ONLINE) {
-        this.logger?.info("Eth1 provider is back online", {oldState, newState: this.state});
-      }
-    });
-
-    this.rpc.emitter.on(JsonRpcHttpClientEvent.ERROR, ({error}) => {
-      if (isErrorAborted(error)) {
-        this.state = Eth1ProviderState.ONLINE;
-      } else if ((error as unknown) instanceof HttpRpcError || (error as unknown) instanceof ErrorJsonRpcResponse) {
-        this.state = Eth1ProviderState.ERROR;
-      } else if (error && isFetchError(error) && HTTP_FATAL_ERROR_CODES.includes((error as FetchError).code)) {
-        this.state = Eth1ProviderState.OFFLINE;
-      } else if (error && isFetchError(error) && HTTP_CONNECTION_ERROR_CODES.includes((error as FetchError).code)) {
-        this.state = Eth1ProviderState.AUTH_FAILED;
-      }
-
-      if (this.state !== Eth1ProviderState.ONLINE && isOneMinutePassed()) {
-        this.logger?.error(
-          "Eth1 provider error",
-          {
-            state: this.state,
-            lastErrorAt: new Date(Date.now() - isOneMinutePassed.msSinceLastCall).toLocaleTimeString(),
-          },
-          error
-        );
-      }
-    });
-  }
-
-  getState(): Eth1ProviderState {
-    return this.state;
-  }
-
-  async validateContract(): Promise<void> {
-    if (!isValidAddress(this.depositContractAddress)) {
-      throw Error(`Invalid contract address: ${this.depositContractAddress}`);
-    }
-
-    const code = await this.getCode(this.depositContractAddress);
-    if (!code || code === "0x") {
-      throw new Error(`There is no deposit contract at given address: ${this.depositContractAddress}`);
-    }
-  }
-
-  async getDepositEvents(fromBlock: number, toBlock: number): Promise<phase0.DepositEvent[]> {
-    const logsRawArr = await this.getLogs({
-      fromBlock,
-      toBlock,
-      address: this.depositContractAddress,
-      topics: depositEventTopics,
-    });
-    return logsRawArr.flat(1).map((log) => parseDepositLog(log));
-  }
-
-  /**
-   * Fetches an arbitrary array of block numbers in batch
-   */
-  async getBlocksByNumber(fromBlock: number, toBlock: number): Promise<EthJsonRpcBlockRaw[]> {
-    const method = "eth_getBlockByNumber";
-    const blocksArr = await this.rpc.fetchBatch<EthJsonRpcReturnTypes[typeof method]>(
-      linspace(fromBlock, toBlock).map((blockNumber) => ({method, params: [numToQuantity(blockNumber), false]})),
-      getBlocksByNumberOpts
-    );
-    const blocks: EthJsonRpcBlockRaw[] = [];
-    for (const block of blocksArr.flat(1)) {
-      if (block) blocks.push(block);
-    }
-    return blocks;
-  }
-
-  async getBlockByNumber(blockNumber: number | "latest"): Promise<EthJsonRpcBlockRaw | null> {
-    const method = "eth_getBlockByNumber";
-    const blockNumberHex = typeof blockNumber === "string" ? blockNumber : numToQuantity(blockNumber);
-    return this.rpc.fetch<EthJsonRpcReturnTypes[typeof method]>(
-      // false = include only transaction roots, not full objects
-      {method, params: [blockNumberHex, false]},
-      getBlockByNumberOpts
-    );
-  }
-
-  async getBlockByHash(blockHashHex: string): Promise<EthJsonRpcBlockRaw | null> {
-    const method = "eth_getBlockByHash";
-    return this.rpc.fetch<EthJsonRpcReturnTypes[typeof method]>(
-      // false = include only transaction roots, not full objects
-      {method, params: [blockHashHex, false]},
-      getBlockByHashOpts
-    );
-  }
-
-  async getBlockNumber(): Promise<number> {
-    const method = "eth_blockNumber";
-    const blockNumberRaw = await this.rpc.fetch<EthJsonRpcReturnTypes[typeof method]>(
-      {method, params: []},
-      getBlockNumberOpts
-    );
-    return parseInt(blockNumberRaw, 16);
-  }
-
-  async getCode(address: string): Promise<string> {
-    const method = "eth_getCode";
-    return this.rpc.fetch<EthJsonRpcReturnTypes[typeof method]>({method, params: [address, "latest"]});
-  }
-
-  async getLogs(options: {
-    fromBlock: number;
-    toBlock: number;
-    address: string;
-    topics: string[];
-  }): Promise<{blockNumber: number; data: string; topics: string[]}[]> {
-    const method = "eth_getLogs";
-    const hexOptions = {
-      ...options,
-      fromBlock: numToQuantity(options.fromBlock),
-      toBlock: numToQuantity(options.toBlock),
-    };
-    const logsRaw = await this.rpc.fetch<EthJsonRpcReturnTypes[typeof method]>(
-      {method, params: [hexOptions]},
-      getLogsOpts
-    );
-    return logsRaw.map((logRaw) => ({
-      blockNumber: parseInt(logRaw.blockNumber, 16),
-      data: logRaw.data,
-      topics: logRaw.topics,
-    }));
-  }
-}
-
-export function parseEth1Block(blockRaw: EthJsonRpcBlockRaw): Eth1Block {
-  if (typeof blockRaw !== "object") throw Error("block is not an object");
-  return {
-    blockHash: dataToBytes(blockRaw.hash, 32),
-    blockNumber: quantityToNum(blockRaw.number, "block.number"),
-    timestamp: quantityToNum(blockRaw.timestamp, "block.timestamp"),
-  };
-}

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}`);
-    }
-  }
-}