Fixes required to sync fusaka-devnet-4

* overhaul fork schedule management for bpos

* Unify log

* Radek's comments

* Use arg config to determine previous epoch, with regression test

* Remove unnecessary NewClock. @potuz feedback

* Continuation of previous commit: Remove unnecessary NewClock. @potuz feedback

* Remove VerifyBlockHeaderSignatureUsingCurrentFork

* cosmetic changes

* Remove unnecessary copy. entryWithForkDigest passes by value, not by pointer so it shold be fine

* Reuse ErrInvalidTopic from p2p package

* Unskip TestServer_GetBeaconConfig

* Resolve TODO about forkwatcher in local mode

* remove Copy()

---------

Co-authored-by: Kasey <kasey@users.noreply.github.com>
Co-authored-by: terence tsao <terence@prysmaticlabs.com>
Co-authored-by: rkapka <radoslaw.kapka@gmail.com>
Co-authored-by: Preston Van Loon <preston@pvl.dev>

.github/workflows/changelog.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout source code
-        uses: actions/checkout@v3
+        uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
 
       - name: Download unclog binary
         uses: dsaltares/fetch-gh-release-asset@aa2ab1243d6e0d5b405b973c89fa4d06a2d0fff7 # 1.1.2
@@ -23,7 +23,7 @@ jobs:
 
       - name: Get new changelog files
         id: new-changelog-files
-        uses: tj-actions/changed-files@v45
+        uses: OffchainLabs/gh-action-changed-files@9200e69727eb73eb060652b19946b8a2fdfb654b # v4.0.8
         with:
           files: |
             changelog/**.md

WORKSPACE

@@ -190,7 +190,7 @@ load("@rules_oci//oci:pull.bzl", "oci_pull")
 # A multi-arch base image
 oci_pull(
     name = "linux_debian11_multiarch_base",  # Debian bullseye
-    digest = "sha256:b82f113425c5b5c714151aaacd8039bc141821cdcd3c65202d42bdf9c43ae60b",  # 2023-12-12
+    digest = "sha256:55a5e011b2c4246b4c51e01fcc2b452d151e03df052e357465f0392fcd59fddf",
     image = "gcr.io/prysmaticlabs/distroless/cc-debian11",
     platforms = [
         "linux/amd64",
@@ -208,7 +208,7 @@ load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_depe
 go_rules_dependencies()
 
 go_register_toolchains(
-    go_version = "1.24.0",
+    go_version = "1.24.6",
     nogo = "@//:nogo",
 )
 

api/client/beacon/BUILD.bazel

@@ -4,7 +4,6 @@ go_library(
     name = "go_default_library",
     srcs = [
         "client.go",
-        "client_epbs.go",
         "doc.go",
         "log.go",
         "template.go",
@@ -17,7 +16,6 @@ go_library(
         "//api/server/structs:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//network/forks:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_pkg_errors//:go_default_library",

api/client/beacon/client.go

@@ -9,7 +9,6 @@ import (
 	"net/url"
 	"path"
 	"regexp"
-	"sort"
 	"strconv"
 
 	"github.com/OffchainLabs/prysm/v6/api/client"
@@ -17,7 +16,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/api/server/structs"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v6/network/forks"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
@@ -35,7 +33,6 @@ const (
 
 	GetNodeVersionPath      = "/eth/v1/node/version"
 	GetWeakSubjectivityPath = "/prysm/v1/beacon/weak_subjectivity"
-	getPayloadEnvelopePath  = "/eth/v1/beacon/execution_payload"
 )
 
 // StateOrBlockId represents the block_id / state_id parameters that several of the Eth Beacon API methods accept.
@@ -138,24 +135,6 @@ func (c *Client) GetFork(ctx context.Context, stateId StateOrBlockId) (*ethpb.Fo
 	return fr.ToConsensus()
 }
 
-// GetForkSchedule retrieve all forks, past present and future, of which this node is aware.
-func (c *Client) GetForkSchedule(ctx context.Context) (forks.OrderedSchedule, error) {
-	body, err := c.Get(ctx, getForkSchedulePath)
-	if err != nil {
-		return nil, errors.Wrap(err, "error requesting fork schedule")
-	}
-	fsr := &forkScheduleResponse{}
-	err = json.Unmarshal(body, fsr)
-	if err != nil {
-		return nil, err
-	}
-	ofs, err := fsr.OrderedForkSchedule()
-	if err != nil {
-		return nil, errors.Wrap(err, fmt.Sprintf("problem unmarshaling %s response", getForkSchedulePath))
-	}
-	return ofs, nil
-}
-
 // GetConfigSpec retrieve the current configs of the network used by the beacon node.
 func (c *Client) GetConfigSpec(ctx context.Context) (*structs.GetSpecResponse, error) {
 	body, err := c.Get(ctx, getConfigSpecPath)
@@ -335,31 +314,3 @@ func (c *Client) GetBLStoExecutionChanges(ctx context.Context) (*structs.BLSToEx
 	}
 	return poolResponse, nil
 }
-
-type forkScheduleResponse struct {
-	Data []structs.Fork
-}
-
-func (fsr *forkScheduleResponse) OrderedForkSchedule() (forks.OrderedSchedule, error) {
-	ofs := make(forks.OrderedSchedule, 0)
-	for _, d := range fsr.Data {
-		epoch, err := strconv.ParseUint(d.Epoch, 10, 64)
-		if err != nil {
-			return nil, errors.Wrapf(err, "error parsing epoch %s", d.Epoch)
-		}
-		vSlice, err := hexutil.Decode(d.CurrentVersion)
-		if err != nil {
-			return nil, err
-		}
-		if len(vSlice) != 4 {
-			return nil, fmt.Errorf("got %d byte version, expected 4 bytes. version hex=%s", len(vSlice), d.CurrentVersion)
-		}
-		version := bytesutil.ToBytes4(vSlice)
-		ofs = append(ofs, forks.ForkScheduleEntry{
-			Version: version,
-			Epoch:   primitives.Epoch(epoch),
-		})
-	}
-	sort.Sort(ofs)
-	return ofs, nil
-}

api/client/beacon/client_epbs.go

@@ -1,22 +0,0 @@
-package beacon
-
-import (
-	"context"
-
-	"github.com/OffchainLabs/prysm/v6/api/client"
-	"github.com/pkg/errors"
-)
-
-// GetExecutionPayload retrieves the SignedExecutionPayloadEnvelope for the given block id.
-// Block identifier can be one of: "head" (canonical head in node's view), "genesis", "finalized",
-// <slot>, <hex encoded blockRoot with 0x prefix>. Variables of type StateOrBlockId are exported by this package
-// for the named identifiers.
-// The return value contains the ssz-encoded bytes.
-func (c *Client) GetExecutionPayload(ctx context.Context, blockId StateOrBlockId) ([]byte, error) {
-	blockPath := RenderGetBlockPath(blockId)
-	b, err := c.Get(ctx, blockPath, client.WithSSZEncoding())
-	if err != nil {
-		return nil, errors.Wrapf(err, "error requesting execuction payload by id = %s", blockId)
-	}
-	return b, nil
-}

api/client/builder/client_test.go

@@ -1727,7 +1727,7 @@ func TestSubmitBlindedBlock_BlobsBundlerInterface(t *testing.T) {
 	t.Run("Interface signature verification", func(t *testing.T) {
 		// This test verifies that the SubmitBlindedBlock method signature
 		// has been updated to return BlobsBundler interface
-		
+
 		client := &Client{}
 
 		// Verify the method exists with the correct signature

api/server/structs/BUILD.bazel

@@ -4,7 +4,6 @@ go_library(
     name = "go_default_library",
     srcs = [
         "block.go",
-        "block_epbs.go",
         "block_execution.go",
         "conversions.go",
         "conversions_blob.go",
@@ -12,8 +11,6 @@ go_library(
         "conversions_block_execution.go",
         "conversions_lightclient.go",
         "conversions_state.go",
-        "conversions_state_epbs.go",
-        "converstions_block_epbs.go",
         "endpoints_beacon.go",
         "endpoints_blob.go",
         "endpoints_builder.go",
@@ -26,7 +23,6 @@ go_library(
         "endpoints_validator.go",
         "other.go",
         "state.go",
-        "state_epbs.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v6/api/server/structs",
     visibility = ["//visibility:public"],
@@ -40,6 +36,7 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/validator:go_default_library",
         "//container/slice:go_default_library",
+        "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//proto/engine/v1:go_default_library",

api/server/structs/block_epbs.go

@@ -1,93 +0,0 @@
-package structs
-
-import "encoding/json"
-
-// ----------------------------------------------------------------------------
-// Epbs
-// ----------------------------------------------------------------------------
-type SignedBeaconBlockEpbs struct {
-	Message   *BeaconBlockEpbs `json:"message"`
-	Signature string           `json:"signature"`
-}
-
-var _ SignedMessageJsoner = &SignedBeaconBlockElectra{}
-
-func (s *SignedBeaconBlockEpbs) MessageRawJson() ([]byte, error) {
-	return json.Marshal(s.Message)
-}
-
-func (s *SignedBeaconBlockEpbs) SigString() string {
-	return s.Signature
-}
-
-type BeaconBlockEpbs struct {
-	Slot          string               `json:"slot"`
-	ProposerIndex string               `json:"proposer_index"`
-	ParentRoot    string               `json:"parent_root"`
-	StateRoot     string               `json:"state_root"`
-	Body          *BeaconBlockBodyEpbs `json:"body"`
-}
-
-type BeaconBlockBodyEpbs struct {
-	RandaoReveal                 string                        `json:"randao_reveal"`
-	Eth1Data                     *Eth1Data                     `json:"eth1_data"`
-	Graffiti                     string                        `json:"graffiti"`
-	ProposerSlashings            []*ProposerSlashing           `json:"proposer_slashings"`
-	AttesterSlashings            []*AttesterSlashingElectra    `json:"attester_slashings"`
-	Attestations                 []*AttestationElectra         `json:"attestations"`
-	Deposits                     []*Deposit                    `json:"deposits"`
-	VoluntaryExits               []*SignedVoluntaryExit        `json:"voluntary_exits"`
-	SyncAggregate                *SyncAggregate                `json:"sync_aggregate"`
-	BLSToExecutionChanges        []*SignedBLSToExecutionChange `json:"bls_to_execution_changes"`
-	SignedExecutionPayloadHeader *SignedExecutionPayloadHeader `json:"signed_execution_payload_header"`
-	PayloadAttestations          []*PayloadAttestation         `json:"payload_attestations"`
-}
-
-type SignedExecutionPayloadEnvelope struct {
-	Message   *ExecutionPayloadEnvelope `json:"message"`
-	Signature string                    `json:"signature"`
-}
-
-type ExecutionPayloadEnvelope struct {
-	Payload            *ExecutionPayloadDeneb `json:"payload"`
-	ExecutionRequests  *ExecutionRequests     `json:"execution_requests"`
-	BuilderIndex       string                 `json:"builder_index"`
-	BeaconBlockRoot    string                 `json:"beacon_block_root"`
-	Slot               string                 `json:"slot"`
-	BlobKzgCommitments []string               `json:"blob_kzg_commitments"`
-	StateRoot          string                 `json:"state_root"`
-}
-type SignedExecutionPayloadHeader struct {
-	Message   *ExecutionPayloadHeaderEPBS `json:"message"`
-	Signature string                      `json:"signature"`
-}
-
-type ExecutionPayloadHeaderEPBS struct {
-	ParentBlockHash        string `json:"parent_block_hash"`
-	ParentBlockRoot        string `json:"parent_block_root"`
-	BlockHash              string `json:"block_hash"`
-	GasLimit               string `json:"gas_limit"`
-	BuilderIndex           string `json:"builder_index"`
-	Slot                   string `json:"slot"`
-	Value                  string `json:"value"`
-	BlobKzgCommitmentsRoot string `json:"blob_kzg_commitments_root"`
-}
-
-type PayloadAttestation struct {
-	AggregationBits string                  `json:"aggregation_bits"`
-	Data            *PayloadAttestationData `json:"data"`
-	Signature       string                  `json:"signature"`
-}
-
-type PayloadAttestationData struct {
-	BeaconBlockRoot string `json:"beacon_block_root"`
-	Slot            string `json:"slot"`
-	PayloadStatus   string `json:"payload_status"`
-}
-
-type GetExecutionPayloadV1Response struct {
-	Version             string                          `json:"version"`
-	ExecutionOptimistic bool                            `json:"execution_optimistic"`
-	Finalized           bool                            `json:"finalized"`
-	Data                *SignedExecutionPayloadEnvelope `json:"data"`
-}

api/server/structs/conversions.go

@@ -10,6 +10,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/validator"
 	"github.com/OffchainLabs/prysm/v6/container/slice"
+	"github.com/OffchainLabs/prysm/v6/crypto/bls"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v6/math"
 	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
@@ -699,6 +700,11 @@ func (m *SyncCommitteeMessage) ToConsensus() (*eth.SyncCommitteeMessage, error)
 	if err != nil {
 		return nil, server.NewDecodeError(err, "Signature")
 	}
+	// Add validation to check if the signature is valid BLS format
+	_, err = bls.SignatureFromBytes(sig)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Signature")
+	}
 
 	return &eth.SyncCommitteeMessage{
 		Slot:           primitives.Slot(slot),

api/server/structs/conversions_block.go

@@ -268,8 +268,6 @@ func SignedBeaconBlockMessageJsoner(block interfaces.ReadOnlySignedBeaconBlock)
 		return SignedBlindedBeaconBlockFuluFromConsensus(pbStruct)
 	case *eth.SignedBeaconBlockFulu:
 		return SignedBeaconBlockFuluFromConsensus(pbStruct)
-	case *eth.SignedBeaconBlockEpbs:
-		return SignedBeaconBlockEpbsFromConsensus(pbStruct)
 	default:
 		return nil, ErrUnsupportedConversion
 	}

api/server/structs/conversions_state_epbs.go

@@ -1,202 +0,0 @@
-package structs
-
-import (
-	"fmt"
-
-	beaconState "github.com/OffchainLabs/prysm/v6/beacon-chain/state"
-	"github.com/ethereum/go-ethereum/common/hexutil"
-)
-
-// ----------------------------------------------------------------------------
-// Fulu
-// ----------------------------------------------------------------------------
-
-func BeaconStateEPBSFromConsensus(st beaconState.BeaconState) (*BeaconStateEPBS, error) {
-	srcBr := st.BlockRoots()
-	br := make([]string, len(srcBr))
-	for i, r := range srcBr {
-		br[i] = hexutil.Encode(r)
-	}
-	srcSr := st.StateRoots()
-	sr := make([]string, len(srcSr))
-	for i, r := range srcSr {
-		sr[i] = hexutil.Encode(r)
-	}
-	srcHr := st.HistoricalRoots()
-	hr := make([]string, len(srcHr))
-	for i, r := range srcHr {
-		hr[i] = hexutil.Encode(r)
-	}
-	srcVotes := st.Eth1DataVotes()
-	votes := make([]*Eth1Data, len(srcVotes))
-	for i, e := range srcVotes {
-		votes[i] = Eth1DataFromConsensus(e)
-	}
-	srcVals := st.Validators()
-	vals := make([]*Validator, len(srcVals))
-	for i, v := range srcVals {
-		vals[i] = ValidatorFromConsensus(v)
-	}
-	srcBals := st.Balances()
-	bals := make([]string, len(srcBals))
-	for i, b := range srcBals {
-		bals[i] = fmt.Sprintf("%d", b)
-	}
-	srcRm := st.RandaoMixes()
-	rm := make([]string, len(srcRm))
-	for i, m := range srcRm {
-		rm[i] = hexutil.Encode(m)
-	}
-	srcSlashings := st.Slashings()
-	slashings := make([]string, len(srcSlashings))
-	for i, s := range srcSlashings {
-		slashings[i] = fmt.Sprintf("%d", s)
-	}
-	srcPrevPart, err := st.PreviousEpochParticipation()
-	if err != nil {
-		return nil, err
-	}
-	prevPart := make([]string, len(srcPrevPart))
-	for i, p := range srcPrevPart {
-		prevPart[i] = fmt.Sprintf("%d", p)
-	}
-	srcCurrPart, err := st.CurrentEpochParticipation()
-	if err != nil {
-		return nil, err
-	}
-	currPart := make([]string, len(srcCurrPart))
-	for i, p := range srcCurrPart {
-		currPart[i] = fmt.Sprintf("%d", p)
-	}
-	srcIs, err := st.InactivityScores()
-	if err != nil {
-		return nil, err
-	}
-	is := make([]string, len(srcIs))
-	for i, s := range srcIs {
-		is[i] = fmt.Sprintf("%d", s)
-	}
-	currSc, err := st.CurrentSyncCommittee()
-	if err != nil {
-		return nil, err
-	}
-	nextSc, err := st.NextSyncCommittee()
-	if err != nil {
-		return nil, err
-	}
-	srcPayload, err := st.LatestExecutionPayloadHeaderEPBS()
-	if err != nil {
-		return nil, err
-	}
-	payload, err := ExecutionPayloadHeaderEPBSFromConsensus(srcPayload)
-	if err != nil {
-		return nil, err
-	}
-	srcHs, err := st.HistoricalSummaries()
-	if err != nil {
-		return nil, err
-	}
-	hs := make([]*HistoricalSummary, len(srcHs))
-	for i, s := range srcHs {
-		hs[i] = HistoricalSummaryFromConsensus(s)
-	}
-	nwi, err := st.NextWithdrawalIndex()
-	if err != nil {
-		return nil, err
-	}
-	nwvi, err := st.NextWithdrawalValidatorIndex()
-	if err != nil {
-		return nil, err
-	}
-	drsi, err := st.DepositRequestsStartIndex()
-	if err != nil {
-		return nil, err
-	}
-	dbtc, err := st.DepositBalanceToConsume()
-	if err != nil {
-		return nil, err
-	}
-	ebtc, err := st.ExitBalanceToConsume()
-	if err != nil {
-		return nil, err
-	}
-	eee, err := st.EarliestExitEpoch()
-	if err != nil {
-		return nil, err
-	}
-	cbtc, err := st.ConsolidationBalanceToConsume()
-	if err != nil {
-		return nil, err
-	}
-	ece, err := st.EarliestConsolidationEpoch()
-	if err != nil {
-		return nil, err
-	}
-	pbd, err := st.PendingDeposits()
-	if err != nil {
-		return nil, err
-	}
-	ppw, err := st.PendingPartialWithdrawals()
-	if err != nil {
-		return nil, err
-	}
-	pc, err := st.PendingConsolidations()
-	if err != nil {
-		return nil, err
-	}
-	latestBlockHash, err := st.LatestBlockHash()
-	if err != nil {
-		return nil, err
-	}
-	latestFullSlot, err := st.LatestFullSlot()
-	if err != nil {
-		return nil, err
-	}
-	latestWithdrawalsRoot, err := st.LastWithdrawalsRoot()
-	if err != nil {
-		return nil, err
-	}
-
-	return &BeaconStateEPBS{
-		GenesisTime:                   fmt.Sprintf("%d", st.GenesisTime().Unix()),
-		GenesisValidatorsRoot:         hexutil.Encode(st.GenesisValidatorsRoot()),
-		Slot:                          fmt.Sprintf("%d", st.Slot()),
-		Fork:                          ForkFromConsensus(st.Fork()),
-		LatestBlockHeader:             BeaconBlockHeaderFromConsensus(st.LatestBlockHeader()),
-		BlockRoots:                    br,
-		StateRoots:                    sr,
-		HistoricalRoots:               hr,
-		Eth1Data:                      Eth1DataFromConsensus(st.Eth1Data()),
-		Eth1DataVotes:                 votes,
-		Eth1DepositIndex:              fmt.Sprintf("%d", st.Eth1DepositIndex()),
-		Validators:                    vals,
-		Balances:                      bals,
-		RandaoMixes:                   rm,
-		Slashings:                     slashings,
-		PreviousEpochParticipation:    prevPart,
-		CurrentEpochParticipation:     currPart,
-		JustificationBits:             hexutil.Encode(st.JustificationBits()),
-		PreviousJustifiedCheckpoint:   CheckpointFromConsensus(st.PreviousJustifiedCheckpoint()),
-		CurrentJustifiedCheckpoint:    CheckpointFromConsensus(st.CurrentJustifiedCheckpoint()),
-		FinalizedCheckpoint:           CheckpointFromConsensus(st.FinalizedCheckpoint()),
-		InactivityScores:              is,
-		CurrentSyncCommittee:          SyncCommitteeFromConsensus(currSc),
-		NextSyncCommittee:             SyncCommitteeFromConsensus(nextSc),
-		LatestExecutionPayloadHeader:  payload,
-		NextWithdrawalIndex:           fmt.Sprintf("%d", nwi),
-		NextWithdrawalValidatorIndex:  fmt.Sprintf("%d", nwvi),
-		HistoricalSummaries:           hs,
-		DepositRequestsStartIndex:     fmt.Sprintf("%d", drsi),
-		DepositBalanceToConsume:       fmt.Sprintf("%d", dbtc),
-		ExitBalanceToConsume:          fmt.Sprintf("%d", ebtc),
-		EarliestExitEpoch:             fmt.Sprintf("%d", eee),
-		ConsolidationBalanceToConsume: fmt.Sprintf("%d", cbtc),
-		EarliestConsolidationEpoch:    fmt.Sprintf("%d", ece),
-		PendingDeposits:               PendingDepositsFromConsensus(pbd),
-		PendingPartialWithdrawals:     PendingPartialWithdrawalsFromConsensus(ppw),
-		PendingConsolidations:         PendingConsolidationsFromConsensus(pc),
-		LatestBlockHash:               hexutil.Encode(latestBlockHash),
-		LatestFullSlot:                fmt.Sprintf("%d", latestFullSlot),
-		LatestWithdrawalsRoot:         hexutil.Encode(latestWithdrawalsRoot),
-	}, nil
-}

api/server/structs/converstions_block_epbs.go

@@ -1,397 +0,0 @@
-package structs
-
-import (
-	"fmt"
-	"strconv"
-
-	"github.com/OffchainLabs/prysm/v6/api/server"
-	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
-	eth "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
-)
-
-// ----------------------------------------------------------------------------
-// Epbs
-// ----------------------------------------------------------------------------
-
-// nolint:gocognit
-func (b *BeaconBlockEpbs) ToConsensus() (*eth.BeaconBlockEpbs, error) {
-	if b == nil {
-		return nil, errNilValue
-	}
-	if b.Body == nil {
-		return nil, server.NewDecodeError(errNilValue, "Body")
-	}
-	if b.Body.Eth1Data == nil {
-		return nil, server.NewDecodeError(errNilValue, "Body.Eth1Data")
-	}
-	if b.Body.SyncAggregate == nil {
-		return nil, server.NewDecodeError(errNilValue, "Body.SyncAggregate")
-	}
-	slot, err := strconv.ParseUint(b.Slot, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Slot")
-	}
-	proposerIndex, err := strconv.ParseUint(b.ProposerIndex, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "ProposerIndex")
-	}
-	parentRoot, err := bytesutil.DecodeHexWithLength(b.ParentRoot, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "ParentRoot")
-	}
-	stateRoot, err := bytesutil.DecodeHexWithLength(b.StateRoot, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "StateRoot")
-	}
-	randaoReveal, err := bytesutil.DecodeHexWithLength(b.Body.RandaoReveal, fieldparams.BLSSignatureLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Body.RandaoReveal")
-	}
-	depositRoot, err := bytesutil.DecodeHexWithLength(b.Body.Eth1Data.DepositRoot, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Body.Eth1Data.DepositRoot")
-	}
-	depositCount, err := strconv.ParseUint(b.Body.Eth1Data.DepositCount, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Body.Eth1Data.DepositCount")
-	}
-	blockHash, err := bytesutil.DecodeHexWithLength(b.Body.Eth1Data.BlockHash, common.HashLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Body.Eth1Data.BlockHash")
-	}
-	graffiti, err := bytesutil.DecodeHexWithLength(b.Body.Graffiti, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Body.Graffiti")
-	}
-	proposerSlashings, err := ProposerSlashingsToConsensus(b.Body.ProposerSlashings)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Body.ProposerSlashings")
-	}
-	attesterSlashings, err := AttesterSlashingsElectraToConsensus(b.Body.AttesterSlashings)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Body.AttesterSlashings")
-	}
-	atts, err := AttsElectraToConsensus(b.Body.Attestations)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Body.Attestations")
-	}
-	deposits, err := DepositsToConsensus(b.Body.Deposits)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Body.Deposits")
-	}
-	exits, err := SignedExitsToConsensus(b.Body.VoluntaryExits)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Body.VoluntaryExits")
-	}
-	syncCommitteeBits, err := bytesutil.DecodeHexWithLength(b.Body.SyncAggregate.SyncCommitteeBits, fieldparams.SyncAggregateSyncCommitteeBytesLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Body.SyncAggregate.SyncCommitteeBits")
-	}
-	syncCommitteeSig, err := bytesutil.DecodeHexWithLength(b.Body.SyncAggregate.SyncCommitteeSignature, fieldparams.BLSSignatureLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Body.SyncAggregate.SyncCommitteeSignature")
-	}
-	signedPayloadHeader, err := b.Body.SignedExecutionPayloadHeader.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Body.SignedExecutionPayloadHeader")
-	}
-
-	blsChanges, err := SignedBLSChangesToConsensus(b.Body.BLSToExecutionChanges)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Body.BLSToExecutionChanges")
-	}
-	payloadAttestations := make([]*eth.PayloadAttestation, len(b.Body.PayloadAttestations))
-	for i, p := range b.Body.PayloadAttestations {
-		payloadAttestations[i], err = p.ToConsensus()
-		if err != nil {
-			return nil, server.NewDecodeError(err, fmt.Sprintf("Body.PayloadAttestations[%d]", i))
-		}
-	}
-
-	return &eth.BeaconBlockEpbs{
-		Slot:          primitives.Slot(slot),
-		ProposerIndex: primitives.ValidatorIndex(proposerIndex),
-		ParentRoot:    parentRoot,
-		StateRoot:     stateRoot,
-		Body: &eth.BeaconBlockBodyEpbs{
-			RandaoReveal: randaoReveal,
-			Eth1Data: &eth.Eth1Data{
-				DepositRoot:  depositRoot,
-				DepositCount: depositCount,
-				BlockHash:    blockHash,
-			},
-			Graffiti:          graffiti,
-			ProposerSlashings: proposerSlashings,
-			AttesterSlashings: attesterSlashings,
-			Attestations:      atts,
-			Deposits:          deposits,
-			VoluntaryExits:    exits,
-			SyncAggregate: &eth.SyncAggregate{
-				SyncCommitteeBits:      syncCommitteeBits,
-				SyncCommitteeSignature: syncCommitteeSig,
-			},
-			BlsToExecutionChanges:        blsChanges,
-			SignedExecutionPayloadHeader: signedPayloadHeader,
-			PayloadAttestations:          payloadAttestations,
-		},
-	}, nil
-}
-
-func (p *PayloadAttestation) ToConsensus() (*eth.PayloadAttestation, error) {
-	if p == nil {
-		return nil, errNilValue
-	}
-	aggregationBits, err := bytesutil.DecodeHexWithLength(p.AggregationBits, fieldparams.PTCSize/8)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "AggregationBits")
-	}
-	data, err := p.Data.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Data")
-	}
-	sig, err := bytesutil.DecodeHexWithLength(p.Signature, fieldparams.BLSSignatureLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Signature")
-	}
-	return &eth.PayloadAttestation{
-		AggregationBits: aggregationBits,
-		Data:            data,
-		Signature:       sig,
-	}, nil
-}
-
-func (p *PayloadAttestationData) ToConsensus() (*eth.PayloadAttestationData, error) {
-	if p == nil {
-		return nil, errNilValue
-	}
-	beaconBlockRoot, err := bytesutil.DecodeHexWithLength(p.BeaconBlockRoot, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "BeaconBlockRoot")
-	}
-	slot, err := strconv.ParseUint(p.Slot, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Slot")
-	}
-	payloadStatus, err := strconv.ParseUint(p.PayloadStatus, 10, 8)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "PayloadStatus")
-	}
-	return &eth.PayloadAttestationData{
-		BeaconBlockRoot: beaconBlockRoot,
-		Slot:            primitives.Slot(slot),
-		PayloadStatus:   bytesutil.Bytes1(payloadStatus),
-	}, nil
-}
-
-func (p *SignedExecutionPayloadHeader) ToConsensus() (*enginev1.SignedExecutionPayloadHeader, error) {
-	if p == nil {
-		return nil, errNilValue
-	}
-	sig, err := bytesutil.DecodeHexWithLength(p.Signature, fieldparams.BLSSignatureLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Signature")
-	}
-	header, err := p.Message.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Header")
-	}
-	return &enginev1.SignedExecutionPayloadHeader{
-		Message:   header,
-		Signature: sig,
-	}, nil
-}
-
-func (p *ExecutionPayloadHeaderEPBS) ToConsensus() (*enginev1.ExecutionPayloadHeaderEPBS, error) {
-	parentBlockHash, err := bytesutil.DecodeHexWithLength(p.ParentBlockHash, common.HashLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "ParentBlockHash")
-	}
-	parentBlockRoot, err := bytesutil.DecodeHexWithLength(p.ParentBlockRoot, common.HashLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "ParentBlockRoot")
-	}
-	blockHash, err := bytesutil.DecodeHexWithLength(p.BlockHash, common.HashLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "BlockHash")
-	}
-	gasLimit, err := strconv.ParseUint(p.GasLimit, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "GasLimit")
-	}
-	builderIndex, err := strconv.ParseUint(p.BuilderIndex, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "BuilderIndex")
-	}
-	slot, err := strconv.ParseUint(p.Slot, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Slot")
-	}
-	value, err := strconv.ParseUint(p.Value, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Value")
-	}
-	blobKzgCommitmentsRoot, err := bytesutil.DecodeHexWithLength(p.BlobKzgCommitmentsRoot, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "BlobKzgCommitmentsRoot")
-	}
-	return &enginev1.ExecutionPayloadHeaderEPBS{
-		ParentBlockHash:        parentBlockHash,
-		ParentBlockRoot:        parentBlockRoot,
-		BlockHash:              blockHash,
-		GasLimit:               gasLimit,
-		BuilderIndex:           primitives.ValidatorIndex(builderIndex),
-		Slot:                   primitives.Slot(slot),
-		Value:                  value,
-		BlobKzgCommitmentsRoot: blobKzgCommitmentsRoot,
-	}, nil
-}
-
-func (b *SignedBeaconBlockEpbs) ToConsensus() (*eth.SignedBeaconBlockEpbs, error) {
-	if b == nil {
-		return nil, errNilValue
-	}
-
-	sig, err := bytesutil.DecodeHexWithLength(b.Signature, fieldparams.BLSSignatureLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Signature")
-	}
-	block, err := b.Message.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Message")
-	}
-	return &eth.SignedBeaconBlockEpbs{
-		Block:     block,
-		Signature: sig,
-	}, nil
-}
-
-func BeaconBlockEpbsFromConsensus(b *eth.BeaconBlockEpbs) (*BeaconBlockEpbs, error) {
-	signedPayloadHeader, err := SignedExecutionPayloadHeaderFromConsensus(b.Body.SignedExecutionPayloadHeader)
-	if err != nil {
-		return nil, err
-	}
-	payloadAttestations, err := PayloadAttestationsFromConsensus(b.Body.PayloadAttestations)
-	if err != nil {
-		return nil, err
-	}
-	return &BeaconBlockEpbs{
-		Slot:          fmt.Sprintf("%d", b.Slot),
-		ProposerIndex: fmt.Sprintf("%d", b.ProposerIndex),
-		ParentRoot:    hexutil.Encode(b.ParentRoot),
-		StateRoot:     hexutil.Encode(b.StateRoot),
-		Body: &BeaconBlockBodyEpbs{
-			RandaoReveal:      hexutil.Encode(b.Body.RandaoReveal),
-			Eth1Data:          Eth1DataFromConsensus(b.Body.Eth1Data),
-			Graffiti:          hexutil.Encode(b.Body.Graffiti),
-			ProposerSlashings: ProposerSlashingsFromConsensus(b.Body.ProposerSlashings),
-			AttesterSlashings: AttesterSlashingsElectraFromConsensus(b.Body.AttesterSlashings),
-			Attestations:      AttsElectraFromConsensus(b.Body.Attestations),
-			Deposits:          DepositsFromConsensus(b.Body.Deposits),
-			VoluntaryExits:    SignedExitsFromConsensus(b.Body.VoluntaryExits),
-			SyncAggregate: &SyncAggregate{
-				SyncCommitteeBits:      hexutil.Encode(b.Body.SyncAggregate.SyncCommitteeBits),
-				SyncCommitteeSignature: hexutil.Encode(b.Body.SyncAggregate.SyncCommitteeSignature),
-			},
-			BLSToExecutionChanges:        SignedBLSChangesFromConsensus(b.Body.BlsToExecutionChanges),
-			SignedExecutionPayloadHeader: signedPayloadHeader,
-			PayloadAttestations:          payloadAttestations,
-		},
-	}, nil
-}
-
-func SignedExecutionPayloadEnvelopeFromConsensus(b *enginev1.SignedExecutionPayloadEnvelope) (*SignedExecutionPayloadEnvelope, error) {
-	payload, err := ExecutionPayloadEnvelopeFromConsensus(b.Message)
-	if err != nil {
-		return nil, err
-	}
-	return &SignedExecutionPayloadEnvelope{
-		Message:   payload,
-		Signature: hexutil.Encode(b.Signature),
-	}, nil
-}
-
-func ExecutionPayloadEnvelopeFromConsensus(b *enginev1.ExecutionPayloadEnvelope) (*ExecutionPayloadEnvelope, error) {
-	payload, err := ExecutionPayloadDenebFromConsensus(b.Payload)
-	if err != nil {
-		return nil, err
-	}
-	committments := make([]string, len(b.BlobKzgCommitments))
-	for i, c := range b.BlobKzgCommitments {
-		committments[i] = hexutil.Encode(c)
-	}
-
-	executionRequests := ExecutionRequestsFromConsensus(b.ExecutionRequests)
-	return &ExecutionPayloadEnvelope{
-		Payload:            payload,
-		ExecutionRequests:  executionRequests,
-		BuilderIndex:       fmt.Sprintf("%d", b.BuilderIndex),
-		BeaconBlockRoot:    hexutil.Encode(b.BeaconBlockRoot),
-		Slot:               fmt.Sprintf("%d", b.Slot),
-		BlobKzgCommitments: committments,
-		StateRoot:          hexutil.Encode(b.BeaconStateRoot),
-	}, nil
-}
-
-func SignedBeaconBlockEpbsFromConsensus(b *eth.SignedBeaconBlockEpbs) (*SignedBeaconBlockEpbs, error) {
-	block, err := BeaconBlockEpbsFromConsensus(b.Block)
-	if err != nil {
-		return nil, err
-	}
-	return &SignedBeaconBlockEpbs{
-		Message:   block,
-		Signature: hexutil.Encode(b.Signature),
-	}, nil
-}
-
-func SignedExecutionPayloadHeaderFromConsensus(b *enginev1.SignedExecutionPayloadHeader) (*SignedExecutionPayloadHeader, error) {
-	header, err := ExecutionPayloadHeaderEPBSFromConsensus(b.Message)
-	if err != nil {
-		return nil, err
-	}
-	return &SignedExecutionPayloadHeader{
-		Message:   header,
-		Signature: hexutil.Encode(b.Signature),
-	}, nil
-}
-
-func ExecutionPayloadHeaderEPBSFromConsensus(b *enginev1.ExecutionPayloadHeaderEPBS) (*ExecutionPayloadHeaderEPBS, error) {
-	return &ExecutionPayloadHeaderEPBS{
-		ParentBlockHash:        hexutil.Encode(b.ParentBlockHash),
-		ParentBlockRoot:        hexutil.Encode(b.ParentBlockRoot),
-		BlockHash:              hexutil.Encode(b.BlockHash),
-		GasLimit:               fmt.Sprintf("%d", b.GasLimit),
-		BuilderIndex:           fmt.Sprintf("%d", b.BuilderIndex),
-		Slot:                   fmt.Sprintf("%d", b.Slot),
-		Value:                  fmt.Sprintf("%d", b.Value),
-		BlobKzgCommitmentsRoot: hexutil.Encode(b.BlobKzgCommitmentsRoot),
-	}, nil
-}
-
-func PayloadAttestationsFromConsensus(b []*eth.PayloadAttestation) ([]*PayloadAttestation, error) {
-	payloadAttestations := make([]*PayloadAttestation, len(b))
-	for i, p := range b {
-		data, err := PayloadAttestationDataFromConsensus(p.Data)
-		if err != nil {
-			return nil, err
-		}
-		payloadAttestations[i] = &PayloadAttestation{
-			AggregationBits: hexutil.Encode(p.AggregationBits),
-			Data:            data,
-			Signature:       hexutil.Encode(p.Signature),
-		}
-	}
-	return payloadAttestations, nil
-}
-
-func PayloadAttestationDataFromConsensus(b *eth.PayloadAttestationData) (*PayloadAttestationData, error) {
-	return &PayloadAttestationData{
-		BeaconBlockRoot: hexutil.Encode(b.BeaconBlockRoot),
-		Slot:            fmt.Sprintf("%d", b.Slot),
-		PayloadStatus:   fmt.Sprintf("%d", b.PayloadStatus),
-	}, nil
-}

api/server/structs/endpoints_beacon.go

@@ -283,3 +283,10 @@ type GetPendingPartialWithdrawalsResponse struct {
 	Finalized           bool                        `json:"finalized"`
 	Data                []*PendingPartialWithdrawal `json:"data"`
 }
+
+type GetProposerLookaheadResponse struct {
+	Version             string   `json:"version"`
+	ExecutionOptimistic bool     `json:"execution_optimistic"`
+	Finalized           bool     `json:"finalized"`
+	Data                []string `json:"data"` // validator indexes
+}

api/server/structs/endpoints_events.go

@@ -32,13 +32,6 @@ type DataColumnGossipEvent struct {
 	KzgCommitments []string `json:"kzg_commitments"`
 }
 
-type PayloadEvent struct {
-	Slot                string `json:"slot"`
-	BlockRoot           string `json:"block_root"`
-	ExecutionBlockHash  string `json:"execution_block_hash"`
-	ExecutionOptimistic bool   `json:"execution_optimistic"`
-}
-
 type AggregatedAttEventSource struct {
 	Aggregate *Attestation `json:"aggregate"`
 }

api/server/structs/endpoints_node.go

@@ -27,6 +27,8 @@ type Identity struct {
 type Metadata struct {
 	SeqNumber string `json:"seq_number"`
 	Attnets   string `json:"attnets"`
+	Syncnets  string `json:"syncnets,omitempty"`
+	Cgc       string `json:"custody_group_count,omitempty"`
 }
 
 type GetPeerResponse struct {

api/server/structs/state_epbs.go

@@ -1,44 +0,0 @@
-package structs
-
-type BeaconStateEPBS struct {
-	GenesisTime                   string                      `json:"genesis_time"`
-	GenesisValidatorsRoot         string                      `json:"genesis_validators_root"`
-	Slot                          string                      `json:"slot"`
-	Fork                          *Fork                       `json:"fork"`
-	LatestBlockHeader             *BeaconBlockHeader          `json:"latest_block_header"`
-	BlockRoots                    []string                    `json:"block_roots"`
-	StateRoots                    []string                    `json:"state_roots"`
-	HistoricalRoots               []string                    `json:"historical_roots"`
-	Eth1Data                      *Eth1Data                   `json:"eth1_data"`
-	Eth1DataVotes                 []*Eth1Data                 `json:"eth1_data_votes"`
-	Eth1DepositIndex              string                      `json:"eth1_deposit_index"`
-	Validators                    []*Validator                `json:"validators"`
-	Balances                      []string                    `json:"balances"`
-	RandaoMixes                   []string                    `json:"randao_mixes"`
-	Slashings                     []string                    `json:"slashings"`
-	PreviousEpochParticipation    []string                    `json:"previous_epoch_participation"`
-	CurrentEpochParticipation     []string                    `json:"current_epoch_participation"`
-	JustificationBits             string                      `json:"justification_bits"`
-	PreviousJustifiedCheckpoint   *Checkpoint                 `json:"previous_justified_checkpoint"`
-	CurrentJustifiedCheckpoint    *Checkpoint                 `json:"current_justified_checkpoint"`
-	FinalizedCheckpoint           *Checkpoint                 `json:"finalized_checkpoint"`
-	InactivityScores              []string                    `json:"inactivity_scores"`
-	CurrentSyncCommittee          *SyncCommittee              `json:"current_sync_committee"`
-	NextSyncCommittee             *SyncCommittee              `json:"next_sync_committee"`
-	LatestExecutionPayloadHeader  *ExecutionPayloadHeaderEPBS `json:"latest_execution_payload_header"`
-	NextWithdrawalIndex           string                      `json:"next_withdrawal_index"`
-	NextWithdrawalValidatorIndex  string                      `json:"next_withdrawal_validator_index"`
-	HistoricalSummaries           []*HistoricalSummary        `json:"historical_summaries"`
-	DepositRequestsStartIndex     string                      `json:"deposit_requests_start_index"`
-	DepositBalanceToConsume       string                      `json:"deposit_balance_to_consume"`
-	ExitBalanceToConsume          string                      `json:"exit_balance_to_consume"`
-	EarliestExitEpoch             string                      `json:"earliest_exit_epoch"`
-	ConsolidationBalanceToConsume string                      `json:"consolidation_balance_to_consume"`
-	EarliestConsolidationEpoch    string                      `json:"earliest_consolidation_epoch"`
-	PendingDeposits               []*PendingDeposit           `json:"pending_deposits"`
-	PendingPartialWithdrawals     []*PendingPartialWithdrawal `json:"pending_partial_withdrawals"`
-	PendingConsolidations         []*PendingConsolidation     `json:"pending_consolidations"`
-	LatestBlockHash               string                      `json:"latest_block_hash"`
-	LatestFullSlot                string                      `json:"latest_full_slot"`
-	LatestWithdrawalsRoot         string                      `json:"latest_withdrawals_root"`
-}

beacon-chain/blockchain/BUILD.bazel

@@ -6,11 +6,9 @@ go_library(
         "chain_info.go",
         "chain_info_forkchoice.go",
         "currently_syncing_block.go",
-        "currently_syncing_execution_payload_envelope.go",
         "defragment.go",
         "error.go",
         "execution_engine.go",
-        "execution_engine_epbs.go",
         "forkchoice_update_execution.go",
         "head.go",
         "head_sync_committee_info.go",
@@ -28,8 +26,6 @@ go_library(
         "receive_blob.go",
         "receive_block.go",
         "receive_data_column.go",
-        "receive_execution_payload_envelope.go",
-        "receive_payload_attestation_message.go",
         "service.go",
         "setup_forchoice.go",
         "tracked_proposer.go",
@@ -50,7 +46,6 @@ go_library(
         "//beacon-chain/core/altair:go_default_library",
         "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/electra:go_default_library",
-        "//beacon-chain/core/epbs:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
@@ -78,6 +73,7 @@ go_library(
         "//beacon-chain/state: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",
@@ -107,7 +103,6 @@ go_library(
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
-        "@io_opencensus_go//trace:go_default_library",
         "@org_golang_x_sync//errgroup:go_default_library",
     ],
 )
@@ -120,7 +115,6 @@ go_test(
         "chain_info_norace_test.go",
         "chain_info_test.go",
         "checktags_test.go",
-        "epbs_test.go",
         "error_test.go",
         "execution_engine_test.go",
         "forkchoice_update_execution_test.go",
@@ -136,7 +130,6 @@ go_test(
         "process_block_test.go",
         "receive_attestation_test.go",
         "receive_block_test.go",
-        "receive_execution_payload_envelope_test.go",
         "service_norace_test.go",
         "service_test.go",
         "setup_forkchoice_test.go",
@@ -189,6 +182,7 @@ go_test(
         "//container/trie:go_default_library",
         "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//genesis:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
@@ -196,13 +190,13 @@ go_test(
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
-        "//testing/util/random:go_default_library",
         "//time:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_ethereum_go_ethereum//core/types:go_default_library",
         "@com_github_holiman_uint256//:go_default_library",
+        "@com_github_libp2p_go_libp2p//core/peer:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",

beacon-chain/blockchain/chain_info.go

@@ -43,7 +43,7 @@ type ForkchoiceFetcher interface {
 	GetProposerHead() [32]byte
 	SetForkChoiceGenesisTime(time.Time)
 	UpdateHead(context.Context, primitives.Slot)
-	HighestReceivedBlockSlotRoot() (primitives.Slot, [32]byte)
+	HighestReceivedBlockSlot() primitives.Slot
 	ReceivedBlocksLastEpoch() (uint64, error)
 	InsertNode(context.Context, state.BeaconState, consensus_blocks.ROBlock) error
 	ForkChoiceDump(context.Context) (*forkchoice.Dump, error)
@@ -52,8 +52,6 @@ type ForkchoiceFetcher interface {
 	RecentBlockSlot(root [32]byte) (primitives.Slot, error)
 	IsCanonical(ctx context.Context, blockRoot [32]byte) (bool, error)
 	DependentRoot(primitives.Epoch) ([32]byte, error)
-	GetPTCVote(root [32]byte) primitives.PTCStatus
-	HashForBlockRoot(context.Context, [32]byte) ([]byte, error)
 }
 
 // TimeFetcher retrieves the Ethereum consensus data that's related to time.
@@ -122,12 +120,6 @@ type OptimisticModeFetcher interface {
 	IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool, error)
 }
 
-// ExecutionPayloadFetcher defines a common interface that returns forkchoice
-// information about payload block hashes
-type ExecutionPayloadFetcher interface {
-	HashInForkchoice([32]byte) bool
-}
-
 // FinalizedCheckpt returns the latest finalized checkpoint from chain store.
 func (s *Service) FinalizedCheckpt() *ethpb.Checkpoint {
 	s.cfg.ForkChoiceStore.RLock()
@@ -409,14 +401,6 @@ func (s *Service) InForkchoice(root [32]byte) bool {
 	return s.cfg.ForkChoiceStore.HasNode(root)
 }
 
-// HashInForkchoice returns true if the given payload block hash is found in
-// forkchoice
-func (s *Service) HashInForkchoice(hash [32]byte) bool {
-	s.cfg.ForkChoiceStore.RLock()
-	defer s.cfg.ForkChoiceStore.RUnlock()
-	return s.cfg.ForkChoiceStore.HasHash(hash)
-}
-
 // IsOptimisticForRoot takes the root as argument instead of the current head
 // and returns true if it is optimistic.
 func (s *Service) IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool, error) {
@@ -553,12 +537,6 @@ func (s *Service) BlockBeingSynced(root [32]byte) bool {
 	return s.blockBeingSynced.isSyncing(root)
 }
 
-// PayloadBeingSynced returns whether the block with the given root is currently being synced
-func (s *Service) PayloadBeingSynced(root [32]byte) bool {
-	_, syncing := s.payloadBeingSynced.isSyncing(root)
-	return syncing
-}
-
 // RecentBlockSlot returns block slot form fork choice store
 func (s *Service) RecentBlockSlot(root [32]byte) (primitives.Slot, error) {
 	s.cfg.ForkChoiceStore.RLock()

beacon-chain/blockchain/chain_info_forkchoice.go

@@ -7,7 +7,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	consensus_blocks "github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/forkchoice"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
@@ -35,11 +34,11 @@ func (s *Service) SetForkChoiceGenesisTime(timestamp time.Time) {
 	s.cfg.ForkChoiceStore.SetGenesisTime(timestamp)
 }
 
-// HighestReceivedBlockSlotRoot returns the corresponding value from forkchoice
-func (s *Service) HighestReceivedBlockSlotRoot() (primitives.Slot, [32]byte) {
+// HighestReceivedBlockSlot returns the corresponding value from forkchoice
+func (s *Service) HighestReceivedBlockSlot() primitives.Slot {
 	s.cfg.ForkChoiceStore.RLock()
 	defer s.cfg.ForkChoiceStore.RUnlock()
-	return s.cfg.ForkChoiceStore.HighestReceivedBlockSlotRoot()
+	return s.cfg.ForkChoiceStore.HighestReceivedBlockSlot()
 }
 
 // ReceivedBlocksLastEpoch returns the corresponding value from forkchoice
@@ -122,13 +121,6 @@ func (s *Service) hashForGenesisBlock(ctx context.Context, root [32]byte) ([]byt
 	if st.Version() < version.Bellatrix {
 		return nil, nil
 	}
-	if st.Version() >= version.EPBS {
-		header, err := st.LatestExecutionPayloadHeaderEPBS()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get latest execution payload header")
-		}
-		return bytesutil.SafeCopyBytes(header.BlockHash), nil
-	}
 	header, err := st.LatestExecutionPayloadHeader()
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get latest execution payload header")
@@ -142,65 +134,3 @@ func (s *Service) DependentRoot(epoch primitives.Epoch) ([32]byte, error) {
 	defer s.cfg.ForkChoiceStore.RUnlock()
 	return s.cfg.ForkChoiceStore.DependentRoot(epoch)
 }
-
-// HashForBlockRoot wraps a call to the corresponding method in forkchoice. If the hash is older it will grab it from DB
-func (s *Service) HashForBlockRoot(ctx context.Context, root [32]byte) ([]byte, error) {
-	s.cfg.ForkChoiceStore.RLock()
-	defer s.cfg.ForkChoiceStore.RUnlock()
-	hash := s.cfg.ForkChoiceStore.HashForBlockRoot(root)
-	if hash != [32]byte{} {
-		return hash[:], nil
-	}
-	blk, err := s.cfg.BeaconDB.Block(ctx, root)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to get block from DB and forkchoice")
-	}
-	// check for genesis block hash
-	genHash, err := s.hashForGenesisBlock(ctx, root)
-	if err == nil {
-		return genHash, nil
-	}
-	if !errors.Is(err, errNotGenesisRoot) {
-		return nil, errors.Wrap(err, "failed to get genesis block hash")
-	}
-	if blk.Version() < version.EPBS {
-		return nil, errors.New("block version is too old")
-	}
-	sh, err := blk.Block().Body().SignedExecutionPayloadHeader()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to get signed execution payload header")
-	}
-	h, err := sh.Header()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to get execution payload header")
-	}
-	hash = h.BlockHash()
-	return hash[:], nil
-}
-
-// GetPTCVote wraps a call to the corresponding method in forkchoice and checks
-// the currently syncing status
-// Warning: this method will return the current PTC status regardless of
-// timeliness. A client MUST call this method when about to submit a PTC
-// attestation, that is exactly at the threshold to submit the attestation.
-func (s *Service) GetPTCVote(root [32]byte) primitives.PTCStatus {
-	s.cfg.ForkChoiceStore.RLock()
-	f := s.cfg.ForkChoiceStore.GetPTCVote()
-	s.cfg.ForkChoiceStore.RUnlock()
-	if f != primitives.PAYLOAD_ABSENT {
-		return f
-	}
-	f, isSyncing := s.payloadBeingSynced.isSyncing(root)
-	if isSyncing {
-		return f
-	}
-	return primitives.PAYLOAD_ABSENT
-}
-
-// insertPayloadEnvelope wraps a locked call to the corresponding method in
-// forkchoice
-func (s *Service) insertPayloadEnvelope(envelope interfaces.ROExecutionPayloadEnvelope) error {
-	s.cfg.ForkChoiceStore.Lock()
-	defer s.cfg.ForkChoiceStore.Unlock()
-	return s.cfg.ForkChoiceStore.InsertPayloadEnvelope(envelope)
-}

beacon-chain/blockchain/chain_info_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/genesis"
 	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
@@ -624,6 +625,7 @@ func Test_hashForGenesisRoot(t *testing.T) {
 	ctx := t.Context()
 	c := setupBeaconChain(t, beaconDB)
 	st, _ := util.DeterministicGenesisStateElectra(t, 10)
+	genesis.StoreDuringTest(t, genesis.GenesisData{State: st})
 	require.NoError(t, c.cfg.BeaconDB.SaveGenesisData(ctx, st))
 	root, err := beaconDB.GenesisBlockRoot(ctx)
 	require.NoError(t, err)

beacon-chain/blockchain/currently_syncing_block.go

@@ -7,10 +7,15 @@ type currentlySyncingBlock struct {
 	roots map[[32]byte]struct{}
 }
 
-func (b *currentlySyncingBlock) set(root [32]byte) {
+func (b *currentlySyncingBlock) set(root [32]byte) error {
 	b.Lock()
 	defer b.Unlock()
+	_, ok := b.roots[root]
+	if ok {
+		return errBlockBeingSynced
+	}
 	b.roots[root] = struct{}{}
+	return nil
 }
 
 func (b *currentlySyncingBlock) unset(root [32]byte) {

beacon-chain/blockchain/currently_syncing_execution_payload_envelope.go

@@ -1,32 +0,0 @@
-package blockchain
-
-import (
-	"sync"
-
-	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-)
-
-type currentlySyncingPayload struct {
-	sync.Mutex
-	roots map[[32]byte]primitives.PTCStatus
-}
-
-func (b *currentlySyncingPayload) set(envelope interfaces.ROExecutionPayloadEnvelope) {
-	b.Lock()
-	defer b.Unlock()
-	b.roots[envelope.BeaconBlockRoot()] = primitives.PAYLOAD_PRESENT
-}
-
-func (b *currentlySyncingPayload) unset(root [32]byte) {
-	b.Lock()
-	defer b.Unlock()
-	delete(b.roots, root)
-}
-
-func (b *currentlySyncingPayload) isSyncing(root [32]byte) (status primitives.PTCStatus, isSyncing bool) {
-	b.Lock()
-	defer b.Unlock()
-	status, isSyncing = b.roots[root]
-	return
-}

beacon-chain/blockchain/epbs_test.go

@@ -1,18 +0,0 @@
-package blockchain
-
-import (
-	"testing"
-
-	doublylinkedtree "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/doubly-linked-tree"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-)
-
-func TestServiceGetPTCVote(t *testing.T) {
-	c := &currentlySyncingPayload{roots: make(map[[32]byte]primitives.PTCStatus)}
-	s := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}, payloadBeingSynced: c}
-	r := [32]byte{'r'}
-	require.Equal(t, primitives.PAYLOAD_ABSENT, s.GetPTCVote(r))
-	c.roots[r] = primitives.PAYLOAD_WITHHELD
-	require.Equal(t, primitives.PAYLOAD_WITHHELD, s.GetPTCVote(r))
-}

beacon-chain/blockchain/error.go

@@ -36,17 +36,16 @@ var (
 	ErrNotCheckpoint = errors.New("not a checkpoint in forkchoice")
 	// ErrNilHead is returned when no head is present in the blockchain service.
 	ErrNilHead = errors.New("nil head")
+	// errNotGenesisRoot is returned when the root is not the genesis block root.
+	errNotGenesisRoot = errors.New("root is not the genesis block root")
 	// errBlacklistedBlock is returned when a block is blacklisted as invalid.
 	errBlacklistedRoot = verification.AsVerificationFailure(errors.New("block root is blacklisted"))
 	// errMaxBlobsExceeded is returned when the number of blobs in a block exceeds the maximum allowed.
 	errMaxBlobsExceeded = verification.AsVerificationFailure(errors.New("expected commitments in block exceeds MAX_BLOBS_PER_BLOCK"))
 	// errMaxDataColumnsExceeded is returned when the number of data columns exceeds the maximum allowed.
 	errMaxDataColumnsExceeded = verification.AsVerificationFailure(errors.New("expected data columns for node exceeds NUMBER_OF_COLUMNS"))
-	// errInvalidValidatorIndex is returned when a validator index is
-	// invalid or unexpected
-	errInvalidValidatorIndex = errors.New("invalid validator index")
-	// errNotGenesisRoot is returned when the root is not the genesis block root.
-	errNotGenesisRoot = errors.New("root is not the genesis block root")
+	// errBlockBeingSynced is returned when a block is being synced.
+	errBlockBeingSynced = errors.New("block is being synced")
 )
 
 // An invalid block is the block that fails state transition based on the core protocol rules.

beacon-chain/blockchain/execution_engine.go

@@ -2,7 +2,6 @@ package blockchain
 
 import (
 	"context"
-	"crypto/sha256"
 	"fmt"
 
 	"github.com/OffchainLabs/prysm/v6/async/event"
@@ -31,8 +30,6 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
-const blobCommitmentVersionKZG uint8 = 0x01
-
 var defaultLatestValidHash = bytesutil.PadTo([]byte{0xff}, 32)
 
 // notifyForkchoiceUpdate signals execution engine the fork choice updates. Execution engine should:
@@ -109,14 +106,6 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 				log.WithError(err).Error("Could not set head root to invalid")
 				return nil, nil
 			}
-			if len(invalidRoots) == 0 {
-				log.WithFields(logrus.Fields{
-					"slot":      headBlk.Slot(),
-					"blockRoot": fmt.Sprintf("%#x", bytesutil.Trunc(headRoot[:])),
-				}).Warn("Invalid payload")
-				return nil, nil
-			}
-
 			if err := s.removeInvalidBlockAndState(ctx, invalidRoots); err != nil {
 				log.WithError(err).Error("Could not remove invalid block and state")
 				return nil, nil
@@ -131,7 +120,6 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 				}).Warn("Pruned invalid blocks, could not update head root")
 				return nil, invalidBlock{error: ErrInvalidPayload, root: arg.headRoot, invalidAncestorRoots: invalidRoots}
 			}
-
 			b, err := s.getBlock(ctx, r)
 			if err != nil {
 				log.WithError(err).Error("Could not get head block")
@@ -186,6 +174,7 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 			"payloadID": fmt.Sprintf("%#x", bytesutil.Trunc(payloadID[:])),
 		}).Info("Forkchoice updated with payload attributes for proposal")
 		s.cfg.PayloadIDCache.Set(nextSlot, arg.headRoot, pId)
+		go s.firePayloadAttributesEvent(s.cfg.StateNotifier.StateFeed(), arg.headBlock, arg.headRoot, nextSlot)
 	} else if hasAttr && payloadID == nil && !features.Get().PrepareAllPayloads {
 		log.WithFields(logrus.Fields{
 			"blockHash": fmt.Sprintf("%#x", headPayload.BlockHash()),
@@ -466,13 +455,7 @@ func kzgCommitmentsToVersionedHashes(body interfaces.ReadOnlyBeaconBlockBody) ([
 
 	versionedHashes := make([]common.Hash, len(commitments))
 	for i, commitment := range commitments {
-		versionedHashes[i] = ConvertKzgCommitmentToVersionedHash(commitment)
+		versionedHashes[i] = primitives.ConvertKzgCommitmentToVersionedHash(commitment)
 	}
 	return versionedHashes, nil
 }
-
-func ConvertKzgCommitmentToVersionedHash(commitment []byte) common.Hash {
-	versionedHash := sha256.Sum256(commitment)
-	versionedHash[0] = blobCommitmentVersionKZG
-	return versionedHash
-}

beacon-chain/blockchain/execution_engine_epbs.go

@@ -1,62 +0,0 @@
-package blockchain
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution"
-	"github.com/OffchainLabs/prysm/v6/config/features"
-	payloadattribute "github.com/OffchainLabs/prysm/v6/consensus-types/payload-attribute"
-	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
-	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
-	"github.com/OffchainLabs/prysm/v6/runtime/version"
-	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
-)
-
-// notifyForkchoiceUpdate signals execution engine the fork choice updates. Execution engine should:
-// 1. Re-organizes the execution payload chain and corresponding state to make head_block_hash the head.
-// 2. Applies finality to the execution state: it irreversibly persists the chain of all execution payloads and corresponding state, up to and including finalized_block_hash.
-func (s *Service) notifyForkchoiceUpdateEPBS(ctx context.Context, blockhash [32]byte, attributes payloadattribute.Attributer) (*enginev1.PayloadIDBytes, error) {
-	ctx, span := trace.StartSpan(ctx, "blockChain.notifyForkchoiceUpdateEPBS")
-	defer span.End()
-
-	finalizedHash := s.cfg.ForkChoiceStore.FinalizedPayloadBlockHash()
-	justifiedHash := s.cfg.ForkChoiceStore.UnrealizedJustifiedPayloadBlockHash()
-	fcs := &enginev1.ForkchoiceState{
-		HeadBlockHash:      blockhash[:],
-		SafeBlockHash:      justifiedHash[:],
-		FinalizedBlockHash: finalizedHash[:],
-	}
-	if attributes == nil {
-		attributes = payloadattribute.EmptyWithVersion(version.EPBS)
-	}
-	payloadID, lastValidHash, err := s.cfg.ExecutionEngineCaller.ForkchoiceUpdated(ctx, fcs, attributes)
-	if err != nil {
-		switch {
-		case errors.Is(err, execution.ErrAcceptedSyncingPayloadStatus):
-			forkchoiceUpdatedOptimisticNodeCount.Inc()
-			log.WithFields(logrus.Fields{
-				"headPayloadBlockHash":      fmt.Sprintf("%#x", bytesutil.Trunc(blockhash[:])),
-				"finalizedPayloadBlockHash": fmt.Sprintf("%#x", bytesutil.Trunc(finalizedHash[:])),
-			}).Info("Called fork choice updated with optimistic block")
-			return payloadID, nil
-		case errors.Is(err, execution.ErrInvalidPayloadStatus):
-			log.WithError(err).Info("Forkchoice updated to invalid block")
-			return nil, invalidBlock{error: ErrInvalidPayload, root: [32]byte(lastValidHash)}
-		default:
-			log.WithError(err).Error(ErrUndefinedExecutionEngineError)
-			return nil, nil
-		}
-	}
-	forkchoiceUpdatedValidNodeCount.Inc()
-	// If the forkchoice update call has an attribute, update the payload ID cache.
-	hasAttr := attributes != nil && !attributes.IsEmpty()
-	if hasAttr && payloadID == nil && !features.Get().PrepareAllPayloads {
-		log.WithFields(logrus.Fields{
-			"blockHash": fmt.Sprintf("%#x", blockhash[:]),
-		}).Error("Received nil payload ID on VALID engine response")
-	}
-	return payloadID, nil
-}

beacon-chain/blockchain/execution_engine_test.go

@@ -19,6 +19,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/genesis"
 	v1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
@@ -46,13 +47,13 @@ func Test_NotifyForkchoiceUpdate_GetPayloadAttrErrorCanContinue(t *testing.T) {
 
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 1, altairBlkRoot, [32]byte{}, [32]byte{'A'}, [32]byte{}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 1, altairBlkRoot, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 2, bellatrixBlkRoot, altairBlkRoot, [32]byte{'B'}, [32]byte{'A'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 2, bellatrixBlkRoot, altairBlkRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 
@@ -104,13 +105,13 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 1, altairBlkRoot, [32]byte{}, [32]byte{'A'}, [32]byte{}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 1, altairBlkRoot, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 2, bellatrixBlkRoot, altairBlkRoot, [32]byte{'B'}, [32]byte{'A'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 2, bellatrixBlkRoot, altairBlkRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 	badHash := [32]byte{'h'}
@@ -288,16 +289,16 @@ func Test_NotifyForkchoiceUpdate_NIlLVH(t *testing.T) {
 	require.NoError(t, fcs.UpdateJustifiedCheckpoint(ctx, &forkchoicetypes.Checkpoint{}))
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 1, bra, [32]byte{}, [32]byte{'A'}, [32]byte{}, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 1, bra, [32]byte{}, [32]byte{'A'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 2, brb, bra, [32]byte{'B'}, [32]byte{'A'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 2, brb, bra, [32]byte{'B'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 3, brc, brb, [32]byte{'C'}, [32]byte{'B'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 3, brc, brb, [32]byte{'C'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 4, brd, brc, [32]byte{'D'}, [32]byte{'C'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 4, brd, brc, [32]byte{'D'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 
@@ -309,6 +310,7 @@ func Test_NotifyForkchoiceUpdate_NIlLVH(t *testing.T) {
 		block: wba,
 	}
 
+	genesis.StoreStateDuringTest(t, st)
 	require.NoError(t, beaconDB.SaveState(ctx, st, bra))
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, bra))
 	a := &fcuConfig{
@@ -317,8 +319,10 @@ func Test_NotifyForkchoiceUpdate_NIlLVH(t *testing.T) {
 		headRoot:  brd,
 	}
 	_, err = service.notifyForkchoiceUpdate(ctx, a)
-	// The incoming block is not invalid because the empty node is still valid on ePBS.
-	require.Equal(t, false, IsInvalidBlock(err))
+	require.Equal(t, true, IsInvalidBlock(err))
+	require.Equal(t, brd, InvalidBlockRoot(err))
+	require.Equal(t, brd, InvalidAncestorRoots(err)[0])
+	require.Equal(t, 1, len(InvalidAncestorRoots(err)))
 }
 
 //
@@ -397,28 +401,29 @@ func Test_NotifyForkchoiceUpdateRecursive_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, fcs.UpdateJustifiedCheckpoint(ctx, &forkchoicetypes.Checkpoint{}))
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 1, bra, [32]byte{}, [32]byte{'A'}, [32]byte{}, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 1, bra, [32]byte{}, [32]byte{'A'}, ojc, ofc)
 	require.NoError(t, err)
 
 	bState, _ := util.DeterministicGenesisState(t, 10)
+	genesis.StoreStateDuringTest(t, bState)
 	require.NoError(t, beaconDB.SaveState(ctx, bState, bra))
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 2, brb, bra, [32]byte{'B'}, [32]byte{'A'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 2, brb, bra, [32]byte{'B'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 3, brc, brb, [32]byte{'C'}, [32]byte{'B'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 3, brc, brb, [32]byte{'C'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 4, brd, brc, [32]byte{'D'}, [32]byte{'C'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 4, brd, brc, [32]byte{'D'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 5, bre, brb, [32]byte{'E'}, [32]byte{'D'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 5, bre, brb, [32]byte{'E'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 6, brf, bre, [32]byte{'F'}, [32]byte{'E'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 6, brf, bre, [32]byte{'F'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 7, brg, bre, [32]byte{'G'}, [32]byte{'F'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 7, brg, bre, [32]byte{'G'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 
@@ -511,10 +516,10 @@ func Test_NotifyNewPayload(t *testing.T) {
 	require.NoError(t, err)
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 1, r, [32]byte{}, [32]byte{'A'}, [32]byte{}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 1, r, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 
@@ -691,7 +696,7 @@ func Test_NotifyNewPayload(t *testing.T) {
 			}
 			service.cfg.ExecutionEngineCaller = e
 			root := [32]byte{'a'}
-			state, blkRoot, err := prepareForkchoiceState(ctx, 0, root, [32]byte{}, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
+			state, blkRoot, err := prepareForkchoiceState(ctx, 0, root, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
 			require.NoError(t, err)
 			require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 			postVersion, postHeader, err := getStateVersionAndPayload(tt.postState)
@@ -758,17 +763,17 @@ func Test_reportInvalidBlock(t *testing.T) {
 	service, tr := minimalTestService(t)
 	ctx, _, fcs := tr.ctx, tr.db, tr.fcs
 	jcp := &ethpb.Checkpoint{}
-	st, root, err := prepareForkchoiceState(ctx, 0, [32]byte{'A'}, [32]byte{}, [32]byte{'a'}, [32]byte{}, jcp, jcp)
+	st, root, err := prepareForkchoiceState(ctx, 0, [32]byte{'A'}, [32]byte{}, [32]byte{'a'}, jcp, jcp)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, st, root))
-	st, root, err = prepareForkchoiceState(ctx, 1, [32]byte{'B'}, [32]byte{'A'}, [32]byte{'b'}, [32]byte{'a'}, jcp, jcp)
+	st, root, err = prepareForkchoiceState(ctx, 1, [32]byte{'B'}, [32]byte{'A'}, [32]byte{'b'}, jcp, jcp)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, st, root))
-	st, root, err = prepareForkchoiceState(ctx, 2, [32]byte{'C'}, [32]byte{'B'}, [32]byte{'c'}, [32]byte{'b'}, jcp, jcp)
+	st, root, err = prepareForkchoiceState(ctx, 2, [32]byte{'C'}, [32]byte{'B'}, [32]byte{'c'}, jcp, jcp)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, st, root))
 
-	st, root, err = prepareForkchoiceState(ctx, 3, [32]byte{'D'}, [32]byte{'C'}, [32]byte{'d'}, [32]byte{'c'}, jcp, jcp)
+	st, root, err = prepareForkchoiceState(ctx, 3, [32]byte{'D'}, [32]byte{'C'}, [32]byte{'d'}, jcp, jcp)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, st, root))
 
@@ -930,7 +935,7 @@ func Test_UpdateLastValidatedCheckpoint(t *testing.T) {
 	fjc := &forkchoicetypes.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash}
 	require.NoError(t, fcs.UpdateJustifiedCheckpoint(ctx, fjc))
 	require.NoError(t, fcs.UpdateFinalizedCheckpoint(fjc))
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, genesisRoot, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, genesisRoot, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 	fcs.SetOriginRoot(genesisRoot)
@@ -964,7 +969,7 @@ func Test_UpdateLastValidatedCheckpoint(t *testing.T) {
 	require.NoError(t, beaconDB.SaveStateSummary(ctx, opStateSummary))
 	tenjc := &ethpb.Checkpoint{Epoch: 10, Root: genesisRoot[:]}
 	tenfc := &ethpb.Checkpoint{Epoch: 10, Root: genesisRoot[:]}
-	state, blkRoot, err = prepareForkchoiceState(ctx, 320, opRoot, genesisRoot, params.BeaconConfig().ZeroHash, [32]byte{}, tenjc, tenfc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 320, opRoot, genesisRoot, params.BeaconConfig().ZeroHash, tenjc, tenfc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 	assert.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, opRoot))
@@ -993,7 +998,7 @@ func Test_UpdateLastValidatedCheckpoint(t *testing.T) {
 	require.NoError(t, beaconDB.SaveStateSummary(ctx, validSummary))
 	twentyjc := &ethpb.Checkpoint{Epoch: 20, Root: validRoot[:]}
 	twentyfc := &ethpb.Checkpoint{Epoch: 20, Root: validRoot[:]}
-	state, blkRoot, err = prepareForkchoiceState(ctx, 640, validRoot, genesisRoot, params.BeaconConfig().ZeroHash, [32]byte{}, twentyjc, twentyfc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 640, validRoot, genesisRoot, params.BeaconConfig().ZeroHash, twentyjc, twentyfc)
 	require.NoError(t, err)
 	fcs.SetBalancesByRooter(func(_ context.Context, _ [32]byte) ([]uint64, error) { return []uint64{}, nil })
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
@@ -1055,8 +1060,8 @@ func TestService_removeInvalidBlockAndState(t *testing.T) {
 
 	require.NoError(t, service.removeInvalidBlockAndState(ctx, [][32]byte{r1, r2}))
 
-	require.Equal(t, false, service.chainHasBlock(ctx, r1))
-	require.Equal(t, false, service.chainHasBlock(ctx, r2))
+	require.Equal(t, false, service.hasBlock(ctx, r1))
+	require.Equal(t, false, service.hasBlock(ctx, r2))
 	require.Equal(t, false, service.cfg.BeaconDB.HasStateSummary(ctx, r1))
 	require.Equal(t, false, service.cfg.BeaconDB.HasStateSummary(ctx, r2))
 	has, err := service.cfg.StateGen.HasState(ctx, r1)

beacon-chain/blockchain/forkchoice_update_execution.go

@@ -102,8 +102,6 @@ func (s *Service) forkchoiceUpdateWithExecution(ctx context.Context, args *fcuCo
 		log.WithError(err).Error("Could not save head")
 	}
 
-	go s.firePayloadAttributesEvent(s.cfg.StateNotifier.StateFeed(), args.headBlock, args.headRoot, s.CurrentSlot()+1)
-
 	// Only need to prune attestations from pool if the head has changed.
 	s.pruneAttsFromPool(s.ctx, args.headState, args.headBlock)
 	return nil

beacon-chain/blockchain/forkchoice_update_execution_test.go

@@ -121,13 +121,13 @@ func TestService_forkchoiceUpdateWithExecution_SameHeadRootNewProposer(t *testin
 
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 1, altairBlkRoot, [32]byte{}, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 1, altairBlkRoot, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 2, bellatrixBlkRoot, altairBlkRoot, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 2, bellatrixBlkRoot, altairBlkRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 
@@ -164,10 +164,10 @@ func TestShouldOverrideFCU(t *testing.T) {
 	headRoot := [32]byte{'b'}
 	parentRoot := [32]byte{'a'}
 	ojc := &ethpb.Checkpoint{}
-	st, root, err := prepareForkchoiceState(ctx, 1, parentRoot, [32]byte{}, [32]byte{}, [32]byte{}, ojc, ojc)
+	st, root, err := prepareForkchoiceState(ctx, 1, parentRoot, [32]byte{}, [32]byte{}, ojc, ojc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, st, root))
-	st, root, err = prepareForkchoiceState(ctx, 2, headRoot, parentRoot, [32]byte{}, [32]byte{}, ojc, ojc)
+	st, root, err = prepareForkchoiceState(ctx, 2, headRoot, parentRoot, [32]byte{}, ojc, ojc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, st, root))
 

beacon-chain/blockchain/head_test.go

@@ -48,7 +48,7 @@ func TestSaveHead_Different(t *testing.T) {
 	require.NoError(t, err)
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, oldBlock.Block().Slot(), oldRoot, oldBlock.Block().ParentRoot(), [32]byte{}, [32]byte{}, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, oldBlock.Block().Slot(), oldRoot, oldBlock.Block().ParentRoot(), [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	service.head = &head{
@@ -63,11 +63,11 @@ func TestSaveHead_Different(t *testing.T) {
 	wsb := util.SaveBlock(t, t.Context(), service.cfg.BeaconDB, newHeadSignedBlock)
 	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
-	state, blkRoot, err = prepareForkchoiceState(ctx, slots.PrevSlot(wsb.Block().Slot()), wsb.Block().ParentRoot(), service.cfg.ForkChoiceStore.CachedHeadRoot(), [32]byte{}, [32]byte{}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, slots.PrevSlot(wsb.Block().Slot()), wsb.Block().ParentRoot(), service.cfg.ForkChoiceStore.CachedHeadRoot(), [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 
-	state, blkRoot, err = prepareForkchoiceState(ctx, wsb.Block().Slot(), newRoot, wsb.Block().ParentRoot(), [32]byte{}, [32]byte{}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, wsb.Block().Slot(), newRoot, wsb.Block().ParentRoot(), [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	headState, err := util.NewBeaconState()
@@ -101,7 +101,7 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	require.NoError(t, err)
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, oldBlock.Block().Slot(), oldRoot, oldBlock.Block().ParentRoot(), [32]byte{}, [32]byte{}, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, oldBlock.Block().Slot(), oldRoot, oldBlock.Block().ParentRoot(), [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	service.head = &head{
@@ -110,7 +110,7 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	}
 
 	reorgChainParent := [32]byte{'B'}
-	state, blkRoot, err = prepareForkchoiceState(ctx, 0, reorgChainParent, oldRoot, oldBlock.Block().ParentRoot(), [32]byte{}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 0, reorgChainParent, oldRoot, oldBlock.Block().ParentRoot(), ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 
@@ -122,7 +122,7 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	wsb := util.SaveBlock(t, t.Context(), service.cfg.BeaconDB, newHeadSignedBlock)
 	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
-	state, blkRoot, err = prepareForkchoiceState(ctx, wsb.Block().Slot(), newRoot, wsb.Block().ParentRoot(), [32]byte{}, [32]byte{}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, wsb.Block().Slot(), newRoot, wsb.Block().ParentRoot(), [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	headState, err := util.NewBeaconState()
@@ -237,11 +237,11 @@ func TestRetrieveHead_ReadOnly(t *testing.T) {
 	wsb := util.SaveBlock(t, t.Context(), service.cfg.BeaconDB, newHeadSignedBlock)
 	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
-	state, blkRoot, err := prepareForkchoiceState(ctx, slots.PrevSlot(wsb.Block().Slot()), wsb.Block().ParentRoot(), service.cfg.ForkChoiceStore.CachedHeadRoot(), [32]byte{}, [32]byte{}, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, slots.PrevSlot(wsb.Block().Slot()), wsb.Block().ParentRoot(), service.cfg.ForkChoiceStore.CachedHeadRoot(), [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 
-	state, blkRoot, err = prepareForkchoiceState(ctx, wsb.Block().Slot(), newRoot, wsb.Block().ParentRoot(), [32]byte{}, [32]byte{}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, wsb.Block().Slot(), newRoot, wsb.Block().ParentRoot(), [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	headState, err := util.NewBeaconState()
@@ -303,7 +303,7 @@ func TestSaveOrphanedAtts(t *testing.T) {
 	for _, blk := range []*ethpb.SignedBeaconBlock{blkG, blk1, blk2, blk3, blk4} {
 		r, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
-		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, [32]byte{}, ojc, ofc)
+		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
 		require.NoError(t, err)
 		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 		util.SaveBlock(t, ctx, beaconDB, blk)
@@ -446,7 +446,7 @@ func TestSaveOrphanedOps(t *testing.T) {
 	for _, blk := range []*ethpb.SignedBeaconBlock{blkG, blk1, blk2, blk3, blk4} {
 		r, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
-		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, [32]byte{}, ojc, ofc)
+		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
 		require.NoError(t, err)
 		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 		util.SaveBlock(t, ctx, beaconDB, blk)
@@ -516,7 +516,7 @@ func TestSaveOrphanedAtts_CanFilter(t *testing.T) {
 	for _, blk := range []*ethpb.SignedBeaconBlockCapella{blkG, blk1, blk2, blk4} {
 		r, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
-		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, [32]byte{}, ojc, ofc)
+		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
 		require.NoError(t, err)
 		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 		util.SaveBlock(t, ctx, beaconDB, blk)
@@ -574,7 +574,7 @@ func TestSaveOrphanedAtts_DoublyLinkedTrie(t *testing.T) {
 	for _, blk := range []*ethpb.SignedBeaconBlock{blkG, blk1, blk2, blk3, blk4} {
 		r, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
-		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, [32]byte{}, ojc, ofc)
+		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
 		require.NoError(t, err)
 		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 		util.SaveBlock(t, ctx, beaconDB, blk)
@@ -633,7 +633,7 @@ func TestSaveOrphanedAtts_CanFilter_DoublyLinkedTrie(t *testing.T) {
 	for _, blk := range []*ethpb.SignedBeaconBlock{blkG, blk1, blk2, blk4} {
 		r, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
-		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, [32]byte{}, ojc, ofc)
+		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
 		require.NoError(t, err)
 		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 		util.SaveBlock(t, ctx, beaconDB, blk)
@@ -648,7 +648,7 @@ func TestUpdateHead_noSavedChanges(t *testing.T) {
 	ctx, beaconDB, fcs := tr.ctx, tr.db, tr.fcs
 
 	ojp := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	st, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, [32]byte{}, [32]byte{}, ojp, ojp)
+	st, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, [32]byte{}, ojp, ojp)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, st, blkRoot))
 
@@ -668,7 +668,7 @@ func TestUpdateHead_noSavedChanges(t *testing.T) {
 	headRoot := service.headRoot()
 	require.Equal(t, [32]byte{}, headRoot)
 
-	st, blkRoot, err = prepareForkchoiceState(ctx, 0, bellatrixBlkRoot, [32]byte{}, [32]byte{}, [32]byte{}, fcp, fcp)
+	st, blkRoot, err = prepareForkchoiceState(ctx, 0, bellatrixBlkRoot, [32]byte{}, [32]byte{}, fcp, fcp)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, st, blkRoot))
 	fcs.SetBalancesByRooter(func(context.Context, [32]byte) ([]uint64, error) { return []uint64{1, 2}, nil })

beacon-chain/blockchain/kzg/trusted_setup.go

@@ -11,7 +11,7 @@ import (
 )
 
 var (
-	// https://github.com/ethereum/consensus-specs/blob/dev/presets/mainnet/trusted_setups/trusted_setup_4096.json
+	// https://github.com/ethereum/consensus-specs/blob/master/presets/mainnet/trusted_setups/trusted_setup_4096.json
 	//go:embed trusted_setup_4096.json
 	embeddedTrustedSetup []byte // 1.2Mb
 	kzgContext           *GoKZG.Context

beacon-chain/blockchain/kzg/validation.go

@@ -6,20 +6,20 @@ import (
 )
 
 // Verify performs single or batch verification of commitments depending on the number of given BlobSidecars.
-func Verify(sidecars ...blocks.ROBlob) error {
-	if len(sidecars) == 0 {
+func Verify(blobSidecars ...blocks.ROBlob) error {
+	if len(blobSidecars) == 0 {
 		return nil
 	}
-	if len(sidecars) == 1 {
+	if len(blobSidecars) == 1 {
 		return kzgContext.VerifyBlobKZGProof(
-			bytesToBlob(sidecars[0].Blob),
-			bytesToCommitment(sidecars[0].KzgCommitment),
-			bytesToKZGProof(sidecars[0].KzgProof))
+			bytesToBlob(blobSidecars[0].Blob),
+			bytesToCommitment(blobSidecars[0].KzgCommitment),
+			bytesToKZGProof(blobSidecars[0].KzgProof))
 	}
-	blobs := make([]GoKZG.Blob, len(sidecars))
-	cmts := make([]GoKZG.KZGCommitment, len(sidecars))
-	proofs := make([]GoKZG.KZGProof, len(sidecars))
-	for i, sidecar := range sidecars {
+	blobs := make([]GoKZG.Blob, len(blobSidecars))
+	cmts := make([]GoKZG.KZGCommitment, len(blobSidecars))
+	proofs := make([]GoKZG.KZGProof, len(blobSidecars))
+	for i, sidecar := range blobSidecars {
 		blobs[i] = *bytesToBlob(sidecar.Blob)
 		cmts[i] = bytesToCommitment(sidecar.KzgCommitment)
 		proofs[i] = bytesToKZGProof(sidecar.KzgProof)

beacon-chain/blockchain/kzg/validation_test.go

@@ -22,8 +22,8 @@ func GenerateCommitmentAndProof(blob GoKZG.Blob) (GoKZG.KZGCommitment, GoKZG.KZG
 }
 
 func TestVerify(t *testing.T) {
-	sidecars := make([]blocks.ROBlob, 0)
-	require.NoError(t, Verify(sidecars...))
+	blobSidecars := make([]blocks.ROBlob, 0)
+	require.NoError(t, Verify(blobSidecars...))
 }
 
 func TestBytesToAny(t *testing.T) {

beacon-chain/blockchain/log.go

@@ -42,47 +42,31 @@ func logStateTransitionData(b interfaces.ReadOnlyBeaconBlock) error {
 		}
 		log = log.WithField("syncBitsCount", agg.SyncCommitteeBits.Count())
 	}
-	if b.Version() >= version.EPBS {
-		sh, err := b.Body().SignedExecutionPayloadHeader()
+	if b.Version() >= version.Bellatrix {
+		p, err := b.Body().Execution()
 		if err != nil {
 			return err
 		}
-		header, err := sh.Header()
-		if err != nil {
+		log = log.WithField("payloadHash", fmt.Sprintf("%#x", bytesutil.Trunc(p.BlockHash())))
+		txs, err := p.Transactions()
+		switch {
+		case errors.Is(err, consensus_types.ErrUnsupportedField):
+		case err != nil:
 			return err
-		}
-		log = log.WithFields(logrus.Fields{"payloadHash": fmt.Sprintf("%#x", header.BlockHash()),
-			"builderIndex":           header.BuilderIndex(),
-			"value":                  header.Value(),
-			"blobKzgCommitmentsRoot": fmt.Sprintf("%#x", header.BlobKzgCommitmentsRoot()),
-		})
-	} else {
-		if b.Version() >= version.Bellatrix {
-			p, err := b.Body().Execution()
-			if err != nil {
-				return err
-			}
-			log = log.WithField("payloadHash", fmt.Sprintf("%#x", bytesutil.Trunc(p.BlockHash())))
-			txs, err := p.Transactions()
-			switch {
-			case errors.Is(err, consensus_types.ErrUnsupportedField):
-			case err != nil:
-				return err
-			default:
-				log = log.WithField("txCount", len(txs))
-				txsPerSlotCount.Set(float64(len(txs)))
-			}
-		}
-		if b.Version() >= version.Deneb {
-			kzgs, err := b.Body().BlobKzgCommitments()
-			if err != nil {
-				log.WithError(err).Error("Failed to get blob KZG commitments")
-			} else if len(kzgs) > 0 {
-				log = log.WithField("kzgCommitmentCount", len(kzgs))
-			}
+		default:
+			log = log.WithField("txCount", len(txs))
+			txsPerSlotCount.Set(float64(len(txs)))
 		}
 	}
-	if b.Version() >= version.Electra && b.Version() < version.EPBS {
+	if b.Version() >= version.Deneb {
+		kzgs, err := b.Body().BlobKzgCommitments()
+		if err != nil {
+			log.WithError(err).Error("Failed to get blob KZG commitments")
+		} else if len(kzgs) > 0 {
+			log = log.WithField("kzgCommitmentCount", len(kzgs))
+		}
+	}
+	if b.Version() >= version.Electra {
 		eReqs, err := b.Body().ExecutionRequests()
 		if err != nil {
 			log.WithError(err).Error("Failed to get execution requests")
@@ -125,18 +109,6 @@ func logBlockSyncStatus(block interfaces.ReadOnlyBeaconBlock, blockRoot [32]byte
 			"chainServiceProcessedTime":  prysmTime.Now().Sub(receivedTime) - daWaitedTime,
 			"dataAvailabilityWaitedTime": daWaitedTime,
 		}
-		if block.Version() >= version.EPBS {
-			ph, err := block.Body().SignedExecutionPayloadHeader()
-			if err != nil {
-				return err
-			}
-			header, err := ph.Header()
-			if err != nil {
-				return err
-			}
-			hash := header.ParentBlockHash()
-			lf["parentHash"] = fmt.Sprintf("0x%s...", hex.EncodeToString(hash[:])[:8])
-		}
 		log.WithFields(lf).Debug("Synced new block")
 	} else {
 		log.WithFields(logrus.Fields{
@@ -152,9 +124,6 @@ func logBlockSyncStatus(block interfaces.ReadOnlyBeaconBlock, blockRoot [32]byte
 
 // logs payload related data every slot.
 func logPayload(block interfaces.ReadOnlyBeaconBlock) error {
-	if block.Version() >= version.EPBS {
-		return nil
-	}
 	isExecutionBlk, err := blocks.IsExecutionBlock(block.Body())
 	if err != nil {
 		return errors.Wrap(err, "could not determine if block is execution block")

beacon-chain/blockchain/metrics.go

@@ -182,10 +182,6 @@ var (
 		Name: "chain_service_processing_milliseconds",
 		Help: "Total time to call a chain service in ReceiveBlock()",
 	})
-	executionEngineProcessingTime = promauto.NewSummary(prometheus.SummaryOpts{
-		Name: "execution_engine_processing_milliseconds",
-		Help: "Total time to process an execution payload envelope in ReceiveExecutionPayloadEnvelope()",
-	})
 	dataAvailWaitedTime = promauto.NewSummary(prometheus.SummaryOpts{
 		Name: "da_waited_time_milliseconds",
 		Help: "Total time spent waiting for a data availability check in ReceiveBlock()",

beacon-chain/blockchain/options.go

@@ -1,14 +1,12 @@
 package blockchain
 
 import (
-	"sync"
 	"time"
 
 	"github.com/OffchainLabs/prysm/v6/async/event"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
 	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution"
@@ -37,7 +35,7 @@ func WithMaxGoroutines(x int) Option {
 // WithLCStore for light client store access.
 func WithLCStore() Option {
 	return func(s *Service) error {
-		s.lcStore = lightclient.NewLightClientStore(s.cfg.BeaconDB)
+		s.lcStore = lightclient.NewLightClientStore(s.cfg.BeaconDB, s.cfg.P2P, s.cfg.StateNotifier.StateFeed())
 		return nil
 	}
 }
@@ -82,22 +80,6 @@ func WithDepositCache(c cache.DepositCache) Option {
 	}
 }
 
-// WithPayloadAttestationCache for payload attestation cache.
-func WithPayloadAttestationCache(c *cache.PayloadAttestationCache) Option {
-	return func(s *Service) error {
-		s.cfg.PayloadAttestationCache = c
-		return nil
-	}
-}
-
-// WithPayloadEnvelopeCache for payload envelope cache.
-func WithPayloadEnvelopeCache(c *sync.Map) Option {
-	return func(s *Service) error {
-		s.cfg.PayloadEnvelopeCache = c
-		return nil
-	}
-}
-
 // WithPayloadIDCache for payload ID cache.
 func WithPayloadIDCache(c *cache.PayloadIDCache) Option {
 	return func(s *Service) error {
@@ -252,14 +234,6 @@ func WithSyncChecker(checker Checker) Option {
 	}
 }
 
-// WithCustodyInfo sets the custody info for the blockchain service.
-func WithCustodyInfo(custodyInfo *peerdas.CustodyInfo) Option {
-	return func(s *Service) error {
-		s.cfg.CustodyInfo = custodyInfo
-		return nil
-	}
-}
-
 // WithSlasherEnabled sets whether the slasher is enabled or not.
 func WithSlasherEnabled(enabled bool) Option {
 	return func(s *Service) error {

beacon-chain/blockchain/process_attestation.go

@@ -96,7 +96,7 @@ func (s *Service) OnAttestation(ctx context.Context, a ethpb.Att, disparity time
 	// We assume trusted attestation in this function has verified signature.
 
 	// Update forkchoice store with the new attestation for updating weight.
-	s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indexedAtt.GetAttestingIndices(), bytesutil.ToBytes32(a.GetData().BeaconBlockRoot), a.GetData().Slot)
+	s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indexedAtt.GetAttestingIndices(), bytesutil.ToBytes32(a.GetData().BeaconBlockRoot), a.GetData().Target.Epoch)
 
 	return nil
 }

beacon-chain/blockchain/process_attestation_test.go

@@ -32,7 +32,7 @@ func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 	util.SaveBlock(t, ctx, beaconDB, blkWithoutState)
 
 	cp := &ethpb.Checkpoint{}
-	st, roblock, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, [32]byte{}, cp, cp)
+	st, roblock, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, cp, cp)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
 
@@ -41,7 +41,7 @@ func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 	r, err := blkWithStateBadAtt.Block.HashTreeRoot()
 	require.NoError(t, err)
 	cp = &ethpb.Checkpoint{Root: r[:]}
-	st, roblock, err = prepareForkchoiceState(ctx, blkWithStateBadAtt.Block.Slot, r, [32]byte{}, params.BeaconConfig().ZeroHash, [32]byte{}, cp, cp)
+	st, roblock, err = prepareForkchoiceState(ctx, blkWithStateBadAtt.Block.Slot, r, [32]byte{}, params.BeaconConfig().ZeroHash, cp, cp)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
 	util.SaveBlock(t, ctx, beaconDB, blkWithStateBadAtt)
@@ -139,7 +139,7 @@ func TestStore_OnAttestation_Ok_DoublyLinkedTree(t *testing.T) {
 		require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
 		ojc := &ethpb.Checkpoint{Epoch: 0, Root: tRoot[:]}
 		ofc := &ethpb.Checkpoint{Epoch: 0, Root: tRoot[:]}
-		state, roblock, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
+		state, roblock, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
 		require.NoError(t, err)
 		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, roblock))
 		require.NoError(t, service.OnAttestation(ctx, att[0], 0))
@@ -170,7 +170,7 @@ func TestService_GetRecentPreState(t *testing.T) {
 	err = s.SetFinalizedCheckpoint(cp0)
 	require.NoError(t, err)
 
-	st, root, err := prepareForkchoiceState(ctx, 31, [32]byte(ckRoot), [32]byte{}, [32]byte{'R'}, [32]byte{}, cp0, cp0)
+	st, root, err := prepareForkchoiceState(ctx, 31, [32]byte(ckRoot), [32]byte{}, [32]byte{'R'}, cp0, cp0)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, root))
 	service.head = &head{
@@ -202,7 +202,7 @@ func TestService_GetAttPreState_Concurrency(t *testing.T) {
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, bytesutil.ToBytes32([]byte{'A'})))
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: ckRoot}))
 
-	st, root, err := prepareForkchoiceState(ctx, 100, [32]byte(cp1.Root), [32]byte{}, [32]byte{'R'}, [32]byte{}, cp1, cp1)
+	st, root, err := prepareForkchoiceState(ctx, 100, [32]byte(cp1.Root), [32]byte{}, [32]byte{'R'}, cp1, cp1)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, root))
 
@@ -259,7 +259,7 @@ func TestStore_SaveCheckpointState(t *testing.T) {
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, bytesutil.ToBytes32([]byte{'A'})))
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: bytesutil.PadTo([]byte{'A'}, fieldparams.RootLength)}))
 
-	st, root, err := prepareForkchoiceState(ctx, 1, [32]byte(cp1.Root), [32]byte{}, [32]byte{'R'}, [32]byte{}, cp1, cp1)
+	st, root, err := prepareForkchoiceState(ctx, 1, [32]byte(cp1.Root), [32]byte{}, [32]byte{'R'}, cp1, cp1)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, root))
 	s1, err := service.getAttPreState(ctx, cp1)
@@ -273,7 +273,7 @@ func TestStore_SaveCheckpointState(t *testing.T) {
 	_, err = service.getAttPreState(ctx, cp2)
 	require.ErrorContains(t, "epoch 2 root 0x4200000000000000000000000000000000000000000000000000000000000000: not a checkpoint in forkchoice", err)
 
-	st, root, err = prepareForkchoiceState(ctx, 33, [32]byte(cp2.Root), [32]byte(cp1.Root), [32]byte{'R'}, [32]byte{}, cp2, cp2)
+	st, root, err = prepareForkchoiceState(ctx, 33, [32]byte(cp2.Root), [32]byte(cp1.Root), [32]byte{'R'}, cp2, cp2)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, root))
 
@@ -298,7 +298,7 @@ func TestStore_SaveCheckpointState(t *testing.T) {
 	cp3 := &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'C'}, fieldparams.RootLength)}
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, bytesutil.ToBytes32([]byte{'C'})))
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: bytesutil.PadTo([]byte{'C'}, fieldparams.RootLength)}))
-	st, root, err = prepareForkchoiceState(ctx, 31, [32]byte(cp3.Root), [32]byte(cp2.Root), [32]byte{'P'}, [32]byte{}, cp2, cp2)
+	st, root, err = prepareForkchoiceState(ctx, 31, [32]byte(cp3.Root), [32]byte(cp2.Root), [32]byte{'P'}, cp2, cp2)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, root))
 
@@ -318,7 +318,7 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 	require.NoError(t, err)
 	checkpoint := &ethpb.Checkpoint{Epoch: epoch, Root: r1[:]}
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(checkpoint.Root)))
-	st, roblock, err := prepareForkchoiceState(ctx, blk.Block.Slot, r1, [32]byte{}, params.BeaconConfig().ZeroHash, [32]byte{}, checkpoint, checkpoint)
+	st, roblock, err := prepareForkchoiceState(ctx, blk.Block.Slot, r1, [32]byte{}, params.BeaconConfig().ZeroHash, checkpoint, checkpoint)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
 	returned, err := service.getAttPreState(ctx, checkpoint)
@@ -336,7 +336,7 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 	require.NoError(t, err)
 	newCheckpoint := &ethpb.Checkpoint{Epoch: epoch, Root: r2[:]}
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(newCheckpoint.Root)))
-	st, roblock, err = prepareForkchoiceState(ctx, blk.Block.Slot, r2, r1, params.BeaconConfig().ZeroHash, [32]byte{}, newCheckpoint, newCheckpoint)
+	st, roblock, err = prepareForkchoiceState(ctx, blk.Block.Slot, r2, r1, params.BeaconConfig().ZeroHash, newCheckpoint, newCheckpoint)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
 	returned, err = service.getAttPreState(ctx, newCheckpoint)

beacon-chain/blockchain/process_block.go

@@ -68,9 +68,7 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 	fcuArgs := &fcuConfig{}
 
 	if s.inRegularSync() {
-		if cfg.roblock.Version() < version.EPBS {
-			defer s.handleSecondFCUCall(cfg, fcuArgs)
-		}
+		defer s.handleSecondFCUCall(cfg, fcuArgs)
 	}
 	if features.Get().EnableLightClient && slots.ToEpoch(s.CurrentSlot()) >= params.BeaconConfig().AltairForkEpoch {
 		defer s.processLightClientUpdates(cfg)
@@ -106,16 +104,6 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 		s.logNonCanonicalBlockReceived(cfg.roblock.Root(), cfg.headRoot)
 		return nil
 	}
-	if cfg.roblock.Version() >= version.EPBS {
-		if err := s.saveHead(ctx, cfg.headRoot, cfg.roblock, cfg.postState); err != nil {
-			log.WithError(err).Error("Could not save head")
-		}
-		s.pruneAttsFromPool(ctx, cfg.postState, cfg.roblock)
-
-		// update the NSC and handle epoch boundaries here since we do
-		// not send FCU at all
-		return s.updateCachesPostBlockProcessing(cfg)
-	}
 	if err := s.getFCUArgs(cfg, fcuArgs); err != nil {
 		log.WithError(err).Error("Could not get forkchoice update argument")
 		return nil
@@ -252,9 +240,10 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 			}
 		}
 
-		if err := avs.IsDataAvailable(ctx, s.CurrentSlot(), b); err != nil {
-			return errors.Wrapf(err, "could not validate sidecar availability at slot %d", b.Block().Slot())
+		if err := s.areSidecarsAvailable(ctx, avs, b); err != nil {
+			return errors.Wrapf(err, "could not validate sidecar availability for block %#x at slot %d", b.Root(), b.Block().Slot())
 		}
+
 		args := &forkchoicetypes.BlockAndCheckpoints{Block: b,
 			JustifiedCheckpoint: jCheckpoints[i],
 			FinalizedCheckpoint: fCheckpoints[i]}
@@ -320,6 +309,26 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 	return s.saveHeadNoDB(ctx, lastB, lastBR, preState, !isValidPayload)
 }
 
+func (s *Service) areSidecarsAvailable(ctx context.Context, avs das.AvailabilityStore, roBlock consensusblocks.ROBlock) error {
+	blockVersion := roBlock.Version()
+	block := roBlock.Block()
+	slot := block.Slot()
+
+	if version.Deneb <= blockVersion && blockVersion < version.Fulu {
+		if err := avs.IsDataAvailable(ctx, s.CurrentSlot(), roBlock); err != nil {
+			return errors.Wrapf(err, "could not validate sidecar availability at slot %d", slot)
+		}
+	}
+
+	if version.Fulu <= blockVersion {
+		if err := s.areDataColumnsAvailable(ctx, roBlock.Root(), block); err != nil {
+			return errors.Wrapf(err, "are data columns available for block %#x with slot %d", roBlock.Root(), slot)
+		}
+	}
+
+	return nil
+}
+
 func (s *Service) updateEpochBoundaryCaches(ctx context.Context, st state.BeaconState) error {
 	e := coreTime.CurrentEpoch(st)
 	if err := helpers.UpdateCommitteeCache(ctx, st, e); err != nil {
@@ -396,7 +405,7 @@ func (s *Service) handleBlockAttestations(ctx context.Context, blk interfaces.Re
 		}
 		r := bytesutil.ToBytes32(a.GetData().BeaconBlockRoot)
 		if s.cfg.ForkChoiceStore.HasNode(r) {
-			s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indices, r, a.GetData().Slot)
+			s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indices, r, a.GetData().Target.Epoch)
 		} else if features.Get().EnableExperimentalAttestationPool {
 			if err = s.cfg.AttestationCache.Add(a); err != nil {
 				return err
@@ -580,15 +589,9 @@ func (s *Service) runLateBlockTasks() {
 
 	attThreshold := params.BeaconConfig().SecondsPerSlot / 3
 	ticker := slots.NewSlotTickerWithOffset(s.genesisTime, time.Duration(attThreshold)*time.Second, params.BeaconConfig().SecondsPerSlot)
-	epbs := params.BeaconConfig().EPBSForkEpoch
 	for {
 		select {
-		case slot := <-ticker.C():
-			if slots.ToEpoch(slot) == epbs && slot%32 == 0 {
-				ticker.Done()
-				attThreshold := params.BeaconConfig().SecondsPerSlot / 4
-				ticker = slots.NewSlotTickerWithOffset(s.genesisTime, time.Duration(attThreshold)*time.Second, params.BeaconConfig().SecondsPerSlot)
-			}
+		case <-ticker.C():
 			s.lateBlockTasks(s.ctx)
 		case <-s.ctx.Done():
 			log.Debug("Context closed, exiting routine")
@@ -684,10 +687,11 @@ func (s *Service) areDataColumnsAvailable(
 	root [fieldparams.RootLength]byte,
 	block interfaces.ReadOnlyBeaconBlock,
 ) error {
-	// We are only required to check within MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS
+	samplesPerSlot := params.BeaconConfig().SamplesPerSlot
+
+	// We are only required to check within MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS
 	blockSlot, currentSlot := block.Slot(), s.CurrentSlot()
 	blockEpoch, currentEpoch := slots.ToEpoch(blockSlot), slots.ToEpoch(currentSlot)
-
 	if !params.WithinDAPeriod(blockEpoch, currentEpoch) {
 		return nil
 	}
@@ -708,16 +712,20 @@ func (s *Service) areDataColumnsAvailable(
 	}
 
 	// All columns to sample need to be available for the block to be considered available.
-	// https://github.com/ethereum/consensus-specs/blob/v1.5.0-alpha.10/specs/fulu/das-core.md#custody-sampling
 	nodeID := s.cfg.P2P.NodeID()
 
-	// Prevent custody group count to change during the rest of the function.
-	s.cfg.CustodyInfo.Mut.RLock()
-	defer s.cfg.CustodyInfo.Mut.RUnlock()
-
 	// Get the custody group sampling size for the node.
-	custodyGroupSamplingSize := s.cfg.CustodyInfo.CustodyGroupSamplingSize(peerdas.Actual)
-	peerInfo, _, err := peerdas.Info(nodeID, custodyGroupSamplingSize)
+	custodyGroupCount, err := s.cfg.P2P.CustodyGroupCount()
+	if err != nil {
+		return errors.Wrap(err, "custody group count")
+	}
+
+	// Compute the sampling size.
+	// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/das-core.md#custody-sampling
+	samplingSize := max(samplesPerSlot, custodyGroupCount)
+
+	// Get the peer info for the node.
+	peerInfo, _, err := peerdas.Info(nodeID, samplingSize)
 	if err != nil {
 		return errors.Wrap(err, "peer info")
 	}
@@ -976,36 +984,24 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 		return
 	}
 
-	if headState.Version() >= version.EPBS {
-		bh, err := headState.LatestBlockHash()
-		if err != nil {
-			log.WithError(err).Debug("could not perform late block tasks: failed to retrieve latest block hash")
-			return
-		}
-		_, err = s.notifyForkchoiceUpdateEPBS(ctx, [32]byte(bh), attribute)
-		if err != nil {
-			log.WithError(err).Debug("could not perform late block tasks: failed to update forkchoice with engine")
-		}
-	} else {
-		s.headLock.RLock()
-		headBlock, err := s.headBlock()
-		if err != nil {
-			s.headLock.RUnlock()
-			log.WithError(err).Debug("could not perform late block tasks: failed to retrieve head block")
-			return
-		}
+	s.headLock.RLock()
+	headBlock, err := s.headBlock()
+	if err != nil {
 		s.headLock.RUnlock()
+		log.WithError(err).Debug("could not perform late block tasks: failed to retrieve head block")
+		return
+	}
+	s.headLock.RUnlock()
 
-		fcuArgs := &fcuConfig{
-			headState:  headState,
-			headRoot:   headRoot,
-			headBlock:  headBlock,
-			attributes: attribute,
-		}
-		_, err = s.notifyForkchoiceUpdate(ctx, fcuArgs)
-		if err != nil {
-			log.WithError(err).Debug("could not perform late block tasks: failed to update forkchoice with engine")
-		}
+	fcuArgs := &fcuConfig{
+		headState:  headState,
+		headRoot:   headRoot,
+		headBlock:  headBlock,
+		attributes: attribute,
+	}
+	_, err = s.notifyForkchoiceUpdate(ctx, fcuArgs)
+	if err != nil {
+		log.WithError(err).Debug("could not perform late block tasks: failed to update forkchoice with engine")
 	}
 }
 

beacon-chain/blockchain/process_block_helpers.go

@@ -1,7 +1,6 @@
 package blockchain
 
 import (
-	"bytes"
 	"context"
 	"fmt"
 	"strings"
@@ -198,8 +197,7 @@ func (s *Service) processLightClientFinalityUpdate(
 
 	finalizedCheckpoint := attestedState.FinalizedCheckpoint()
 
-	// Check if the finalized checkpoint has changed
-	if finalizedCheckpoint == nil || bytes.Equal(finalizedCheckpoint.GetRoot(), postState.FinalizedCheckpoint().Root) {
+	if finalizedCheckpoint == nil {
 		return nil
 	}
 
@@ -224,17 +222,7 @@ func (s *Service) processLightClientFinalityUpdate(
 		return nil
 	}
 
-	log.Debug("Saving new light client finality update")
-	s.lcStore.SetLastFinalityUpdate(newUpdate)
-
-	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
-		Type: statefeed.LightClientFinalityUpdate,
-		Data: newUpdate,
-	})
-
-	if err = s.cfg.P2P.BroadcastLightClientFinalityUpdate(ctx, newUpdate); err != nil {
-		return errors.Wrap(err, "could not broadcast light client finality update")
-	}
+	s.lcStore.SetLastFinalityUpdate(newUpdate, true)
 
 	return nil
 }
@@ -266,17 +254,7 @@ func (s *Service) processLightClientOptimisticUpdate(ctx context.Context, signed
 		return nil
 	}
 
-	log.Debug("Saving new light client optimistic update")
-	s.lcStore.SetLastOptimisticUpdate(newUpdate)
-
-	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
-		Type: statefeed.LightClientOptimisticUpdate,
-		Data: newUpdate,
-	})
-
-	if err = s.cfg.P2P.BroadcastLightClientOptimisticUpdate(ctx, newUpdate); err != nil {
-		return errors.Wrap(err, "could not broadcast light client optimistic update")
-	}
+	s.lcStore.SetLastOptimisticUpdate(newUpdate, true)
 
 	return nil
 }
@@ -338,31 +316,7 @@ func (s *Service) getBlockPreState(ctx context.Context, b interfaces.ReadOnlyBea
 		return nil, err
 	}
 
-	parentRoot := b.ParentRoot()
-	s.ForkChoicer().RLock()
-	slot, err := s.ForkChoicer().Slot(parentRoot)
-	s.ForkChoicer().RUnlock()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get slot for parent root")
-	}
-	if slots.ToEpoch(slot) >= params.BeaconConfig().EPBSForkEpoch {
-		s.ForkChoicer().RLock()
-		parentHash := s.ForkChoicer().HashForBlockRoot(parentRoot)
-		s.ForkChoicer().RUnlock()
-		signedBid, err := b.Body().SignedExecutionPayloadHeader()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get signed execution payload header")
-		}
-		bid, err := signedBid.Header()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get execution payload header")
-		}
-		if parentHash == bid.ParentBlockHash() {
-			// It's based on full, use the state by hash
-			parentRoot = parentHash
-		}
-	}
-	preState, err := s.cfg.StateGen.StateByRoot(ctx, parentRoot)
+	preState, err := s.cfg.StateGen.StateByRoot(ctx, b.ParentRoot())
 	if err != nil {
 		return nil, errors.Wrapf(err, "could not get pre state for slot %d", b.Slot())
 	}

beacon-chain/blockchain/process_block_test.go

@@ -35,6 +35,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/crypto/bls"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/genesis"
 	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
@@ -232,7 +233,7 @@ func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
 	// the parent of the last block inserted is the tree node.
 	fcp := &ethpb.Checkpoint{Epoch: 0, Root: service.originBlockRoot[:]}
 	r0 := bytesutil.ToBytes32(roots[0])
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, r0, service.originBlockRoot, [32]byte{}, [32]byte{}, fcp, fcp)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, r0, service.originBlockRoot, [32]byte{}, fcp, fcp)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	fcp2 := &forkchoicetypes.Checkpoint{Epoch: 0, Root: r0}
@@ -274,7 +275,7 @@ func TestFillForkChoiceMissingBlocks_RootsMatch(t *testing.T) {
 	// the parent of the last block inserted is the tree node.
 	fcp := &ethpb.Checkpoint{Epoch: 0, Root: service.originBlockRoot[:]}
 	r0 := bytesutil.ToBytes32(roots[0])
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, r0, service.originBlockRoot, [32]byte{}, [32]byte{}, fcp, fcp)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, r0, service.originBlockRoot, [32]byte{}, fcp, fcp)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	fcp2 := &forkchoicetypes.Checkpoint{Epoch: 0, Root: r0}
@@ -555,7 +556,7 @@ func TestAncestor_CanUseForkchoice(t *testing.T) {
 		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
 		r, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		st, blkRoot, err := prepareForkchoiceState(t.Context(), b.Block.Slot, r, bytesutil.ToBytes32(b.Block.ParentRoot), params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
+		st, blkRoot, err := prepareForkchoiceState(t.Context(), b.Block.Slot, r, bytesutil.ToBytes32(b.Block.ParentRoot), params.BeaconConfig().ZeroHash, ojc, ofc)
 		require.NoError(t, err)
 		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
 	}
@@ -595,7 +596,7 @@ func TestAncestor_CanUseDB(t *testing.T) {
 		util.SaveBlock(t, t.Context(), beaconDB, beaconBlock)
 	}
 
-	st, blkRoot, err := prepareForkchoiceState(t.Context(), 200, r200, r200, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
+	st, blkRoot, err := prepareForkchoiceState(t.Context(), 200, r200, r200, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
 
@@ -1247,7 +1248,7 @@ func TestOnBlock_ProcessBlocksParallel(t *testing.T) {
 	logHook := logTest.NewGlobal()
 	for i := 0; i < 10; i++ {
 		fc := &ethpb.Checkpoint{}
-		st, blkRoot, err := prepareForkchoiceState(ctx, 0, wsb1.Block().ParentRoot(), [32]byte{}, [32]byte{}, [32]byte{}, fc, fc)
+		st, blkRoot, err := prepareForkchoiceState(ctx, 0, wsb1.Block().ParentRoot(), [32]byte{}, [32]byte{}, fc, fc)
 		require.NoError(t, err)
 		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
 		var wg sync.WaitGroup
@@ -1980,14 +1981,15 @@ func TestNoViableHead_Reboot(t *testing.T) {
 	genesisState, keys := util.DeterministicGenesisState(t, 64)
 	stateRoot, err := genesisState.HashTreeRoot(ctx)
 	require.NoError(t, err, "Could not hash genesis state")
-	genesis := blocks.NewGenesisBlock(stateRoot[:])
-	wsb, err := consensusblocks.NewSignedBeaconBlock(genesis)
+	gb := blocks.NewGenesisBlock(stateRoot[:])
+	wsb, err := consensusblocks.NewSignedBeaconBlock(gb)
 	require.NoError(t, err)
-	genesisRoot, err := genesis.Block.HashTreeRoot()
+	genesisRoot, err := gb.Block.HashTreeRoot()
 	require.NoError(t, err, "Could not get signing root")
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb), "Could not save genesis block")
 	require.NoError(t, service.saveGenesisData(ctx, genesisState))
 
+	genesis.StoreStateDuringTest(t, genesisState)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, genesisState, genesisRoot), "Could not save genesis state")
 	require.NoError(t, service.cfg.BeaconDB.SaveHeadBlockRoot(ctx, genesisRoot), "Could not save genesis state")
 	require.NoError(t, service.cfg.BeaconDB.SaveGenesisBlockRoot(ctx, genesisRoot), "Could not save genesis state")
@@ -2894,7 +2896,6 @@ func TestIsDataAvailable(t *testing.T) {
 		}
 
 		params := testIsAvailableParams{
-			options:                 []Option{WithCustodyInfo(&peerdas.CustodyInfo{})},
 			columnsToSave:           indices,
 			blobKzgCommitmentsCount: 3,
 		}
@@ -2907,7 +2908,6 @@ func TestIsDataAvailable(t *testing.T) {
 
 	t.Run("Fulu - no missing data columns", func(t *testing.T) {
 		params := testIsAvailableParams{
-			options:                 []Option{WithCustodyInfo(&peerdas.CustodyInfo{})},
 			columnsToSave:           []uint64{1, 17, 19, 42, 75, 87, 102, 117, 119}, // 119 is not needed
 			blobKzgCommitmentsCount: 3,
 		}
@@ -2922,7 +2922,7 @@ func TestIsDataAvailable(t *testing.T) {
 		startWaiting := make(chan bool)
 
 		testParams := testIsAvailableParams{
-			options:       []Option{WithCustodyInfo(&peerdas.CustodyInfo{}), WithStartWaitingDataColumnSidecars(startWaiting)},
+			options:       []Option{WithStartWaitingDataColumnSidecars(startWaiting)},
 			columnsToSave: []uint64{1, 17, 19, 75, 102, 117, 119}, // 119 is not needed, 42 and 87 are missing
 
 			blobKzgCommitmentsCount: 3,
@@ -2959,6 +2959,9 @@ func TestIsDataAvailable(t *testing.T) {
 			require.NoError(t, err)
 		}()
 
+		ctx, cancel := context.WithTimeout(ctx, time.Second*2)
+		defer cancel()
+
 		err = service.isDataAvailable(ctx, root, signed)
 		require.NoError(t, err)
 	})
@@ -2971,10 +2974,6 @@ func TestIsDataAvailable(t *testing.T) {
 
 		startWaiting := make(chan bool)
 
-		var custodyInfo peerdas.CustodyInfo
-		custodyInfo.TargetGroupCount.SetValidatorsCustodyRequirement(cgc)
-		custodyInfo.ToAdvertiseGroupCount.Set(cgc)
-
 		minimumColumnsCountToReconstruct := peerdas.MinimumColumnsCountToReconstruct()
 		indices := make([]uint64, 0, minimumColumnsCountToReconstruct-missingColumns)
 
@@ -2983,12 +2982,14 @@ func TestIsDataAvailable(t *testing.T) {
 		}
 
 		testParams := testIsAvailableParams{
-			options:                 []Option{WithCustodyInfo(&custodyInfo), WithStartWaitingDataColumnSidecars(startWaiting)},
+			options:                 []Option{WithStartWaitingDataColumnSidecars(startWaiting)},
 			columnsToSave:           indices,
 			blobKzgCommitmentsCount: 3,
 		}
 
 		ctx, _, service, root, signed := testIsAvailableSetup(t, testParams)
+		_, _, err := service.cfg.P2P.UpdateCustodyInfo(0, cgc)
+		require.NoError(t, err)
 		block := signed.Block()
 		slot := block.Slot()
 		proposerIndex := block.ProposerIndex()
@@ -3020,6 +3021,9 @@ func TestIsDataAvailable(t *testing.T) {
 			require.NoError(t, err)
 		}()
 
+		ctx, cancel := context.WithTimeout(ctx, time.Second*2)
+		defer cancel()
+
 		err = service.isDataAvailable(ctx, root, signed)
 		require.NoError(t, err)
 	})
@@ -3028,7 +3032,7 @@ func TestIsDataAvailable(t *testing.T) {
 		startWaiting := make(chan bool)
 
 		params := testIsAvailableParams{
-			options:                 []Option{WithCustodyInfo(&peerdas.CustodyInfo{}), WithStartWaitingDataColumnSidecars(startWaiting)},
+			options:                 []Option{WithStartWaitingDataColumnSidecars(startWaiting)},
 			blobKzgCommitmentsCount: 3,
 		}
 
@@ -3170,7 +3174,7 @@ func TestProcessLightClientOptimisticUpdate(t *testing.T) {
 
 			t.Run(version.String(testVersion)+"_"+tc.name, func(t *testing.T) {
 				s.genesisTime = time.Unix(time.Now().Unix()-(int64(forkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
-				s.lcStore = &lightClient.Store{}
+				s.lcStore = lightClient.NewLightClientStore(s.cfg.BeaconDB, s.cfg.P2P, s.cfg.StateNotifier.StateFeed())
 
 				var oldActualUpdate interfaces.LightClientOptimisticUpdate
 				var err error
@@ -3246,39 +3250,39 @@ func TestProcessLightClientFinalityUpdate(t *testing.T) {
 			expectReplace: true,
 		},
 		{
-			name:          "Old update is better - age - no supermajority",
+			name:          "Old update is better - finalized slot is higher",
 			oldOptions:    []util.LightClientOption{util.WithIncreasedFinalizedSlot(1)},
 			newOptions:    []util.LightClientOption{},
 			expectReplace: false,
 		},
 		{
-			name:          "Old update is better - age - both supermajority",
-			oldOptions:    []util.LightClientOption{util.WithIncreasedFinalizedSlot(1), util.WithSupermajority()},
-			newOptions:    []util.LightClientOption{util.WithSupermajority()},
-			expectReplace: false,
-		},
-		{
-			name:          "Old update is better - supermajority",
-			oldOptions:    []util.LightClientOption{util.WithSupermajority()},
+			name:          "Old update is better - attested slot is higher",
+			oldOptions:    []util.LightClientOption{util.WithIncreasedAttestedSlot(1)},
 			newOptions:    []util.LightClientOption{},
 			expectReplace: false,
 		},
 		{
-			name:          "New update is better - age - both supermajority",
-			oldOptions:    []util.LightClientOption{util.WithSupermajority()},
-			newOptions:    []util.LightClientOption{util.WithIncreasedFinalizedSlot(1), util.WithSupermajority()},
+			name:          "Old update is better - signature slot is higher",
+			oldOptions:    []util.LightClientOption{util.WithIncreasedSignatureSlot(1)},
+			newOptions:    []util.LightClientOption{},
+			expectReplace: false,
+		},
+		{
+			name:          "New update is better - finalized slot is higher",
+			oldOptions:    []util.LightClientOption{},
+			newOptions:    []util.LightClientOption{util.WithIncreasedAttestedSlot(1)},
 			expectReplace: true,
 		},
 		{
-			name:          "New update is better - age - no supermajority",
+			name:          "New update is better - attested slot is higher",
 			oldOptions:    []util.LightClientOption{},
-			newOptions:    []util.LightClientOption{util.WithIncreasedFinalizedSlot(1)},
+			newOptions:    []util.LightClientOption{util.WithIncreasedAttestedSlot(1)},
 			expectReplace: true,
 		},
 		{
-			name:          "New update is better - supermajority",
+			name:          "New update is better - signature slot is higher",
 			oldOptions:    []util.LightClientOption{},
-			newOptions:    []util.LightClientOption{util.WithSupermajority()},
+			newOptions:    []util.LightClientOption{util.WithIncreasedSignatureSlot(1)},
 			expectReplace: true,
 		},
 	}
@@ -3310,7 +3314,7 @@ func TestProcessLightClientFinalityUpdate(t *testing.T) {
 
 			t.Run(version.String(testVersion)+"_"+tc.name, func(t *testing.T) {
 				s.genesisTime = time.Unix(time.Now().Unix()-(int64(forkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
-				s.lcStore = &lightClient.Store{}
+				s.lcStore = lightClient.NewLightClientStore(s.cfg.BeaconDB, s.cfg.P2P, s.cfg.StateNotifier.StateFeed())
 
 				var actualOldUpdate, actualNewUpdate interfaces.LightClientFinalityUpdate
 				var err error

beacon-chain/blockchain/receive_attestation.go

@@ -10,7 +10,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v6/config/features"
 	"github.com/OffchainLabs/prysm/v6/config/params"
-	payloadattribute "github.com/OffchainLabs/prysm/v6/consensus-types/payload-attribute"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
@@ -149,33 +148,15 @@ func (s *Service) UpdateHead(ctx context.Context, proposingSlot primitives.Slot)
 		return
 	}
 	newAttHeadElapsedTime.Observe(float64(time.Since(start).Milliseconds()))
-	var attributes payloadattribute.Attributer
-	if s.inRegularSync() {
-		attributes = s.getPayloadAttribute(ctx, headState, proposingSlot, newHeadRoot[:])
-	}
-	if headState.Version() >= version.EPBS {
-		bh, err := headState.LatestBlockHash()
-		if err != nil {
-			log.WithError(err).Error("Could not get latest block hash")
-			return
-		}
-		_, err = s.notifyForkchoiceUpdateEPBS(ctx, [32]byte(bh), attributes)
-		if err != nil {
-			log.WithError(err).Error("Could not notify forkchoice update")
-		}
-		if err := s.saveHead(ctx, newHeadRoot, headBlock, headState); err != nil {
-			log.WithError(err).Error("Could not save head")
-			return
-		}
-		s.pruneAttsFromPool(ctx, headState, headBlock)
-		return
-	}
 	fcuArgs := &fcuConfig{
 		headState:     headState,
 		headRoot:      newHeadRoot,
 		headBlock:     headBlock,
 		proposingSlot: proposingSlot,
 	}
+	if s.inRegularSync() {
+		fcuArgs.attributes = s.getPayloadAttribute(ctx, headState, proposingSlot, newHeadRoot[:])
+	}
 	if fcuArgs.attributes != nil && s.shouldOverrideFCU(newHeadRoot, proposingSlot) {
 		return
 	}
@@ -196,14 +177,14 @@ func (s *Service) processAttestations(ctx context.Context, disparity time.Durati
 	for _, a := range atts {
 		// Based on the spec, don't process the attestation until the subsequent slot.
 		// This delays consideration in the fork choice until their slot is in the past.
-		// https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/fork-choice.md#validate_on_attestation
+		// https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/fork-choice.md#validate_on_attestation
 		nextSlot := a.GetData().Slot + 1
 		if err := slots.VerifyTime(s.genesisTime, nextSlot, disparity); err != nil {
 			continue
 		}
 
 		hasState := s.cfg.BeaconDB.HasStateSummary(ctx, bytesutil.ToBytes32(a.GetData().BeaconBlockRoot))
-		hasBlock := s.chainHasBlock(ctx, bytesutil.ToBytes32(a.GetData().BeaconBlockRoot))
+		hasBlock := s.hasBlock(ctx, bytesutil.ToBytes32(a.GetData().BeaconBlockRoot))
 		if !(hasState && hasBlock) {
 			continue
 		}

beacon-chain/blockchain/receive_attestation_test.go

@@ -41,11 +41,11 @@ func TestVerifyLMDFFGConsistent(t *testing.T) {
 
 	f := service.cfg.ForkChoiceStore
 	fc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, r32, err := prepareForkchoiceState(ctx, 32, [32]byte{'a'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, [32]byte{}, fc, fc)
+	state, r32, err := prepareForkchoiceState(ctx, 32, [32]byte{'a'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, fc, fc)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, r32))
 
-	state, r33, err := prepareForkchoiceState(ctx, 33, [32]byte{'b'}, r32.Root(), params.BeaconConfig().ZeroHash, [32]byte{}, fc, fc)
+	state, r33, err := prepareForkchoiceState(ctx, 33, [32]byte{'b'}, r32.Root(), params.BeaconConfig().ZeroHash, fc, fc)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, r33))
 
@@ -81,7 +81,7 @@ func TestProcessAttestations_Ok(t *testing.T) {
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	attsToSave := make([]ethpb.Att, len(atts))
@@ -141,7 +141,7 @@ func TestService_ProcessAttestationsAndUpdateHead(t *testing.T) {
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	util.SaveBlock(t, ctx, service.cfg.BeaconDB, b)
-	state, blkRoot, err := prepareForkchoiceState(ctx, 2, r, service.originBlockRoot, [32]byte{'b'}, [32]byte{}, ojc, ojc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 2, r, service.originBlockRoot, [32]byte{'b'}, ojc, ojc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	require.Equal(t, 3, fcs.NodeCount())
@@ -190,7 +190,7 @@ func TestService_UpdateHead_NoAtts(t *testing.T) {
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	util.SaveBlock(t, ctx, service.cfg.BeaconDB, b)
-	state, blkRoot, err := prepareForkchoiceState(ctx, 2, r, service.originBlockRoot, [32]byte{'b'}, [32]byte{}, ojc, ojc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 2, r, service.originBlockRoot, [32]byte{'b'}, ojc, ojc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	require.Equal(t, 3, fcs.NodeCount())

beacon-chain/blockchain/receive_block.go

@@ -41,18 +41,10 @@ var epochsSinceFinalityExpandCache = primitives.Epoch(4)
 // BlockReceiver interface defines the methods of chain service for receiving and processing new blocks.
 type BlockReceiver interface {
 	ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, blockRoot [32]byte, avs das.AvailabilityStore) error
-	ReceiveExecutionPayloadEnvelope(ctx context.Context, env interfaces.ROSignedExecutionPayloadEnvelope, avs das.AvailabilityStore) error
 	ReceiveBlockBatch(ctx context.Context, blocks []blocks.ROBlock, avs das.AvailabilityStore) error
 	HasBlock(ctx context.Context, root [32]byte) bool
 	RecentBlockSlot(root [32]byte) (primitives.Slot, error)
 	BlockBeingSynced([32]byte) bool
-	PayloadBeingSynced([32]byte) bool
-}
-
-// PayloadAttestationReceiver defines methods of the chain service for receiving
-// and processing new payload attestations and payload attestation messages
-type PayloadAttestationReceiver interface {
-	ReceivePayloadAttestationMessage(ctx context.Context, a *ethpb.PayloadAttestationMessage) error
 }
 
 // BlobReceiver interface defines the methods of chain service for receiving new
@@ -68,11 +60,6 @@ type DataColumnReceiver interface {
 	ReceiveDataColumns([]blocks.VerifiedRODataColumn) error
 }
 
-// ExecutionPayloadReceiver interface defines the methods of chain service for receiving `ROExecutionPayloadEnvelope`.
-type ExecutionPayloadReceiver interface {
-	ReceiveExecutionPayloadEnvelope(ctx context.Context, envelope interfaces.ROSignedExecutionPayloadEnvelope, _ das.AvailabilityStore) error
-}
-
 // SlashingReceiver interface defines the methods of chain service for receiving validated slashing over the wire.
 type SlashingReceiver interface {
 	ReceiveAttesterSlashing(ctx context.Context, slashing ethpb.AttSlashing)
@@ -97,7 +84,11 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	}
 
 	receivedTime := time.Now()
-	s.blockBeingSynced.set(blockRoot)
+	err := s.blockBeingSynced.set(blockRoot)
+	if errors.Is(err, errBlockBeingSynced) {
+		log.WithField("blockRoot", fmt.Sprintf("%#x", blockRoot)).Debug("Ignoring block currently being synced")
+		return nil
+	}
 	defer s.blockBeingSynced.unset(blockRoot)
 
 	blockCopy, err := block.Copy()
@@ -116,30 +107,14 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 		return err
 	}
 
-	var postState state.BeaconState
-	var isValidPayload bool
-	var daWaitedTime time.Duration
-	if blockCopy.Version() >= version.EPBS {
-		postState, err = s.validateStateTransition(ctx, preState, roblock)
-		if err != nil {
-			return errors.Wrap(err, "could not validate state transition")
-		}
-		optimistic, err := s.IsOptimisticForRoot(ctx, roblock.Block().ParentRoot())
-		if err != nil {
-			return errors.Wrap(err, "could not check if parent is optimistic")
-		}
-		// if the parent is not optimistic then we can set the block as
-		// not optimistic.
-		isValidPayload = !optimistic
-	} else {
-		postState, isValidPayload, err = s.validateExecutionAndConsensus(ctx, preState, roblock)
-		if err != nil {
-			return err
-		}
-		daWaitedTime, err = s.handleDA(ctx, blockCopy, blockRoot, avs)
-		if err != nil {
-			return err
-		}
+	postState, isValidPayload, err := s.validateExecutionAndConsensus(ctx, preState, roblock)
+	if err != nil {
+		return err
+	}
+
+	daWaitedTime, err := s.handleDA(ctx, blockCopy, blockRoot, avs)
+	if err != nil {
+		return err
 	}
 
 	// Defragment the state before continuing block processing.

beacon-chain/blockchain/receive_block_test.go

@@ -311,7 +311,10 @@ func TestService_HasBlock(t *testing.T) {
 	r, err = b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.Equal(t, true, s.HasBlock(t.Context(), r))
-	s.blockBeingSynced.set(r)
+	err = s.blockBeingSynced.set(r)
+	require.NoError(t, err)
+	err = s.blockBeingSynced.set(r)
+	require.ErrorIs(t, err, errBlockBeingSynced)
 	require.Equal(t, false, s.HasBlock(t.Context(), r))
 }
 

beacon-chain/blockchain/receive_data_column.go

@@ -15,7 +15,6 @@ func (s *Service) ReceiveDataColumns(dataColumnSidecars []blocks.VerifiedRODataC
 }
 
 // ReceiveDataColumn receives a single data column.
-// (It is only a wrapper around ReceiveDataColumns.)
 func (s *Service) ReceiveDataColumn(dataColumnSidecar blocks.VerifiedRODataColumn) error {
 	if err := s.dataColumnStorage.Save([]blocks.VerifiedRODataColumn{dataColumnSidecar}); err != nil {
 		return errors.Wrap(err, "save data column sidecars")

beacon-chain/blockchain/receive_execution_payload_envelope.go

@@ -1,255 +0,0 @@
-package blockchain
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"time"
-
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/epbs"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed"
-	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/transition"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/das"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
-	"go.opencensus.io/trace"
-	"golang.org/x/sync/errgroup"
-)
-
-// ReceiveExecutionPayloadEnvelope is a function that defines the operations (minus pubsub)
-// that are performed on a received execution payload envelope. The operations consist of:
-//  1. Validate the payload, apply state transition.
-//  2. Apply fork choice to the processed payload
-//  3. Save latest head info
-func (s *Service) ReceiveExecutionPayloadEnvelope(ctx context.Context, signed interfaces.ROSignedExecutionPayloadEnvelope, _ das.AvailabilityStore) error {
-	receivedTime := time.Now()
-	envelope, err := signed.Envelope()
-	if err != nil {
-		return err
-	}
-	root := envelope.BeaconBlockRoot()
-	s.payloadBeingSynced.set(envelope)
-	defer s.payloadBeingSynced.unset(root)
-
-	preState, err := s.getPayloadEnvelopePrestate(ctx, envelope)
-	if err != nil {
-		return errors.Wrap(err, "could not get prestate")
-	}
-
-	eg, _ := errgroup.WithContext(ctx)
-	eg.Go(func() error {
-		if err := epbs.ValidatePayloadStateTransition(ctx, preState, envelope); err != nil {
-			return errors.Wrap(err, "failed to validate consensus state transition function")
-		}
-		return nil
-	})
-	var isValidPayload bool
-	eg.Go(func() error {
-		var err error
-		isValidPayload, err = s.validateExecutionOnEnvelope(ctx, envelope)
-		if err != nil {
-			return errors.Wrap(err, "could not notify the engine of the new payload")
-		}
-		return nil
-	})
-
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	daStartTime := time.Now()
-	// TODO: Add DA check
-	daWaitedTime := time.Since(daStartTime)
-	dataAvailWaitedTime.Observe(float64(daWaitedTime.Milliseconds()))
-	if err := s.savePostPayload(ctx, signed, preState); err != nil {
-		return err
-	}
-	if err := s.insertPayloadEnvelope(envelope); err != nil {
-		return errors.Wrap(err, "could not insert payload to forkchoice")
-	}
-	if isValidPayload {
-		s.ForkChoicer().Lock()
-		if err := s.ForkChoicer().SetOptimisticToValid(ctx, root); err != nil {
-			s.ForkChoicer().Unlock()
-			return errors.Wrap(err, "could not set optimistic payload to valid")
-		}
-		s.ForkChoicer().Unlock()
-	}
-
-	headRoot, err := s.HeadRoot(ctx)
-	if err != nil {
-		log.WithError(err).Error("Could not get headroot to compute attributes")
-		return nil
-	}
-	execution, err := envelope.Execution()
-	if err != nil {
-		log.WithError(err).Error("Could not get execution data")
-		return nil
-	}
-	blockHash := [32]byte(execution.BlockHash())
-	if bytes.Equal(headRoot, root[:]) {
-		attr := s.getPayloadAttribute(ctx, preState, envelope.Slot()+1, headRoot)
-		payloadID, err := s.notifyForkchoiceUpdateEPBS(ctx, blockHash, attr)
-		if err != nil {
-			if IsInvalidBlock(err) {
-				// TODO handle the lvh here
-				return err
-			}
-			return nil
-		}
-		if attr != nil && !attr.IsEmpty() && payloadID != nil {
-			var pid [8]byte
-			copy(pid[:], payloadID[:])
-			log.WithFields(logrus.Fields{
-				"blockRoot": fmt.Sprintf("%#x", bytesutil.Trunc(headRoot)),
-				"headSlot":  envelope.Slot(),
-				"payloadID": fmt.Sprintf("%#x", bytesutil.Trunc(payloadID[:])),
-			}).Info("Forkchoice updated with payload attributes for proposal")
-			s.cfg.PayloadIDCache.Set(envelope.Slot()+1, root, pid)
-		}
-		// simply update the headstate in head
-		s.headLock.Lock()
-		s.head.state = preState.Copy()
-		s.headLock.Unlock()
-		// update the NSC with the hash for the full block, we use the block hash as the key
-		if err := transition.UpdateNextSlotCache(ctx, blockHash[:], preState); err != nil {
-			log.WithError(err).Error("Could not update next slot cache with payload")
-		}
-
-	}
-	timeWithoutDaWait := time.Since(receivedTime) - daWaitedTime
-	executionEngineProcessingTime.Observe(float64(timeWithoutDaWait.Milliseconds()))
-	ex, err := envelope.Execution()
-	if err != nil {
-		return errors.Wrap(err, "could not get execution data")
-	}
-	// Send feed event
-	// Send notification of the processed block to the state feed.
-	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
-		Type: statefeed.PayloadProcessed,
-		Data: &statefeed.PayloadProcessedData{
-			Slot:                envelope.Slot(),
-			BlockRoot:           root,
-			ExecutionBlockHash:  blockHash,
-			ExecutionOptimistic: !isValidPayload,
-		},
-	})
-
-	log.WithFields(logrus.Fields{
-		"slot":       envelope.Slot(),
-		"blockRoot":  fmt.Sprintf("%#x", bytesutil.Trunc(root[:])),
-		"blockHash":  fmt.Sprintf("%#x", bytesutil.Trunc(ex.BlockHash())),
-		"ParentHash": fmt.Sprintf("%#x", bytesutil.Trunc(ex.ParentHash())),
-	}).Info("Processed execution payload envelope")
-	return nil
-}
-
-// notifyNewPayload signals execution engine on a new payload.
-// It returns true if the EL has returned VALID for the block
-func (s *Service) notifyNewEnvelope(ctx context.Context, envelope interfaces.ROExecutionPayloadEnvelope) (bool, error) {
-	ctx, span := trace.StartSpan(ctx, "blockChain.notifyNewPayload")
-	defer span.End()
-
-	payload, err := envelope.Execution()
-	if err != nil {
-		return false, errors.Wrap(err, "could not get execution payload")
-	}
-
-	versionedHashes := envelope.VersionedHashes()
-	root := envelope.BeaconBlockRoot()
-	parentRoot, err := s.ParentRoot(root)
-	if err != nil {
-		return false, errors.Wrap(err, "could not get parent block root")
-	}
-	pr := common.Hash(parentRoot)
-	requests := envelope.ExecutionRequests()
-	lastValidHash, err := s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload, versionedHashes, &pr, requests)
-	switch {
-	case err == nil:
-		newPayloadValidNodeCount.Inc()
-		return true, nil
-	case errors.Is(err, execution.ErrAcceptedSyncingPayloadStatus):
-		newPayloadOptimisticNodeCount.Inc()
-		log.WithFields(logrus.Fields{
-			"payloadBlockHash": fmt.Sprintf("%#x", bytesutil.Trunc(payload.BlockHash())),
-		}).Info("Called new payload with optimistic block")
-		return false, nil
-	case errors.Is(err, execution.ErrInvalidPayloadStatus):
-		lvh := bytesutil.ToBytes32(lastValidHash)
-		return false, invalidBlock{
-			error:         ErrInvalidPayload,
-			lastValidHash: lvh,
-		}
-	default:
-		return false, errors.WithMessage(ErrUndefinedExecutionEngineError, err.Error())
-	}
-}
-
-// validateExecutionOnEnvelope notifies the engine of the incoming execution payload and returns true if the payload is valid
-func (s *Service) validateExecutionOnEnvelope(ctx context.Context, e interfaces.ROExecutionPayloadEnvelope) (bool, error) {
-	isValidPayload, err := s.notifyNewEnvelope(ctx, e)
-	if err == nil {
-		return isValidPayload, nil
-	}
-	blockRoot := e.BeaconBlockRoot()
-	parentRoot, rootErr := s.ParentRoot(blockRoot)
-	if rootErr != nil {
-		return false, errors.Wrap(rootErr, "could not get parent block root")
-	}
-	s.cfg.ForkChoiceStore.Lock()
-	err = s.handleInvalidExecutionError(ctx, err, blockRoot, parentRoot)
-	s.cfg.ForkChoiceStore.Unlock()
-	return false, err
-}
-
-func (s *Service) getPayloadEnvelopePrestate(ctx context.Context, e interfaces.ROExecutionPayloadEnvelope) (state.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "blockChain.getPayloadEnvelopePreState")
-	defer span.End()
-
-	// Verify incoming payload has a valid pre state.
-	root := e.BeaconBlockRoot()
-	// Verify the referred block is known to forkchoice
-	if !s.InForkchoice(root) {
-		return nil, errors.New("Cannot import execution payload envelope for unknown block")
-	}
-	if err := s.verifyBlkPreState(ctx, root); err != nil {
-		return nil, errors.Wrap(err, "could not verify payload prestate")
-	}
-
-	preState, err := s.cfg.StateGen.StateByRoot(ctx, root)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get pre state")
-	}
-	if preState == nil || preState.IsNil() {
-		return nil, errors.Wrap(err, "nil pre state")
-	}
-	return preState, nil
-}
-
-func (s *Service) savePostPayload(ctx context.Context, signed interfaces.ROSignedExecutionPayloadEnvelope, st state.BeaconState) error {
-	if err := s.cfg.BeaconDB.SaveBlindPayloadEnvelope(ctx, signed); err != nil {
-		return err
-	}
-	envelope, err := signed.Envelope()
-	if err != nil {
-		return err
-	}
-	execution, err := envelope.Execution()
-	if err != nil {
-		return err
-	}
-	r := envelope.BeaconBlockRoot()
-	if err := s.cfg.StateGen.SaveState(ctx, [32]byte(execution.BlockHash()), st); err != nil {
-		log.Warnf("Rolling back insertion of block with root %#x", r)
-		if err := s.cfg.BeaconDB.DeleteBlock(ctx, r); err != nil {
-			log.WithError(err).Errorf("Could not delete block with block root %#x", r)
-		}
-		return errors.Wrap(err, "could not save state")
-	}
-	return nil
-}

beacon-chain/blockchain/receive_execution_payload_envelope_test.go

@@ -1,103 +0,0 @@
-package blockchain
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/das"
-	mockExecution "github.com/OffchainLabs/prysm/v6/beacon-chain/execution/testing"
-	forkchoicetypes "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/types"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
-	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/OffchainLabs/prysm/v6/testing/util"
-	"github.com/OffchainLabs/prysm/v6/testing/util/random"
-)
-
-func Test_getPayloadEnvelopePrestate(t *testing.T) {
-	service, tr := minimalTestService(t)
-	ctx, fcs := tr.ctx, tr.fcs
-
-	gs, _ := util.DeterministicGenesisStateEpbs(t, 32)
-	require.NoError(t, service.saveGenesisData(ctx, gs))
-	require.NoError(t, fcs.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Root: service.originBlockRoot}))
-
-	p := random.ExecutionPayloadEnvelope(t)
-	p.BeaconBlockRoot = service.originBlockRoot[:]
-	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
-	require.NoError(t, err)
-
-	_, err = service.getPayloadEnvelopePrestate(ctx, e)
-	require.NoError(t, err)
-}
-
-func Test_notifyNewEnvelope(t *testing.T) {
-	service, tr := minimalTestService(t, WithPayloadIDCache(cache.NewPayloadIDCache()))
-	ctx, fcs := tr.ctx, tr.fcs
-	gs, _ := util.DeterministicGenesisStateEpbs(t, 32)
-	require.NoError(t, service.saveGenesisData(ctx, gs))
-	require.NoError(t, fcs.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Root: service.originBlockRoot}))
-	p := random.ExecutionPayloadEnvelope(t)
-	p.BeaconBlockRoot = service.originBlockRoot[:]
-	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
-	require.NoError(t, err)
-	engine := &mockExecution.EngineClient{}
-	service.cfg.ExecutionEngineCaller = engine
-	isValidPayload, err := service.notifyNewEnvelope(ctx, e)
-	require.NoError(t, err)
-	require.Equal(t, true, isValidPayload)
-}
-
-func Test_validateExecutionOnEnvelope(t *testing.T) {
-	service, tr := minimalTestService(t, WithPayloadIDCache(cache.NewPayloadIDCache()))
-	ctx, fcs := tr.ctx, tr.fcs
-	gs, _ := util.DeterministicGenesisStateEpbs(t, 32)
-	require.NoError(t, service.saveGenesisData(ctx, gs))
-	require.NoError(t, fcs.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Root: service.originBlockRoot}))
-	p := random.ExecutionPayloadEnvelope(t)
-	p.BeaconBlockRoot = service.originBlockRoot[:]
-	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
-	require.NoError(t, err)
-	engine := &mockExecution.EngineClient{}
-	service.cfg.ExecutionEngineCaller = engine
-	isValidPayload, err := service.validateExecutionOnEnvelope(ctx, e)
-	require.NoError(t, err)
-	require.Equal(t, true, isValidPayload)
-}
-
-func Test_ReceiveExecutionPayloadEnvelope(t *testing.T) {
-	service, tr := minimalTestService(t, WithPayloadIDCache(cache.NewPayloadIDCache()))
-	ctx, fcs := tr.ctx, tr.fcs
-	gs, _ := util.DeterministicGenesisStateEpbs(t, 32)
-	require.NoError(t, service.saveGenesisData(ctx, gs))
-	require.NoError(t, fcs.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Root: service.originBlockRoot}))
-	post := gs.Copy()
-	p := &enginev1.ExecutionPayloadEnvelope{
-		Payload: &enginev1.ExecutionPayloadDeneb{
-			ParentHash: make([]byte, 32),
-			BlockHash:  make([]byte, 32),
-		},
-		BeaconBlockRoot:    service.originBlockRoot[:],
-		BlobKzgCommitments: make([][]byte, 0),
-		BeaconStateRoot:    make([]byte, 32),
-		ExecutionRequests:  &enginev1.ExecutionRequests{},
-	}
-	sp := &enginev1.SignedExecutionPayloadEnvelope{
-		Message: p,
-	}
-	e, err := blocks.WrappedROSignedExecutionPayloadEnvelope(sp)
-	require.NoError(t, err)
-	das := &das.MockAvailabilityStore{}
-
-	blockHeader := post.LatestBlockHeader()
-	prevStateRoot, err := post.HashTreeRoot(ctx)
-	require.NoError(t, err)
-	blockHeader.StateRoot = prevStateRoot[:]
-	require.NoError(t, post.SetLatestBlockHeader(blockHeader))
-	stRoot, err := post.HashTreeRoot(ctx)
-	require.NoError(t, err)
-	p.BeaconStateRoot = stRoot[:]
-	engine := &mockExecution.EngineClient{}
-	service.cfg.ExecutionEngineCaller = engine
-	require.NoError(t, service.ReceiveExecutionPayloadEnvelope(ctx, e, das))
-}

beacon-chain/blockchain/receive_payload_attestation_message.go

@@ -1,33 +0,0 @@
-package blockchain
-
-import (
-	"context"
-	"slices"
-
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-	eth "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-)
-
-func (s *Service) ReceivePayloadAttestationMessage(ctx context.Context, a *eth.PayloadAttestationMessage) error {
-	if err := helpers.ValidateNilPayloadAttestationMessage(a); err != nil {
-		return err
-	}
-	root := [32]byte(a.Data.BeaconBlockRoot)
-	st, err := s.HeadStateReadOnly(ctx)
-	if err != nil {
-		return err
-	}
-	ptc, err := helpers.GetPayloadTimelinessCommittee(ctx, st, a.Data.Slot)
-	if err != nil {
-		return err
-	}
-	idx := slices.Index(ptc, a.ValidatorIndex)
-	if idx == -1 {
-		return errInvalidValidatorIndex
-	}
-	if s.cfg.PayloadAttestationCache.Seen(root, uint64(primitives.ValidatorIndex(idx))) {
-		return nil
-	}
-	return s.cfg.PayloadAttestationCache.Add(a, uint64(idx))
-}

beacon-chain/blockchain/service.go

@@ -12,11 +12,9 @@ import (
 	"github.com/OffchainLabs/prysm/v6/async/event"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
 	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	coreTime "github.com/OffchainLabs/prysm/v6/beacon-chain/core/time"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/transition"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
@@ -31,6 +29,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/stategen"
+	"github.com/OffchainLabs/prysm/v6/cmd/beacon-chain/flags"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
@@ -70,7 +69,6 @@ type Service struct {
 	lcStore                        *lightClient.Store
 	startWaitingDataColumnSidecars chan bool // for testing purposes only
 	syncCommitteeHeadState         *cache.SyncCommitteeHeadStateCache
-	payloadBeingSynced             *currentlySyncingPayload
 }
 
 // config options for the service.
@@ -79,8 +77,6 @@ type config struct {
 	ChainStartFetcher       execution.ChainStartFetcher
 	BeaconDB                db.HeadAccessDatabase
 	DepositCache            cache.DepositCache
-	PayloadAttestationCache *cache.PayloadAttestationCache
-	PayloadEnvelopeCache    *sync.Map
 	PayloadIDCache          *cache.PayloadIDCache
 	TrackedValidatorsCache  *cache.TrackedValidatorsCache
 	AttestationCache        *cache.AttestationCache
@@ -100,7 +96,6 @@ type config struct {
 	FinalizedStateAtStartUp state.BeaconState
 	ExecutionEngineCaller   execution.EngineCaller
 	SyncChecker             Checker
-	CustodyInfo             *peerdas.CustodyInfo
 }
 
 // Checker is an interface used to determine if a node is in initial sync
@@ -193,7 +188,6 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 		cfg:                    &config{},
 		blockBeingSynced:       &currentlySyncingBlock{roots: make(map[[32]byte]struct{})},
 		syncCommitteeHeadState: cache.NewSyncCommitteeHeadState(),
-		payloadBeingSynced:     &currentlySyncingPayload{roots: make(map[[32]byte]primitives.PTCStatus)},
 	}
 	for _, opt := range opts {
 		if err := opt(srv); err != nil {
@@ -212,17 +206,9 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 
 // Start a blockchain service's main event loop.
 func (s *Service) Start() {
-	saved := s.cfg.FinalizedStateAtStartUp
 	defer s.removeStartupState()
-
-	if saved != nil && !saved.IsNil() {
-		if err := s.StartFromSavedState(saved); err != nil {
-			log.Fatal(err)
-		}
-	} else {
-		if err := s.startFromExecutionChain(); err != nil {
-			log.Fatal(err)
-		}
+	if err := s.StartFromSavedState(s.cfg.FinalizedStateAtStartUp); err != nil {
+		log.Fatal(err)
 	}
 	s.spawnProcessAttestationsRoutine()
 	go s.runLateBlockTasks()
@@ -271,6 +257,9 @@ func (s *Service) Status() error {
 
 // StartFromSavedState initializes the blockchain using a previously saved finalized checkpoint.
 func (s *Service) StartFromSavedState(saved state.BeaconState) error {
+	if state.IsNil(saved) {
+		return errors.New("Last finalized state at startup is nil")
+	}
 	log.Info("Blockchain data already exists in DB, initializing...")
 	s.genesisTime = saved.GenesisTime()
 	s.cfg.AttService.SetGenesisTime(saved.GenesisTime())
@@ -300,6 +289,20 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 	if err := s.clockSetter.SetClock(startup.NewClock(s.genesisTime, vr)); err != nil {
 		return errors.Wrap(err, "failed to initialize blockchain service")
 	}
+
+	if !params.FuluEnabled() {
+		return nil
+	}
+
+	earliestAvailableSlot, custodySubnetCount, err := s.updateCustodyInfoInDB(saved.Slot())
+	if err != nil {
+		return errors.Wrap(err, "could not get and save custody group count")
+	}
+
+	if _, _, err := s.cfg.P2P.UpdateCustodyInfo(earliestAvailableSlot, custodySubnetCount); err != nil {
+		return errors.Wrap(err, "update custody info")
+	}
+
 	return nil
 }
 
@@ -362,62 +365,6 @@ func (s *Service) initializeHead(ctx context.Context, st state.BeaconState) erro
 	return nil
 }
 
-func (s *Service) startFromExecutionChain() error {
-	log.Info("Waiting to reach the validator deposit threshold to start the beacon chain...")
-	if s.cfg.ChainStartFetcher == nil {
-		return errors.New("not configured execution chain")
-	}
-	go func() {
-		stateChannel := make(chan *feed.Event, 1)
-		stateSub := s.cfg.StateNotifier.StateFeed().Subscribe(stateChannel)
-		defer stateSub.Unsubscribe()
-		for {
-			select {
-			case e := <-stateChannel:
-				if e.Type == statefeed.ChainStarted {
-					data, ok := e.Data.(*statefeed.ChainStartedData)
-					if !ok {
-						log.Error("Event data is not type *statefeed.ChainStartedData")
-						return
-					}
-					log.WithField("startTime", data.StartTime).Debug("Received chain start event")
-					s.onExecutionChainStart(s.ctx, data.StartTime)
-					return
-				}
-			case <-s.ctx.Done():
-				log.Debug("Context closed, exiting goroutine")
-				return
-			case err := <-stateSub.Err():
-				log.WithError(err).Error("Subscription to state forRoot failed")
-				return
-			}
-		}
-	}()
-
-	return nil
-}
-
-// onExecutionChainStart initializes a series of deposits from the ChainStart deposits in the eth1
-// deposit contract, initializes the beacon chain's state, and kicks off the beacon chain.
-func (s *Service) onExecutionChainStart(ctx context.Context, genesisTime time.Time) {
-	preGenesisState := s.cfg.ChainStartFetcher.PreGenesisState()
-	initializedState, err := s.initializeBeaconChain(ctx, genesisTime, preGenesisState, s.cfg.ChainStartFetcher.ChainStartEth1Data())
-	if err != nil {
-		log.WithError(err).Fatal("Could not initialize beacon chain")
-	}
-	// We start a counter to genesis, if needed.
-	gRoot, err := initializedState.HashTreeRoot(s.ctx)
-	if err != nil {
-		log.WithError(err).Fatal("Could not hash tree root genesis state")
-	}
-	go slots.CountdownToGenesis(ctx, genesisTime, uint64(initializedState.NumValidators()), gRoot)
-
-	vr := bytesutil.ToBytes32(initializedState.GenesisValidatorsRoot())
-	if err := s.clockSetter.SetClock(startup.NewClock(genesisTime, vr)); err != nil {
-		log.WithError(err).Fatal("Failed to initialize blockchain service from execution start event")
-	}
-}
-
 // initializes the state and genesis block of the beacon chain to persistent storage
 // based on a genesis timestamp value obtained from the ChainStart event emitted
 // by the ETH1.0 Deposit Contract and the POWChain service of the node.
@@ -508,7 +455,7 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState state.Beacon
 // 2.) Check DB.
 // Checking 1.) is ten times faster than checking 2.)
 // this function requires a lock in forkchoice
-func (s *Service) chainHasBlock(ctx context.Context, root [32]byte) bool {
+func (s *Service) hasBlock(ctx context.Context, root [32]byte) bool {
 	if s.cfg.ForkChoiceStore.HasNode(root) {
 		return true
 	}
@@ -520,6 +467,57 @@ func (s *Service) removeStartupState() {
 	s.cfg.FinalizedStateAtStartUp = nil
 }
 
+// UpdateCustodyInfoInDB updates the custody information in the database.
+// It returns the (potentially updated) custody group count and the earliest available slot.
+func (s *Service) updateCustodyInfoInDB(slot primitives.Slot) (primitives.Slot, uint64, error) {
+	isSubscribedToAllDataSubnets := flags.Get().SubscribeAllDataSubnets
+
+	beaconConfig := params.BeaconConfig()
+	custodyRequirement := beaconConfig.CustodyRequirement
+
+	// Check if the node was previously subscribed to all data subnets, and if so,
+	// store the new status accordingly.
+	wasSubscribedToAllDataSubnets, err := s.cfg.BeaconDB.UpdateSubscribedToAllDataSubnets(s.ctx, isSubscribedToAllDataSubnets)
+	if err != nil {
+		log.WithError(err).Error("Could not update subscription status to all data subnets")
+	}
+
+	// Warn the user if the node was previously subscribed to all data subnets and is not any more.
+	if wasSubscribedToAllDataSubnets && !isSubscribedToAllDataSubnets {
+		log.Warnf(
+			"Because the flag `--%s` was previously used, the node will still subscribe to all data subnets.",
+			flags.SubscribeAllDataSubnets.Name,
+		)
+	}
+
+	// Compute the custody group count.
+	custodyGroupCount := custodyRequirement
+	if isSubscribedToAllDataSubnets {
+		custodyGroupCount = beaconConfig.NumberOfColumns
+	}
+
+	// Safely compute the fulu fork slot.
+	fuluForkSlot, err := fuluForkSlot()
+	if err != nil {
+		return 0, 0, errors.Wrap(err, "fulu fork slot")
+	}
+
+	// If slot is before the fulu fork slot, then use the earliest stored slot as the reference slot.
+	if slot < fuluForkSlot {
+		slot, err = s.cfg.BeaconDB.EarliestSlot(s.ctx)
+		if err != nil {
+			return 0, 0, errors.Wrap(err, "earliest slot")
+		}
+	}
+
+	earliestAvailableSlot, custodyGroupCount, err := s.cfg.BeaconDB.UpdateCustodyInfo(s.ctx, slot, custodyGroupCount)
+	if err != nil {
+		return 0, 0, errors.Wrap(err, "update custody info")
+	}
+
+	return earliestAvailableSlot, custodyGroupCount, nil
+}
+
 func spawnCountdownIfPreGenesis(ctx context.Context, genesisTime time.Time, db db.HeadAccessDatabase) {
 	currentTime := prysmTime.Now()
 	if currentTime.After(genesisTime) {
@@ -536,3 +534,19 @@ func spawnCountdownIfPreGenesis(ctx context.Context, genesisTime time.Time, db d
 	}
 	go slots.CountdownToGenesis(ctx, genesisTime, uint64(gState.NumValidators()), gRoot)
 }
+
+func fuluForkSlot() (primitives.Slot, error) {
+	beaconConfig := params.BeaconConfig()
+
+	fuluForkEpoch := beaconConfig.FuluForkEpoch
+	if fuluForkEpoch == beaconConfig.FarFutureEpoch {
+		return beaconConfig.FarFutureSlot, nil
+	}
+
+	forkFuluSlot, err := slots.EpochStart(fuluForkEpoch)
+	if err != nil {
+		return 0, errors.Wrap(err, "epoch start")
+	}
+
+	return forkFuluSlot, nil
+}

beacon-chain/blockchain/service_test.go

@@ -31,6 +31,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/container/trie"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/genesis"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
@@ -51,6 +52,7 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 		srv.Stop()
 	})
 	bState, _ := util.DeterministicGenesisState(t, 10)
+	genesis.StoreStateDuringTest(t, bState)
 	pbState, err := state_native.ProtobufBeaconStatePhase0(bState.ToProtoUnsafe())
 	require.NoError(t, err)
 	mockTrie, err := trie.NewTrie(0)
@@ -71,20 +73,22 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 		DepositContainers: []*ethpb.DepositContainer{},
 	})
 	require.NoError(t, err)
+
+	depositCache, err := depositsnapshot.New()
+	require.NoError(t, err)
+
 	web3Service, err = execution.NewService(
 		ctx,
 		execution.WithDatabase(beaconDB),
 		execution.WithHttpEndpoint(endpoint),
 		execution.WithDepositContractAddress(common.Address{}),
+		execution.WithDepositCache(depositCache),
 	)
 	require.NoError(t, err, "Unable to set up web3 service")
 
 	attService, err := attestations.NewService(ctx, &attestations.Config{Pool: attestations.NewPool()})
 	require.NoError(t, err)
 
-	depositCache, err := depositsnapshot.New()
-	require.NoError(t, err)
-
 	fc := doublylinkedtree.New()
 	stateGen := stategen.New(beaconDB, fc)
 	// Safe a state in stategen to purposes of testing a service stop / shutdown.
@@ -379,8 +383,8 @@ func TestHasBlock_ForkChoiceAndDB_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, s.cfg.ForkChoiceStore.InsertNode(ctx, beaconState, roblock))
 
-	assert.Equal(t, false, s.chainHasBlock(ctx, [32]byte{}), "Should not have block")
-	assert.Equal(t, true, s.chainHasBlock(ctx, r), "Should have block")
+	assert.Equal(t, false, s.hasBlock(ctx, [32]byte{}), "Should not have block")
+	assert.Equal(t, true, s.hasBlock(ctx, r), "Should have block")
 }
 
 func TestServiceStop_SaveCachedBlocks(t *testing.T) {
@@ -396,24 +400,6 @@ func TestServiceStop_SaveCachedBlocks(t *testing.T) {
 	require.Equal(t, true, s.cfg.BeaconDB.HasBlock(s.ctx, r))
 }
 
-func TestProcessChainStartTime_ReceivedFeed(t *testing.T) {
-	ctx := t.Context()
-	beaconDB := testDB.SetupDB(t)
-	service := setupBeaconChain(t, beaconDB)
-	mgs := &MockClockSetter{}
-	service.clockSetter = mgs
-	gt := time.Now()
-	service.onExecutionChainStart(t.Context(), gt)
-	gs, err := beaconDB.GenesisState(ctx)
-	require.NoError(t, err)
-	require.NotEqual(t, nil, gs)
-	require.Equal(t, 32, len(gs.GenesisValidatorsRoot()))
-	var zero [32]byte
-	require.DeepNotEqual(t, gs.GenesisValidatorsRoot(), zero[:])
-	require.Equal(t, gt, mgs.G.GenesisTime())
-	require.Equal(t, bytesutil.ToBytes32(gs.GenesisValidatorsRoot()), mgs.G.GenesisValidatorsRoot())
-}
-
 func BenchmarkHasBlockDB(b *testing.B) {
 	ctx := b.Context()
 	s := testServiceWithDB(b)

beacon-chain/blockchain/setup_test.go

@@ -30,6 +30,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
+	"github.com/libp2p/go-libp2p/core/peer"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -54,6 +55,7 @@ type mockBroadcaster struct {
 
 type mockAccessor struct {
 	mockBroadcaster
+	mockCustodyManager
 	p2pTesting.MockPeerManager
 }
 
@@ -97,6 +99,43 @@ func (mb *mockBroadcaster) BroadcastBLSChanges(_ context.Context, _ []*ethpb.Sig
 
 var _ p2p.Broadcaster = (*mockBroadcaster)(nil)
 
+// mockCustodyManager is a mock implementation of p2p.CustodyManager
+type mockCustodyManager struct {
+	mut                   sync.RWMutex
+	earliestAvailableSlot primitives.Slot
+	custodyGroupCount     uint64
+}
+
+func (dch *mockCustodyManager) EarliestAvailableSlot() (primitives.Slot, error) {
+	dch.mut.RLock()
+	defer dch.mut.RUnlock()
+
+	return dch.earliestAvailableSlot, nil
+}
+
+func (dch *mockCustodyManager) CustodyGroupCount() (uint64, error) {
+	dch.mut.RLock()
+	defer dch.mut.RUnlock()
+
+	return dch.custodyGroupCount, nil
+}
+
+func (dch *mockCustodyManager) UpdateCustodyInfo(earliestAvailableSlot primitives.Slot, custodyGroupCount uint64) (primitives.Slot, uint64, error) {
+	dch.mut.Lock()
+	defer dch.mut.Unlock()
+
+	dch.earliestAvailableSlot = earliestAvailableSlot
+	dch.custodyGroupCount = custodyGroupCount
+
+	return earliestAvailableSlot, custodyGroupCount, nil
+}
+
+func (dch *mockCustodyManager) CustodyGroupCountFromPeer(peer.ID) uint64 {
+	return 0
+}
+
+var _ p2p.CustodyManager = (*mockCustodyManager)(nil)
+
 type testServiceRequirements struct {
 	ctx     context.Context
 	db      db.Database

beacon-chain/blockchain/testing/BUILD.bazel

@@ -3,10 +3,7 @@ load("@prysm//tools/go:def.bzl", "go_library")
 go_library(
     name = "go_default_library",
     testonly = True,
-    srcs = [
-        "mock.go",
-        "mock_epbs.go",
-    ],
+    srcs = ["mock.go"],
     importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/testing",
     visibility = [
         "//beacon-chain:__subpackages__",

beacon-chain/blockchain/testing/mock.go

@@ -37,51 +37,47 @@ var ErrNilState = errors.New("nil state")
 
 // ChainService defines the mock interface for testing
 type ChainService struct {
-	NotFinalized                        bool
-	Optimistic                          bool
-	ValidAttestation                    bool
-	ValidatorsRoot                      [32]byte
-	PublicKey                           [fieldparams.BLSPubkeyLength]byte
-	FinalizedCheckPoint                 *ethpb.Checkpoint
-	CurrentJustifiedCheckPoint          *ethpb.Checkpoint
-	PreviousJustifiedCheckPoint         *ethpb.Checkpoint
-	Slot                                *primitives.Slot // Pointer because 0 is a useful value, so checking against it can be incorrect.
-	Balance                             *precompute.Balance
-	CanonicalRoots                      map[[32]byte]bool
-	Fork                                *ethpb.Fork
-	ETH1Data                            *ethpb.Eth1Data
-	InitSyncBlockRoots                  map[[32]byte]bool
-	DB                                  db.Database
-	State                               state.BeaconState
-	HeadStateErr                        error
-	Block                               interfaces.ReadOnlySignedBeaconBlock
-	VerifyBlkDescendantErr              error
-	stateNotifier                       statefeed.Notifier
-	BlocksReceived                      []interfaces.ReadOnlySignedBeaconBlock
-	SyncCommitteeIndices                []primitives.CommitteeIndex
-	blockNotifier                       blockfeed.Notifier
-	opNotifier                          opfeed.Notifier
-	Root                                []byte
-	SyncCommitteeDomain                 []byte
-	SyncSelectionProofDomain            []byte
-	SyncContributionProofDomain         []byte
-	SyncCommitteePubkeys                [][]byte
-	Genesis                             time.Time
-	ForkChoiceStore                     forkchoice.ForkChoicer
-	ReceiveBlockMockErr                 error
-	OptimisticCheckRootReceived         [32]byte
-	FinalizedRoots                      map[[32]byte]bool
-	OptimisticRoots                     map[[32]byte]bool
-	BlockSlot                           primitives.Slot
-	SyncingRoot                         [32]byte
-	Blobs                               []blocks.VerifiedROBlob
-	DataColumns                         []blocks.VerifiedRODataColumn
-	TargetRoot                          [32]byte
-	MockHeadSlot                        *primitives.Slot
-	HighestReceivedSlot                 primitives.Slot
-	HighestReceivedRoot                 [32]byte
-	PayloadStatus                       primitives.PTCStatus
-	ReceivePayloadAttestationMessageErr error
+	NotFinalized                bool
+	Optimistic                  bool
+	ValidAttestation            bool
+	ValidatorsRoot              [32]byte
+	PublicKey                   [fieldparams.BLSPubkeyLength]byte
+	FinalizedCheckPoint         *ethpb.Checkpoint
+	CurrentJustifiedCheckPoint  *ethpb.Checkpoint
+	PreviousJustifiedCheckPoint *ethpb.Checkpoint
+	Slot                        *primitives.Slot // Pointer because 0 is a useful value, so checking against it can be incorrect.
+	Balance                     *precompute.Balance
+	CanonicalRoots              map[[32]byte]bool
+	Fork                        *ethpb.Fork
+	ETH1Data                    *ethpb.Eth1Data
+	InitSyncBlockRoots          map[[32]byte]bool
+	DB                          db.Database
+	State                       state.BeaconState
+	HeadStateErr                error
+	Block                       interfaces.ReadOnlySignedBeaconBlock
+	VerifyBlkDescendantErr      error
+	stateNotifier               statefeed.Notifier
+	BlocksReceived              []interfaces.ReadOnlySignedBeaconBlock
+	SyncCommitteeIndices        []primitives.CommitteeIndex
+	blockNotifier               blockfeed.Notifier
+	opNotifier                  opfeed.Notifier
+	Root                        []byte
+	SyncCommitteeDomain         []byte
+	SyncSelectionProofDomain    []byte
+	SyncContributionProofDomain []byte
+	SyncCommitteePubkeys        [][]byte
+	Genesis                     time.Time
+	ForkChoiceStore             forkchoice.ForkChoicer
+	ReceiveBlockMockErr         error
+	OptimisticCheckRootReceived [32]byte
+	FinalizedRoots              map[[32]byte]bool
+	OptimisticRoots             map[[32]byte]bool
+	BlockSlot                   primitives.Slot
+	SyncingRoot                 [32]byte
+	Blobs                       []blocks.VerifiedROBlob
+	DataColumns                 []blocks.VerifiedRODataColumn
+	TargetRoot                  [32]byte
+	MockHeadSlot                *primitives.Slot
 }
 
 func (s *ChainService) Ancestor(ctx context.Context, root []byte, slot primitives.Slot) ([]byte, error) {
@@ -659,12 +655,12 @@ func (s *ChainService) ReceivedBlocksLastEpoch() (uint64, error) {
 	return 0, nil
 }
 
-// HighestReceivedBlockSlotRoot mocks the same method in the chain service
-func (s *ChainService) HighestReceivedBlockSlotRoot() (primitives.Slot, [32]byte) {
+// HighestReceivedBlockSlot mocks the same method in the chain service
+func (s *ChainService) HighestReceivedBlockSlot() primitives.Slot {
 	if s.ForkChoiceStore != nil {
-		return s.ForkChoiceStore.HighestReceivedBlockSlotRoot()
+		return s.ForkChoiceStore.HighestReceivedBlockSlot()
 	}
-	return s.HighestReceivedSlot, s.HighestReceivedRoot
+	return 0
 }
 
 // InsertNode mocks the same method in the chain service
@@ -709,11 +705,6 @@ func (*ChainService) UnrealizedJustifiedPayloadBlockHash() [32]byte {
 	return [32]byte{}
 }
 
-// PayloadBeingSynced mocks the same method in the chain service
-func (c *ChainService) PayloadBeingSynced(root [32]byte) bool {
-	return root == c.SyncingRoot
-}
-
 // BlockBeingSynced mocks the same method in the chain service
 func (c *ChainService) BlockBeingSynced(root [32]byte) bool {
 	return root == c.SyncingRoot
@@ -751,21 +742,3 @@ type MockSyncChecker struct {
 func (m *MockSyncChecker) Synced() bool {
 	return m.synced
 }
-
-// HashInForkchoice mocks the same method in the chain service
-func (c *ChainService) HashInForkchoice([32]byte) bool {
-	return false
-}
-
-// ReceivePayloadAttestationMessage mocks the same method in the chain service
-func (c *ChainService) ReceivePayloadAttestationMessage(_ context.Context, _ *ethpb.PayloadAttestationMessage) error {
-	return c.ReceivePayloadAttestationMessageErr
-}
-
-func (c *ChainService) GetPTCVote(root [32]byte) primitives.PTCStatus {
-	return c.PayloadStatus
-}
-
-func (c *ChainService) HashForBlockRoot(_ context.Context, root [32]byte) ([]byte, error) {
-	return root[:], nil
-}

beacon-chain/blockchain/testing/mock_epbs.go

@@ -1,30 +0,0 @@
-package testing
-
-import (
-	"context"
-
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/das"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
-)
-
-// ReceiveExecutionPayloadEnvelope mocks the  method in chain service.
-func (s *ChainService) ReceiveExecutionPayloadEnvelope(ctx context.Context, env interfaces.ROSignedExecutionPayloadEnvelope, _ das.AvailabilityStore) error {
-	if s.ReceiveBlockMockErr != nil {
-		return s.ReceiveBlockMockErr
-	}
-	if s.State == nil {
-		return ErrNilState
-	}
-	e, err := env.Envelope()
-	if err != nil {
-		return err
-	}
-
-	if s.State.Slot() == e.Slot() {
-		if err := s.State.SetLatestFullSlot(s.State.Slot()); err != nil {
-			return err
-		}
-	}
-	s.ExecutionPayloadEnvelope = e
-	return nil
-}

beacon-chain/cache/BUILD.bazel

@@ -16,13 +16,11 @@ go_library(
         "doc.go",
         "error.go",
         "interfaces.go",
-        "payload_attestation.go",
         "payload_id.go",
         "proposer_indices.go",
         "proposer_indices_disabled.go",  # keep
         "proposer_indices_type.go",
         "registration.go",
-        "signed_execution_header.go",
         "skip_slot_cache.go",
         "subnet_ids.go",
         "sync_committee.go",
@@ -52,7 +50,6 @@ go_library(
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
-        "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//runtime/version:go_default_library",
@@ -78,12 +75,10 @@ go_test(
         "checkpoint_state_test.go",
         "committee_fuzz_test.go",
         "committee_test.go",
-        "payload_attestation_test.go",
         "payload_id_test.go",
         "private_access_test.go",
         "proposer_indices_test.go",
         "registration_test.go",
-        "signed_execution_header_test.go",
         "skip_slot_cache_test.go",
         "subnet_ids_test.go",
         "sync_committee_head_state_test.go",
@@ -99,10 +94,8 @@ go_test(
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
-        "//crypto/bls:go_default_library",
         "//crypto/bls/blst:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//testing/assert:go_default_library",

beacon-chain/cache/payload_attestation.go

@@ -1,137 +0,0 @@
-package cache
-
-import (
-	"errors"
-	"fmt"
-	"sync"
-
-	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v6/crypto/bls"
-	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	eth "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-)
-
-var errNilPayloadAttestationMessage = errors.New("nil Payload Attestation Message")
-
-// PayloadAttestationCache keeps a map of all the PTC votes that were seen,
-// already aggregated. The key is the beacon block root.
-type PayloadAttestationCache struct {
-	root         [32]byte
-	attestations [primitives.PAYLOAD_INVALID_STATUS]*eth.PayloadAttestation
-	sync.Mutex
-}
-
-// Seen returns true if a vote for the given Beacon Block Root has already been processed
-// for this Payload Timeliness Committee index. This will return true even if
-// the Payload status differs.
-func (p *PayloadAttestationCache) Seen(root [32]byte, idx uint64) bool {
-	p.Lock()
-	defer p.Unlock()
-	if p.root != root {
-		return false
-	}
-	for _, agg := range p.attestations {
-		if agg == nil {
-			continue
-		}
-		if agg.AggregationBits.BitAt(idx) {
-			return true
-		}
-	}
-	return false
-}
-
-// messageToPayloadAttestation creates a PayloadAttestation with a single
-// aggregated bit from the passed PayloadAttestationMessage
-func messageToPayloadAttestation(att *eth.PayloadAttestationMessage, idx uint64) *eth.PayloadAttestation {
-	bits := primitives.NewPayloadAttestationAggregationBits()
-	bits.SetBitAt(idx, true)
-	data := &eth.PayloadAttestationData{
-		BeaconBlockRoot: bytesutil.SafeCopyBytes(att.Data.BeaconBlockRoot),
-		Slot:            att.Data.Slot,
-		PayloadStatus:   att.Data.PayloadStatus,
-	}
-	return &eth.PayloadAttestation{
-		AggregationBits: bits,
-		Data:            data,
-		Signature:       bytesutil.SafeCopyBytes(att.Signature),
-	}
-}
-
-// aggregateSigFromMessage returns the aggregated signature from a Payload
-// Attestation by adding the passed signature in the PayloadAttestationMessage,
-// no signature validation is performed.
-func aggregateSigFromMessage(aggregated *eth.PayloadAttestation, message *eth.PayloadAttestationMessage) ([]byte, error) {
-	aggSig, err := bls.SignatureFromBytesNoValidation(aggregated.Signature)
-	if err != nil {
-		return nil, err
-	}
-	sig, err := bls.SignatureFromBytesNoValidation(message.Signature)
-	if err != nil {
-		return nil, err
-	}
-	return bls.AggregateSignatures([]bls.Signature{aggSig, sig}).Marshal(), nil
-}
-
-// Add adds a PayloadAttestationMessage to the internal cache of aggregated
-// PayloadAttestations.
-// If the index has already been seen for this attestation status the function does nothing.
-// If the root is not the cached root, the function will clear the previous cache
-// This function assumes that the message has already been validated. In
-// particular that the signature is valid and that the block root corresponds to
-// the given slot in the attestation data.
-func (p *PayloadAttestationCache) Add(att *eth.PayloadAttestationMessage, idx uint64) error {
-	if att == nil || att.Data == nil || att.Data.BeaconBlockRoot == nil {
-		return errNilPayloadAttestationMessage
-	}
-	p.Lock()
-	defer p.Unlock()
-	root := [32]byte(att.Data.BeaconBlockRoot)
-	if p.root != root {
-		p.root = root
-		p.attestations = [primitives.PAYLOAD_INVALID_STATUS]*eth.PayloadAttestation{}
-	}
-	if len(att.Data.PayloadStatus) != 1 {
-		return fmt.Errorf("expected payload status length 1, got %d", len(att.Data.PayloadStatus))
-	}
-	status := uint64(att.Data.PayloadStatus[0])
-	agg := p.attestations[status]
-	if agg == nil {
-		p.attestations[status] = messageToPayloadAttestation(att, idx)
-		return nil
-	}
-	if agg.AggregationBits.BitAt(idx) {
-		return nil
-	}
-	sig, err := aggregateSigFromMessage(agg, att)
-	if err != nil {
-		return err
-	}
-	agg.Signature = sig
-	agg.AggregationBits.SetBitAt(idx, true)
-	return nil
-}
-
-// Get returns the aggregated PayloadAttestation for the given root and status
-// if the root doesn't exist or status is invalid, the function returns nil.
-func (p *PayloadAttestationCache) Get(root [32]byte, status primitives.PTCStatus) *eth.PayloadAttestation {
-	p.Lock()
-	defer p.Unlock()
-
-	if p.root != root {
-		return nil
-	}
-	if status >= primitives.PAYLOAD_INVALID_STATUS {
-		return nil
-	}
-
-	return eth.CopyPayloadAttestation(p.attestations[status])
-}
-
-// Clear clears the internal map
-func (p *PayloadAttestationCache) Clear() {
-	p.Lock()
-	defer p.Unlock()
-	p.root = [32]byte{}
-	p.attestations = [primitives.PAYLOAD_INVALID_STATUS]*eth.PayloadAttestation{}
-}

beacon-chain/cache/payload_attestation_test.go

@@ -1,143 +0,0 @@
-package cache
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v6/crypto/bls"
-	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	eth "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-)
-
-func TestPayloadAttestationCache(t *testing.T) {
-	p := &PayloadAttestationCache{}
-
-	//Test Has seen
-	root := [32]byte{'r'}
-	idx := uint64(5)
-	require.Equal(t, false, p.Seen(root, idx))
-
-	// Test Add
-	msg := &eth.PayloadAttestationMessage{
-		Signature: bls.NewAggregateSignature().Marshal(),
-		Data: &eth.PayloadAttestationData{
-			BeaconBlockRoot: root[:],
-			Slot:            1,
-			PayloadStatus:   primitives.PAYLOAD_PRESENT,
-		},
-	}
-
-	// Add new root
-	require.NoError(t, p.Add(msg, idx))
-	require.Equal(t, true, p.Seen(root, idx))
-	require.Equal(t, root, p.root)
-	att := p.attestations[primitives.PAYLOAD_PRESENT]
-	indices := att.AggregationBits.BitIndices()
-	require.DeepEqual(t, []int{int(idx)}, indices)
-	singleSig := bytesutil.SafeCopyBytes(msg.Signature)
-	require.DeepEqual(t, singleSig, att.Signature)
-
-	// Test Seen
-	require.Equal(t, true, p.Seen(root, idx))
-	require.Equal(t, false, p.Seen(root, idx+1))
-
-	// Add another attestation on the same data
-	msg2 := &eth.PayloadAttestationMessage{
-		Signature: bls.NewAggregateSignature().Marshal(),
-		Data:      att.Data,
-	}
-	idx2 := uint64(7)
-	require.NoError(t, p.Add(msg2, idx2))
-	att = p.attestations[primitives.PAYLOAD_PRESENT]
-	indices = att.AggregationBits.BitIndices()
-	require.DeepEqual(t, []int{int(idx), int(idx2)}, indices)
-	require.DeepNotEqual(t, att.Signature, msg.Signature)
-
-	// Try again the same index
-	require.NoError(t, p.Add(msg2, idx2))
-	att2 := p.attestations[primitives.PAYLOAD_PRESENT]
-	indices = att.AggregationBits.BitIndices()
-	require.DeepEqual(t, []int{int(idx), int(idx2)}, indices)
-	require.DeepEqual(t, att, att2)
-
-	// Test Seen
-	require.Equal(t, true, p.Seen(root, idx2))
-	require.Equal(t, false, p.Seen(root, idx2+1))
-
-	// Add another payload status for a different payload status
-	msg3 := &eth.PayloadAttestationMessage{
-		Signature: bls.NewAggregateSignature().Marshal(),
-		Data: &eth.PayloadAttestationData{
-			BeaconBlockRoot: root[:],
-			Slot:            1,
-			PayloadStatus:   primitives.PAYLOAD_WITHHELD,
-		},
-	}
-	idx3 := uint64(17)
-
-	require.NoError(t, p.Add(msg3, idx3))
-	att3 := p.attestations[primitives.PAYLOAD_WITHHELD]
-	indices3 := att3.AggregationBits.BitIndices()
-	require.DeepEqual(t, []int{int(idx3)}, indices3)
-	require.DeepEqual(t, singleSig, att3.Signature)
-
-	// Add a different root
-	root2 := [32]byte{'s'}
-	msg.Data.BeaconBlockRoot = root2[:]
-	require.NoError(t, p.Add(msg, idx))
-	require.Equal(t, root2, p.root)
-	require.Equal(t, true, p.Seen(root2, idx))
-	require.Equal(t, false, p.Seen(root, idx))
-	att = p.attestations[primitives.PAYLOAD_PRESENT]
-	indices = att.AggregationBits.BitIndices()
-	require.DeepEqual(t, []int{int(idx)}, indices)
-}
-
-func TestPayloadAttestationCache_Get(t *testing.T) {
-	root := [32]byte{1, 2, 3}
-	wrongRoot := [32]byte{4, 5, 6}
-	status := primitives.PAYLOAD_PRESENT
-	invalidStatus := primitives.PAYLOAD_INVALID_STATUS
-
-	cache := &PayloadAttestationCache{
-		root: root,
-		attestations: [primitives.PAYLOAD_INVALID_STATUS]*eth.PayloadAttestation{
-			{
-				Signature: []byte{1},
-			},
-			{
-				Signature: []byte{2},
-			},
-			{
-				Signature: []byte{3},
-			},
-		},
-	}
-
-	t.Run("valid root and status", func(t *testing.T) {
-		result := cache.Get(root, status)
-		require.NotNil(t, result, "Expected a non-nil result")
-		require.DeepEqual(t, cache.attestations[status], result)
-	})
-
-	t.Run("invalid root", func(t *testing.T) {
-		result := cache.Get(wrongRoot, status)
-		require.IsNil(t, result)
-	})
-
-	t.Run("status out of bound", func(t *testing.T) {
-		result := cache.Get(root, invalidStatus)
-		require.IsNil(t, result)
-	})
-
-	t.Run("no attestation", func(t *testing.T) {
-		emptyCache := &PayloadAttestationCache{
-			root:         root,
-			attestations: [primitives.PAYLOAD_INVALID_STATUS]*eth.PayloadAttestation{},
-		}
-
-		result := emptyCache.Get(root, status)
-		require.IsNil(t, result)
-	})
-}

beacon-chain/cache/signed_execution_header.go

@@ -1,76 +0,0 @@
-package cache
-
-import (
-	"bytes"
-	"sync"
-
-	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
-)
-
-// ExecutionPayloadHeaders is used  by the sync service to store signed execution payload headers after they pass validation,
-// and filter out subsequent headers with lower value.
-// The signed header from this cache could be used by the proposer when proposing the next slot.
-type ExecutionPayloadHeaders struct {
-	headers map[primitives.Slot][]*enginev1.SignedExecutionPayloadHeader
-	sync.RWMutex
-}
-
-func NewExecutionPayloadHeaders() *ExecutionPayloadHeaders {
-	return &ExecutionPayloadHeaders{
-		headers: make(map[primitives.Slot][]*enginev1.SignedExecutionPayloadHeader),
-	}
-}
-
-// SaveSignedExecutionPayloadHeader saves the signed execution payload header to the cache.
-// The cache stores headers for up to two slots. If the input slot is higher than the lowest slot
-// currently in the cache, the lowest slot is removed to make space for the new header.
-// Only the highest value header for a given parent block hash will be stored.
-// This function assumes caller already checks header's slot is current or next slot, it doesn't account for slot validation.
-func (c *ExecutionPayloadHeaders) SaveSignedExecutionPayloadHeader(header *enginev1.SignedExecutionPayloadHeader) {
-	c.Lock()
-	defer c.Unlock()
-
-	for s := range c.headers {
-		if s+1 < header.Message.Slot {
-			delete(c.headers, s)
-		}
-	}
-
-	// Add or update the header in the map
-	if _, ok := c.headers[header.Message.Slot]; !ok {
-		c.headers[header.Message.Slot] = []*enginev1.SignedExecutionPayloadHeader{header}
-	} else {
-		found := false
-		for i, h := range c.headers[header.Message.Slot] {
-			if bytes.Equal(h.Message.ParentBlockHash, header.Message.ParentBlockHash) && bytes.Equal(h.Message.ParentBlockRoot, header.Message.ParentBlockRoot) {
-				if header.Message.Value > h.Message.Value {
-					c.headers[header.Message.Slot][i] = header
-				}
-				found = true
-				break
-			}
-		}
-		if !found {
-			c.headers[header.Message.Slot] = append(c.headers[header.Message.Slot], header)
-		}
-	}
-}
-
-// SignedExecutionPayloadHeader returns the signed payload header for the given slot and parent block hash and block root.
-// Returns nil if the header is not found.
-// This should be used when the caller wants the header to match parent block hash and parent block root such as proposer choosing a header to propose.
-func (c *ExecutionPayloadHeaders) SignedExecutionPayloadHeader(slot primitives.Slot, parentBlockHash []byte, parentBlockRoot []byte) *enginev1.SignedExecutionPayloadHeader {
-	c.RLock()
-	defer c.RUnlock()
-
-	if headers, ok := c.headers[slot]; ok {
-		for _, header := range headers {
-			if bytes.Equal(header.Message.ParentBlockHash, parentBlockHash) && bytes.Equal(header.Message.ParentBlockRoot, parentBlockRoot) {
-				return header
-			}
-		}
-	}
-
-	return nil
-}

beacon-chain/cache/signed_execution_header_test.go

@@ -1,243 +0,0 @@
-package cache
-
-import (
-	"testing"
-
-	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-)
-
-func Test_SaveSignedExecutionPayloadHeader(t *testing.T) {
-	t.Run("First header should be added to cache", func(t *testing.T) {
-		c := NewExecutionPayloadHeaders()
-		header := &enginev1.SignedExecutionPayloadHeader{
-			Message: &enginev1.ExecutionPayloadHeaderEPBS{
-				Slot:            1,
-				ParentBlockHash: []byte("parent1"),
-				Value:           100,
-			},
-		}
-		c.SaveSignedExecutionPayloadHeader(header)
-		require.Equal(t, 1, len(c.headers))
-		require.Equal(t, header, c.headers[1][0])
-	})
-
-	t.Run("Second header with higher slot should be added, and both slots should be in cache", func(t *testing.T) {
-		c := NewExecutionPayloadHeaders()
-		header1 := &enginev1.SignedExecutionPayloadHeader{
-			Message: &enginev1.ExecutionPayloadHeaderEPBS{
-				Slot:            1,
-				ParentBlockHash: []byte("parent1"),
-				Value:           100,
-			},
-		}
-		header2 := &enginev1.SignedExecutionPayloadHeader{
-			Message: &enginev1.ExecutionPayloadHeaderEPBS{
-				Slot:            2,
-				ParentBlockHash: []byte("parent2"),
-				Value:           100,
-			},
-		}
-		c.SaveSignedExecutionPayloadHeader(header1)
-		c.SaveSignedExecutionPayloadHeader(header2)
-		require.Equal(t, 2, len(c.headers))
-		require.Equal(t, header1, c.headers[1][0])
-		require.Equal(t, header2, c.headers[2][0])
-	})
-
-	t.Run("Third header with higher slot should replace the oldest slot", func(t *testing.T) {
-		c := NewExecutionPayloadHeaders()
-		header1 := &enginev1.SignedExecutionPayloadHeader{
-			Message: &enginev1.ExecutionPayloadHeaderEPBS{
-				Slot:            1,
-				ParentBlockHash: []byte("parent1"),
-				Value:           100,
-			},
-		}
-		header2 := &enginev1.SignedExecutionPayloadHeader{
-			Message: &enginev1.ExecutionPayloadHeaderEPBS{
-				Slot:            2,
-				ParentBlockHash: []byte("parent2"),
-				Value:           100,
-			},
-		}
-		header3 := &enginev1.SignedExecutionPayloadHeader{
-			Message: &enginev1.ExecutionPayloadHeaderEPBS{
-				Slot:            3,
-				ParentBlockHash: []byte("parent3"),
-				Value:           100,
-			},
-		}
-		c.SaveSignedExecutionPayloadHeader(header1)
-		c.SaveSignedExecutionPayloadHeader(header2)
-		c.SaveSignedExecutionPayloadHeader(header3)
-		require.Equal(t, 2, len(c.headers))
-		require.Equal(t, header2, c.headers[2][0])
-		require.Equal(t, header3, c.headers[3][0])
-	})
-
-	t.Run("Header with same slot but higher value should replace the existing one", func(t *testing.T) {
-		c := NewExecutionPayloadHeaders()
-		header1 := &enginev1.SignedExecutionPayloadHeader{
-			Message: &enginev1.ExecutionPayloadHeaderEPBS{
-				Slot:            2,
-				ParentBlockHash: []byte("parent2"),
-				Value:           100,
-			},
-		}
-		header2 := &enginev1.SignedExecutionPayloadHeader{
-			Message: &enginev1.ExecutionPayloadHeaderEPBS{
-				Slot:            2,
-				ParentBlockHash: []byte("parent2"),
-				Value:           200,
-			},
-		}
-		c.SaveSignedExecutionPayloadHeader(header1)
-		c.SaveSignedExecutionPayloadHeader(header2)
-		require.Equal(t, 1, len(c.headers[2]))
-		require.Equal(t, header2, c.headers[2][0])
-	})
-
-	t.Run("Header with different parent block hash should be appended to the same slot", func(t *testing.T) {
-		c := NewExecutionPayloadHeaders()
-		header1 := &enginev1.SignedExecutionPayloadHeader{
-			Message: &enginev1.ExecutionPayloadHeaderEPBS{
-				Slot:            2,
-				ParentBlockHash: []byte("parent1"),
-				Value:           100,
-			},
-		}
-		header2 := &enginev1.SignedExecutionPayloadHeader{
-			Message: &enginev1.ExecutionPayloadHeaderEPBS{
-				Slot:            2,
-				ParentBlockHash: []byte("parent2"),
-				Value:           200,
-			},
-		}
-		c.SaveSignedExecutionPayloadHeader(header1)
-		c.SaveSignedExecutionPayloadHeader(header2)
-		require.Equal(t, 2, len(c.headers[2]))
-		require.Equal(t, header1, c.headers[2][0])
-		require.Equal(t, header2, c.headers[2][1])
-	})
-}
-
-func TestSignedExecutionPayloadHeader(t *testing.T) {
-	t.Run("Return header when slot and parentBlockHash match", func(t *testing.T) {
-		c := NewExecutionPayloadHeaders()
-		header := &enginev1.SignedExecutionPayloadHeader{
-			Message: &enginev1.ExecutionPayloadHeaderEPBS{
-				Slot:            1,
-				ParentBlockHash: []byte("parent1"),
-				ParentBlockRoot: []byte("root1"),
-				Value:           100,
-			},
-		}
-		c.SaveSignedExecutionPayloadHeader(header)
-		result := c.SignedExecutionPayloadHeader(1, []byte("parent1"), []byte("root1"))
-		require.NotNil(t, result)
-		require.Equal(t, header, result)
-	})
-
-	t.Run("Return nil when no matching slot and parentBlockHash", func(t *testing.T) {
-		c := NewExecutionPayloadHeaders()
-		header := &enginev1.SignedExecutionPayloadHeader{
-			Message: &enginev1.ExecutionPayloadHeaderEPBS{
-				Slot:            1,
-				ParentBlockHash: []byte("parent1"),
-				ParentBlockRoot: []byte("root1"),
-				Value:           100,
-			},
-		}
-		c.SaveSignedExecutionPayloadHeader(header)
-		result := c.SignedExecutionPayloadHeader(2, []byte("parent2"), []byte("root1"))
-		require.IsNil(t, result)
-	})
-
-	t.Run("Return nil when no matching slot and parentBlockRoot", func(t *testing.T) {
-		c := NewExecutionPayloadHeaders()
-		header := &enginev1.SignedExecutionPayloadHeader{
-			Message: &enginev1.ExecutionPayloadHeaderEPBS{
-				Slot:            1,
-				ParentBlockHash: []byte("parent1"),
-				ParentBlockRoot: []byte("root1"),
-				Value:           100,
-			},
-		}
-		c.SaveSignedExecutionPayloadHeader(header)
-		result := c.SignedExecutionPayloadHeader(2, []byte("parent1"), []byte("root2"))
-		require.IsNil(t, result)
-	})
-
-	t.Run("Return header when there are two slots in the cache and a match is found", func(t *testing.T) {
-		c := NewExecutionPayloadHeaders()
-		header1 := &enginev1.SignedExecutionPayloadHeader{
-			Message: &enginev1.ExecutionPayloadHeaderEPBS{
-				Slot:            1,
-				ParentBlockHash: []byte("parent1"),
-				Value:           100,
-			},
-		}
-		header2 := &enginev1.SignedExecutionPayloadHeader{
-			Message: &enginev1.ExecutionPayloadHeaderEPBS{
-				Slot:            2,
-				ParentBlockHash: []byte("parent2"),
-				Value:           200,
-			},
-		}
-		c.SaveSignedExecutionPayloadHeader(header1)
-		c.SaveSignedExecutionPayloadHeader(header2)
-
-		// Check for the first header
-		result1 := c.SignedExecutionPayloadHeader(1, []byte("parent1"), []byte{})
-		require.NotNil(t, result1)
-		require.Equal(t, header1, result1)
-
-		// Check for the second header
-		result2 := c.SignedExecutionPayloadHeader(2, []byte("parent2"), []byte{})
-		require.NotNil(t, result2)
-		require.Equal(t, header2, result2)
-	})
-
-	t.Run("Return nil when slot is evicted from cache", func(t *testing.T) {
-		c := NewExecutionPayloadHeaders()
-		header1 := &enginev1.SignedExecutionPayloadHeader{
-			Message: &enginev1.ExecutionPayloadHeaderEPBS{
-				Slot:            1,
-				ParentBlockHash: []byte("parent1"),
-				Value:           100,
-			},
-		}
-		header2 := &enginev1.SignedExecutionPayloadHeader{
-			Message: &enginev1.ExecutionPayloadHeaderEPBS{
-				Slot:            2,
-				ParentBlockHash: []byte("parent2"),
-				Value:           200,
-			},
-		}
-		header3 := &enginev1.SignedExecutionPayloadHeader{
-			Message: &enginev1.ExecutionPayloadHeaderEPBS{
-				Slot:            3,
-				ParentBlockHash: []byte("parent3"),
-				Value:           300,
-			},
-		}
-		c.SaveSignedExecutionPayloadHeader(header1)
-		c.SaveSignedExecutionPayloadHeader(header2)
-		c.SaveSignedExecutionPayloadHeader(header3)
-
-		// The first slot should be evicted, so result should be nil
-		result := c.SignedExecutionPayloadHeader(1, []byte("parent1"), []byte{})
-		require.IsNil(t, result)
-
-		// The second slot should still be present
-		result = c.SignedExecutionPayloadHeader(2, []byte("parent2"), []byte{})
-		require.NotNil(t, result)
-		require.Equal(t, header2, result)
-
-		// The third slot should be present
-		result = c.SignedExecutionPayloadHeader(3, []byte("parent3"), []byte{})
-		require.NotNil(t, result)
-		require.Equal(t, header3, result)
-	})
-}

beacon-chain/core/blocks/BUILD.bazel

@@ -41,7 +41,6 @@ go_library(
         "//encoding/ssz:go_default_library",
         "//math:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
-        "//network/forks:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",

beacon-chain/core/blocks/genesis.go

@@ -11,7 +11,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v6/encoding/ssz"
 	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/pkg/errors"
@@ -223,42 +222,6 @@ func NewGenesisBlockForState(ctx context.Context, st state.BeaconState) (interfa
 			},
 			Signature: params.BeaconConfig().EmptySignature[:],
 		})
-	case *ethpb.BeaconStateEPBS:
-		kzgs := make([][]byte, 0)
-		kzgRoot, err := ssz.KzgCommitmentsRoot(kzgs)
-		if err != nil {
-			return nil, err
-		}
-		return blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockEpbs{
-			Block: &ethpb.BeaconBlockEpbs{
-				ParentRoot: params.BeaconConfig().ZeroHash[:],
-				StateRoot:  root[:],
-				Body: &ethpb.BeaconBlockBodyEpbs{
-					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),
-					},
-					SignedExecutionPayloadHeader: &enginev1.SignedExecutionPayloadHeader{
-						Message: &enginev1.ExecutionPayloadHeaderEPBS{
-							ParentBlockHash:        make([]byte, 32),
-							ParentBlockRoot:        make([]byte, 32),
-							BlockHash:              make([]byte, 32),
-							BlobKzgCommitmentsRoot: kzgRoot[:],
-						},
-						Signature: make([]byte, 96),
-					},
-					BlsToExecutionChanges: make([]*ethpb.SignedBLSToExecutionChange, 0),
-					PayloadAttestations:   make([]*ethpb.PayloadAttestation, 0),
-				},
-			},
-			Signature: params.BeaconConfig().EmptySignature[:],
-		})
 	default:
 		return nil, ErrUnrecognizedState
 	}

beacon-chain/core/blocks/payload.go

@@ -58,9 +58,6 @@ func IsMergeTransitionComplete(st state.BeaconState) (bool, error) {
 //
 //	return block.body.execution_payload != ExecutionPayload()
 func IsExecutionBlock(body interfaces.ReadOnlyBeaconBlockBody) (bool, error) {
-	if body.Version() >= version.Capella {
-		return true, nil
-	}
 	if body == nil {
 		return false, errors.New("nil block body")
 	}
@@ -96,9 +93,6 @@ func IsExecutionEnabled(st state.BeaconState, body interfaces.ReadOnlyBeaconBloc
 	if IsPreBellatrixVersion(st.Version()) {
 		return false, nil
 	}
-	if body.Version() >= version.Capella {
-		return true, nil
-	}
 	header, err := st.LatestExecutionPayloadHeader()
 	if err != nil {
 		return false, err

beacon-chain/core/blocks/signature.go

@@ -11,7 +11,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/crypto/bls"
-	"github.com/OffchainLabs/prysm/v6/network/forks"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1/attestation"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
@@ -101,7 +100,7 @@ func VerifyBlockHeaderSignature(beaconState state.BeaconState, header *ethpb.Sig
 // via the respective epoch.
 func VerifyBlockSignatureUsingCurrentFork(beaconState state.ReadOnlyBeaconState, blk interfaces.ReadOnlySignedBeaconBlock, blkRoot [32]byte) error {
 	currentEpoch := slots.ToEpoch(blk.Block().Slot())
-	fork, err := forks.Fork(currentEpoch)
+	fork, err := params.Fork(currentEpoch)
 	if err != nil {
 		return err
 	}

beacon-chain/core/blocks/withdrawals.go

@@ -13,8 +13,8 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/crypto/bls"
 	"github.com/OffchainLabs/prysm/v6/crypto/hash"
+	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v6/encoding/ssz"
-	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
 	"github.com/pkg/errors"
@@ -118,97 +118,14 @@ func ValidateBLSToExecutionChange(st state.ReadOnlyBeaconState, signed *ethpb.Si
 	return val, nil
 }
 
-func checkWithdrawalsAgainstPayload(
-	executionData interfaces.ExecutionData,
-	numExpected int,
-	expectedRoot [32]byte,
-) error {
-	var wdRoot [32]byte
-	if executionData.IsBlinded() {
-		r, err := executionData.WithdrawalsRoot()
-		if err != nil {
-			return errors.Wrap(err, "could not get withdrawals root")
-		}
-		copy(wdRoot[:], r)
-	} else {
-		wds, err := executionData.Withdrawals()
-		if err != nil {
-			return errors.Wrap(err, "could not get withdrawals")
-		}
-
-		if len(wds) != numExpected {
-			return fmt.Errorf("execution payload header has %d withdrawals when %d were expected", len(wds), numExpected)
-		}
-
-		wdRoot, err = ssz.WithdrawalSliceRoot(wds, fieldparams.MaxWithdrawalsPerPayload)
-		if err != nil {
-			return errors.Wrap(err, "could not get withdrawals root")
-		}
-	}
-	if expectedRoot != wdRoot {
-		return fmt.Errorf("expected withdrawals root %#x, got %#x", expectedRoot, wdRoot)
-	}
-	return nil
-}
-
-func processWithdrawalStateTransition(
-	st state.BeaconState,
-	expectedWithdrawals []*enginev1.Withdrawal,
-	partialWithdrawalsCount uint64,
-) (err error) {
-	for _, withdrawal := range expectedWithdrawals {
-		err := helpers.DecreaseBalance(st, withdrawal.ValidatorIndex, withdrawal.Amount)
-		if err != nil {
-			return errors.Wrap(err, "could not decrease balance")
-		}
-	}
-	if st.Version() >= version.Electra {
-		if err := st.DequeuePendingPartialWithdrawals(partialWithdrawalsCount); err != nil {
-			return fmt.Errorf("unable to dequeue partial withdrawals from state: %w", err)
-		}
-	}
-
-	if len(expectedWithdrawals) > 0 {
-		if err := st.SetNextWithdrawalIndex(expectedWithdrawals[len(expectedWithdrawals)-1].Index + 1); err != nil {
-			return errors.Wrap(err, "could not set next withdrawal index")
-		}
-	}
-	var nextValidatorIndex primitives.ValidatorIndex
-	if uint64(len(expectedWithdrawals)) < params.BeaconConfig().MaxWithdrawalsPerPayload {
-		nextValidatorIndex, err = st.NextWithdrawalValidatorIndex()
-		if err != nil {
-			return errors.Wrap(err, "could not get next withdrawal validator index")
-		}
-		nextValidatorIndex += primitives.ValidatorIndex(params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep)
-		nextValidatorIndex = nextValidatorIndex % primitives.ValidatorIndex(st.NumValidators())
-	} else {
-		nextValidatorIndex = expectedWithdrawals[len(expectedWithdrawals)-1].ValidatorIndex + 1
-		if nextValidatorIndex == primitives.ValidatorIndex(st.NumValidators()) {
-			nextValidatorIndex = 0
-		}
-	}
-	if err := st.SetNextWithdrawalValidatorIndex(nextValidatorIndex); err != nil {
-		return errors.Wrap(err, "could not set next withdrawal validator index")
-	}
-	return nil
-}
-
 // ProcessWithdrawals processes the validator withdrawals from the provided execution payload
 // into the beacon state.
 //
 // Spec pseudocode definition:
 //
-//	def process_withdrawals(state: BeaconState, payload: ExecutionPayload) -> None:
-//		if state.fork.current_version >= EIP7732_FORK_VERSION :
-//			if not is_parent_block_full(state): # [New in EIP-7732]
-//		 		return
+// def process_withdrawals(state: BeaconState, payload: ExecutionPayload) -> None:
 //
-//	    expected_withdrawals, partial_withdrawals_count = get_expected_withdrawals(state)  # [Modified in Electra:EIP7251]
-//
-//		if state.fork.current_version >= EIP7732_FORK_VERSION :
-//			state.latest_withdrawals_root = hash_tree_root(expected_withdrawals) # [New in EIP-7732]
-//		else :
-//	    	assert len(payload.withdrawals) == len(expected_withdrawals)
+//	expected_withdrawals, processed_partial_withdrawals_count = get_expected_withdrawals(state) # [Modified in Electra:EIP7251]
 //
 //	assert len(payload.withdrawals) == len(expected_withdrawals)
 //
@@ -235,39 +152,76 @@ func processWithdrawalStateTransition(
 //	    next_validator_index = ValidatorIndex(next_index % len(state.validators))
 //	    state.next_withdrawal_validator_index = next_validator_index
 func ProcessWithdrawals(st state.BeaconState, executionData interfaces.ExecutionData) (state.BeaconState, error) {
-	if st.Version() >= version.EPBS {
-		IsParentBlockFull, err := st.IsParentBlockFull()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not check if parent block is full")
-		}
-
-		if !IsParentBlockFull {
-			return st, nil
-		}
-	}
-
-	expectedWithdrawals, partialWithdrawalsCount, err := st.ExpectedWithdrawals()
+	expectedWithdrawals, processedPartialWithdrawalsCount, err := st.ExpectedWithdrawals()
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get expected withdrawals")
 	}
 
+	var wdRoot [32]byte
+	if executionData.IsBlinded() {
+		r, err := executionData.WithdrawalsRoot()
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get withdrawals root")
+		}
+		wdRoot = bytesutil.ToBytes32(r)
+	} else {
+		wds, err := executionData.Withdrawals()
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get withdrawals")
+		}
+
+		if len(wds) != len(expectedWithdrawals) {
+			return nil, fmt.Errorf("execution payload header has %d withdrawals when %d were expected", len(wds), len(expectedWithdrawals))
+		}
+
+		wdRoot, err = ssz.WithdrawalSliceRoot(wds, fieldparams.MaxWithdrawalsPerPayload)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get withdrawals root")
+		}
+	}
+
 	expectedRoot, err := ssz.WithdrawalSliceRoot(expectedWithdrawals, fieldparams.MaxWithdrawalsPerPayload)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get expected withdrawals root")
 	}
+	if expectedRoot != wdRoot {
+		return nil, fmt.Errorf("expected withdrawals root %#x, got %#x", expectedRoot, wdRoot)
+	}
 
-	if st.Version() >= version.EPBS {
-		err = st.SetLastWithdrawalsRoot(expectedRoot[:])
+	for _, withdrawal := range expectedWithdrawals {
+		err := helpers.DecreaseBalance(st, withdrawal.ValidatorIndex, withdrawal.Amount)
 		if err != nil {
-			return nil, errors.Wrap(err, "could not set withdrawals root")
-		}
-	} else {
-		if err := checkWithdrawalsAgainstPayload(executionData, len(expectedWithdrawals), expectedRoot); err != nil {
-			return nil, err
+			return nil, errors.Wrap(err, "could not decrease balance")
 		}
 	}
-	if err := processWithdrawalStateTransition(st, expectedWithdrawals, partialWithdrawalsCount); err != nil {
-		return nil, err
+
+	if st.Version() >= version.Electra {
+		if err := st.DequeuePendingPartialWithdrawals(processedPartialWithdrawalsCount); err != nil {
+			return nil, fmt.Errorf("unable to dequeue partial withdrawals from state: %w", err)
+		}
+	}
+
+	if len(expectedWithdrawals) > 0 {
+		if err := st.SetNextWithdrawalIndex(expectedWithdrawals[len(expectedWithdrawals)-1].Index + 1); err != nil {
+			return nil, errors.Wrap(err, "could not set next withdrawal index")
+		}
+	}
+	var nextValidatorIndex primitives.ValidatorIndex
+	if uint64(len(expectedWithdrawals)) < params.BeaconConfig().MaxWithdrawalsPerPayload {
+		nextValidatorIndex, err = st.NextWithdrawalValidatorIndex()
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get next withdrawal validator index")
+		}
+		nextValidatorIndex += primitives.ValidatorIndex(params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep)
+		nextValidatorIndex = nextValidatorIndex % primitives.ValidatorIndex(st.NumValidators())
+	} else {
+		nextValidatorIndex = expectedWithdrawals[len(expectedWithdrawals)-1].ValidatorIndex + 1
+		if nextValidatorIndex == primitives.ValidatorIndex(st.NumValidators()) {
+			nextValidatorIndex = 0
+		}
+	}
+	if err := st.SetNextWithdrawalValidatorIndex(nextValidatorIndex); err != nil {
+		return nil, errors.Wrap(err, "could not set next withdrawal validator index")
 	}
 	return st, nil
 }

beacon-chain/core/blocks/withdrawals_test.go

@@ -1167,407 +1167,13 @@ func TestProcessWithdrawals(t *testing.T) {
 						checkPostState(t, test.Control, post)
 					}
 					params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep = saved
+
 				})
 			}
 		})
 	}
 }
 
-func TestProcessWithdrawalsEPBS(t *testing.T) {
-	const (
-		currentEpoch             = primitives.Epoch(10)
-		epochInFuture            = primitives.Epoch(12)
-		epochInPast              = primitives.Epoch(8)
-		numValidators            = 128
-		notWithdrawableIndex     = 127
-		notPartiallyWithdrawable = 126
-		maxSweep                 = uint64(80)
-	)
-	maxEffectiveBalance := params.BeaconConfig().MaxEffectiveBalance
-
-	type args struct {
-		Name                            string
-		NextWithdrawalValidatorIndex    primitives.ValidatorIndex
-		NextWithdrawalIndex             uint64
-		FullWithdrawalIndices           []primitives.ValidatorIndex
-		PendingPartialWithdrawalIndices []primitives.ValidatorIndex
-		Withdrawals                     []*enginev1.Withdrawal
-		PendingPartialWithdrawals       []*ethpb.PendingPartialWithdrawal // Electra
-		LatestBlockHash                 []byte                            // EIP-7732
-	}
-	type control struct {
-		NextWithdrawalValidatorIndex primitives.ValidatorIndex
-		NextWithdrawalIndex          uint64
-		Balances                     map[uint64]uint64
-	}
-	type Test struct {
-		Args    args
-		Control control
-	}
-	executionAddress := func(i primitives.ValidatorIndex) []byte {
-		wc := make([]byte, 20)
-		wc[19] = byte(i)
-		return wc
-	}
-	withdrawalAmount := func(i primitives.ValidatorIndex) uint64 {
-		return maxEffectiveBalance + uint64(i)*100000
-	}
-	fullWithdrawal := func(i primitives.ValidatorIndex, idx uint64) *enginev1.Withdrawal {
-		return &enginev1.Withdrawal{
-			Index:          idx,
-			ValidatorIndex: i,
-			Address:        executionAddress(i),
-			Amount:         withdrawalAmount(i),
-		}
-	}
-	PendingPartialWithdrawal := func(i primitives.ValidatorIndex, idx uint64) *enginev1.Withdrawal {
-		return &enginev1.Withdrawal{
-			Index:          idx,
-			ValidatorIndex: i,
-			Address:        executionAddress(i),
-			Amount:         withdrawalAmount(i) - maxEffectiveBalance,
-		}
-	}
-	tests := []Test{
-		{
-			Args: args{
-				Name:                         "success no withdrawals",
-				NextWithdrawalValidatorIndex: 10,
-				NextWithdrawalIndex:          3,
-			},
-			Control: control{
-				NextWithdrawalValidatorIndex: 90,
-				NextWithdrawalIndex:          3,
-			},
-		},
-		{
-			Args: args{
-				Name:                         "success one full withdrawal",
-				NextWithdrawalIndex:          3,
-				NextWithdrawalValidatorIndex: 5,
-				FullWithdrawalIndices:        []primitives.ValidatorIndex{70},
-				Withdrawals: []*enginev1.Withdrawal{
-					fullWithdrawal(70, 3),
-				},
-			},
-			Control: control{
-				NextWithdrawalValidatorIndex: 85,
-				NextWithdrawalIndex:          4,
-				Balances:                     map[uint64]uint64{70: 0},
-			},
-		},
-		{
-			Args: args{
-				Name:                            "success one partial withdrawal",
-				NextWithdrawalIndex:             21,
-				NextWithdrawalValidatorIndex:    120,
-				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{7},
-				Withdrawals: []*enginev1.Withdrawal{
-					PendingPartialWithdrawal(7, 21),
-				},
-			},
-			Control: control{
-				NextWithdrawalValidatorIndex: 72,
-				NextWithdrawalIndex:          22,
-				Balances:                     map[uint64]uint64{7: maxEffectiveBalance},
-			},
-		},
-		{
-			Args: args{
-				Name:                         "success many full withdrawals",
-				NextWithdrawalIndex:          22,
-				NextWithdrawalValidatorIndex: 4,
-				FullWithdrawalIndices:        []primitives.ValidatorIndex{7, 19, 28, 1},
-				Withdrawals: []*enginev1.Withdrawal{
-					fullWithdrawal(7, 22), fullWithdrawal(19, 23), fullWithdrawal(28, 24),
-				},
-			},
-			Control: control{
-				NextWithdrawalValidatorIndex: 84,
-				NextWithdrawalIndex:          25,
-				Balances:                     map[uint64]uint64{7: 0, 19: 0, 28: 0},
-			},
-		},
-		{
-			Args: args{
-				Name:                         "less than max sweep at end",
-				NextWithdrawalIndex:          22,
-				NextWithdrawalValidatorIndex: 4,
-				FullWithdrawalIndices:        []primitives.ValidatorIndex{80, 81, 82, 83},
-				Withdrawals: []*enginev1.Withdrawal{
-					fullWithdrawal(80, 22), fullWithdrawal(81, 23), fullWithdrawal(82, 24),
-					fullWithdrawal(83, 25),
-				},
-			},
-			Control: control{
-				NextWithdrawalValidatorIndex: 84,
-				NextWithdrawalIndex:          26,
-				Balances:                     map[uint64]uint64{80: 0, 81: 0, 82: 0, 83: 0},
-			},
-		},
-		{
-			Args: args{
-				Name:                         "less than max sweep and beginning",
-				NextWithdrawalIndex:          22,
-				NextWithdrawalValidatorIndex: 4,
-				FullWithdrawalIndices:        []primitives.ValidatorIndex{4, 5, 6},
-				Withdrawals: []*enginev1.Withdrawal{
-					fullWithdrawal(4, 22), fullWithdrawal(5, 23), fullWithdrawal(6, 24),
-				},
-			},
-			Control: control{
-				NextWithdrawalValidatorIndex: 84,
-				NextWithdrawalIndex:          25,
-				Balances:                     map[uint64]uint64{4: 0, 5: 0, 6: 0},
-			},
-		},
-		{
-			Args: args{
-				Name:                            "success many partial withdrawals",
-				NextWithdrawalIndex:             22,
-				NextWithdrawalValidatorIndex:    4,
-				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{7, 19, 28},
-				Withdrawals: []*enginev1.Withdrawal{
-					PendingPartialWithdrawal(7, 22), PendingPartialWithdrawal(19, 23), PendingPartialWithdrawal(28, 24),
-				},
-			},
-			Control: control{
-				NextWithdrawalValidatorIndex: 84,
-				NextWithdrawalIndex:          25,
-				Balances: map[uint64]uint64{
-					7:  maxEffectiveBalance,
-					19: maxEffectiveBalance,
-					28: maxEffectiveBalance,
-				},
-			},
-		},
-		{
-			Args: args{
-				Name:                            "success many withdrawals",
-				NextWithdrawalIndex:             22,
-				NextWithdrawalValidatorIndex:    88,
-				FullWithdrawalIndices:           []primitives.ValidatorIndex{7, 19, 28},
-				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{2, 1, 89, 15},
-				Withdrawals: []*enginev1.Withdrawal{
-					PendingPartialWithdrawal(89, 22), PendingPartialWithdrawal(1, 23), PendingPartialWithdrawal(2, 24),
-					fullWithdrawal(7, 25), PendingPartialWithdrawal(15, 26), fullWithdrawal(19, 27),
-					fullWithdrawal(28, 28),
-				},
-			},
-			Control: control{
-				NextWithdrawalValidatorIndex: 40,
-				NextWithdrawalIndex:          29,
-				Balances: map[uint64]uint64{
-					7: 0, 19: 0, 28: 0,
-					2: maxEffectiveBalance, 1: maxEffectiveBalance, 89: maxEffectiveBalance,
-					15: maxEffectiveBalance,
-				},
-			},
-		},
-		{
-			Args: args{
-				Name:                            "success many withdrawals with pending partial withdrawals in state",
-				NextWithdrawalIndex:             22,
-				NextWithdrawalValidatorIndex:    88,
-				FullWithdrawalIndices:           []primitives.ValidatorIndex{7, 19, 28},
-				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{2, 1, 89, 15},
-				Withdrawals: []*enginev1.Withdrawal{
-					PendingPartialWithdrawal(89, 22), PendingPartialWithdrawal(1, 23), PendingPartialWithdrawal(2, 24),
-					fullWithdrawal(7, 25), PendingPartialWithdrawal(15, 26), fullWithdrawal(19, 27),
-					fullWithdrawal(28, 28),
-				},
-				PendingPartialWithdrawals: []*ethpb.PendingPartialWithdrawal{
-					{
-						Index:  11,
-						Amount: withdrawalAmount(11) - maxEffectiveBalance,
-					},
-				},
-			},
-			Control: control{
-				NextWithdrawalValidatorIndex: 40,
-				NextWithdrawalIndex:          29,
-				Balances: map[uint64]uint64{
-					7: 0, 19: 0, 28: 0,
-					2: maxEffectiveBalance, 1: maxEffectiveBalance, 89: maxEffectiveBalance,
-					15: maxEffectiveBalance,
-				},
-			},
-		},
-
-		{
-			Args: args{
-				Name:                         "success more than max fully withdrawals",
-				NextWithdrawalIndex:          22,
-				NextWithdrawalValidatorIndex: 0,
-				FullWithdrawalIndices:        []primitives.ValidatorIndex{1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 22, 23, 24, 25, 26, 27, 29, 35, 89},
-				Withdrawals: []*enginev1.Withdrawal{
-					fullWithdrawal(1, 22), fullWithdrawal(2, 23), fullWithdrawal(3, 24),
-					fullWithdrawal(4, 25), fullWithdrawal(5, 26), fullWithdrawal(6, 27),
-					fullWithdrawal(7, 28), fullWithdrawal(8, 29), fullWithdrawal(9, 30),
-					fullWithdrawal(21, 31), fullWithdrawal(22, 32), fullWithdrawal(23, 33),
-					fullWithdrawal(24, 34), fullWithdrawal(25, 35), fullWithdrawal(26, 36),
-					fullWithdrawal(27, 37),
-				},
-			},
-			Control: control{
-				NextWithdrawalValidatorIndex: 28,
-				NextWithdrawalIndex:          38,
-				Balances: map[uint64]uint64{
-					1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0,
-					21: 0, 22: 0, 23: 0, 24: 0, 25: 0, 26: 0, 27: 0,
-				},
-			},
-		},
-		{
-			Args: args{
-				Name:                            "success more than max partially withdrawals",
-				NextWithdrawalIndex:             22,
-				NextWithdrawalValidatorIndex:    0,
-				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 22, 23, 24, 25, 26, 27, 29, 35, 89},
-				Withdrawals: []*enginev1.Withdrawal{
-					PendingPartialWithdrawal(1, 22), PendingPartialWithdrawal(2, 23), PendingPartialWithdrawal(3, 24),
-					PendingPartialWithdrawal(4, 25), PendingPartialWithdrawal(5, 26), PendingPartialWithdrawal(6, 27),
-					PendingPartialWithdrawal(7, 28), PendingPartialWithdrawal(8, 29), PendingPartialWithdrawal(9, 30),
-					PendingPartialWithdrawal(21, 31), PendingPartialWithdrawal(22, 32), PendingPartialWithdrawal(23, 33),
-					PendingPartialWithdrawal(24, 34), PendingPartialWithdrawal(25, 35), PendingPartialWithdrawal(26, 36),
-					PendingPartialWithdrawal(27, 37),
-				},
-			},
-			Control: control{
-				NextWithdrawalValidatorIndex: 28,
-				NextWithdrawalIndex:          38,
-				Balances: map[uint64]uint64{
-					1:  maxEffectiveBalance,
-					2:  maxEffectiveBalance,
-					3:  maxEffectiveBalance,
-					4:  maxEffectiveBalance,
-					5:  maxEffectiveBalance,
-					6:  maxEffectiveBalance,
-					7:  maxEffectiveBalance,
-					8:  maxEffectiveBalance,
-					9:  maxEffectiveBalance,
-					21: maxEffectiveBalance,
-					22: maxEffectiveBalance,
-					23: maxEffectiveBalance,
-					24: maxEffectiveBalance,
-					25: maxEffectiveBalance,
-					26: maxEffectiveBalance,
-					27: maxEffectiveBalance,
-				},
-			},
-		},
-		{
-			Args: args{
-				Name:                         "Parent Node is not full",
-				NextWithdrawalIndex:          22,
-				NextWithdrawalValidatorIndex: 4,
-				FullWithdrawalIndices:        []primitives.ValidatorIndex{7, 19, 28, 1},
-				Withdrawals: []*enginev1.Withdrawal{
-					fullWithdrawal(7, 22), fullWithdrawal(19, 23), fullWithdrawal(28, 24),
-				},
-				LatestBlockHash: []byte{1, 2, 3},
-			},
-		},
-	}
-
-	checkPostState := func(t *testing.T, expected control, st state.BeaconState) {
-		l, err := st.NextWithdrawalValidatorIndex()
-		require.NoError(t, err)
-		require.Equal(t, expected.NextWithdrawalValidatorIndex, l)
-
-		n, err := st.NextWithdrawalIndex()
-		require.NoError(t, err)
-		require.Equal(t, expected.NextWithdrawalIndex, n)
-		balances := st.Balances()
-		for idx, bal := range expected.Balances {
-			require.Equal(t, bal, balances[idx])
-		}
-	}
-
-	prepareValidators := func(st state.BeaconState, arguments args) error {
-		validators := make([]*ethpb.Validator, numValidators)
-		if err := st.SetBalances(make([]uint64, numValidators)); err != nil {
-			return err
-		}
-		for i := range validators {
-			v := &ethpb.Validator{}
-			v.EffectiveBalance = maxEffectiveBalance
-			v.WithdrawableEpoch = epochInFuture
-			v.WithdrawalCredentials = make([]byte, 32)
-			v.WithdrawalCredentials[31] = byte(i)
-			if err := st.UpdateBalancesAtIndex(primitives.ValidatorIndex(i), v.EffectiveBalance-uint64(rand.Intn(1000))); err != nil {
-				return err
-			}
-			validators[i] = v
-		}
-		for _, idx := range arguments.FullWithdrawalIndices {
-			if idx != notWithdrawableIndex {
-				validators[idx].WithdrawableEpoch = epochInPast
-			}
-			if err := st.UpdateBalancesAtIndex(idx, withdrawalAmount(idx)); err != nil {
-				return err
-			}
-			validators[idx].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
-		}
-		for _, idx := range arguments.PendingPartialWithdrawalIndices {
-			validators[idx].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
-			if err := st.UpdateBalancesAtIndex(idx, withdrawalAmount(idx)); err != nil {
-				return err
-			}
-		}
-		return st.SetValidators(validators)
-	}
-
-	for _, test := range tests {
-		t.Run(test.Args.Name, func(t *testing.T) {
-			saved := params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep
-			params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep = maxSweep
-			if test.Args.Withdrawals == nil {
-				test.Args.Withdrawals = make([]*enginev1.Withdrawal, 0)
-			}
-			if test.Args.FullWithdrawalIndices == nil {
-				test.Args.FullWithdrawalIndices = make([]primitives.ValidatorIndex, 0)
-			}
-			if test.Args.PendingPartialWithdrawalIndices == nil {
-				test.Args.PendingPartialWithdrawalIndices = make([]primitives.ValidatorIndex, 0)
-			}
-			slot, err := slots.EpochStart(currentEpoch)
-			require.NoError(t, err)
-			var st state.BeaconState
-			var p interfaces.ExecutionData
-			spb := &ethpb.BeaconStateEPBS{
-				Slot:                         slot,
-				NextWithdrawalValidatorIndex: test.Args.NextWithdrawalValidatorIndex,
-				NextWithdrawalIndex:          test.Args.NextWithdrawalIndex,
-				PendingPartialWithdrawals:    test.Args.PendingPartialWithdrawals,
-				LatestExecutionPayloadHeader: &enginev1.ExecutionPayloadHeaderEPBS{
-					BlockHash: []byte{},
-				},
-				LatestBlockHash: test.Args.LatestBlockHash,
-			}
-			st, err = state_native.InitializeFromProtoUnsafeEpbs(spb)
-			require.NoError(t, err)
-			env := random.ExecutionPayloadEnvelope(t)
-			env.Payload.Withdrawals = test.Args.Withdrawals
-			wp, err := consensusblocks.WrappedROExecutionPayloadEnvelope(env)
-			require.NoError(t, err)
-			p, err = wp.Execution()
-			require.NoError(t, err)
-			err = prepareValidators(st, test.Args)
-			require.NoError(t, err)
-			post, err := blocks.ProcessWithdrawals(st, p)
-			if test.Args.Name == "Parent Node is not full" {
-				require.DeepEqual(t, post, st)
-				require.IsNil(t, err)
-			} else {
-				require.NoError(t, err)
-				checkPostState(t, test.Control, post)
-			}
-			params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep = saved
-		})
-	}
-}
-
 func TestProcessBLSToExecutionChanges(t *testing.T) {
 	spb := &ethpb.BeaconStateCapella{
 		Fork: &ethpb.Fork{

beacon-chain/core/electra/BUILD.bazel

@@ -11,6 +11,7 @@ go_library(
         "error.go",
         "registry_updates.go",
         "transition.go",
+        "transition_no_verify_sig.go",
         "upgrade.go",
         "validator.go",
         "withdrawals.go",

beacon-chain/core/electra/transition_no_verify_sig.go

@@ -1,14 +1,12 @@
-package epbs
+package electra
 
 import (
 	"context"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/blocks"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/electra"
 	v "github.com/OffchainLabs/prysm/v6/beacon-chain/core/validators"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v6/runtime/version"
 	"github.com/pkg/errors"
 )
 
@@ -63,11 +61,11 @@ func ProcessOperations(
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process altair attester slashing")
 	}
-	st, err = electra.ProcessAttestationsNoVerifySignature(ctx, st, block)
+	st, err = ProcessAttestationsNoVerifySignature(ctx, st, block)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process altair attestation")
 	}
-	if _, err := electra.ProcessDeposits(ctx, st, bb.Deposits()); err != nil { // new in electra
+	if _, err := ProcessDeposits(ctx, st, bb.Deposits()); err != nil { // new in electra
 		return nil, errors.Wrap(err, "could not process altair deposit")
 	}
 	st, err = ProcessVoluntaryExits(ctx, st, bb.VoluntaryExits())
@@ -78,13 +76,6 @@ func ProcessOperations(
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process bls-to-execution changes")
 	}
-	// new in ePBS
-	if block.Version() >= version.EPBS {
-		if err := ProcessPayloadAttestations(st, bb); err != nil {
-			return nil, err
-		}
-		return st, nil
-	}
 	// new in electra
 	requests, err := bb.ExecutionRequests()
 	if err != nil {
@@ -95,7 +86,7 @@ func ProcessOperations(
 			return nil, errors.New("nil deposit request")
 		}
 	}
-	st, err = electra.ProcessDepositRequests(ctx, st, requests.Deposits)
+	st, err = ProcessDepositRequests(ctx, st, requests.Deposits)
 	if err != nil {
 		return nil, execReqErr{errors.Wrap(err, "could not process deposit requests")}
 	}
@@ -104,7 +95,7 @@ func ProcessOperations(
 			return nil, errors.New("nil withdrawal request")
 		}
 	}
-	st, err = electra.ProcessWithdrawalRequests(ctx, st, requests.Withdrawals)
+	st, err = ProcessWithdrawalRequests(ctx, st, requests.Withdrawals)
 	if err != nil {
 		return nil, execReqErr{errors.Wrap(err, "could not process withdrawal requests")}
 	}
@@ -113,7 +104,7 @@ func ProcessOperations(
 			return nil, errors.New("nil consolidation request")
 		}
 	}
-	if err := electra.ProcessConsolidationRequests(ctx, st, requests.Consolidations); err != nil {
+	if err := ProcessConsolidationRequests(ctx, st, requests.Consolidations); err != nil {
 		return nil, execReqErr{errors.Wrap(err, "could not process consolidation requests")}
 	}
 	return st, nil

beacon-chain/core/electra/withdrawals.go

@@ -102,13 +102,13 @@ func ProcessWithdrawalRequests(ctx context.Context, st state.BeaconState, wrs []
 			return nil, err
 		} else if n == params.BeaconConfig().PendingPartialWithdrawalsLimit && !isFullExitRequest {
 			// if the PendingPartialWithdrawalsLimit is met, the user would have paid for a partial withdrawal that's not included
-			log.Debugln("Skipping execution layer withdrawal request, PendingPartialWithdrawalsLimit reached")
+			log.Debug("Skipping execution layer withdrawal request, PendingPartialWithdrawalsLimit reached")
 			continue
 		}
 
 		vIdx, exists := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(wr.ValidatorPubkey))
 		if !exists {
-			log.Debugf("Skipping execution layer withdrawal request, validator index for %s not found\n", hexutil.Encode(wr.ValidatorPubkey))
+			log.WithField("validator", hexutil.Encode(wr.ValidatorPubkey)).Debug("Skipping execution layer withdrawal request, validator index not found")
 			continue
 		}
 		validator, err := st.ValidatorAtIndexReadOnly(vIdx)
@@ -120,23 +120,23 @@ func ProcessWithdrawalRequests(ctx context.Context, st state.BeaconState, wrs []
 		wc := validator.GetWithdrawalCredentials()
 		isCorrectSourceAddress := bytes.Equal(wc[12:], wr.SourceAddress)
 		if !hasCorrectCredential || !isCorrectSourceAddress {
-			log.Debugln("Skipping execution layer withdrawal request, wrong withdrawal credentials")
+			log.Debug("Skipping execution layer withdrawal request, wrong withdrawal credentials")
 			continue
 		}
 
 		// Verify the validator is active.
 		if !helpers.IsActiveValidatorUsingTrie(validator, currentEpoch) {
-			log.Debugln("Skipping execution layer withdrawal request, validator not active")
+			log.Debug("Skipping execution layer withdrawal request, validator not active")
 			continue
 		}
 		// Verify the validator has not yet submitted an exit.
 		if validator.ExitEpoch() != params.BeaconConfig().FarFutureEpoch {
-			log.Debugln("Skipping execution layer withdrawal request, validator has submitted an exit already")
+			log.Debug("Skipping execution layer withdrawal request, validator has submitted an exit already")
 			continue
 		}
 		// Verify the validator has been active long enough.
 		if currentEpoch < validator.ActivationEpoch().AddEpoch(params.BeaconConfig().ShardCommitteePeriod) {
-			log.Debugln("Skipping execution layer withdrawal request, validator has not been active long enough")
+			log.Debug("Skipping execution layer withdrawal request, validator has not been active long enough")
 			continue
 		}
 

beacon-chain/core/epbs/BUILD.bazel

@@ -1,62 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "attestation.go",
-        "error.go",
-        "execution_payload_envelope.go",
-        "execution_payload_header.go",
-        "operations.go",
-        "payload_attestation.go",
-        "upgrade.go",
-    ],
-    importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/core/epbs",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//beacon-chain/core/altair:go_default_library",
-        "//beacon-chain/core/blocks:go_default_library",
-        "//beacon-chain/core/electra:go_default_library",
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/signing:go_default_library",
-        "//beacon-chain/core/time:go_default_library",
-        "//beacon-chain/core/validators:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/state-native:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//crypto/bls:go_default_library",
-        "//network/forks:go_default_library",
-        "//proto/engine/v1:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//runtime/version:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = [
-        "attestation_test.go",
-        "execution_payload_envelope_test.go",
-        "upgrade_test.go",
-    ],
-    deps = [
-        ":go_default_library",
-        "//beacon-chain/core/altair:go_default_library",
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/time:go_default_library",
-        "//beacon-chain/state/state-native:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/blocks:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//proto/engine/v1:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/util:go_default_library",
-        "//testing/util/random:go_default_library",
-        "//time/slots:go_default_library",
-    ],
-)

beacon-chain/core/epbs/attestation.go

@@ -1,13 +0,0 @@
-package epbs
-
-import (
-	"fmt"
-)
-
-// RemoveValidatorFlag removes validator flag from existing one.
-func RemoveValidatorFlag(flag, flagPosition uint8) (uint8, error) {
-	if flagPosition > 7 {
-		return flag, fmt.Errorf("flag position %d exceeds length", flagPosition)
-	}
-	return flag & ^(1 << flagPosition), nil
-}

beacon-chain/core/epbs/attestation_test.go

@@ -1,93 +0,0 @@
-package epbs_test
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/altair"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/epbs"
-	"github.com/OffchainLabs/prysm/v6/config/params"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-)
-
-func TestValidatorFlag_Remove(t *testing.T) {
-	tests := []struct {
-		name          string
-		add           []uint8
-		remove        []uint8
-		expectedTrue  []uint8
-		expectedFalse []uint8
-	}{
-		{
-			name:          "none",
-			add:           []uint8{},
-			remove:        []uint8{},
-			expectedTrue:  []uint8{},
-			expectedFalse: []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
-		},
-		{
-			name:          "source",
-			add:           []uint8{params.BeaconConfig().TimelySourceFlagIndex},
-			remove:        []uint8{params.BeaconConfig().TimelySourceFlagIndex},
-			expectedTrue:  []uint8{},
-			expectedFalse: []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
-		},
-		{
-			name:          "source, target",
-			add:           []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex},
-			remove:        []uint8{params.BeaconConfig().TimelySourceFlagIndex},
-			expectedTrue:  []uint8{params.BeaconConfig().TimelyTargetFlagIndex},
-			expectedFalse: []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
-		},
-		{
-			name:          "source, target, head",
-			add:           []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
-			remove:        []uint8{params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
-			expectedTrue:  []uint8{params.BeaconConfig().TimelySourceFlagIndex},
-			expectedFalse: []uint8{params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
-		},
-	}
-	var err error
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			flag := uint8(0)
-
-			// Add flags.
-			for _, flagPosition := range test.add {
-				flag, err = altair.AddValidatorFlag(flag, flagPosition)
-				require.NoError(t, err)
-
-				has, err := altair.HasValidatorFlag(flag, flagPosition)
-				require.NoError(t, err)
-				require.Equal(t, true, has)
-			}
-
-			// Remove flags.
-			for _, flagPosition := range test.remove {
-				flag, err = epbs.RemoveValidatorFlag(flag, flagPosition)
-				require.NoError(t, err)
-			}
-
-			// Check if flags are set correctly.
-			for _, flagPosition := range test.expectedTrue {
-				has, err := altair.HasValidatorFlag(flag, flagPosition)
-				require.NoError(t, err)
-				require.Equal(t, true, has)
-			}
-			for _, flagPosition := range test.expectedFalse {
-				has, err := altair.HasValidatorFlag(flag, flagPosition)
-				require.NoError(t, err)
-				require.Equal(t, false, has)
-			}
-		})
-	}
-}
-
-func TestValidatorFlag_Remove_ExceedsLength(t *testing.T) {
-	_, err := epbs.RemoveValidatorFlag(0, 8)
-	require.ErrorContains(t, "flag position 8 exceeds length", err)
-}
-
-func TestValidatorFlag_Remove_NotSet(t *testing.T) {
-	_, err := epbs.RemoveValidatorFlag(0, 1)
-	require.NoError(t, err)
-}

beacon-chain/core/epbs/error.go

@@ -1,16 +0,0 @@
-package epbs
-
-import "github.com/pkg/errors"
-
-type execReqErr struct {
-	error
-}
-
-// IsExecutionRequestError returns true if the error has `execReqErr`.
-func IsExecutionRequestError(e error) bool {
-	if e == nil {
-		return false
-	}
-	var d execReqErr
-	return errors.As(e, &d)
-}

beacon-chain/core/epbs/execution_payload_envelope.go

@@ -1,126 +0,0 @@
-package epbs
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/electra"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
-	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
-	"github.com/pkg/errors"
-)
-
-// ValidatePayloadStateTransition performs the process_execution_payload
-// function.
-func ValidatePayloadStateTransition(
-	ctx context.Context,
-	preState state.BeaconState,
-	envelope interfaces.ROExecutionPayloadEnvelope,
-) error {
-	if err := UpdateHeaderAndVerify(ctx, preState, envelope); err != nil {
-		return err
-	}
-	committedHeader, err := preState.LatestExecutionPayloadHeaderEPBS()
-	if err != nil {
-		return err
-	}
-	if err := ValidateAgainstCommittedBid(committedHeader, envelope); err != nil {
-		return err
-	}
-	if err := ProcessPayloadStateTransition(ctx, preState, envelope); err != nil {
-		return err
-	}
-	return CheckPostStateRoot(ctx, preState, envelope)
-}
-
-func ProcessPayloadStateTransition(
-	ctx context.Context,
-	preState state.BeaconState,
-	envelope interfaces.ROExecutionPayloadEnvelope,
-) error {
-	er := envelope.ExecutionRequests()
-	preState, err := electra.ProcessDepositRequests(ctx, preState, er.Deposits)
-	if err != nil {
-		return errors.Wrap(err, "could not process deposit receipts")
-	}
-	preState, err = electra.ProcessWithdrawalRequests(ctx, preState, er.Withdrawals)
-	if err != nil {
-		return errors.Wrap(err, "could not process ercution layer withdrawal requests")
-	}
-	if err := electra.ProcessConsolidationRequests(ctx, preState, er.Consolidations); err != nil {
-		return errors.Wrap(err, "could not process consolidation requests")
-	}
-	payload, err := envelope.Execution()
-	if err != nil {
-		return errors.Wrap(err, "could not get execution payload")
-	}
-	if err := preState.SetLatestBlockHash(payload.BlockHash()); err != nil {
-		return err
-	}
-	return preState.SetLatestFullSlot(preState.Slot())
-}
-
-func UpdateHeaderAndVerify(
-	ctx context.Context,
-	preState state.BeaconState,
-	envelope interfaces.ROExecutionPayloadEnvelope,
-) error {
-	blockHeader := preState.LatestBlockHeader()
-	if blockHeader == nil {
-		return errors.New("invalid nil latest block header")
-	}
-	if len(blockHeader.StateRoot) == 0 || [32]byte(blockHeader.StateRoot) == [32]byte{} {
-		prevStateRoot, err := preState.HashTreeRoot(ctx)
-		if err != nil {
-			return errors.Wrap(err, "could not compute previous state root")
-		}
-		blockHeader.StateRoot = prevStateRoot[:]
-		if err := preState.SetLatestBlockHeader(blockHeader); err != nil {
-			return errors.Wrap(err, "could not set latest block header")
-		}
-	}
-	blockHeaderRoot, err := blockHeader.HashTreeRoot()
-	if err != nil {
-		return err
-	}
-	beaconBlockRoot := envelope.BeaconBlockRoot()
-	if blockHeaderRoot != beaconBlockRoot {
-		return fmt.Errorf("beacon block root does not match previous header, got: %#x wanted: %#x", beaconBlockRoot, blockHeaderRoot)
-	}
-	return nil
-}
-
-func ValidateAgainstCommittedBid(
-	committedHeader *enginev1.ExecutionPayloadHeaderEPBS,
-	envelope interfaces.ROExecutionPayloadEnvelope,
-) error {
-	builderIndex := envelope.BuilderIndex()
-	if committedHeader.BuilderIndex != builderIndex {
-		return errors.New("builder index does not match committed header")
-	}
-	kzgRoot, err := envelope.BlobKzgCommitmentsRoot()
-	if err != nil {
-		return err
-	}
-	if [32]byte(committedHeader.BlobKzgCommitmentsRoot) != kzgRoot {
-		return errors.New("blob KZG commitments root does not match committed header")
-	}
-	return nil
-}
-
-func CheckPostStateRoot(
-	ctx context.Context,
-	preState state.BeaconState,
-	envelope interfaces.ROExecutionPayloadEnvelope,
-) error {
-	stateRoot, err := preState.HashTreeRoot(ctx)
-	if err != nil {
-		return err
-	}
-	envelopeStateRoot := envelope.StateRoot()
-	if stateRoot != envelopeStateRoot {
-		return errors.New("state root mismatch")
-	}
-	return nil
-}

beacon-chain/core/epbs/execution_payload_envelope_test.go

@@ -1,110 +0,0 @@
-package epbs_test
-
-import (
-	"context"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/epbs"
-	state_native "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
-	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/OffchainLabs/prysm/v6/testing/util"
-	"github.com/OffchainLabs/prysm/v6/testing/util/random"
-)
-
-func TestProcessPayloadStateTransition(t *testing.T) {
-	bh := [32]byte{'h'}
-	p := random.ExecutionPayloadEnvelope(t)
-	p.Payload.BlockHash = bh[:]
-	p.ExecutionRequests = &enginev1.ExecutionRequests{}
-	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
-	require.NoError(t, err)
-	validators := make([]*ethpb.Validator, 0)
-	stpb := &ethpb.BeaconStateEPBS{Slot: 3, Validators: validators}
-	st, err := state_native.InitializeFromProtoUnsafeEpbs(stpb)
-	require.NoError(t, err)
-	ctx := context.Background()
-
-	lbh, err := st.LatestBlockHash()
-	require.NoError(t, err)
-	require.Equal(t, [32]byte{}, [32]byte(lbh))
-
-	require.NoError(t, epbs.ProcessPayloadStateTransition(ctx, st, e))
-
-	lbh, err = st.LatestBlockHash()
-	require.NoError(t, err)
-	require.Equal(t, bh, [32]byte(lbh))
-
-	lfs, err := st.LatestFullSlot()
-	require.NoError(t, err)
-	require.Equal(t, lfs, st.Slot())
-}
-
-func Test_validateAgainstHeader(t *testing.T) {
-	bh := [32]byte{'h'}
-	payload := &enginev1.ExecutionPayloadDeneb{BlockHash: bh[:]}
-	p := random.ExecutionPayloadEnvelope(t)
-	p.Payload = payload
-	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
-	require.NoError(t, err)
-	stpb := &ethpb.BeaconStateEPBS{Slot: 3}
-	st, err := state_native.InitializeFromProtoUnsafeEpbs(stpb)
-	require.NoError(t, err)
-	ctx := context.Background()
-	require.ErrorContains(t, "invalid nil latest block header", epbs.UpdateHeaderAndVerify(ctx, st, e))
-
-	prest, _ := util.DeterministicGenesisStateEpbs(t, 64)
-	br := [32]byte{'r'}
-	p.BeaconBlockRoot = br[:]
-	require.ErrorContains(t, "beacon block root does not match previous header", epbs.UpdateHeaderAndVerify(ctx, prest, e))
-
-	header := prest.LatestBlockHeader()
-	require.NoError(t, err)
-	headerRoot, err := header.HashTreeRoot()
-	require.NoError(t, err)
-	p.BeaconBlockRoot = headerRoot[:]
-	require.NoError(t, epbs.UpdateHeaderAndVerify(ctx, prest, e))
-}
-
-func Test_validateAgainstCommittedBid(t *testing.T) {
-	payload := &enginev1.ExecutionPayloadDeneb{}
-	p := random.ExecutionPayloadEnvelope(t)
-	p.Payload = payload
-	p.BuilderIndex = 1
-	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
-	require.NoError(t, err)
-	h := &enginev1.ExecutionPayloadHeaderEPBS{}
-	require.ErrorContains(t, "builder index does not match committed header", epbs.ValidateAgainstCommittedBid(h, e))
-
-	h.BuilderIndex = 1
-	p.BlobKzgCommitments = make([][]byte, 6)
-	for i := range p.BlobKzgCommitments {
-		p.BlobKzgCommitments[i] = make([]byte, 48)
-	}
-	h.BlobKzgCommitmentsRoot = make([]byte, 32)
-	require.ErrorContains(t, "blob KZG commitments root does not match committed header", epbs.ValidateAgainstCommittedBid(h, e))
-
-	root, err := e.BlobKzgCommitmentsRoot()
-	require.NoError(t, err)
-	h.BlobKzgCommitmentsRoot = root[:]
-	require.NoError(t, epbs.ValidateAgainstCommittedBid(h, e))
-}
-
-func TestCheckPostStateRoot(t *testing.T) {
-	payload := &enginev1.ExecutionPayloadDeneb{}
-	p := random.ExecutionPayloadEnvelope(t)
-	p.Payload = payload
-	p.BuilderIndex = 1
-	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
-	require.NoError(t, err)
-	ctx := context.Background()
-	st, _ := util.DeterministicGenesisStateEpbs(t, 64)
-	p.BeaconStateRoot = make([]byte, 32)
-	require.ErrorContains(t, "state root mismatch", epbs.CheckPostStateRoot(ctx, st, e))
-	root, err := st.HashTreeRoot(ctx)
-	require.NoError(t, err)
-	p.BeaconStateRoot = root[:]
-	require.NoError(t, epbs.CheckPostStateRoot(ctx, st, e))
-}

beacon-chain/core/epbs/execution_payload_header.go

@@ -1,50 +0,0 @@
-package epbs
-
-import (
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/signing"
-	"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/crypto/bls"
-	"github.com/OffchainLabs/prysm/v6/network/forks"
-	"github.com/OffchainLabs/prysm/v6/time/slots"
-)
-
-// ValidatePayloadHeaderSignature validates the signature of the execution payload header.
-func ValidatePayloadHeaderSignature(st state.ReadOnlyBeaconState, sh interfaces.ROSignedExecutionPayloadHeader) error {
-	h, err := sh.Header()
-	if err != nil {
-		return err
-	}
-	pubkey := st.PubkeyAtIndex(h.BuilderIndex())
-	pub, err := bls.PublicKeyFromBytes(pubkey[:])
-	if err != nil {
-		return err
-	}
-
-	s := sh.Signature()
-	sig, err := bls.SignatureFromBytes(s[:])
-	if err != nil {
-		return err
-	}
-
-	currentEpoch := slots.ToEpoch(h.Slot())
-	f, err := forks.Fork(currentEpoch)
-	if err != nil {
-		return err
-	}
-
-	domain, err := signing.Domain(f, currentEpoch, params.BeaconConfig().DomainBeaconBuilder, st.GenesisValidatorsRoot())
-	if err != nil {
-		return err
-	}
-	root, err := sh.SigningRoot(domain)
-	if err != nil {
-		return err
-	}
-	if !sig.Verify(pub, root[:]) {
-		return signing.ErrSigFailedToVerify
-	}
-
-	return nil
-}

beacon-chain/core/epbs/payload_attestation.go

@@ -1,125 +0,0 @@
-package epbs
-
-import (
-	"bytes"
-	"context"
-	"time"
-
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/altair"
-	"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"
-	"github.com/pkg/errors"
-)
-
-func ProcessPayloadAttestations(state state.BeaconState, body interfaces.ReadOnlyBeaconBlockBody) error {
-	atts, err := body.PayloadAttestations()
-	if err != nil {
-		return err
-	}
-	if len(atts) == 0 {
-		return nil
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), 12*time.Second)
-	defer cancel()
-	lbh := state.LatestBlockHeader()
-	proposerIndex := lbh.ProposerIndex
-	var participation []byte
-	if state.Slot()%32 == 0 {
-		participation, err = state.PreviousEpochParticipation()
-	} else {
-		participation, err = state.CurrentEpochParticipation()
-	}
-	if err != nil {
-		return err
-	}
-	totalBalance, err := helpers.TotalActiveBalance(state)
-	if err != nil {
-		return err
-	}
-	baseReward, err := altair.BaseRewardWithTotalBalance(state, proposerIndex, totalBalance)
-	if err != nil {
-		return err
-	}
-	lfs, err := state.LatestFullSlot()
-	if err != nil {
-		return err
-	}
-
-	cfg := params.BeaconConfig()
-	sourceFlagIndex := cfg.TimelySourceFlagIndex
-	targetFlagIndex := cfg.TimelyTargetFlagIndex
-	headFlagIndex := cfg.TimelyHeadFlagIndex
-	penaltyNumerator := uint64(0)
-	rewardNumerator := uint64(0)
-	rewardDenominator := (cfg.WeightDenominator - cfg.ProposerWeight) * cfg.WeightDenominator / cfg.ProposerWeight
-
-	for _, att := range atts {
-		data := att.Data
-		if !bytes.Equal(data.BeaconBlockRoot, lbh.ParentRoot) {
-			return errors.New("invalid beacon block root in payload attestation data")
-		}
-		if data.Slot+1 != state.Slot() {
-			return errors.New("invalid data slot")
-		}
-		indexed, err := helpers.GetIndexedPayloadAttestation(ctx, state, data.Slot, att)
-		if err != nil {
-			return err
-		}
-		valid, err := helpers.IsValidIndexedPayloadAttestation(state, indexed)
-		if err != nil {
-			return err
-		}
-		if !valid {
-			return errors.New("invalid payload attestation")
-		}
-		payloadWasPreset := data.Slot == lfs
-		votedPresent := primitives.PTCStatus(data.PayloadStatus[0]) == primitives.PAYLOAD_PRESENT
-		if votedPresent != payloadWasPreset {
-			for _, idx := range indexed.GetAttestingIndices() {
-				flags := participation[idx]
-				has, err := altair.HasValidatorFlag(flags, targetFlagIndex)
-				if err != nil {
-					return err
-				}
-				if has {
-					penaltyNumerator += baseReward * cfg.TimelyTargetWeight
-				}
-				has, err = altair.HasValidatorFlag(flags, sourceFlagIndex)
-				if err != nil {
-					return err
-				}
-				if has {
-					penaltyNumerator += baseReward * cfg.TimelySourceWeight
-				}
-				has, err = altair.HasValidatorFlag(flags, headFlagIndex)
-				if err != nil {
-					return err
-				}
-				if has {
-					penaltyNumerator += baseReward * cfg.TimelyHeadWeight
-				}
-				participation[idx] = 0
-			}
-		} else {
-			for _, idx := range indexed.GetAttestingIndices() {
-				participation[idx] = (1 << headFlagIndex) | (1 << sourceFlagIndex) | (1 << targetFlagIndex)
-				rewardNumerator += baseReward * (cfg.TimelyHeadWeight + cfg.TimelySourceWeight + cfg.TimelyTargetWeight)
-			}
-		}
-	}
-	if penaltyNumerator > 0 {
-		if err := helpers.DecreaseBalance(state, proposerIndex, penaltyNumerator/rewardDenominator); err != nil {
-			return err
-		}
-	}
-	if rewardNumerator > 0 {
-		if err := helpers.IncreaseBalance(state, proposerIndex, penaltyNumerator/rewardDenominator); err != nil {
-			return err
-		}
-	}
-	return nil
-}

beacon-chain/core/epbs/upgrade.go

@@ -1,147 +0,0 @@
-package epbs
-
-import (
-	"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/pkg/errors"
-)
-
-// UpgradeToEIP7732 updates inputs a generic state to return the version EIP-7732 state.
-// https://github.com/ethereum/consensus-specs/blob/dev/specs/_features/eip7732/fork.md
-func UpgradeToEIP7732(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
-	}
-	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
-	}
-	historicalRoots := beaconState.HistoricalRoots()
-	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
-	}
-
-	s := &ethpb.BeaconStateEPBS{
-		GenesisTime:           uint64(beaconState.GenesisTime().Unix()),
-		GenesisValidatorsRoot: beaconState.GenesisValidatorsRoot(),
-		Slot:                  beaconState.Slot(),
-		Fork: &ethpb.Fork{
-			PreviousVersion: beaconState.Fork().CurrentVersion,
-			CurrentVersion:  params.BeaconConfig().EPBSForkVersion,
-			Epoch:           time.CurrentEpoch(beaconState),
-		},
-		LatestBlockHeader:            beaconState.LatestBlockHeader(),
-		BlockRoots:                   beaconState.BlockRoots(),
-		StateRoots:                   beaconState.StateRoots(),
-		HistoricalRoots:              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,
-		NextWithdrawalIndex:          wi,
-		NextWithdrawalValidatorIndex: vi,
-		HistoricalSummaries:          summaries,
-
-		DepositRequestsStartIndex:     params.BeaconConfig().UnsetDepositRequestsStartIndex,
-		DepositBalanceToConsume:       depositBalanceToConsume,
-		ExitBalanceToConsume:          exitBalanceToConsume,
-		EarliestExitEpoch:             earliestExitEpoch,
-		ConsolidationBalanceToConsume: consolidationBalanceToConsume,
-		EarliestConsolidationEpoch:    earliestConsolidationEpoch,
-		PendingDeposits:               pendingDeposits,
-		PendingPartialWithdrawals:     pendingPartialWithdrawals,
-		PendingConsolidations:         pendingConsolidations,
-
-		// Newly added for EIP7732
-		LatestExecutionPayloadHeader: &enginev1.ExecutionPayloadHeaderEPBS{
-			ParentBlockHash:        make([]byte, 32),
-			ParentBlockRoot:        make([]byte, 32),
-			BlockHash:              make([]byte, 32),
-			BlobKzgCommitmentsRoot: make([]byte, 32),
-		},
-		LatestBlockHash:       payloadHeader.BlockHash(),
-		LatestFullSlot:        beaconState.Slot(),
-		LatestWithdrawalsRoot: make([]byte, 32),
-	}
-
-	post, err := state_native.InitializeFromProtoUnsafeEpbs(s)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to initialize post EIP-7732 beaconState")
-	}
-
-	return post, nil
-}

beacon-chain/core/epbs/upgrade_test.go

@@ -1,135 +0,0 @@
-package epbs_test
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/epbs"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/time"
-	"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/testing/require"
-	"github.com/OffchainLabs/prysm/v6/testing/util"
-	"github.com/OffchainLabs/prysm/v6/time/slots"
-)
-
-func TestUpgradeToEip7732(t *testing.T) {
-	st, _ := util.DeterministicGenesisStateElectra(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	require.NoError(t, st.SetHistoricalRoots([][]byte{{1}}))
-
-	preForkState := st.Copy()
-	mSt, err := epbs.UpgradeToEIP7732(st)
-	require.NoError(t, err)
-
-	require.Equal(t, preForkState.GenesisTime(), mSt.GenesisTime())
-	require.DeepSSZEqual(t, preForkState.GenesisValidatorsRoot(), mSt.GenesisValidatorsRoot())
-	require.Equal(t, preForkState.Slot(), mSt.Slot())
-	require.DeepSSZEqual(t, preForkState.LatestBlockHeader(), mSt.LatestBlockHeader())
-	require.DeepSSZEqual(t, preForkState.BlockRoots(), mSt.BlockRoots())
-	require.DeepSSZEqual(t, preForkState.StateRoots(), mSt.StateRoots())
-	require.DeepSSZEqual(t, preForkState.Validators()[2:], mSt.Validators()[2:])
-	require.DeepSSZEqual(t, preForkState.Balances()[2:], mSt.Balances()[2:])
-	require.DeepSSZEqual(t, preForkState.Eth1Data(), mSt.Eth1Data())
-	require.DeepSSZEqual(t, preForkState.Eth1DataVotes(), mSt.Eth1DataVotes())
-	require.DeepSSZEqual(t, preForkState.Eth1DepositIndex(), mSt.Eth1DepositIndex())
-	require.DeepSSZEqual(t, preForkState.RandaoMixes(), mSt.RandaoMixes())
-	require.DeepSSZEqual(t, preForkState.Slashings(), mSt.Slashings())
-	require.DeepSSZEqual(t, preForkState.JustificationBits(), mSt.JustificationBits())
-	require.DeepSSZEqual(t, preForkState.PreviousJustifiedCheckpoint(), mSt.PreviousJustifiedCheckpoint())
-	require.DeepSSZEqual(t, preForkState.CurrentJustifiedCheckpoint(), mSt.CurrentJustifiedCheckpoint())
-	require.DeepSSZEqual(t, preForkState.FinalizedCheckpoint(), mSt.FinalizedCheckpoint())
-
-	require.Equal(t, len(preForkState.Validators()), len(mSt.Validators()))
-
-	numValidators := mSt.NumValidators()
-	p, err := mSt.PreviousEpochParticipation()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, make([]byte, numValidators), p)
-	p, err = mSt.CurrentEpochParticipation()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, make([]byte, numValidators), p)
-	s, err := mSt.InactivityScores()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, make([]uint64, numValidators), s)
-
-	hr1, err := preForkState.HistoricalRoots()
-	require.NoError(t, err)
-	hr2, err := mSt.HistoricalRoots()
-	require.NoError(t, err)
-	require.DeepEqual(t, hr1, hr2)
-
-	f := mSt.Fork()
-	require.DeepSSZEqual(t, &ethpb.Fork{
-		PreviousVersion: st.Fork().CurrentVersion,
-		CurrentVersion:  params.BeaconConfig().EPBSForkVersion,
-		Epoch:           time.CurrentEpoch(st),
-	}, f)
-	csc, err := mSt.CurrentSyncCommittee()
-	require.NoError(t, err)
-	psc, err := preForkState.CurrentSyncCommittee()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, psc, csc)
-	nsc, err := mSt.NextSyncCommittee()
-	require.NoError(t, err)
-	psc, err = preForkState.NextSyncCommittee()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, psc, nsc)
-
-	nwi, err := mSt.NextWithdrawalIndex()
-	require.NoError(t, err)
-	require.Equal(t, uint64(0), nwi)
-
-	lwvi, err := mSt.NextWithdrawalValidatorIndex()
-	require.NoError(t, err)
-	require.Equal(t, primitives.ValidatorIndex(0), lwvi)
-
-	summaries, err := mSt.HistoricalSummaries()
-	require.NoError(t, err)
-	require.Equal(t, 0, len(summaries))
-
-	startIndex, err := mSt.DepositRequestsStartIndex()
-	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().UnsetDepositRequestsStartIndex, startIndex)
-
-	balance, err := mSt.DepositBalanceToConsume()
-	require.NoError(t, err)
-	require.Equal(t, primitives.Gwei(0), balance)
-
-	tab, err := helpers.TotalActiveBalance(mSt)
-	require.NoError(t, err)
-
-	ebtc, err := mSt.ExitBalanceToConsume()
-	require.NoError(t, err)
-	require.Equal(t, helpers.ActivationExitChurnLimit(primitives.Gwei(tab)), ebtc)
-
-	cbtc, err := mSt.ConsolidationBalanceToConsume()
-	require.NoError(t, err)
-	require.Equal(t, helpers.ConsolidationChurnLimit(primitives.Gwei(tab)), cbtc)
-
-	earliestConsolidationEpoch, err := mSt.EarliestConsolidationEpoch()
-	require.NoError(t, err)
-	require.Equal(t, helpers.ActivationExitEpoch(slots.ToEpoch(preForkState.Slot())), earliestConsolidationEpoch)
-
-	// EIP-7732 checks.
-	h, err := mSt.LatestExecutionPayloadHeaderEPBS()
-	require.NoError(t, err)
-	require.DeepEqual(t, &enginev1.ExecutionPayloadHeaderEPBS{
-		ParentBlockHash:        make([]byte, 32),
-		ParentBlockRoot:        make([]byte, 32),
-		BlockHash:              make([]byte, 32),
-		BlobKzgCommitmentsRoot: make([]byte, 32),
-	}, h)
-	lwr, err := mSt.LastWithdrawalsRoot()
-	require.NoError(t, err)
-	require.DeepEqual(t, lwr, make([]byte, 32))
-	lbh, err := mSt.LatestBlockHash()
-	require.NoError(t, err)
-	lh, err := preForkState.LatestExecutionPayloadHeader()
-	require.NoError(t, err)
-	require.DeepEqual(t, lbh, lh.BlockHash())
-	slot, err := mSt.LatestFullSlot()
-	require.NoError(t, err)
-	require.Equal(t, slot, preForkState.Slot())
-}

beacon-chain/core/feed/state/events.go

@@ -33,8 +33,6 @@ const (
 	LightClientOptimisticUpdate
 	// PayloadAttributes events are fired upon a missed slot or new head.
 	PayloadAttributes
-	// PayloadProcessed is fired when a payload is processed.
-	PayloadProcessed
 )
 
 // BlockProcessedData is the data sent with BlockProcessed events.
@@ -55,17 +53,6 @@ type BlockProcessedData struct {
 	Optimistic bool
 }
 
-type PayloadProcessedData struct {
-	// Slot is the slot of the processed block.
-	Slot primitives.Slot
-	// BlockRoot of the processed block.
-	BlockRoot [32]byte
-	// ExecutionBlockHash is the hash of the execution payload.
-	ExecutionBlockHash [32]byte
-	// ExecutionOptimistic is true if the execution payload is optimistic.
-	ExecutionOptimistic bool
-}
-
 // ChainStartedData is the data sent with ChainStarted events.
 type ChainStartedData struct {
 	// StartTime is the time at which the chain started.

beacon-chain/core/fulu/upgrade.go

@@ -15,7 +15,7 @@ import (
 )
 
 // UpgradeToFulu updates inputs a generic state to return the version Fulu state.
-// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/fork.md#upgrading-the-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) {
 	currentSyncCommittee, err := beaconState.CurrentSyncCommittee()
 	if err != nil {

beacon-chain/core/helpers/BUILD.bazel

@@ -9,7 +9,6 @@ go_library(
         "genesis.go",
         "legacy.go",
         "metrics.go",
-        "payload_attestation.go",
         "randao.go",
         "rewards_penalties.go",
         "shuffle.go",
@@ -22,13 +21,11 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//beacon-chain/cache:go_default_library",
-        "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/epbs:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
         "//container/trie:go_default_library",
@@ -55,9 +52,7 @@ go_test(
         "attestation_test.go",
         "beacon_committee_test.go",
         "block_test.go",
-        "exports_test.go",
         "legacy_test.go",
-        "payload_attestation_test.go",
         "private_access_fuzz_noop_test.go",  # keep
         "private_access_test.go",
         "randao_test.go",
@@ -74,27 +69,21 @@ go_test(
     tags = ["CI_race_detection"],
     deps = [
         "//beacon-chain/cache:go_default_library",
-        "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/epbs:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
-        "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
-        "//crypto/rand:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
-        "//testing/util/random:go_default_library",
         "//time:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",

beacon-chain/core/helpers/beacon_committee.go

@@ -275,7 +275,6 @@ type CommitteeAssignment struct {
 	Committee      []primitives.ValidatorIndex
 	AttesterSlot   primitives.Slot
 	CommitteeIndex primitives.CommitteeIndex
-	PtcSlot        primitives.Slot
 }
 
 // VerifyAssignmentEpoch verifies if the given epoch is valid for assignment based on the provided state.
@@ -418,7 +417,7 @@ func CommitteeAssignments(ctx context.Context, state state.BeaconState, epoch pr
 	if err := VerifyAssignmentEpoch(epoch, state); err != nil {
 		return nil, err
 	}
-	slot, err := slots.EpochStart(epoch)
+	startSlot, err := slots.EpochStart(epoch)
 	if err != nil {
 		return nil, err
 	}
@@ -427,17 +426,14 @@ func CommitteeAssignments(ctx context.Context, state state.BeaconState, epoch pr
 		vals[v] = struct{}{}
 	}
 	assignments := make(map[primitives.ValidatorIndex]*CommitteeAssignment)
-
-	committees, err := BeaconCommittees(ctx, state, slot)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not compute beacon committees")
-	}
-	ptcPerSlot, ptcMembersPerCommittee := PtcAllocation(len(committees))
 	// Compute committee assignments for each slot in the epoch.
-	endSlot := slot + params.BeaconConfig().SlotsPerEpoch
-	for {
+	for slot := startSlot; slot < startSlot+params.BeaconConfig().SlotsPerEpoch; slot++ {
+		committees, err := BeaconCommittees(ctx, state, slot)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not compute beacon committees")
+		}
 		for j, committee := range committees {
-			for i, vIndex := range committee {
+			for _, vIndex := range committee {
 				if _, ok := vals[vIndex]; !ok { // Skip if the validator is not in the provided validators slice.
 					continue
 				}
@@ -447,19 +443,8 @@ func CommitteeAssignments(ctx context.Context, state state.BeaconState, epoch pr
 				assignments[vIndex].Committee = committee
 				assignments[vIndex].AttesterSlot = slot
 				assignments[vIndex].CommitteeIndex = primitives.CommitteeIndex(j)
-				if uint64(j) < ptcPerSlot && uint64(i) < ptcMembersPerCommittee {
-					assignments[vIndex].PtcSlot = slot
-				}
 			}
 		}
-		slot++
-		if slot == endSlot {
-			break
-		}
-		committees, err = BeaconCommittees(ctx, state, slot)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not compute beacon committees")
-		}
 	}
 	return assignments, nil
 }
@@ -572,7 +557,7 @@ func UpdateProposerIndicesInCache(ctx context.Context, state state.ReadOnlyBeaco
 	}
 	var proposerIndices []primitives.ValidatorIndex
 	// use the state if post fulu (EIP-7917)
-	if state.Version() >= version.Fulu && state.Version() != version.EPBS {
+	if state.Version() >= version.Fulu {
 		lookAhead, err := state.ProposerLookahead()
 		if err != nil {
 			return errors.Wrap(err, "could not get proposer lookahead")

beacon-chain/core/helpers/beacon_committee_test.go

@@ -2,7 +2,6 @@ package helpers_test
 
 import (
 	"fmt"
-	"slices"
 	"strconv"
 	"testing"
 
@@ -731,18 +730,15 @@ func TestCommitteeIndices(t *testing.T) {
 
 func TestAttestationCommitteesFromState(t *testing.T) {
 	ctx := t.Context()
+
+	validators := make([]*ethpb.Validator, params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().TargetCommitteeSize))
 	for i := 0; i < len(validators); i++ {
-		k := make([]byte, 48)
-		copy(k, strconv.Itoa(i))
 		validators[i] = &ethpb.Validator{
-			PublicKey:             k,
-			WithdrawalCredentials: make([]byte, 32),
-			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
 		}
-		validatorIndices[i] = primitives.ValidatorIndex(i)
 	}
 
-	state, err := state_native.InitializeFromProtoEpbs(&ethpb.BeaconStateEPBS{
+	state, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
 		Validators:  validators,
 		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 	})
@@ -766,31 +762,6 @@ func TestAttestationCommitteesFromState(t *testing.T) {
 		assert.Equal(t, params.BeaconConfig().TargetCommitteeSize, uint64(len(committees[0])))
 		assert.Equal(t, params.BeaconConfig().TargetCommitteeSize, uint64(len(committees[1])))
 	})
-	as, err := helpers.CommitteeAssignments(context.Background(), state, 1, validatorIndices)
-	require.NoError(t, err)
-
-	// Capture all the slots and all the validator index that belonged in a PTC using a map for verification later.
-	slotValidatorMap := make(map[primitives.Slot][]primitives.ValidatorIndex)
-	for i, a := range as {
-		slotValidatorMap[a.PtcSlot] = append(slotValidatorMap[a.PtcSlot], i)
-	}
-
-	// Verify that all the slots have the correct number of PTC.
-	for s, v := range slotValidatorMap {
-		if s == 0 {
-			continue
-		}
-		// Make sure all the PTC are the correct size from the map.
-		require.Equal(t, len(v), field_params.PTCSize)
-
-		// Get the actual PTC from the beacon state using the helper function
-		ptc, err := helpers.GetPayloadTimelinessCommittee(context.Background(), state, s)
-		require.NoError(t, err)
-		for _, index := range ptc {
-			i := slices.Index(v, index)
-			require.NotEqual(t, -1, i) // PTC not found from the assignment map
-		}
-	}
 }
 
 func TestAttestationCommitteesFromCache(t *testing.T) {

beacon-chain/core/helpers/exports_test.go

@@ -1,12 +0,0 @@
-package helpers
-
-var (
-	ErrNilMessage            = errNilMessage
-	ErrNilData               = errNilData
-	ErrNilBeaconBlockRoot    = errNilBeaconBlockRoot
-	ErrNilPayloadAttestation = errNilPayloadAttestation
-	ErrNilSignature          = errNilSignature
-	ErrNilAggregationBits    = errNilAggregationBits
-	ErrPreEPBSState          = errPreEPBSState
-	ErrCommitteeOverflow     = errCommitteeOverflow
-)

beacon-chain/core/helpers/payload_attestation.go

@@ -1,296 +0,0 @@
-package helpers
-
-import (
-	"context"
-	"slices"
-
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/signing"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
-	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v6/config/params"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/epbs"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v6/crypto/bls"
-	"github.com/OffchainLabs/prysm/v6/math"
-	eth "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v6/runtime/version"
-	"github.com/OffchainLabs/prysm/v6/time/slots"
-	"github.com/pkg/errors"
-)
-
-var (
-	errNilMessage            = errors.New("nil PayloadAttestationMessage")
-	errNilData               = errors.New("nil PayloadAttestationData")
-	errNilBeaconBlockRoot    = errors.New("nil BeaconBlockRoot")
-	errNilPayloadAttestation = errors.New("nil PayloadAttestation")
-	errNilSignature          = errors.New("nil Signature")
-	errNilAggregationBits    = errors.New("nil AggregationBits")
-	errPreEPBSState          = errors.New("beacon state pre ePBS fork")
-	errCommitteeOverflow     = errors.New("beacon committee of insufficient size")
-)
-
-// ValidateNilPayloadAttestationData checks if any composite field of the
-// payload attestation data is nil
-func ValidateNilPayloadAttestationData(data *eth.PayloadAttestationData) error {
-	if data == nil {
-		return errNilData
-	}
-	if data.BeaconBlockRoot == nil {
-		return errNilBeaconBlockRoot
-	}
-	return nil
-}
-
-// ValidateNilPayloadAttestationMessage checks if any composite field of the
-// payload attestation message is nil
-func ValidateNilPayloadAttestationMessage(att *eth.PayloadAttestationMessage) error {
-	if att == nil {
-		return errNilMessage
-	}
-	if att.Signature == nil {
-		return errNilSignature
-	}
-	return ValidateNilPayloadAttestationData(att.Data)
-}
-
-// ValidateNilPayloadAttestation checks if any composite field of the
-// payload attestation is nil
-func ValidateNilPayloadAttestation(att *eth.PayloadAttestation) error {
-	if att == nil {
-		return errNilPayloadAttestation
-	}
-	if att.AggregationBits == nil {
-		return errNilAggregationBits
-	}
-	if att.Signature == nil {
-		return errNilSignature
-	}
-	return ValidateNilPayloadAttestationData(att.Data)
-}
-
-// InPayloadTimelinessCommittee returns whether the given index belongs to the
-// PTC computed from the passed state.
-func InPayloadTimelinessCommittee(ctx context.Context, state state.ReadOnlyBeaconState, slot primitives.Slot, idx primitives.ValidatorIndex) (bool, error) {
-	ptc, err := GetPayloadTimelinessCommittee(ctx, state, slot)
-	if err != nil {
-		return false, err
-	}
-	for _, i := range ptc {
-		if i == idx {
-			return true, nil
-		}
-	}
-	return false, nil
-}
-
-// GetPayloadTimelinessCommittee returns the PTC for the given slot, computed from the passed state as in the
-// spec function `get_ptc`.
-func GetPayloadTimelinessCommittee(ctx context.Context, state state.ReadOnlyBeaconState, slot primitives.Slot) (indices []primitives.ValidatorIndex, err error) {
-	if state.Version() < version.EPBS {
-		return nil, errPreEPBSState
-	}
-	committees, err := BeaconCommittees(ctx, state, slot)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get beacon committees")
-	}
-	committeesPerSlot, membersPerCommittee := PtcAllocation(len(committees))
-	for i, committee := range committees {
-		if uint64(i) >= committeesPerSlot {
-			return
-		}
-		if uint64(len(committee)) < membersPerCommittee {
-			return nil, errCommitteeOverflow
-		}
-		indices = append(indices, committee[:membersPerCommittee]...)
-	}
-	return
-}
-
-// PtcAllocation returns:
-// 1. The number of beacon committees that PTC will borrow from in a slot.
-// 2. The number of validators that PTC will borrow from in a beacon committee.
-func PtcAllocation(slotCommittees int) (committeesPerSlot, membersPerCommittee uint64) {
-	committeesPerSlot = math.LargestPowerOfTwo(math.Min(uint64(slotCommittees), fieldparams.PTCSize))
-	membersPerCommittee = fieldparams.PTCSize / committeesPerSlot
-	return
-}
-
-// GetPayloadAttestingIndices returns the set of attester indices corresponding to the given PayloadAttestation.
-//
-// Spec pseudocode definition:
-//
-//	def get_payload_attesting_indices(state: BeaconState, slot: Slot,
-//		payload_attestation: PayloadAttestation) -> Set[ValidatorIndex]:
-//	"""
-//	Return the set of attesting indices corresponding to ``payload_attestation``.
-//	"""
-//	ptc = get_ptc(state, slot)
-//	return set(index for i, index in enumerate(ptc) if payload_attestation.aggregation_bits[i])
-func GetPayloadAttestingIndices(ctx context.Context, state state.ReadOnlyBeaconState, slot primitives.Slot, att *eth.PayloadAttestation) (indices []primitives.ValidatorIndex, err error) {
-	if state.Version() < version.EPBS {
-		return nil, errPreEPBSState
-	}
-
-	ptc, err := GetPayloadTimelinessCommittee(ctx, state, slot)
-	if err != nil {
-		return nil, err
-	}
-
-	for i, validatorIndex := range ptc {
-		if att.AggregationBits.BitAt(uint64(i)) {
-			indices = append(indices, validatorIndex)
-		}
-	}
-
-	return
-}
-
-// GetIndexedPayloadAttestation replaces a PayloadAttestation's AggregationBits with sorted AttestingIndices and returns an IndexedPayloadAttestation.
-//
-// Spec pseudocode definition:
-//
-//	def get_indexed_payload_attestation(state: BeaconState, slot: Slot,
-//		payload_attestation: PayloadAttestation) -> IndexedPayloadAttestation:
-//	"""
-//	Return the indexed payload attestation corresponding to ``payload_attestation``.
-//	"""
-//	attesting_indices = get_payload_attesting_indices(state, slot, payload_attestation)
-//
-//	return IndexedPayloadAttestation(
-//	attesting_indices=sorted(attesting_indices),
-//	data=payload_attestation.data,
-//	signature=payload_attestation.signature,
-//	)
-func GetIndexedPayloadAttestation(ctx context.Context, state state.ReadOnlyBeaconState, slot primitives.Slot, att *eth.PayloadAttestation) (*epbs.IndexedPayloadAttestation, error) {
-	if state.Version() < version.EPBS {
-		return nil, errPreEPBSState
-	}
-
-	attestingIndices, err := GetPayloadAttestingIndices(ctx, state, slot, att)
-	if err != nil {
-		return nil, err
-	}
-
-	slices.Sort(attestingIndices)
-
-	return &epbs.IndexedPayloadAttestation{
-		AttestingIndices: attestingIndices,
-		Data:             att.Data,
-		Signature:        att.Signature,
-	}, nil
-}
-
-// IsValidIndexedPayloadAttestation validates the given IndexedPayloadAttestation.
-//
-// Spec pseudocode definition:
-//
-//	def is_valid_indexed_payload_attestation(
-//		state: BeaconState,
-//		indexed_payload_attestation: IndexedPayloadAttestation) -> bool:
-//	"""
-//	Check if ``indexed_payload_attestation`` is not empty, has sorted and unique indices and has
-//	a valid aggregate signature.
-//	"""
-//	# Verify the data is valid
-//	if indexed_payload_attestation.data.payload_status >= PAYLOAD_INVALID_STATUS:
-//		return False
-//
-//	# Verify indices are sorted and unique
-//	indices = indexed_payload_attestation.attesting_indices
-//	if len(indices) == 0 or not indices == sorted(set(indices)):
-//		return False
-//
-//	# Verify aggregate signature
-//	pubkeys = [state.validators[i].pubkey for i in indices]
-//	domain = get_domain(state, DOMAIN_PTC_ATTESTER, None)
-//	signing_root = compute_signing_root(indexed_payload_attestation.data, domain)
-//	return bls.FastAggregateVerify(pubkeys, signing_root, indexed_payload_attestation.signature)
-func IsValidIndexedPayloadAttestation(state state.ReadOnlyBeaconState, att *epbs.IndexedPayloadAttestation) (bool, error) {
-	if state.Version() < version.EPBS {
-		return false, errPreEPBSState
-	}
-
-	// Verify the data is valid.
-	if primitives.PTCStatus(att.Data.PayloadStatus[0]) >= primitives.PAYLOAD_INVALID_STATUS {
-		return false, nil
-	}
-
-	// Verify indices are sorted and unique.
-	indices := att.AttestingIndices
-	slices.Sort(indices)
-	if len(indices) == 0 || !slices.Equal(att.AttestingIndices, indices) {
-		return false, nil
-	}
-
-	// Verify aggregate signature.
-	publicKeys := make([]bls.PublicKey, len(indices))
-	for i, index := range indices {
-		validator, err := state.ValidatorAtIndexReadOnly(index)
-		if err != nil {
-			return false, err
-		}
-
-		publicKeyBytes := validator.PublicKey()
-		publicKey, err := bls.PublicKeyFromBytes(publicKeyBytes[:])
-		if err != nil {
-			return false, err
-		}
-
-		publicKeys[i] = publicKey
-	}
-
-	domain, err := signing.Domain(
-		state.Fork(),
-		slots.ToEpoch(state.Slot()),
-		params.BeaconConfig().DomainPTCAttester,
-		state.GenesisValidatorsRoot(),
-	)
-	if err != nil {
-		return false, err
-	}
-
-	signingRoot, err := signing.ComputeSigningRoot(att.Data, domain)
-	if err != nil {
-		return false, err
-	}
-
-	signature, err := bls.SignatureFromBytes(att.Signature)
-	if err != nil {
-		return false, err
-	}
-
-	return signature.FastAggregateVerify(publicKeys, signingRoot), nil
-}
-
-// ValidatePayloadAttestationMessageSignature verifies the signature of a
-// payload attestation message.
-func ValidatePayloadAttestationMessageSignature(ctx context.Context, st state.ReadOnlyBeaconState, msg *eth.PayloadAttestationMessage) error {
-	if err := ValidateNilPayloadAttestationMessage(msg); err != nil {
-		return err
-	}
-	val, err := st.ValidatorAtIndex(msg.ValidatorIndex)
-	if err != nil {
-		return err
-	}
-	pub, err := bls.PublicKeyFromBytes(val.PublicKey)
-	if err != nil {
-		return err
-	}
-	sig, err := bls.SignatureFromBytes(msg.Signature)
-	if err != nil {
-		return err
-	}
-	currentEpoch := slots.ToEpoch(st.Slot())
-	domain, err := signing.Domain(st.Fork(), currentEpoch, params.BeaconConfig().DomainPTCAttester, st.GenesisValidatorsRoot())
-	if err != nil {
-		return err
-	}
-	root, err := signing.ComputeSigningRoot(msg.Data, domain)
-	if err != nil {
-		return err
-	}
-	if !sig.Verify(pub, root[:]) {
-		return signing.ErrSigFailedToVerify
-	}
-	return nil
-}

beacon-chain/core/helpers/payload_attestation_test.go

@@ -1,363 +0,0 @@
-package helpers_test
-
-import (
-	"context"
-	"slices"
-	"strconv"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/signing"
-	state_native "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native"
-	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v6/config/params"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/epbs"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v6/crypto/bls"
-	"github.com/OffchainLabs/prysm/v6/crypto/rand"
-	"github.com/OffchainLabs/prysm/v6/math"
-	eth "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/OffchainLabs/prysm/v6/testing/util"
-	"github.com/OffchainLabs/prysm/v6/testing/util/random"
-	"github.com/OffchainLabs/prysm/v6/time/slots"
-	"github.com/prysmaticlabs/go-bitfield"
-)
-
-func TestValidateNilPayloadAttestation(t *testing.T) {
-	require.ErrorIs(t, helpers.ErrNilData, helpers.ValidateNilPayloadAttestationData(nil))
-	data := &eth.PayloadAttestationData{}
-	require.ErrorIs(t, helpers.ErrNilBeaconBlockRoot, helpers.ValidateNilPayloadAttestationData(data))
-	data.BeaconBlockRoot = make([]byte, 32)
-	require.NoError(t, helpers.ValidateNilPayloadAttestationData(data))
-
-	require.ErrorIs(t, helpers.ErrNilMessage, helpers.ValidateNilPayloadAttestationMessage(nil))
-	message := &eth.PayloadAttestationMessage{}
-	require.ErrorIs(t, helpers.ErrNilSignature, helpers.ValidateNilPayloadAttestationMessage(message))
-	message.Signature = make([]byte, 96)
-	require.ErrorIs(t, helpers.ErrNilData, helpers.ValidateNilPayloadAttestationMessage(message))
-	message.Data = data
-	require.NoError(t, helpers.ValidateNilPayloadAttestationMessage(message))
-
-	require.ErrorIs(t, helpers.ErrNilPayloadAttestation, helpers.ValidateNilPayloadAttestation(nil))
-	att := &eth.PayloadAttestation{}
-	require.ErrorIs(t, helpers.ErrNilAggregationBits, helpers.ValidateNilPayloadAttestation(att))
-	att.AggregationBits = bitfield.NewBitvector512()
-	require.ErrorIs(t, helpers.ErrNilSignature, helpers.ValidateNilPayloadAttestation(att))
-	att.Signature = message.Signature
-	require.ErrorIs(t, helpers.ErrNilData, helpers.ValidateNilPayloadAttestation(att))
-	att.Data = data
-	require.NoError(t, helpers.ValidateNilPayloadAttestation(att))
-}
-
-func TestGetPayloadTimelinessCommittee(t *testing.T) {
-	helpers.ClearCache()
-
-	// Create 10 committees
-	committeeCount := uint64(10)
-	validatorCount := committeeCount * params.BeaconConfig().TargetCommitteeSize * uint64(params.BeaconConfig().SlotsPerEpoch)
-	validators := make([]*ethpb.Validator, validatorCount)
-
-	for i := 0; i < len(validators); i++ {
-		k := make([]byte, 48)
-		copy(k, strconv.Itoa(i))
-		validators[i] = &ethpb.Validator{
-			PublicKey:             k,
-			WithdrawalCredentials: make([]byte, 32),
-			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
-		}
-	}
-
-	state, err := state_native.InitializeFromProtoEpbs(random.BeaconState(t))
-	require.NoError(t, err)
-	require.NoError(t, state.SetValidators(validators))
-	require.NoError(t, state.SetSlot(200))
-
-	ctx := context.Background()
-	indices, err := helpers.BeaconCommitteeFromState(ctx, state, state.Slot(), 1)
-	require.NoError(t, err)
-	require.Equal(t, 128, len(indices))
-
-	epoch := slots.ToEpoch(state.Slot())
-	activeCount, err := helpers.ActiveValidatorCount(ctx, state, epoch)
-	require.NoError(t, err)
-	require.Equal(t, uint64(40960), activeCount)
-
-	computedCommitteeCount := helpers.SlotCommitteeCount(activeCount)
-	require.Equal(t, committeeCount, computedCommitteeCount)
-	committeesPerSlot := math.LargestPowerOfTwo(math.Min(committeeCount, fieldparams.PTCSize))
-	require.Equal(t, uint64(8), committeesPerSlot)
-
-	ptc, err := helpers.GetPayloadTimelinessCommittee(ctx, state, state.Slot())
-	require.NoError(t, err)
-	require.Equal(t, fieldparams.PTCSize, len(ptc))
-
-	committee1, err := helpers.BeaconCommitteeFromState(ctx, state, state.Slot(), 0)
-	require.NoError(t, err)
-
-	require.DeepEqual(t, committee1[:64], ptc[:64])
-}
-
-func Test_PtcAllocation(t *testing.T) {
-	tests := []struct {
-		committeeCount     int
-		memberPerCommittee uint64
-		committeesPerSlot  uint64
-	}{
-		{1, 512, 1},
-		{4, 128, 4},
-		{128, 4, 128},
-		{512, 1, 512},
-		{1024, 1, 512},
-	}
-
-	for _, test := range tests {
-		committeesPerSlot, memberPerCommittee := helpers.PtcAllocation(test.committeeCount)
-		if memberPerCommittee != test.memberPerCommittee {
-			t.Errorf("memberPerCommittee(%d) = %d; expected %d", test.committeeCount, memberPerCommittee, test.memberPerCommittee)
-		}
-		if committeesPerSlot != test.committeesPerSlot {
-			t.Errorf("committeesPerSlot(%d) = %d; expected %d", test.committeeCount, committeesPerSlot, test.committeesPerSlot)
-		}
-	}
-}
-
-func TestGetPayloadAttestingIndices(t *testing.T) {
-	helpers.ClearCache()
-
-	// Create 10 committees. Total 40960 validators.
-	committeeCount := uint64(10)
-	validatorCount := committeeCount * params.BeaconConfig().TargetCommitteeSize * uint64(params.BeaconConfig().SlotsPerEpoch)
-	validators := make([]*ethpb.Validator, validatorCount)
-
-	for i := 0; i < len(validators); i++ {
-		pubkey := make([]byte, 48)
-		copy(pubkey, strconv.Itoa(i))
-		validators[i] = &ethpb.Validator{
-			PublicKey:             pubkey,
-			WithdrawalCredentials: make([]byte, 32),
-			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
-		}
-	}
-
-	// Create a beacon state.
-	state, err := state_native.InitializeFromProtoEpbs(&ethpb.BeaconStateEPBS{
-		Validators:  validators,
-		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-	})
-	require.NoError(t, err)
-
-	// Get PTC.
-	ptc, err := helpers.GetPayloadTimelinessCommittee(context.Background(), state, state.Slot())
-	require.NoError(t, err)
-	require.Equal(t, fieldparams.PTCSize, len(ptc))
-
-	// Generate random indices. PTC members at the corresponding indices are considered attested.
-	randGen := rand.NewDeterministicGenerator()
-	attesterCount := randGen.Intn(fieldparams.PTCSize) + 1
-	indices := randGen.Perm(fieldparams.PTCSize)[:attesterCount]
-	slices.Sort(indices)
-	require.Equal(t, attesterCount, len(indices))
-
-	// Create a PayloadAttestation with AggregationBits set true at the indices.
-	aggregationBits := bitfield.NewBitvector512()
-	for _, index := range indices {
-		aggregationBits.SetBitAt(uint64(index), true)
-	}
-
-	payloadAttestation := &eth.PayloadAttestation{
-		AggregationBits: aggregationBits,
-		Data: &eth.PayloadAttestationData{
-			BeaconBlockRoot: make([]byte, 32),
-		},
-		Signature: make([]byte, 96),
-	}
-
-	// Get attesting indices.
-	attesters, err := helpers.GetPayloadAttestingIndices(context.Background(), state, state.Slot(), payloadAttestation)
-	require.NoError(t, err)
-	require.Equal(t, len(indices), len(attesters))
-
-	// Check if each attester equals to the PTC member at the corresponding index.
-	for i, index := range indices {
-		require.Equal(t, attesters[i], ptc[index])
-	}
-}
-
-func TestGetIndexedPayloadAttestation(t *testing.T) {
-	helpers.ClearCache()
-
-	// Create 10 committees. Total 40960 validators.
-	committeeCount := uint64(10)
-	validatorCount := committeeCount * params.BeaconConfig().TargetCommitteeSize * uint64(params.BeaconConfig().SlotsPerEpoch)
-	validators := make([]*ethpb.Validator, validatorCount)
-
-	for i := 0; i < len(validators); i++ {
-		publicKey := make([]byte, 48)
-		copy(publicKey, strconv.Itoa(i))
-		validators[i] = &ethpb.Validator{
-			PublicKey:             publicKey,
-			WithdrawalCredentials: make([]byte, 32),
-			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
-		}
-	}
-
-	// Create a beacon state.
-	state, err := state_native.InitializeFromProtoEpbs(&ethpb.BeaconStateEPBS{
-		Validators:  validators,
-		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-	})
-	require.NoError(t, err)
-
-	// Get PTC.
-	ptc, err := helpers.GetPayloadTimelinessCommittee(context.Background(), state, state.Slot())
-	require.NoError(t, err)
-	require.Equal(t, fieldparams.PTCSize, len(ptc))
-
-	// Generate random indices. PTC members at the corresponding indices are considered attested.
-	randGen := rand.NewDeterministicGenerator()
-	attesterCount := randGen.Intn(fieldparams.PTCSize) + 1
-	indices := randGen.Perm(fieldparams.PTCSize)[:attesterCount]
-	slices.Sort(indices)
-	require.Equal(t, attesterCount, len(indices))
-
-	// Create a PayloadAttestation with AggregationBits set true at the indices.
-	aggregationBits := bitfield.NewBitvector512()
-	for _, index := range indices {
-		aggregationBits.SetBitAt(uint64(index), true)
-	}
-
-	payloadAttestation := &eth.PayloadAttestation{
-		AggregationBits: aggregationBits,
-		Data: &eth.PayloadAttestationData{
-			BeaconBlockRoot: make([]byte, 32),
-		},
-		Signature: make([]byte, 96),
-	}
-
-	// Get attesting indices.
-	ctx := context.Background()
-	attesters, err := helpers.GetPayloadAttestingIndices(ctx, state, state.Slot(), payloadAttestation)
-	require.NoError(t, err)
-	require.Equal(t, len(indices), len(attesters))
-
-	// Get an IndexedPayloadAttestation.
-	indexedPayloadAttestation, err := helpers.GetIndexedPayloadAttestation(ctx, state, state.Slot(), payloadAttestation)
-	require.NoError(t, err)
-	require.Equal(t, len(indices), len(indexedPayloadAttestation.AttestingIndices))
-	require.DeepEqual(t, payloadAttestation.Data, indexedPayloadAttestation.Data)
-	require.DeepEqual(t, payloadAttestation.Signature, indexedPayloadAttestation.Signature)
-
-	// Check if the attesting indices are the same.
-	slices.Sort(attesters) // GetIndexedPayloadAttestation sorts attesting indices.
-	require.DeepEqual(t, attesters, indexedPayloadAttestation.AttestingIndices)
-}
-
-func TestIsValidIndexedPayloadAttestation(t *testing.T) {
-	helpers.ClearCache()
-
-	// Create validators.
-	validatorCount := uint64(350)
-	validators := make([]*ethpb.Validator, validatorCount)
-	_, secretKeys, err := util.DeterministicDepositsAndKeys(validatorCount)
-	require.NoError(t, err)
-
-	for i := 0; i < len(validators); i++ {
-		validators[i] = &ethpb.Validator{
-			PublicKey:             secretKeys[i].PublicKey().Marshal(),
-			WithdrawalCredentials: make([]byte, 32),
-			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
-		}
-	}
-
-	// Create a beacon state.
-	state, err := state_native.InitializeFromProtoEpbs(&ethpb.BeaconStateEPBS{
-		Validators: validators,
-		Fork: &ethpb.Fork{
-			Epoch:           0,
-			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-		},
-		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
-	})
-	require.NoError(t, err)
-
-	// Define test cases.
-	tests := []struct {
-		attestation *epbs.IndexedPayloadAttestation
-	}{
-		{
-			attestation: &epbs.IndexedPayloadAttestation{
-				AttestingIndices: []primitives.ValidatorIndex{1},
-				Data: &eth.PayloadAttestationData{
-					BeaconBlockRoot: make([]byte, fieldparams.RootLength),
-				},
-				Signature: make([]byte, fieldparams.BLSSignatureLength),
-			},
-		},
-		{
-			attestation: &epbs.IndexedPayloadAttestation{
-				AttestingIndices: []primitives.ValidatorIndex{13, 19},
-				Data: &eth.PayloadAttestationData{
-					BeaconBlockRoot: make([]byte, fieldparams.RootLength),
-				},
-				Signature: make([]byte, fieldparams.BLSSignatureLength),
-			},
-		},
-		{
-			attestation: &epbs.IndexedPayloadAttestation{
-				AttestingIndices: []primitives.ValidatorIndex{123, 234, 345},
-				Data: &eth.PayloadAttestationData{
-					BeaconBlockRoot: make([]byte, fieldparams.RootLength),
-				},
-				Signature: make([]byte, fieldparams.BLSSignatureLength),
-			},
-		},
-		{
-			attestation: &epbs.IndexedPayloadAttestation{
-				AttestingIndices: []primitives.ValidatorIndex{38, 46, 54, 62, 70, 78, 86, 194},
-				Data: &eth.PayloadAttestationData{
-					BeaconBlockRoot: make([]byte, fieldparams.RootLength),
-				},
-				Signature: make([]byte, fieldparams.BLSSignatureLength),
-			},
-		},
-		{
-			attestation: &epbs.IndexedPayloadAttestation{
-				AttestingIndices: []primitives.ValidatorIndex{5},
-				Data: &eth.PayloadAttestationData{
-					BeaconBlockRoot: make([]byte, fieldparams.RootLength),
-				},
-				Signature: make([]byte, fieldparams.BLSSignatureLength),
-			},
-		},
-	}
-
-	// Run test cases.
-	for _, test := range tests {
-		signatures := make([]bls.Signature, len(test.attestation.AttestingIndices))
-		for i, index := range test.attestation.AttestingIndices {
-			signedBytes, err := signing.ComputeDomainAndSign(
-				state,
-				slots.ToEpoch(test.attestation.Data.Slot),
-				test.attestation.Data,
-				params.BeaconConfig().DomainPTCAttester,
-				secretKeys[index],
-			)
-			require.NoError(t, err)
-
-			signature, err := bls.SignatureFromBytes(signedBytes)
-			require.NoError(t, err)
-
-			signatures[i] = signature
-		}
-
-		aggregatedSignature := bls.AggregateSignatures(signatures)
-		test.attestation.Signature = aggregatedSignature.Marshal()
-
-		isValid, err := helpers.IsValidIndexedPayloadAttestation(state, test.attestation)
-		require.NoError(t, err)
-		require.Equal(t, true, isValid)
-	}
-}

beacon-chain/core/helpers/sync_committee_test.go

@@ -78,6 +78,7 @@ func TestIsCurrentEpochSyncCommittee_UsingCommittee(t *testing.T) {
 
 func TestIsCurrentEpochSyncCommittee_DoesNotExist(t *testing.T) {
 	helpers.ClearCache()
+	params.SetupTestConfigCleanup(t)
 
 	validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize)
 	syncCommittee := &ethpb.SyncCommittee{
@@ -264,6 +265,7 @@ func TestCurrentEpochSyncSubcommitteeIndices_UsingCommittee(t *testing.T) {
 }
 
 func TestCurrentEpochSyncSubcommitteeIndices_DoesNotExist(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
 	helpers.ClearCache()
 
 	validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize)

beacon-chain/core/helpers/validators.go

@@ -319,7 +319,7 @@ func beaconProposerIndexAtSlotFulu(state state.ReadOnlyBeaconState, slot primiti
 // BeaconProposerIndexAtSlot returns proposer index at the given slot from the
 // point of view of the given state as head state
 func BeaconProposerIndexAtSlot(ctx context.Context, state state.ReadOnlyBeaconState, slot primitives.Slot) (primitives.ValidatorIndex, error) {
-	if state.Version() >= version.Fulu && state.Version() != version.EPBS {
+	if state.Version() >= version.Fulu {
 		return beaconProposerIndexAtSlotFulu(state, slot)
 	}
 	e := slots.ToEpoch(slot)

beacon-chain/core/helpers/weak_subjectivity.go

@@ -206,9 +206,9 @@ func ParseWeakSubjectivityInputString(wsCheckpointString string) (*v1alpha1.Chec
 // 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/dev/specs/phase0/p2p-interface.md#configuration
+// 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/dev/specs/phase0/p2p-interface.md#why-are-blocksbyrange-requests-only-required-to-be-served-for-the-latest-min_epochs_for_block_requests-epochs
+// 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

@@ -292,7 +292,7 @@ func TestMinEpochsForBlockRequests(t *testing.T) {
 	params.SetActiveTestCleanup(t, params.MainnetConfig())
 	var expected primitives.Epoch = 33024
 	// expected value of 33024 via spec commentary:
-	// https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/p2p-interface.md#why-are-blocksbyrange-requests-only-required-to-be-served-for-the-latest-min_epochs_for_block_requests-epochs
+	// 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 = (

beacon-chain/core/light-client/BUILD.bazel

@@ -10,8 +10,12 @@ go_library(
     importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client",
     visibility = ["//visibility:public"],
     deps = [
+        "//async/event:go_default_library",
+        "//beacon-chain/core/feed:go_default_library",
+        "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/db/iface:go_default_library",
         "//beacon-chain/execution:go_default_library",
+        "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
@@ -39,6 +43,9 @@ go_test(
     ],
     deps = [
         ":go_default_library",
+        "//async/event:go_default_library",
+        "//beacon-chain/db/testing:go_default_library",
+        "//beacon-chain/p2p/testing:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types:go_default_library",

beacon-chain/core/light-client/lightclient.go

@@ -750,7 +750,9 @@ func UpdateHasSupermajority(syncAggregate *pb.SyncAggregate) bool {
 	return numActiveParticipants*3 >= maxActiveParticipants*2
 }
 
-func IsBetterFinalityUpdate(newUpdate, oldUpdate interfaces.LightClientFinalityUpdate) bool {
+// IsFinalityUpdateValidForBroadcast checks if a finality update needs to be broadcasted.
+// It is also used to check if an incoming gossiped finality update is valid for forwarding and saving.
+func IsFinalityUpdateValidForBroadcast(newUpdate, oldUpdate interfaces.LightClientFinalityUpdate) bool {
 	if oldUpdate == nil {
 		return true
 	}
@@ -772,6 +774,35 @@ func IsBetterFinalityUpdate(newUpdate, oldUpdate interfaces.LightClientFinalityU
 	return true
 }
 
+// IsBetterFinalityUpdate checks if the new finality update is better than the old one for saving.
+// This does not concern broadcasting, but rather the decision of whether to save the new update.
+// For broadcasting checks, use IsFinalityUpdateValidForBroadcast.
+func IsBetterFinalityUpdate(newUpdate, oldUpdate interfaces.LightClientFinalityUpdate) bool {
+	if oldUpdate == nil {
+		return true
+	}
+
+	// Full nodes SHOULD provide the LightClientFinalityUpdate with the highest attested_header.beacon.slot (if multiple, highest signature_slot)
+	newFinalizedSlot := newUpdate.FinalizedHeader().Beacon().Slot
+	newAttestedSlot := newUpdate.AttestedHeader().Beacon().Slot
+
+	oldFinalizedSlot := oldUpdate.FinalizedHeader().Beacon().Slot
+	oldAttestedSlot := oldUpdate.AttestedHeader().Beacon().Slot
+
+	if newFinalizedSlot < oldFinalizedSlot {
+		return false
+	}
+	if newFinalizedSlot == oldFinalizedSlot {
+		if newAttestedSlot < oldAttestedSlot {
+			return false
+		}
+		if newAttestedSlot == oldAttestedSlot && newUpdate.SignatureSlot() <= oldUpdate.SignatureSlot() {
+			return false
+		}
+	}
+	return true
+}
+
 func IsBetterOptimisticUpdate(newUpdate, oldUpdate interfaces.LightClientOptimisticUpdate) bool {
 	if oldUpdate == nil {
 		return true

beacon-chain/core/light-client/store.go

@@ -4,7 +4,11 @@ import (
 	"context"
 	"sync"
 
+	"github.com/OffchainLabs/prysm/v6/async/event"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed"
+	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/iface"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/pkg/errors"
 	log "github.com/sirupsen/logrus"
@@ -16,13 +20,17 @@ type Store struct {
 	mu sync.RWMutex
 
 	beaconDB             iface.HeadAccessDatabase
-	lastFinalityUpdate   interfaces.LightClientFinalityUpdate
-	lastOptimisticUpdate interfaces.LightClientOptimisticUpdate
+	lastFinalityUpdate   interfaces.LightClientFinalityUpdate   // tracks the best finality update seen so far
+	lastOptimisticUpdate interfaces.LightClientOptimisticUpdate // tracks the best optimistic update seen so far
+	p2p                  p2p.Accessor
+	stateFeed            event.SubscriberSender
 }
 
-func NewLightClientStore(db iface.HeadAccessDatabase) *Store {
+func NewLightClientStore(db iface.HeadAccessDatabase, p p2p.Accessor, e event.SubscriberSender) *Store {
 	return &Store{
-		beaconDB: db,
+		beaconDB:  db,
+		p2p:       p,
+		stateFeed: e,
 	}
 }
 
@@ -143,10 +151,23 @@ func (s *Store) SaveLightClientUpdate(ctx context.Context, period uint64, update
 	return nil
 }
 
-func (s *Store) SetLastFinalityUpdate(update interfaces.LightClientFinalityUpdate) {
+func (s *Store) SetLastFinalityUpdate(update interfaces.LightClientFinalityUpdate, broadcast bool) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
+
+	if broadcast && IsFinalityUpdateValidForBroadcast(update, s.lastFinalityUpdate) {
+		if err := s.p2p.BroadcastLightClientFinalityUpdate(context.Background(), update); err != nil {
+			log.WithError(err).Error("Could not broadcast light client finality update")
+		}
+	}
+
 	s.lastFinalityUpdate = update
+	log.Debug("Saved new light client finality update")
+
+	s.stateFeed.Send(&feed.Event{
+		Type: statefeed.LightClientFinalityUpdate,
+		Data: update,
+	})
 }
 
 func (s *Store) LastFinalityUpdate() interfaces.LightClientFinalityUpdate {
@@ -155,10 +176,23 @@ func (s *Store) LastFinalityUpdate() interfaces.LightClientFinalityUpdate {
 	return s.lastFinalityUpdate
 }
 
-func (s *Store) SetLastOptimisticUpdate(update interfaces.LightClientOptimisticUpdate) {
+func (s *Store) SetLastOptimisticUpdate(update interfaces.LightClientOptimisticUpdate, broadcast bool) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
+
+	if broadcast {
+		if err := s.p2p.BroadcastLightClientOptimisticUpdate(context.Background(), update); err != nil {
+			log.WithError(err).Error("Could not broadcast light client optimistic update")
+		}
+	}
+
 	s.lastOptimisticUpdate = update
+	log.Debug("Saved new light client optimistic update")
+
+	s.stateFeed.Send(&feed.Event{
+		Type: statefeed.LightClientOptimisticUpdate,
+		Data: update,
+	})
 }
 
 func (s *Store) LastOptimisticUpdate() interfaces.LightClientOptimisticUpdate {

beacon-chain/core/light-client/store_test.go

@@ -3,7 +3,10 @@ package light_client_test
 import (
 	"testing"
 
+	"github.com/OffchainLabs/prysm/v6/async/event"
 	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
+	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
+	p2pTesting "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
@@ -21,7 +24,7 @@ func TestLightClientStore(t *testing.T) {
 	params.OverrideBeaconConfig(cfg)
 
 	// Initialize the light client store
-	lcStore := &lightClient.Store{}
+	lcStore := lightClient.NewLightClientStore(testDB.SetupDB(t), &p2pTesting.FakeP2P{}, new(event.Feed))
 
 	// Create test light client updates for Capella and Deneb
 	lCapella := util.NewTestLightClient(t, version.Capella)
@@ -45,24 +48,118 @@ func TestLightClientStore(t *testing.T) {
 	require.IsNil(t, lcStore.LastOptimisticUpdate(), "lastOptimisticUpdate should be nil")
 
 	// Set and get finality with Capella update. Optimistic update should be nil
-	lcStore.SetLastFinalityUpdate(finUpdateCapella)
+	lcStore.SetLastFinalityUpdate(finUpdateCapella, false)
 	require.Equal(t, finUpdateCapella, lcStore.LastFinalityUpdate(), "lastFinalityUpdate is wrong")
 	require.IsNil(t, lcStore.LastOptimisticUpdate(), "lastOptimisticUpdate should be nil")
 
 	// Set and get optimistic with Capella update. Finality update should be Capella
-	lcStore.SetLastOptimisticUpdate(opUpdateCapella)
+	lcStore.SetLastOptimisticUpdate(opUpdateCapella, false)
 	require.Equal(t, opUpdateCapella, lcStore.LastOptimisticUpdate(), "lastOptimisticUpdate is wrong")
 	require.Equal(t, finUpdateCapella, lcStore.LastFinalityUpdate(), "lastFinalityUpdate is wrong")
 
 	// Set and get finality and optimistic with Deneb update
-	lcStore.SetLastFinalityUpdate(finUpdateDeneb)
-	lcStore.SetLastOptimisticUpdate(opUpdateDeneb)
+	lcStore.SetLastFinalityUpdate(finUpdateDeneb, false)
+	lcStore.SetLastOptimisticUpdate(opUpdateDeneb, false)
 	require.Equal(t, finUpdateDeneb, lcStore.LastFinalityUpdate(), "lastFinalityUpdate is wrong")
 	require.Equal(t, opUpdateDeneb, lcStore.LastOptimisticUpdate(), "lastOptimisticUpdate is wrong")
-
-	// Set and get finality and optimistic with nil update
-	lcStore.SetLastFinalityUpdate(nil)
-	lcStore.SetLastOptimisticUpdate(nil)
-	require.IsNil(t, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should be nil")
-	require.IsNil(t, lcStore.LastOptimisticUpdate(), "lastOptimisticUpdate should be nil")
+}
+
+func TestLightClientStore_SetLastFinalityUpdate(t *testing.T) {
+	p2p := p2pTesting.NewTestP2P(t)
+	lcStore := lightClient.NewLightClientStore(testDB.SetupDB(t), p2p, new(event.Feed))
+
+	// update 0 with basic data and no supermajority following an empty lastFinalityUpdate - should save and broadcast
+	l0 := util.NewTestLightClient(t, version.Altair)
+	update0, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l0.Ctx, l0.State, l0.Block, l0.AttestedState, l0.AttestedBlock, l0.FinalizedBlock)
+	require.NoError(t, err, "Failed to create light client finality update")
+
+	require.Equal(t, true, lightClient.IsBetterFinalityUpdate(update0, lcStore.LastFinalityUpdate()), "update0 should be better than nil")
+	// update0 should be valid for broadcast - meaning it should be broadcasted
+	require.Equal(t, true, lightClient.IsFinalityUpdateValidForBroadcast(update0, lcStore.LastFinalityUpdate()), "update0 should be valid for broadcast")
+
+	lcStore.SetLastFinalityUpdate(update0, true)
+	require.Equal(t, update0, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
+	require.Equal(t, true, p2p.BroadcastCalled.Load(), "Broadcast should have been called after setting a new last finality update when previous is nil")
+	p2p.BroadcastCalled.Store(false) // Reset for next test
+
+	// update 1 with same finality slot, increased attested slot, and no supermajority - should save but not broadcast
+	l1 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(1))
+	update1, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l1.Ctx, l1.State, l1.Block, l1.AttestedState, l1.AttestedBlock, l1.FinalizedBlock)
+	require.NoError(t, err, "Failed to create light client finality update")
+
+	require.Equal(t, true, lightClient.IsBetterFinalityUpdate(update1, update0), "update1 should be better than update0")
+	// update1 should not be valid for broadcast - meaning it should not be broadcasted
+	require.Equal(t, false, lightClient.IsFinalityUpdateValidForBroadcast(update1, lcStore.LastFinalityUpdate()), "update1 should not be valid for broadcast")
+
+	lcStore.SetLastFinalityUpdate(update1, true)
+	require.Equal(t, update1, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
+	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been called after setting a new last finality update without supermajority")
+	p2p.BroadcastCalled.Store(false) // Reset for next test
+
+	// update 2 with same finality slot, increased attested slot, and supermajority - should save and broadcast
+	l2 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(2), util.WithSupermajority())
+	update2, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock)
+	require.NoError(t, err, "Failed to create light client finality update")
+
+	require.Equal(t, true, lightClient.IsBetterFinalityUpdate(update2, update1), "update2 should be better than update1")
+	// update2 should be valid for broadcast - meaning it should be broadcasted
+	require.Equal(t, true, lightClient.IsFinalityUpdateValidForBroadcast(update2, lcStore.LastFinalityUpdate()), "update2 should be valid for broadcast")
+
+	lcStore.SetLastFinalityUpdate(update2, true)
+	require.Equal(t, update2, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
+	require.Equal(t, true, p2p.BroadcastCalled.Load(), "Broadcast should have been called after setting a new last finality update with supermajority")
+	p2p.BroadcastCalled.Store(false) // Reset for next test
+
+	// update 3 with same finality slot, increased attested slot, and supermajority - should save but not broadcast
+	l3 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(3), util.WithSupermajority())
+	update3, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l3.Ctx, l3.State, l3.Block, l3.AttestedState, l3.AttestedBlock, l3.FinalizedBlock)
+	require.NoError(t, err, "Failed to create light client finality update")
+
+	require.Equal(t, true, lightClient.IsBetterFinalityUpdate(update3, update2), "update3 should be better than update2")
+	// update3 should not be valid for broadcast - meaning it should not be broadcasted
+	require.Equal(t, false, lightClient.IsFinalityUpdateValidForBroadcast(update3, lcStore.LastFinalityUpdate()), "update3 should not be valid for broadcast")
+
+	lcStore.SetLastFinalityUpdate(update3, true)
+	require.Equal(t, update3, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
+	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been when previous was already broadcast")
+
+	// update 4 with increased finality slot, increased attested slot, and supermajority - should save and broadcast
+	l4 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedFinalizedSlot(1), util.WithIncreasedAttestedSlot(1), util.WithSupermajority())
+	update4, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l4.Ctx, l4.State, l4.Block, l4.AttestedState, l4.AttestedBlock, l4.FinalizedBlock)
+	require.NoError(t, err, "Failed to create light client finality update")
+
+	require.Equal(t, true, lightClient.IsBetterFinalityUpdate(update4, update3), "update4 should be better than update3")
+	// update4 should be valid for broadcast - meaning it should be broadcasted
+	require.Equal(t, true, lightClient.IsFinalityUpdateValidForBroadcast(update4, lcStore.LastFinalityUpdate()), "update4 should be valid for broadcast")
+
+	lcStore.SetLastFinalityUpdate(update4, true)
+	require.Equal(t, update4, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
+	require.Equal(t, true, p2p.BroadcastCalled.Load(), "Broadcast should have been called after a new finality update with increased finality slot")
+	p2p.BroadcastCalled.Store(false) // Reset for next test
+
+	// update 5 with the same new finality slot, increased attested slot, and supermajority - should save but not broadcast
+	l5 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedFinalizedSlot(1), util.WithIncreasedAttestedSlot(2), util.WithSupermajority())
+	update5, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l5.Ctx, l5.State, l5.Block, l5.AttestedState, l5.AttestedBlock, l5.FinalizedBlock)
+	require.NoError(t, err, "Failed to create light client finality update")
+
+	require.Equal(t, true, lightClient.IsBetterFinalityUpdate(update5, update4), "update5 should be better than update4")
+	// update5 should not be valid for broadcast - meaning it should not be broadcasted
+	require.Equal(t, false, lightClient.IsFinalityUpdateValidForBroadcast(update5, lcStore.LastFinalityUpdate()), "update5 should not be valid for broadcast")
+
+	lcStore.SetLastFinalityUpdate(update5, true)
+	require.Equal(t, update5, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
+	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been called when previous was already broadcast with supermajority")
+
+	// update 6 with the same new finality slot, increased attested slot, and no supermajority - should save but not broadcast
+	l6 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedFinalizedSlot(1), util.WithIncreasedAttestedSlot(3))
+	update6, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l6.Ctx, l6.State, l6.Block, l6.AttestedState, l6.AttestedBlock, l6.FinalizedBlock)
+	require.NoError(t, err, "Failed to create light client finality update")
+
+	require.Equal(t, true, lightClient.IsBetterFinalityUpdate(update6, update5), "update6 should be better than update5")
+	// update6 should not be valid for broadcast - meaning it should not be broadcasted
+	require.Equal(t, false, lightClient.IsFinalityUpdateValidForBroadcast(update6, lcStore.LastFinalityUpdate()), "update6 should not be valid for broadcast")
+
+	lcStore.SetLastFinalityUpdate(update6, true)
+	require.Equal(t, update6, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
+	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been called when previous was already broadcast with supermajority")
 }

beacon-chain/core/peerdas/BUILD.bazel

@@ -16,7 +16,6 @@ go_library(
     deps = [
         "//beacon-chain/blockchain/kzg:go_default_library",
         "//beacon-chain/state:go_default_library",
-        "//cmd/beacon-chain/flags:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
@@ -53,7 +52,6 @@ go_test(
         ":go_default_library",
         "//beacon-chain/blockchain/kzg:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
-        "//cmd/beacon-chain/flags:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",

beacon-chain/core/peerdas/das_core.go

@@ -31,27 +31,20 @@ var (
 	maxUint256 = &uint256.Int{math.MaxUint64, math.MaxUint64, math.MaxUint64, math.MaxUint64}
 )
 
-type CustodyType int
-
-const (
-	Target CustodyType = iota
-	Actual
-)
-
 // CustodyGroups computes the custody groups the node should participate in for custody.
-// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/das-core.md#get_custody_groups
+// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/das-core.md#get_custody_groups
 func CustodyGroups(nodeId enode.ID, custodyGroupCount uint64) ([]uint64, error) {
-	numberOfCustodyGroup := params.BeaconConfig().NumberOfCustodyGroups
+	numberOfCustodyGroups := params.BeaconConfig().NumberOfCustodyGroups
 
 	// Check if the custody group count is larger than the number of custody groups.
-	if custodyGroupCount > numberOfCustodyGroup {
+	if custodyGroupCount > numberOfCustodyGroups {
 		return nil, ErrCustodyGroupCountTooLarge
 	}
 
 	// Shortcut if all custody groups are needed.
-	if custodyGroupCount == numberOfCustodyGroup {
-		custodyGroups := make([]uint64, 0, numberOfCustodyGroup)
-		for i := range numberOfCustodyGroup {
+	if custodyGroupCount == numberOfCustodyGroups {
+		custodyGroups := make([]uint64, 0, numberOfCustodyGroups)
+		for i := range numberOfCustodyGroups {
 			custodyGroups = append(custodyGroups, i)
 		}
 
@@ -73,7 +66,7 @@ func CustodyGroups(nodeId enode.ID, custodyGroupCount uint64) ([]uint64, error)
 		hashedCurrentId := hash.Hash(currentIdBytesLittleEndian)
 
 		// Get the custody group ID.
-		custodyGroup := binary.LittleEndian.Uint64(hashedCurrentId[:8]) % numberOfCustodyGroup
+		custodyGroup := binary.LittleEndian.Uint64(hashedCurrentId[:8]) % numberOfCustodyGroups
 
 		// Add the custody group to the map.
 		if !custodyGroupsMap[custodyGroup] {
@@ -88,9 +81,6 @@ func CustodyGroups(nodeId enode.ID, custodyGroupCount uint64) ([]uint64, error)
 			// Increment the current ID.
 			currentId.Add(currentId, one)
 		}
-
-		// Sort the custody groups.
-		slices.Sort[[]uint64](custodyGroups)
 	}
 
 	// Final check.
@@ -98,26 +88,29 @@ func CustodyGroups(nodeId enode.ID, custodyGroupCount uint64) ([]uint64, error)
 		return nil, errWrongComputedCustodyGroupCount
 	}
 
+	// Sort the custody groups.
+	slices.Sort[[]uint64](custodyGroups)
+
 	return custodyGroups, nil
 }
 
 // ComputeColumnsForCustodyGroup computes the columns for a given custody group.
-// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/das-core.md#compute_columns_for_custody_group
+// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/das-core.md#compute_columns_for_custody_group
 func ComputeColumnsForCustodyGroup(custodyGroup uint64) ([]uint64, error) {
 	beaconConfig := params.BeaconConfig()
-	numberOfCustodyGroup := beaconConfig.NumberOfCustodyGroups
+	numberOfCustodyGroups := beaconConfig.NumberOfCustodyGroups
 
-	if custodyGroup >= numberOfCustodyGroup {
+	if custodyGroup >= numberOfCustodyGroups {
 		return nil, ErrCustodyGroupTooLarge
 	}
 
 	numberOfColumns := beaconConfig.NumberOfColumns
 
-	columnsPerGroup := numberOfColumns / numberOfCustodyGroup
+	columnsPerGroup := numberOfColumns / numberOfCustodyGroups
 
 	columns := make([]uint64, 0, columnsPerGroup)
 	for i := range columnsPerGroup {
-		column := numberOfCustodyGroup*i + custodyGroup
+		column := numberOfCustodyGroups*i + custodyGroup
 		columns = append(columns, column)
 	}
 
@@ -127,7 +120,7 @@ func ComputeColumnsForCustodyGroup(custodyGroup uint64) ([]uint64, error) {
 // DataColumnSidecars computes the data column sidecars from the signed block, cells and cell proofs.
 // The returned value contains pointers to function parameters.
 // (If the caller alterates `cellsAndProofs` afterwards, the returned value will be modified as well.)
-// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.3/specs/fulu/das-core.md#get_data_column_sidecars
+// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#get_data_column_sidecars_from_block
 func DataColumnSidecars(signedBlock interfaces.ReadOnlySignedBeaconBlock, cellsAndProofs []kzg.CellsAndProofs) ([]*ethpb.DataColumnSidecar, error) {
 	if signedBlock == nil || signedBlock.IsNil() || len(cellsAndProofs) == 0 {
 		return nil, nil
@@ -151,7 +144,7 @@ func DataColumnSidecars(signedBlock interfaces.ReadOnlySignedBeaconBlock, cellsA
 
 	kzgCommitmentsInclusionProof, err := blocks.MerkleProofKZGCommitments(blockBody)
 	if err != nil {
-		return nil, errors.Wrap(err, "merkle proof ZKG commitments")
+		return nil, errors.Wrap(err, "merkle proof KZG commitments")
 	}
 
 	dataColumnSidecars, err := dataColumnsSidecars(signedBlockHeader, blobKzgCommitments, kzgCommitmentsInclusionProof, cellsAndProofs)
@@ -176,19 +169,6 @@ func ComputeCustodyGroupForColumn(columnIndex uint64) (uint64, error) {
 	return columnIndex % numberOfCustodyGroups, nil
 }
 
-// CustodyGroupSamplingSize returns the number of custody groups the node should sample from.
-// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/das-core.md#custody-sampling
-func (custodyInfo *CustodyInfo) CustodyGroupSamplingSize(ct CustodyType) uint64 {
-	custodyGroupCount := custodyInfo.TargetGroupCount.Get()
-
-	if ct == Actual {
-		custodyGroupCount = custodyInfo.ActualGroupCount()
-	}
-
-	samplesPerSlot := params.BeaconConfig().SamplesPerSlot
-	return max(samplesPerSlot, custodyGroupCount)
-}
-
 // CustodyColumns computes the custody columns from the custody groups.
 func CustodyColumns(custodyGroups []uint64) (map[uint64]bool, error) {
 	numberOfCustodyGroups := params.BeaconConfig().NumberOfCustodyGroups
@@ -219,6 +199,7 @@ func CustodyColumns(custodyGroups []uint64) (map[uint64]bool, error) {
 // the KZG commitment includion proofs and cells and cell proofs.
 // The returned value contains pointers to function parameters.
 // (If the caller alterates input parameters afterwards, the returned value will be modified as well.)
+// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#get_data_column_sidecars
 func dataColumnsSidecars(
 	signedBlockHeader *ethpb.SignedBeaconBlockHeader,
 	blobKzgCommitments [][]byte,

beacon-chain/core/peerdas/das_core_test.go

@@ -17,8 +17,8 @@ func TestCustodyGroups(t *testing.T) {
 	// --------------------------------------------
 	// The happy path is unit tested in spec tests.
 	// --------------------------------------------
-	numberOfCustodyGroup := params.BeaconConfig().NumberOfCustodyGroups
-	_, err := peerdas.CustodyGroups(enode.ID{}, numberOfCustodyGroup+1)
+	numberOfCustodyGroups := params.BeaconConfig().NumberOfCustodyGroups
+	_, err := peerdas.CustodyGroups(enode.ID{}, numberOfCustodyGroups+1)
 	require.ErrorIs(t, err, peerdas.ErrCustodyGroupCountTooLarge)
 }
 
@@ -26,8 +26,8 @@ func TestComputeColumnsForCustodyGroup(t *testing.T) {
 	// --------------------------------------------
 	// The happy path is unit tested in spec tests.
 	// --------------------------------------------
-	numberOfCustodyGroup := params.BeaconConfig().NumberOfCustodyGroups
-	_, err := peerdas.ComputeColumnsForCustodyGroup(numberOfCustodyGroup)
+	numberOfCustodyGroups := params.BeaconConfig().NumberOfCustodyGroups
+	_, err := peerdas.ComputeColumnsForCustodyGroup(numberOfCustodyGroups)
 	require.ErrorIs(t, err, peerdas.ErrCustodyGroupTooLarge)
 }
 
@@ -104,62 +104,6 @@ func TestComputeCustodyGroupForColumn(t *testing.T) {
 	})
 }
 
-func TestCustodyGroupSamplingSize(t *testing.T) {
-	testCases := []struct {
-		name                         string
-		custodyType                  peerdas.CustodyType
-		validatorsCustodyRequirement uint64
-		toAdvertiseCustodyGroupCount uint64
-		expected                     uint64
-	}{
-		{
-			name:                         "target, lower than samples per slot",
-			custodyType:                  peerdas.Target,
-			validatorsCustodyRequirement: 2,
-			expected:                     8,
-		},
-		{
-			name:                         "target, higher than samples per slot",
-			custodyType:                  peerdas.Target,
-			validatorsCustodyRequirement: 100,
-			expected:                     100,
-		},
-		{
-			name:                         "actual, lower than samples per slot",
-			custodyType:                  peerdas.Actual,
-			validatorsCustodyRequirement: 3,
-			toAdvertiseCustodyGroupCount: 4,
-			expected:                     8,
-		},
-		{
-			name:                         "actual, higher than samples per slot",
-			custodyType:                  peerdas.Actual,
-			validatorsCustodyRequirement: 100,
-			toAdvertiseCustodyGroupCount: 101,
-			expected:                     100,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			// Create a custody info.
-			custodyInfo := peerdas.CustodyInfo{}
-
-			// Set the validators custody requirement for target custody group count.
-			custodyInfo.TargetGroupCount.SetValidatorsCustodyRequirement(tc.validatorsCustodyRequirement)
-
-			// Set the to advertise custody group count.
-			custodyInfo.ToAdvertiseGroupCount.Set(tc.toAdvertiseCustodyGroupCount)
-
-			// Compute the custody group sampling size.
-			actual := custodyInfo.CustodyGroupSamplingSize(tc.custodyType)
-
-			// Check the result.
-			require.Equal(t, tc.expected, actual)
-		})
-	}
-}
-
 func TestCustodyColumns(t *testing.T) {
 	t.Run("group too large", func(t *testing.T) {
 		_, err := peerdas.CustodyColumns([]uint64{1_000_000})

beacon-chain/core/peerdas/info.go

@@ -4,45 +4,17 @@ import (
 	"encoding/binary"
 	"sync"
 
-	"github.com/OffchainLabs/prysm/v6/cmd/beacon-chain/flags"
-	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	lru "github.com/hashicorp/golang-lru"
 	"github.com/pkg/errors"
 )
 
 // info contains all useful peerDAS related information regarding a peer.
-type (
-	info struct {
-		CustodyGroups      map[uint64]bool
-		CustodyColumns     map[uint64]bool
-		DataColumnsSubnets map[uint64]bool
-	}
-
-	targetCustodyGroupCount struct {
-		mut                          sync.RWMutex
-		validatorsCustodyRequirement uint64
-	}
-
-	toAdverstiseCustodyGroupCount struct {
-		mut   sync.RWMutex
-		value uint64
-	}
-
-	CustodyInfo struct {
-		// Mut is a mutex to be used by caller to ensure neither
-		// TargetCustodyGroupCount nor ToAdvertiseCustodyGroupCount are being modified.
-		// (This is not necessary to use this mutex for any data protection.)
-		Mut sync.RWMutex
-
-		// TargetGroupCount represents the target number of custody groups we should custody
-		// regarding the validators we are tracking.
-		TargetGroupCount targetCustodyGroupCount
-
-		// ToAdvertiseGroupCount represents the number of custody groups to advertise to the network.
-		ToAdvertiseGroupCount toAdverstiseCustodyGroupCount
-	}
-)
+type info struct {
+	CustodyGroups      map[uint64]bool
+	CustodyColumns     map[uint64]bool
+	DataColumnsSubnets map[uint64]bool
+}
 
 const (
 	nodeInfoCacheSize   = 200
@@ -109,61 +81,6 @@ func Info(nodeID enode.ID, custodyGroupCount uint64) (*info, bool, error) {
 	return result, false, nil
 }
 
-// ActualGroupCount returns the actual custody group count.
-func (custodyInfo *CustodyInfo) ActualGroupCount() uint64 {
-	return min(custodyInfo.TargetGroupCount.Get(), custodyInfo.ToAdvertiseGroupCount.Get())
-}
-
-// CustodyGroupCount returns the number of groups we should participate in for custody.
-func (tcgc *targetCustodyGroupCount) Get() uint64 {
-	// If subscribed to all subnets, return the number of custody groups.
-	if flags.Get().SubscribeAllDataSubnets {
-		return params.BeaconConfig().NumberOfCustodyGroups
-	}
-
-	tcgc.mut.RLock()
-	defer tcgc.mut.RUnlock()
-
-	// If no validators are tracked, return the default custody requirement.
-	if tcgc.validatorsCustodyRequirement == 0 {
-		return params.BeaconConfig().CustodyRequirement
-	}
-
-	// Return the validators custody requirement.
-	return tcgc.validatorsCustodyRequirement
-}
-
-// setValidatorsCustodyRequirement sets the validators custody requirement.
-func (tcgc *targetCustodyGroupCount) SetValidatorsCustodyRequirement(value uint64) {
-	tcgc.mut.Lock()
-	defer tcgc.mut.Unlock()
-
-	tcgc.validatorsCustodyRequirement = value
-}
-
-// Get returns the to advertise custody group count.
-func (tacgc *toAdverstiseCustodyGroupCount) Get() uint64 {
-	// If subscribed to all subnets, return the number of custody groups.
-	if flags.Get().SubscribeAllDataSubnets {
-		return params.BeaconConfig().NumberOfCustodyGroups
-	}
-
-	custodyRequirement := params.BeaconConfig().CustodyRequirement
-
-	tacgc.mut.RLock()
-	defer tacgc.mut.RUnlock()
-
-	return max(tacgc.value, custodyRequirement)
-}
-
-// Set sets the to advertise custody group count.
-func (tacgc *toAdverstiseCustodyGroupCount) Set(value uint64) {
-	tacgc.mut.Lock()
-	defer tacgc.mut.Unlock()
-
-	tacgc.value = value
-}
-
 // createInfoCacheIfNeeded creates a new cache if it doesn't exist.
 func createInfoCacheIfNeeded() error {
 	nodeInfoCacheMut.Lock()

beacon-chain/core/peerdas/info_test.go

@@ -4,7 +4,6 @@ import (
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
-	"github.com/OffchainLabs/prysm/v6/cmd/beacon-chain/flags"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/ethereum/go-ethereum/p2p/enode"
 )
@@ -26,108 +25,3 @@ func TestInfo(t *testing.T) {
 		require.DeepEqual(t, expectedDataColumnsSubnets, actual.DataColumnsSubnets)
 	}
 }
-
-func TestTargetCustodyGroupCount(t *testing.T) {
-	testCases := []struct {
-		name                         string
-		subscribeToAllColumns        bool
-		validatorsCustodyRequirement uint64
-		expected                     uint64
-	}{
-		{
-			name:                         "subscribed to all data subnets",
-			subscribeToAllColumns:        true,
-			validatorsCustodyRequirement: 100,
-			expected:                     128,
-		},
-		{
-			name:                         "no validators attached",
-			subscribeToAllColumns:        false,
-			validatorsCustodyRequirement: 0,
-			expected:                     4,
-		},
-		{
-			name:                         "some validators attached",
-			subscribeToAllColumns:        false,
-			validatorsCustodyRequirement: 100,
-			expected:                     100,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			// Subscribe to all subnets if needed.
-			if tc.subscribeToAllColumns {
-				resetFlags := flags.Get()
-				gFlags := new(flags.GlobalFlags)
-				gFlags.SubscribeAllDataSubnets = true
-				flags.Init(gFlags)
-				defer flags.Init(resetFlags)
-			}
-
-			var custodyInfo peerdas.CustodyInfo
-
-			// Set the validators custody requirement.
-			custodyInfo.TargetGroupCount.SetValidatorsCustodyRequirement(tc.validatorsCustodyRequirement)
-
-			// Get the target custody group count.
-			actual := custodyInfo.TargetGroupCount.Get()
-
-			// Compare the expected and actual values.
-			require.Equal(t, tc.expected, actual)
-		})
-	}
-}
-
-func TestToAdvertiseCustodyGroupCount(t *testing.T) {
-	testCases := []struct {
-		name                         string
-		subscribeToAllColumns        bool
-		toAdvertiseCustodyGroupCount uint64
-		expected                     uint64
-	}{
-		{
-			name:                         "subscribed to all subnets",
-			subscribeToAllColumns:        true,
-			toAdvertiseCustodyGroupCount: 100,
-			expected:                     128,
-		},
-		{
-			name:                         "higher than custody requirement",
-			subscribeToAllColumns:        false,
-			toAdvertiseCustodyGroupCount: 100,
-			expected:                     100,
-		},
-		{
-			name:                         "lower than custody requirement",
-			subscribeToAllColumns:        false,
-			toAdvertiseCustodyGroupCount: 1,
-			expected:                     4,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			// Subscribe to all subnets if needed.
-			if tc.subscribeToAllColumns {
-				resetFlags := flags.Get()
-				gFlags := new(flags.GlobalFlags)
-				gFlags.SubscribeAllDataSubnets = true
-				flags.Init(gFlags)
-				defer flags.Init(resetFlags)
-			}
-
-			// Create a custody info.
-			var custodyInfo peerdas.CustodyInfo
-
-			// Set the to advertise custody group count.
-			custodyInfo.ToAdvertiseGroupCount.Set(tc.toAdvertiseCustodyGroupCount)
-
-			// Get the to advertise custody group count.
-			actual := custodyInfo.ToAdvertiseGroupCount.Get()
-
-			// Compare the expected and actual values.
-			require.Equal(t, tc.expected, actual)
-		})
-	}
-}