feat: add debug_getHistoricalSummaries endpoint

packages/api/src/beacon/routes/lodestar.ts

@@ -1,8 +1,10 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {Epoch, RootHex, Slot} from "@lodestar/types";
+import {Epoch, RootHex, Slot, ssz} from "@lodestar/types";
 import {
+  ArrayOf,
   EmptyArgs,
   EmptyMeta,
+  EmptyMetaCodec,
   EmptyRequest,
   EmptyRequestCodec,
   EmptyResponseCodec,
@@ -11,6 +13,8 @@ import {
 } from "../../utils/codecs.js";
 import {Endpoint, RouteDefinitions, Schema} from "../../utils/index.js";
 import {FilterGetPeers, NodePeer, PeerDirection, PeerState} from "./node.js";
+import {ContainerType, ValueOf} from "@chainsafe/ssz";
+import {StateArgs} from "./beacon/state.js";
 
 // See /packages/api/src/routes/index.ts for reasoning and instructions to add new routes
 
@@ -75,6 +79,15 @@ export type LodestarNodePeer = NodePeer & {
 
 export type LodestarThreadType = "main" | "network" | "discv5";
 
+type HistoricalSummariesList = ValueOf<typeof HistoricalSummariesResponseType>;
+const HistoricalSummariesResponseType = new ContainerType(
+  {
+    HistoricalSummaries: ssz.capella.HistoricalSummaries,
+    proof: ArrayOf(ssz.Bytes8),
+  },
+  {jsonCase: "eth2"}
+);
+
 export type Endpoints = {
   /** Trigger to write a heapdump to disk at `dirpath`. May take > 1min */
   writeHeapdump: Endpoint<
@@ -247,6 +260,9 @@ export type Endpoints = {
     {root: RootHex; slot: Slot}[],
     EmptyMeta
   >;
+
+  /** Returns historical summaries and proof for a given state ID */
+  getHistoricalSummaries: Endpoint<"GET", StateArgs, {params: {state_id: string}}, HistoricalSummariesList, EmptyMeta>;
 };
 
 export function getDefinitions(_config: ChainForkConfig): RouteDefinitions<Endpoints> {
@@ -387,5 +403,20 @@ export function getDefinitions(_config: ChainForkConfig): RouteDefinitions<Endpo
       req: EmptyRequestCodec,
       resp: JsonOnlyResponseCodec,
     },
+    getHistoricalSummaries: {
+      url: "/eth/v0/lodestar/historical_summaries/{state_id}",
+      method: "GET",
+      req: {
+        writeReq: ({stateId}) => ({params: {state_id: stateId.toString()}}),
+        parseReq: ({params}) => ({stateId: params.state_id}),
+        schema: {
+          params: {state_id: Schema.StringRequired},
+        },
+      },
+      resp: {
+        data: HistoricalSummariesResponseType,
+        meta: EmptyMetaCodec,
+      },
+    },
   };
 }

packages/api/test/unit/beacon/genericServerTest/lodestar.test.ts

@@ -0,0 +1,54 @@
+import {config} from "@lodestar/config/default";
+import {FastifyInstance} from "fastify";
+import {afterAll, beforeAll, describe, expect, it, vi} from "vitest";
+import {getClient} from "../../../../src/beacon/client/lodestar.js";
+import {Endpoints, getDefinitions} from "../../../../src/beacon/routes/lodestar.js";
+import {getRoutes} from "../../../../src/beacon/server/lodestar.js";
+import {HttpClient} from "../../../../src/utils/client/httpClient.js";
+import {AnyEndpoint} from "../../../../src/utils/codecs.js";
+import {FastifyRoute} from "../../../../src/utils/server/index.js";
+import {WireFormat} from "../../../../src/utils/wireFormat.js";
+import {getMockApi, getTestServer} from "../../../utils/utils.js";
+
+describe("lodestar", () => {
+  describe("get HistoricalSummaries as json", () => {
+    const mockApi = getMockApi<Endpoints>(getDefinitions(config));
+    let baseUrl: string;
+    let server: FastifyInstance;
+
+    beforeAll(async () => {
+      const res = getTestServer();
+      server = res.server;
+      for (const route of Object.values(getRoutes(config, mockApi))) {
+        server.route(route as FastifyRoute<AnyEndpoint>);
+      }
+      baseUrl = await res.start();
+    });
+
+    afterAll(async () => {
+      if (server !== undefined) await server.close();
+    });
+
+    it("getHistoricalSummaries", async () => {
+      mockApi.getHistoricalSummaries.mockResolvedValue({
+        data: {
+          HistoricalSummaries: [],
+          proof: [],
+        },
+      });
+
+      const httpClient = new HttpClient({baseUrl});
+      const client = getClient(config, httpClient);
+
+      const res = await client.getHistoricalSummaries({stateId: "head"}, {responseWireFormat: WireFormat.json});
+
+      expect(res.ok).toBe(true);
+      expect(res.wireFormat()).toBe(WireFormat.json);
+      expect(res.json().data).toStrictEqual({
+        // biome-ignore lint/style/useNamingConvention: <explanation>
+        Historical_summaries: [],
+        proof: [],
+      });
+    });
+  });
+});

packages/beacon-node/src/api/impl/debug/index.ts

@@ -2,7 +2,7 @@ import {routes} from "@lodestar/api";
 import {ApplicationMethods} from "@lodestar/api/server";
 import {ExecutionStatus} from "@lodestar/fork-choice";
 import {ZERO_HASH_HEX} from "@lodestar/params";
-import {BeaconState} from "@lodestar/types";
+import {BeaconState, ssz} from "@lodestar/types";
 import {isOptimisticBlock} from "../../../util/forkChoice.js";
 import {getStateSlotFromBytes} from "../../../util/multifork.js";
 import {getStateResponseWithRegen} from "../beacon/state/utils.js";

packages/beacon-node/src/api/impl/lodestar/index.ts

@@ -4,8 +4,8 @@ import {routes} from "@lodestar/api";
 import {ApplicationMethods} from "@lodestar/api/server";
 import {ChainForkConfig} from "@lodestar/config";
 import {Repository} from "@lodestar/db";
-import {SLOTS_PER_EPOCH} from "@lodestar/params";
-import {getLatestWeakSubjectivityCheckpointEpoch} from "@lodestar/state-transition";
+import {ForkName, ForkSeq, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {getLatestWeakSubjectivityCheckpointEpoch, loadState} from "@lodestar/state-transition";
 import {ssz} from "@lodestar/types";
 import {toHex, toRootHex} from "@lodestar/utils";
 import {BeaconChain} from "../../../chain/index.js";
@@ -14,6 +14,9 @@ import {IBeaconDb} from "../../../db/interface.js";
 import {GossipType} from "../../../network/index.js";
 import {profileNodeJS, writeHeapSnapshot} from "../../../util/profile.js";
 import {ApiModules} from "../types.js";
+import {Tree} from "@chainsafe/persistent-merkle-tree";
+import {getStateSlotFromBytes} from "../../../index.js";
+import {getStateResponseWithRegen} from "../beacon/state/utils.js";
 
 export function getLodestarApi({
   chain,
@@ -187,6 +190,33 @@ export function getLodestarApi({
     async dumpDbStateIndex() {
       return {data: await db.stateArchive.dumpRootIndexEntries()};
     },
+    async getHistoricalSummaries({stateId}, _context) {
+      const {state} = await getStateResponseWithRegen(chain, stateId);
+      let slot: number;
+      if (state instanceof Uint8Array) {
+        slot = getStateSlotFromBytes(state);
+      } else {
+        slot = state.slot;
+      }
+      if (config.getForkSeq(slot) < ForkSeq.capella) {
+        throw new Error("Historical summaries are not supported before Capella");
+      }
+      const fork = config.getForkName(slot) as Exclude<ForkName, "phase0" | "altair" | "bellatrix">;
+
+      const stateView =
+        state instanceof Uint8Array ? loadState(config, chain.getHeadState(), state).state : state.clone();
+
+      const gindex = ssz[fork].BeaconState.getPathInfo(["historicalSummaries"]);
+      const proof = new Tree(stateView.node).getSingleProof(gindex.gindex);
+
+      return {
+        data: {
+          // biome-ignore lint/suspicious/noExplicitAny: state is definitely Capella or later based on above check
+          HistoricalSummaries: (stateView as any).historicalSummaries.toValue(),
+          proof: proof,
+        },
+      };
+    },
   };
 }
 

packages/types/src/capella/sszTypes.ts

@@ -125,6 +125,10 @@ export const HistoricalSummary = new ContainerType(
   {typeName: "HistoricalSummary", jsonCase: "eth2"}
 );
 
+export const HistoricalSummaries = new ListCompositeType(HistoricalSummary, HISTORICAL_ROOTS_LIMIT, {
+  typeName: "HistoricalSummaries",
+});
+
 // we don't reuse bellatrix.BeaconState fields since we need to replace some keys
 // and we cannot keep order doing that
 export const BeaconState = new ContainerType(
@@ -168,7 +172,7 @@ export const BeaconState = new ContainerType(
     nextWithdrawalIndex: WithdrawalIndex, // [New in Capella]
     nextWithdrawalValidatorIndex: ValidatorIndex, // [New in Capella]
     // Deep history valid from Capella onwards
-    historicalSummaries: new ListCompositeType(HistoricalSummary, HISTORICAL_ROOTS_LIMIT), // [New in Capella]
+    historicalSummaries: HistoricalSummaries, // [New in Capella]
   },
   {typeName: "BeaconState", jsonCase: "eth2"}
 );