@lodestar/prover 1.35.0-dev.b42a298a7c → 1.35.0-dev.ba92bd8a88

package/src/utils/version.ts

@@ -0,0 +1,74 @@
+import fs from "node:fs";
+import path from "node:path";
+import {fileURLToPath} from "node:url";
+import {findUpSync} from "find-up";
+import {readAndGetGitData} from "./gitData/index.js";
+
+// 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));
+
+type VersionJson = {
+  /** "0.28.2" */
+  version: string;
+};
+
+const BRANCH_IGNORE = /^(HEAD|master|unstable|main)$/;
+
+/**
+ * Gathers all information on package version including Git data.
+ * @returns a version string, e.g.
+ * - Stable release: `v0.36.0/80c248bb`
+ * - Dev release: `v0.36.0-dev.80c248bb/80c248bb`
+ * - Test branch: `v0.36.0/developer-feature/80c248bb`
+ */
+export function getVersionData(): {
+  version: string;
+  commit: string;
+} {
+  const parts: string[] = [];
+
+  /** Returns local version from `lerna.json` or `package.json` as `"0.28.2"` */
+  const localVersion = readCliPackageJson() || readVersionFromLernaJson();
+  if (localVersion) {
+    parts.push(`v${localVersion}`);
+  }
+
+  const {branch, commit} = readAndGetGitData();
+
+  // Add branch only if not present and not an ignore value
+  if (branch && !BRANCH_IGNORE.test(branch)) parts.push(branch);
+
+  // Add commit only if present. 7 characters to be consistent with Github
+  if (commit) {
+    const commitShort = commit.slice(0, 7);
+    // Don't add commit if it's already in the version string (dev versions)
+    if (!localVersion || !localVersion.includes(commitShort)) {
+      parts.push(commitShort);
+    }
+  }
+
+  return {
+    // Guard against empty parts array
+    version: parts.length > 0 ? parts.join("/") : "unknown",
+    commit,
+  };
+}
+
+/** Read version information from lerna.json */
+function readVersionFromLernaJson(): string | undefined {
+  const filePath = findUpSync("lerna.json", {cwd: __dirname});
+  if (!filePath) return undefined;
+
+  const lernaJson = JSON.parse(fs.readFileSync(filePath, "utf8")) as VersionJson;
+  return lernaJson.version;
+}
+
+/** Read version information from package.json */
+function readCliPackageJson(): string | undefined {
+  const filePath = findUpSync("package.json", {cwd: __dirname});
+  if (!filePath) return undefined;
+
+  const packageJson = JSON.parse(fs.readFileSync(filePath, "utf8")) as VersionJson;
+  return packageJson.version;
+}

package/src/verified_requests/eth_call.ts

@@ -0,0 +1,50 @@
+import {ELVerifiedRequestHandler} from "../interfaces.js";
+import {ELApiParams, ELApiReturn} from "../types.js";
+import {bufferToHex} from "../utils/conversion.js";
+import {createVM, executeVMCall, getVMWithState} from "../utils/evm.js";
+import {
+  getErrorResponseForRequestWithFailedVerification,
+  getResponseForRequest,
+  getVerificationFailedMessage,
+} from "../utils/json_rpc.js";
+
+export const eth_call: ELVerifiedRequestHandler<ELApiParams["eth_call"], ELApiReturn["eth_call"]> = async ({
+  rpc,
+  payload,
+  logger,
+  proofProvider,
+}) => {
+  const {
+    params: [tx, block],
+  } = payload;
+  // We assume that standard tx validation already been done by the caller (web3, ethers.js, etc.)
+  const executionPayload = await proofProvider.getExecutionPayload(block ?? "latest");
+
+  try {
+    // TODO: Optimize the creation of the evm
+    const vm = await createVM({proofProvider});
+    const vmWithState = await getVMWithState({
+      rpc,
+      executionPayload,
+      tx,
+      vm,
+      logger,
+    });
+    const result = await executeVMCall({
+      vm: vmWithState,
+      tx,
+      rpc,
+      executionPayload,
+      network: proofProvider.network,
+    });
+
+    return getResponseForRequest(payload, bufferToHex(result.returnValue));
+  } catch (err) {
+    logger.error(
+      "Request could not be verified.",
+      {method: payload.method, params: JSON.stringify(payload.params)},
+      err as Error
+    );
+    return getErrorResponseForRequestWithFailedVerification(payload, getVerificationFailedMessage("eth_call"));
+  }
+};

package/src/verified_requests/eth_estimateGas.ts

@@ -0,0 +1,49 @@
+import {ELVerifiedRequestHandler} from "../interfaces.js";
+import {ELApiParams, ELApiReturn} from "../types.js";
+import {bigIntToHex} from "../utils/conversion.js";
+import {createVM, executeVMTx, getVMWithState} from "../utils/evm.js";
+import {
+  getErrorResponseForRequestWithFailedVerification,
+  getResponseForRequest,
+  getVerificationFailedMessage,
+} from "../utils/json_rpc.js";
+
+export const eth_estimateGas: ELVerifiedRequestHandler<
+  ELApiParams["eth_estimateGas"],
+  ELApiReturn["eth_estimateGas"]
+> = async ({rpc, payload, logger, proofProvider}) => {
+  const {
+    params: [tx, block],
+  } = payload;
+  // We assume that standard tx validation already been done by the caller (web3, ethers.js, etc.)
+  const executionPayload = await proofProvider.getExecutionPayload(block ?? "latest");
+
+  try {
+    // TODO: Optimize the creation of the evm
+    const vm = await createVM({proofProvider});
+    const vmWithState = await getVMWithState({
+      rpc,
+      executionPayload,
+      tx,
+      vm,
+      logger,
+    });
+
+    const result = await executeVMTx({
+      vm: vmWithState,
+      tx,
+      rpc,
+      executionPayload,
+      network: proofProvider.network,
+    });
+
+    return getResponseForRequest(payload, bigIntToHex(result.totalGasSpent));
+  } catch (err) {
+    logger.error(
+      "Request could not be verified.",
+      {method: payload.method, params: JSON.stringify(payload.params)},
+      err as Error
+    );
+    return getErrorResponseForRequestWithFailedVerification(payload, getVerificationFailedMessage("eth_estimateGas"));
+  }
+};

package/src/verified_requests/eth_getBalance.ts

@@ -0,0 +1,26 @@
+import {ELVerifiedRequestHandler} from "../interfaces.js";
+import {
+  getErrorResponseForRequestWithFailedVerification,
+  getResponseForRequest,
+  getVerificationFailedMessage,
+} from "../utils/json_rpc.js";
+import {verifyAccount} from "../utils/verification.js";
+
+export const eth_getBalance: ELVerifiedRequestHandler<[address: string, block?: number | string], string> = async ({
+  rpc,
+  payload,
+  logger,
+  proofProvider,
+}) => {
+  const {
+    params: [address, block],
+  } = payload;
+  const result = await verifyAccount({proofProvider, logger, rpc, address, block});
+
+  if (result.valid) {
+    return getResponseForRequest(payload, result.data.balance);
+  }
+
+  logger.error("Request could not be verified.", {method: payload.method, params: JSON.stringify(payload.params)});
+  return getErrorResponseForRequestWithFailedVerification(payload, getVerificationFailedMessage("eth_getBalance"));
+};

package/src/verified_requests/eth_getBlockByHash.ts

@@ -0,0 +1,24 @@
+import {ELVerifiedRequestHandler} from "../interfaces.js";
+import {ELBlock} from "../types.js";
+import {
+  getErrorResponseForRequestWithFailedVerification,
+  getResponseForRequest,
+  getVerificationFailedMessage,
+} from "../utils/json_rpc.js";
+import {verifyBlock} from "../utils/verification.js";
+
+export const eth_getBlockByHash: ELVerifiedRequestHandler<[block: string, hydrated: boolean], ELBlock> = async ({
+  rpc,
+  payload,
+  logger,
+  proofProvider,
+}) => {
+  const result = await verifyBlock({payload, proofProvider, logger, rpc});
+
+  if (result.valid) {
+    return getResponseForRequest(payload, result.data);
+  }
+
+  logger.error("Request could not be verified.", {method: payload.method, params: JSON.stringify(payload.params)});
+  return getErrorResponseForRequestWithFailedVerification(payload, getVerificationFailedMessage("eth_getBlockByHash"));
+};

package/src/verified_requests/eth_getBlockByNumber.ts

@@ -0,0 +1,25 @@
+import {ELVerifiedRequestHandler} from "../interfaces.js";
+import {ELBlock} from "../types.js";
+import {
+  getErrorResponseForRequestWithFailedVerification,
+  getResponseForRequest,
+  getVerificationFailedMessage,
+} from "../utils/json_rpc.js";
+import {verifyBlock} from "../utils/verification.js";
+
+export const eth_getBlockByNumber: ELVerifiedRequestHandler<
+  [block: string | number, hydrated: boolean],
+  ELBlock
+> = async ({rpc, payload, logger, proofProvider}) => {
+  const result = await verifyBlock({payload, proofProvider, logger, rpc});
+
+  if (result.valid) {
+    return getResponseForRequest(payload, result.data);
+  }
+
+  logger.error("Request could not be verified.", {method: payload.method, params: JSON.stringify(payload.params)});
+  return getErrorResponseForRequestWithFailedVerification(
+    payload,
+    getVerificationFailedMessage("eth_getBlockByNumber")
+  );
+};

package/src/verified_requests/eth_getCode.ts

@@ -0,0 +1,50 @@
+import {ELVerifiedRequestHandler} from "../interfaces.js";
+import {
+  getErrorResponseForRequestWithFailedVerification,
+  getResponseForRequest,
+  getVerificationFailedMessage,
+} from "../utils/json_rpc.js";
+import {verifyAccount, verifyCode} from "../utils/verification.js";
+
+export const eth_getCode: ELVerifiedRequestHandler<[address: string, block?: number | string], string> = async ({
+  rpc,
+  payload,
+  logger,
+  proofProvider,
+}) => {
+  const {
+    params: [address, block],
+  } = payload;
+  // TODO: When batch requests are supported merged these two requests into one
+  const accountProof = await verifyAccount({
+    proofProvider,
+    logger,
+    rpc,
+    address,
+    block,
+  });
+
+  if (!accountProof.valid) {
+    logger.error("Request could not be verified.", {method: payload.method, params: JSON.stringify(payload.params)});
+    return getErrorResponseForRequestWithFailedVerification(
+      payload,
+      "account for eth_getCode request can not be verified."
+    );
+  }
+
+  const codeProof = await verifyCode({
+    proofProvider,
+    logger,
+    rpc,
+    address,
+    block,
+    codeHash: accountProof.data.codeHash,
+  });
+
+  if (codeProof.valid) {
+    return getResponseForRequest(payload, codeProof.data);
+  }
+
+  logger.error("Request could not be verified.", {method: payload.method, params: JSON.stringify(payload.params)});
+  return getErrorResponseForRequestWithFailedVerification(payload, getVerificationFailedMessage("eth_getCode"));
+};

package/src/verified_requests/eth_getTransactionCount.ts

@@ -0,0 +1,26 @@
+import {ELVerifiedRequestHandler} from "../interfaces.js";
+import {
+  getErrorResponseForRequestWithFailedVerification,
+  getResponseForRequest,
+  getVerificationFailedMessage,
+} from "../utils/json_rpc.js";
+import {verifyAccount} from "../utils/verification.js";
+
+export const eth_getTransactionCount: ELVerifiedRequestHandler<
+  [address: string, block?: number | string],
+  string
+> = async ({rpc, payload, logger, proofProvider}) => {
+  const {
+    params: [address, block],
+  } = payload;
+  const result = await verifyAccount({proofProvider, logger, rpc, address, block});
+  if (result.valid) {
+    return getResponseForRequest(payload, result.data.nonce);
+  }
+
+  logger.error("Request could not be verified.", {method: payload.method, params: JSON.stringify(payload.params)});
+  return getErrorResponseForRequestWithFailedVerification(
+    payload,
+    getVerificationFailedMessage("eth_getTransactionCount")
+  );
+};

package/src/web3_provider.ts

@@ -0,0 +1,58 @@
+import {LogLevel} from "@lodestar/logger";
+import {getBrowserLogger} from "@lodestar/logger/browser";
+import {Logger} from "@lodestar/utils";
+import {AnyWeb3Provider, ELRequestHandler, VerifiedExecutionInitOptions} from "./interfaces.js";
+import {ProofProvider} from "./proof_provider/proof_provider.js";
+import {processAndVerifyRequest} from "./utils/process.js";
+import {ELRpcProvider} from "./utils/rpc_provider.js";
+import {Web3ProviderInspector} from "./web3_provider_inspector.js";
+
+export type Web3ProviderTypeHandler<T extends AnyWeb3Provider> = (
+  provider: T,
+  proofProvider: ProofProvider,
+  logger: Logger
+) => {provider: T; handler: ELRpcProvider["handler"]};
+
+export function createVerifiedExecutionProvider<
+  T extends AnyWeb3Provider,
+  Mutate extends undefined | boolean = true,
+  Return = {provider: Mutate extends undefined | true ? T : ELRpcProvider; proofProvider: ProofProvider},
+>(provider: T, opts: VerifiedExecutionInitOptions<Mutate>): Return {
+  const signal = opts.signal ?? new AbortController().signal;
+  const logger = opts.logger ?? getBrowserLogger({level: opts.logLevel ?? LogLevel.info});
+  const mutateProvider = opts.mutateProvider === undefined;
+  const customProviderTypes = opts.providerTypes ?? [];
+
+  const providerInspector = Web3ProviderInspector.initWithDefault({logger});
+  for (const providerType of customProviderTypes.reverse()) {
+    providerInspector.register(providerType, {index: 0});
+  }
+  const providerType = providerInspector.detect(provider);
+  logger.debug(`Provider is detected as '${providerType.name}' provider.`);
+
+  const proofProvider = ProofProvider.init({
+    ...opts,
+    signal,
+    logger,
+  });
+
+  const nonVerifiedHandler = providerType.handler(provider);
+  const nonVerifiedRpc = new ELRpcProvider(nonVerifiedHandler, logger);
+
+  nonVerifiedRpc.verifyCompatibility().catch((err) => {
+    logger.error(err);
+    logger.error("Due to compatibility issues, verified execution may not work properly.");
+  });
+
+  const verifiedHandler: ELRequestHandler = function newVerifiedHandler(payload) {
+    return processAndVerifyRequest({payload, rpc: nonVerifiedRpc, logger, proofProvider});
+  };
+
+  if (mutateProvider) {
+    providerType.mutateProvider(provider, verifiedHandler);
+    return {provider, proofProvider} as Return;
+  }
+
+  // Verified RPC
+  return {provider: new ELRpcProvider(verifiedHandler, logger), proofProvider} as Return;
+}

package/src/web3_provider_inspector.ts

@@ -0,0 +1,88 @@
+import {Logger} from "@lodestar/logger";
+import {AnyWeb3Provider, Web3ProviderType} from "./interfaces.js";
+import eip1193ProviderType from "./provider_types/eip1193_provider_type.js";
+import ethersProviderType from "./provider_types/ethers_provider_type.js";
+import legacyProviderType from "./provider_types/legacy_provider_type.js";
+import web3jsProviderType from "./provider_types/web3_js_provider_type.js";
+
+export class Web3ProviderInspector {
+  protected providerTypes: Web3ProviderType<AnyWeb3Provider>[] = [];
+  logger: Logger;
+
+  protected constructor(opts: {logger: Logger}) {
+    this.logger = opts.logger;
+  }
+
+  static initWithDefault(opts: {logger: Logger}): Web3ProviderInspector {
+    const inspector = new Web3ProviderInspector(opts);
+    inspector.register(web3jsProviderType, {index: 0});
+    inspector.register(ethersProviderType, {index: 1});
+    inspector.register(eip1193ProviderType, {index: 2});
+    inspector.register(legacyProviderType, {index: 3});
+
+    return inspector;
+  }
+
+  getProviderTypes(): Web3ProviderType<AnyWeb3Provider>[] {
+    // Destruct so user can not mutate the output
+    return [...this.providerTypes];
+  }
+
+  register(providerType: Web3ProviderType<AnyWeb3Provider>, opts?: {index?: number}): void {
+    // If user does not provider index, we will register the provider type to last
+    let index = opts?.index ?? this.providerTypes.length;
+
+    // If index is larger, let's add type at the end
+    if (index > this.providerTypes.length) {
+      index = this.providerTypes.length;
+    }
+
+    // If a lower index is provided let's add type at the start
+    if (index < 0) {
+      index = 0;
+    }
+
+    if (this.providerTypes.map((p) => p.name).includes(providerType.name)) {
+      throw new Error(`Provider type '${providerType.name}' is already registered.`);
+    }
+
+    // If some provider type is already register on that index, we will make space for new
+    if (this.providerTypes.at(index)) {
+      this.logger.debug(
+        `A provider type '${this.providerTypes[index].name}' already existed at index '${index}', now moved down.`
+      );
+      this.providerTypes.splice(index, 0, providerType);
+    }
+
+    this.logger.debug(`Registered provider type "${providerType.name}" at index ${index}`);
+    this.providerTypes[index] = providerType;
+  }
+
+  unregister(indexOrName: string | number): void {
+    if (typeof indexOrName === "number") {
+      if (indexOrName > this.providerTypes.length || indexOrName < 0) {
+        throw new Error(`Provider type at index '${indexOrName}' is not registered.`);
+      }
+      this.providerTypes.splice(indexOrName, 1);
+      return;
+    }
+
+    const index = this.providerTypes.findIndex((p) => p.name === indexOrName);
+    if (index < 0) {
+      throw Error(`Provider type '${indexOrName}' is not registered.`);
+    }
+    this.providerTypes.splice(index, 1);
+  }
+
+  detect(provider: AnyWeb3Provider): Web3ProviderType<AnyWeb3Provider> {
+    for (const providerType of Object.values(this.providerTypes)) {
+      if (providerType.matched(provider)) {
+        return providerType;
+      }
+    }
+
+    throw new Error(
+      `Given provider could not be detected of any type. Supported types are ${Object.keys(this.providerTypes).join()}`
+    );
+  }
+}

package/src/web3_proxy.ts

@@ -0,0 +1,175 @@
+import http from "node:http";
+import https from "node:https";
+import url from "node:url";
+import httpProxy from "http-proxy";
+import {LogLevel} from "@lodestar/logger";
+import {getNodeLogger} from "@lodestar/logger/node";
+import {ELRequestHandler, VerifiedExecutionInitOptions} from "./interfaces.js";
+import {ProofProvider} from "./proof_provider/proof_provider.js";
+import {JsonRpcRequestOrBatch, JsonRpcRequestPayload, JsonRpcResponseOrBatch} from "./types.js";
+import {getResponseForRequest, isBatchRequest} from "./utils/json_rpc.js";
+import {processAndVerifyRequest} from "./utils/process.js";
+import {fetchRequestPayload, fetchResponseBody} from "./utils/req_resp.js";
+import {ELRpcProvider} from "./utils/rpc_provider.js";
+
+export type VerifiedProxyOptions = Exclude<VerifiedExecutionInitOptions<false>, "mutateProvider" | "providerTypes"> & {
+  executionRpcUrl: string;
+  requestTimeout: number;
+};
+
+function createHttpHandler({
+  info,
+  signal,
+}: {
+  signal: AbortSignal;
+  info: () => {port: number; host: string; timeout: number} | string;
+}): ELRequestHandler {
+  return function handler(payload: JsonRpcRequestOrBatch): Promise<JsonRpcResponseOrBatch | undefined> {
+    return new Promise((resolve, reject) => {
+      const serverInfo = info();
+      if (typeof serverInfo === "string") {
+        return reject(new Error(serverInfo));
+      }
+
+      const req = http.request(
+        {
+          method: "POST",
+          path: "/proxy",
+          port: serverInfo.port,
+          host: serverInfo.host,
+          timeout: serverInfo.timeout,
+          signal,
+          headers: {
+            "Content-Type": "application/json",
+          },
+        },
+        (res) => {
+          fetchResponseBody(res)
+            .then((response) => {
+              resolve(response);
+            })
+            .catch(reject);
+        }
+      );
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new Error("Request timeout"));
+      });
+      req.write(JSON.stringify(payload));
+      req.end();
+    });
+  };
+}
+
+export function createVerifiedExecutionProxy(opts: VerifiedProxyOptions): {
+  server: http.Server;
+  proofProvider: ProofProvider;
+} {
+  const {executionRpcUrl, requestTimeout} = opts;
+  const signal = opts.signal ?? new AbortController().signal;
+  const logger = opts.logger ?? getNodeLogger({level: opts.logLevel ?? LogLevel.info, module: "prover"});
+
+  const proofProvider = ProofProvider.init({
+    ...opts,
+    signal,
+    logger,
+  });
+
+  logger.info("Creating http proxy", {url: executionRpcUrl});
+  const proxy = httpProxy.createProxy({
+    target: executionRpcUrl,
+    ws: executionRpcUrl.startsWith("ws"),
+    agent: executionRpcUrl.startsWith("https") ? https.globalAgent : http.globalAgent,
+    xfwd: true,
+    ignorePath: true,
+    changeOrigin: true,
+  });
+
+  let proxyServerListeningAddress: {host: string; port: number} | undefined;
+  const rpc = new ELRpcProvider(
+    createHttpHandler({
+      signal,
+      info: () => {
+        if (!proxyServerListeningAddress) {
+          return "Proxy server not listening";
+        }
+
+        return {
+          port: proxyServerListeningAddress.port,
+          host: proxyServerListeningAddress.host,
+          timeout: requestTimeout,
+        };
+      },
+    }),
+    logger
+  );
+
+  logger.info("Creating http server");
+  const proxyServer = http.createServer(function proxyRequestHandler(req, res) {
+    if (req.url === "/proxy") {
+      logger.debug("Forwarding request to execution layer");
+      proxy.web(req, res);
+      return;
+    }
+
+    let payload: JsonRpcRequestPayload;
+    fetchRequestPayload(req)
+      .then((data) => {
+        payload = data;
+        return processAndVerifyRequest({payload, proofProvider, rpc, logger});
+      })
+      .then((response) => {
+        res.write(JSON.stringify(response));
+        res.end();
+      })
+      .catch((err) => {
+        logger.error("Error processing request", err);
+        const message = (err as Error).message;
+        if (isBatchRequest(payload)) {
+          res.write(JSON.stringify(payload.map((req) => getResponseForRequest(req, {message}))));
+        } else {
+          res.write(JSON.stringify(getResponseForRequest(payload, undefined, {message})));
+        }
+
+        res.end();
+      });
+  });
+
+  proxyServer.on("listening", () => {
+    const address = proxyServer.address();
+
+    if (address === null) {
+      throw new Error("Invalid proxy server address");
+    }
+
+    if (typeof address === "string") {
+      const rawUrl = url.parse(address);
+      if (!rawUrl.host || !rawUrl.port || !rawUrl.protocol) {
+        throw new Error(`Invalid proxy server address: ${address}`);
+      }
+      proxyServerListeningAddress = {host: rawUrl.host, port: parseInt(rawUrl.port)};
+    } else {
+      proxyServerListeningAddress = {host: address.address, port: address.port};
+    }
+
+    logger.info(
+      `Lodestar Prover Proxy listening on ${proxyServerListeningAddress.host}:${proxyServerListeningAddress.port}`
+    );
+
+    rpc.verifyCompatibility().catch((err) => {
+      logger.error(err);
+      process.exit(1);
+    });
+  });
+
+  proxyServer.on("upgrade", function proxyRequestUpgrade(req, socket, head) {
+    logger.debug("Upgrading the ws connection");
+    proxy.ws(req, socket, head);
+  });
+
+  signal.addEventListener("abort", () => {
+    proxyServer.close();
+  });
+
+  return {server: proxyServer, proofProvider};
+}