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

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};
+}