fix(fork-choice): port 3 upstream fixes from lodestar unstable

- Initialize anchor block PTC votes to all-true per spec get_forkchoice_store
- Reject same-slot full attestation votes and require FULL variant for index=1
- Add hasPayload to proto_array/fork_choice, refactor isPayloadTimely to use it

Author: GrapeBaBa

src/fork_choice/fork_choice.zig

@@ -77,6 +77,7 @@ pub const ForkChoiceError = ProtoArrayError || error{
     InvalidAttestationAttestsToFutureBlock,
     InvalidAttestationFutureSlot,
     InvalidAttestationInvalidDataIndex,
+    InvalidAttestationUnknownPayloadStatus,
     // InvalidBlock inner codes
     InvalidBlockUnknownParent,
     InvalidBlockFutureSlot,
@@ -808,9 +809,18 @@ pub const ForkChoice = struct {
         // the case, the attestation should not be considered.
         if (block.slot > slot) return error.InvalidAttestationAttestsToFutureBlock;
 
-        // INVALID_DATA_INDEX: For Gloas blocks, attestation index must be 0 or 1.
+        // Gloas attestation validation.
         const att_index = attestation.index();
-        if (block.isGloasBlock() and att_index != 0 and att_index != 1) return error.InvalidAttestationInvalidDataIndex;
+        if (block.isGloasBlock()) {
+            // INVALID_DATA_INDEX: For Gloas blocks, attestation index must be 0 or 1.
+            if (att_index != 0 and att_index != 1) return error.InvalidAttestationInvalidDataIndex;
+
+            // Same-slot attestations can only vote for the PENDING variant (index 0).
+            if (block.slot == slot and att_index != 0) return error.InvalidAttestationInvalidDataIndex;
+
+            // Voting for FULL (index=1) requires the FULL variant to exist.
+            if (att_index == 1 and !self.proto_array.hasPayload(block_root)) return error.InvalidAttestationUnknownPayloadStatus;
+        }
 
         // Cache validated attestation data root.
         try self.validated_attestation_datas.put(
@@ -1574,6 +1584,12 @@ pub const ForkChoice = struct {
         return self.proto_array.hasBlock(block_root);
     }
 
+    /// Returns true if the FULL payload variant (execution payload envelope) exists for this
+    /// block root, without checking finalized-descendant status.
+    pub fn hasPayloadUnsafe(self: *const ForkChoice, block_root: Root) bool {
+        return self.proto_array.hasPayload(block_root);
+    }
+
     /// Returns a `ProtoBlock` if the block is known **and** a descendant of the finalized root.
     pub fn getBlock(self: *const ForkChoice, block_root: Root, payload_status: PayloadStatus) ?ProtoBlock {
         const node = self.proto_array.getNode(block_root, payload_status) orelse return null;
@@ -4140,3 +4156,133 @@ test "onAttestation: equivocating validator votes are not counted" {
     try fc.updateHead(allocator);
     try testing.expectEqual(b_root, fc.head.block_root);
 }
+
+test "onAttestation: reject same-slot full vote for Gloas block" {
+    const allocator = testing.allocator;
+    const genesis_root = hashFromByte(0x01);
+    const block_root = hashFromByte(0x02);
+    const genesis_block = makeTestBlock(0, genesis_root, ZERO_HASH);
+    const balances = [_]u16{100} ** 2;
+
+    var fc = try initTestForkChoice(
+        allocator,
+        genesis_block,
+        10,
+        makeTestCheckpoint(0, genesis_root),
+        makeTestCheckpoint(0, genesis_root),
+        &balances,
+    );
+    defer deinitTestForkChoice(allocator, fc);
+
+    // Add a Gloas block at slot 1.
+    try onBlockFromProto(fc, allocator, makeGloasTestBlock(1, block_root, genesis_root, ZERO_HASH), 10);
+
+    // Same-slot attestation (slot=1) with index=1 (FULL vote) must be rejected.
+    const indices = [_]ValidatorIndex{0};
+    var att = makeTestIndexedAttestation(&indices, 1, block_root, 0, block_root, 0, genesis_root, 1);
+    const any_att = AnyIndexedAttestation{ .phase0 = &att };
+    try testing.expectError(
+        error.InvalidAttestationInvalidDataIndex,
+        fc.onAttestation(allocator, &any_att, hashFromByte(0xB1), false),
+    );
+}
+
+test "onAttestation: reject full vote when FULL variant missing" {
+    const allocator = testing.allocator;
+    const genesis_root = hashFromByte(0x01);
+    const block_root = hashFromByte(0x02);
+    const genesis_block = makeTestBlock(0, genesis_root, ZERO_HASH);
+    const balances = [_]u16{100} ** 2;
+
+    var fc = try initTestForkChoice(
+        allocator,
+        genesis_block,
+        10,
+        makeTestCheckpoint(0, genesis_root),
+        makeTestCheckpoint(0, genesis_root),
+        &balances,
+    );
+    defer deinitTestForkChoice(allocator, fc);
+
+    // Add a Gloas block at slot 1 (only PENDING + EMPTY, no FULL).
+    try onBlockFromProto(fc, allocator, makeGloasTestBlock(1, block_root, genesis_root, ZERO_HASH), 10);
+
+    // Attestation from a later slot (slot=2) with index=1 (FULL vote)
+    // must be rejected because no FULL variant exists yet.
+    const indices = [_]ValidatorIndex{0};
+    var att = makeTestIndexedAttestation(&indices, 2, block_root, 0, block_root, 0, genesis_root, 1);
+    const any_att = AnyIndexedAttestation{ .phase0 = &att };
+    try testing.expectError(
+        error.InvalidAttestationUnknownPayloadStatus,
+        fc.onAttestation(allocator, &any_att, hashFromByte(0xB2), false),
+    );
+}
+
+test "hasPayloadUnsafe reflects onExecutionPayload" {
+    const allocator = testing.allocator;
+    const genesis_root = hashFromByte(0x01);
+    const block_root = hashFromByte(0x02);
+    const genesis_block = makeTestBlock(0, genesis_root, ZERO_HASH);
+    const balances = [_]u16{100} ** 2;
+
+    var fc = try initTestForkChoice(
+        allocator,
+        genesis_block,
+        10,
+        makeTestCheckpoint(0, genesis_root),
+        makeTestCheckpoint(0, genesis_root),
+        &balances,
+    );
+    defer deinitTestForkChoice(allocator, fc);
+
+    // Pre-Gloas genesis always has payload.
+    try testing.expect(fc.hasPayloadUnsafe(genesis_root));
+
+    // Add Gloas block — no FULL yet.
+    try onBlockFromProto(fc, allocator, makeGloasTestBlock(1, block_root, genesis_root, ZERO_HASH), 10);
+    try testing.expect(!fc.hasPayloadUnsafe(block_root));
+
+    // After execution payload arrives, FULL exists.
+    try fc.onExecutionPayload(allocator, block_root, hashFromByte(0xEE), 1, ZERO_HASH, .valid);
+    try testing.expect(fc.hasPayloadUnsafe(block_root));
+}
+
+test "getCanonicalBlockByRoot finds ancestor on canonical chain" {
+    const allocator = testing.allocator;
+    const genesis_root = hashFromByte(0x01);
+    const a_root = hashFromByte(0x0A);
+    const b_root = hashFromByte(0x0B);
+    const genesis_block = makeTestBlock(0, genesis_root, ZERO_HASH);
+    const balances = [_]u16{100} ** 2;
+
+    var fc = try initTestForkChoice(
+        allocator,
+        genesis_block,
+        10,
+        makeTestCheckpoint(0, genesis_root),
+        makeTestCheckpoint(0, genesis_root),
+        &balances,
+    );
+    defer deinitTestForkChoice(allocator, fc);
+
+    try onBlockFromProto(fc, allocator, makeTestBlock(1, a_root, genesis_root), 10);
+    try onBlockFromProto(fc, allocator, makeTestBlock(2, b_root, a_root), 10);
+    try fc.updateHead(allocator);
+
+    // Head should be B (longest chain).
+    try testing.expectEqual(b_root, fc.head.block_root);
+
+    // A is on the canonical chain.
+    const found_a = try fc.getCanonicalBlockByRoot(a_root);
+    try testing.expect(found_a != null);
+    try testing.expectEqual(a_root, found_a.?.block_root);
+
+    // Head itself is found.
+    const found_b = try fc.getCanonicalBlockByRoot(b_root);
+    try testing.expect(found_b != null);
+    try testing.expectEqual(b_root, found_b.?.block_root);
+
+    // Non-existent root returns null.
+    const not_found = try fc.getCanonicalBlockByRoot(hashFromByte(0xFF));
+    try testing.expect(not_found == null);
+}

src/fork_choice/proto_array.zig

@@ -561,6 +561,13 @@ pub const ProtoArray = struct {
         anchor.target_root = block.block_root;
 
         try self.onBlock(allocator, anchor, current_slot, null);
+
+        // Anchor block PTC votes must be all-true per spec get_forkchoice_store:
+        // payload_timeliness_vote={anchor_root: Vector[boolean, PTC_SIZE](True for _ in range(PTC_SIZE))}
+        // Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.4/specs/gloas/fork-choice.md#modified-get_forkchoice_store
+        if (self.ptc_votes.getPtr(block.block_root)) |votes| {
+            votes.* = PtcVotes.initFull();
+        }
     }
 
     // ── Accessors ──
@@ -600,6 +607,16 @@ pub const ProtoArray = struct {
         return self.indices.contains(root);
     }
 
+    /// Returns true if the FULL payload variant exists for this block root.
+    /// This means the SignedExecutionPayloadEnvelope has been received and processed.
+    pub fn hasPayload(self: *const ProtoArray, root: Root) bool {
+        const vi = self.indices.get(root) orelse return false;
+        return switch (vi) {
+            .pre_gloas => true, // Pre-Gloas blocks always have their payload.
+            .gloas => |g| g.full != null,
+        };
+    }
+
     // ── onBlock ──
 
     /// Register a block with the fork choice. It is only sane to supply
@@ -1710,12 +1727,8 @@ pub const ProtoArray = struct {
         // Block not found or not a Gloas block.
         const votes = self.ptc_votes.get(block_root) orelse return false;
 
-        // Payload is locally available if proto array
-        // has FULL variant of the block.
-        if (self.getNodeIndexByRootAndStatus(
-            block_root,
-            .full,
-        ) == null) return false;
+        // Payload is locally available if FULL variant exists.
+        if (!self.hasPayload(block_root)) return false;
 
         // Count votes for payload_present=true.
         return votes.count() > PAYLOAD_TIMELY_THRESHOLD;
@@ -5171,3 +5184,40 @@ test "invalid node not re-validated by valid LVH" {
     // B must remain invalid — the valid response must NOT resurrect it.
     try testing.expectEqual(ExecutionStatus.invalid, pa.nodes.items[idx_b].extra_meta.executionStatus());
 }
+
+test "initialize sets Gloas anchor PTC votes to all-true" {
+    var pa: ProtoArray = undefined;
+    pa.init(0, ZERO_HASH, 0, ZERO_HASH, 0);
+    defer pa.deinit(testing.allocator);
+
+    const root = makeRoot(1);
+    const anchor = TestBlock.asGloas(TestBlock.withRoot(root));
+    try pa.initialize(testing.allocator, anchor, 0);
+
+    // Anchor block PTC votes must be all-true per spec get_forkchoice_store.
+    const votes = pa.ptc_votes.get(root).?;
+    try testing.expectEqual(preset.PTC_SIZE, votes.count());
+}
+
+test "hasPayload returns false before and true after onExecutionPayload" {
+    var pa: ProtoArray = undefined;
+    pa.init(0, ZERO_HASH, 0, ZERO_HASH, 0);
+    defer pa.deinit(testing.allocator);
+
+    // Pre-Gloas block always has payload.
+    const pre_gloas_root = makeRoot(0xAA);
+    try pa.onBlock(testing.allocator, TestBlock.genesis(), 0, null);
+    try testing.expect(pa.hasPayload(ZERO_HASH));
+
+    // Gloas block: no FULL variant yet.
+    const root = makeRoot(1);
+    try pa.onBlock(testing.allocator, TestBlock.asGloas(TestBlock.withRoot(root)), 0, null);
+    try testing.expect(!pa.hasPayload(root));
+
+    // After onExecutionPayload, FULL variant exists.
+    try pa.onExecutionPayload(testing.allocator, root, 0, makeRoot(0xBB), 42, ZERO_HASH, null, .valid);
+    try testing.expect(pa.hasPayload(root));
+
+    // Unknown root returns false.
+    try testing.expect(!pa.hasPayload(pre_gloas_root));
+}