merge: resolve conflicts merging epbs-devnet-0 into te/epbs-devnet-0_syncing

Per Nico's requested flow:
1) branch from te/epbs-devnet-0_syncing (up to date, includes ChainSafe#8995 commit 6d6b2de)
2) merge epbs-devnet-0 (up to date)
3) resolve conflicts

Conflicts resolved in:
- ReqRespBeaconNode.ts
- handlers/executionPayloadEnvelopesByRange.ts
- reqresp/types.ts
- forkChoice/interface.ts

Also deduplicated merge duplicates in protocols/rateLimit/ssz type maps and aligned envelope handler callsites/tests.

Build/check-types/lint pass locally.

Author: lodekeeper

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

@@ -1007,17 +1007,18 @@ export function getValidatorApi(
 
       let index: CommitteeIndex;
       if (isForkPostGloas(fork)) {
-        // In Gloas (ePBS), attestation.data.index signals payload status in fork-choice:
-        // 0 = EMPTY / not present, 1 = FULL / present.
-        // Per spec, same-slot attestations must always use index = 0.
-        const canonicalAttestedBlock = chain.forkChoice.getCanonicalBlockClosestLteSlot(slot);
-        const isMatchingCanonicalRoot =
-          canonicalAttestedBlock !== null && canonicalAttestedBlock.blockRoot === toRootHex(beaconBlockRoot);
-
-        if (!isMatchingCanonicalRoot || canonicalAttestedBlock.slot === slot) {
-          index = 0;
+        const canonicalBlock = chain.forkChoice.getCanonicalBlockByRoot(beaconBlockRoot);
+        if (!canonicalBlock) {
+          // This should never happen
+          throw Error(`Block not found in fork choice for slot=${slot}, root=${toRootHex(beaconBlockRoot)}`);
+        }
+        // After Gloas, attestation.data.index signals payload status in fork-choice:
+        // - 0 = EMPTY / not present, 1 = FULL / present
+        // - same-slot attestations must always use index = 0
+        if (canonicalBlock.slot !== slot) {
+          index = canonicalBlock.payloadStatus === PayloadStatus.FULL ? 1 : 0;
         } else {
-          index = canonicalAttestedBlock.payloadStatus === PayloadStatus.FULL ? 1 : 0;
+          index = 0;
         }
       } else if (isForkPostElectra(fork)) {
         index = 0;

packages/beacon-node/src/network/reqresp/handlers/index.ts

@@ -64,15 +64,14 @@ export function getReqRespHandlers({db, chain}: {db: IBeaconDb; chain: IBeaconCh
       const body = DataColumnSidecarsByRootRequestType(chain.config).deserialize(req.data);
       return onDataColumnSidecarsByRoot(body, chain, db, peerId, peerClient);
     },
+    [ReqRespMethod.ExecutionPayloadEnvelopesByRange]: (req, peerId, peerClient) => {
+      const body = ssz.gloas.ExecutionPayloadEnvelopesByRangeRequest.deserialize(req.data);
+      return onExecutionPayloadEnvelopesByRange(body, chain, db);
+    },
     [ReqRespMethod.ExecutionPayloadEnvelopesByRoot]: (req) => {
       const body = ExecutionPayloadEnvelopesByRootRequestType(chain.config).deserialize(req.data);
       return onExecutionPayloadEnvelopesByRoot(body, chain, db);
     },
-    [ReqRespMethod.ExecutionPayloadEnvelopesByRange]: (req) => {
-      const body = ssz.gloas.ExecutionPayloadEnvelopesByRangeRequest.deserialize(req.data);
-      return onExecutionPayloadEnvelopesByRange(body, chain, db);
-    },
-
     [ReqRespMethod.LightClientBootstrap]: (req) => {
       const body = ssz.Root.deserialize(req.data);
       return onLightClientBootstrap(body, chain);

packages/beacon-node/src/network/reqresp/protocols.ts

@@ -94,14 +94,14 @@ export const DataColumnSidecarsByRoot = toProtocol({
   contextBytesType: ContextBytesType.ForkDigest,
 });
 
-export const ExecutionPayloadEnvelopesByRoot = toProtocol({
-  method: ReqRespMethod.ExecutionPayloadEnvelopesByRoot,
+export const ExecutionPayloadEnvelopesByRange = toProtocol({
+  method: ReqRespMethod.ExecutionPayloadEnvelopesByRange,
   version: Version.V1,
   contextBytesType: ContextBytesType.ForkDigest,
 });
 
-export const ExecutionPayloadEnvelopesByRange = toProtocol({
-  method: ReqRespMethod.ExecutionPayloadEnvelopesByRange,
+export const ExecutionPayloadEnvelopesByRoot = toProtocol({
+  method: ReqRespMethod.ExecutionPayloadEnvelopesByRoot,
   version: Version.V1,
   contextBytesType: ContextBytesType.ForkDigest,
 });

packages/beacon-node/src/network/reqresp/rateLimit.ts

@@ -73,24 +73,24 @@ export const rateLimitQuotas: (fork: ForkName, config: BeaconConfig) => Record<R
       req.reduce((total, item) => total + item.columns.length, 0)
     ),
   },
-  [ReqRespMethod.ExecutionPayloadEnvelopesByRoot]: {
-    // Rationale: similar to BeaconBlocksByRoot — one envelope per block
+  [ReqRespMethod.ExecutionPayloadEnvelopesByRange]: {
+    // Rationale: bounded by payload request limits
     byPeer: {quota: config.MAX_REQUEST_PAYLOADS, quotaTimeMs: 10_000},
     getRequestCount: getRequestCountFn(
       fork,
       config,
-      ReqRespMethod.ExecutionPayloadEnvelopesByRoot,
-      (req) => req.length
+      ReqRespMethod.ExecutionPayloadEnvelopesByRange,
+      (req) => req.count
     ),
   },
-  [ReqRespMethod.ExecutionPayloadEnvelopesByRange]: {
-    // Rationale: similar to BeaconBlocksByRange — one envelope per block
+  [ReqRespMethod.ExecutionPayloadEnvelopesByRoot]: {
+    // Rationale: similar to BeaconBlocksByRoot — one envelope per block
     byPeer: {quota: config.MAX_REQUEST_PAYLOADS, quotaTimeMs: 10_000},
     getRequestCount: getRequestCountFn(
       fork,
       config,
-      ReqRespMethod.ExecutionPayloadEnvelopesByRange,
-      (req) => req.count
+      ReqRespMethod.ExecutionPayloadEnvelopesByRoot,
+      (req) => req.length
     ),
   },
   [ReqRespMethod.LightClientBootstrap]: {

packages/beacon-node/src/network/reqresp/score.ts

@@ -55,6 +55,7 @@ export function onOutgoingReqRespError(e: RequestError, method: ReqRespMethod):
           return PeerAction.LowToleranceError;
         case ReqRespMethod.BeaconBlocksByRange:
         case ReqRespMethod.BeaconBlocksByRoot:
+        case ReqRespMethod.ExecutionPayloadEnvelopesByRange:
           return PeerAction.MidToleranceError;
         default:
           return null;

packages/beacon-node/test/unit/network/reqresp/executionPayloadEnvelopesByRange.test.ts

@@ -0,0 +1,165 @@
+import {describe, expect, it, vi} from "vitest";
+import {ForkName} from "@lodestar/params";
+import {ssz} from "@lodestar/types";
+import {toRootHex} from "@lodestar/utils";
+import {onExecutionPayloadEnvelopesByRange} from "../../../../src/network/reqresp/handlers/executionPayloadEnvelopesByRange.js";
+
+function rootWithByte(n: number): Uint8Array {
+  const root = new Uint8Array(32);
+  root[31] = n;
+  return root;
+}
+
+describe("beacon-node / network / reqresp / handlers / executionPayloadEnvelopesByRange", () => {
+  it("serves envelopes from finalized archive and non-finalized cache", async () => {
+    const finalizedEnvelope = ssz.gloas.SignedExecutionPayloadEnvelope.defaultValue();
+    finalizedEnvelope.message.slot = 64;
+    finalizedEnvelope.message.beaconBlockRoot = rootWithByte(64);
+
+    const hotEnvelope = ssz.gloas.SignedExecutionPayloadEnvelope.defaultValue();
+    hotEnvelope.message.slot = 65;
+    hotEnvelope.message.beaconBlockRoot = rootWithByte(65);
+
+    const archivedBySlot = new Map<number, typeof finalizedEnvelope>([[64, finalizedEnvelope]]);
+    const hotByRoot = new Map<string, typeof hotEnvelope>([
+      [toRootHex(hotEnvelope.message.beaconBlockRoot), hotEnvelope],
+    ]);
+
+    const chain = {
+      earliestAvailableSlot: 1,
+      logger: {verbose: vi.fn()},
+      config: {
+        SLOTS_PER_EPOCH: 32,
+        MAX_REQUEST_BLOCKS: 1024,
+        MAX_REQUEST_BLOCKS_DENEB: 128,
+        getForkName: () => ForkName.gloas,
+        getForkBoundaryAtEpoch: (epoch: number) => ({fork: ForkName.gloas, epoch}),
+      },
+      forkChoice: {
+        getFinalizedCheckpointSlot: () => 64,
+        getHeadRoot: () => "0xhead",
+        getBlockHexDefaultStatus: () => ({slot: 66, blockRoot: toRootHex(rootWithByte(66))}),
+        getAllAncestorBlocks: () => [
+          {slot: 66, blockRoot: toRootHex(rootWithByte(66))},
+          {slot: 65, blockRoot: toRootHex(rootWithByte(65))},
+          {slot: 64, blockRoot: toRootHex(rootWithByte(64))},
+        ],
+      },
+    } as any;
+
+    const db = {
+      executionPayloadEnvelopeArchive: {
+        get: vi.fn(async (slot: number) => archivedBySlot.get(slot) ?? null),
+      },
+      executionPayloadEnvelope: {
+        get: vi.fn(async (root: Uint8Array) => hotByRoot.get(toRootHex(root)) ?? null),
+      },
+    } as any;
+
+    const request = {startSlot: 64, count: 2};
+
+    const responses = [];
+    for await (const response of onExecutionPayloadEnvelopesByRange(request, chain, db)) {
+      responses.push(ssz.gloas.SignedExecutionPayloadEnvelope.deserialize(response.data));
+    }
+
+    expect(responses).toHaveLength(2);
+    expect(responses.map((e) => e.message.slot)).toEqual([64, 65]);
+  });
+
+  it("returns nothing for requests below earliestAvailableSlot", async () => {
+    const chain = {
+      earliestAvailableSlot: 10,
+      logger: {verbose: vi.fn()},
+      config: {
+        SLOTS_PER_EPOCH: 32,
+        MAX_REQUEST_BLOCKS: 1024,
+        MAX_REQUEST_BLOCKS_DENEB: 128,
+        getForkName: () => ForkName.gloas,
+        getForkBoundaryAtEpoch: (epoch: number) => ({fork: ForkName.gloas, epoch}),
+      },
+      forkChoice: {
+        getFinalizedCheckpointSlot: () => 0,
+        getHeadRoot: () => "0xhead",
+        getBlockHexDefaultStatus: () => undefined,
+        getAllAncestorBlocks: () => [],
+      },
+    } as any;
+
+    const db = {
+      executionPayloadEnvelopeArchive: {get: vi.fn()},
+      executionPayloadEnvelope: {get: vi.fn()},
+    } as any;
+
+    const request = {startSlot: 1, count: 1};
+
+    const responses = [];
+    for await (const response of onExecutionPayloadEnvelopesByRange(request, chain, db)) {
+      responses.push(response);
+    }
+
+    expect(responses).toHaveLength(0);
+    expect(chain.logger.verbose).toHaveBeenCalledTimes(1);
+    expect(db.executionPayloadEnvelopeArchive.get).not.toHaveBeenCalled();
+    expect(db.executionPayloadEnvelope.get).not.toHaveBeenCalled();
+  });
+
+  it("includes head envelope when ancestor list excludes head", async () => {
+    const finalizedEnvelope = ssz.gloas.SignedExecutionPayloadEnvelope.defaultValue();
+    finalizedEnvelope.message.slot = 64;
+    finalizedEnvelope.message.beaconBlockRoot = rootWithByte(64);
+
+    const headEnvelope = ssz.gloas.SignedExecutionPayloadEnvelope.defaultValue();
+    headEnvelope.message.slot = 66;
+    headEnvelope.message.beaconBlockRoot = rootWithByte(66);
+
+    const slot65Envelope = ssz.gloas.SignedExecutionPayloadEnvelope.defaultValue();
+    slot65Envelope.message.slot = 65;
+    slot65Envelope.message.beaconBlockRoot = rootWithByte(65);
+
+    const archivedBySlot = new Map<number, typeof finalizedEnvelope>([[64, finalizedEnvelope]]);
+    const hotByRoot = new Map<string, typeof headEnvelope>([
+      [toRootHex(headEnvelope.message.beaconBlockRoot), headEnvelope],
+      [toRootHex(slot65Envelope.message.beaconBlockRoot), slot65Envelope],
+    ]);
+
+    const chain = {
+      earliestAvailableSlot: 1,
+      logger: {verbose: vi.fn()},
+      config: {
+        SLOTS_PER_EPOCH: 32,
+        MAX_REQUEST_BLOCKS: 1024,
+        MAX_REQUEST_BLOCKS_DENEB: 128,
+        getForkName: () => ForkName.gloas,
+        getForkBoundaryAtEpoch: (epoch: number) => ({fork: ForkName.gloas, epoch}),
+      },
+      forkChoice: {
+        getFinalizedCheckpointSlot: () => 64,
+        getHeadRoot: () => "0xhead",
+        getBlockHexDefaultStatus: () => ({slot: 66, blockRoot: toRootHex(rootWithByte(66))}),
+        getAllAncestorBlocks: () => [
+          {slot: 65, blockRoot: toRootHex(rootWithByte(65))},
+          {slot: 64, blockRoot: toRootHex(rootWithByte(64))},
+        ],
+      },
+    } as any;
+
+    const db = {
+      executionPayloadEnvelopeArchive: {
+        get: vi.fn(async (slot: number) => archivedBySlot.get(slot) ?? null),
+      },
+      executionPayloadEnvelope: {
+        get: vi.fn(async (root: Uint8Array) => hotByRoot.get(toRootHex(root)) ?? null),
+      },
+    } as any;
+
+    const request = {startSlot: 64, count: 3};
+
+    const responses = [];
+    for await (const response of onExecutionPayloadEnvelopesByRange(request, chain, db)) {
+      responses.push(ssz.gloas.SignedExecutionPayloadEnvelope.deserialize(response.data));
+    }
+
+    expect(responses.map((e) => e.message.slot)).toEqual([64, 65, 66]);
+  });
+});

packages/fork-choice/src/forkChoice/forkChoice.ts

@@ -1239,6 +1239,21 @@ export class ForkChoice implements IForkChoice {
     };
   }
 
+  getCanonicalBlockByRoot(blockRoot: Root): ProtoBlock | null {
+    const blockRootHex = toRootHex(blockRoot);
+    if (blockRootHex === this.head.blockRoot) {
+      return this.head;
+    }
+
+    for (const block of this.protoArray.iterateAncestorNodes(this.head.blockRoot)) {
+      if (block.blockRoot === blockRootHex) {
+        return block;
+      }
+    }
+
+    return null;
+  }
+
   getCanonicalBlockAtSlot(slot: Slot): ProtoBlock | null {
     if (slot > this.head.slot) {
       return null;

packages/fork-choice/src/forkChoice/interface.ts

@@ -268,6 +268,7 @@ export interface IForkChoice {
     blockRoot: RootHex,
     payloadStatus: PayloadStatus
   ): {ancestors: ProtoBlock[]; nonAncestors: ProtoBlock[]};
+  getCanonicalBlockByRoot(blockRoot: Root): ProtoBlock | null;
   getCanonicalBlockAtSlot(slot: Slot): ProtoBlock | null;
   getCanonicalBlockClosestLteSlot(slot: Slot): ProtoBlock | null;
   /**