feat(indexer-api): expose hubpool balance endpoint (#81)

Signed-off-by: david <[email protected]>

packages/indexer-api/package.json

@@ -22,11 +22,13 @@
   "license": "ISC",
   "dependencies": {
     "@repo/indexer-database": "workspace:*",
+    "@repo/indexer": "workspace:*",
     "@types/express": "^4.17.21",
     "@types/supertest": "^6.0.2",
     "body-parser": "^1.20.2",
     "cors": "^2.8.5",
     "express": "^4.19.2",
+    "ioredis": "^5.4.1",
     "superstruct": "2.0.3-1",
     "winston": "^3.13.1"
   },

packages/indexer-api/src/controllers/balances.ts

@@ -1,30 +1,32 @@
 import { Request, Response, NextFunction } from "express";
 import * as s from "superstruct";
-import { DepositsService } from "../services/deposits";
+import { BalancesService } from "../services/balances";
 import {
-  HubPoolBalanceParams,
+  HubPoolBalanceQueryParams,
   SpokePoolBalanceParams,
 } from "../dtos/balances.dto";
 
 export class BalancesController {
-  constructor(private service: DepositsService) {}
+  constructor(private service: BalancesService) {}
 
-  public getHubPoolBalance = async (
+  public getHubPoolBalance = (
     req: Request,
     res: Response,
     next: NextFunction,
   ) => {
-    s.assert(req.query, HubPoolBalanceParams);
-    return 0;
+    req.query && s.assert(req.query, HubPoolBalanceQueryParams);
+    this.service
+      .hubPoolBalance(req.query)
+      .then((result) => res.json(result))
+      .catch((err) => next(err));
   };
 
-  public getSpokePoolBalance = async (
+  public getSpokePoolBalance = (
     req: Request,
     res: Response,
     next: NextFunction,
   ) => {
-    s.assert(req.query, SpokePoolBalanceParams);
-
-    return 0;
+    req.query && s.assert(req.query, SpokePoolBalanceParams);
+    res.json([]);
   };
 }

packages/indexer-api/src/dtos/balances.dto.ts

@@ -1,9 +1,8 @@
 import * as s from "superstruct";
 
 // query hub pools by chainId? default to 1 if not specified. will leave option in case of testnets?
-export const HubPoolBalanceParams = s.object({
-  chainId: s.defaulted(s.number(), 1),
-  l1Token: s.string(),
+export const HubPoolBalanceQueryParams = s.object({
+  l1Token: s.optional(s.string()),
 });
 
 // query spokepools by chainId, must specify

packages/indexer-api/src/main.ts

@@ -4,7 +4,38 @@ import { createDataSource, DatabaseConfig } from "@repo/indexer-database";
 import * as routers from "./routers";
 import winston from "winston";
 import { type Router } from "express";
+import Redis from "ioredis";
+import * as s from "superstruct";
+import * as Indexer from "@repo/indexer";
 
+async function initializeRedis(
+  config: Indexer.RedisConfig,
+  logger: winston.Logger,
+) {
+  const redis = new Redis({
+    ...config,
+  });
+
+  return new Promise<Redis>((resolve, reject) => {
+    redis.on("ready", () => {
+      logger.info({
+        at: "Indexer-API",
+        message: "Redis connection established",
+        config,
+      });
+      resolve(redis);
+    });
+
+    redis.on("error", (err) => {
+      logger.error({
+        at: "Indexer-API",
+        message: "Redis connection failed",
+        error: err,
+      });
+      reject(err);
+    });
+  });
+}
 export async function connectToDatabase(
   databaseConfig: DatabaseConfig,
   logger: winston.Logger,
@@ -52,9 +83,12 @@ export async function Main(
 
   const postgresConfig = getPostgresConfig(env);
   const postgres = await connectToDatabase(postgresConfig, logger);
+  const redisConfig = Indexer.parseRedisConfig(env);
+  const redis = await initializeRedis(redisConfig, logger);
 
   const allRouters: Record<string, Router> = {
     deposits: routers.deposits.getRouter(postgres),
+    balances: routers.balances.getRouter(redis),
   };
   const app = ExpressApp(allRouters);
 

packages/indexer-api/src/routers/balances.ts

@@ -0,0 +1,13 @@
+import { Router } from "express";
+import Redis from "ioredis";
+import { BalancesController } from "../controllers/balances";
+import { BalancesService } from "../services/balances";
+
+export function getRouter(redis: Redis): Router {
+  const router = Router();
+  const service = new BalancesService(redis);
+  const controller = new BalancesController(service);
+  router.get("/hubpool-balance", controller.getHubPoolBalance);
+  router.get("/spokepool-balance", controller.getSpokePoolBalance);
+  return router;
+}

packages/indexer-api/src/routers/index.ts

@@ -1 +1,2 @@
 export * as deposits from "./deposits";
+export * as balances from "./balances";

packages/indexer-api/src/services/balances.ts

@@ -0,0 +1,25 @@
+import assert from "assert";
+import Redis from "ioredis";
+import * as Indexer from "@repo/indexer";
+
+export class BalancesService {
+  hubBalancesCache: Indexer.redis.hubBalancesCache.HubPoolBalanceCache;
+  constructor(private redis: Redis) {
+    this.hubBalancesCache =
+      new Indexer.redis.hubBalancesCache.HubPoolBalanceCache({
+        redis,
+        prefix: "hubBalanceCache",
+      });
+  }
+  async hubPoolBalance(params?: {
+    l1Token?: string;
+  }): Promise<Indexer.redis.hubBalancesCache.HubPoolBalances> {
+    if (params?.l1Token) {
+      const balance = await this.hubBalancesCache.get(params.l1Token);
+      assert(balance, `No hubpoolBalance found for ${params.l1Token}`);
+      return [balance];
+    } else {
+      return this.hubBalancesCache.getAllL1Tokens();
+    }
+  }
+}

packages/indexer/src/index.ts

@@ -1,2 +1,3 @@
 export * from "./main";
 export * from "./parseEnv";
+export * as redis from "./redis";

packages/indexer/src/parseEnv.ts

@@ -17,7 +17,7 @@ export type ProviderConfig = [providerUrl: string, chainId: number];
 
 export type Env = Record<string, string | undefined>;
 
-function parseRedisConfig(env: Env): RedisConfig {
+export function parseRedisConfig(env: Env): RedisConfig {
   assert(env.REDIS_HOST, "requires REDIS_HOST");
   assert(env.REDIS_PORT, "requires REDIS_PORT");
   const port = parseNumber(env.REDIS_PORT);

packages/indexer/src/redis/index.ts

@@ -0,0 +1,4 @@
+export * as bundleLeavesCache from "./bundleLeavesCache";
+export * as hubBalancesCache from "./hubBalancesCache";
+export * as rangeQueryStore from "./rangeQueryStore";
+export * as redisCache from "./redisCache";