Write changelog

CHANGELOG.md

@@ -4,44 +4,6 @@ All notable changes to this project will be documented in this file.
 
 The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.
 
-## [v6.1.3](https://github.com/prysmaticlabs/prysm/compare/v6.1.2...v6.1.3) - 2025-10-20
-
-This release has several important beacon API and p2p fixes.
-
-### Added
-
-- Add Grandine to P2P known agents. (Useful for metrics). [[PR]](https://github.com/prysmaticlabs/prysm/pull/15829)
-- Delegate sszInfo HashTreeRoot to FastSSZ-generated implementations via SSZObject, enabling roots calculation for generated types while avoiding duplicate logic. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15805)
-- SSZ-QL: Use `fastssz`'s `SizeSSZ` method for calculating the size of `Container` type. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15864)
-- SSZ-QL: Access n-th element in `List`/`Vector`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15767)
-
-### Changed
-
-- Do not verify block data when calculating rewards. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15819)
-- Process pending attestations after pending blocks are cleared. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15824)
-- updated web3signer to 25.9.1. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15832)
-- Gracefully handle submit blind block returning 502 errors. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15848)
-- Improve returning individual message errors from Beacon API. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15835)
-- SSZ-QL: Clarify `Size` method with more sophisticated `SSZType`s. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15864)
-
-### Fixed
-
-- Use service context and continue on slasher attestation errors (#15803). [[PR]](https://github.com/prysmaticlabs/prysm/pull/15803)
-- block event probably shouldn't be sent on certain block processing failures, now sends only on successing processing Block is NON-CANONICAL, Block IS CANONICAL but getFCUArgs FAILS, and Full success. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15814)
-- Fixed web3signer e2e, issues caused due to a regression on old fork support. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15832)
-- Do not mark blocks as invalid from ErrNotDescendantOfFinalized. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15846)
-- Fixed [#15812](https://github.com/OffchainLabs/prysm/issues/15812): Gossip attestation validation incorrectly rejecting attestations that arrive before their referenced blocks. Previously, attestations were saved to the pending queue but immediately rejected by forkchoice validation, causing "not descendant of finalized checkpoint" errors. Now attestations for missing blocks return `ValidationIgnore` without error, allowing them to be properly processed when their blocks arrive. This eliminates false positive rejections and prevents potential incorrect peer downscoring during network congestion. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15840)
-- Mark the block as invalid if it has an invalid signature. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15847)
-- Display error messages from the server verbatim when they are not encoded as `application/json`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15860)
-- `HasAtLeastOneIndex`: Check the index is not too high. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15865)
-- Fix `/eth/v1/beacon/blob_sidecars/` beacon API is the fulu fork epoch is set to the far future epoch. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15867)
-- `dataColumnSidecarsByRangeRPCHandler`: Gracefully close the stream if no data to return. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15866)
-- `VerifyDataColumnSidecar`: Check if there is no too many commitments. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15859)
-- `WithDataColumnRetentionEpochs`: Use `dataColumnRetentionEpoch` instead of `blobColumnRetentionEpoch`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15872)
-- Mark epoch transition correctly on new head events. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15871)
-- reject committee index >= committees_per_slot in unaggregated attestation validation. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15855)
-- Decreased attestation gossip validation batch deadline to 5ms. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15882)
-
 ## [v6.1.2](https://github.com/prysmaticlabs/prysm/compare/v6.1.1...v6.1.2) - 2025-10-10
 
 This release has several important fixes to improve Prysm's peering, stability, and attestation inclusion on mainnet and all testnets. All node operators are encouraged to update to this release as soon as practical for the best mainnet performance.
@@ -3797,4 +3759,4 @@ There are no security updates in this release.
 
 # Older than v2.0.0
 
-For changelog history for releases older than v2.0.0, please refer to https://github.com/prysmaticlabs/prysm/releases
+For changelog history for releases older than v2.0.0, please refer to https://github.com/prysmaticlabs/prysm/releases

WORKSPACE

@@ -253,16 +253,16 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.6.0-beta.1"
+consensus_spec_version = "v1.6.0-beta.0"
 
 load("@prysm//tools:download_spectests.bzl", "consensus_spec_tests")
 
 consensus_spec_tests(
     name = "consensus_spec_tests",
     flavors = {
-        "general": "sha256-oEj0MTViJHjZo32nABK36gfvSXpbwkBk/jt6Mj7pWFI=",
-        "minimal": "sha256-cS4NPv6IRBoCSmWomQ8OEo8IsVNW9YawUFqoRZQBUj4=",
-        "mainnet": "sha256-BYuLndMPAh4p13IRJgNfVakrCVL69KRrNw2tdc3ETbE=",
+        "general": "sha256-rT3jQp2+ZaDiO66gIQggetzqr+kGeexaLqEhbx4HDMY=",
+        "minimal": "sha256-wowwwyvd0KJLsE+oDOtPkrhZyJndJpJ0lbXYsLH6XBw=",
+        "mainnet": "sha256-4ZLrLNeO7NihZ4TuWH5V5fUhvW9Y3mAPBQDCqrfShps=",
     },
     version = consensus_spec_version,
 )
@@ -278,7 +278,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-yrq3tdwPS8Ri+ueeLAHssIT3ssMrX7zvHiJ8Xf9GVYs=",
+    integrity = "sha256-sBe3Rx8zGq9IrvfgIhZQpYidGjy3mE1SiCb6/+pjLdY=",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )

api/client/BUILD.bazel

@@ -6,7 +6,6 @@ go_library(
         "client.go",
         "errors.go",
         "options.go",
-        "transport.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v6/api/client",
     visibility = ["//visibility:public"],
@@ -15,13 +14,7 @@ go_library(
 
 go_test(
     name = "go_default_test",
-    srcs = [
-        "client_test.go",
-        "transport_test.go",
-    ],
+    srcs = ["client_test.go"],
     embed = [":go_default_library"],
-    deps = [
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-    ],
+    deps = ["//testing/require:go_default_library"],
 )

api/client/transport.go

@@ -1,25 +0,0 @@
-package client
-
-import "net/http"
-
-// CustomHeadersTransport adds custom headers to each request
-type CustomHeadersTransport struct {
-	base    http.RoundTripper
-	headers map[string][]string
-}
-
-func NewCustomHeadersTransport(base http.RoundTripper, headers map[string][]string) *CustomHeadersTransport {
-	return &CustomHeadersTransport{
-		base:    base,
-		headers: headers,
-	}
-}
-
-func (t *CustomHeadersTransport) RoundTrip(req *http.Request) (*http.Response, error) {
-	for header, values := range t.headers {
-		for _, value := range values {
-			req.Header.Add(header, value)
-		}
-	}
-	return t.base.RoundTrip(req)
-}

api/client/transport_test.go

@@ -1,25 +0,0 @@
-package client
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/testing/assert"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-)
-
-type noopTransport struct{}
-
-func (*noopTransport) RoundTrip(*http.Request) (*http.Response, error) {
-	return nil, nil
-}
-
-func TestRoundTrip(t *testing.T) {
-	tr := &CustomHeadersTransport{base: &noopTransport{}, headers: map[string][]string{"key1": []string{"value1", "value2"}, "key2": []string{"value3"}}}
-	req := httptest.NewRequest("GET", "http://foo", nil)
-	_, err := tr.RoundTrip(req)
-	require.NoError(t, err)
-	assert.DeepEqual(t, []string{"value1", "value2"}, req.Header.Values("key1"))
-	assert.DeepEqual(t, []string{"value3"}, req.Header.Values("key2"))
-}

api/server/structs/endpoints_beacon.go

@@ -296,8 +296,3 @@ type GetBlobsResponse struct {
 	Finalized           bool     `json:"finalized"`
 	Data                []string `json:"data"` //blobs
 }
-
-type SSZQueryRequest struct {
-	Query        string `json:"query"`
-	IncludeProof bool   `json:"include_proof,omitempty"`
-}

beacon-chain/blockchain/BUILD.bazel

@@ -173,7 +173,6 @@ go_test(
         "//beacon-chain/state/state-native:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
         "//beacon-chain/verification:go_default_library",
-        "//cmd/beacon-chain/flags:go_default_library",
         "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",

beacon-chain/blockchain/service.go

@@ -493,7 +493,7 @@ func (s *Service) updateCustodyInfoInDB(slot primitives.Slot) (primitives.Slot,
 	// Compute the custody group count.
 	custodyGroupCount := custodyRequirement
 	if isSubscribedToAllDataSubnets {
-		custodyGroupCount = beaconConfig.NumberOfCustodyGroups
+		custodyGroupCount = beaconConfig.NumberOfColumns
 	}
 
 	// Safely compute the fulu fork slot.

beacon-chain/blockchain/service_test.go

@@ -23,11 +23,9 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 	state_native "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/stategen"
-	"github.com/OffchainLabs/prysm/v6/cmd/beacon-chain/flags"
 	"github.com/OffchainLabs/prysm/v6/config/features"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	consensusblocks "github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
@@ -598,103 +596,3 @@ func TestNotifyIndex(t *testing.T) {
 		t.Errorf("Notifier channel did not receive the index")
 	}
 }
-
-func TestUpdateCustodyInfoInDB(t *testing.T) {
-	const (
-		fuluForkEpoch         = 10
-		custodyRequirement    = uint64(4)
-		earliestStoredSlot    = primitives.Slot(12)
-		numberOfCustodyGroups = uint64(64)
-		numberOfColumns       = uint64(128)
-	)
-
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig()
-	cfg.FuluForkEpoch = fuluForkEpoch
-	cfg.CustodyRequirement = custodyRequirement
-	cfg.NumberOfCustodyGroups = numberOfCustodyGroups
-	cfg.NumberOfColumns = numberOfColumns
-	params.OverrideBeaconConfig(cfg)
-
-	ctx := t.Context()
-	pbBlock := util.NewBeaconBlock()
-	pbBlock.Block.Slot = 12
-	signedBeaconBlock, err := blocks.NewSignedBeaconBlock(pbBlock)
-	require.NoError(t, err)
-
-	roBlock, err := blocks.NewROBlock(signedBeaconBlock)
-	require.NoError(t, err)
-
-	t.Run("CGC increases before fulu", func(t *testing.T) {
-		service, requirements := minimalTestService(t)
-		err = requirements.db.SaveBlock(ctx, roBlock)
-		require.NoError(t, err)
-
-		// Before Fulu
-		// -----------
-		actualEas, actualCgc, err := service.updateCustodyInfoInDB(15)
-		require.NoError(t, err)
-		require.Equal(t, earliestStoredSlot, actualEas)
-		require.Equal(t, custodyRequirement, actualCgc)
-
-		actualEas, actualCgc, err = service.updateCustodyInfoInDB(17)
-		require.NoError(t, err)
-		require.Equal(t, earliestStoredSlot, actualEas)
-		require.Equal(t, custodyRequirement, actualCgc)
-
-		resetFlags := flags.Get()
-		gFlags := new(flags.GlobalFlags)
-		gFlags.SubscribeAllDataSubnets = true
-		flags.Init(gFlags)
-		defer flags.Init(resetFlags)
-
-		actualEas, actualCgc, err = service.updateCustodyInfoInDB(19)
-		require.NoError(t, err)
-		require.Equal(t, earliestStoredSlot, actualEas)
-		require.Equal(t, numberOfCustodyGroups, actualCgc)
-
-		// After Fulu
-		// ----------
-		actualEas, actualCgc, err = service.updateCustodyInfoInDB(fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1)
-		require.NoError(t, err)
-		require.Equal(t, earliestStoredSlot, actualEas)
-		require.Equal(t, numberOfCustodyGroups, actualCgc)
-	})
-
-	t.Run("CGC increases after fulu", func(t *testing.T) {
-		service, requirements := minimalTestService(t)
-		err = requirements.db.SaveBlock(ctx, roBlock)
-		require.NoError(t, err)
-
-		// Before Fulu
-		// -----------
-		actualEas, actualCgc, err := service.updateCustodyInfoInDB(15)
-		require.NoError(t, err)
-		require.Equal(t, earliestStoredSlot, actualEas)
-		require.Equal(t, custodyRequirement, actualCgc)
-
-		actualEas, actualCgc, err = service.updateCustodyInfoInDB(17)
-		require.NoError(t, err)
-		require.Equal(t, earliestStoredSlot, actualEas)
-		require.Equal(t, custodyRequirement, actualCgc)
-
-		// After Fulu
-		// ----------
-		resetFlags := flags.Get()
-		gFlags := new(flags.GlobalFlags)
-		gFlags.SubscribeAllDataSubnets = true
-		flags.Init(gFlags)
-		defer flags.Init(resetFlags)
-
-		slot := fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1
-		actualEas, actualCgc, err = service.updateCustodyInfoInDB(slot)
-		require.NoError(t, err)
-		require.Equal(t, slot, actualEas)
-		require.Equal(t, numberOfCustodyGroups, actualCgc)
-
-		actualEas, actualCgc, err = service.updateCustodyInfoInDB(slot + 2)
-		require.NoError(t, err)
-		require.Equal(t, slot, actualEas)
-		require.Equal(t, numberOfCustodyGroups, actualCgc)
-	})
-}

beacon-chain/blockchain/setup_test.go

@@ -130,14 +130,6 @@ func (dch *mockCustodyManager) UpdateCustodyInfo(earliestAvailableSlot primitive
 	return earliestAvailableSlot, custodyGroupCount, nil
 }
 
-func (dch *mockCustodyManager) UpdateEarliestAvailableSlot(earliestAvailableSlot primitives.Slot) error {
-	dch.mut.Lock()
-	defer dch.mut.Unlock()
-
-	dch.earliestAvailableSlot = earliestAvailableSlot
-	return nil
-}
-
 func (dch *mockCustodyManager) CustodyGroupCountFromPeer(peer.ID) uint64 {
 	return 0
 }

beacon-chain/core/altair/upgrade.go

@@ -12,46 +12,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1/attestation"
 )
 
-// ConvertToAltair converts a Phase 0 beacon state to an Altair beacon state.
-func ConvertToAltair(state state.BeaconState) (state.BeaconState, error) {
-	epoch := time.CurrentEpoch(state)
-
-	numValidators := state.NumValidators()
-	s := &ethpb.BeaconStateAltair{
-		GenesisTime:           uint64(state.GenesisTime().Unix()),
-		GenesisValidatorsRoot: state.GenesisValidatorsRoot(),
-		Slot:                  state.Slot(),
-		Fork: &ethpb.Fork{
-			PreviousVersion: state.Fork().CurrentVersion,
-			CurrentVersion:  params.BeaconConfig().AltairForkVersion,
-			Epoch:           epoch,
-		},
-		LatestBlockHeader:           state.LatestBlockHeader(),
-		BlockRoots:                  state.BlockRoots(),
-		StateRoots:                  state.StateRoots(),
-		HistoricalRoots:             state.HistoricalRoots(),
-		Eth1Data:                    state.Eth1Data(),
-		Eth1DataVotes:               state.Eth1DataVotes(),
-		Eth1DepositIndex:            state.Eth1DepositIndex(),
-		Validators:                  state.Validators(),
-		Balances:                    state.Balances(),
-		RandaoMixes:                 state.RandaoMixes(),
-		Slashings:                   state.Slashings(),
-		PreviousEpochParticipation:  make([]byte, numValidators),
-		CurrentEpochParticipation:   make([]byte, numValidators),
-		JustificationBits:           state.JustificationBits(),
-		PreviousJustifiedCheckpoint: state.PreviousJustifiedCheckpoint(),
-		CurrentJustifiedCheckpoint:  state.CurrentJustifiedCheckpoint(),
-		FinalizedCheckpoint:         state.FinalizedCheckpoint(),
-		InactivityScores:            make([]uint64, numValidators),
-	}
-	newState, err := state_native.InitializeFromProtoUnsafeAltair(s)
-	if err != nil {
-		return nil, err
-	}
-	return newState, nil
-}
-
 // UpgradeToAltair updates input state to return the version Altair state.
 //
 // Spec code:
@@ -104,7 +64,39 @@ func ConvertToAltair(state state.BeaconState) (state.BeaconState, error) {
 //	post.next_sync_committee = get_next_sync_committee(post)
 //	return post
 func UpgradeToAltair(ctx context.Context, state state.BeaconState) (state.BeaconState, error) {
-	newState, err := ConvertToAltair(state)
+	epoch := time.CurrentEpoch(state)
+
+	numValidators := state.NumValidators()
+	s := &ethpb.BeaconStateAltair{
+		GenesisTime:           uint64(state.GenesisTime().Unix()),
+		GenesisValidatorsRoot: state.GenesisValidatorsRoot(),
+		Slot:                  state.Slot(),
+		Fork: &ethpb.Fork{
+			PreviousVersion: state.Fork().CurrentVersion,
+			CurrentVersion:  params.BeaconConfig().AltairForkVersion,
+			Epoch:           epoch,
+		},
+		LatestBlockHeader:           state.LatestBlockHeader(),
+		BlockRoots:                  state.BlockRoots(),
+		StateRoots:                  state.StateRoots(),
+		HistoricalRoots:             state.HistoricalRoots(),
+		Eth1Data:                    state.Eth1Data(),
+		Eth1DataVotes:               state.Eth1DataVotes(),
+		Eth1DepositIndex:            state.Eth1DepositIndex(),
+		Validators:                  state.Validators(),
+		Balances:                    state.Balances(),
+		RandaoMixes:                 state.RandaoMixes(),
+		Slashings:                   state.Slashings(),
+		PreviousEpochParticipation:  make([]byte, numValidators),
+		CurrentEpochParticipation:   make([]byte, numValidators),
+		JustificationBits:           state.JustificationBits(),
+		PreviousJustifiedCheckpoint: state.PreviousJustifiedCheckpoint(),
+		CurrentJustifiedCheckpoint:  state.CurrentJustifiedCheckpoint(),
+		FinalizedCheckpoint:         state.FinalizedCheckpoint(),
+		InactivityScores:            make([]uint64, numValidators),
+	}
+
+	newState, err := state_native.InitializeFromProtoUnsafeAltair(s)
 	if err != nil {
 		return nil, err
 	}

beacon-chain/core/blocks/genesis.go

@@ -192,46 +192,6 @@ func NewGenesisBlockForState(ctx context.Context, st state.BeaconState) (interfa
 			Block:     electraGenesisBlock(root),
 			Signature: params.BeaconConfig().EmptySignature[:],
 		})
-	case *ethpb.BeaconStateGloas:
-		return blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockGloas{
-			Block: &ethpb.BeaconBlockGloas{
-				ParentRoot: params.BeaconConfig().ZeroHash[:],
-				StateRoot:  root[:],
-				Body: &ethpb.BeaconBlockBodyGloas{
-					RandaoReveal: make([]byte, 96),
-					Eth1Data: &ethpb.Eth1Data{
-						DepositRoot: make([]byte, 32),
-						BlockHash:   make([]byte, 32),
-					},
-					Graffiti: make([]byte, 32),
-					SyncAggregate: &ethpb.SyncAggregate{
-						SyncCommitteeBits:      make([]byte, fieldparams.SyncCommitteeLength/8),
-						SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
-					},
-					ExecutionPayload: &enginev1.ExecutionPayloadGloas{
-						ParentHash:    make([]byte, 32),
-						FeeRecipient:  make([]byte, 20),
-						StateRoot:     make([]byte, 32),
-						ReceiptsRoot:  make([]byte, 32),
-						LogsBloom:     make([]byte, 256),
-						PrevRandao:    make([]byte, 32),
-						ExtraData:     make([]byte, 0),
-						BaseFeePerGas: make([]byte, 32),
-						BlockHash:     make([]byte, 32),
-						Transactions:  make([][]byte, 0),
-						Withdrawals:   make([]*enginev1.Withdrawal, 0),
-					},
-					BlsToExecutionChanges: make([]*ethpb.SignedBLSToExecutionChange, 0),
-					BlobKzgCommitments:    make([][]byte, 0),
-					ExecutionRequests: &enginev1.ExecutionRequests{
-						Withdrawals:    make([]*enginev1.WithdrawalRequest, 0),
-						Deposits:       make([]*enginev1.DepositRequest, 0),
-						Consolidations: make([]*enginev1.ConsolidationRequest, 0),
-					},
-				},
-			},
-			Signature: params.BeaconConfig().EmptySignature[:],
-		})
 	default:
 		return nil, ErrUnrecognizedState
 	}

beacon-chain/core/electra/upgrade.go

@@ -15,129 +15,6 @@ import (
 	"github.com/pkg/errors"
 )
 
-// ConvertToElectra converts a Deneb beacon state to an Electra beacon state. It does not perform any fork logic.
-func ConvertToElectra(beaconState state.BeaconState) (state.BeaconState, error) {
-	currentSyncCommittee, err := beaconState.CurrentSyncCommittee()
-	if err != nil {
-		return nil, err
-	}
-	nextSyncCommittee, err := beaconState.NextSyncCommittee()
-	if err != nil {
-		return nil, err
-	}
-	prevEpochParticipation, err := beaconState.PreviousEpochParticipation()
-	if err != nil {
-		return nil, err
-	}
-	currentEpochParticipation, err := beaconState.CurrentEpochParticipation()
-	if err != nil {
-		return nil, err
-	}
-	inactivityScores, err := beaconState.InactivityScores()
-	if err != nil {
-		return nil, err
-	}
-	payloadHeader, err := beaconState.LatestExecutionPayloadHeader()
-	if err != nil {
-		return nil, err
-	}
-	txRoot, err := payloadHeader.TransactionsRoot()
-	if err != nil {
-		return nil, err
-	}
-	wdRoot, err := payloadHeader.WithdrawalsRoot()
-	if err != nil {
-		return nil, err
-	}
-	wi, err := beaconState.NextWithdrawalIndex()
-	if err != nil {
-		return nil, err
-	}
-	vi, err := beaconState.NextWithdrawalValidatorIndex()
-	if err != nil {
-		return nil, err
-	}
-	summaries, err := beaconState.HistoricalSummaries()
-	if err != nil {
-		return nil, err
-	}
-	excessBlobGas, err := payloadHeader.ExcessBlobGas()
-	if err != nil {
-		return nil, err
-	}
-	blobGasUsed, err := payloadHeader.BlobGasUsed()
-	if err != nil {
-		return nil, err
-	}
-
-	s := &ethpb.BeaconStateElectra{
-		GenesisTime:           uint64(beaconState.GenesisTime().Unix()),
-		GenesisValidatorsRoot: beaconState.GenesisValidatorsRoot(),
-		Slot:                  beaconState.Slot(),
-		Fork: &ethpb.Fork{
-			PreviousVersion: beaconState.Fork().CurrentVersion,
-			CurrentVersion:  params.BeaconConfig().ElectraForkVersion,
-			Epoch:           time.CurrentEpoch(beaconState),
-		},
-		LatestBlockHeader:           beaconState.LatestBlockHeader(),
-		BlockRoots:                  beaconState.BlockRoots(),
-		StateRoots:                  beaconState.StateRoots(),
-		HistoricalRoots:             beaconState.HistoricalRoots(),
-		Eth1Data:                    beaconState.Eth1Data(),
-		Eth1DataVotes:               beaconState.Eth1DataVotes(),
-		Eth1DepositIndex:            beaconState.Eth1DepositIndex(),
-		Validators:                  beaconState.Validators(),
-		Balances:                    beaconState.Balances(),
-		RandaoMixes:                 beaconState.RandaoMixes(),
-		Slashings:                   beaconState.Slashings(),
-		PreviousEpochParticipation:  prevEpochParticipation,
-		CurrentEpochParticipation:   currentEpochParticipation,
-		JustificationBits:           beaconState.JustificationBits(),
-		PreviousJustifiedCheckpoint: beaconState.PreviousJustifiedCheckpoint(),
-		CurrentJustifiedCheckpoint:  beaconState.CurrentJustifiedCheckpoint(),
-		FinalizedCheckpoint:         beaconState.FinalizedCheckpoint(),
-		InactivityScores:            inactivityScores,
-		CurrentSyncCommittee:        currentSyncCommittee,
-		NextSyncCommittee:           nextSyncCommittee,
-		LatestExecutionPayloadHeader: &enginev1.ExecutionPayloadHeaderDeneb{
-			ParentHash:       payloadHeader.ParentHash(),
-			FeeRecipient:     payloadHeader.FeeRecipient(),
-			StateRoot:        payloadHeader.StateRoot(),
-			ReceiptsRoot:     payloadHeader.ReceiptsRoot(),
-			LogsBloom:        payloadHeader.LogsBloom(),
-			PrevRandao:       payloadHeader.PrevRandao(),
-			BlockNumber:      payloadHeader.BlockNumber(),
-			GasLimit:         payloadHeader.GasLimit(),
-			GasUsed:          payloadHeader.GasUsed(),
-			Timestamp:        payloadHeader.Timestamp(),
-			ExtraData:        payloadHeader.ExtraData(),
-			BaseFeePerGas:    payloadHeader.BaseFeePerGas(),
-			BlockHash:        payloadHeader.BlockHash(),
-			TransactionsRoot: txRoot,
-			WithdrawalsRoot:  wdRoot,
-			ExcessBlobGas:    excessBlobGas,
-			BlobGasUsed:      blobGasUsed,
-		},
-		NextWithdrawalIndex:          wi,
-		NextWithdrawalValidatorIndex: vi,
-		HistoricalSummaries:          summaries,
-
-		DepositRequestsStartIndex:  params.BeaconConfig().UnsetDepositRequestsStartIndex,
-		DepositBalanceToConsume:    0,
-		EarliestConsolidationEpoch: helpers.ActivationExitEpoch(slots.ToEpoch(beaconState.Slot())),
-		PendingDeposits:            make([]*ethpb.PendingDeposit, 0),
-		PendingPartialWithdrawals:  make([]*ethpb.PendingPartialWithdrawal, 0),
-		PendingConsolidations:      make([]*ethpb.PendingConsolidation, 0),
-	}
-
-	// need to cast the beaconState to use in helper functions
-	post, err := state_native.InitializeFromProtoUnsafeElectra(s)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to initialize post electra beaconState")
-	}
-	return post, nil
-}
-
 // UpgradeToElectra updates inputs a generic state to return the version Electra state.
 //
 // nolint:dupword
@@ -249,7 +126,55 @@ func ConvertToElectra(beaconState state.BeaconState) (state.BeaconState, error)
 //
 //	return post
 func UpgradeToElectra(beaconState state.BeaconState) (state.BeaconState, error) {
-	s, err := ConvertToElectra(beaconState)
+	currentSyncCommittee, err := beaconState.CurrentSyncCommittee()
+	if err != nil {
+		return nil, err
+	}
+	nextSyncCommittee, err := beaconState.NextSyncCommittee()
+	if err != nil {
+		return nil, err
+	}
+	prevEpochParticipation, err := beaconState.PreviousEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	currentEpochParticipation, err := beaconState.CurrentEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	inactivityScores, err := beaconState.InactivityScores()
+	if err != nil {
+		return nil, err
+	}
+	payloadHeader, err := beaconState.LatestExecutionPayloadHeader()
+	if err != nil {
+		return nil, err
+	}
+	txRoot, err := payloadHeader.TransactionsRoot()
+	if err != nil {
+		return nil, err
+	}
+	wdRoot, err := payloadHeader.WithdrawalsRoot()
+	if err != nil {
+		return nil, err
+	}
+	wi, err := beaconState.NextWithdrawalIndex()
+	if err != nil {
+		return nil, err
+	}
+	vi, err := beaconState.NextWithdrawalValidatorIndex()
+	if err != nil {
+		return nil, err
+	}
+	summaries, err := beaconState.HistoricalSummaries()
+	if err != nil {
+		return nil, err
+	}
+	excessBlobGas, err := payloadHeader.ExcessBlobGas()
+	if err != nil {
+		return nil, err
+	}
+	blobGasUsed, err := payloadHeader.BlobGasUsed()
 	if err != nil {
 		return nil, err
 	}
@@ -281,38 +206,97 @@ func UpgradeToElectra(beaconState state.BeaconState) (state.BeaconState, error)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to get total active balance")
 	}
-	if err := s.SetExitBalanceToConsume(helpers.ActivationExitChurnLimit(primitives.Gwei(tab))); err != nil {
-		return nil, errors.Wrap(err, "failed to set exit balance to consume")
-	}
-	if err := s.SetEarliestExitEpoch(earliestExitEpoch); err != nil {
-		return nil, errors.Wrap(err, "failed to set earliest exit epoch")
-	}
-	if err := s.SetConsolidationBalanceToConsume(helpers.ConsolidationChurnLimit(primitives.Gwei(tab))); err != nil {
-		return nil, errors.Wrap(err, "failed to set consolidation balance to consume")
+
+	s := &ethpb.BeaconStateElectra{
+		GenesisTime:           uint64(beaconState.GenesisTime().Unix()),
+		GenesisValidatorsRoot: beaconState.GenesisValidatorsRoot(),
+		Slot:                  beaconState.Slot(),
+		Fork: &ethpb.Fork{
+			PreviousVersion: beaconState.Fork().CurrentVersion,
+			CurrentVersion:  params.BeaconConfig().ElectraForkVersion,
+			Epoch:           time.CurrentEpoch(beaconState),
+		},
+		LatestBlockHeader:           beaconState.LatestBlockHeader(),
+		BlockRoots:                  beaconState.BlockRoots(),
+		StateRoots:                  beaconState.StateRoots(),
+		HistoricalRoots:             beaconState.HistoricalRoots(),
+		Eth1Data:                    beaconState.Eth1Data(),
+		Eth1DataVotes:               beaconState.Eth1DataVotes(),
+		Eth1DepositIndex:            beaconState.Eth1DepositIndex(),
+		Validators:                  beaconState.Validators(),
+		Balances:                    beaconState.Balances(),
+		RandaoMixes:                 beaconState.RandaoMixes(),
+		Slashings:                   beaconState.Slashings(),
+		PreviousEpochParticipation:  prevEpochParticipation,
+		CurrentEpochParticipation:   currentEpochParticipation,
+		JustificationBits:           beaconState.JustificationBits(),
+		PreviousJustifiedCheckpoint: beaconState.PreviousJustifiedCheckpoint(),
+		CurrentJustifiedCheckpoint:  beaconState.CurrentJustifiedCheckpoint(),
+		FinalizedCheckpoint:         beaconState.FinalizedCheckpoint(),
+		InactivityScores:            inactivityScores,
+		CurrentSyncCommittee:        currentSyncCommittee,
+		NextSyncCommittee:           nextSyncCommittee,
+		LatestExecutionPayloadHeader: &enginev1.ExecutionPayloadHeaderDeneb{
+			ParentHash:       payloadHeader.ParentHash(),
+			FeeRecipient:     payloadHeader.FeeRecipient(),
+			StateRoot:        payloadHeader.StateRoot(),
+			ReceiptsRoot:     payloadHeader.ReceiptsRoot(),
+			LogsBloom:        payloadHeader.LogsBloom(),
+			PrevRandao:       payloadHeader.PrevRandao(),
+			BlockNumber:      payloadHeader.BlockNumber(),
+			GasLimit:         payloadHeader.GasLimit(),
+			GasUsed:          payloadHeader.GasUsed(),
+			Timestamp:        payloadHeader.Timestamp(),
+			ExtraData:        payloadHeader.ExtraData(),
+			BaseFeePerGas:    payloadHeader.BaseFeePerGas(),
+			BlockHash:        payloadHeader.BlockHash(),
+			TransactionsRoot: txRoot,
+			WithdrawalsRoot:  wdRoot,
+			ExcessBlobGas:    excessBlobGas,
+			BlobGasUsed:      blobGasUsed,
+		},
+		NextWithdrawalIndex:          wi,
+		NextWithdrawalValidatorIndex: vi,
+		HistoricalSummaries:          summaries,
+
+		DepositRequestsStartIndex:     params.BeaconConfig().UnsetDepositRequestsStartIndex,
+		DepositBalanceToConsume:       0,
+		ExitBalanceToConsume:          helpers.ActivationExitChurnLimit(primitives.Gwei(tab)),
+		EarliestExitEpoch:             earliestExitEpoch,
+		ConsolidationBalanceToConsume: helpers.ConsolidationChurnLimit(primitives.Gwei(tab)),
+		EarliestConsolidationEpoch:    helpers.ActivationExitEpoch(slots.ToEpoch(beaconState.Slot())),
+		PendingDeposits:               make([]*ethpb.PendingDeposit, 0),
+		PendingPartialWithdrawals:     make([]*ethpb.PendingPartialWithdrawal, 0),
+		PendingConsolidations:         make([]*ethpb.PendingConsolidation, 0),
 	}
 
 	// Sorting preActivationIndices based on a custom criteria
-	vals := s.Validators()
 	sort.Slice(preActivationIndices, func(i, j int) bool {
 		// Comparing based on ActivationEligibilityEpoch and then by index if the epochs are the same
-		if vals[preActivationIndices[i]].ActivationEligibilityEpoch == vals[preActivationIndices[j]].ActivationEligibilityEpoch {
+		if s.Validators[preActivationIndices[i]].ActivationEligibilityEpoch == s.Validators[preActivationIndices[j]].ActivationEligibilityEpoch {
 			return preActivationIndices[i] < preActivationIndices[j]
 		}
-		return vals[preActivationIndices[i]].ActivationEligibilityEpoch < vals[preActivationIndices[j]].ActivationEligibilityEpoch
+		return s.Validators[preActivationIndices[i]].ActivationEligibilityEpoch < s.Validators[preActivationIndices[j]].ActivationEligibilityEpoch
 	})
 
+	// need to cast the beaconState to use in helper functions
+	post, err := state_native.InitializeFromProtoUnsafeElectra(s)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to initialize post electra beaconState")
+	}
+
 	for _, index := range preActivationIndices {
-		if err := QueueEntireBalanceAndResetValidator(s, index); err != nil {
+		if err := QueueEntireBalanceAndResetValidator(post, index); err != nil {
 			return nil, errors.Wrap(err, "failed to queue entire balance and reset validator")
 		}
 	}
 
 	// Ensure early adopters of compounding credentials go through the activation churn
 	for _, index := range compoundWithdrawalIndices {
-		if err := QueueExcessActiveBalance(s, index); err != nil {
+		if err := QueueExcessActiveBalance(post, index); err != nil {
 			return nil, errors.Wrap(err, "failed to queue excess active balance")
 		}
 	}
 
-	return s, nil
+	return post, nil
 }

beacon-chain/core/execution/BUILD.bazel

@@ -7,7 +7,6 @@ go_library(
     visibility = [
         "//beacon-chain:__subpackages__",
         "//cmd/prysmctl/testnet:__pkg__",
-        "//consensus-types/hdiff:__subpackages__",
         "//testing/spectest:__subpackages__",
         "//validator/client:__pkg__",
     ],

beacon-chain/core/fulu/BUILD.bazel

@@ -15,7 +15,6 @@ go_library(
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/primitives:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/core/fulu/upgrade.go

@@ -8,7 +8,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	state_native "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native"
 	"github.com/OffchainLabs/prysm/v6/config/params"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
@@ -18,25 +17,6 @@ import (
 // UpgradeToFulu updates inputs a generic state to return the version Fulu state.
 // https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/fork.md#upgrading-the-state
 func UpgradeToFulu(ctx context.Context, beaconState state.BeaconState) (state.BeaconState, error) {
-	s, err := ConvertToFulu(beaconState)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not convert to fulu")
-	}
-	proposerLookahead, err := helpers.InitializeProposerLookahead(ctx, beaconState, slots.ToEpoch(beaconState.Slot()))
-	if err != nil {
-		return nil, err
-	}
-	pl := make([]primitives.ValidatorIndex, len(proposerLookahead))
-	for i, v := range proposerLookahead {
-		pl[i] = primitives.ValidatorIndex(v)
-	}
-	if err := s.SetProposerLookahead(pl); err != nil {
-		return nil, errors.Wrap(err, "failed to set proposer lookahead")
-	}
-	return s, nil
-}
-
-func ConvertToFulu(beaconState state.BeaconState) (state.BeaconState, error) {
 	currentSyncCommittee, err := beaconState.CurrentSyncCommittee()
 	if err != nil {
 		return nil, err
@@ -125,6 +105,11 @@ func ConvertToFulu(beaconState state.BeaconState) (state.BeaconState, error) {
 	if err != nil {
 		return nil, err
 	}
+	proposerLookahead, err := helpers.InitializeProposerLookahead(ctx, beaconState, slots.ToEpoch(beaconState.Slot()))
+	if err != nil {
+		return nil, err
+	}
+
 	s := &ethpb.BeaconStateFulu{
 		GenesisTime:           uint64(beaconState.GenesisTime().Unix()),
 		GenesisValidatorsRoot: beaconState.GenesisValidatorsRoot(),
@@ -186,6 +171,14 @@ func ConvertToFulu(beaconState state.BeaconState) (state.BeaconState, error) {
 		PendingDeposits:               pendingDeposits,
 		PendingPartialWithdrawals:     pendingPartialWithdrawals,
 		PendingConsolidations:         pendingConsolidations,
+		ProposerLookahead:             proposerLookahead,
 	}
-	return state_native.InitializeFromProtoUnsafeFulu(s)
+
+	// Need to cast the beaconState to use in helper functions
+	post, err := state_native.InitializeFromProtoUnsafeFulu(s)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to initialize post fulu beaconState")
+	}
+
+	return post, nil
 }

beacon-chain/core/gloas/BUILD.bazel

@@ -1,19 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["upgrade.go"],
-    importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/core/gloas",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/time:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/state-native:go_default_library",
-        "//config/params:go_default_library",
-        "//proto/engine/v1:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-    ],
-)

beacon-chain/core/gloas/upgrade.go

@@ -1,189 +0,0 @@
-package gloas
-
-import (
-	"context"
-
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/time"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
-	state_native "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native"
-	"github.com/OffchainLabs/prysm/v6/config/params"
-	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v6/time/slots"
-	"github.com/pkg/errors"
-)
-
-// UpgradeToGloas updates inputs a generic state to return the version Gloas state.
-// This implements the upgrade_to_eip7928 function from the specification.
-func UpgradeToGloas(ctx context.Context, beaconState state.BeaconState) (state.BeaconState, error) {
-	epoch := time.CurrentEpoch(beaconState)
-
-	currentSyncCommittee, err := beaconState.CurrentSyncCommittee()
-	if err != nil {
-		return nil, err
-	}
-	nextSyncCommittee, err := beaconState.NextSyncCommittee()
-	if err != nil {
-		return nil, err
-	}
-	prevEpochParticipation, err := beaconState.PreviousEpochParticipation()
-	if err != nil {
-		return nil, err
-	}
-	currentEpochParticipation, err := beaconState.CurrentEpochParticipation()
-	if err != nil {
-		return nil, err
-	}
-	inactivityScores, err := beaconState.InactivityScores()
-	if err != nil {
-		return nil, err
-	}
-	payloadHeader, err := beaconState.LatestExecutionPayloadHeader()
-	if err != nil {
-		return nil, err
-	}
-	txRoot, err := payloadHeader.TransactionsRoot()
-	if err != nil {
-		return nil, err
-	}
-	wdRoot, err := payloadHeader.WithdrawalsRoot()
-	if err != nil {
-		return nil, err
-	}
-	wi, err := beaconState.NextWithdrawalIndex()
-	if err != nil {
-		return nil, err
-	}
-	vi, err := beaconState.NextWithdrawalValidatorIndex()
-	if err != nil {
-		return nil, err
-	}
-	summaries, err := beaconState.HistoricalSummaries()
-	if err != nil {
-		return nil, err
-	}
-	excessBlobGas, err := payloadHeader.ExcessBlobGas()
-	if err != nil {
-		return nil, err
-	}
-	blobGasUsed, err := payloadHeader.BlobGasUsed()
-	if err != nil {
-		return nil, err
-	}
-	depositRequestsStartIndex, err := beaconState.DepositRequestsStartIndex()
-	if err != nil {
-		return nil, err
-	}
-	depositBalanceToConsume, err := beaconState.DepositBalanceToConsume()
-	if err != nil {
-		return nil, err
-	}
-	exitBalanceToConsume, err := beaconState.ExitBalanceToConsume()
-	if err != nil {
-		return nil, err
-	}
-	earliestExitEpoch, err := beaconState.EarliestExitEpoch()
-	if err != nil {
-		return nil, err
-	}
-	consolidationBalanceToConsume, err := beaconState.ConsolidationBalanceToConsume()
-	if err != nil {
-		return nil, err
-	}
-	earliestConsolidationEpoch, err := beaconState.EarliestConsolidationEpoch()
-	if err != nil {
-		return nil, err
-	}
-	pendingDeposits, err := beaconState.PendingDeposits()
-	if err != nil {
-		return nil, err
-	}
-	pendingPartialWithdrawals, err := beaconState.PendingPartialWithdrawals()
-	if err != nil {
-		return nil, err
-	}
-	pendingConsolidations, err := beaconState.PendingConsolidations()
-	if err != nil {
-		return nil, err
-	}
-	proposerLookahead, err := helpers.InitializeProposerLookahead(ctx, beaconState, slots.ToEpoch(beaconState.Slot()))
-	if err != nil {
-		return nil, err
-	}
-
-	// Create the new Gloas execution payload header with block_access_list_root
-	// as specified in the EIP7928 upgrade function
-	latestExecutionPayloadHeader := &enginev1.ExecutionPayloadHeaderGloas{
-		ParentHash:          payloadHeader.ParentHash(),
-		FeeRecipient:        payloadHeader.FeeRecipient(),
-		StateRoot:           payloadHeader.StateRoot(),
-		ReceiptsRoot:        payloadHeader.ReceiptsRoot(),
-		LogsBloom:           payloadHeader.LogsBloom(),
-		PrevRandao:          payloadHeader.PrevRandao(),
-		BlockNumber:         payloadHeader.BlockNumber(),
-		GasLimit:            payloadHeader.GasLimit(),
-		GasUsed:             payloadHeader.GasUsed(),
-		Timestamp:           payloadHeader.Timestamp(),
-		ExtraData:           payloadHeader.ExtraData(),
-		BaseFeePerGas:       payloadHeader.BaseFeePerGas(),
-		BlockHash:           payloadHeader.BlockHash(),
-		TransactionsRoot:    txRoot,
-		WithdrawalsRoot:     wdRoot,
-		BlobGasUsed:         blobGasUsed,
-		ExcessBlobGas:       excessBlobGas,
-		BlockAccessListRoot: make([]byte, 32), // New in EIP7928 - empty Root()
-	}
-
-	s := &ethpb.BeaconStateGloas{
-		GenesisTime:           uint64(beaconState.GenesisTime().Unix()),
-		GenesisValidatorsRoot: beaconState.GenesisValidatorsRoot(),
-		Slot:                  beaconState.Slot(),
-		Fork: &ethpb.Fork{
-			PreviousVersion: beaconState.Fork().CurrentVersion,
-			CurrentVersion:  params.BeaconConfig().GloasForkVersion, // Modified in EIP7928
-			Epoch:           epoch,
-		},
-		LatestBlockHeader:             beaconState.LatestBlockHeader(),
-		BlockRoots:                    beaconState.BlockRoots(),
-		StateRoots:                    beaconState.StateRoots(),
-		HistoricalRoots:               beaconState.HistoricalRoots(),
-		Eth1Data:                      beaconState.Eth1Data(),
-		Eth1DataVotes:                 beaconState.Eth1DataVotes(),
-		Eth1DepositIndex:              beaconState.Eth1DepositIndex(),
-		Validators:                    beaconState.Validators(),
-		Balances:                      beaconState.Balances(),
-		RandaoMixes:                   beaconState.RandaoMixes(),
-		Slashings:                     beaconState.Slashings(),
-		PreviousEpochParticipation:    prevEpochParticipation,
-		CurrentEpochParticipation:     currentEpochParticipation,
-		JustificationBits:             beaconState.JustificationBits(),
-		PreviousJustifiedCheckpoint:   beaconState.PreviousJustifiedCheckpoint(),
-		CurrentJustifiedCheckpoint:    beaconState.CurrentJustifiedCheckpoint(),
-		FinalizedCheckpoint:           beaconState.FinalizedCheckpoint(),
-		InactivityScores:              inactivityScores,
-		CurrentSyncCommittee:          currentSyncCommittee,
-		NextSyncCommittee:             nextSyncCommittee,
-		LatestExecutionPayloadHeader:  latestExecutionPayloadHeader,
-		NextWithdrawalIndex:           wi,
-		NextWithdrawalValidatorIndex:  vi,
-		HistoricalSummaries:           summaries,
-		DepositRequestsStartIndex:     depositRequestsStartIndex,
-		DepositBalanceToConsume:       depositBalanceToConsume,
-		ExitBalanceToConsume:          exitBalanceToConsume,
-		EarliestExitEpoch:             earliestExitEpoch,
-		ConsolidationBalanceToConsume: consolidationBalanceToConsume,
-		EarliestConsolidationEpoch:    earliestConsolidationEpoch,
-		PendingDeposits:               pendingDeposits,
-		PendingPartialWithdrawals:     pendingPartialWithdrawals,
-		PendingConsolidations:         pendingConsolidations,
-		ProposerLookahead:             proposerLookahead,
-	}
-
-	post, err := state_native.InitializeFromProtoUnsafeGloas(s)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to initialize post gloas beaconState")
-	}
-
-	return post, nil
-}

beacon-chain/core/helpers/weak_subjectivity.go

@@ -201,3 +201,14 @@ func ParseWeakSubjectivityInputString(wsCheckpointString string) (*v1alpha1.Chec
 		Root:  bRoot,
 	}, nil
 }
+
+// MinEpochsForBlockRequests computes the number of epochs of block history that we need to maintain,
+// relative to the current epoch, per the p2p specs. This is used to compute the slot where backfill is complete.
+// value defined:
+// https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/p2p-interface.md#configuration
+// MIN_VALIDATOR_WITHDRAWABILITY_DELAY + CHURN_LIMIT_QUOTIENT // 2 (= 33024, ~5 months)
+// detailed rationale: https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/p2p-interface.md#why-are-blocksbyrange-requests-only-required-to-be-served-for-the-latest-min_epochs_for_block_requests-epochs
+func MinEpochsForBlockRequests() primitives.Epoch {
+	return params.BeaconConfig().MinValidatorWithdrawabilityDelay +
+		primitives.Epoch(params.BeaconConfig().ChurnLimitQuotient/2)
+}

beacon-chain/core/helpers/weak_subjectivity_test.go

@@ -286,3 +286,20 @@ func genState(t *testing.T, valCount, avgBalance uint64) state.BeaconState {
 	return beaconState
 }
 
+func TestMinEpochsForBlockRequests(t *testing.T) {
+	helpers.ClearCache()
+
+	params.SetActiveTestCleanup(t, params.MainnetConfig())
+	var expected primitives.Epoch = 33024
+	// expected value of 33024 via spec commentary:
+	// https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/p2p-interface.md#why-are-blocksbyrange-requests-only-required-to-be-served-for-the-latest-min_epochs_for_block_requests-epochs
+	//	MIN_EPOCHS_FOR_BLOCK_REQUESTS is calculated using the arithmetic from compute_weak_subjectivity_period found in the weak subjectivity guide. Specifically to find this max epoch range, we use the worst case event of a very large validator size (>= MIN_PER_EPOCH_CHURN_LIMIT * CHURN_LIMIT_QUOTIENT).
+	//
+	//	MIN_EPOCHS_FOR_BLOCK_REQUESTS = (
+	//	    MIN_VALIDATOR_WITHDRAWABILITY_DELAY
+	//	    + MAX_SAFETY_DECAY * CHURN_LIMIT_QUOTIENT // (2 * 100)
+	//	)
+	//
+	//	Where MAX_SAFETY_DECAY = 100 and thus MIN_EPOCHS_FOR_BLOCK_REQUESTS = 33024 (~5 months).
+	require.Equal(t, expected, helpers.MinEpochsForBlockRequests())
+}

beacon-chain/core/peerdas/p2p_interface.go

@@ -79,30 +79,10 @@ func VerifyDataColumnsSidecarKZGProofs(sidecars []blocks.RODataColumn) error {
 
 	for _, sidecar := range sidecars {
 		for i := range sidecar.Column {
-			var (
-				commitment kzg.Bytes48
-				cell       kzg.Cell
-				proof      kzg.Bytes48
-			)
-
-			commitmentBytes := sidecar.KzgCommitments[i]
-			cellBytes := sidecar.Column[i]
-			proofBytes := sidecar.KzgProofs[i]
-
-			if len(commitmentBytes) != len(commitment) ||
-				len(cellBytes) != len(cell) ||
-				len(proofBytes) != len(proof) {
-				return ErrMismatchLength
-			}
-
-			copy(commitment[:], commitmentBytes)
-			copy(cell[:], cellBytes)
-			copy(proof[:], proofBytes)
-
-			commitments = append(commitments, commitment)
+			commitments = append(commitments, kzg.Bytes48(sidecar.KzgCommitments[i]))
 			indices = append(indices, sidecar.Index)
-			cells = append(cells, cell)
-			proofs = append(proofs, proof)
+			cells = append(cells, kzg.Cell(sidecar.Column[i]))
+			proofs = append(proofs, kzg.Bytes48(sidecar.KzgProofs[i]))
 		}
 	}
 

beacon-chain/core/peerdas/p2p_interface_test.go

@@ -68,14 +68,6 @@ func TestVerifyDataColumnSidecarKZGProofs(t *testing.T) {
 	err := kzg.Start()
 	require.NoError(t, err)
 
-	t.Run("size mismatch", func(t *testing.T) {
-		sidecars := generateRandomSidecars(t, seed, blobCount)
-		sidecars[0].Column[0] = sidecars[0].Column[0][:len(sidecars[0].Column[0])-1] // Remove one byte to create size mismatch
-
-		err := peerdas.VerifyDataColumnsSidecarKZGProofs(sidecars)
-		require.ErrorIs(t, err, peerdas.ErrMismatchLength)
-	})
-
 	t.Run("invalid proof", func(t *testing.T) {
 		sidecars := generateRandomSidecars(t, seed, blobCount)
 		sidecars[0].Column[0][0]++ // It is OK to overflow

beacon-chain/core/time/slot_epoch.go

@@ -108,12 +108,6 @@ func CanUpgradeToFulu(slot primitives.Slot) bool {
 	return epochStart && fuluEpoch
 }
 
-func CanUpgradeToGloas(slot primitives.Slot) bool {
-	epochStart := slots.IsEpochStart(slot)
-	gloasEpoch := slots.ToEpoch(slot) == params.BeaconConfig().GloasForkEpoch
-	return epochStart && gloasEpoch
-}
-
 // CanProcessEpoch checks the eligibility to process epoch.
 // The epoch can be processed at the end of the last slot of every epoch.
 //

beacon-chain/core/transition/BUILD.bazel

@@ -24,7 +24,6 @@ go_library(
         "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/execution:go_default_library",
         "//beacon-chain/core/fulu:go_default_library",
-        "//beacon-chain/core/gloas:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/core/transition/interop:go_default_library",

beacon-chain/core/transition/transition.go

@@ -17,7 +17,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/epoch/precompute"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/execution"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/fulu"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/gloas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/time"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v6/config/features"
@@ -390,15 +389,6 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 		upgraded = true
 	}
 
-	if time.CanUpgradeToGloas(slot) {
-		state, err = gloas.UpgradeToGloas(ctx, state)
-		if err != nil {
-			tracing.AnnotateError(span, err)
-			return nil, err
-		}
-		upgraded = true
-	}
-
 	if upgraded {
 		log.WithField("version", version.String(state.Version())).Info("Upgraded state to")
 	}

beacon-chain/db/filesystem/data_column.go

@@ -989,7 +989,6 @@ func filePath(root [fieldparams.RootLength]byte, epoch primitives.Epoch) string
 // extractFileMetadata extracts the metadata from a file path.
 // If the path is not a leaf, it returns nil.
 func extractFileMetadata(path string) (*fileMetadata, error) {
-	// Use filepath.Separator to handle both Windows (\) and Unix (/) path separators
 	parts := strings.Split(path, string(filepath.Separator))
 	if len(parts) != 3 {
 		return nil, errors.Errorf("unexpected file %s", path)

beacon-chain/db/filesystem/data_column_test.go

@@ -3,7 +3,6 @@ package filesystem
 import (
 	"encoding/binary"
 	"os"
-	"path/filepath"
 	"testing"
 
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
@@ -726,37 +725,3 @@ func TestPrune(t *testing.T) {
 		require.Equal(t, true, compareSlices([]string{"0x0de28a18cae63cbc6f0b20dc1afb0b1df38da40824a5f09f92d485ade04de97f.sszs"}, dirs))
 	})
 }
-
-func TestExtractFileMetadata(t *testing.T) {
-	t.Run("Unix", func(t *testing.T) {
-		// Test with Unix-style path separators (/)
-		path := "12/1234/0x8bb2f09de48c102635622dc27e6de03ae2b22639df7c33edbc8222b2ec423746.sszs"
-		metadata, err := extractFileMetadata(path)
-		if filepath.Separator == '/' {
-			// On Unix systems, this should succeed
-			require.NoError(t, err)
-			require.Equal(t, uint64(12), metadata.period)
-			require.Equal(t, primitives.Epoch(1234), metadata.epoch)
-			return
-		}
-
-		// On Windows systems, this should fail because it uses the wrong separator
-		require.NotNil(t, err)
-	})
-
-	t.Run("Windows", func(t *testing.T) {
-		// Test with Windows-style path separators (\)
-		path := "12\\1234\\0x8bb2f09de48c102635622dc27e6de03ae2b22639df7c33edbc8222b2ec423746.sszs"
-		metadata, err := extractFileMetadata(path)
-		if filepath.Separator == '\\' {
-			// On Windows systems, this should succeed
-			require.NoError(t, err)
-			require.Equal(t, uint64(12), metadata.period)
-			require.Equal(t, primitives.Epoch(1234), metadata.epoch)
-			return
-		}
-
-		// On Unix systems, this should fail because it uses the wrong separator
-		require.NotNil(t, err)
-	})
-}

beacon-chain/db/filesystem/iteration.go

@@ -212,8 +212,7 @@ func filterNoop(_ string) bool {
 	return true
 }
 
-// IsBlockRootDir returns true if the path segment looks like a block root directory.
-func IsBlockRootDir(p string) bool {
+func isRootDir(p string) bool {
 	dir := filepath.Base(p)
 	return len(dir) == rootStringLen && strings.HasPrefix(dir, "0x")
 }

beacon-chain/db/filesystem/iteration_test.go

@@ -188,7 +188,7 @@ func TestListDir(t *testing.T) {
 			name:     "root filter",
 			dirPath:  ".",
 			expected: []string{childlessBlob.name, blobWithSsz.name, blobWithSszAndTmp.name},
-			filter:   IsBlockRootDir,
+			filter:   isRootDir,
 		},
 		{
 			name:     "ssz filter",

beacon-chain/db/filesystem/layout.go

@@ -19,14 +19,12 @@ import (
 const (
 	// Full root in directory will be 66 chars, eg:
 	// >>> len('0x0002fb4db510b8618b04dc82d023793739c26346a8b02eb73482e24b0fec0555') == 66
-	rootStringLen = 66
-	sszExt        = "ssz"
-	partExt       = "part"
+	rootStringLen        = 66
+	sszExt               = "ssz"
+	partExt              = "part"
+	periodicEpochBaseDir = "by-epoch"
 )
 
-// PeriodicEpochBaseDir is the name of the base directory for the by-epoch layout.
-const PeriodicEpochBaseDir = "by-epoch"
-
 const (
 	LayoutNameFlat    = "flat"
 	LayoutNameByEpoch = "by-epoch"
@@ -132,11 +130,11 @@ func migrateLayout(fs afero.Fs, from, to fsLayout, cache *blobStorageSummaryCach
 	if iter.atEOF() {
 		return errLayoutNotDetected
 	}
+	log.WithField("fromLayout", from.name()).WithField("toLayout", to.name()).Info("Migrating blob filesystem layout. This one-time operation can take extra time (up to a few minutes for systems with extended blob storage and a cold disk cache).")
 	lastMoved := ""
 	parentDirs := make(map[string]bool) // this map should have < 65k keys by design
 	moved := 0
 	dc := newDirCleaner()
-	migrationLogged := false
 	for ident, err := iter.next(); !errors.Is(err, io.EOF); ident, err = iter.next() {
 		if err != nil {
 			if errors.Is(err, errIdentFailure) {
@@ -148,11 +146,6 @@ func migrateLayout(fs afero.Fs, from, to fsLayout, cache *blobStorageSummaryCach
 			}
 			return errors.Wrapf(errMigrationFailure, "failed to iterate previous layout structure while migrating blobs, err=%s", err.Error())
 		}
-		if !migrationLogged {
-			log.WithField("fromLayout", from.name()).WithField("toLayout", to.name()).
-				Info("Migrating blob filesystem layout. This one-time operation can take extra time (up to a few minutes for systems with extended blob storage and a cold disk cache).")
-			migrationLogged = true
-		}
 		src := from.dir(ident)
 		target := to.dir(ident)
 		if src != lastMoved {

beacon-chain/db/filesystem/layout_by_epoch.go

@@ -34,7 +34,7 @@ func (l *periodicEpochLayout) name() string {
 
 func (l *periodicEpochLayout) blockParentDirs(ident blobIdent) []string {
 	return []string{
-		PeriodicEpochBaseDir,
+		periodicEpochBaseDir,
 		l.periodDir(ident.epoch),
 		l.epochDir(ident.epoch),
 	}
@@ -50,28 +50,28 @@ func (l *periodicEpochLayout) notify(ident blobIdent) error {
 
 // If before == 0, it won't be used as a filter and all idents will be returned.
 func (l *periodicEpochLayout) iterateIdents(before primitives.Epoch) (*identIterator, error) {
-	_, err := l.fs.Stat(PeriodicEpochBaseDir)
+	_, err := l.fs.Stat(periodicEpochBaseDir)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return &identIterator{eof: true}, nil // The directory is non-existent, which is fine; stop iteration.
 		}
-		return nil, errors.Wrapf(err, "error reading path %s", PeriodicEpochBaseDir)
+		return nil, errors.Wrapf(err, "error reading path %s", periodicEpochBaseDir)
 	}
 	// iterate root, which should have directories named by "period"
-	entries, err := listDir(l.fs, PeriodicEpochBaseDir)
+	entries, err := listDir(l.fs, periodicEpochBaseDir)
 	if err != nil {
-		return nil, errors.Wrapf(err, "failed to list %s", PeriodicEpochBaseDir)
+		return nil, errors.Wrapf(err, "failed to list %s", periodicEpochBaseDir)
 	}
 
 	return &identIterator{
 		fs:   l.fs,
-		path: PeriodicEpochBaseDir,
+		path: periodicEpochBaseDir,
 		// Please see comments on the `layers` field in `identIterator`` if the role of the layers is unclear.
 		layers: []layoutLayer{
 			{populateIdent: populateNoop, filter: isBeforePeriod(before)},
 			{populateIdent: populateEpoch, filter: isBeforeEpoch(before)},
-			{populateIdent: populateRoot, filter: IsBlockRootDir}, // extract root from path
-			{populateIdent: populateIndex, filter: isSszFile},     // extract index from filename
+			{populateIdent: populateRoot, filter: isRootDir},  // extract root from path
+			{populateIdent: populateIndex, filter: isSszFile}, // extract index from filename
 		},
 		entries: entries,
 	}, nil
@@ -98,7 +98,7 @@ func (l *periodicEpochLayout) epochDir(epoch primitives.Epoch) string {
 }
 
 func (l *periodicEpochLayout) periodDir(epoch primitives.Epoch) string {
-	return filepath.Join(PeriodicEpochBaseDir, fmt.Sprintf("%d", periodForEpoch(epoch)))
+	return filepath.Join(periodicEpochBaseDir, fmt.Sprintf("%d", periodForEpoch(epoch)))
 }
 
 func (l *periodicEpochLayout) sszPath(n blobIdent) string {

beacon-chain/db/filesystem/layout_flat.go

@@ -30,7 +30,7 @@ func (l *flatLayout) iterateIdents(before primitives.Epoch) (*identIterator, err
 		if os.IsNotExist(err) {
 			return &identIterator{eof: true}, nil // The directory is non-existent, which is fine; stop iteration.
 		}
-		return nil, errors.Wrap(err, "error reading blob base dir")
+		return nil, errors.Wrapf(err, "error reading path %s", periodicEpochBaseDir)
 	}
 	entries, err := listDir(l.fs, ".")
 	if err != nil {
@@ -199,10 +199,10 @@ func (l *flatSlotReader) isSSZAndBefore(fname string) bool {
 // the epoch can be determined.
 func isFlatCachedAndBefore(cache *blobStorageSummaryCache, before primitives.Epoch) func(string) bool {
 	if before == 0 {
-		return IsBlockRootDir
+		return isRootDir
 	}
 	return func(p string) bool {
-		if !IsBlockRootDir(p) {
+		if !isRootDir(p) {
 			return false
 		}
 		root, err := rootFromPath(p)

beacon-chain/db/iface/interface.go

@@ -129,7 +129,6 @@ type NoHeadAccessDatabase interface {
 	// Custody operations.
 	UpdateSubscribedToAllDataSubnets(ctx context.Context, subscribed bool) (bool, error)
 	UpdateCustodyInfo(ctx context.Context, earliestAvailableSlot primitives.Slot, custodyGroupCount uint64) (primitives.Slot, uint64, error)
-	UpdateEarliestAvailableSlot(ctx context.Context, earliestAvailableSlot primitives.Slot) error
 
 	// P2P Metadata operations.
 	SaveMetadataSeqNum(ctx context.Context, seqNum uint64) error

beacon-chain/db/kv/checkpoint.go

@@ -132,6 +132,6 @@ func recoverStateSummary(ctx context.Context, tx *bolt.Tx, root []byte) error {
 	if err != nil {
 		return err
 	}
-	summaryBucket := tx.Bucket(stateSummaryBucket)
+	summaryBucket := tx.Bucket(stateBucket)
 	return summaryBucket.Put(root, summaryEnc)
 }

beacon-chain/db/kv/checkpoint_test.go

@@ -137,32 +137,3 @@ func TestStore_FinalizedCheckpoint_StateMustExist(t *testing.T) {
 
 	require.ErrorContains(t, errMissingStateForCheckpoint.Error(), db.SaveFinalizedCheckpoint(ctx, cp))
 }
-
-// Regression test: verify that saving a checkpoint triggers recovery which writes
-// the state summary into the correct stateSummaryBucket so that HasStateSummary/StateSummary see it.
-func TestRecoverStateSummary_WritesToStateSummaryBucket(t *testing.T) {
-	db := setupDB(t)
-	ctx := t.Context()
-
-	// Create a block without saving a state or summary, so recovery is needed.
-	blk := util.HydrateSignedBeaconBlock(&ethpb.SignedBeaconBlock{})
-	root, err := blk.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wsb, err := blocks.NewSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	require.NoError(t, db.SaveBlock(ctx, wsb))
-
-	// Precondition: summary not present yet.
-	require.Equal(t, false, db.HasStateSummary(ctx, root))
-
-	// Saving justified checkpoint should trigger recovery path calling recoverStateSummary.
-	cp := &ethpb.Checkpoint{Epoch: 2, Root: root[:]}
-	require.NoError(t, db.SaveJustifiedCheckpoint(ctx, cp))
-
-	// Postcondition: summary is visible via the public summary APIs (which read stateSummaryBucket).
-	require.Equal(t, true, db.HasStateSummary(ctx, root))
-	summary, err := db.StateSummary(ctx, root)
-	require.NoError(t, err)
-	require.NotNil(t, summary)
-	assert.DeepEqual(t, &ethpb.StateSummary{Slot: blk.Block.Slot, Root: root[:]}, summary)
-}

beacon-chain/db/kv/custody.go

@@ -2,19 +2,16 @@ package kv
 
 import (
 	"context"
-	"time"
 
-	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
-	"github.com/OffchainLabs/prysm/v6/time/slots"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	bolt "go.etcd.io/bbolt"
 )
 
-// UpdateCustodyInfo atomically updates the custody group count only if it is greater than the stored one.
+// UpdateCustodyInfo atomically updates the custody group count only it is greater than the stored one.
 // In this case, it also updates the earliest available slot with the provided value.
 // It returns the (potentially updated) custody group count and earliest available slot.
 func (s *Store) UpdateCustodyInfo(ctx context.Context, earliestAvailableSlot primitives.Slot, custodyGroupCount uint64) (primitives.Slot, uint64, error) {
@@ -73,79 +70,6 @@ func (s *Store) UpdateCustodyInfo(ctx context.Context, earliestAvailableSlot pri
 	return storedEarliestAvailableSlot, storedGroupCount, nil
 }
 
-// UpdateEarliestAvailableSlot updates the earliest available slot.
-func (s *Store) UpdateEarliestAvailableSlot(ctx context.Context, earliestAvailableSlot primitives.Slot) error {
-	_, span := trace.StartSpan(ctx, "BeaconDB.UpdateEarliestAvailableSlot")
-	defer span.End()
-
-	storedEarliestAvailableSlot := primitives.Slot(0)
-	if err := s.db.Update(func(tx *bolt.Tx) error {
-		// Retrieve the custody bucket.
-		bucket, err := tx.CreateBucketIfNotExists(custodyBucket)
-		if err != nil {
-			return errors.Wrap(err, "create custody bucket")
-		}
-
-		// Retrieve the stored earliest available slot.
-		storedEarliestAvailableSlotBytes := bucket.Get(earliestAvailableSlotKey)
-		if len(storedEarliestAvailableSlotBytes) != 0 {
-			storedEarliestAvailableSlot = primitives.Slot(bytesutil.BytesToUint64BigEndian(storedEarliestAvailableSlotBytes))
-		}
-
-		// Allow decrease (for backfill scenarios)
-		if earliestAvailableSlot <= storedEarliestAvailableSlot {
-			storedEarliestAvailableSlot = earliestAvailableSlot
-			bytes := bytesutil.Uint64ToBytesBigEndian(uint64(earliestAvailableSlot))
-			if err := bucket.Put(earliestAvailableSlotKey, bytes); err != nil {
-				return errors.Wrap(err, "put earliest available slot")
-			}
-			return nil
-		}
-
-		// Prevent increase within the MIN_EPOCHS_FOR_BLOCK_REQUESTS period
-		// This ensures we don't voluntarily refuse to serve mandatory block data
-		genesisTime := time.Unix(int64(params.BeaconConfig().MinGenesisTime+params.BeaconConfig().GenesisDelay), 0)
-		currentSlot := slots.CurrentSlot(genesisTime)
-		currentEpoch := slots.ToEpoch(currentSlot)
-		minEpochsForBlocks := primitives.Epoch(params.BeaconConfig().MinEpochsForBlockRequests)
-
-		// Calculate the minimum required epoch (or 0 if we're early in the chain)
-		minRequiredEpoch := primitives.Epoch(0)
-		if currentEpoch > minEpochsForBlocks {
-			minRequiredEpoch = currentEpoch - minEpochsForBlocks
-		}
-
-		// Convert to slot to ensure we compare at slot-level granularity
-		minRequiredSlot, err := slots.EpochStart(minRequiredEpoch)
-		if err != nil {
-			return errors.Wrap(err, "calculate minimum required slot")
-		}
-
-		// Prevent any increase that would put earliest available slot beyond the minimum required slot
-		if earliestAvailableSlot > minRequiredSlot {
-			return errors.Errorf(
-				"cannot increase earliest available slot to %d (epoch %d) as it exceeds minimum required slot %d (epoch %d)",
-				earliestAvailableSlot, slots.ToEpoch(earliestAvailableSlot),
-				minRequiredSlot, minRequiredEpoch,
-			)
-		}
-
-		storedEarliestAvailableSlot = earliestAvailableSlot
-		bytes := bytesutil.Uint64ToBytesBigEndian(uint64(earliestAvailableSlot))
-		if err := bucket.Put(earliestAvailableSlotKey, bytes); err != nil {
-			return errors.Wrap(err, "put earliest available slot")
-		}
-
-		return nil
-	}); err != nil {
-		return err
-	}
-
-	log.WithField("earliestAvailableSlot", storedEarliestAvailableSlot).Debug("Updated earliest available slot")
-
-	return nil
-}
-
 // UpdateSubscribedToAllDataSubnets updates the "subscribed to all data subnets" status in the database
 // only if `subscribed` is `true`.
 // It returns the previous subscription status.

beacon-chain/db/kv/custody_test.go

@@ -3,13 +3,10 @@ package kv
 import (
 	"context"
 	"testing"
-	"time"
 
-	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/OffchainLabs/prysm/v6/time/slots"
 	bolt "go.etcd.io/bbolt"
 )
 
@@ -135,131 +132,6 @@ func TestUpdateCustodyInfo(t *testing.T) {
 	})
 }
 
-func TestUpdateEarliestAvailableSlot(t *testing.T) {
-	ctx := t.Context()
-
-	t.Run("allow decreasing earliest slot (backfill scenario)", func(t *testing.T) {
-		const (
-			initialSlot  = primitives.Slot(300)
-			initialCount = uint64(10)
-			earliestSlot = primitives.Slot(200) // Lower than initial (backfill discovered earlier blocks)
-		)
-
-		db := setupDB(t)
-
-		// Initialize custody info
-		_, _, err := db.UpdateCustodyInfo(ctx, initialSlot, initialCount)
-		require.NoError(t, err)
-
-		// Update with a lower slot (should update for backfill)
-		err = db.UpdateEarliestAvailableSlot(ctx, earliestSlot)
-		require.NoError(t, err)
-
-		storedSlot, storedCount := getCustodyInfoFromDB(t, db)
-		require.Equal(t, earliestSlot, storedSlot)
-		require.Equal(t, initialCount, storedCount)
-	})
-
-	t.Run("allow increasing slot within MIN_EPOCHS_FOR_BLOCK_REQUESTS (pruning scenario)", func(t *testing.T) {
-		db := setupDB(t)
-
-		// Calculate the current slot and minimum required slot based on actual current time
-		genesisTime := time.Unix(int64(params.BeaconConfig().MinGenesisTime+params.BeaconConfig().GenesisDelay), 0)
-		currentSlot := slots.CurrentSlot(genesisTime)
-		currentEpoch := slots.ToEpoch(currentSlot)
-		minEpochsForBlocks := primitives.Epoch(params.BeaconConfig().MinEpochsForBlockRequests)
-
-		var minRequiredEpoch primitives.Epoch
-		if currentEpoch > minEpochsForBlocks {
-			minRequiredEpoch = currentEpoch - minEpochsForBlocks
-		} else {
-			minRequiredEpoch = 0
-		}
-
-		minRequiredSlot, err := slots.EpochStart(minRequiredEpoch)
-		require.NoError(t, err)
-
-		// Initial setup: set earliest slot well before minRequiredSlot
-		const groupCount = uint64(5)
-		initialSlot := primitives.Slot(1000)
-
-		_, _, err = db.UpdateCustodyInfo(ctx, initialSlot, groupCount)
-		require.NoError(t, err)
-
-		// Try to increase to a slot that's still BEFORE minRequiredSlot (should succeed)
-		validSlot := minRequiredSlot - 100
-
-		err = db.UpdateEarliestAvailableSlot(ctx, validSlot)
-		require.NoError(t, err)
-
-		// Verify the database was updated
-		storedSlot, storedCount := getCustodyInfoFromDB(t, db)
-		require.Equal(t, validSlot, storedSlot)
-		require.Equal(t, groupCount, storedCount)
-	})
-
-	t.Run("prevent increasing slot beyond MIN_EPOCHS_FOR_BLOCK_REQUESTS", func(t *testing.T) {
-		db := setupDB(t)
-
-		// Calculate the current slot and minimum required slot based on actual current time
-		genesisTime := time.Unix(int64(params.BeaconConfig().MinGenesisTime+params.BeaconConfig().GenesisDelay), 0)
-		currentSlot := slots.CurrentSlot(genesisTime)
-		currentEpoch := slots.ToEpoch(currentSlot)
-		minEpochsForBlocks := primitives.Epoch(params.BeaconConfig().MinEpochsForBlockRequests)
-
-		var minRequiredEpoch primitives.Epoch
-		if currentEpoch > minEpochsForBlocks {
-			minRequiredEpoch = currentEpoch - minEpochsForBlocks
-		} else {
-			minRequiredEpoch = 0
-		}
-
-		minRequiredSlot, err := slots.EpochStart(minRequiredEpoch)
-		require.NoError(t, err)
-
-		// Initial setup: set a valid earliest slot (well before minRequiredSlot)
-		const initialCount = uint64(5)
-		initialSlot := primitives.Slot(1000)
-
-		_, _, err = db.UpdateCustodyInfo(ctx, initialSlot, initialCount)
-		require.NoError(t, err)
-
-		// Try to set earliest slot beyond the minimum required slot
-		invalidSlot := minRequiredSlot + 100
-
-		// This should fail
-		err = db.UpdateEarliestAvailableSlot(ctx, invalidSlot)
-		require.ErrorContains(t, "cannot increase earliest available slot", err)
-		require.ErrorContains(t, "exceeds minimum required slot", err)
-
-		// Verify the database wasn't updated
-		storedSlot, storedCount := getCustodyInfoFromDB(t, db)
-		require.Equal(t, initialSlot, storedSlot)
-		require.Equal(t, initialCount, storedCount)
-	})
-
-	t.Run("no change when slot equals current slot", func(t *testing.T) {
-		const (
-			initialSlot  = primitives.Slot(100)
-			initialCount = uint64(5)
-		)
-
-		db := setupDB(t)
-
-		// Initialize custody info
-		_, _, err := db.UpdateCustodyInfo(ctx, initialSlot, initialCount)
-		require.NoError(t, err)
-
-		// Update with the same slot
-		err = db.UpdateEarliestAvailableSlot(ctx, initialSlot)
-		require.NoError(t, err)
-
-		storedSlot, storedCount := getCustodyInfoFromDB(t, db)
-		require.Equal(t, initialSlot, storedSlot)
-		require.Equal(t, initialCount, storedCount)
-	})
-}
-
 func TestUpdateSubscribedToAllDataSubnets(t *testing.T) {
 	ctx := context.Background()
 

beacon-chain/db/pruner/BUILD.bazel

@@ -8,6 +8,7 @@ go_library(
         "//beacon-chain:__subpackages__",
     ],
     deps = [
+        "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/iface:go_default_library",
         "//config/params:go_default_library",
@@ -28,7 +29,6 @@ go_test(
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "//time/slots/testing:go_default_library",

beacon-chain/db/pruner/pruner.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"time"
 
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/iface"
 	"github.com/OffchainLabs/prysm/v6/config/params"
@@ -24,24 +25,17 @@ const (
 	defaultNumBatchesToPrune = 15
 )
 
-// custodyUpdater is a tiny interface that p2p service implements; kept here to avoid
-// importing the p2p package and creating a cycle.
-type custodyUpdater interface {
-	UpdateEarliestAvailableSlot(earliestAvailableSlot primitives.Slot) error
-}
-
 type ServiceOption func(*Service)
 
 // WithRetentionPeriod allows the user to specify a different data retention period than the spec default.
 // The retention period is specified in epochs, and must be >= MIN_EPOCHS_FOR_BLOCK_REQUESTS.
 func WithRetentionPeriod(retentionEpochs primitives.Epoch) ServiceOption {
 	return func(s *Service) {
-		defaultRetentionEpochs := primitives.Epoch(params.BeaconConfig().MinEpochsForBlockRequests) + 1
+		defaultRetentionEpochs := helpers.MinEpochsForBlockRequests() + 1
 		if retentionEpochs < defaultRetentionEpochs {
 			log.WithField("userEpochs", retentionEpochs).
 				WithField("minRequired", defaultRetentionEpochs).
-				Warn("Retention period too low, ignoring and using minimum required value")
-			retentionEpochs = defaultRetentionEpochs
+				Warn("Retention period too low, using minimum required value")
 		}
 
 		s.ps = pruneStartSlotFunc(retentionEpochs)
@@ -64,23 +58,17 @@ type Service struct {
 	slotTicker     slots.Ticker
 	backfillWaiter func() error
 	initSyncWaiter func() error
-	custody        custodyUpdater
 }
 
-func New(ctx context.Context, db iface.Database, genesisTime time.Time, initSyncWaiter, backfillWaiter func() error, custody custodyUpdater, opts ...ServiceOption) (*Service, error) {
-	if custody == nil {
-		return nil, errors.New("custody updater is required for pruner but was not provided")
-	}
-
+func New(ctx context.Context, db iface.Database, genesisTime time.Time, initSyncWaiter, backfillWaiter func() error, opts ...ServiceOption) (*Service, error) {
 	p := &Service{
 		ctx:            ctx,
 		db:             db,
-		ps:             pruneStartSlotFunc(primitives.Epoch(params.BeaconConfig().MinEpochsForBlockRequests) + 1), // Default retention epochs is MIN_EPOCHS_FOR_BLOCK_REQUESTS + 1 from the current slot.
+		ps:             pruneStartSlotFunc(helpers.MinEpochsForBlockRequests() + 1), // Default retention epochs is MIN_EPOCHS_FOR_BLOCK_REQUESTS + 1 from the current slot.
 		done:           make(chan struct{}),
 		slotTicker:     slots.NewSlotTicker(slots.UnsafeStartTime(genesisTime, 0), params.BeaconConfig().SecondsPerSlot),
 		initSyncWaiter: initSyncWaiter,
 		backfillWaiter: backfillWaiter,
-		custody:        custody,
 	}
 
 	for _, o := range opts {
@@ -169,45 +157,17 @@ func (p *Service) prune(slot primitives.Slot) error {
 		return errors.Wrap(err, "failed to prune batches")
 	}
 
-	earliestAvailableSlot := pruneUpto + 1
+	log.WithFields(logrus.Fields{
+		"prunedUpto":  pruneUpto,
+		"duration":    time.Since(tt),
+		"currentSlot": slot,
+		"batchSize":   defaultPrunableBatchSize,
+		"numBatches":  numBatches,
+	}).Debug("Successfully pruned chain data")
 
 	// Update pruning checkpoint.
 	p.prunedUpto = pruneUpto
 
-	// Update the earliest available slot after pruning
-	if err := p.updateEarliestAvailableSlot(earliestAvailableSlot); err != nil {
-		return errors.Wrap(err, "update earliest available slot")
-	}
-
-	log.WithFields(logrus.Fields{
-		"prunedUpto":            pruneUpto,
-		"earliestAvailableSlot": earliestAvailableSlot,
-		"duration":              time.Since(tt),
-		"currentSlot":           slot,
-		"batchSize":             defaultPrunableBatchSize,
-		"numBatches":            numBatches,
-	}).Debug("Successfully pruned chain data")
-
-	return nil
-}
-
-// updateEarliestAvailableSlot updates the earliest available slot via the injected custody updater
-// and also persists it to the database.
-func (p *Service) updateEarliestAvailableSlot(earliestAvailableSlot primitives.Slot) error {
-	if !params.FuluEnabled() {
-		return nil
-	}
-
-	// Update the p2p in-memory state
-	if err := p.custody.UpdateEarliestAvailableSlot(earliestAvailableSlot); err != nil {
-		return errors.Wrapf(err, "update earliest available slot after pruning to %d", earliestAvailableSlot)
-	}
-
-	// Persist to database to ensure it survives restarts
-	if err := p.db.UpdateEarliestAvailableSlot(p.ctx, earliestAvailableSlot); err != nil {
-		return errors.Wrapf(err, "update earliest available slot in database for slot %d", earliestAvailableSlot)
-	}
-
 	return nil
 }
 

beacon-chain/db/pruner/pruner_test.go

@@ -2,7 +2,6 @@ package pruner
 
 import (
 	"context"
-	"errors"
 	"testing"
 	"time"
 
@@ -16,7 +15,6 @@ import (
 
 	dbtest "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )
@@ -64,9 +62,7 @@ func TestPruner_PruningConditions(t *testing.T) {
 			if !tt.backfillCompleted {
 				backfillWaiter = waiter
 			}
-
-			mockCustody := &mockCustodyUpdater{}
-			p, err := New(ctx, beaconDB, time.Now(), initSyncWaiter, backfillWaiter, mockCustody, WithSlotTicker(slotTicker))
+			p, err := New(ctx, beaconDB, time.Now(), initSyncWaiter, backfillWaiter, WithSlotTicker(slotTicker))
 			require.NoError(t, err)
 
 			go p.Start()
@@ -101,14 +97,12 @@ func TestPruner_PruneSuccess(t *testing.T) {
 	retentionEpochs := primitives.Epoch(2)
 	slotTicker := &slottest.MockTicker{Channel: make(chan primitives.Slot)}
 
-	mockCustody := &mockCustodyUpdater{}
 	p, err := New(
 		ctx,
 		beaconDB,
 		time.Now(),
 		nil,
 		nil,
-		mockCustody,
 		WithSlotTicker(slotTicker),
 	)
 	require.NoError(t, err)
@@ -139,242 +133,3 @@ func TestPruner_PruneSuccess(t *testing.T) {
 
 	require.NoError(t, p.Stop())
 }
-
-// Mock custody updater for testing
-type mockCustodyUpdater struct {
-	custodyGroupCount     uint64
-	earliestAvailableSlot primitives.Slot
-	updateCallCount       int
-}
-
-func (m *mockCustodyUpdater) UpdateEarliestAvailableSlot(earliestAvailableSlot primitives.Slot) error {
-	m.updateCallCount++
-	m.earliestAvailableSlot = earliestAvailableSlot
-	return nil
-}
-
-func TestPruner_UpdatesEarliestAvailableSlot(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	config := params.BeaconConfig()
-	config.FuluForkEpoch = 0 // Enable Fulu from epoch 0
-	params.OverrideBeaconConfig(config)
-
-	logrus.SetLevel(logrus.DebugLevel)
-	hook := logTest.NewGlobal()
-	ctx, cancel := context.WithCancel(t.Context())
-	defer cancel()
-
-	beaconDB := dbtest.SetupDB(t)
-	retentionEpochs := primitives.Epoch(2)
-
-	slotTicker := &slottest.MockTicker{Channel: make(chan primitives.Slot)}
-
-	// Create mock custody updater
-	mockCustody := &mockCustodyUpdater{
-		custodyGroupCount:     4,
-		earliestAvailableSlot: 0,
-	}
-
-	// Create pruner with mock custody updater
-	p, err := New(
-		ctx,
-		beaconDB,
-		time.Now(),
-		nil,
-		nil,
-		mockCustody,
-		WithSlotTicker(slotTicker),
-	)
-	require.NoError(t, err)
-
-	p.ps = func(current primitives.Slot) primitives.Slot {
-		return current - primitives.Slot(retentionEpochs)*params.BeaconConfig().SlotsPerEpoch
-	}
-
-	// Save some blocks to be pruned
-	for i := primitives.Slot(1); i <= 32; i++ {
-		blk := util.NewBeaconBlock()
-		blk.Block.Slot = i
-		wsb, err := blocks.NewSignedBeaconBlock(blk)
-		require.NoError(t, err)
-		require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
-	}
-
-	// Start pruner and trigger at slot 80 (middle of 3rd epoch)
-	go p.Start()
-	currentSlot := primitives.Slot(80)
-	slotTicker.Channel <- currentSlot
-
-	// Wait for pruning to complete
-	time.Sleep(100 * time.Millisecond)
-
-	// Check that UpdateEarliestAvailableSlot was called
-	assert.Equal(t, true, mockCustody.updateCallCount > 0, "UpdateEarliestAvailableSlot should have been called")
-
-	// The earliest available slot should be pruneUpto + 1
-	// pruneUpto = currentSlot - retentionEpochs*slotsPerEpoch = 80 - 2*32 = 16
-	// So earliest available slot should be 16 + 1 = 17
-	expectedEarliestSlot := primitives.Slot(17)
-	require.Equal(t, expectedEarliestSlot, mockCustody.earliestAvailableSlot, "Earliest available slot should be updated correctly")
-	require.Equal(t, uint64(4), mockCustody.custodyGroupCount, "Custody group count should be preserved")
-
-	// Verify that no error was logged
-	for _, entry := range hook.AllEntries() {
-		if entry.Level == logrus.ErrorLevel {
-			t.Errorf("Unexpected error log: %s", entry.Message)
-		}
-	}
-
-	require.NoError(t, p.Stop())
-}
-
-// Mock custody updater that returns an error for UpdateEarliestAvailableSlot
-type mockCustodyUpdaterWithUpdateError struct {
-	updateCallCount int
-}
-
-func (m *mockCustodyUpdaterWithUpdateError) UpdateEarliestAvailableSlot(earliestAvailableSlot primitives.Slot) error {
-	m.updateCallCount++
-	return errors.New("failed to update earliest available slot")
-}
-
-func TestWithRetentionPeriod_EnforcesMinimum(t *testing.T) {
-	// Use minimal config for testing
-	params.SetupTestConfigCleanup(t)
-	config := params.MinimalSpecConfig()
-	params.OverrideBeaconConfig(config)
-
-	ctx := t.Context()
-	beaconDB := dbtest.SetupDB(t)
-
-	// Get the minimum required epochs (272 + 1 = 273 for minimal)
-	minRequiredEpochs := primitives.Epoch(params.BeaconConfig().MinEpochsForBlockRequests + 1)
-
-	// Use a slot that's guaranteed to be after the minimum retention period
-	currentSlot := primitives.Slot(minRequiredEpochs+100) * (params.BeaconConfig().SlotsPerEpoch)
-
-	tests := []struct {
-		name                string
-		userRetentionEpochs primitives.Epoch
-		expectedPruneSlot   primitives.Slot
-		description         string
-	}{
-		{
-			name:                "User value below minimum - should use minimum",
-			userRetentionEpochs: 2, // Way below minimum
-			expectedPruneSlot:   currentSlot - primitives.Slot(minRequiredEpochs)*params.BeaconConfig().SlotsPerEpoch,
-			description:         "Should use minimum when user value is too low",
-		},
-		{
-			name:                "User value at minimum",
-			userRetentionEpochs: minRequiredEpochs,
-			expectedPruneSlot:   currentSlot - primitives.Slot(minRequiredEpochs)*params.BeaconConfig().SlotsPerEpoch,
-			description:         "Should use user value when at minimum",
-		},
-		{
-			name:                "User value above minimum",
-			userRetentionEpochs: minRequiredEpochs + 10,
-			expectedPruneSlot:   currentSlot - primitives.Slot(minRequiredEpochs+10)*params.BeaconConfig().SlotsPerEpoch,
-			description:         "Should use user value when above minimum",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			hook := logTest.NewGlobal()
-			logrus.SetLevel(logrus.WarnLevel)
-
-			mockCustody := &mockCustodyUpdater{}
-			// Create pruner with retention period
-			p, err := New(
-				ctx,
-				beaconDB,
-				time.Now(),
-				nil,
-				nil,
-				mockCustody,
-				WithRetentionPeriod(tt.userRetentionEpochs),
-			)
-			require.NoError(t, err)
-
-			// Test the pruning calculation
-			pruneUptoSlot := p.ps(currentSlot)
-
-			// Verify the pruning slot
-			assert.Equal(t, tt.expectedPruneSlot, pruneUptoSlot, tt.description)
-
-			// Check if warning was logged when value was too low
-			if tt.userRetentionEpochs < minRequiredEpochs {
-				assert.LogsContain(t, hook, "Retention period too low, ignoring and using minimum required value")
-			}
-		})
-	}
-}
-
-func TestPruner_UpdateEarliestSlotError(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	config := params.BeaconConfig()
-	config.FuluForkEpoch = 0 // Enable Fulu from epoch 0
-	params.OverrideBeaconConfig(config)
-
-	logrus.SetLevel(logrus.DebugLevel)
-	hook := logTest.NewGlobal()
-	ctx, cancel := context.WithCancel(t.Context())
-	defer cancel()
-
-	beaconDB := dbtest.SetupDB(t)
-	retentionEpochs := primitives.Epoch(2)
-
-	slotTicker := &slottest.MockTicker{Channel: make(chan primitives.Slot)}
-
-	// Create mock custody updater that returns an error for UpdateEarliestAvailableSlot
-	mockCustody := &mockCustodyUpdaterWithUpdateError{}
-
-	// Create pruner with mock custody updater
-	p, err := New(
-		ctx,
-		beaconDB,
-		time.Now(),
-		nil,
-		nil,
-		mockCustody,
-		WithSlotTicker(slotTicker),
-	)
-	require.NoError(t, err)
-
-	p.ps = func(current primitives.Slot) primitives.Slot {
-		return current - primitives.Slot(retentionEpochs)*params.BeaconConfig().SlotsPerEpoch
-	}
-
-	// Save some blocks to be pruned
-	for i := primitives.Slot(1); i <= 32; i++ {
-		blk := util.NewBeaconBlock()
-		blk.Block.Slot = i
-		wsb, err := blocks.NewSignedBeaconBlock(blk)
-		require.NoError(t, err)
-		require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
-	}
-
-	// Start pruner and trigger at slot 80
-	go p.Start()
-	currentSlot := primitives.Slot(80)
-	slotTicker.Channel <- currentSlot
-
-	// Wait for pruning to complete
-	time.Sleep(100 * time.Millisecond)
-
-	// Should have called UpdateEarliestAvailableSlot
-	assert.Equal(t, 1, mockCustody.updateCallCount, "UpdateEarliestAvailableSlot should be called")
-
-	// Check that error was logged by the prune function
-	found := false
-	for _, entry := range hook.AllEntries() {
-		if entry.Level == logrus.ErrorLevel && entry.Message == "Failed to prune database" {
-			found = true
-			break
-		}
-	}
-	assert.Equal(t, true, found, "Should log error when UpdateEarliestAvailableSlot fails")
-
-	require.NoError(t, p.Stop())
-}

beacon-chain/execution/engine_client.go

@@ -58,11 +58,6 @@ var (
 		GetPayloadMethodV5,
 		GetBlobsV2,
 	}
-
-	gloasEngineEndpoints = []string{
-		NewPayloadMethodV5,
-		GetPayloadMethodV6,
-	}
 )
 
 const (
@@ -73,8 +68,6 @@ const (
 	NewPayloadMethodV3 = "engine_newPayloadV3"
 	// NewPayloadMethodV4 is the engine_newPayloadVX method added at Electra.
 	NewPayloadMethodV4 = "engine_newPayloadV4"
-	// NewPayloadMethodV5 is the engine_newPayloadVX method added at Gloas.
-	NewPayloadMethodV5 = "engine_newPayloadV5"
 	// ForkchoiceUpdatedMethod v1 request string for JSON-RPC.
 	ForkchoiceUpdatedMethod = "engine_forkchoiceUpdatedV1"
 	// ForkchoiceUpdatedMethodV2 v2 request string for JSON-RPC.
@@ -91,8 +84,6 @@ const (
 	GetPayloadMethodV4 = "engine_getPayloadV4"
 	// GetPayloadMethodV5 is the get payload method added for fulu
 	GetPayloadMethodV5 = "engine_getPayloadV5"
-	// GetPayloadMethodV6 is the get payload method added for gloas
-	GetPayloadMethodV6 = "engine_getPayloadV6"
 	// BlockByHashMethod request string for JSON-RPC.
 	BlockByHashMethod = "eth_getBlockByHash"
 	// BlockByNumberMethod request string for JSON-RPC.
@@ -187,18 +178,6 @@ func (s *Service) NewPayload(ctx context.Context, payload interfaces.ExecutionDa
 				return nil, handleRPCError(err)
 			}
 		}
-	case *pb.ExecutionPayloadGloas:
-		if executionRequests == nil {
-			return nil, errors.New("execution requests are required for gloas execution payload")
-		}
-		flattenedRequests, err := pb.EncodeExecutionRequests(executionRequests)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to encode execution requests")
-		}
-		err = s.rpcClient.CallContext(ctx, result, NewPayloadMethodV5, payloadPb, versionedHashes, parentBlockRoot, flattenedRequests)
-		if err != nil {
-			return nil, handleRPCError(err)
-		}
 	default:
 		return nil, errors.New("unknown execution data type")
 	}
@@ -260,7 +239,7 @@ func (s *Service) ForkchoiceUpdated(
 		if err != nil {
 			return nil, nil, handleRPCError(err)
 		}
-	case version.Deneb, version.Electra, version.Fulu, version.Gloas:
+	case version.Deneb, version.Electra, version.Fulu:
 		a, err := attrs.PbV3()
 		if err != nil {
 			return nil, nil, err
@@ -294,9 +273,6 @@ func (s *Service) ForkchoiceUpdated(
 
 func getPayloadMethodAndMessage(slot primitives.Slot) (string, proto.Message) {
 	epoch := slots.ToEpoch(slot)
-	if epoch >= params.BeaconConfig().GloasForkEpoch {
-		return GetPayloadMethodV6, &pb.ExecutionBundleGloas{}
-	}
 	if epoch >= params.BeaconConfig().FuluForkEpoch {
 		return GetPayloadMethodV5, &pb.ExecutionBundleFulu{}
 	}
@@ -349,10 +325,6 @@ func (s *Service) ExchangeCapabilities(ctx context.Context) ([]string, error) {
 		supportedEngineEndpoints = append(supportedEngineEndpoints, fuluEngineEndpoints...)
 	}
 
-	if params.GloasEnabled() {
-		supportedEngineEndpoints = append(supportedEngineEndpoints, gloasEngineEndpoints...)
-	}
-
 	elSupportedEndpointsSlice := make([]string, len(supportedEngineEndpoints))
 	if err := s.rpcClient.CallContext(ctx, &elSupportedEndpointsSlice, ExchangeCapabilities, supportedEngineEndpoints); err != nil {
 		return nil, handleRPCError(err)

beacon-chain/node/node.go

@@ -1108,7 +1108,6 @@ func (b *BeaconNode) registerPrunerService(cliCtx *cli.Context) error {
 		genesis,
 		initSyncWaiter(cliCtx.Context, b.initialSyncComplete),
 		backfillService.WaitForCompletion,
-		b.fetchP2P(),
 		opts...,
 	)
 	if err != nil {

beacon-chain/p2p/custody.go

@@ -115,57 +115,6 @@ func (s *Service) UpdateCustodyInfo(earliestAvailableSlot primitives.Slot, custo
 	return earliestAvailableSlot, custodyGroupCount, nil
 }
 
-// UpdateEarliestAvailableSlot updates the earliest available slot.
-//
-// IMPORTANT: This function should only be called when Fulu is enabled. The caller is responsible
-// for checking params.FuluEnabled() before calling this function.
-func (s *Service) UpdateEarliestAvailableSlot(earliestAvailableSlot primitives.Slot) error {
-	s.custodyInfoLock.Lock()
-	defer s.custodyInfoLock.Unlock()
-
-	if s.custodyInfo == nil {
-		return errors.New("no custody info available")
-	}
-
-	currentSlot := slots.CurrentSlot(s.genesisTime)
-	currentEpoch := slots.ToEpoch(currentSlot)
-
-	// Allow decrease (for backfill scenarios)
-	if earliestAvailableSlot < s.custodyInfo.earliestAvailableSlot {
-		s.custodyInfo.earliestAvailableSlot = earliestAvailableSlot
-		return nil
-	}
-
-	// Prevent increase within the MIN_EPOCHS_FOR_BLOCK_REQUESTS period
-	// This ensures we don't voluntarily refuse to serve mandatory block data
-	// This check applies regardless of whether we're early or late in the chain
-	minEpochsForBlocks := primitives.Epoch(params.BeaconConfig().MinEpochsForBlockRequests)
-
-	// Calculate the minimum required epoch (or 0 if we're early in the chain)
-	minRequiredEpoch := primitives.Epoch(0)
-	if currentEpoch > minEpochsForBlocks {
-		minRequiredEpoch = currentEpoch - minEpochsForBlocks
-	}
-
-	// Convert to slot to ensure we compare at slot-level granularity, not epoch-level
-	// This prevents allowing increases to slots within minRequiredEpoch that are after its first slot
-	minRequiredSlot, err := slots.EpochStart(minRequiredEpoch)
-	if err != nil {
-		return errors.Wrap(err, "epoch start")
-	}
-
-	// Prevent any increase that would put earliest slot beyond the minimum required slot
-	if earliestAvailableSlot > s.custodyInfo.earliestAvailableSlot && earliestAvailableSlot > minRequiredSlot {
-		return errors.Errorf(
-			"cannot increase earliest available slot to %d (epoch %d) as it exceeds minimum required slot %d (epoch %d)",
-			earliestAvailableSlot, slots.ToEpoch(earliestAvailableSlot), minRequiredSlot, minRequiredEpoch,
-		)
-	}
-
-	s.custodyInfo.earliestAvailableSlot = earliestAvailableSlot
-	return nil
-}
-
 // CustodyGroupCountFromPeer retrieves custody group count from a peer.
 // It first tries to get the custody group count from the peer's metadata,
 // then falls back to the ENR value if the metadata is not available, then

beacon-chain/p2p/custody_test.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"strings"
 	"testing"
-	"time"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers"
@@ -168,148 +167,6 @@ func TestUpdateCustodyInfo(t *testing.T) {
 	}
 }
 
-func TestUpdateEarliestAvailableSlot(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	config := params.BeaconConfig()
-	config.FuluForkEpoch = 0 // Enable Fulu from epoch 0
-	params.OverrideBeaconConfig(config)
-
-	t.Run("Valid update", func(t *testing.T) {
-		const (
-			initialSlot primitives.Slot = 50
-			newSlot     primitives.Slot = 100
-			groupCount  uint64          = 5
-		)
-
-		// Set up a scenario where we're far enough in the chain that increasing to newSlot is valid
-		minEpochsForBlocks := primitives.Epoch(params.BeaconConfig().MinEpochsForBlockRequests)
-		currentEpoch := minEpochsForBlocks + 100 // Well beyond MIN_EPOCHS_FOR_BLOCK_REQUESTS
-		currentSlot := primitives.Slot(currentEpoch) * primitives.Slot(params.BeaconConfig().SlotsPerEpoch)
-
-		service := &Service{
-			// Set genesis time in the past so currentSlot is the "current" slot
-			genesisTime: time.Now().Add(-time.Duration(currentSlot) * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second),
-			custodyInfo: &custodyInfo{
-				earliestAvailableSlot: initialSlot,
-				groupCount:            groupCount,
-			},
-		}
-
-		err := service.UpdateEarliestAvailableSlot(newSlot)
-
-		require.NoError(t, err)
-		require.Equal(t, newSlot, service.custodyInfo.earliestAvailableSlot)
-		require.Equal(t, groupCount, service.custodyInfo.groupCount) // Should preserve group count
-	})
-
-	t.Run("Earlier slot - allowed for backfill", func(t *testing.T) {
-		const initialSlot primitives.Slot = 100
-		const earlierSlot primitives.Slot = 50
-
-		service := &Service{
-			genesisTime: time.Now(),
-			custodyInfo: &custodyInfo{
-				earliestAvailableSlot: initialSlot,
-				groupCount:            5,
-			},
-		}
-
-		err := service.UpdateEarliestAvailableSlot(earlierSlot)
-
-		require.NoError(t, err)
-		require.Equal(t, earlierSlot, service.custodyInfo.earliestAvailableSlot) // Should decrease for backfill
-	})
-
-	t.Run("Prevent increase within MIN_EPOCHS_FOR_BLOCK_REQUESTS - late in chain", func(t *testing.T) {
-		// Set current time far enough in the future to have a meaningful MIN_EPOCHS_FOR_BLOCK_REQUESTS period
-		minEpochsForBlocks := primitives.Epoch(params.BeaconConfig().MinEpochsForBlockRequests)
-		currentEpoch := minEpochsForBlocks + 100 // Well beyond the minimum
-		currentSlot := primitives.Slot(currentEpoch) * primitives.Slot(params.BeaconConfig().SlotsPerEpoch)
-
-		// Calculate the minimum allowed epoch
-		minRequiredEpoch := currentEpoch - minEpochsForBlocks
-		minRequiredSlot := primitives.Slot(minRequiredEpoch) * primitives.Slot(params.BeaconConfig().SlotsPerEpoch)
-
-		// Try to set earliest slot to a value within the MIN_EPOCHS_FOR_BLOCK_REQUESTS period (should fail)
-		attemptedSlot := minRequiredSlot + 1000 // Within the mandatory retention period
-
-		service := &Service{
-			genesisTime: time.Now().Add(-time.Duration(currentSlot) * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second),
-			custodyInfo: &custodyInfo{
-				earliestAvailableSlot: minRequiredSlot - 100, // Current value is before the min required
-				groupCount:            5,
-			},
-		}
-
-		err := service.UpdateEarliestAvailableSlot(attemptedSlot)
-
-		require.NotNil(t, err)
-		require.Equal(t, true, strings.Contains(err.Error(), "cannot increase earliest available slot"))
-	})
-
-	t.Run("Prevent increase at epoch boundary - slot precision matters", func(t *testing.T) {
-		minEpochsForBlocks := primitives.Epoch(params.BeaconConfig().MinEpochsForBlockRequests)
-		currentEpoch := minEpochsForBlocks + 976 // Current epoch
-		currentSlot := primitives.Slot(currentEpoch) * primitives.Slot(params.BeaconConfig().SlotsPerEpoch)
-
-		minRequiredEpoch := currentEpoch - minEpochsForBlocks                                                              // = 976
-		storedEarliestSlot := primitives.Slot(minRequiredEpoch)*primitives.Slot(params.BeaconConfig().SlotsPerEpoch) - 232 // Before minRequired
-
-		// Try to set earliest to slot 8 of the minRequiredEpoch (should fail with slot comparison)
-		attemptedSlot := primitives.Slot(minRequiredEpoch)*primitives.Slot(params.BeaconConfig().SlotsPerEpoch) + 8
-
-		service := &Service{
-			genesisTime: time.Now().Add(-time.Duration(currentSlot) * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second),
-			custodyInfo: &custodyInfo{
-				earliestAvailableSlot: storedEarliestSlot,
-				groupCount:            5,
-			},
-		}
-
-		err := service.UpdateEarliestAvailableSlot(attemptedSlot)
-
-		require.NotNil(t, err, "Should prevent increasing earliest slot beyond the minimum required SLOT (not just epoch)")
-		require.Equal(t, true, strings.Contains(err.Error(), "cannot increase earliest available slot"))
-	})
-
-	t.Run("Prevent increase within MIN_EPOCHS_FOR_BLOCK_REQUESTS - early in chain", func(t *testing.T) {
-		minEpochsForBlocks := primitives.Epoch(params.BeaconConfig().MinEpochsForBlockRequests)
-		currentEpoch := minEpochsForBlocks - 10 // Early in chain, BEFORE we have MIN_EPOCHS_FOR_BLOCK_REQUESTS of history
-		currentSlot := primitives.Slot(currentEpoch) * primitives.Slot(params.BeaconConfig().SlotsPerEpoch)
-
-		// Current earliest slot is at slot 100
-		currentEarliestSlot := primitives.Slot(100)
-
-		// Try to increase earliest slot to slot 1000 (which would be within the mandatory window from currentSlot)
-		attemptedSlot := primitives.Slot(1000)
-
-		service := &Service{
-			genesisTime: time.Now().Add(-time.Duration(currentSlot) * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second),
-			custodyInfo: &custodyInfo{
-				earliestAvailableSlot: currentEarliestSlot,
-				groupCount:            5,
-			},
-		}
-
-		err := service.UpdateEarliestAvailableSlot(attemptedSlot)
-
-		require.NotNil(t, err, "Should prevent increasing earliest slot within the mandatory retention window, even early in chain")
-		require.Equal(t, true, strings.Contains(err.Error(), "cannot increase earliest available slot"))
-	})
-
-	t.Run("Nil custody info - should return error", func(t *testing.T) {
-		service := &Service{
-			genesisTime: time.Now(),
-			custodyInfo: nil, // No custody info set
-		}
-
-		err := service.UpdateEarliestAvailableSlot(100)
-
-		require.NotNil(t, err)
-		require.Equal(t, true, strings.Contains(err.Error(), "no custody info available"))
-	})
-}
-
 func TestCustodyGroupCountFromPeer(t *testing.T) {
 	const (
 		expectedENR      uint64 = 7

beacon-chain/p2p/gossip_topic_mappings.go

@@ -32,9 +32,6 @@ var gossipTopicMappings = map[string]func() proto.Message{
 func GossipTopicMappings(topic string, epoch primitives.Epoch) proto.Message {
 	switch topic {
 	case BlockSubnetTopicFormat:
-		if epoch >= params.BeaconConfig().GloasForkEpoch {
-			return &ethpb.SignedBeaconBlockGloas{}
-		}
 		if epoch >= params.BeaconConfig().FuluForkEpoch {
 			return &ethpb.SignedBeaconBlockFulu{}
 		}
@@ -147,7 +144,4 @@ func init() {
 
 	// Specially handle Fulu objects.
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockFulu{})] = BlockSubnetTopicFormat
-
-	// Specially handle Gloas objects.
-	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockGloas{})] = BlockSubnetTopicFormat
 }

beacon-chain/p2p/interfaces.go

@@ -126,7 +126,6 @@ type (
 		EarliestAvailableSlot(ctx context.Context) (primitives.Slot, error)
 		CustodyGroupCount(ctx context.Context) (uint64, error)
 		UpdateCustodyInfo(earliestAvailableSlot primitives.Slot, custodyGroupCount uint64) (primitives.Slot, uint64, error)
-		UpdateEarliestAvailableSlot(earliestAvailableSlot primitives.Slot) error
 		CustodyGroupCountFromPeer(peer.ID) uint64
 	}
 )

beacon-chain/p2p/testing/fuzz_p2p.go

@@ -213,11 +213,6 @@ func (s *FakeP2P) UpdateCustodyInfo(earliestAvailableSlot primitives.Slot, custo
 	return earliestAvailableSlot, custodyGroupCount, nil
 }
 
-// UpdateEarliestAvailableSlot -- fake.
-func (*FakeP2P) UpdateEarliestAvailableSlot(earliestAvailableSlot primitives.Slot) error {
-	return nil
-}
-
 // CustodyGroupCountFromPeer -- fake.
 func (*FakeP2P) CustodyGroupCountFromPeer(peer.ID) uint64 {
 	return 0

beacon-chain/p2p/testing/p2p.go

@@ -499,15 +499,6 @@ func (s *TestP2P) UpdateCustodyInfo(earliestAvailableSlot primitives.Slot, custo
 	return s.earliestAvailableSlot, s.custodyGroupCount, nil
 }
 
-// UpdateEarliestAvailableSlot .
-func (s *TestP2P) UpdateEarliestAvailableSlot(earliestAvailableSlot primitives.Slot) error {
-	s.custodyInfoMut.Lock()
-	defer s.custodyInfoMut.Unlock()
-
-	s.earliestAvailableSlot = earliestAvailableSlot
-	return nil
-}
-
 // CustodyGroupCountFromPeer retrieves custody group count from a peer.
 // It first tries to get the custody group count from the peer's metadata,
 // then falls back to the ENR value if the metadata is not available, then

beacon-chain/p2p/types/object_mapping.go

@@ -85,11 +85,6 @@ func InitializeDataMaps() {
 				&ethpb.SignedBeaconBlockFulu{Block: &ethpb.BeaconBlockElectra{Body: &ethpb.BeaconBlockBodyElectra{ExecutionPayload: &enginev1.ExecutionPayloadDeneb{}}}},
 			)
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().GloasForkVersion): func() (interfaces.ReadOnlySignedBeaconBlock, error) {
-			return blocks.NewSignedBeaconBlock(
-				&ethpb.SignedBeaconBlockGloas{Block: &ethpb.BeaconBlockGloas{Body: &ethpb.BeaconBlockBodyGloas{ExecutionPayload: &enginev1.ExecutionPayloadGloas{}}}},
-			)
-		},
 	}
 
 	// Reset our metadata map.
@@ -115,9 +110,6 @@ func InitializeDataMaps() {
 		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (metadata.Metadata, error) {
 			return wrapper.WrappedMetadataV2(&ethpb.MetaDataV2{}), nil
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().GloasForkVersion): func() (metadata.Metadata, error) {
-			return wrapper.WrappedMetadataV2(&ethpb.MetaDataV2{}), nil
-		},
 	}
 
 	// Reset our attestation map.
@@ -143,9 +135,6 @@ func InitializeDataMaps() {
 		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (ethpb.Att, error) {
 			return &ethpb.SingleAttestation{}, nil
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().GloasForkVersion): func() (ethpb.Att, error) {
-			return &ethpb.SingleAttestation{}, nil
-		},
 	}
 
 	// Reset our aggregate attestation map.
@@ -171,9 +160,6 @@ func InitializeDataMaps() {
 		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
 			return &ethpb.SignedAggregateAttestationAndProofElectra{}, nil
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().GloasForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
-			return &ethpb.SignedAggregateAttestationAndProofElectra{}, nil
-		},
 	}
 
 	// Reset our aggregate attestation map.
@@ -199,9 +185,6 @@ func InitializeDataMaps() {
 		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (ethpb.AttSlashing, error) {
 			return &ethpb.AttesterSlashingElectra{}, nil
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().GloasForkVersion): func() (ethpb.AttSlashing, error) {
-			return &ethpb.AttesterSlashingElectra{}, nil
-		},
 	}
 
 	// Reset our light client optimistic update map.
@@ -221,12 +204,6 @@ func InitializeDataMaps() {
 		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (interfaces.LightClientOptimisticUpdate, error) {
 			return lightclientConsensusTypes.NewEmptyOptimisticUpdateDeneb(), nil
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (interfaces.LightClientOptimisticUpdate, error) {
-			return lightclientConsensusTypes.NewEmptyOptimisticUpdateDeneb(), nil
-		},
-		bytesutil.ToBytes4(params.BeaconConfig().GloasForkVersion): func() (interfaces.LightClientOptimisticUpdate, error) {
-			return lightclientConsensusTypes.NewEmptyOptimisticUpdateDeneb(), nil
-		},
 	}
 
 	// Reset our light client finality update map.
@@ -246,11 +223,5 @@ func InitializeDataMaps() {
 		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (interfaces.LightClientFinalityUpdate, error) {
 			return lightclientConsensusTypes.NewEmptyFinalityUpdateElectra(), nil
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (interfaces.LightClientFinalityUpdate, error) {
-			return lightclientConsensusTypes.NewEmptyFinalityUpdateElectra(), nil
-		},
-		bytesutil.ToBytes4(params.BeaconConfig().GloasForkVersion): func() (interfaces.LightClientFinalityUpdate, error) {
-			return lightclientConsensusTypes.NewEmptyFinalityUpdateElectra(), nil
-		},
 	}
 }

beacon-chain/p2p/utils.go

@@ -68,10 +68,7 @@ func privKey(cfg *Config) (*ecdsa.PrivateKey, error) {
 	}
 
 	if defaultKeysExist {
-		if !params.FuluEnabled() {
-			log.WithField("filePath", defaultKeyPath).Info("Reading static P2P private key from a file. To generate a new random private key at every start, please remove this file.")
-		}
-
+		log.WithField("filePath", defaultKeyPath).Info("Reading static P2P private key from a file. To generate a new random private key at every start, please remove this file.")
 		return privKeyFromFile(defaultKeyPath)
 	}
 

beacon-chain/rpc/endpoints.go

@@ -97,7 +97,7 @@ func (s *Service) endpoints(
 	endpoints = append(endpoints, s.beaconEndpoints(ch, stater, blocker, validatorServer, coreService)...)
 	endpoints = append(endpoints, s.configEndpoints()...)
 	endpoints = append(endpoints, s.eventsEndpoints()...)
-	endpoints = append(endpoints, s.prysmBeaconEndpoints(ch, stater, blocker, coreService)...)
+	endpoints = append(endpoints, s.prysmBeaconEndpoints(ch, stater, coreService)...)
 	endpoints = append(endpoints, s.prysmNodeEndpoints()...)
 	endpoints = append(endpoints, s.prysmValidatorEndpoints(stater, coreService)...)
 
@@ -1184,7 +1184,6 @@ func (s *Service) eventsEndpoints() []endpoint {
 func (s *Service) prysmBeaconEndpoints(
 	ch *stategen.CanonicalHistory,
 	stater lookup.Stater,
-	blocker lookup.Blocker,
 	coreService *core.Service,
 ) []endpoint {
 	server := &beaconprysm.Server{
@@ -1195,7 +1194,6 @@ func (s *Service) prysmBeaconEndpoints(
 		CanonicalHistory:      ch,
 		BeaconDB:              s.cfg.BeaconDB,
 		Stater:                stater,
-		Blocker:               blocker,
 		ChainInfoFetcher:      s.cfg.ChainInfoFetcher,
 		FinalizationFetcher:   s.cfg.FinalizationFetcher,
 		CoreService:           coreService,
@@ -1268,28 +1266,6 @@ func (s *Service) prysmBeaconEndpoints(
 			handler: server.PublishBlobs,
 			methods: []string{http.MethodPost},
 		},
-		{
-			template: "/prysm/v1/beacon/states/{state_id}/query",
-			name:     namespace + ".QueryBeaconState",
-			middleware: []middleware.Middleware{
-				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
-				middleware.AcceptHeaderHandler([]string{api.OctetStreamMediaType}),
-				middleware.AcceptEncodingHeaderHandler(),
-			},
-			handler: server.QueryBeaconState,
-			methods: []string{http.MethodPost},
-		},
-		{
-			template: "/prysm/v1/beacon/blocks/{block_id}/query",
-			name:     namespace + ".QueryBeaconBlock",
-			middleware: []middleware.Middleware{
-				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
-				middleware.AcceptHeaderHandler([]string{api.OctetStreamMediaType}),
-				middleware.AcceptEncodingHeaderHandler(),
-			},
-			handler: server.QueryBeaconBlock,
-			methods: []string{http.MethodPost},
-		},
 	}
 }
 

beacon-chain/rpc/endpoints_test.go

@@ -127,8 +127,6 @@ func Test_endpoints(t *testing.T) {
 		"/prysm/v1/beacon/states/{state_id}/validator_count": {http.MethodGet},
 		"/prysm/v1/beacon/chain_head":                        {http.MethodGet},
 		"/prysm/v1/beacon/blobs":                             {http.MethodPost},
-		"/prysm/v1/beacon/states/{state_id}/query":           {http.MethodPost},
-		"/prysm/v1/beacon/blocks/{block_id}/query":           {http.MethodPost},
 	}
 
 	prysmNodeRoutes := map[string][]string{

beacon-chain/rpc/prysm/beacon/BUILD.bazel

@@ -5,13 +5,11 @@ go_library(
     srcs = [
         "handlers.go",
         "server.go",
-        "ssz_query.go",
         "validator_count.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/prysm/beacon",
     visibility = ["//visibility:public"],
     deps = [
-        "//api:go_default_library",
         "//api/server/structs:go_default_library",
         "//beacon-chain/blockchain:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
@@ -29,13 +27,10 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/validator:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//encoding/ssz/query:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
         "//network/httputil:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/ssz_query:go_default_library",
-        "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
@@ -46,12 +41,10 @@ go_test(
     name = "go_default_test",
     srcs = [
         "handlers_test.go",
-        "ssz_query_test.go",
         "validator_count_test.go",
     ],
     embed = [":go_default_library"],
     deps = [
-        "//api:go_default_library",
         "//api/server/structs:go_default_library",
         "//beacon-chain/blockchain/testing:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
@@ -70,13 +63,10 @@ go_test(
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//network/httputil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/ssz_query:go_default_library",
-        "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",

beacon-chain/rpc/prysm/beacon/server.go

@@ -18,7 +18,6 @@ type Server struct {
 	CanonicalHistory      *stategen.CanonicalHistory
 	BeaconDB              beacondb.ReadOnlyDatabase
 	Stater                lookup.Stater
-	Blocker               lookup.Blocker
 	ChainInfoFetcher      blockchain.ChainInfoFetcher
 	FinalizationFetcher   blockchain.FinalizationFetcher
 	CoreService           *core.Service

beacon-chain/rpc/prysm/beacon/ssz_query.go

@@ -1,202 +0,0 @@
-package beacon
-
-import (
-	"encoding/json"
-	"errors"
-	"io"
-	"net/http"
-
-	"github.com/OffchainLabs/prysm/v6/api"
-	"github.com/OffchainLabs/prysm/v6/api/server/structs"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/eth/shared"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/lookup"
-	"github.com/OffchainLabs/prysm/v6/encoding/ssz/query"
-	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
-	"github.com/OffchainLabs/prysm/v6/network/httputil"
-	sszquerypb "github.com/OffchainLabs/prysm/v6/proto/ssz_query"
-	"github.com/OffchainLabs/prysm/v6/runtime/version"
-)
-
-// QueryBeaconState handles SSZ Query request for BeaconState.
-// Returns as bytes serialized SSZQueryResponse.
-func (s *Server) QueryBeaconState(w http.ResponseWriter, r *http.Request) {
-	ctx, span := trace.StartSpan(r.Context(), "beacon.QueryBeaconState")
-	defer span.End()
-
-	stateID := r.PathValue("state_id")
-	if stateID == "" {
-		httputil.HandleError(w, "state_id is required in URL params", http.StatusBadRequest)
-		return
-	}
-
-	// Validate path before lookup: it might be expensive.
-	var req structs.SSZQueryRequest
-	err := json.NewDecoder(r.Body).Decode(&req)
-	switch {
-	case errors.Is(err, io.EOF):
-		httputil.HandleError(w, "No data submitted", http.StatusBadRequest)
-		return
-	case err != nil:
-		httputil.HandleError(w, "Could not decode request body: "+err.Error(), http.StatusBadRequest)
-		return
-	}
-
-	if len(req.Query) == 0 {
-		httputil.HandleError(w, "Empty query submitted", http.StatusBadRequest)
-		return
-	}
-
-	path, err := query.ParsePath(req.Query)
-	if err != nil {
-		httputil.HandleError(w, "Could not parse path '"+req.Query+"': "+err.Error(), http.StatusBadRequest)
-		return
-	}
-
-	stateRoot, err := s.Stater.StateRoot(ctx, []byte(stateID))
-	if err != nil {
-		var rootNotFoundErr *lookup.StateRootNotFoundError
-		if errors.As(err, &rootNotFoundErr) {
-			httputil.HandleError(w, "State root not found: "+rootNotFoundErr.Error(), http.StatusNotFound)
-			return
-		}
-		httputil.HandleError(w, "Could not get state root: "+err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	st, err := s.Stater.State(ctx, []byte(stateID))
-	if err != nil {
-		shared.WriteStateFetchError(w, err)
-		return
-	}
-
-	// NOTE: Using unsafe conversion to proto is acceptable here,
-	// as we play with a copy of the state returned by Stater.
-	sszObject, ok := st.ToProtoUnsafe().(query.SSZObject)
-	if !ok {
-		httputil.HandleError(w, "Unsupported state version for querying: "+version.String(st.Version()), http.StatusBadRequest)
-		return
-	}
-
-	info, err := query.AnalyzeObject(sszObject)
-	if err != nil {
-		httputil.HandleError(w, "Could not analyze state object: "+err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	_, offset, length, err := query.CalculateOffsetAndLength(info, path)
-	if err != nil {
-		httputil.HandleError(w, "Could not calculate offset and length for path '"+req.Query+"': "+err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	encodedState, err := st.MarshalSSZ()
-	if err != nil {
-		httputil.HandleError(w, "Could not marshal state to SSZ: "+err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	response := &sszquerypb.SSZQueryResponse{
-		Root:   stateRoot,
-		Result: encodedState[offset : offset+length],
-	}
-
-	responseSsz, err := response.MarshalSSZ()
-	if err != nil {
-		httputil.HandleError(w, "Could not marshal response to SSZ: "+err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	w.Header().Set(api.VersionHeader, version.String(st.Version()))
-	httputil.WriteSsz(w, responseSsz)
-}
-
-// QueryBeaconState handles SSZ Query request for BeaconState.
-// Returns as bytes serialized SSZQueryResponse.
-func (s *Server) QueryBeaconBlock(w http.ResponseWriter, r *http.Request) {
-	ctx, span := trace.StartSpan(r.Context(), "beacon.QueryBeaconBlock")
-	defer span.End()
-
-	blockId := r.PathValue("block_id")
-	if blockId == "" {
-		httputil.HandleError(w, "block_id is required in URL params", http.StatusBadRequest)
-		return
-	}
-
-	// Validate path before lookup: it might be expensive.
-	var req structs.SSZQueryRequest
-	err := json.NewDecoder(r.Body).Decode(&req)
-	switch {
-	case errors.Is(err, io.EOF):
-		httputil.HandleError(w, "No data submitted", http.StatusBadRequest)
-		return
-	case err != nil:
-		httputil.HandleError(w, "Could not decode request body: "+err.Error(), http.StatusBadRequest)
-		return
-	}
-
-	if len(req.Query) == 0 {
-		httputil.HandleError(w, "Empty query submitted", http.StatusBadRequest)
-		return
-	}
-
-	path, err := query.ParsePath(req.Query)
-	if err != nil {
-		httputil.HandleError(w, "Could not parse path '"+req.Query+"': "+err.Error(), http.StatusBadRequest)
-		return
-	}
-
-	signedBlock, err := s.Blocker.Block(ctx, []byte(blockId))
-	if !shared.WriteBlockFetchError(w, signedBlock, err) {
-		return
-	}
-
-	protoBlock, err := signedBlock.Block().Proto()
-	if err != nil {
-		httputil.HandleError(w, "Could not convert block to proto: "+err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	block, ok := protoBlock.(query.SSZObject)
-	if !ok {
-		httputil.HandleError(w, "Unsupported block version for querying: "+version.String(signedBlock.Version()), http.StatusBadRequest)
-		return
-	}
-
-	info, err := query.AnalyzeObject(block)
-	if err != nil {
-		httputil.HandleError(w, "Could not analyze block object: "+err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	_, offset, length, err := query.CalculateOffsetAndLength(info, path)
-	if err != nil {
-		httputil.HandleError(w, "Could not calculate offset and length for path '"+req.Query+"': "+err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	encodedBlock, err := signedBlock.Block().MarshalSSZ()
-	if err != nil {
-		httputil.HandleError(w, "Could not marshal block to SSZ: "+err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	blockRoot, err := block.HashTreeRoot()
-	if err != nil {
-		httputil.HandleError(w, "Could not compute block root: "+err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	response := &sszquerypb.SSZQueryResponse{
-		Root:   blockRoot[:],
-		Result: encodedBlock[offset : offset+length],
-	}
-
-	responseSsz, err := response.MarshalSSZ()
-	if err != nil {
-		httputil.HandleError(w, "Could not marshal response to SSZ: "+err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	w.Header().Set(api.VersionHeader, version.String(signedBlock.Version()))
-	httputil.WriteSsz(w, responseSsz)
-}

beacon-chain/rpc/prysm/beacon/ssz_query_test.go

@@ -1,335 +0,0 @@
-package beacon
-
-import (
-	"bytes"
-	"context"
-	"encoding/binary"
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/api"
-	"github.com/OffchainLabs/prysm/v6/api/server/structs"
-	chainMock "github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/testing"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/testutil"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-	eth "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	sszquerypb "github.com/OffchainLabs/prysm/v6/proto/ssz_query"
-	"github.com/OffchainLabs/prysm/v6/runtime/version"
-	"github.com/OffchainLabs/prysm/v6/testing/assert"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/OffchainLabs/prysm/v6/testing/util"
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/prysmaticlabs/go-bitfield"
-)
-
-func TestQueryBeaconState(t *testing.T) {
-	ctx := context.Background()
-
-	st, _ := util.DeterministicGenesisState(t, 16)
-	require.NoError(t, st.SetSlot(primitives.Slot(42)))
-	stateRoot, err := st.HashTreeRoot(ctx)
-	require.NoError(t, err)
-	require.NoError(t, st.UpdateBalancesAtIndex(0, 42000000000))
-
-	tests := []struct {
-		path          string
-		expectedValue []byte
-	}{
-		{
-			path: ".slot",
-			expectedValue: func() []byte {
-				slot := st.Slot()
-				result, _ := slot.MarshalSSZ()
-				return result
-			}(),
-		},
-		{
-			path: ".latest_block_header",
-			expectedValue: func() []byte {
-				header := st.LatestBlockHeader()
-				result, _ := header.MarshalSSZ()
-				return result
-			}(),
-		},
-		{
-			path: ".validators",
-			expectedValue: func() []byte {
-				b := make([]byte, 0)
-				validators := st.Validators()
-				for _, v := range validators {
-					vBytes, _ := v.MarshalSSZ()
-					b = append(b, vBytes...)
-				}
-				return b
-
-			}(),
-		},
-		{
-			path: ".validators[0]",
-			expectedValue: func() []byte {
-				v, _ := st.ValidatorAtIndex(0)
-				result, _ := v.MarshalSSZ()
-				return result
-			}(),
-		},
-		{
-			path: ".validators[0].withdrawal_credentials",
-			expectedValue: func() []byte {
-				v, _ := st.ValidatorAtIndex(0)
-				return v.WithdrawalCredentials
-			}(),
-		},
-		{
-			path: ".validators[0].effective_balance",
-			expectedValue: func() []byte {
-				v, _ := st.ValidatorAtIndex(0)
-				b := make([]byte, 8)
-				binary.LittleEndian.PutUint64(b, uint64(v.EffectiveBalance))
-				return b
-			}(),
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.path, func(t *testing.T) {
-			chainService := &chainMock.ChainService{Optimistic: false, FinalizedRoots: make(map[[32]byte]bool)}
-			s := &Server{
-				OptimisticModeFetcher: chainService,
-				FinalizationFetcher:   chainService,
-				Stater: &testutil.MockStater{
-					BeaconStateRoot: stateRoot[:],
-					BeaconState:     st,
-				},
-			}
-
-			requestBody := &structs.SSZQueryRequest{
-				Query: tt.path,
-			}
-			var buf bytes.Buffer
-			require.NoError(t, json.NewEncoder(&buf).Encode(requestBody))
-
-			request := httptest.NewRequest(http.MethodPost, "http://example.com/prysm/v1/beacon/states/{state_id}/query", &buf)
-			request.SetPathValue("state_id", "head")
-			writer := httptest.NewRecorder()
-			writer.Body = &bytes.Buffer{}
-
-			s.QueryBeaconState(writer, request)
-			require.Equal(t, http.StatusOK, writer.Code)
-			assert.Equal(t, version.String(version.Phase0), writer.Header().Get(api.VersionHeader))
-
-			expectedResponse := &sszquerypb.SSZQueryResponse{
-				Root:   stateRoot[:],
-				Result: tt.expectedValue,
-			}
-			sszExpectedResponse, err := expectedResponse.MarshalSSZ()
-			require.NoError(t, err)
-			assert.DeepEqual(t, sszExpectedResponse, writer.Body.Bytes())
-		})
-	}
-}
-
-func TestQueryBeaconStateInvalidRequest(t *testing.T) {
-	ctx := context.Background()
-
-	st, _ := util.DeterministicGenesisState(t, 16)
-	require.NoError(t, st.SetSlot(primitives.Slot(42)))
-	stateRoot, err := st.HashTreeRoot(ctx)
-	require.NoError(t, err)
-
-	tests := []struct {
-		name        string
-		stateId     string
-		path        string
-		code        int
-		errorString string
-	}{
-		{
-			name:        "empty query submitted",
-			stateId:     "head",
-			path:        "",
-			errorString: "Empty query submitted",
-		},
-		{
-			name:        "invalid path",
-			stateId:     "head",
-			path:        ".invalid[]]",
-			errorString: "Could not parse path",
-		},
-		{
-			name:        "non-existent field",
-			stateId:     "head",
-			path:        ".non_existent_field",
-			code:        http.StatusInternalServerError,
-			errorString: "Could not calculate offset and length for path",
-		},
-		{
-			name:    "empty state ID",
-			stateId: "",
-			path:    "",
-		},
-		{
-			name:    "far future slot",
-			stateId: "1000000000000",
-			path:    "",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.path, func(t *testing.T) {
-			chainService := &chainMock.ChainService{Optimistic: false, FinalizedRoots: make(map[[32]byte]bool)}
-			s := &Server{
-				OptimisticModeFetcher: chainService,
-				FinalizationFetcher:   chainService,
-				Stater: &testutil.MockStater{
-					BeaconStateRoot: stateRoot[:],
-					BeaconState:     st,
-				},
-			}
-
-			requestBody := &structs.SSZQueryRequest{
-				Query: tt.path,
-			}
-			var buf bytes.Buffer
-			require.NoError(t, json.NewEncoder(&buf).Encode(requestBody))
-
-			request := httptest.NewRequest(http.MethodPost, "http://example.com/prysm/v1/beacon/states/{state_id}/query", &buf)
-			request.SetPathValue("state_id", tt.stateId)
-			writer := httptest.NewRecorder()
-			writer.Body = &bytes.Buffer{}
-
-			s.QueryBeaconState(writer, request)
-
-			if tt.code == 0 {
-				tt.code = http.StatusBadRequest
-			}
-			require.Equal(t, tt.code, writer.Code)
-			if tt.errorString != "" {
-				errorString := writer.Body.String()
-				require.Equal(t, true, strings.Contains(errorString, tt.errorString))
-			}
-		})
-	}
-}
-
-func TestQueryBeaconBlock(t *testing.T) {
-	randaoReveal, err := hexutil.Decode("0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505")
-	require.NoError(t, err)
-	root, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-	require.NoError(t, err)
-	signature, err := hexutil.Decode("0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505")
-	require.NoError(t, err)
-	att := &eth.Attestation{
-		AggregationBits: bitfield.Bitlist{0x01},
-		Data: &eth.AttestationData{
-			Slot:            1,
-			CommitteeIndex:  1,
-			BeaconBlockRoot: root,
-			Source: &eth.Checkpoint{
-				Epoch: 1,
-				Root:  root,
-			},
-			Target: &eth.Checkpoint{
-				Epoch: 1,
-				Root:  root,
-			},
-		},
-		Signature: signature,
-	}
-
-	tests := []struct {
-		name          string
-		path          string
-		block         interfaces.ReadOnlySignedBeaconBlock
-		expectedValue []byte
-	}{
-		{
-			name: "slot",
-			path: ".slot",
-			block: func() interfaces.ReadOnlySignedBeaconBlock {
-				b := util.NewBeaconBlock()
-				b.Block.Slot = 123
-				sb, err := blocks.NewSignedBeaconBlock(b)
-				require.NoError(t, err)
-				return sb
-			}(),
-			expectedValue: func() []byte {
-				b := make([]byte, 8)
-				binary.LittleEndian.PutUint64(b, 123)
-				return b
-			}(),
-		},
-		{
-			name: "randao_reveal",
-			path: ".body.randao_reveal",
-			block: func() interfaces.ReadOnlySignedBeaconBlock {
-				b := util.NewBeaconBlock()
-				b.Block.Body.RandaoReveal = randaoReveal
-				sb, err := blocks.NewSignedBeaconBlock(b)
-				require.NoError(t, err)
-				return sb
-			}(),
-			expectedValue: randaoReveal,
-		},
-		{
-			name: "attestations",
-			path: ".body.attestations",
-			block: func() interfaces.ReadOnlySignedBeaconBlock {
-				b := util.NewBeaconBlock()
-				b.Block.Body.Attestations = []*eth.Attestation{
-					att,
-				}
-				sb, err := blocks.NewSignedBeaconBlock(b)
-				require.NoError(t, err)
-				return sb
-			}(),
-			expectedValue: func() []byte {
-				b, err := att.MarshalSSZ()
-				require.NoError(t, err)
-				return b
-			}(),
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: tt.block}
-			mockChainService := &chainMock.ChainService{
-				FinalizedRoots: map[[32]byte]bool{},
-			}
-			s := &Server{
-				FinalizationFetcher: mockChainService,
-				Blocker:             mockBlockFetcher,
-			}
-			requestBody := &structs.SSZQueryRequest{
-				Query: tt.path,
-			}
-			var buf bytes.Buffer
-			require.NoError(t, json.NewEncoder(&buf).Encode(requestBody))
-
-			request := httptest.NewRequest(http.MethodPost, "http://example.com/prysm/v1/beacon/blocks/{block_id}/query", &buf)
-			request.SetPathValue("block_id", "head")
-			writer := httptest.NewRecorder()
-			writer.Body = &bytes.Buffer{}
-
-			s.QueryBeaconBlock(writer, request)
-			require.Equal(t, http.StatusOK, writer.Code)
-			assert.Equal(t, version.String(version.Phase0), writer.Header().Get(api.VersionHeader))
-
-			blockRoot, err := tt.block.Block().HashTreeRoot()
-			require.NoError(t, err)
-
-			expectedResponse := &sszquerypb.SSZQueryResponse{
-				Root:   blockRoot[:],
-				Result: tt.expectedValue,
-			}
-			sszExpectedResponse, err := expectedResponse.MarshalSSZ()
-			require.NoError(t, err)
-			assert.DeepEqual(t, sszExpectedResponse, writer.Body.Bytes())
-		})
-	}
-}

beacon-chain/rpc/prysm/v1alpha1/validator/construct_generic_block.go

@@ -57,12 +57,6 @@ func (vs *Server) constructGenericBeaconBlock(
 			return nil, fmt.Errorf("expected *BlobsBundleV2, got %T", blobsBundler)
 		}
 		return vs.constructFuluBlock(blockProto, isBlinded, bidStr, bundle), nil
-	case version.Gloas:
-		bundle, ok := blobsBundler.(*enginev1.BlobsBundleV2)
-		if blobsBundler != nil && !ok {
-			return nil, fmt.Errorf("expected *BlobsBundleV2, got %T", blobsBundler)
-		}
-		return vs.constructGloasBlock(blockProto, isBlinded, bidStr, bundle), nil
 	default:
 		return nil, fmt.Errorf("unknown block version: %d", sBlk.Version())
 	}
@@ -126,12 +120,3 @@ func (vs *Server) constructFuluBlock(blockProto proto.Message, isBlinded bool, p
 	}
 	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Fulu{Fulu: fuluContents}, IsBlinded: false, PayloadValue: payloadValue}
 }
-
-func (vs *Server) constructGloasBlock(blockProto proto.Message, isBlinded bool, payloadValue string, bundle *enginev1.BlobsBundleV2) *ethpb.GenericBeaconBlock {
-	gloasContents := &ethpb.BeaconBlockContentsGloas{Block: blockProto.(*ethpb.BeaconBlockGloas)}
-	if bundle != nil {
-		gloasContents.KzgProofs = bundle.Proofs
-		gloasContents.Blobs = bundle.Blobs
-	}
-	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Gloas{Gloas: gloasContents}, IsBlinded: false, PayloadValue: payloadValue}
-}

beacon-chain/rpc/prysm/v1alpha1/validator/proposer.go

@@ -229,7 +229,7 @@ func (vs *Server) BuildBlockParallel(ctx context.Context, sBlk interfaces.Signed
 		sBlk.SetVoluntaryExits(vs.getExits(head, sBlk.Block().Slot()))
 
 		// Set sync aggregate. New in Altair.
-		vs.setSyncAggregate(ctx, sBlk, head)
+		vs.setSyncAggregate(ctx, sBlk)
 
 		// Set bls to execution change. New in Capella.
 		vs.setBlsToExecData(sBlk, head)
@@ -300,7 +300,7 @@ func (vs *Server) ProposeBeaconBlock(ctx context.Context, req *ethpb.GenericSign
 		return nil, status.Errorf(codes.Internal, "Could not hash tree root: %v", err)
 	}
 
-	// For post-Fulu blinded blocks (including Gloas), submit to relay and return early
+	// For post-Fulu blinded blocks, submit to relay and return early
 	if block.IsBlinded() && slots.ToEpoch(block.Block().Slot()) >= params.BeaconConfig().FuluForkEpoch {
 		err := vs.BlockBuilder.SubmitBlindedBlockPostFulu(ctx, block)
 		if err != nil {
@@ -370,7 +370,7 @@ func (vs *Server) broadcastAndReceiveSidecars(
 }
 
 // handleBlindedBlock processes blinded beacon blocks (pre-Fulu only).
-// Post-Fulu blinded blocks (including Gloas) are handled directly in ProposeBeaconBlock.
+// Post-Fulu blinded blocks are handled directly in ProposeBeaconBlock.
 func (vs *Server) handleBlindedBlock(ctx context.Context, block interfaces.SignedBeaconBlock) (interfaces.SignedBeaconBlock, []*ethpb.BlobSidecar, error) {
 	if block.Version() < version.Bellatrix {
 		return nil, nil, errors.New("pre-Bellatrix blinded block")
@@ -640,9 +640,6 @@ func blobsAndProofs(req *ethpb.GenericSignedBeaconBlock) ([][]byte, [][]byte, er
 	case req.GetFulu() != nil:
 		dbBlockContents := req.GetFulu()
 		return dbBlockContents.Blobs, dbBlockContents.KzgProofs, nil
-	case req.GetGloas() != nil:
-		dbBlockContents := req.GetGloas()
-		return dbBlockContents.Blobs, dbBlockContents.KzgProofs, nil
 	default:
 		return nil, nil, errors.Errorf("unknown request type provided: %T", req)
 	}

beacon-chain/rpc/prysm/v1alpha1/validator/proposer_altair.go

@@ -5,7 +5,6 @@ import (
 	"context"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
@@ -21,12 +20,12 @@ import (
 	"github.com/prysmaticlabs/go-bitfield"
 )
 
-func (vs *Server) setSyncAggregate(ctx context.Context, blk interfaces.SignedBeaconBlock, headState state.BeaconState) {
+func (vs *Server) setSyncAggregate(ctx context.Context, blk interfaces.SignedBeaconBlock) {
 	if blk.Version() < version.Altair {
 		return
 	}
 
-	syncAggregate, err := vs.getSyncAggregate(ctx, slots.PrevSlot(blk.Block().Slot()), blk.Block().ParentRoot(), headState)
+	syncAggregate, err := vs.getSyncAggregate(ctx, slots.PrevSlot(blk.Block().Slot()), blk.Block().ParentRoot())
 	if err != nil {
 		log.WithError(err).Error("Could not get sync aggregate")
 		emptySig := [96]byte{0xC0}
@@ -48,7 +47,7 @@ func (vs *Server) setSyncAggregate(ctx context.Context, blk interfaces.SignedBea
 
 // getSyncAggregate retrieves the sync contributions from the pool to construct the sync aggregate object.
 // The contributions are filtered based on matching of the input root and slot then profitability.
-func (vs *Server) getSyncAggregate(ctx context.Context, slot primitives.Slot, root [32]byte, headState state.BeaconState) (*ethpb.SyncAggregate, error) {
+func (vs *Server) getSyncAggregate(ctx context.Context, slot primitives.Slot, root [32]byte) (*ethpb.SyncAggregate, error) {
 	_, span := trace.StartSpan(ctx, "ProposerServer.getSyncAggregate")
 	defer span.End()
 
@@ -63,7 +62,7 @@ func (vs *Server) getSyncAggregate(ctx context.Context, slot primitives.Slot, ro
 	// Contributions have to match the input root
 	proposerContributions := proposerSyncContributions(poolContributions).filterByBlockRoot(root)
 
-	aggregatedContributions, err := vs.aggregatedSyncCommitteeMessages(ctx, slot, root, poolContributions, headState)
+	aggregatedContributions, err := vs.aggregatedSyncCommitteeMessages(ctx, slot, root, poolContributions)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get aggregated sync committee messages")
 	}
@@ -124,7 +123,6 @@ func (vs *Server) aggregatedSyncCommitteeMessages(
 	slot primitives.Slot,
 	root [32]byte,
 	poolContributions []*ethpb.SyncCommitteeContribution,
-	st state.BeaconState,
 ) ([]*ethpb.SyncCommitteeContribution, error) {
 	subcommitteeCount := params.BeaconConfig().SyncCommitteeSubnetCount
 	subcommitteeSize := params.BeaconConfig().SyncCommitteeSize / subcommitteeCount
@@ -148,7 +146,10 @@ func (vs *Server) aggregatedSyncCommitteeMessages(
 			messageSigs = append(messageSigs, msg.Signature)
 		}
 	}
-
+	st, err := vs.HeadFetcher.HeadState(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get head state")
+	}
 	positions, err := helpers.CurrentPeriodPositions(st, messageIndices)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get sync committee positions")

beacon-chain/rpc/prysm/v1alpha1/validator/proposer_altair_test.go

@@ -9,7 +9,6 @@ import (
 	mockSync "github.com/OffchainLabs/prysm/v6/beacon-chain/sync/initial-sync/testing"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/crypto/bls"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
@@ -52,15 +51,15 @@ func TestProposer_GetSyncAggregate_OK(t *testing.T) {
 		require.NoError(t, proposerServer.SyncCommitteePool.SaveSyncCommitteeContribution(cont))
 	}
 
-	aggregate, err := proposerServer.getSyncAggregate(t.Context(), 1, bytesutil.ToBytes32(conts[0].BlockRoot), st)
+	aggregate, err := proposerServer.getSyncAggregate(t.Context(), 1, bytesutil.ToBytes32(conts[0].BlockRoot))
 	require.NoError(t, err)
 	require.DeepEqual(t, bitfield.Bitvector32{0xf, 0xf, 0xf, 0xf}, aggregate.SyncCommitteeBits)
 
-	aggregate, err = proposerServer.getSyncAggregate(t.Context(), 2, bytesutil.ToBytes32(conts[0].BlockRoot), st)
+	aggregate, err = proposerServer.getSyncAggregate(t.Context(), 2, bytesutil.ToBytes32(conts[0].BlockRoot))
 	require.NoError(t, err)
 	require.DeepEqual(t, bitfield.Bitvector32{0xaa, 0xaa, 0xaa, 0xaa}, aggregate.SyncCommitteeBits)
 
-	aggregate, err = proposerServer.getSyncAggregate(t.Context(), 3, bytesutil.ToBytes32(conts[0].BlockRoot), st)
+	aggregate, err = proposerServer.getSyncAggregate(t.Context(), 3, bytesutil.ToBytes32(conts[0].BlockRoot))
 	require.NoError(t, err)
 	require.DeepEqual(t, bitfield.NewBitvector32(), aggregate.SyncCommitteeBits)
 }
@@ -69,7 +68,7 @@ func TestServer_SetSyncAggregate_EmptyCase(t *testing.T) {
 	b, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlockAltair())
 	require.NoError(t, err)
 	s := &Server{} // Sever is not initialized with sync committee pool.
-	s.setSyncAggregate(t.Context(), b, nil)
+	s.setSyncAggregate(t.Context(), b)
 	agg, err := b.Block().Body().SyncAggregate()
 	require.NoError(t, err)
 
@@ -139,7 +138,7 @@ func TestProposer_GetSyncAggregate_IncludesSyncCommitteeMessages(t *testing.T) {
 	}
 
 	// The final sync aggregates must have indexes [0,1,2,3] set for both subcommittees
-	sa, err := proposerServer.getSyncAggregate(t.Context(), 1, r, st)
+	sa, err := proposerServer.getSyncAggregate(t.Context(), 1, r)
 	require.NoError(t, err)
 	assert.Equal(t, true, sa.SyncCommitteeBits.BitAt(0))
 	assert.Equal(t, true, sa.SyncCommitteeBits.BitAt(1))
@@ -195,99 +194,8 @@ func Test_aggregatedSyncCommitteeMessages_NoIntersectionWithPoolContributions(t
 		BlockRoot:         r[:],
 	}
 
-	aggregated, err := proposerServer.aggregatedSyncCommitteeMessages(t.Context(), 1, r, []*ethpb.SyncCommitteeContribution{cont}, st)
+	aggregated, err := proposerServer.aggregatedSyncCommitteeMessages(t.Context(), 1, r, []*ethpb.SyncCommitteeContribution{cont})
 	require.NoError(t, err)
 	require.Equal(t, 1, len(aggregated))
 	assert.Equal(t, false, aggregated[0].AggregationBits.BitAt(3))
 }
-
-func TestGetSyncAggregate_CorrectStateAtSyncCommitteePeriodBoundary(t *testing.T) {
-	helpers.ClearCache()
-	syncPeriodBoundaryEpoch := primitives.Epoch(274176) // Real epoch from the bug report
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-
-	preEpochState, keys := util.DeterministicGenesisStateAltair(t, 100)
-	require.NoError(t, preEpochState.SetSlot(primitives.Slot(syncPeriodBoundaryEpoch)*slotsPerEpoch-1)) // Last slot of previous epoch
-
-	postEpochState := preEpochState.Copy()
-	require.NoError(t, postEpochState.SetSlot(primitives.Slot(syncPeriodBoundaryEpoch)*slotsPerEpoch+2)) // After 2 missed slots
-
-	oldCommittee := &ethpb.SyncCommittee{
-		Pubkeys: make([][]byte, params.BeaconConfig().SyncCommitteeSize),
-	}
-	newCommittee := &ethpb.SyncCommittee{
-		Pubkeys: make([][]byte, params.BeaconConfig().SyncCommitteeSize),
-	}
-
-	for i := 0; i < int(params.BeaconConfig().SyncCommitteeSize); i++ {
-		if i < len(keys) {
-			oldCommittee.Pubkeys[i] = keys[i%len(keys)].PublicKey().Marshal()
-			// Use different keys for new committee to simulate rotation
-			newCommittee.Pubkeys[i] = keys[(i+10)%len(keys)].PublicKey().Marshal()
-		}
-	}
-
-	require.NoError(t, preEpochState.SetCurrentSyncCommittee(oldCommittee))
-	require.NoError(t, postEpochState.SetCurrentSyncCommittee(newCommittee))
-
-	mockChainService := &chainmock.ChainService{
-		State: postEpochState,
-	}
-
-	proposerServer := &Server{
-		HeadFetcher:       mockChainService,
-		SyncChecker:       &mockSync.Sync{IsSyncing: false},
-		SyncCommitteePool: synccommittee.NewStore(),
-	}
-
-	slot := primitives.Slot(syncPeriodBoundaryEpoch)*slotsPerEpoch + 1 // First slot of new epoch
-	blockRoot := [32]byte{0x01, 0x02, 0x03}
-
-	msg1 := &ethpb.SyncCommitteeMessage{
-		Slot:           slot,
-		BlockRoot:      blockRoot[:],
-		ValidatorIndex: 0, // This validator is in position 0 of OLD committee
-		Signature:      bls.NewAggregateSignature().Marshal(),
-	}
-	msg2 := &ethpb.SyncCommitteeMessage{
-		Slot:           slot,
-		BlockRoot:      blockRoot[:],
-		ValidatorIndex: 1, // This validator is in position 1 of OLD committee
-		Signature:      bls.NewAggregateSignature().Marshal(),
-	}
-
-	require.NoError(t, proposerServer.SyncCommitteePool.SaveSyncCommitteeMessage(msg1))
-	require.NoError(t, proposerServer.SyncCommitteePool.SaveSyncCommitteeMessage(msg2))
-
-	aggregateWrongState, err := proposerServer.getSyncAggregate(t.Context(), slot, blockRoot, postEpochState)
-	require.NoError(t, err)
-
-	aggregateCorrectState, err := proposerServer.getSyncAggregate(t.Context(), slot, blockRoot, preEpochState)
-	require.NoError(t, err)
-
-	wrongStateBits := bitfield.Bitlist(aggregateWrongState.SyncCommitteeBits)
-	correctStateBits := bitfield.Bitlist(aggregateCorrectState.SyncCommitteeBits)
-
-	wrongStateHasValidators := false
-	correctStateHasValidators := false
-
-	for i := 0; i < len(wrongStateBits); i++ {
-		if wrongStateBits[i] != 0 {
-			wrongStateHasValidators = true
-			break
-		}
-	}
-
-	for i := 0; i < len(correctStateBits); i++ {
-		if correctStateBits[i] != 0 {
-			correctStateHasValidators = true
-			break
-		}
-	}
-
-	assert.Equal(t, true, correctStateHasValidators, "Correct state should include validators that sent messages")
-	assert.Equal(t, false, wrongStateHasValidators, "Wrong state should not find validators in incorrect sync committee")
-
-	t.Logf("Wrong state aggregate bits: %x (has validators: %v)", wrongStateBits, wrongStateHasValidators)
-	t.Logf("Correct state aggregate bits: %x (has validators: %v)", correctStateBits, correctStateHasValidators)
-}

beacon-chain/rpc/prysm/v1alpha1/validator/proposer_bellatrix.go

@@ -473,11 +473,6 @@ func isVersionCompatible(bidVersion, headBlockVersion int) bool {
 		return true
 	}
 
-	// Allow Electra bids for Gloas blocks - they have compatible payload formats
-	if bidVersion == version.Electra && headBlockVersion == version.Gloas {
-		return true
-	}
-
 	// For all other cases, require exact version match
 	return false
 }

beacon-chain/rpc/prysm/v1alpha1/validator/proposer_empty_block.go

@@ -16,11 +16,6 @@ func getEmptyBlock(slot primitives.Slot) (interfaces.SignedBeaconBlock, error) {
 	var err error
 	epoch := slots.ToEpoch(slot)
 	switch {
-	case epoch >= params.BeaconConfig().GloasForkEpoch:
-		sBlk, err = blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockGloas{Block: &ethpb.BeaconBlockGloas{Body: &ethpb.BeaconBlockBodyGloas{}}})
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "Could not initialize block for proposal: %v", err)
-		}
 	case epoch >= params.BeaconConfig().FuluForkEpoch:
 		sBlk, err = blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockFulu{Block: &ethpb.BeaconBlockElectra{Body: &ethpb.BeaconBlockBodyElectra{}}})
 		if err != nil {

beacon-chain/rpc/prysm/v1alpha1/validator/proposer_execution_payload.go

@@ -136,7 +136,7 @@ func (vs *Server) getLocalPayloadFromEngine(
 	}
 	var attr payloadattribute.Attributer
 	switch st.Version() {
-	case version.Deneb, version.Electra, version.Fulu, version.Gloas:
+	case version.Deneb, version.Electra, version.Fulu:
 		withdrawals, _, err := st.ExpectedWithdrawals()
 		if err != nil {
 			return nil, err

beacon-chain/state/interfaces.go

@@ -266,8 +266,6 @@ type WriteOnlyEth1Data interface {
 	SetEth1DepositIndex(val uint64) error
 	ExitEpochAndUpdateChurn(exitBalance primitives.Gwei) (primitives.Epoch, error)
 	ExitEpochAndUpdateChurnForTotalBal(totalActiveBalance primitives.Gwei, exitBalance primitives.Gwei) (primitives.Epoch, error)
-	SetExitBalanceToConsume(val primitives.Gwei) error
-	SetEarliestExitEpoch(val primitives.Epoch) error
 }
 
 // WriteOnlyValidators defines a struct which only has write access to validators methods.
@@ -335,7 +333,6 @@ type WriteOnlyWithdrawals interface {
 	DequeuePendingPartialWithdrawals(num uint64) error
 	SetNextWithdrawalIndex(i uint64) error
 	SetNextWithdrawalValidatorIndex(i primitives.ValidatorIndex) error
-	SetPendingPartialWithdrawals(val []*ethpb.PendingPartialWithdrawal) error
 }
 
 type WriteOnlyConsolidations interface {

beacon-chain/state/state-native/beacon_state.go

@@ -52,7 +52,6 @@ type BeaconState struct {
 	latestExecutionPayloadHeader        *enginev1.ExecutionPayloadHeader
 	latestExecutionPayloadHeaderCapella *enginev1.ExecutionPayloadHeaderCapella
 	latestExecutionPayloadHeaderDeneb   *enginev1.ExecutionPayloadHeaderDeneb
-	latestExecutionPayloadHeaderGloas   *enginev1.ExecutionPayloadHeaderGloas
 
 	// Capella fields
 	nextWithdrawalIndex          uint64

beacon-chain/state/state-native/getters_payload_header.go

@@ -17,10 +17,6 @@ func (b *BeaconState) LatestExecutionPayloadHeader() (interfaces.ExecutionData,
 	b.lock.RLock()
 	defer b.lock.RUnlock()
 
-	if b.version >= version.Gloas {
-		return blocks.WrappedExecutionPayloadHeaderGloas(b.latestExecutionPayloadHeaderGloas.Copy())
-	}
-
 	if b.version >= version.Deneb {
 		return blocks.WrappedExecutionPayloadHeaderDeneb(b.latestExecutionPayloadHeaderDeneb.Copy())
 	}

beacon-chain/state/state-native/hasher.go

@@ -43,8 +43,6 @@ func ComputeFieldRootsWithHasher(ctx context.Context, state *BeaconState) ([][]b
 		fieldRoots = make([][]byte, params.BeaconConfig().BeaconStateElectraFieldCount)
 	case version.Fulu:
 		fieldRoots = make([][]byte, params.BeaconConfig().BeaconStateFuluFieldCount)
-	case version.Gloas:
-		fieldRoots = make([][]byte, params.BeaconConfig().BeaconStateGloasFieldCount)
 	default:
 		return nil, fmt.Errorf("unknown state version %s", version.String(state.version))
 	}
@@ -247,7 +245,7 @@ func ComputeFieldRootsWithHasher(ctx context.Context, state *BeaconState) ([][]b
 		fieldRoots[types.LatestExecutionPayloadHeaderCapella.RealPosition()] = executionPayloadRoot[:]
 	}
 
-	if state.version >= version.Deneb && state.version < version.Gloas {
+	if state.version >= version.Deneb {
 		// Execution payload root.
 		executionPayloadRoot, err := state.latestExecutionPayloadHeaderDeneb.HashTreeRoot()
 		if err != nil {
@@ -256,15 +254,6 @@ func ComputeFieldRootsWithHasher(ctx context.Context, state *BeaconState) ([][]b
 		fieldRoots[types.LatestExecutionPayloadHeaderDeneb.RealPosition()] = executionPayloadRoot[:]
 	}
 
-	if state.version >= version.Gloas {
-		// Execution payload root.
-		executionPayloadRoot, err := state.latestExecutionPayloadHeaderGloas.HashTreeRoot()
-		if err != nil {
-			return nil, err
-		}
-		fieldRoots[types.LatestExecutionPayloadHeaderGloas.RealPosition()] = executionPayloadRoot[:]
-	}
-
 	if state.version >= version.Capella {
 		// Next withdrawal index root.
 		nextWithdrawalIndexRoot := make([]byte, 32)

beacon-chain/state/state-native/setters_churn.go

@@ -91,33 +91,3 @@ func (b *BeaconState) exitEpochAndUpdateChurn(totalActiveBalance primitives.Gwei
 
 	return b.earliestExitEpoch, nil
 }
-
-// SetExitBalanceToConsume sets the exit balance to consume. This method mutates the state.
-func (b *BeaconState) SetExitBalanceToConsume(exitBalanceToConsume primitives.Gwei) error {
-	if b.version < version.Electra {
-		return errNotSupported("SetExitBalanceToConsume", b.version)
-	}
-
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	b.exitBalanceToConsume = exitBalanceToConsume
-	b.markFieldAsDirty(types.ExitBalanceToConsume)
-
-	return nil
-}
-
-// SetEarliestExitEpoch sets the earliest exit epoch. This method mutates the state.
-func (b *BeaconState) SetEarliestExitEpoch(earliestExitEpoch primitives.Epoch) error {
-	if b.version < version.Electra {
-		return errNotSupported("SetEarliestExitEpoch", b.version)
-	}
-
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	b.earliestExitEpoch = earliestExitEpoch
-	b.markFieldAsDirty(types.EarliestExitEpoch)
-
-	return nil
-}

beacon-chain/state/state-native/setters_payload_header.go

@@ -55,17 +55,6 @@ func (b *BeaconState) SetLatestExecutionPayloadHeader(val interfaces.ExecutionDa
 		b.latestExecutionPayloadHeaderDeneb = latest
 		b.markFieldAsDirty(types.LatestExecutionPayloadHeaderDeneb)
 		return nil
-	case *enginev1.ExecutionPayloadGloas:
-		if !(b.version >= version.Gloas) {
-			return fmt.Errorf("wrong state version (%s) for gloas execution payload", version.String(b.version))
-		}
-		latest, err := consensusblocks.PayloadToHeaderGloas(val)
-		if err != nil {
-			return errors.Wrap(err, "could not convert payload to header")
-		}
-		b.latestExecutionPayloadHeaderGloas = latest
-		b.markFieldAsDirty(types.LatestExecutionPayloadHeaderGloas)
-		return nil
 	case *enginev1.ExecutionPayloadHeader:
 		if b.version != version.Bellatrix {
 			return fmt.Errorf("wrong state version (%s) for bellatrix execution payload header", version.String(b.version))
@@ -87,13 +76,6 @@ func (b *BeaconState) SetLatestExecutionPayloadHeader(val interfaces.ExecutionDa
 		b.latestExecutionPayloadHeaderDeneb = header
 		b.markFieldAsDirty(types.LatestExecutionPayloadHeaderDeneb)
 		return nil
-	case *enginev1.ExecutionPayloadHeaderGloas:
-		if !(b.version >= version.Gloas) {
-			return fmt.Errorf("wrong state version (%s) for gloas execution payload header", version.String(b.version))
-		}
-		b.latestExecutionPayloadHeaderGloas = header
-		b.markFieldAsDirty(types.LatestExecutionPayloadHeaderGloas)
-		return nil
 	default:
 		return errors.New("value must be an execution payload header")
 	}

beacon-chain/state/state-native/setters_withdrawal.go

@@ -100,24 +100,3 @@ func (b *BeaconState) DequeuePendingPartialWithdrawals(n uint64) error {
 
 	return nil
 }
-
-// SetPendingPartialWithdrawals sets the pending partial withdrawals. This method mutates the state.
-func (b *BeaconState) SetPendingPartialWithdrawals(pendingPartialWithdrawals []*eth.PendingPartialWithdrawal) error {
-	if b.version < version.Electra {
-		return errNotSupported("SetPendingPartialWithdrawals", b.version)
-	}
-
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	if pendingPartialWithdrawals == nil {
-		return errors.New("cannot set nil pending partial withdrawals")
-	}
-	b.sharedFieldReferences[types.PendingPartialWithdrawals].MinusRef()
-	b.sharedFieldReferences[types.PendingPartialWithdrawals] = stateutil.NewRef(1)
-
-	b.pendingPartialWithdrawals = pendingPartialWithdrawals
-	b.markFieldAsDirty(types.PendingPartialWithdrawals)
-
-	return nil
-}

beacon-chain/state/state-native/state_trie.go

@@ -112,24 +112,6 @@ var (
 		electraFields,
 		types.ProposerLookahead,
 	)
-
-	gloasFields = append(
-		altairFields,
-		types.LatestExecutionPayloadHeaderGloas,
-		types.NextWithdrawalIndex,
-		types.NextWithdrawalValidatorIndex,
-		types.HistoricalSummaries,
-		types.DepositRequestsStartIndex,
-		types.DepositBalanceToConsume,
-		types.ExitBalanceToConsume,
-		types.EarliestExitEpoch,
-		types.ConsolidationBalanceToConsume,
-		types.EarliestConsolidationEpoch,
-		types.PendingDeposits,
-		types.PendingPartialWithdrawals,
-		types.PendingConsolidations,
-		types.ProposerLookahead,
-	)
 )
 
 const (
@@ -140,7 +122,6 @@ const (
 	denebSharedFieldRefCount     = 7
 	electraSharedFieldRefCount   = 10
 	fuluSharedFieldRefCount      = 11
-	gloasSharedFieldRefCount     = 11
 )
 
 // InitializeFromProtoPhase0 the beacon state from a protobuf representation.
@@ -178,11 +159,6 @@ func InitializeFromProtoFulu(st *ethpb.BeaconStateFulu) (state.BeaconState, erro
 	return InitializeFromProtoUnsafeFulu(proto.Clone(st).(*ethpb.BeaconStateFulu))
 }
 
-// InitializeFromProtoGloas the beacon state from a protobuf representation.
-func InitializeFromProtoGloas(st *ethpb.BeaconStateGloas) (state.BeaconState, error) {
-	return InitializeFromProtoUnsafeGloas(proto.Clone(st).(*ethpb.BeaconStateGloas))
-}
-
 // InitializeFromProtoUnsafePhase0 directly uses the beacon state protobuf fields
 // and sets them as fields of the BeaconState type.
 func InitializeFromProtoUnsafePhase0(st *ethpb.BeaconState) (state.BeaconState, error) {
@@ -674,11 +650,6 @@ func InitializeFromProtoUnsafeFulu(st *ethpb.BeaconStateFulu) (state.BeaconState
 	for i, v := range st.ProposerLookahead {
 		proposerLookahead[i] = primitives.ValidatorIndex(v)
 	}
-	// Proposer lookahead must be exactly 2 * SLOTS_PER_EPOCH in length. We fill in with zeroes instead of erroring out here
-	for i := len(proposerLookahead); i < 2*fieldparams.SlotsPerEpoch; i++ {
-		proposerLookahead = append(proposerLookahead, 0)
-	}
-
 	fieldCount := params.BeaconConfig().BeaconStateFuluFieldCount
 	b := &BeaconState{
 		version:                           version.Fulu,
@@ -760,105 +731,6 @@ func InitializeFromProtoUnsafeFulu(st *ethpb.BeaconStateFulu) (state.BeaconState
 	return b, nil
 }
 
-// InitializeFromProtoUnsafeGloas directly uses the beacon state protobuf fields
-// and sets them as fields of the BeaconState type.
-func InitializeFromProtoUnsafeGloas(st *ethpb.BeaconStateGloas) (state.BeaconState, error) {
-	if st == nil {
-		return nil, errors.New("received nil state")
-	}
-
-	hRoots := customtypes.HistoricalRoots(make([][32]byte, len(st.HistoricalRoots)))
-	for i, r := range st.HistoricalRoots {
-		hRoots[i] = bytesutil.ToBytes32(r)
-	}
-
-	proposerLookahead := make([]primitives.ValidatorIndex, len(st.ProposerLookahead))
-	for i, v := range st.ProposerLookahead {
-		proposerLookahead[i] = primitives.ValidatorIndex(v)
-	}
-	fieldCount := params.BeaconConfig().BeaconStateFuluFieldCount
-	b := &BeaconState{
-		version:                           version.Gloas,
-		genesisTime:                       st.GenesisTime,
-		genesisValidatorsRoot:             bytesutil.ToBytes32(st.GenesisValidatorsRoot),
-		slot:                              st.Slot,
-		fork:                              st.Fork,
-		latestBlockHeader:                 st.LatestBlockHeader,
-		historicalRoots:                   hRoots,
-		eth1Data:                          st.Eth1Data,
-		eth1DataVotes:                     st.Eth1DataVotes,
-		eth1DepositIndex:                  st.Eth1DepositIndex,
-		slashings:                         st.Slashings,
-		previousEpochParticipation:        st.PreviousEpochParticipation,
-		currentEpochParticipation:         st.CurrentEpochParticipation,
-		justificationBits:                 st.JustificationBits,
-		previousJustifiedCheckpoint:       st.PreviousJustifiedCheckpoint,
-		currentJustifiedCheckpoint:        st.CurrentJustifiedCheckpoint,
-		finalizedCheckpoint:               st.FinalizedCheckpoint,
-		currentSyncCommittee:              st.CurrentSyncCommittee,
-		nextSyncCommittee:                 st.NextSyncCommittee,
-		latestExecutionPayloadHeaderGloas: st.LatestExecutionPayloadHeader,
-		nextWithdrawalIndex:               st.NextWithdrawalIndex,
-		nextWithdrawalValidatorIndex:      st.NextWithdrawalValidatorIndex,
-		historicalSummaries:               st.HistoricalSummaries,
-		depositRequestsStartIndex:         st.DepositRequestsStartIndex,
-		depositBalanceToConsume:           st.DepositBalanceToConsume,
-		exitBalanceToConsume:              st.ExitBalanceToConsume,
-		earliestExitEpoch:                 st.EarliestExitEpoch,
-		consolidationBalanceToConsume:     st.ConsolidationBalanceToConsume,
-		earliestConsolidationEpoch:        st.EarliestConsolidationEpoch,
-		pendingDeposits:                   st.PendingDeposits,
-		pendingPartialWithdrawals:         st.PendingPartialWithdrawals,
-		pendingConsolidations:             st.PendingConsolidations,
-		proposerLookahead:                 proposerLookahead,
-
-		id: types.Enumerator.Inc(),
-
-		dirtyFields:      make(map[types.FieldIndex]bool, fieldCount),
-		dirtyIndices:     make(map[types.FieldIndex][]uint64, fieldCount),
-		stateFieldLeaves: make(map[types.FieldIndex]*fieldtrie.FieldTrie, fieldCount),
-		rebuildTrie:      make(map[types.FieldIndex]bool, fieldCount),
-		valMapHandler:    stateutil.NewValMapHandler(st.Validators),
-	}
-
-	b.blockRootsMultiValue = NewMultiValueBlockRoots(st.BlockRoots)
-	b.stateRootsMultiValue = NewMultiValueStateRoots(st.StateRoots)
-	b.randaoMixesMultiValue = NewMultiValueRandaoMixes(st.RandaoMixes)
-	b.balancesMultiValue = NewMultiValueBalances(st.Balances)
-	b.validatorsMultiValue = NewMultiValueValidators(st.Validators)
-	b.inactivityScoresMultiValue = NewMultiValueInactivityScores(st.InactivityScores)
-	b.sharedFieldReferences = make(map[types.FieldIndex]*stateutil.Reference, gloasSharedFieldRefCount)
-
-	for _, f := range gloasFields {
-		b.dirtyFields[f] = true
-		b.rebuildTrie[f] = true
-		b.dirtyIndices[f] = []uint64{}
-		trie, err := fieldtrie.NewFieldTrie(f, types.BasicArray, nil, 0)
-		if err != nil {
-			return nil, err
-		}
-		b.stateFieldLeaves[f] = trie
-	}
-
-	// Initialize field reference tracking for shared data.
-	b.sharedFieldReferences[types.HistoricalRoots] = stateutil.NewRef(1)
-	b.sharedFieldReferences[types.Eth1DataVotes] = stateutil.NewRef(1)
-	b.sharedFieldReferences[types.Slashings] = stateutil.NewRef(1)
-	b.sharedFieldReferences[types.PreviousEpochParticipationBits] = stateutil.NewRef(1)
-	b.sharedFieldReferences[types.CurrentEpochParticipationBits] = stateutil.NewRef(1)
-	b.sharedFieldReferences[types.LatestExecutionPayloadHeaderGloas] = stateutil.NewRef(1) // New in Gloas.
-	b.sharedFieldReferences[types.HistoricalSummaries] = stateutil.NewRef(1)
-	b.sharedFieldReferences[types.PendingDeposits] = stateutil.NewRef(1)
-	b.sharedFieldReferences[types.PendingPartialWithdrawals] = stateutil.NewRef(1)
-	b.sharedFieldReferences[types.PendingConsolidations] = stateutil.NewRef(1)
-	b.sharedFieldReferences[types.ProposerLookahead] = stateutil.NewRef(1)
-
-	state.Count.Inc()
-	// Finalizer runs when dst is being destroyed in garbage collection.
-	runtime.SetFinalizer(b, finalizerCleanup)
-	return b, nil
-}
-
 // Copy returns a deep copy of the beacon state.
 func (b *BeaconState) Copy() state.BeaconState {
 	b.lock.RLock()
@@ -880,8 +752,6 @@ func (b *BeaconState) Copy() state.BeaconState {
 		fieldCount = params.BeaconConfig().BeaconStateElectraFieldCount
 	case version.Fulu:
 		fieldCount = params.BeaconConfig().BeaconStateFuluFieldCount
-	case version.Gloas:
-		fieldCount = params.BeaconConfig().BeaconStateFuluFieldCount
 	}
 
 	dst := &BeaconState{
@@ -936,7 +806,6 @@ func (b *BeaconState) Copy() state.BeaconState {
 		latestExecutionPayloadHeader:        b.latestExecutionPayloadHeader.Copy(),
 		latestExecutionPayloadHeaderCapella: b.latestExecutionPayloadHeaderCapella.Copy(),
 		latestExecutionPayloadHeaderDeneb:   b.latestExecutionPayloadHeaderDeneb.Copy(),
-		latestExecutionPayloadHeaderGloas:   b.latestExecutionPayloadHeaderGloas.Copy(),
 
 		id: types.Enumerator.Inc(),
 
@@ -973,8 +842,6 @@ func (b *BeaconState) Copy() state.BeaconState {
 		dst.sharedFieldReferences = make(map[types.FieldIndex]*stateutil.Reference, electraSharedFieldRefCount)
 	case version.Fulu:
 		dst.sharedFieldReferences = make(map[types.FieldIndex]*stateutil.Reference, fuluSharedFieldRefCount)
-	case version.Gloas:
-		dst.sharedFieldReferences = make(map[types.FieldIndex]*stateutil.Reference, gloasSharedFieldRefCount)
 	}
 
 	for field, ref := range b.sharedFieldReferences {
@@ -1070,8 +937,6 @@ func (b *BeaconState) initializeMerkleLayers(ctx context.Context) error {
 		b.dirtyFields = make(map[types.FieldIndex]bool, params.BeaconConfig().BeaconStateElectraFieldCount)
 	case version.Fulu:
 		b.dirtyFields = make(map[types.FieldIndex]bool, params.BeaconConfig().BeaconStateFuluFieldCount)
-	case version.Gloas:
-		b.dirtyFields = make(map[types.FieldIndex]bool, params.BeaconConfig().BeaconStateFuluFieldCount)
 	default:
 		return fmt.Errorf("unknown state version (%s) when computing dirty fields in merklization", version.String(b.version))
 	}
@@ -1284,8 +1149,6 @@ func (b *BeaconState) rootSelector(ctx context.Context, field types.FieldIndex)
 		return b.latestExecutionPayloadHeaderCapella.HashTreeRoot()
 	case types.LatestExecutionPayloadHeaderDeneb:
 		return b.latestExecutionPayloadHeaderDeneb.HashTreeRoot()
-	case types.LatestExecutionPayloadHeaderGloas:
-		return b.latestExecutionPayloadHeaderGloas.HashTreeRoot()
 	case types.NextWithdrawalIndex:
 		return ssz.Uint64Root(b.nextWithdrawalIndex), nil
 	case types.NextWithdrawalValidatorIndex:

beacon-chain/state/state-native/types/types.go

@@ -88,8 +88,6 @@ func (f FieldIndex) String() string {
 		return "latestExecutionPayloadHeaderCapella"
 	case LatestExecutionPayloadHeaderDeneb:
 		return "latestExecutionPayloadHeaderDeneb"
-	case LatestExecutionPayloadHeaderGloas:
-		return "latestExecutionPayloadHeaderGloas"
 	case NextWithdrawalIndex:
 		return "nextWithdrawalIndex"
 	case NextWithdrawalValidatorIndex:
@@ -173,7 +171,7 @@ func (f FieldIndex) RealPosition() int {
 		return 22
 	case NextSyncCommittee:
 		return 23
-	case LatestExecutionPayloadHeader, LatestExecutionPayloadHeaderCapella, LatestExecutionPayloadHeaderDeneb, LatestExecutionPayloadHeaderGloas:
+	case LatestExecutionPayloadHeader, LatestExecutionPayloadHeaderCapella, LatestExecutionPayloadHeaderDeneb:
 		return 24
 	case NextWithdrawalIndex:
 		return 25
@@ -253,7 +251,6 @@ const (
 	LatestExecutionPayloadHeader
 	LatestExecutionPayloadHeaderCapella
 	LatestExecutionPayloadHeaderDeneb
-	LatestExecutionPayloadHeaderGloas
 	NextWithdrawalIndex
 	NextWithdrawalValidatorIndex
 	HistoricalSummaries

beacon-chain/sync/backfill/BUILD.bazel

@@ -17,6 +17,7 @@ go_library(
     importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/sync/backfill",
     visibility = ["//visibility:public"],
     deps = [
+        "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/das:go_default_library",
         "//beacon-chain/db:go_default_library",
@@ -60,6 +61,7 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
+        "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/das:go_default_library",
         "//beacon-chain/db:go_default_library",

beacon-chain/sync/backfill/service.go

@@ -3,12 +3,12 @@ package backfill
 import (
 	"context"
 
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/sync"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
-	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
@@ -348,7 +348,7 @@ func (*Service) Status() error {
 // minimumBackfillSlot determines the lowest slot that backfill needs to download based on looking back
 // MIN_EPOCHS_FOR_BLOCK_REQUESTS from the current slot.
 func minimumBackfillSlot(current primitives.Slot) primitives.Slot {
-	oe := primitives.Epoch(params.BeaconConfig().MinEpochsForBlockRequests)
+	oe := helpers.MinEpochsForBlockRequests()
 	if oe > slots.MaxSafeEpoch() {
 		oe = slots.MaxSafeEpoch()
 	}

beacon-chain/sync/backfill/service_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	p2ptest "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
@@ -83,7 +84,7 @@ func TestServiceInit(t *testing.T) {
 }
 
 func TestMinimumBackfillSlot(t *testing.T) {
-	oe := primitives.Epoch(params.BeaconConfig().MinEpochsForBlockRequests)
+	oe := helpers.MinEpochsForBlockRequests()
 
 	currSlot := (oe + 100).Mul(uint64(params.BeaconConfig().SlotsPerEpoch))
 	minSlot := minimumBackfillSlot(primitives.Slot(currSlot))
@@ -108,7 +109,7 @@ func testReadN(ctx context.Context, t *testing.T, c chan batch, n int, into []ba
 }
 
 func TestBackfillMinSlotDefault(t *testing.T) {
-	oe := primitives.Epoch(params.BeaconConfig().MinEpochsForBlockRequests)
+	oe := helpers.MinEpochsForBlockRequests()
 	current := primitives.Slot((oe + 100).Mul(uint64(params.BeaconConfig().SlotsPerEpoch)))
 	s := &Service{}
 	specMin := minimumBackfillSlot(current)

beacon-chain/sync/metrics.go

@@ -192,13 +192,6 @@ var (
 		},
 	)
 
-	dataColumnsRecoveredFromELTotal = promauto.NewCounter(
-		prometheus.CounterOpts{
-			Name: "data_columns_recovered_from_el_total",
-			Help: "Count the number of times data columns have been recovered from the execution layer.",
-		},
-	)
-
 	// Data column sidecar validation, beacon metrics specs
 	dataColumnSidecarVerificationRequestsCounter = promauto.NewCounter(prometheus.CounterOpts{
 		Name: "beacon_data_column_sidecar_processing_requests_total",

beacon-chain/sync/subscriber_beacon_blocks.go

@@ -224,8 +224,6 @@ func (s *Service) processDataColumnSidecarsFromExecution(ctx context.Context, so
 			}
 
 			if len(unseenIndices) > 0 {
-				dataColumnsRecoveredFromELTotal.Inc()
-
 				log.WithFields(logrus.Fields{
 					"root":          fmt.Sprintf("%#x", source.Root()),
 					"slot":          source.Slot(),

changelog/Galoretka_feature-slasher-feed-use-service-ctx.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- Use service context and continue on slasher attestation errors (#15803).

changelog/MozirDmitriy_fix_kv-recover-state-summurt-bucket.md

@@ -1,3 +0,0 @@
-### Fixed
-
-- Fix recoverStateSummary to persist state summaries in stateSummaryBucket instead of stateBucket (#15896).

changelog/fernantho_ssz-ql-use-fastssz-generated-functions.md

@@ -0,0 +1,3 @@
+### Added
+
+- Delegate sszInfo HashTreeRoot to FastSSZ-generated implementations via SSZObject, enabling roots calculation for generated types while avoiding duplicate logic.

changelog/james-prysm_cleanup-process-aggregate.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- Small code changes for reusability and readability to processAggregate.

changelog/james-prysm_fix-block-event.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- block event probably shouldn't be sent on certain block processing failures, now sends only on successing processing Block is NON-CANONICAL, Block IS CANONICAL but getFCUArgs FAILS, and Full success

changelog/james-prysm_fix-web3signer-e2e.md

@@ -0,0 +1,7 @@
+### Fixed
+
+- Fixed web3signer e2e, issues caused due to a regression on old fork support
+
+### Changed
+
+- updated web3signer to 25.9.1

changelog/james-prysm_v6.1.3.md

@@ -1,3 +0,0 @@
-### Ignored
-
-- Changelog entries for v6.1.3 through v6.1.2

changelog/kasey_att-batch-5ms-deadline.md

@@ -0,0 +1,2 @@
+### Fixed
+- Decreased attestation gossip validation batch deadline to 5ms.

changelog/kasey_default-layout-by-epoch.md

@@ -1,2 +0,0 @@
-### Changed
-- Use the `by-epoch' blob storage layout by default and log a warning to users who continue to use the flat layout, encouraging them to switch.

changelog/manu-adjust-log-levels.md

@@ -0,0 +1,2 @@
+### Ignored 
+- Data column sidecars fetch: Adjust log levels.

changelog/manu-blob-sidecars-beacon-api.md

@@ -0,0 +1,2 @@
+### Fixed 
+- Fix `/eth/v1/beacon/blob_sidecars/` beacon API is the fulu fork epoch is set to the far future epoch.

changelog/manu-check-commitment-count.md

@@ -0,0 +1,2 @@
+### Fixed 
+- `VerifyDataColumnSidecar`: Check if there is no too many commitments.

changelog/manu-data-column-retention-period.md

@@ -0,0 +1,2 @@
+### Fixed 
+- `WithDataColumnRetentionEpochs`: Use `dataColumnRetentionEpoch` instead of `blobColumnRetentionEpoch`.

changelog/manu-fulu-log.md

@@ -1,2 +0,0 @@
-### Fixed 
-- Remove `Reading static P2P private key from a file.` log if Fulu is enabled.

changelog/manu-gracefully-close-stream.md

@@ -0,0 +1,2 @@
+### Fixed 
+- `dataColumnSidecarsByRangeRPCHandler`: Gracefully close the stream if no data to return.

changelog/manu-grandine-known-agents.md

@@ -0,0 +1,2 @@
+### Added 
+- Add Grandine to P2P known agents. (Useful for metrics)

changelog/manu-handle-windows.md

@@ -0,0 +1,3 @@
+### Fixed 
+- `WarmCache`: Return if `extractFileMetadata` fails.
+- `extractFileMetadata`: Use filepath.Separator instead of `/` for Windows support.

changelog/manu-has-at-least-one-index.md

@@ -0,0 +1,2 @@
+### Fixed 
+- `HasAtLeastOneIndex`: Check the index is not too high.

changelog/manu-number-custody-groups.md

@@ -1,2 +0,0 @@
-### Fixed 
-- `updateCustodyInfoInDB`: Use `NumberOfCustodyGroups` instead of `NumberOfColumns`.

changelog/manu-verify-data-column-sidecar-kzg-proofs.md

@@ -1,2 +0,0 @@
-### Fixed 
-- `VerifyDataColumnsSidecarKZGProofs`: Check if sizes match.

changelog/marcopolo_push-nxynxywxtlpo.md

@@ -0,0 +1,2 @@
+### Ignored
+- Fix (unreleased) bug where the preallocated slice for KZG Proofs was 48x bigger than it needed to be.

changelog/muzry_fix_extract_metadata_file.md

@@ -1,2 +0,0 @@
-### Fixed
-- Fixed metadata extraction on Windows by correctly splitting file paths

changelog/phrwlk_fix-attestation-committee-index-bound.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- reject committee index >= committees_per_slot in unaggregated attestation validation