Add brain API (#398)

* add brain api

* fix tag imports

* Implement middleware validation

* fix path-to-regexp breaking change

* remove logging

packages/brain/src/calls/types.ts

@@ -1,4 +1,4 @@
-import { Tag } from "../modules/db/types.js";
+import { Tag } from "@stakingbrain/common";
 
 export type ActionRequestOrigin = "ui" | "api";
 

packages/brain/src/index.ts

@@ -11,18 +11,16 @@ import {
   PostgresClient,
   PrometheusApi
 } from "./modules/apiClients/index.js";
-import { startUiServer, startLaunchpadApi } from "./modules/apiServers/index.js";
+import { startUiServer, startLaunchpadApi, startBrainApi } from "./modules/apiServers/index.js";
 import * as dotenv from "dotenv";
 import process from "node:process";
 import { params } from "./params.js";
 import {
   CronJob,
   reloadValidators,
-  // trackValidatorsPerformanceCron,
   sendProofsOfValidation,
   trackValidatorsPerformanceCron
 } from "./modules/cron/index.js";
-// import { PostgresClient } from "./modules/apiClients/index.js";
 import { brainConfig } from "./modules/config/index.js";
 
 logger.info(`Starting brain...`);
@@ -99,6 +97,7 @@ export const postgresClient = new PostgresClient(postgresUrl);
 // Start server APIs
 const uiServer = startUiServer(path.resolve(__dirname, params.uiBuildDirName), network);
 const launchpadServer = startLaunchpadApi();
+const brainApiServer = startBrainApi();
 
 await brainDb.initialize(signerApi, validatorApi);
 logger.debug(brainDb.data);
@@ -141,6 +140,7 @@ function handle(signal: string): void {
   postgresClient.close().catch((err) => logger.error(`Error closing postgres client`, err)); // postgresClient db connection is the only external resource that needs to be closed
   uiServer.close();
   launchpadServer.close();
+  brainApiServer.close();
   logger.debug(`Stopped all cron jobs and closed all connections.`);
   process.exit(0);
 }

packages/brain/src/modules/apiClients/signer/types.ts

@@ -1,4 +1,4 @@
-import { Tag } from "../../db/types.js";
+import { Tag } from "@stakingbrain/common";
 
 export type Web3SignerStatus = "UP" | "DOWN" | "UNKNOWN" | "LOADING" | "ERROR";
 

packages/brain/src/modules/apiServers/brain/config.ts

@@ -0,0 +1,3 @@
+export const corsOptions = {
+  origin: ["http://csm-lido.dappnode", "http://csm-lido.testnet.dappnode"] // TODO: update with DAppNodePackage-lido-csm.dnp.dappnode.eth domains
+};

packages/brain/src/modules/apiServers/brain/index.ts

@@ -0,0 +1 @@
+export { startBrainApi } from "./startBrainApi.js";

packages/brain/src/modules/apiServers/brain/routes/index.ts

@@ -0,0 +1 @@
+export * from "./validators/index.js";

packages/brain/src/modules/apiServers/brain/routes/validators/index.ts

@@ -0,0 +1,3 @@
+import validatorsRouter from "./route.js";
+
+export { validatorsRouter };

packages/brain/src/modules/apiServers/brain/routes/validators/route.ts

@@ -0,0 +1,45 @@
+import { Tag } from "@stakingbrain/common";
+import express from "express";
+import logger from "../../../../logger/index.js";
+import { brainDb } from "../../../../../index.js";
+import { validateQueryParams } from "./validation.js";
+import { RequestParsed } from "./types.js";
+
+const validatorsRouter = express.Router();
+
+const validatorsEndpoint = "/api/v0/brain/validators";
+
+validatorsRouter.get(validatorsEndpoint, validateQueryParams, async (req: RequestParsed, res) => {
+  const { format, tag } = req.query;
+
+  try {
+    const validators = brainDb.getData();
+
+    const tagValidatorsMap = new Map<Tag, string[]>();
+
+    for (const [pubkey, details] of Object.entries(validators)) {
+      if (tag && !tag.includes(details.tag)) continue;
+
+      const tagList = tagValidatorsMap.get(details.tag) || [];
+
+      if (format === "index") {
+        if (!details.index) {
+          logger.warn(
+            `Validator ${pubkey} does not have an index, a possible cause is that the deposit has not been processed yet`
+          );
+          continue;
+        }
+        tagList.push(details.index.toString());
+      } else tagList.push(pubkey);
+
+      tagValidatorsMap.set(details.tag, tagList);
+    }
+
+    res.send(Object.fromEntries(tagValidatorsMap));
+  } catch (e) {
+    logger.error(e);
+    res.status(500).send({ message: "Internal server error" });
+  }
+});
+
+export default validatorsRouter;

packages/brain/src/modules/apiServers/brain/routes/validators/types.ts

@@ -0,0 +1,20 @@
+import { Request } from "express";
+import { Tag } from "@stakingbrain/common"; // Assuming this is defined somewhere
+
+// The query parameters before they are parsed or validated
+// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-empty-object-type
+export type RequestReceived = Request<{}, any, any, QueryParamsReceived>;
+
+type QueryParamsReceived = {
+  format: "pubkey" | "index";
+  tag?: Tag[] | Tag; // Can be an array or a single value before validation
+};
+
+// The query parameters after they are validated and parsed
+// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-empty-object-type
+export type RequestParsed = Request<{}, any, any, QueryParamsParsed>;
+
+type QueryParamsParsed = {
+  format: "pubkey" | "index";
+  tag?: Tag[]; // After validation, tag should be an array
+};

packages/brain/src/modules/apiServers/brain/routes/validators/validation.ts

@@ -0,0 +1,36 @@
+import { Response, NextFunction } from "express";
+import { Tag, tags } from "@stakingbrain/common";
+import { RequestReceived } from "./types.js";
+
+// Validation middleware for query parameters
+export function validateQueryParams(req: RequestReceived, res: Response, next: NextFunction): void {
+  const { format, tag } = req.query;
+
+  // Validate format
+  if (!format || (format !== "pubkey" && format !== "index")) {
+    res.status(400).json({ message: "format is required and must be either 'pubkey' or 'index'" });
+    return;
+  }
+
+  // Validate tag
+  if (tag) {
+    // tag may be of type string or array of strings otherwise return 400
+    if (typeof tag !== "string" && !Array.isArray(tag)) {
+      res.status(400).json({ message: "tag must be a string or an array of strings" });
+    }
+
+    // if tag is a string, convert it to an array
+    const tagsArray = Array.isArray(tag) ? tag : [tag];
+    const invalidTag = tagsArray.find((t) => !tags.includes(t as Tag));
+
+    if (invalidTag) {
+      res.status(400).json({ message: `invalid tag received: ${invalidTag}. Allowed tags are ${tags.join(", ")}` });
+      return;
+    }
+
+    // If validation passed, update req.query.tag to ensure it is always an array for downstream middleware
+    req.query.tag = tagsArray;
+  }
+
+  next(); // Continue to the next middleware or route handler
+}

packages/brain/src/modules/apiServers/brain/startBrainApi.ts

@@ -0,0 +1,22 @@
+import express from "express";
+import cors from "cors";
+import logger from "../../logger/index.js";
+import http from "node:http";
+import { params } from "../../../params.js";
+import { corsOptions } from "./config.js";
+import { validatorsRouter } from "./routes/index.js";
+
+export function startBrainApi(): http.Server {
+  const app = express();
+  app.use(express.json());
+  app.use(cors(corsOptions));
+
+  app.use(validatorsRouter);
+
+  const server = new http.Server(app);
+  server.listen(params.brainPort, () => {
+    logger.info(`Brain API listening on port ${params.brainPort}`);
+  });
+
+  return server;
+}

packages/brain/src/modules/apiServers/index.ts

@@ -1,2 +1,3 @@
 export * from "./ui/index.js";
 export * from "./launchpad/index.js";
+export * from "./brain/index.js";

packages/brain/src/modules/apiServers/ui/startUiServer.ts

@@ -78,7 +78,10 @@ export function startUiServer(uiBuildPath: string, network: Network): http.Serve
   );
   app.use(express.json());
   app.use(express.static(uiBuildPath));
-  app.get("*", (req, res) => {
+  // path-to-regexp (used by express >=5.0.0) has a breaking change
+  // where it does not allow to use wildcard among other characters
+  // https://github.com/pillarjs/path-to-regexp?tab=readme-ov-file#errors
+  app.get("/", (_, res) => {
     logger.debug("request received");
     res.sendFile(path.join(uiBuildPath, "index.html"));
   });

packages/brain/src/modules/db/types.ts

@@ -1,3 +1,5 @@
+import { Tag } from "@stakingbrain/common";
+
 /**
  * DbSlot represents the line in the database for a given public key:
  * @param pubkey - the public key
@@ -25,13 +27,6 @@ export interface PubkeyDetails {
   index?: number; // index of the validator. Only available if the validator is active.
 }
 
-export const tags = ["obol", "diva", "ssv", "rocketpool", "stakewise", "stakehouse", "solo", "stader", "lido"] as const;
-
 export const nonEditableFeeRecipientTags = ["rocketpool", "stader", "stakewise", "lido"] as const;
 
 export type NonEditableFeeRecipientTag = (typeof nonEditableFeeRecipientTags)[number];
-
-/**
- * Tag describes the protocol of the public key imported
- */
-export type Tag = (typeof tags)[number];

packages/brain/src/modules/db/utils.ts

@@ -1,4 +1,4 @@
-import { Tag, tags } from "./types.js";
+import { Tag, tags } from "@stakingbrain/common";
 
 export function isValidTag(tag: Tag): boolean {
   return tags.includes(tag);

packages/brain/src/params.ts

@@ -8,6 +8,7 @@ export const params = {
   defaultTag: "solo" as Tag,
   uiPort: 80,
   launchpadPort: 3000,
+  brainPort: 5000,
   defaultValidatorsMonitorUrl: "https://validators-proofs.dappnode.io",
   defaultProofsOfValidationCron: 24 * 60 * 60 * 1000 // 1 day in ms
 };