@lodestar/prover 1.35.0-dev.c88a6ed255 → 1.35.0-dev.c9deb9b59f

package/src/utils/execution.ts

@@ -0,0 +1,76 @@
+import {Common, CustomChain, Hardfork} from "@ethereumjs/common";
+import {ELApiParams, ELApiReturn, ELTransaction} from "../types.js";
+import {isValidResponse} from "./json_rpc.js";
+import {ELRpcProvider} from "./rpc_provider.js";
+import {isBlockNumber, isPresent} from "./validation.js";
+
+export type Optional<T, K extends keyof T> = Omit<T, K> & {[P in keyof T]?: T[P] | undefined};
+
+export async function getELCode(
+  rpc: ELRpcProvider,
+  args: ELApiParams["eth_getCode"]
+): Promise<ELApiReturn["eth_getCode"]> {
+  const codeResult = await rpc.request("eth_getCode", args, {raiseError: false});
+
+  if (!isValidResponse(codeResult)) {
+    throw new Error(`Can not find code for address=${args[0]}`);
+  }
+
+  return codeResult.result;
+}
+
+export async function getELProof(
+  rpc: ELRpcProvider,
+  args: ELApiParams["eth_getProof"]
+): Promise<ELApiReturn["eth_getProof"]> {
+  const proof = await rpc.request("eth_getProof", args, {raiseError: false});
+  if (!isValidResponse(proof)) {
+    throw new Error(`Can not find proof for address=${args[0]}`);
+  }
+  return proof.result;
+}
+
+export async function getELBlock(
+  rpc: ELRpcProvider,
+  args: ELApiParams["eth_getBlockByNumber"]
+): Promise<ELApiReturn["eth_getBlockByNumber"]> {
+  const block = await rpc.request(isBlockNumber(args[0]) ? "eth_getBlockByNumber" : "eth_getBlockByHash", args, {
+    raiseError: false,
+  });
+
+  if (!isValidResponse(block)) {
+    throw new Error(`Can not find block. id=${args[0]}`);
+  }
+
+  return block.result;
+}
+
+export function getChainCommon(network: string): Common {
+  switch (network) {
+    case "mainnet":
+    case "sepolia":
+    case "holesky":
+    case "ephemery":
+      // TODO: Not sure how to detect the fork during runtime
+      return new Common({chain: network, hardfork: Hardfork.Shanghai});
+    case "minimal":
+      // TODO: Not sure how to detect the fork during runtime
+      return new Common({chain: "mainnet", hardfork: Hardfork.Shanghai});
+    case "gnosis":
+      return new Common({chain: CustomChain.xDaiChain});
+    default:
+      throw new Error(`Non supported network "${network}"`);
+  }
+}
+
+export function getTxType(tx: ELTransaction): number {
+  if (isPresent(tx.maxFeePerGas) || isPresent(tx.maxPriorityFeePerGas)) {
+    return 2;
+  }
+
+  if (isPresent(tx.accessList)) {
+    return 1;
+  }
+
+  return 0;
+}

package/src/utils/file.ts

@@ -0,0 +1,51 @@
+import fs from "node:fs";
+import path from "node:path";
+import yaml from "js-yaml";
+
+const {load, FAILSAFE_SCHEMA, Type} = yaml;
+
+enum FileFormat {
+  json = "json",
+  yaml = "yaml",
+  yml = "yml",
+  toml = "toml",
+}
+
+const yamlSchema = FAILSAFE_SCHEMA.extend({
+  implicit: [
+    new Type("tag:yaml.org,2002:str", {
+      kind: "scalar",
+      construct: function construct(data) {
+        return data !== null ? data : "";
+      },
+    }),
+  ],
+});
+
+/**
+ * Parse file contents as Json.
+ */
+function parse<T>(contents: string, fileFormat: FileFormat): T {
+  switch (fileFormat) {
+    case FileFormat.json:
+      return JSON.parse(contents) as T;
+    case FileFormat.yaml:
+    case FileFormat.yml:
+      return load(contents, {schema: yamlSchema}) as T;
+    default:
+      return contents as unknown as T;
+  }
+}
+
+/**
+ * Read a JSON serializable object from a file
+ *
+ * Parse either from json, yaml, or toml
+ * Optional acceptedFormats object can be passed which can be an array of accepted formats, in future can be extended to include parseFn for the accepted formats
+ */
+export function readFile<T>(filepath: string, acceptedFormats?: string[]): T {
+  const fileFormat = path.extname(filepath).substr(1);
+  if (acceptedFormats && !acceptedFormats.includes(fileFormat)) throw new Error(`UnsupportedFileFormat: ${filepath}`);
+  const contents = fs.readFileSync(filepath, "utf-8");
+  return parse(contents, fileFormat as FileFormat);
+}

package/src/utils/gitData/gitDataPath.ts

@@ -0,0 +1,48 @@
+import fs from "node:fs";
+import path from "node:path";
+import {fileURLToPath} from "node:url";
+
+// Global variable __dirname no longer available in ES6 modules.
+// Solutions: https://stackoverflow.com/questions/46745014/alternative-for-dirname-in-node-js-when-using-es6-modules
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Persist git data and distribute through NPM so CLI consumers can know exactly
+// at what commit was this src build. This is used in the metrics and to log initially.
+//
+// - For NPM release (stable): Only the version is persisted. Once must then track the version's tag
+//   in Github to resolve that version to a specific commit. While this is okay, git-data.json gives
+//   a gurantee of the exact commit at build time.
+//
+// - For NPM release (dev): canary commits include the commit, so this feature is not really
+//   necessary. However, it's more cumbersome to have conditional logic on stable / dev.
+//
+// - For build from source: .git folder is available in the context of the built code, so it can extract
+//   branch and commit directly without the need for .git-data.json.
+//
+// - For build from source dockerized: This feature is required to know the branch and commit, since
+//   git data is not persisted past the build. However, .dockerignore prevents .git folder from being
+//   copied into the container's context, so .git-data.json can't be generated.
+
+/**
+ * WARNING!! If you change this path make sure to update:
+ * - 'packages/cli/package.json' -> .files -> `".git-data.json"`
+ */
+export const gitDataPath = path.resolve(__dirname, "../../../.git-data.json");
+
+/** Git data type used to construct version information string and persistence. */
+export type GitData = {
+  /** "developer-feature" */
+  branch: string;
+  /** "80c248bb392f512cc115d95059e22239a17bbd7d" */
+  commit: string;
+};
+
+/** Writes a persistent git data file. */
+export function writeGitDataFile(gitData: GitData): void {
+  fs.writeFileSync(gitDataPath, JSON.stringify(gitData, null, 2));
+}
+
+/** Reads the persistent git data file. */
+export function readGitDataFile(): GitData {
+  return JSON.parse(fs.readFileSync(gitDataPath, "utf8")) as GitData;
+}

package/src/utils/gitData/index.ts

@@ -0,0 +1,70 @@
+import {execSync} from "node:child_process";
+// This file is created in the build step and is distributed through NPM
+// MUST be in sync with `-/gitDataPath.ts` and `package.json` files.
+import {GitData, readGitDataFile} from "./gitDataPath.js";
+
+/** Reads git data from a persisted file or local git data at build time. */
+export function readAndGetGitData(): GitData {
+  try {
+    // Gets git data containing current branch and commit info from persistent file.
+    let persistedGitData: Partial<GitData>;
+    try {
+      persistedGitData = readGitDataFile();
+    } catch (_e) {
+      persistedGitData = {};
+    }
+
+    const currentGitData = getGitData();
+
+    return {
+      // If the CLI is run from source, prioritze current git data
+      // over `.git-data.json` file, which might be stale here.
+      branch:
+        currentGitData.branch && currentGitData.branch.length > 0
+          ? currentGitData.branch
+          : (persistedGitData.branch ?? ""),
+      commit:
+        currentGitData.commit && currentGitData.commit.length > 0
+          ? currentGitData.commit
+          : (persistedGitData.commit ?? ""),
+    };
+  } catch (_e) {
+    return {
+      branch: "",
+      commit: "",
+    };
+  }
+}
+
+/** Gets git data containing current branch and commit info from CLI. */
+export function getGitData(): GitData {
+  return {
+    branch: process.env.GIT_BRANCH ?? getBranch(),
+    commit: process.env.GIT_COMMIT ?? getCommit(),
+  };
+}
+
+/** Tries to get branch from git CLI. */
+function getBranch(): string {
+  try {
+    return shellSilent("git rev-parse --abbrev-ref HEAD");
+  } catch (_e) {
+    return "";
+  }
+}
+
+/** Tries to get commit from git from git CLI. */
+function getCommit(): string {
+  try {
+    return shellSilent("git rev-parse --verify HEAD");
+  } catch (_e) {
+    return "";
+  }
+}
+
+/** Silent shell that won't pollute stdout, or stderr */
+function shellSilent(cmd: string): string {
+  return execSync(cmd, {stdio: ["ignore", "pipe", "ignore"]})
+    .toString()
+    .trim();
+}

package/src/utils/gitData/writeGitData.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+// For RATIONALE of this file, check packages/cli/src/util/gitData/gitDataPath.ts
+// Persist exact commit in NPM distributions for easier tracking of the build
+
+import {writeGitDataFile} from "./gitDataPath.js";
+import {getGitData} from "./index.js";
+
+// Script to write the git data file (json) used by the build procedures to persist git data.
+writeGitDataFile(getGitData());

package/src/utils/json_rpc.ts

@@ -0,0 +1,170 @@
+import {Logger} from "@lodestar/logger";
+import {VERIFICATION_FAILED_RESPONSE_CODE} from "../constants.js";
+import {
+  JsonRpcBatchRequest,
+  JsonRpcBatchResponse,
+  JsonRpcErrorPayload,
+  JsonRpcNotificationPayload,
+  JsonRpcRequest,
+  JsonRpcRequestOrBatch,
+  JsonRpcRequestPayload,
+  JsonRpcResponse,
+  JsonRpcResponseOrBatch,
+  JsonRpcResponseWithErrorPayload,
+  JsonRpcResponseWithResultPayload,
+} from "../types.js";
+import {isNullish} from "./validation.js";
+
+export function getResponseForRequest<P, R, E = unknown>(
+  payload: JsonRpcRequest<P>,
+  res?: R,
+  error?: JsonRpcErrorPayload<E>
+): JsonRpcResponse<R, E> {
+  // If it's a notification
+  if (!isRequest(payload)) {
+    throw new Error("Cannot generate response for notification");
+  }
+
+  if (!isNullish(res) && isNullish(error)) {
+    return {
+      jsonrpc: payload.jsonrpc,
+      id: payload.id,
+      result: res,
+    };
+  }
+
+  if (!isNullish(error)) {
+    return {
+      jsonrpc: payload.jsonrpc,
+      id: payload.id,
+      error,
+    };
+  }
+
+  throw new Error("Either result or error must be defined.");
+}
+
+export function getVerificationFailedMessage(method: string): string {
+  return `verification for '${method}' request failed.`;
+}
+
+export function isVerificationFailedError<P>(payload: JsonRpcResponseWithErrorPayload<P>): boolean {
+  return !isValidResponsePayload(payload) && payload.error.code === VERIFICATION_FAILED_RESPONSE_CODE;
+}
+
+export function getErrorResponseForRequestWithFailedVerification<P, D = unknown>(
+  payload: JsonRpcRequest<P>,
+  message: string,
+  data?: D
+): JsonRpcResponseWithErrorPayload<D> {
+  return isNullish(data)
+    ? (getResponseForRequest(payload, undefined, {
+        code: VERIFICATION_FAILED_RESPONSE_CODE,
+        message,
+      }) as JsonRpcResponseWithErrorPayload<D>)
+    : (getResponseForRequest(payload, undefined, {
+        code: VERIFICATION_FAILED_RESPONSE_CODE,
+        message,
+        data,
+      }) as JsonRpcResponseWithErrorPayload<D>);
+}
+
+function isValidResponsePayload<R, E>(
+  response: JsonRpcResponse<R, E> | undefined
+): response is JsonRpcResponseWithResultPayload<R> {
+  return !isNullish(response) && isNullish(response.error);
+}
+
+export function isValidResponse<R, E>(
+  response: JsonRpcResponseOrBatch<R, E> | undefined
+): response is JsonRpcResponseWithResultPayload<R> | JsonRpcResponseWithResultPayload<R>[] {
+  return Array.isArray(response) ? response.every(isValidResponsePayload) : isValidResponsePayload(response);
+}
+
+export function isValidBatchResponse<R, E>(
+  payload: JsonRpcBatchRequest,
+  response: JsonRpcBatchResponse<R, E>
+): response is JsonRpcBatchResponse<R, E> | JsonRpcResponseWithResultPayload<R>[] {
+  for (const [index, req] of payload.entries()) {
+    if (isRequest(req) && (response[index].id !== req.id || !isValidResponse(response[index]))) return false;
+  }
+  return true;
+}
+
+export function mergeBatchReqResp(
+  payload: JsonRpcBatchRequest,
+  response: JsonRpcBatchResponse
+): {request: JsonRpcRequest; response: JsonRpcResponse}[] {
+  const result = [];
+  for (const [index, req] of payload.entries()) {
+    if (isRequest(req)) {
+      // Some providers return raw json-rpc response, some return only result
+      // we need to just merge the result back based on the provider
+      result.push({request: req, response: response[index]});
+    }
+  }
+  return result;
+}
+
+export function isNotification<P>(payload: JsonRpcRequest<P>): payload is JsonRpcNotificationPayload<P> {
+  return !("id" in payload);
+}
+
+export function isRequest<P>(payload: JsonRpcRequest<P>): payload is JsonRpcRequestPayload<P> {
+  return "id" in payload;
+}
+
+export function isBatchRequest<P>(payload: JsonRpcRequestOrBatch<P>): payload is JsonRpcBatchRequest<P> {
+  return Array.isArray(payload);
+}
+
+export function isBatchResponse<R>(response: JsonRpcResponseOrBatch<R>): response is JsonRpcBatchResponse<R> {
+  return Array.isArray(response);
+}
+
+function logRequestPayload(payload: JsonRpcRequest, logger: Logger): void {
+  logger.debug("PR -> EL", {
+    id: isRequest(payload) ? payload.id : "notification",
+    method: payload.method,
+    params: JSON.stringify(payload.params),
+  });
+}
+
+export function logRequest(payload: JsonRpcRequestOrBatch | undefined | null, logger: Logger): void {
+  if (payload === undefined || payload === null) {
+    return;
+  }
+
+  for (const p of isBatchRequest(payload) ? payload : [payload]) {
+    logRequestPayload(p, logger);
+  }
+}
+
+function logResponsePayload(response: JsonRpcResponse | null | undefined, logger: Logger): void {
+  if (response === undefined || response === null) {
+    logger.debug("PR <- EL (empty response)");
+    return;
+  }
+
+  if (isValidResponse(response)) {
+    logger.debug("PR <- EL", {
+      id: response.id,
+      result: JSON.stringify(response.result),
+    });
+  } else {
+    logger.debug("PR <- E:", {
+      id: response.id,
+      error: JSON.stringify(response.error),
+    });
+  }
+}
+
+export function logResponse(response: JsonRpcResponseOrBatch | undefined, logger: Logger): void {
+  if (response === undefined || response === null) {
+    return;
+  }
+
+  for (const p of isBatchResponse(response) ? response : [response]) {
+    logResponsePayload(p, logger);
+  }
+}

package/src/utils/process.ts

@@ -0,0 +1,111 @@
+import {Logger} from "@lodestar/logger";
+import {ELVerifiedRequestHandler} from "../interfaces.js";
+import {ProofProvider} from "../proof_provider/proof_provider.js";
+import {JsonRpcBatchRequest, JsonRpcBatchResponse, JsonRpcRequestOrBatch, JsonRpcResponseOrBatch} from "../types.js";
+import {eth_call} from "../verified_requests/eth_call.js";
+import {eth_estimateGas} from "../verified_requests/eth_estimateGas.js";
+import {eth_getBalance} from "../verified_requests/eth_getBalance.js";
+import {eth_getBlockByHash} from "../verified_requests/eth_getBlockByHash.js";
+import {eth_getBlockByNumber} from "../verified_requests/eth_getBlockByNumber.js";
+import {eth_getCode} from "../verified_requests/eth_getCode.js";
+import {eth_getTransactionCount} from "../verified_requests/eth_getTransactionCount.js";
+import {getResponseForRequest, isBatchRequest, isRequest} from "./json_rpc.js";
+import {ELRpcProvider} from "./rpc_provider.js";
+import {isNullish} from "./validation.js";
+
+// biome-ignore lint/suspicious/noExplicitAny: We need to use `any` type here
+export const verifiableMethodHandlers: Record<string, ELVerifiedRequestHandler<any, any>> = {
+  eth_getBalance: eth_getBalance,
+  eth_getTransactionCount: eth_getTransactionCount,
+  eth_getBlockByHash: eth_getBlockByHash,
+  eth_getBlockByNumber: eth_getBlockByNumber,
+  eth_getCode: eth_getCode,
+  eth_call: eth_call,
+  eth_estimateGas: eth_estimateGas,
+};
+
+export const verifiableMethods = Object.keys(verifiableMethodHandlers);
+export const alwaysAllowedMethods = ["eth_subscribe", "eth_unsubscribe", "eth_getProof"];
+
+export function splitRequestsInChunks(
+  payload: JsonRpcRequestOrBatch,
+  unverifiedWhitelist?: string[]
+): {
+  verifiable: JsonRpcBatchRequest;
+  nonVerifiable: JsonRpcBatchRequest;
+  blocked: JsonRpcBatchRequest;
+} {
+  const verifiable: JsonRpcBatchRequest = [];
+  const nonVerifiable: JsonRpcBatchRequest = [];
+  const blocked: JsonRpcBatchRequest = [];
+
+  for (const pay of isBatchRequest(payload) ? payload : [payload]) {
+    if (isRequest(pay) && verifiableMethods.includes(pay.method)) {
+      verifiable.push(pay);
+      continue;
+    }
+
+    // If unverifiedWhitelist is not set that implies all methods are allowed
+    if ((isRequest(pay) && isNullish(unverifiedWhitelist)) || unverifiedWhitelist?.includes(pay.method)) {
+      nonVerifiable.push(pay);
+      continue;
+    }
+
+    if (alwaysAllowedMethods.includes(pay.method)) {
+      nonVerifiable.push(pay);
+      continue;
+    }
+
+    blocked.push(pay);
+  }
+
+  return {verifiable, nonVerifiable, blocked};
+}
+
+export async function processAndVerifyRequest({
+  payload,
+  rpc,
+  proofProvider,
+  logger,
+}: {
+  payload: JsonRpcRequestOrBatch;
+  rpc: ELRpcProvider;
+  proofProvider: ProofProvider;
+  logger: Logger;
+}): Promise<JsonRpcResponseOrBatch | undefined> {
+  await proofProvider.waitToBeReady();
+
+  const {verifiable, nonVerifiable, blocked} = splitRequestsInChunks(payload, proofProvider.opts.unverifiedWhitelist);
+  const verifiedResponses: JsonRpcBatchResponse = [];
+  const nonVerifiedResponses: JsonRpcBatchResponse = [];
+  const blockedResponses: JsonRpcBatchResponse = [];
+
+  for (const request of verifiable) {
+    logger.debug("Processing verifiable request", {
+      method: request.method,
+      params: JSON.stringify(request.params),
+    });
+    const verifiableRequestHandler = verifiableMethodHandlers[request.method];
+    const response = await verifiableRequestHandler({payload: request, rpc, proofProvider, logger});
+    verifiedResponses.push(response);
+  }
+
+  if (nonVerifiable.length > 0) {
+    logger.warn("Forwarding non-verifiable requests to EL provider.", {count: nonVerifiable.length});
+    const response = await rpc.batchRequest(nonVerifiable, {raiseError: false});
+    nonVerifiedResponses.push(...response.map((r) => r.response));
+  }
+
+  for (const request of blocked) {
+    blockedResponses.push(
+      getResponseForRequest(request, undefined, {message: `Method "${request.method}" not allowed.`})
+    );
+  }
+
+  const responses = [...verifiedResponses, ...nonVerifiedResponses, ...blockedResponses];
+
+  if (responses.length === 1) {
+    return responses[0];
+  }
+  return responses;
+}

package/src/utils/req_resp.ts

@@ -0,0 +1,34 @@
+import http from "node:http";
+import {JsonRpcRequestPayload, JsonRpcResponse} from "../types.js";
+
+export const fetchRequestPayload = async (req: http.IncomingMessage): Promise<JsonRpcRequestPayload> => {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk;
+    });
+    req.on("end", () => {
+      try {
+        resolve(JSON.parse(body) as JsonRpcRequestPayload);
+      } catch (err) {
+        reject(err);
+      }
+    });
+  });
+};
+
+export const fetchResponseBody = async (res: http.IncomingMessage): Promise<JsonRpcResponse> => {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    res.on("data", (chunk) => {
+      body += chunk;
+    });
+    res.on("end", () => {
+      try {
+        resolve(JSON.parse(body) as JsonRpcResponse);
+      } catch (err) {
+        reject(err);
+      }
+    });
+  });
+};

package/src/utils/rpc_provider.ts

@@ -0,0 +1,117 @@
+import {Logger} from "@lodestar/logger";
+import {ZERO_ADDRESS} from "../constants.js";
+import {ELRequestHandler} from "../interfaces.js";
+import {
+  ELApi,
+  ELApiParams,
+  ELApiReturn,
+  JsonRpcBatchRequest,
+  JsonRpcBatchResponse,
+  JsonRpcRequest,
+  JsonRpcResponse,
+  JsonRpcResponseWithResultPayload,
+} from "../types.js";
+import {
+  isRequest,
+  isValidBatchResponse,
+  isValidResponse,
+  logRequest,
+  logResponse,
+  mergeBatchReqResp,
+} from "./json_rpc.js";
+import {isNullish} from "./validation.js";
+
+export type Optional<T, K extends keyof T> = Omit<T, K> & {[P in keyof T]?: T[P] | undefined};
+
+export class ELRpcProvider {
+  private handler: ELRequestHandler;
+  private logger: Logger;
+
+  private requestId = 0;
+
+  constructor(handler: ELRequestHandler, logger: Logger) {
+    this.handler = handler;
+    this.logger = logger;
+  }
+
+  /**
+   * Request the EL RPC Provider
+   *
+   * @template K
+   * @template E
+   * @param {K} method - RPC Method
+   * @param {ELApiParams[K]} params - RPC Params
+   * @param {{raiseError?: E}} [opts]
+   * @return {*}  {Promise<E extends false ? JsonRpcResponse<ELApiReturn[K]> : JsonRpcResponseWithResultPayload<ELApiReturn[K]>>}
+   * @memberof ELRpc
+   */
+  async request<K extends keyof ELApi, E extends boolean>(
+    method: K,
+    params: ELApiParams[K],
+    opts?: {raiseError?: E}
+  ): Promise<E extends false ? JsonRpcResponse<ELApiReturn[K]> : JsonRpcResponseWithResultPayload<ELApiReturn[K]>> {
+    const {raiseError} = opts ?? {raiseError: true};
+
+    const payload: JsonRpcRequest = {jsonrpc: "2.0", method, params, id: this.getRequestId()};
+    logRequest(payload, this.logger);
+
+    const response = await this.handler(payload);
+    logResponse(response, this.logger);
+
+    if (raiseError && !isValidResponse(response)) {
+      throw new Error(`Invalid response from RPC. method=${method} params=${JSON.stringify(params)}`);
+    }
+
+    return response as JsonRpcResponseWithResultPayload<ELApiReturn[K]>;
+  }
+
+  async batchRequest<E extends boolean>(
+    input: JsonRpcBatchRequest,
+    opts: {raiseError: E}
+  ): Promise<
+    E extends false
+      ? {request: JsonRpcRequest; response: JsonRpcResponse}[]
+      : {request: JsonRpcRequest; response: JsonRpcResponseWithResultPayload<unknown>}[]
+  > {
+    const payloads: JsonRpcBatchRequest = [];
+
+    for (const req of input) {
+      if (isRequest(req) && isNullish(req.id)) {
+        payloads.push({jsonrpc: "2.0", method: req.method, params: req.params, id: this.getRequestId()});
+      } else {
+        payloads.push(req);
+      }
+    }
+
+    logRequest(payloads, this.logger);
+    const response = await this.handler(payloads);
+    logResponse(response, this.logger);
+
+    if (isNullish(response)) {
+      throw new Error("Invalid empty response from server.");
+    }
+
+    if (opts.raiseError && !isValidBatchResponse(payloads, response as JsonRpcBatchResponse)) {
+      throw new Error(
+        `Invalid response from RPC. payload=${JSON.stringify(payloads)} response=${JSON.stringify(response)}}`
+      );
+    }
+
+    return mergeBatchReqResp(payloads, response as JsonRpcBatchResponse) as E extends false
+      ? {request: JsonRpcRequest; response: JsonRpcResponse}[]
+      : {request: JsonRpcRequest; response: JsonRpcResponseWithResultPayload<unknown>}[];
+  }
+
+  async verifyCompatibility(): Promise<void> {
+    try {
+      await this.request("eth_getProof", [ZERO_ADDRESS, [], "latest"], {raiseError: true});
+    } catch (err) {
+      this.logger.error("Execution compatibility failed.", undefined, err as Error);
+      throw new Error("RPC does not support 'eth_getProof', which is required for the prover to work properly.");
+    }
+  }
+
+  getRequestId(): string {
+    return (++this.requestId).toString();
+  }
+}