@lodestar/beacon-node 1.39.0-dev.882891d89c → 1.39.0-dev.b37f2bd1bd

package/src/eth1/eth1DepositsCache.ts

@@ -0,0 +1,141 @@
+import {byteArrayEquals} from "@chainsafe/ssz";
+import {ChainForkConfig} from "@lodestar/config";
+import {FilterOptions} from "@lodestar/db";
+import {phase0, ssz} from "@lodestar/types";
+import {IBeaconDb} from "../db/index.js";
+import {Eth1Error, Eth1ErrorCode} from "./errors.js";
+import {Eth1Block} from "./interface.js";
+import {getDepositsWithProofs} from "./utils/deposits.js";
+import {getEth1DataForBlocks} from "./utils/eth1Data.js";
+import {assertConsecutiveDeposits} from "./utils/eth1DepositEvent.js";
+
+export class Eth1DepositsCache {
+  unsafeAllowDepositDataOverwrite: boolean;
+  db: IBeaconDb;
+  config: ChainForkConfig;
+
+  constructor(opts: {unsafeAllowDepositDataOverwrite?: boolean}, config: ChainForkConfig, db: IBeaconDb) {
+    this.config = config;
+    this.db = db;
+    this.unsafeAllowDepositDataOverwrite = opts.unsafeAllowDepositDataOverwrite ?? false;
+  }
+
+  /**
+   * Returns a list of `Deposit` objects, within the given deposit index `range`.
+   *
+   * The `depositCount` is used to generate the proofs for the `Deposits`. For example, if we
+   * have 100 proofs, but the Ethereum Consensus chain only acknowledges 50 of them, we must produce our
+   * proofs with respect to a tree size of 50.
+   */
+  async get(indexRange: FilterOptions<number>, eth1Data: phase0.Eth1Data): Promise<phase0.Deposit[]> {
+    const depositEvents = await this.db.depositEvent.values(indexRange);
+    const depositRootTree = await this.db.depositDataRoot.getDepositRootTree();
+    return getDepositsWithProofs(depositEvents, depositRootTree, eth1Data);
+  }
+
+  /**
+   * Add log to cache
+   * This function enforces that `logs` are imported one-by-one with consecutive indexes
+   */
+  async add(depositEvents: phase0.DepositEvent[]): Promise<void> {
+    assertConsecutiveDeposits(depositEvents);
+
+    const lastLog = await this.db.depositEvent.lastValue();
+    const firstEvent = depositEvents[0];
+
+    // Check, validate and skip if we got any deposit events already present in DB
+    // This can happen if the remote eth1/EL resets its head in these four scenarios:
+    //   1. Remote eth1/EL resynced/restarted from head behind its previous head pre-merge
+    //   2. In a post merge scenario, Lodestar restarted from finalized state from DB which
+    //      generally is a few epochs behind the last synced head. This causes eth1 tracker to reset
+    //      and refetch the deposits as the lodestar syncs further along (Post merge there is 1-1
+    //      correspondence between EL and CL blocks)
+    //   3. The EL reorged beyond the eth1 follow distance.
+    //
+    // While 1. & 2. are benign and we handle them below by checking if the duplicate log fetched
+    // is same as one written in DB. Refer to this issue for some data dump of how this happens
+    // https://github.com/ChainSafe/lodestar/issues/3674
+    //
+    // If the duplicate log fetched is not same as written in DB then its probablu scenario 3.
+    // which would be a catastrophic event for the network (or we messed up real bad!!!).
+    //
+    // So we provide for a way to overwrite this log without deleting full db via
+    // --unsafeAllowDepositDataOverwrite cli flag which will just overwrite the previous tracker data
+    // if any. This option as indicated by its name is unsafe and to be only used if you know what
+    // you are doing.
+    if (lastLog !== null && firstEvent !== undefined) {
+      const newIndex = firstEvent.index;
+      const lastLogIndex = lastLog.index;
+
+      if (!this.unsafeAllowDepositDataOverwrite && firstEvent.index <= lastLog.index) {
+        // lastLogIndex - newIndex + 1 events are duplicate since this is a consecutive log
+        // as asserted by assertConsecutiveDeposits. Splice those events out from depositEvents.
+        const skipEvents = depositEvents.splice(0, lastLogIndex - newIndex + 1);
+        // After splicing skipEvents will contain duplicate events to be checked and validated
+        // and rest of the remaining events in depositEvents could be safely written to DB and
+        // move the tracker along.
+        for (const depositEvent of skipEvents) {
+          const prevDBSerializedEvent = await this.db.depositEvent.getBinary(depositEvent.index);
+          if (!prevDBSerializedEvent) {
+            throw new Eth1Error({code: Eth1ErrorCode.MISSING_DEPOSIT_LOG, newIndex, lastLogIndex});
+          }
+          const serializedEvent = ssz.phase0.DepositEvent.serialize(depositEvent);
+          if (!byteArrayEquals(prevDBSerializedEvent, serializedEvent)) {
+            throw new Eth1Error({code: Eth1ErrorCode.DUPLICATE_DISTINCT_LOG, newIndex, lastLogIndex});
+          }
+        }
+      } else if (newIndex > lastLogIndex + 1) {
+        // deposit events need to be consective, the way we fetch our tracker. If the deposit event
+        // is not consecutive it means either our tracker, or the corresponding eth1/EL
+        // node or the database has messed up. All these failures are critical and the tracker
+        // shouldn't proceed without the resolution of this error.
+        throw new Eth1Error({code: Eth1ErrorCode.NON_CONSECUTIVE_LOGS, newIndex, lastLogIndex});
+      }
+    }
+
+    const depositRoots = depositEvents.map((depositEvent) => ({
+      index: depositEvent.index,
+      root: ssz.phase0.DepositData.hashTreeRoot(depositEvent.depositData),
+    }));
+
+    // Store events after verifying that data is consecutive
+    // depositDataRoot will throw if adding non consecutive roots
+    await this.db.depositDataRoot.batchPutValues(depositRoots);
+    await this.db.depositEvent.batchPutValues(depositEvents);
+  }
+
+  /**
+   * Appends partial eth1 data (depositRoot, depositCount) in a block range (inclusive)
+   * Returned array is sequential and ascending in blockNumber
+   * @param fromBlock
+   * @param toBlock
+   */
+  async getEth1DataForBlocks(
+    blocks: Eth1Block[],
+    lastProcessedDepositBlockNumber: number | null
+  ): Promise<(phase0.Eth1Data & Eth1Block)[]> {
+    const highestBlock = blocks.at(-1)?.blockNumber;
+    return getEth1DataForBlocks(
+      blocks,
+      this.db.depositEvent.valuesStream({lte: highestBlock, reverse: true}),
+      await this.db.depositDataRoot.getDepositRootTree(),
+      lastProcessedDepositBlockNumber
+    );
+  }
+
+  /**
+   * Returns the highest blockNumber stored in DB if any
+   */
+  async getHighestDepositEventBlockNumber(): Promise<number | null> {
+    const latestEvent = await this.db.depositEvent.lastValue();
+    return latestEvent?.blockNumber || null;
+  }
+
+  /**
+   * Returns the lowest blockNumber stored in DB if any
+   */
+  async getLowestDepositEventBlockNumber(): Promise<number | null> {
+    const firstEvent = await this.db.depositEvent.firstValue();
+    return firstEvent?.blockNumber || null;
+  }
+}

package/src/eth1/index.ts

@@ -0,0 +1,94 @@
+import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
+import {Eth1DepositDataTracker, Eth1DepositDataTrackerModules} from "./eth1DepositDataTracker.js";
+import {Eth1DataAndDeposits, IEth1ForBlockProduction, IEth1Provider} from "./interface.js";
+import {Eth1Options} from "./options.js";
+import {Eth1Provider} from "./provider/eth1Provider.js";
+export {Eth1Provider};
+export type {IEth1ForBlockProduction, IEth1Provider};
+
+// This module encapsulates all consumer functionality to the execution node (formerly eth1). The execution client
+// has to:
+//
+// - For genesis, the beacon node must follow the eth1 chain: get all deposit events + blocks within that range.
+//   Once the genesis conditions are met, start the POS chain with the resulting state. The logic is similar to the
+//   two points below, but the implementation is specialized for each scenario.
+//
+// - Follow the eth1 block chain to validate eth1Data votes. It needs all consecutive blocks within a specific range
+//   and at a distance from the head.
+//   ETH1_FOLLOW_DISTANCE 	        uint64(2**11) (= 2,048) 	Eth1 blocks 	~8 hours
+//   EPOCHS_PER_ETH1_VOTING_PERIOD 	uint64(2**6) (= 64)     	epochs 	      ~6.8 hours
+//
+// - Fetch ALL deposit events from the deposit contract to build the deposit tree and validate future merkle proofs.
+//   Then it must follow deposit events at a distance roughly similar to the `ETH1_FOLLOW_DISTANCE` parameter above.
+
+export function initializeEth1ForBlockProduction(
+  opts: Eth1Options,
+  modules: Pick<Eth1DepositDataTrackerModules, "db" | "config" | "metrics" | "logger" | "signal">
+): IEth1ForBlockProduction {
+  if (opts.enabled) {
+    return new Eth1ForBlockProduction(opts, {
+      config: modules.config,
+      db: modules.db,
+      metrics: modules.metrics,
+      logger: modules.logger,
+      signal: modules.signal,
+    });
+  }
+  return new Eth1ForBlockProductionDisabled();
+}
+
+export class Eth1ForBlockProduction implements IEth1ForBlockProduction {
+  private readonly eth1DepositDataTracker: Eth1DepositDataTracker | null;
+
+  constructor(opts: Eth1Options, modules: Eth1DepositDataTrackerModules & {eth1Provider?: IEth1Provider}) {
+    const eth1Provider =
+      modules.eth1Provider ||
+      new Eth1Provider(
+        modules.config,
+        {...opts, logger: modules.logger},
+        modules.signal,
+        modules.metrics?.eth1HttpClient
+      );
+
+    this.eth1DepositDataTracker = opts.disableEth1DepositDataTracker
+      ? null
+      : new Eth1DepositDataTracker(opts, modules, eth1Provider);
+  }
+
+  async getEth1DataAndDeposits(state: CachedBeaconStateAllForks): Promise<Eth1DataAndDeposits> {
+    if (this.eth1DepositDataTracker === null) {
+      return {eth1Data: state.eth1Data, deposits: []};
+    }
+    return this.eth1DepositDataTracker.getEth1DataAndDeposits(state);
+  }
+
+  isPollingEth1Data(): boolean {
+    return this.eth1DepositDataTracker?.isPollingEth1Data() ?? false;
+  }
+
+  stopPollingEth1Data(): void {
+    this.eth1DepositDataTracker?.stopPollingEth1Data();
+  }
+}
+
+/**
+ * Disabled version of Eth1ForBlockProduction
+ * May produce invalid blocks by not adding new deposits and voting for the same eth1Data
+ */
+export class Eth1ForBlockProductionDisabled implements IEth1ForBlockProduction {
+  /**
+   * Returns same eth1Data as in state and no deposits
+   * May produce invalid blocks if deposits have to be added
+   */
+  async getEth1DataAndDeposits(state: CachedBeaconStateAllForks): Promise<Eth1DataAndDeposits> {
+    return {eth1Data: state.eth1Data, deposits: []};
+  }
+
+  isPollingEth1Data(): boolean {
+    return false;
+  }
+
+  stopPollingEth1Data(): void {
+    // Ignore
+  }
+}

package/src/eth1/interface.ts

@@ -0,0 +1,87 @@
+import {BeaconConfig} from "@lodestar/config";
+import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
+import {phase0} from "@lodestar/types";
+
+export type EthJsonRpcBlockRaw = {
+  /** the block number. null when its pending block. `"0x1b4"` */
+  number: string;
+  /** 32 Bytes - hash of the block. null when its pending block. `"0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae"` */
+  hash: string;
+  /** 32 Bytes - hash of the parent block. `"0xe99e022112df268087ea7eafaf4790497fd21dbeeb6bd7a1721df161a6657a54"` */
+  parentHash: string;
+  /**
+   * integer of the total difficulty of the chain until this block. `"0x78ed983323d"`.
+   * Current mainnet value is 0x684de10dc5c03f006b6, 75 bits so requires a bigint.
+   */
+  totalDifficulty: string;
+  /** the unix timestamp for when the block was collated. `"0x55ba467c"` */
+  timestamp: string;
+};
+
+export interface IEth1Provider {
+  deployBlock: number;
+  getBlockNumber(): Promise<number>;
+  /** Returns HTTP code 200 + value=null if block is not found */
+  getBlockByNumber(blockNumber: number | "latest"): Promise<EthJsonRpcBlockRaw | null>;
+  /** Returns HTTP code 200 + value=null if block is not found */
+  getBlockByHash(blockHashHex: string): Promise<EthJsonRpcBlockRaw | null>;
+  /** null returns are ignored, may return a different number of blocks than expected */
+  getBlocksByNumber(fromBlock: number, toBlock: number): Promise<EthJsonRpcBlockRaw[]>;
+  getDepositEvents(fromBlock: number, toBlock: number): Promise<phase0.DepositEvent[]>;
+  validateContract(): Promise<void>;
+  getState(): Eth1ProviderState;
+}
+
+export enum Eth1ProviderState {
+  ONLINE = "ONLINE",
+  OFFLINE = "OFFLINE",
+  ERROR = "ERROR",
+  AUTH_FAILED = "AUTH_FAILED",
+}
+
+export type Eth1DataAndDeposits = {
+  eth1Data: phase0.Eth1Data;
+  deposits: phase0.Deposit[];
+};
+
+export interface IEth1ForBlockProduction {
+  getEth1DataAndDeposits(state: CachedBeaconStateAllForks): Promise<Eth1DataAndDeposits>;
+
+  isPollingEth1Data(): boolean;
+
+  /**
+   * Should stop polling eth1Data after a Electra block is finalized AND deposit_requests_start_index is reached
+   */
+  stopPollingEth1Data(): void;
+}
+
+/** Different Eth1Block from phase0.Eth1Block with blockHash */
+export type Eth1Block = {
+  blockHash: Uint8Array;
+  blockNumber: number;
+  timestamp: number;
+};
+
+export type BatchDepositEvents = {
+  depositEvents: phase0.DepositEvent[];
+  blockNumber: number;
+};
+
+export type Eth1Streamer = {
+  getDepositsStream(fromBlock: number): AsyncGenerator<BatchDepositEvents>;
+  getDepositsAndBlockStreamForGenesis(fromBlock: number): AsyncGenerator<[phase0.DepositEvent[], phase0.Eth1Block]>;
+};
+
+export type IEth1StreamParams = Pick<
+  BeaconConfig,
+  "ETH1_FOLLOW_DISTANCE" | "MIN_GENESIS_TIME" | "GENESIS_DELAY" | "SECONDS_PER_ETH1_BLOCK"
+> & {
+  maxBlocksPerPoll: number;
+};
+
+export type IJson = string | number | boolean | undefined | IJson[] | {[key: string]: IJson};
+
+export interface RpcPayload<P = IJson[]> {
+  method: string;
+  params: P;
+}

package/src/eth1/options.ts

@@ -0,0 +1,28 @@
+export type Eth1Options = {
+  enabled?: boolean;
+  disableEth1DepositDataTracker?: boolean;
+  providerUrls?: string[];
+  /**
+   * jwtSecretHex is the jwt secret if the eth1 modules should ping the jwt auth
+   * protected engine endpoints.
+   */
+  jwtSecretHex?: string;
+  jwtId?: string;
+  jwtVersion?: string;
+  depositContractDeployBlock?: number;
+  unsafeAllowDepositDataOverwrite?: boolean;
+  /**
+   * Vote for a specific eth1_data regardless of validity and existing votes.
+   * hex encoded ssz serialized Eth1Data type.
+   */
+  forcedEth1DataVote?: string;
+};
+
+export const DEFAULT_PROVIDER_URLS = ["http://localhost:8545"];
+
+export const defaultEth1Options: Eth1Options = {
+  enabled: true,
+  providerUrls: DEFAULT_PROVIDER_URLS,
+  depositContractDeployBlock: 0,
+  unsafeAllowDepositDataOverwrite: false,
+};

package/src/eth1/provider/eth1Provider.ts

@@ -0,0 +1,229 @@
+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/{execution/engine → eth1/provider}/jsonRpcHttpClient.ts

@@ -1,8 +1,8 @@
 import {EventEmitter} from "node:events";
 import {StrictEventEmitter} from "strict-event-emitter-types";
 import {ErrorAborted, Gauge, Histogram, TimeoutError, fetch, isValidHttpUrl, retry} from "@lodestar/utils";
+import {IJson, RpcPayload} from "../interface.js";
 import {JwtClaim, encodeJwtToken} from "./jwt.js";
-import {IJson, RpcPayload} from "./utils.js";
 
 export enum JsonRpcHttpClientEvent {
   /**