fix gen-logs.sh bug

.ethspecify.yml

@@ -1,4 +1,4 @@
-version: v1.7.0-alpha.2
+version: v1.7.0-alpha.1
 style: full
 
 specrefs:
@@ -146,6 +146,7 @@ exceptions:
     - g1_lincomb#deneb
     - hash_to_bls_field#deneb
     - is_power_of_two#deneb
+    - multi_exp#deneb
     - reverse_bits#deneb
     - validate_kzg_g1#deneb
     - verify_blob_kzg_proof#deneb
@@ -385,8 +386,7 @@ exceptions:
     - convert_builder_index_to_validator_index#gloas
     - convert_validator_index_to_builder_index#gloas
     - get_attestation_score#gloas
-    - get_attestation_score#phase0
-    - get_balance_after_withdrawals#capella
+    - get_builder_from_deposit#gloas
     - get_builder_withdrawals#gloas
     - get_builders_sweep_withdrawals#gloas
     - get_index_for_new_builder#gloas
@@ -396,18 +396,13 @@ exceptions:
     - initiate_builder_exit#gloas
     - is_active_builder#gloas
     - is_builder_index#gloas
-    - is_data_available#gloas
-    - is_eligible_for_partial_withdrawals#electra
     - is_head_late#gloas
     - is_head_weak#gloas
     - is_parent_strong#gloas
     - is_valid_proposal_slot#gloas
-    - onboard_builders_from_pending_deposits#gloas
     - process_deposit_request#gloas
     - process_voluntary_exit#gloas
     - record_block_timeliness#gloas
-    - record_block_timeliness#phase0
-    - verify_data_column_sidecar_kzg_proofs#gloas
     - should_apply_proposer_boost#gloas
     - update_builder_pending_withdrawals#gloas
     - update_next_withdrawal_builder_index#gloas

WORKSPACE

@@ -273,16 +273,16 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.7.0-alpha.2"
+consensus_spec_version = "v1.7.0-alpha.1"
 
 load("@prysm//tools:download_spectests.bzl", "consensus_spec_tests")
 
 consensus_spec_tests(
     name = "consensus_spec_tests",
     flavors = {
-        "general": "sha256-iGQsGZ1cHah+2CSod9jC3kN8Ku4n6KO0hIwfINrn/po=",
-        "minimal": "sha256-TgcYt8N8sXSttdHTGvOa+exUZ1zn1UzlAMz0V7i37xc=",
-        "mainnet": "sha256-LnXyiLoJtrvEvbqLDSAAqpLMdN/lXv92SAgYG8fNjCs=",
+        "general": "sha256-j5R3jA7Oo4OSDMTvpMuD+8RomaCByeFSwtfkq6fL0Zg=",
+        "minimal": "sha256-tdTqByoyswOS4r6OxFmo70y2BP7w1TgEok+gf4cbxB0=",
+        "mainnet": "sha256-5gB4dt6SnSDKzdBc06VedId3NkgvSYyv9n9FRxWKwYI=",
     },
     version = consensus_spec_version,
 )
@@ -298,7 +298,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-Y/67Dg393PksZj5rTFNLntiJ6hNdB7Rxbu5gZE2gebY=",
+    integrity = "sha256-J+43DrK1pF658kTXTwMS6zGf4KDjvas++m8w2a8swpg=",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )

api/server/structs/block.go

@@ -509,17 +509,17 @@ func (s *SignedBlindedBeaconBlockFulu) SigString() string {
 // ----------------------------------------------------------------------------
 
 type ExecutionPayloadBid struct {
-	ParentBlockHash    string   `json:"parent_block_hash"`
-	ParentBlockRoot    string   `json:"parent_block_root"`
-	BlockHash          string   `json:"block_hash"`
-	PrevRandao         string   `json:"prev_randao"`
-	FeeRecipient       string   `json:"fee_recipient"`
-	GasLimit           string   `json:"gas_limit"`
-	BuilderIndex       string   `json:"builder_index"`
-	Slot               string   `json:"slot"`
-	Value              string   `json:"value"`
-	ExecutionPayment   string   `json:"execution_payment"`
-	BlobKzgCommitments []string `json:"blob_kzg_commitments"`
+	ParentBlockHash        string `json:"parent_block_hash"`
+	ParentBlockRoot        string `json:"parent_block_root"`
+	BlockHash              string `json:"block_hash"`
+	PrevRandao             string `json:"prev_randao"`
+	FeeRecipient           string `json:"fee_recipient"`
+	GasLimit               string `json:"gas_limit"`
+	BuilderIndex           string `json:"builder_index"`
+	Slot                   string `json:"slot"`
+	Value                  string `json:"value"`
+	ExecutionPayment       string `json:"execution_payment"`
+	BlobKzgCommitmentsRoot string `json:"blob_kzg_commitments_root"`
 }
 
 type SignedExecutionPayloadBid struct {

api/server/structs/conversions_block.go

@@ -2939,22 +2939,18 @@ func SignedExecutionPayloadBidFromConsensus(b *eth.SignedExecutionPayloadBid) *S
 }
 
 func ExecutionPayloadBidFromConsensus(b *eth.ExecutionPayloadBid) *ExecutionPayloadBid {
-	blobKzgCommitments := make([]string, len(b.BlobKzgCommitments))
-	for i := range b.BlobKzgCommitments {
-		blobKzgCommitments[i] = hexutil.Encode(b.BlobKzgCommitments[i])
-	}
 	return &ExecutionPayloadBid{
-		ParentBlockHash:    hexutil.Encode(b.ParentBlockHash),
-		ParentBlockRoot:    hexutil.Encode(b.ParentBlockRoot),
-		BlockHash:          hexutil.Encode(b.BlockHash),
-		PrevRandao:         hexutil.Encode(b.PrevRandao),
-		FeeRecipient:       hexutil.Encode(b.FeeRecipient),
-		GasLimit:           fmt.Sprintf("%d", b.GasLimit),
-		BuilderIndex:       fmt.Sprintf("%d", b.BuilderIndex),
-		Slot:               fmt.Sprintf("%d", b.Slot),
-		Value:              fmt.Sprintf("%d", b.Value),
-		ExecutionPayment:   fmt.Sprintf("%d", b.ExecutionPayment),
-		BlobKzgCommitments: blobKzgCommitments,
+		ParentBlockHash:        hexutil.Encode(b.ParentBlockHash),
+		ParentBlockRoot:        hexutil.Encode(b.ParentBlockRoot),
+		BlockHash:              hexutil.Encode(b.BlockHash),
+		PrevRandao:             hexutil.Encode(b.PrevRandao),
+		FeeRecipient:           hexutil.Encode(b.FeeRecipient),
+		GasLimit:               fmt.Sprintf("%d", b.GasLimit),
+		BuilderIndex:           fmt.Sprintf("%d", b.BuilderIndex),
+		Slot:                   fmt.Sprintf("%d", b.Slot),
+		Value:                  fmt.Sprintf("%d", b.Value),
+		ExecutionPayment:       fmt.Sprintf("%d", b.ExecutionPayment),
+		BlobKzgCommitmentsRoot: hexutil.Encode(b.BlobKzgCommitmentsRoot),
 	}
 }
 
@@ -3191,30 +3187,22 @@ func (b *ExecutionPayloadBid) ToConsensus() (*eth.ExecutionPayloadBid, error) {
 	if err != nil {
 		return nil, server.NewDecodeError(err, "ExecutionPayment")
 	}
-	err = slice.VerifyMaxLength(b.BlobKzgCommitments, fieldparams.MaxBlobCommitmentsPerBlock)
+	blobKzgCommitmentsRoot, err := bytesutil.DecodeHexWithLength(b.BlobKzgCommitmentsRoot, fieldparams.RootLength)
 	if err != nil {
-		return nil, server.NewDecodeError(err, "BlobKzgCommitments")
-	}
-	blobKzgCommitments := make([][]byte, len(b.BlobKzgCommitments))
-	for i, commitment := range b.BlobKzgCommitments {
-		kzg, err := bytesutil.DecodeHexWithLength(commitment, fieldparams.BLSPubkeyLength)
-		if err != nil {
-			return nil, server.NewDecodeError(err, fmt.Sprintf("BlobKzgCommitments[%d]", i))
-		}
-		blobKzgCommitments[i] = kzg
+		return nil, server.NewDecodeError(err, "BlobKzgCommitmentsRoot")
 	}
 	return &eth.ExecutionPayloadBid{
-		ParentBlockHash:    parentBlockHash,
-		ParentBlockRoot:    parentBlockRoot,
-		BlockHash:          blockHash,
-		PrevRandao:         prevRandao,
-		FeeRecipient:       feeRecipient,
-		GasLimit:           gasLimit,
-		BuilderIndex:       primitives.BuilderIndex(builderIndex),
-		Slot:               primitives.Slot(slot),
-		Value:              primitives.Gwei(value),
-		ExecutionPayment:   primitives.Gwei(executionPayment),
-		BlobKzgCommitments: blobKzgCommitments,
+		ParentBlockHash:        parentBlockHash,
+		ParentBlockRoot:        parentBlockRoot,
+		BlockHash:              blockHash,
+		PrevRandao:             prevRandao,
+		FeeRecipient:           feeRecipient,
+		GasLimit:               gasLimit,
+		BuilderIndex:           primitives.BuilderIndex(builderIndex),
+		Slot:                   primitives.Slot(slot),
+		Value:                  primitives.Gwei(value),
+		ExecutionPayment:       primitives.Gwei(executionPayment),
+		BlobKzgCommitmentsRoot: blobKzgCommitmentsRoot,
 	}, nil
 }
 

beacon-chain/blockchain/BUILD.bazel

@@ -27,7 +27,6 @@ go_library(
         "receive_blob.go",
         "receive_block.go",
         "receive_data_column.go",
-        "receive_payload_attestation_message.go",
         "service.go",
         "setup_forkchoice.go",
         "tracked_proposer.go",
@@ -86,7 +85,6 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//io/logs:go_default_library",
         "//math:go_default_library",
         "//monitoring/tracing:go_default_library",
         "//monitoring/tracing/trace:go_default_library",

beacon-chain/blockchain/log_helpers.go

@@ -10,7 +10,6 @@ import (
 	consensus_types "github.com/OffchainLabs/prysm/v7/consensus-types"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v7/io/logs"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
 	prysmTime "github.com/OffchainLabs/prysm/v7/time"
@@ -88,45 +87,36 @@ func logStateTransitionData(b interfaces.ReadOnlyBeaconBlock) error {
 func logBlockSyncStatus(block interfaces.ReadOnlyBeaconBlock, blockRoot [32]byte, justified, finalized *ethpb.Checkpoint, receivedTime time.Time, genesis time.Time, daWaitedTime time.Duration) error {
 	startTime, err := slots.StartTime(genesis, block.Slot())
 	if err != nil {
-		return errors.Wrap(err, "failed to get slot start time")
+		return err
 	}
-	parentRoot := block.ParentRoot()
-	blkRoot := fmt.Sprintf("0x%s...", hex.EncodeToString(blockRoot[:])[:8])
-	finalizedRoot := fmt.Sprintf("0x%s...", hex.EncodeToString(finalized.Root)[:8])
-	sinceSlotStartTime := prysmTime.Now().Sub(startTime)
-
-	lessFields := logrus.Fields{
-		"slot":               block.Slot(),
-		"block":              blkRoot,
-		"finalizedEpoch":     finalized.Epoch,
-		"finalizedRoot":      finalizedRoot,
-		"epoch":              slots.ToEpoch(block.Slot()),
-		"sinceSlotStartTime": sinceSlotStartTime,
-	}
-	moreFields := logrus.Fields{
-		"slot":                       block.Slot(),
-		"slotInEpoch":                block.Slot() % params.BeaconConfig().SlotsPerEpoch,
-		"block":                      blkRoot,
-		"epoch":                      slots.ToEpoch(block.Slot()),
-		"justifiedEpoch":             justified.Epoch,
-		"justifiedRoot":              fmt.Sprintf("0x%s...", hex.EncodeToString(justified.Root)[:8]),
-		"finalizedEpoch":             finalized.Epoch,
-		"finalizedRoot":              finalizedRoot,
-		"parentRoot":                 fmt.Sprintf("0x%s...", hex.EncodeToString(parentRoot[:])[:8]),
-		"version":                    version.String(block.Version()),
-		"sinceSlotStartTime":         sinceSlotStartTime,
-		"chainServiceProcessedTime":  prysmTime.Now().Sub(receivedTime) - daWaitedTime,
-		"dataAvailabilityWaitedTime": daWaitedTime,
-	}
-
-	level := logs.PackageVerbosity("beacon-chain/blockchain")
+	level := log.Logger.GetLevel()
 	if level >= logrus.DebugLevel {
-		log.WithFields(moreFields).Info("Synced new block")
-		return nil
+		parentRoot := block.ParentRoot()
+		lf := logrus.Fields{
+			"slot":                       block.Slot(),
+			"slotInEpoch":                block.Slot() % params.BeaconConfig().SlotsPerEpoch,
+			"block":                      fmt.Sprintf("0x%s...", hex.EncodeToString(blockRoot[:])[:8]),
+			"epoch":                      slots.ToEpoch(block.Slot()),
+			"justifiedEpoch":             justified.Epoch,
+			"justifiedRoot":              fmt.Sprintf("0x%s...", hex.EncodeToString(justified.Root)[:8]),
+			"finalizedEpoch":             finalized.Epoch,
+			"finalizedRoot":              fmt.Sprintf("0x%s...", hex.EncodeToString(finalized.Root)[:8]),
+			"parentRoot":                 fmt.Sprintf("0x%s...", hex.EncodeToString(parentRoot[:])[:8]),
+			"version":                    version.String(block.Version()),
+			"sinceSlotStartTime":         prysmTime.Now().Sub(startTime),
+			"chainServiceProcessedTime":  prysmTime.Now().Sub(receivedTime) - daWaitedTime,
+			"dataAvailabilityWaitedTime": daWaitedTime,
+		}
+		log.WithFields(lf).Debug("Synced new block")
+	} else {
+		log.WithFields(logrus.Fields{
+			"slot":           block.Slot(),
+			"block":          fmt.Sprintf("0x%s...", hex.EncodeToString(blockRoot[:])[:8]),
+			"finalizedEpoch": finalized.Epoch,
+			"finalizedRoot":  fmt.Sprintf("0x%s...", hex.EncodeToString(finalized.Root)[:8]),
+			"epoch":          slots.ToEpoch(block.Slot()),
+		}).Info("Synced new block")
 	}
-
-	log.WithFields(lessFields).WithField(logs.LogTargetField, logs.LogTargetUser).Info("Synced new block")
-	log.WithFields(moreFields).WithField(logs.LogTargetField, logs.LogTargetEphemeral).Info("Synced new block")
 	return nil
 }
 

beacon-chain/blockchain/receive_payload_attestation_message.go

@@ -1,19 +0,0 @@
-package blockchain
-
-import (
-	"context"
-
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-)
-
-// PayloadAttestationReceiver interface defines the methods of chain service for receiving
-// validated payload attestation messages.
-type PayloadAttestationReceiver interface {
-	ReceivePayloadAttestationMessage(context.Context, *ethpb.PayloadAttestationMessage) error
-}
-
-// ReceivePayloadAttestationMessage accepts a payload attestation message.
-func (s *Service) ReceivePayloadAttestationMessage(ctx context.Context, a *ethpb.PayloadAttestationMessage) error {
-	// TODO: Handle payload attestation message processing once Gloas is fully wired.
-	return nil
-}

beacon-chain/blockchain/testing/mock.go

@@ -757,11 +757,6 @@ func (c *ChainService) ReceiveDataColumns(dcs []blocks.VerifiedRODataColumn) err
 	return nil
 }
 
-// ReceivePayloadAttestationMessage implements the same method in the chain service.
-func (c *ChainService) ReceivePayloadAttestationMessage(_ context.Context, _ *ethpb.PayloadAttestationMessage) error {
-	return nil
-}
-
 // DependentRootForEpoch mocks the same method in the chain service
 func (c *ChainService) DependentRootForEpoch(_ [32]byte, _ primitives.Epoch) ([32]byte, error) {
 	return c.TargetRoot, nil

beacon-chain/cache/BUILD.bazel

@@ -17,7 +17,6 @@ go_library(
         "error.go",
         "interfaces.go",
         "log.go",
-        "payload_attestation.go",
         "payload_id.go",
         "proposer_indices.go",
         "proposer_indices_disabled.go",  # keep
@@ -77,7 +76,6 @@ 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",

beacon-chain/cache/payload_attestation.go

@@ -1,53 +0,0 @@
-package cache
-
-import (
-	"sync"
-
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-)
-
-// PayloadAttestationCache tracks seen payload attestation messages for a single slot.
-type PayloadAttestationCache struct {
-	slot primitives.Slot
-	seen map[primitives.ValidatorIndex]struct{}
-	mu   sync.RWMutex
-}
-
-// Seen returns true if a vote for the given slot has already been
-// processed for this validator index.
-func (p *PayloadAttestationCache) Seen(slot primitives.Slot, idx primitives.ValidatorIndex) bool {
-	p.mu.RLock()
-	defer p.mu.RUnlock()
-	if p.slot != slot {
-		return false
-	}
-	if p.seen == nil {
-		return false
-	}
-	_, ok := p.seen[idx]
-	return ok
-}
-
-// Add marks the given slot and validator index as seen.
-// This function assumes that the message has already been validated.
-func (p *PayloadAttestationCache) Add(slot primitives.Slot, idx primitives.ValidatorIndex) error {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	if p.slot != slot {
-		p.slot = slot
-		p.seen = make(map[primitives.ValidatorIndex]struct{})
-	}
-	if p.seen == nil {
-		p.seen = make(map[primitives.ValidatorIndex]struct{})
-	}
-	p.seen[idx] = struct{}{}
-	return nil
-}
-
-// Clear clears the internal cache.
-func (p *PayloadAttestationCache) Clear() {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	p.slot = 0
-	p.seen = nil
-}

beacon-chain/cache/payload_attestation_test.go

@@ -1,48 +0,0 @@
-package cache_test
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/cache"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/stretchr/testify/require"
-)
-
-func TestPayloadAttestationCache_SeenAndAdd(t *testing.T) {
-	var c cache.PayloadAttestationCache
-	slot1 := primitives.Slot(1)
-	slot2 := primitives.Slot(2)
-	idx1 := primitives.ValidatorIndex(3)
-	idx2 := primitives.ValidatorIndex(4)
-
-	require.False(t, c.Seen(slot1, idx1))
-
-	require.NoError(t, c.Add(slot1, idx1))
-	require.True(t, c.Seen(slot1, idx1))
-	require.False(t, c.Seen(slot1, idx2))
-	require.False(t, c.Seen(slot2, idx1))
-
-	require.NoError(t, c.Add(slot1, idx2))
-	require.True(t, c.Seen(slot1, idx1))
-	require.True(t, c.Seen(slot1, idx2))
-
-	require.NoError(t, c.Add(slot2, idx1))
-	require.True(t, c.Seen(slot2, idx1))
-	require.False(t, c.Seen(slot1, idx1))
-	require.False(t, c.Seen(slot1, idx2))
-}
-
-func TestPayloadAttestationCache_Clear(t *testing.T) {
-	var c cache.PayloadAttestationCache
-	slot := primitives.Slot(10)
-	idx := primitives.ValidatorIndex(42)
-
-	require.NoError(t, c.Add(slot, idx))
-	require.True(t, c.Seen(slot, idx))
-
-	c.Clear()
-	require.False(t, c.Seen(slot, idx))
-
-	require.NoError(t, c.Add(slot, idx))
-	require.True(t, c.Seen(slot, idx))
-}

beacon-chain/core/gloas/bid.go

@@ -18,7 +18,7 @@ import (
 
 // ProcessExecutionPayloadBid processes a signed execution payload bid in the Gloas fork.
 //
-//	<spec fn="process_execution_payload_bid" fork="gloas" hash="823c9f3a">
+//	<spec fn="process_execution_payload_bid" fork="gloas" hash="6dc696bb">
 //	def process_execution_payload_bid(state: BeaconState, block: BeaconBlock) -> None:
 //	    signed_bid = block.body.signed_execution_payload_bid
 //	    bid = signed_bid.message
@@ -37,12 +37,6 @@ import (
 //	        # Verify that the bid signature is valid
 //	        assert verify_execution_payload_bid_signature(state, signed_bid)
 //
-//	    # Verify commitments are under limit
-//	    assert (
-//	        len(bid.blob_kzg_commitments)
-//	        <= get_blob_parameters(get_current_epoch(state)).max_blobs_per_block
-//	    )
-//
 //	    # Verify that the bid is for the current slot
 //	    assert bid.slot == block.slot
 //	    # Verify that the bid is for the right parent block
@@ -115,12 +109,6 @@ func ProcessExecutionPayloadBid(st state.BeaconState, block interfaces.ReadOnlyB
 		}
 	}
 
-	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlockAtEpoch(slots.ToEpoch(block.Slot()))
-	commitmentCount := bid.BlobKzgCommitmentCount()
-	if commitmentCount > uint64(maxBlobsPerBlock) {
-		return fmt.Errorf("bid has %d blob KZG commitments over max %d", commitmentCount, maxBlobsPerBlock)
-	}
-
 	if err := validateBidConsistency(st, bid, block); err != nil {
 		return errors.Wrap(err, "bid consistency validation failed")
 	}

beacon-chain/core/gloas/bid_test.go

@@ -184,28 +184,6 @@ func signBid(t *testing.T, sk common.SecretKey, bid *ethpb.ExecutionPayloadBid,
 	return out
 }
 
-func blobCommitmentsForSlot(slot primitives.Slot, count int) [][]byte {
-	max := int(params.BeaconConfig().MaxBlobsPerBlockAtEpoch(slots.ToEpoch(slot)))
-	if count > max {
-		count = max
-	}
-	commitments := make([][]byte, count)
-	for i := range commitments {
-		commitments[i] = bytes.Repeat([]byte{0xEE}, 48)
-	}
-	return commitments
-}
-
-func tooManyBlobCommitmentsForSlot(slot primitives.Slot) [][]byte {
-	max := int(params.BeaconConfig().MaxBlobsPerBlockAtEpoch(slots.ToEpoch(slot)))
-	count := max + 1
-	commitments := make([][]byte, count)
-	for i := range commitments {
-		commitments[i] = bytes.Repeat([]byte{0xEE}, 48)
-	}
-	return commitments
-}
-
 func TestProcessExecutionPayloadBid_SelfBuildSuccess(t *testing.T) {
 	slot := primitives.Slot(12)
 	proposerIdx := primitives.ValidatorIndex(0)
@@ -216,17 +194,17 @@ func TestProcessExecutionPayloadBid_SelfBuildSuccess(t *testing.T) {
 	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinActivationBalance+1000, randao, latestHash, pubKey)
 
 	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:    latestHash[:],
-		ParentBlockRoot:    bytes.Repeat([]byte{0xCC}, 32),
-		BlockHash:          bytes.Repeat([]byte{0xDD}, 32),
-		PrevRandao:         randao[:],
-		GasLimit:           1,
-		BuilderIndex:       builderIdx,
-		Slot:               slot,
-		Value:              0,
-		ExecutionPayment:   0,
-		BlobKzgCommitments: blobCommitmentsForSlot(slot, 1),
-		FeeRecipient:       bytes.Repeat([]byte{0xFF}, 20),
+		ParentBlockHash:        latestHash[:],
+		ParentBlockRoot:        bytes.Repeat([]byte{0xCC}, 32),
+		BlockHash:              bytes.Repeat([]byte{0xDD}, 32),
+		PrevRandao:             randao[:],
+		GasLimit:               1,
+		BuilderIndex:           builderIdx,
+		Slot:                   slot,
+		Value:                  0,
+		ExecutionPayment:       0,
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
+		FeeRecipient:           bytes.Repeat([]byte{0xFF}, 20),
 	}
 	signed := &ethpb.SignedExecutionPayloadBid{
 		Message:   bid,
@@ -258,16 +236,16 @@ func TestProcessExecutionPayloadBid_SelfBuildNonZeroAmountFails(t *testing.T) {
 	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinActivationBalance+1000, randao, latestHash, [48]byte{})
 
 	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:    latestHash[:],
-		ParentBlockRoot:    bytes.Repeat([]byte{0xAA}, 32),
-		BlockHash:          bytes.Repeat([]byte{0xBB}, 32),
-		PrevRandao:         randao[:],
-		BuilderIndex:       builderIdx,
-		Slot:               slot,
-		Value:              10,
-		ExecutionPayment:   0,
-		BlobKzgCommitments: blobCommitmentsForSlot(slot, 1),
-		FeeRecipient:       bytes.Repeat([]byte{0xDD}, 20),
+		ParentBlockHash:        latestHash[:],
+		ParentBlockRoot:        bytes.Repeat([]byte{0xAA}, 32),
+		BlockHash:              bytes.Repeat([]byte{0xBB}, 32),
+		PrevRandao:             randao[:],
+		BuilderIndex:           builderIdx,
+		Slot:                   slot,
+		Value:                  10,
+		ExecutionPayment:       0,
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xCC}, 32),
+		FeeRecipient:           bytes.Repeat([]byte{0xDD}, 20),
 	}
 	signed := &ethpb.SignedExecutionPayloadBid{
 		Message:   bid,
@@ -302,17 +280,17 @@ func TestProcessExecutionPayloadBid_PendingPaymentAndCacheBid(t *testing.T) {
 	state := buildGloasState(t, slot, proposerIdx, builderIdx, balance, randao, latestHash, pubKey)
 
 	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:    latestHash[:],
-		ParentBlockRoot:    bytes.Repeat([]byte{0xCC}, 32),
-		BlockHash:          bytes.Repeat([]byte{0xDD}, 32),
-		PrevRandao:         randao[:],
-		GasLimit:           1,
-		BuilderIndex:       builderIdx,
-		Slot:               slot,
-		Value:              500_000,
-		ExecutionPayment:   1,
-		BlobKzgCommitments: blobCommitmentsForSlot(slot, 1),
-		FeeRecipient:       bytes.Repeat([]byte{0xFF}, 20),
+		ParentBlockHash:        latestHash[:],
+		ParentBlockRoot:        bytes.Repeat([]byte{0xCC}, 32),
+		BlockHash:              bytes.Repeat([]byte{0xDD}, 32),
+		PrevRandao:             randao[:],
+		GasLimit:               1,
+		BuilderIndex:           builderIdx,
+		Slot:                   slot,
+		Value:                  500_000,
+		ExecutionPayment:       1,
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
+		FeeRecipient:           bytes.Repeat([]byte{0xFF}, 20),
 	}
 
 	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
@@ -363,17 +341,17 @@ func TestProcessExecutionPayloadBid_BuilderNotActive(t *testing.T) {
 	state = stateIface.(*state_native.BeaconState)
 
 	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:    latestHash[:],
-		ParentBlockRoot:    bytes.Repeat([]byte{0x03}, 32),
-		BlockHash:          bytes.Repeat([]byte{0x04}, 32),
-		PrevRandao:         randao[:],
-		GasLimit:           1,
-		BuilderIndex:       builderIdx,
-		Slot:               slot,
-		Value:              10,
-		ExecutionPayment:   0,
-		BlobKzgCommitments: blobCommitmentsForSlot(slot, 1),
-		FeeRecipient:       bytes.Repeat([]byte{0x06}, 20),
+		ParentBlockHash:        latestHash[:],
+		ParentBlockRoot:        bytes.Repeat([]byte{0x03}, 32),
+		BlockHash:              bytes.Repeat([]byte{0x04}, 32),
+		PrevRandao:             randao[:],
+		GasLimit:               1,
+		BuilderIndex:           builderIdx,
+		Slot:                   slot,
+		Value:                  10,
+		ExecutionPayment:       0,
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x05}, 32),
+		FeeRecipient:           bytes.Repeat([]byte{0x06}, 20),
 	}
 	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
 	sig := signBid(t, sk, bid, state.Fork(), genesis)
@@ -416,17 +394,17 @@ func TestProcessExecutionPayloadBid_CannotCoverBid(t *testing.T) {
 	state = stateIface.(*state_native.BeaconState)
 
 	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:    latestHash[:],
-		ParentBlockRoot:    bytes.Repeat([]byte{0xCC}, 32),
-		BlockHash:          bytes.Repeat([]byte{0xDD}, 32),
-		PrevRandao:         randao[:],
-		GasLimit:           1,
-		BuilderIndex:       builderIdx,
-		Slot:               slot,
-		Value:              25,
-		ExecutionPayment:   0,
-		BlobKzgCommitments: blobCommitmentsForSlot(slot, 1),
-		FeeRecipient:       bytes.Repeat([]byte{0xFF}, 20),
+		ParentBlockHash:        latestHash[:],
+		ParentBlockRoot:        bytes.Repeat([]byte{0xCC}, 32),
+		BlockHash:              bytes.Repeat([]byte{0xDD}, 32),
+		PrevRandao:             randao[:],
+		GasLimit:               1,
+		BuilderIndex:           builderIdx,
+		Slot:                   slot,
+		Value:                  25,
+		ExecutionPayment:       0,
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
+		FeeRecipient:           bytes.Repeat([]byte{0xFF}, 20),
 	}
 	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
 	sig := signBid(t, sk, bid, state.Fork(), genesis)
@@ -458,17 +436,17 @@ func TestProcessExecutionPayloadBid_InvalidSignature(t *testing.T) {
 	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
 
 	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:    latestHash[:],
-		ParentBlockRoot:    bytes.Repeat([]byte{0xCC}, 32),
-		BlockHash:          bytes.Repeat([]byte{0xDD}, 32),
-		PrevRandao:         randao[:],
-		GasLimit:           1,
-		BuilderIndex:       builderIdx,
-		Slot:               slot,
-		Value:              10,
-		ExecutionPayment:   0,
-		BlobKzgCommitments: blobCommitmentsForSlot(slot, 1),
-		FeeRecipient:       bytes.Repeat([]byte{0xFF}, 20),
+		ParentBlockHash:        latestHash[:],
+		ParentBlockRoot:        bytes.Repeat([]byte{0xCC}, 32),
+		BlockHash:              bytes.Repeat([]byte{0xDD}, 32),
+		PrevRandao:             randao[:],
+		GasLimit:               1,
+		BuilderIndex:           builderIdx,
+		Slot:                   slot,
+		Value:                  10,
+		ExecutionPayment:       0,
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
+		FeeRecipient:           bytes.Repeat([]byte{0xFF}, 20),
 	}
 	// Use an invalid signature.
 	invalidSig := [96]byte{1}
@@ -485,42 +463,6 @@ func TestProcessExecutionPayloadBid_InvalidSignature(t *testing.T) {
 	require.ErrorContains(t, "bid signature validation failed", err)
 }
 
-func TestProcessExecutionPayloadBid_TooManyBlobCommitments(t *testing.T) {
-	slot := primitives.Slot(9)
-	proposerIdx := primitives.ValidatorIndex(0)
-	builderIdx := params.BeaconConfig().BuilderIndexSelfBuild
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-	pubKey := [48]byte{}
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinActivationBalance+1000, randao, latestHash, pubKey)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:    latestHash[:],
-		ParentBlockRoot:    bytes.Repeat([]byte{0xCC}, 32),
-		BlockHash:          bytes.Repeat([]byte{0xDD}, 32),
-		PrevRandao:         randao[:],
-		BuilderIndex:       builderIdx,
-		Slot:               slot,
-		BlobKzgCommitments: tooManyBlobCommitmentsForSlot(slot),
-		FeeRecipient:       bytes.Repeat([]byte{0xFF}, 20),
-	}
-	signed := &ethpb.SignedExecutionPayloadBid{
-		Message:   bid,
-		Signature: common.InfiniteSignature[:],
-	}
-
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err := ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "blob KZG commitments over max", err)
-}
-
 func TestProcessExecutionPayloadBid_SlotMismatch(t *testing.T) {
 	slot := primitives.Slot(10)
 	builderIdx := primitives.BuilderIndex(1)
@@ -536,17 +478,17 @@ func TestProcessExecutionPayloadBid_SlotMismatch(t *testing.T) {
 	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
 
 	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:    latestHash[:],
-		ParentBlockRoot:    bytes.Repeat([]byte{0xAA}, 32),
-		BlockHash:          bytes.Repeat([]byte{0xBB}, 32),
-		PrevRandao:         randao[:],
-		GasLimit:           1,
-		BuilderIndex:       builderIdx,
-		Slot:               slot + 1, // mismatch
-		Value:              1,
-		ExecutionPayment:   0,
-		BlobKzgCommitments: blobCommitmentsForSlot(slot, 1),
-		FeeRecipient:       bytes.Repeat([]byte{0xDD}, 20),
+		ParentBlockHash:        latestHash[:],
+		ParentBlockRoot:        bytes.Repeat([]byte{0xAA}, 32),
+		BlockHash:              bytes.Repeat([]byte{0xBB}, 32),
+		PrevRandao:             randao[:],
+		GasLimit:               1,
+		BuilderIndex:           builderIdx,
+		Slot:                   slot + 1, // mismatch
+		Value:                  1,
+		ExecutionPayment:       0,
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xCC}, 32),
+		FeeRecipient:           bytes.Repeat([]byte{0xDD}, 20),
 	}
 	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
 	sig := signBid(t, sk, bid, state.Fork(), genesis)
@@ -578,17 +520,17 @@ func TestProcessExecutionPayloadBid_ParentHashMismatch(t *testing.T) {
 	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
 
 	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:    bytes.Repeat([]byte{0x11}, 32), // mismatch
-		ParentBlockRoot:    bytes.Repeat([]byte{0x22}, 32),
-		BlockHash:          bytes.Repeat([]byte{0x33}, 32),
-		PrevRandao:         randao[:],
-		GasLimit:           1,
-		BuilderIndex:       builderIdx,
-		Slot:               slot,
-		Value:              1,
-		ExecutionPayment:   0,
-		BlobKzgCommitments: blobCommitmentsForSlot(slot, 1),
-		FeeRecipient:       bytes.Repeat([]byte{0x55}, 20),
+		ParentBlockHash:        bytes.Repeat([]byte{0x11}, 32), // mismatch
+		ParentBlockRoot:        bytes.Repeat([]byte{0x22}, 32),
+		BlockHash:              bytes.Repeat([]byte{0x33}, 32),
+		PrevRandao:             randao[:],
+		GasLimit:               1,
+		BuilderIndex:           builderIdx,
+		Slot:                   slot,
+		Value:                  1,
+		ExecutionPayment:       0,
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x44}, 32),
+		FeeRecipient:           bytes.Repeat([]byte{0x55}, 20),
 	}
 	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
 	sig := signBid(t, sk, bid, state.Fork(), genesis)
@@ -621,17 +563,17 @@ func TestProcessExecutionPayloadBid_ParentRootMismatch(t *testing.T) {
 
 	parentRoot := bytes.Repeat([]byte{0x22}, 32)
 	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:    latestHash[:],
-		ParentBlockRoot:    parentRoot,
-		BlockHash:          bytes.Repeat([]byte{0x33}, 32),
-		PrevRandao:         randao[:],
-		GasLimit:           1,
-		BuilderIndex:       builderIdx,
-		Slot:               slot,
-		Value:              1,
-		ExecutionPayment:   0,
-		BlobKzgCommitments: blobCommitmentsForSlot(slot, 1),
-		FeeRecipient:       bytes.Repeat([]byte{0x55}, 20),
+		ParentBlockHash:        latestHash[:],
+		ParentBlockRoot:        parentRoot,
+		BlockHash:              bytes.Repeat([]byte{0x33}, 32),
+		PrevRandao:             randao[:],
+		GasLimit:               1,
+		BuilderIndex:           builderIdx,
+		Slot:                   slot,
+		Value:                  1,
+		ExecutionPayment:       0,
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x44}, 32),
+		FeeRecipient:           bytes.Repeat([]byte{0x55}, 20),
 	}
 	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
 	sig := signBid(t, sk, bid, state.Fork(), genesis)
@@ -663,17 +605,17 @@ func TestProcessExecutionPayloadBid_PrevRandaoMismatch(t *testing.T) {
 	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
 
 	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:    latestHash[:],
-		ParentBlockRoot:    bytes.Repeat([]byte{0x22}, 32),
-		BlockHash:          bytes.Repeat([]byte{0x33}, 32),
-		PrevRandao:         bytes.Repeat([]byte{0x01}, 32), // mismatch
-		GasLimit:           1,
-		BuilderIndex:       builderIdx,
-		Slot:               slot,
-		Value:              1,
-		ExecutionPayment:   0,
-		BlobKzgCommitments: blobCommitmentsForSlot(slot, 1),
-		FeeRecipient:       bytes.Repeat([]byte{0x55}, 20),
+		ParentBlockHash:        latestHash[:],
+		ParentBlockRoot:        bytes.Repeat([]byte{0x22}, 32),
+		BlockHash:              bytes.Repeat([]byte{0x33}, 32),
+		PrevRandao:             bytes.Repeat([]byte{0x01}, 32), // mismatch
+		GasLimit:               1,
+		BuilderIndex:           builderIdx,
+		Slot:                   slot,
+		Value:                  1,
+		ExecutionPayment:       0,
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x44}, 32),
+		FeeRecipient:           bytes.Repeat([]byte{0x55}, 20),
 	}
 	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
 	sig := signBid(t, sk, bid, state.Fork(), genesis)

beacon-chain/core/gloas/payload_attestation.go

@@ -77,7 +77,7 @@ func ProcessPayloadAttestations(ctx context.Context, st state.BeaconState, body
 
 // indexedPayloadAttestation converts a payload attestation into its indexed form.
 func indexedPayloadAttestation(ctx context.Context, st state.ReadOnlyBeaconState, att *eth.PayloadAttestation) (*consensus_types.IndexedPayloadAttestation, error) {
-	committee, err := PayloadCommittee(ctx, st, att.Data.Slot)
+	committee, err := payloadCommittee(ctx, st, att.Data.Slot)
 	if err != nil {
 		return nil, err
 	}
@@ -96,7 +96,7 @@ func indexedPayloadAttestation(ctx context.Context, st state.ReadOnlyBeaconState
 	}, nil
 }
 
-// PayloadCommittee returns the payload timeliness committee for a given slot for the state.
+// payloadCommittee returns the payload timeliness committee for a given slot for the state.
 //
 //	<spec fn="get_ptc" fork="gloas" hash="ae15f761">
 //	def get_ptc(state: BeaconState, slot: Slot) -> Vector[ValidatorIndex, PTC_SIZE]:
@@ -115,7 +115,7 @@ func indexedPayloadAttestation(ctx context.Context, st state.ReadOnlyBeaconState
 //	        state, indices, seed, size=PTC_SIZE, shuffle_indices=False
 //	    )
 //	</spec>
-func PayloadCommittee(ctx context.Context, st state.ReadOnlyBeaconState, slot primitives.Slot) ([]primitives.ValidatorIndex, error) {
+func payloadCommittee(ctx context.Context, st state.ReadOnlyBeaconState, slot primitives.Slot) ([]primitives.ValidatorIndex, error) {
 	epoch := slots.ToEpoch(slot)
 	seed, err := ptcSeed(st, epoch, slot)
 	if err != nil {
@@ -264,24 +264,24 @@ func acceptByBalance(st state.ReadOnlyBeaconState, idx primitives.ValidatorIndex
 
 // validIndexedPayloadAttestation verifies the signature of an indexed payload attestation.
 //
-//	<spec fn="is_valid_indexed_payload_attestation" fork="gloas" hash="d76e0f89">
+//	<spec fn="is_valid_indexed_payload_attestation" fork="gloas" hash="cf1e65b5">
 //	def is_valid_indexed_payload_attestation(
-//	    state: BeaconState, attestation: IndexedPayloadAttestation
+//	    state: BeaconState, indexed_payload_attestation: IndexedPayloadAttestation
 //	) -> bool:
 //	    """
-//	    Check if ``attestation`` is non-empty, has sorted indices, and has
+//	    Check if ``indexed_payload_attestation`` is non-empty, has sorted indices, and has
 //	    a valid aggregate signature.
 //	    """
 //	    # Verify indices are non-empty and sorted
-//	    indices = attestation.attesting_indices
+//	    indices = indexed_payload_attestation.attesting_indices
 //	    if len(indices) == 0 or not indices == sorted(indices):
 //	        return False
 //
 //	    # Verify aggregate signature
 //	    pubkeys = [state.validators[i].pubkey for i in indices]
-//	    domain = get_domain(state, DOMAIN_PTC_ATTESTER, compute_epoch_at_slot(attestation.data.slot))
-//	    signing_root = compute_signing_root(attestation.data, domain)
-//	    return bls.FastAggregateVerify(pubkeys, signing_root, attestation.signature)
+//	    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)
 //	</spec>
 func validIndexedPayloadAttestation(st state.ReadOnlyBeaconState, att *consensus_types.IndexedPayloadAttestation) error {
 	indices := att.AttestingIndices

beacon-chain/core/transition/transition_gloas_test.go

@@ -78,7 +78,7 @@ func newGloasState(t *testing.T, slot primitives.Slot, availability []byte) stat
 			BlockHash:              make([]byte, 32),
 			PrevRandao:             make([]byte, 32),
 			FeeRecipient:           make([]byte, 20),
-			BlobKzgCommitments:     [][]byte{make([]byte, 48)},
+			BlobKzgCommitmentsRoot: make([]byte, 32),
 		},
 		Eth1Data: &ethpb.Eth1Data{
 			DepositRoot: make([]byte, 32),

beacon-chain/db/kv/archived_point.go

@@ -2,7 +2,6 @@ package kv
 
 import (
 	"context"
-	"slices"
 
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
@@ -34,9 +33,6 @@ func (s *Store) LastArchivedRoot(ctx context.Context) [32]byte {
 	if err := s.db.View(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(stateSlotIndicesBucket)
 		_, blockRoot = bkt.Cursor().Last()
-		if len(blockRoot) > 0 {
-			blockRoot = slices.Clone(blockRoot)
-		}
 		return nil
 	}); err != nil { // This view never returns an error, but we'll handle anyway for sanity.
 		panic(err) // lint:nopanic -- View never returns an error.
@@ -55,9 +51,6 @@ func (s *Store) ArchivedPointRoot(ctx context.Context, slot primitives.Slot) [32
 	if err := s.db.View(func(tx *bolt.Tx) error {
 		bucket := tx.Bucket(stateSlotIndicesBucket)
 		blockRoot = bucket.Get(bytesutil.SlotToBytesBigEndian(slot))
-		if len(blockRoot) > 0 {
-			blockRoot = slices.Clone(blockRoot)
-		}
 		return nil
 	}); err != nil { // This view never returns an error, but we'll handle anyway for sanity.
 		panic(err) // lint:nopanic -- View never returns an error.

beacon-chain/db/kv/blocks.go

@@ -812,10 +812,7 @@ func (s *Store) FeeRecipientByValidatorID(ctx context.Context, id primitives.Val
 	var addr []byte
 	err := s.db.View(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(feeRecipientBucket)
-		stored := bkt.Get(bytesutil.Uint64ToBytesBigEndian(uint64(id)))
-		if len(stored) > 0 {
-			addr = slices.Clone(stored)
-		}
+		addr = bkt.Get(bytesutil.Uint64ToBytesBigEndian(uint64(id)))
 		// IF the fee recipient is not found in the standard fee recipient bucket, then
 		// check the registration bucket. The fee recipient may be there.
 		// This is to resolve imcompatility until we fully migrate to the registration bucket.
@@ -829,7 +826,7 @@ func (s *Store) FeeRecipientByValidatorID(ctx context.Context, id primitives.Val
 			if err := decode(ctx, enc, reg); err != nil {
 				return err
 			}
-			addr = slices.Clone(reg.FeeRecipient)
+			addr = reg.FeeRecipient
 		}
 		return nil
 	})

beacon-chain/db/kv/deposit_contract.go

@@ -3,7 +3,6 @@ package kv
 import (
 	"context"
 	"fmt"
-	"slices"
 
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
 	"github.com/ethereum/go-ethereum/common"
@@ -18,10 +17,7 @@ func (s *Store) DepositContractAddress(ctx context.Context) ([]byte, error) {
 	var addr []byte
 	if err := s.db.View(func(tx *bolt.Tx) error {
 		chainInfo := tx.Bucket(chainMetadataBucket)
-		stored := chainInfo.Get(depositContractAddressKey)
-		if len(stored) > 0 {
-			addr = slices.Clone(stored)
-		}
+		addr = chainInfo.Get(depositContractAddressKey)
 		return nil
 	}); err != nil { // This view never returns an error, but we'll handle anyway for sanity.
 		panic(err) // lint:nopanic -- View never returns an error.

beacon-chain/db/kv/error.go

@@ -26,15 +26,6 @@ var ErrNotFoundMetadataSeqNum = errors.Wrap(ErrNotFound, "metadata sequence numb
 // but the database was created without state-diff support.
 var ErrStateDiffIncompatible = errors.New("state-diff feature enabled but database was created without state-diff support")
 
-// ErrStateDiffCorrupted is returned when state-diff metadata or data is missing or invalid.
-var ErrStateDiffCorrupted = errors.New("state-diff database corrupted")
-
-// ErrStateDiffExponentMismatch is returned when configured exponents differ from stored metadata.
-var ErrStateDiffExponentMismatch = errors.New("state-diff exponents mismatch")
-
-// ErrStateDiffMissingSnapshot is returned when the offset snapshot is missing.
-var ErrStateDiffMissingSnapshot = errors.New("state-diff offset snapshot missing")
-
 var errEmptyBlockSlice = errors.New("[]blocks.ROBlock is empty")
 var errIncorrectBlockParent = errors.New("unexpected missing or forked blocks in a []ROBlock")
 var errFinalizedChildNotFound = errors.New("unable to find finalized root descending from backfill batch")

beacon-chain/db/kv/kv.go

@@ -7,11 +7,9 @@ import (
 	"fmt"
 	"os"
 	"path"
-	"slices"
 	"time"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/db/iface"
-	"github.com/OffchainLabs/prysm/v7/cmd/beacon-chain/flags"
 	"github.com/OffchainLabs/prysm/v7/config/features"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
@@ -23,7 +21,6 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	prombolt "github.com/prysmaticlabs/prombbolt"
-	logrus "github.com/sirupsen/logrus"
 	bolt "go.etcd.io/bbolt"
 )
 
@@ -226,42 +223,8 @@ func (kv *Store) startStateDiff(ctx context.Context) error {
 	}
 
 	if hasOffset {
-		storedExponents, err := kv.loadStateDiffExponents()
-		if err != nil {
-			return fmt.Errorf("%w: state-diff metadata missing or invalid; re-sync required: %v", ErrStateDiffCorrupted, err)
-		}
-		currentExponents := flags.Get().StateDiffExponents
-		if !slices.Equal(storedExponents, currentExponents) {
-			return errors.Wrapf(
-				ErrStateDiffExponentMismatch,
-				"state-diff exponents changed; database incompatible. "+
-					"Database was initialized with: %v. "+
-					"Current configuration: %v. "+
-					"Options: use original exponents (--state-diff-exponents=%s) or delete database and re-sync from genesis/checkpoint.",
-				storedExponents,
-				currentExponents,
-				formatStateDiffExponents(storedExponents),
-			)
-		}
-		offset, err := kv.loadOffset()
-		if err != nil {
-			return err
-		}
-		cache, err := populateStateDiffCacheFromDB(kv, offset)
-		if err != nil {
-			return err
-		}
-		kv.stateDiffCache = cache
-		if flags.Get().StateDiffValidateOnStartup {
-			if err := validateStateDiffCache(ctx, kv, cache); err != nil {
-				return err
-			}
-		}
-		log.WithFields(logrus.Fields{
-			"offset":    offset,
-			"exponents": storedExponents,
-		}).Info("State-diff cache initialized from existing database")
-		return nil
+		// Existing state-diff database - restarts not yet supported.
+		return errors.New("restarting with existing state-diff database not yet supported")
 	}
 
 	// Check if this is a new database (no head block).

beacon-chain/db/kv/kv_test.go

@@ -3,15 +3,12 @@ package kv
 import (
 	"bytes"
 	"context"
-	"encoding/binary"
 	"fmt"
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v7/cmd/beacon-chain/flags"
 	"github.com/OffchainLabs/prysm/v7/config/features"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
 	"github.com/OffchainLabs/prysm/v7/testing/util"
 	bolt "go.etcd.io/bbolt"
@@ -30,108 +27,6 @@ func setupDB(t testing.TB) *Store {
 	return db
 }
 
-func TestStartStateDiff_ExponentMismatch(t *testing.T) {
-	resetCfg := features.InitWithReset(&features.Flags{EnableStateDiff: true})
-	defer resetCfg()
-	setDefaultStateDiffExponents()
-
-	store := setupDB(t)
-	require.NoError(t, store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket(stateDiffBucket)
-		if bucket == nil {
-			return bolt.ErrBucketNotFound
-		}
-		offsetBytes := make([]byte, 8)
-		binary.LittleEndian.PutUint64(offsetBytes, 0)
-		if err := bucket.Put(offsetKey, offsetBytes); err != nil {
-			return err
-		}
-		encoded, err := encodeStateDiffExponents([]int{20, 10})
-		if err != nil {
-			return err
-		}
-		return bucket.Put(exponentsKey, encoded)
-	}))
-
-	ctx := t.Context()
-	err := store.startStateDiff(ctx)
-	require.ErrorContains(t, "state-diff exponents changed", err)
-}
-
-func TestStartStateDiff_MissingOffsetSnapshot(t *testing.T) {
-	resetCfg := features.InitWithReset(&features.Flags{EnableStateDiff: true})
-	defer resetCfg()
-	setDefaultStateDiffExponents()
-
-	store := setupDB(t)
-	require.NoError(t, store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket(stateDiffBucket)
-		if bucket == nil {
-			return bolt.ErrBucketNotFound
-		}
-		offsetBytes := make([]byte, 8)
-		binary.LittleEndian.PutUint64(offsetBytes, 0)
-		if err := bucket.Put(offsetKey, offsetBytes); err != nil {
-			return err
-		}
-		encoded, err := encodeStateDiffExponents(flags.Get().StateDiffExponents)
-		if err != nil {
-			return err
-		}
-		return bucket.Put(exponentsKey, encoded)
-	}))
-
-	ctx := t.Context()
-	err := store.startStateDiff(ctx)
-	require.ErrorContains(t, "missing offset snapshot", err)
-}
-
-func TestStartStateDiff_ValidateOnStartup(t *testing.T) {
-	resetCfg := features.InitWithReset(&features.Flags{EnableStateDiff: true})
-	defer resetCfg()
-	setDefaultStateDiffExponents()
-
-	globalFlags := flags.GlobalFlags{
-		StateDiffExponents:         flags.Get().StateDiffExponents,
-		StateDiffValidateOnStartup: true,
-	}
-	flags.Init(&globalFlags)
-
-	store := setupDB(t)
-	require.NoError(t, store.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket(stateDiffBucket)
-		if bucket == nil {
-			return bolt.ErrBucketNotFound
-		}
-		st, _ := createState(t, 0, version.Phase0)
-		stateBytes, err := st.MarshalSSZ()
-		if err != nil {
-			return err
-		}
-		enc, err := addKey(st.Version(), stateBytes)
-		if err != nil {
-			return err
-		}
-		offsetBytes := make([]byte, 8)
-		binary.LittleEndian.PutUint64(offsetBytes, 0)
-		if err := bucket.Put(offsetKey, offsetBytes); err != nil {
-			return err
-		}
-		encoded, err := encodeStateDiffExponents(flags.Get().StateDiffExponents)
-		if err != nil {
-			return err
-		}
-		if err := bucket.Put(exponentsKey, encoded); err != nil {
-			return err
-		}
-		key := makeKeyForStateDiffTree(0, 0)
-		return bucket.Put(key, enc)
-	}))
-
-	err := store.startStateDiff(t.Context())
-	require.NoError(t, err)
-}
-
 func Test_setupBlockStorageType(t *testing.T) {
 	ctx := t.Context()
 	t.Run("fresh database with feature enabled to store full blocks should store full blocks", func(t *testing.T) {

beacon-chain/db/kv/migration_state_validators.go

@@ -199,7 +199,7 @@ func performValidatorStateMigration(ctx context.Context, bar *progressbar.Progre
 func stateBucketKeys(stateBucket *bolt.Bucket) ([][]byte, error) {
 	var keys [][]byte
 	if err := stateBucket.ForEach(func(pubKey, v []byte) error {
-		keys = append(keys, bytes.Clone(pubKey))
+		keys = append(keys, pubKey)
 		return nil
 	}); err != nil {
 		return nil, err

beacon-chain/db/kv/state.go

@@ -1048,15 +1048,10 @@ func (s *Store) isStateValidatorMigrationOver() (bool, error) {
 }
 
 func (s *Store) getStateUsingStateDiff(ctx context.Context, blockRoot [32]byte) (state.BeaconState, error) {
-	stateSummary, err := s.StateSummary(ctx, blockRoot)
+	slot, err := s.SlotByBlockRoot(ctx, blockRoot)
 	if err != nil {
 		return nil, err
 	}
-	if stateSummary == nil {
-		return nil, ErrNotFoundState
-	}
-
-	slot := stateSummary.Slot
 
 	if uint64(slot) < s.getOffset() {
 		return nil, ErrSlotBeforeOffset
@@ -1070,33 +1065,14 @@ func (s *Store) getStateUsingStateDiff(ctx context.Context, blockRoot [32]byte)
 		return nil, errors.New("state not found")
 	}
 
-	blk, err := s.Block(ctx, blockRoot)
-	if err != nil {
-		return nil, err
-	}
-	if blk != nil && !blk.IsNil() {
-		stateRoot, err := st.HashTreeRoot(ctx)
-		if err != nil {
-			return nil, err
-		}
-		if stateRoot != blk.Block().StateRoot() {
-			return nil, errors.Wrap(ErrNotFoundState, "state root mismatch for block")
-		}
-	}
-
 	return st, nil
 }
 
 func (s *Store) hasStateUsingStateDiff(ctx context.Context, blockRoot [32]byte) (bool, error) {
-	stateSummary, err := s.StateSummary(ctx, blockRoot)
+	slot, err := s.SlotByBlockRoot(ctx, blockRoot)
 	if err != nil {
 		return false, err
 	}
-	if stateSummary == nil {
-		return false, nil
-	}
-
-	slot := stateSummary.Slot
 
 	if uint64(slot) < s.getOffset() {
 		return false, ErrSlotBeforeOffset

beacon-chain/db/kv/state_diff.go

@@ -2,7 +2,6 @@ package kv
 
 import (
 	"context"
-	"slices"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v7/cmd/beacon-chain/flags"
@@ -133,9 +132,6 @@ func (s *Store) saveHdiff(lvl int, anchor, st state.ReadOnlyBeaconState) error {
 			return err
 		}
 	}
-	if err := s.stateDiffCache.setLevelHasData(lvl); err != nil {
-		return err
-	}
 
 	return nil
 }
@@ -175,9 +171,6 @@ func (s *Store) saveFullSnapshot(st state.ReadOnlyBeaconState) error {
 	if err != nil {
 		return err
 	}
-	if err := s.stateDiffCache.setLevelHasData(0); err != nil {
-		return err
-	}
 
 	return nil
 }
@@ -194,23 +187,20 @@ func (s *Store) getDiff(lvl int, slot uint64) (hdiff.HdiffBytes, error) {
 			return bolt.ErrBucketNotFound
 		}
 		buf := append(key, stateSuffix...)
-		rawStateDiff := bucket.Get(buf)
-		if len(rawStateDiff) == 0 {
+		stateDiff = bucket.Get(buf)
+		if stateDiff == nil {
 			return errors.New("state diff not found")
 		}
-		stateDiff = slices.Clone(rawStateDiff)
 		buf = append(key, validatorSuffix...)
-		rawValidatorDiff := bucket.Get(buf)
-		if len(rawValidatorDiff) == 0 {
+		validatorDiff = bucket.Get(buf)
+		if validatorDiff == nil {
 			return errors.New("validator diff not found")
 		}
-		validatorDiff = slices.Clone(rawValidatorDiff)
 		buf = append(key, balancesSuffix...)
-		rawBalancesDiff := bucket.Get(buf)
-		if len(rawBalancesDiff) == 0 {
+		balancesDiff = bucket.Get(buf)
+		if balancesDiff == nil {
 			return errors.New("balances diff not found")
 		}
-		balancesDiff = slices.Clone(rawBalancesDiff)
 		return nil
 	})
 
@@ -234,11 +224,10 @@ func (s *Store) getFullSnapshot(slot uint64) (state.BeaconState, error) {
 		if bucket == nil {
 			return bolt.ErrBucketNotFound
 		}
-		rawEnc := bucket.Get(key)
-		if rawEnc == nil {
+		enc = bucket.Get(key)
+		if enc == nil {
 			return errors.New("state not found")
 		}
-		enc = slices.Clone(rawEnc)
 		return nil
 	})
 

beacon-chain/db/kv/state_diff_cache.go

@@ -1,131 +1,19 @@
 package kv
 
 import (
-	"context"
 	"encoding/binary"
 	"errors"
 	"sync"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v7/cmd/beacon-chain/flags"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	pkgerrors "github.com/pkg/errors"
 	"go.etcd.io/bbolt"
 )
 
 type stateDiffCache struct {
 	sync.RWMutex
-	anchors        []state.ReadOnlyBeaconState
-	levelsWithData []bool
-	offset         uint64
-}
-
-func populateStateDiffCacheFromDB(s *Store, offset uint64) (*stateDiffCache, error) {
-	cache := &stateDiffCache{
-		anchors:        make([]state.ReadOnlyBeaconState, len(flags.Get().StateDiffExponents)-1),
-		levelsWithData: make([]bool, len(flags.Get().StateDiffExponents)),
-		offset:         offset,
-	}
-
-	if err := s.db.View(func(tx *bbolt.Tx) error {
-		bucket := tx.Bucket(stateDiffBucket)
-		if bucket == nil {
-			return bbolt.ErrBucketNotFound
-		}
-		for level := range cache.levelsWithData {
-			if level == 0 {
-				if bucket.Get(makeKeyForStateDiffTree(0, offset)) != nil {
-					cache.levelsWithData[level] = true
-				}
-				continue
-			}
-			cursor := bucket.Cursor()
-			prefix := []byte{byte(level)}
-			key, _ := cursor.Seek(prefix)
-			if key != nil && key[0] == byte(level) {
-				slot, ok := slotFromStateDiffKey(key)
-				if !ok {
-					return ErrStateDiffCorrupted
-				}
-				if slot < offset {
-					return ErrStateDiffCorrupted
-				}
-				if level == 0 && slot != offset {
-					return ErrStateDiffCorrupted
-				}
-				if computeLevel(offset, primitives.Slot(slot)) != level {
-					return ErrStateDiffCorrupted
-				}
-				cache.levelsWithData[level] = true
-			}
-		}
-		return nil
-	}); err != nil {
-		return nil, err
-	}
-
-	anchor0, err := s.getFullSnapshot(offset)
-	if err != nil {
-		return nil, pkgerrors.Wrapf(ErrStateDiffMissingSnapshot, "state diff cache: missing offset snapshot at %d", offset)
-	}
-	cache.anchors[0] = anchor0
-	cache.levelsWithData[0] = true
-
-	return cache, nil
-}
-
-func validateStateDiffCache(ctx context.Context, s *Store, cache *stateDiffCache) error {
-	for level, hasData := range cache.levelsWithData {
-		if !hasData || level == 0 {
-			continue
-		}
-		maxSlot, err := latestSlotForLevel(s, level)
-		if err != nil {
-			return err
-		}
-		if _, err := s.stateByDiff(ctx, primitives.Slot(maxSlot)); err != nil {
-			return pkgerrors.Wrapf(ErrStateDiffCorrupted, "state diff validation failed for level %d slot %d: %v", level, maxSlot, err)
-		}
-	}
-	return nil
-}
-
-func latestSlotForLevel(s *Store, level int) (uint64, error) {
-	var maxSlot uint64
-	found := false
-	err := s.db.View(func(tx *bbolt.Tx) error {
-		bucket := tx.Bucket(stateDiffBucket)
-		if bucket == nil {
-			return bbolt.ErrBucketNotFound
-		}
-		cursor := bucket.Cursor()
-		prefix := []byte{byte(level)}
-		for key, _ := cursor.Seek(prefix); key != nil && key[0] == byte(level); key, _ = cursor.Next() {
-			slot, ok := slotFromStateDiffKey(key)
-			if !ok {
-				return ErrStateDiffCorrupted
-			}
-			if !found || slot > maxSlot {
-				maxSlot = slot
-				found = true
-			}
-		}
-		return nil
-	})
-	if err != nil {
-		return 0, err
-	}
-	if !found {
-		return 0, ErrStateDiffCorrupted
-	}
-	return maxSlot, nil
-}
-
-func slotFromStateDiffKey(key []byte) (uint64, bool) {
-	if len(key) < 9 {
-		return 0, false
-	}
-	return binary.LittleEndian.Uint64(key[1:9]), true
+	anchors []state.ReadOnlyBeaconState
+	offset  uint64
 }
 
 func newStateDiffCache(s *Store) (*stateDiffCache, error) {
@@ -149,9 +37,8 @@ func newStateDiffCache(s *Store) (*stateDiffCache, error) {
 	}
 
 	return &stateDiffCache{
-		anchors:        make([]state.ReadOnlyBeaconState, len(flags.Get().StateDiffExponents)-1), // -1 because last level doesn't need to be cached
-		levelsWithData: make([]bool, len(flags.Get().StateDiffExponents)),
-		offset:         offset,
+		anchors: make([]state.ReadOnlyBeaconState, len(flags.Get().StateDiffExponents)-1), // -1 because last level doesn't need to be cached
+		offset:  offset,
 	}, nil
 }
 
@@ -171,25 +58,6 @@ func (c *stateDiffCache) setAnchor(level int, anchor state.ReadOnlyBeaconState)
 	return nil
 }
 
-func (c *stateDiffCache) levelHasData(level int) bool {
-	c.RLock()
-	defer c.RUnlock()
-	if level < 0 || level >= len(c.levelsWithData) {
-		return false
-	}
-	return c.levelsWithData[level]
-}
-
-func (c *stateDiffCache) setLevelHasData(level int) error {
-	c.Lock()
-	defer c.Unlock()
-	if level < 0 || level >= len(c.levelsWithData) {
-		return errors.New("state diff cache: level data index out of range")
-	}
-	c.levelsWithData[level] = true
-	return nil
-}
-
 func (c *stateDiffCache) getOffset() uint64 {
 	c.RLock()
 	defer c.RUnlock()

beacon-chain/db/kv/state_diff_helpers.go

@@ -5,7 +5,6 @@ import (
 	"encoding/binary"
 	"errors"
 	"fmt"
-	"strings"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	statenative "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
@@ -22,78 +21,9 @@ import (
 
 var (
 	offsetKey           = []byte("offset")
-	exponentsKey        = []byte("exponents")
 	ErrSlotBeforeOffset = errors.New("slot is before state-diff root offset")
 )
 
-func encodeStateDiffExponents(exponents []int) ([]byte, error) {
-	if len(exponents) == 0 {
-		return nil, errors.New("state diff exponents cannot be empty")
-	}
-	if len(exponents) > 255 {
-		return nil, fmt.Errorf("state diff exponents length %d exceeds max 255", len(exponents))
-	}
-	encoded := make([]byte, len(exponents)+1)
-	encoded[0] = byte(len(exponents))
-	for i, exp := range exponents {
-		if exp < 2 || exp > flags.MaxStateDiffExponent {
-			return nil, fmt.Errorf("state diff exponent %d out of range for encoding", exp)
-		}
-		encoded[i+1] = byte(exp)
-	}
-	return encoded, nil
-}
-
-func decodeStateDiffExponents(encoded []byte) ([]int, error) {
-	if len(encoded) == 0 {
-		return nil, errors.New("state diff exponents missing length prefix")
-	}
-	count := int(encoded[0])
-	if count == 0 {
-		return nil, errors.New("state diff exponents length cannot be zero")
-	}
-	if len(encoded) != count+1 {
-		return nil, fmt.Errorf("state diff exponents length mismatch: expected %d got %d", count, len(encoded)-1)
-	}
-	exponents := make([]int, count)
-	for i := range count {
-		exponents[i] = int(encoded[i+1])
-	}
-	return exponents, nil
-}
-
-func formatStateDiffExponents(exponents []int) string {
-	if len(exponents) == 0 {
-		return ""
-	}
-	parts := make([]string, len(exponents))
-	for i, exp := range exponents {
-		parts[i] = fmt.Sprintf("%d", exp)
-	}
-	return strings.Join(parts, ",")
-}
-
-func (s *Store) loadStateDiffExponents() ([]int, error) {
-	var encoded []byte
-	err := s.db.View(func(tx *bbolt.Tx) error {
-		bucket := tx.Bucket(stateDiffBucket)
-		if bucket == nil {
-			return bbolt.ErrBucketNotFound
-		}
-		value := bucket.Get(exponentsKey)
-		if value == nil {
-			return errors.New("state diff exponents not found")
-		}
-		encoded = make([]byte, len(value))
-		copy(encoded, value)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return decodeStateDiffExponents(encoded)
-}
-
 func makeKeyForStateDiffTree(level int, slot uint64) []byte {
 	buf := make([]byte, 16)
 	buf[0] = byte(level)
@@ -194,29 +124,6 @@ func (s *Store) getOffset() uint64 {
 	return s.stateDiffCache.getOffset()
 }
 
-func (s *Store) loadOffset() (uint64, error) {
-	var offset uint64
-	err := s.db.View(func(tx *bbolt.Tx) error {
-		bucket := tx.Bucket(stateDiffBucket)
-		if bucket == nil {
-			return bbolt.ErrBucketNotFound
-		}
-		offsetBytes := bucket.Get(offsetKey)
-		if offsetBytes == nil {
-			return errors.New("state diff offset not found")
-		}
-		if len(offsetBytes) != 8 {
-			return fmt.Errorf("state diff offset has invalid length %d", len(offsetBytes))
-		}
-		offset = binary.LittleEndian.Uint64(offsetBytes)
-		return nil
-	})
-	if err != nil {
-		return 0, err
-	}
-	return offset, nil
-}
-
 // hasStateDiffOffset checks if the state-diff offset has been set in the database.
 // This is used to detect if an existing database has state-diff enabled.
 func (s *Store) hasStateDiffOffset() (bool, error) {
@@ -246,13 +153,8 @@ func (s *Store) initializeStateDiff(slot primitives.Slot, initialState state.Rea
 			return nil
 		}
 	}
-	exponentsBytes, err := encodeStateDiffExponents(flags.Get().StateDiffExponents)
-	if err != nil {
-		return pkgerrors.Wrap(err, "failed to encode state diff exponents")
-	}
-
-	// Write metadata directly to the database (without using cache which doesn't exist yet).
-	err = s.db.Update(func(tx *bbolt.Tx) error {
+	// Write offset directly to the database (without using cache which doesn't exist yet).
+	err := s.db.Update(func(tx *bbolt.Tx) error {
 		bucket := tx.Bucket(stateDiffBucket)
 		if bucket == nil {
 			return bbolt.ErrBucketNotFound
@@ -260,10 +162,7 @@ func (s *Store) initializeStateDiff(slot primitives.Slot, initialState state.Rea
 
 		offsetBytes := make([]byte, 8)
 		binary.LittleEndian.PutUint64(offsetBytes, uint64(slot))
-		if err := bucket.Put(offsetKey, offsetBytes); err != nil {
-			return err
-		}
-		return bucket.Put(exponentsKey, exponentsBytes)
+		return bucket.Put(offsetKey, offsetBytes)
 	})
 	if err != nil {
 		return pkgerrors.Wrap(err, "failed to set offset")
@@ -387,20 +286,15 @@ func (s *Store) getBaseAndDiffChain(offset uint64, slot primitives.Slot) (state.
 	}
 
 	var diffChainItems []diffItem
-	lastSeenAnchorRelSlot := baseAnchorSlot - offset
+	lastSeenAnchorSlot := baseAnchorSlot
 	for i, exp := range exponents[1 : lvl+1] {
 		span := math.PowerOf2(uint64(exp))
 		diffSlot := rel / span * span
-		if diffSlot == lastSeenAnchorRelSlot {
+		if diffSlot == lastSeenAnchorSlot {
 			continue
 		}
-		level := i + 1
-		if s.stateDiffCache != nil && !s.stateDiffCache.levelHasData(level) {
-			lastSeenAnchorRelSlot = diffSlot
-			continue
-		}
-		diffChainItems = append(diffChainItems, diffItem{level: level, slot: diffSlot + offset})
-		lastSeenAnchorRelSlot = diffSlot
+		diffChainItems = append(diffChainItems, diffItem{level: i + 1, slot: diffSlot + offset})
+		lastSeenAnchorSlot = diffSlot
 	}
 
 	baseSnapshot, err := s.getFullSnapshot(baseAnchorSlot)

beacon-chain/db/kv/state_diff_test.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v7/cmd/beacon-chain/flags"
-	"github.com/OffchainLabs/prysm/v7/config/features"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/math"
@@ -35,81 +34,6 @@ func TestStateDiff_LoadOrInitOffset(t *testing.T) {
 	require.Equal(t, uint64(10), offset)
 }
 
-func TestStateDiff_LoadOffset(t *testing.T) {
-	setDefaultStateDiffExponents()
-
-	db := setupDB(t)
-	_, err := db.loadOffset()
-	require.ErrorContains(t, "offset not found", err)
-
-	err = setOffsetInDB(db, 10)
-	require.NoError(t, err)
-	offset, err := db.loadOffset()
-	require.NoError(t, err)
-	require.Equal(t, uint64(10), offset)
-}
-
-func TestStateDiff_EncodeDecodeExponents(t *testing.T) {
-	t.Run("roundtrip", func(t *testing.T) {
-		exponents := []int{21, 18, 16, 13}
-		encoded, err := encodeStateDiffExponents(exponents)
-		require.NoError(t, err)
-		decoded, err := decodeStateDiffExponents(encoded)
-		require.NoError(t, err)
-		require.DeepEqual(t, exponents, decoded)
-	})
-
-	t.Run("encode-empty", func(t *testing.T) {
-		_, err := encodeStateDiffExponents(nil)
-		require.ErrorContains(t, "cannot be empty", err)
-	})
-
-	t.Run("encode-negative", func(t *testing.T) {
-		_, err := encodeStateDiffExponents([]int{21, -1})
-		require.ErrorContains(t, "out of range", err)
-	})
-
-	t.Run("encode-too-large", func(t *testing.T) {
-		_, err := encodeStateDiffExponents([]int{flags.MaxStateDiffExponent + 1})
-		require.ErrorContains(t, "out of range", err)
-	})
-
-	t.Run("decode-empty", func(t *testing.T) {
-		_, err := decodeStateDiffExponents(nil)
-		require.ErrorContains(t, "missing length prefix", err)
-	})
-
-	t.Run("decode-zero-length", func(t *testing.T) {
-		_, err := decodeStateDiffExponents([]byte{0})
-		require.ErrorContains(t, "length cannot be zero", err)
-	})
-
-	t.Run("decode-length-mismatch", func(t *testing.T) {
-		_, err := decodeStateDiffExponents([]byte{2, 10})
-		require.ErrorContains(t, "length mismatch", err)
-	})
-}
-
-func TestStateDiff_InitializeStoresExponents(t *testing.T) {
-	setDefaultStateDiffExponents()
-	resetCfg := features.InitWithReset(&features.Flags{EnableStateDiff: true})
-	defer resetCfg()
-
-	db := setupDB(t)
-	st, _ := createState(t, 0, version.Phase0)
-	require.NoError(t, db.initializeStateDiff(0, st))
-
-	stored, err := db.loadStateDiffExponents()
-	require.NoError(t, err)
-	require.DeepEqual(t, flags.Get().StateDiffExponents, stored)
-}
-
-func TestStateDiff_LoadExponentsMissing(t *testing.T) {
-	db := setupDB(t)
-	_, err := db.loadStateDiffExponents()
-	require.ErrorContains(t, "exponents not found", err)
-}
-
 func TestStateDiff_ComputeLevel(t *testing.T) {
 	db := setupDB(t)
 	setDefaultStateDiffExponents()
@@ -230,124 +154,6 @@ func TestStateDiff_SaveFullSnapshot(t *testing.T) {
 	}
 }
 
-func TestStateDiff_StateByDiff_NonZeroOffsetSkipsRedundantLevelDiff(t *testing.T) {
-	setStateDiffExponents([]int{6, 5, 4})
-
-	db := setupDB(t)
-
-	offset := uint64(1000)
-	require.NoError(t, setOffsetInDB(db, offset))
-
-	stOffset, _ := createState(t, primitives.Slot(offset), version.Phase0)
-	require.NoError(t, db.saveStateByDiff(context.Background(), stOffset))
-
-	st32, _ := createState(t, primitives.Slot(offset+32), version.Phase0)
-	require.NoError(t, db.saveStateByDiff(context.Background(), st32))
-
-	st64, _ := createState(t, primitives.Slot(offset+64), version.Phase0)
-	require.NoError(t, db.saveStateByDiff(context.Background(), st64))
-
-	st80, _ := createState(t, primitives.Slot(offset+80), version.Phase0)
-	require.NoError(t, db.saveStateByDiff(context.Background(), st80))
-
-	readSt, err := db.stateByDiff(context.Background(), primitives.Slot(offset+80))
-	require.NoError(t, err)
-
-	stWantSSZ, err := st80.MarshalSSZ()
-	require.NoError(t, err)
-	stGotSSZ, err := readSt.MarshalSSZ()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, stWantSSZ, stGotSSZ)
-}
-
-func TestStateDiff_PopulateStateDiffCacheFromDB(t *testing.T) {
-	setDefaultStateDiffExponents()
-
-	db := setupDB(t)
-	_, err := populateStateDiffCacheFromDB(db, 0)
-	require.ErrorContains(t, "missing offset snapshot", err)
-
-	st, _ := createState(t, 0, version.Phase0)
-	require.NoError(t, setOffsetInDB(db, 0))
-	require.NoError(t, db.saveStateByDiff(context.Background(), st))
-
-	err = db.db.Update(func(tx *bbolt.Tx) error {
-		bucket := tx.Bucket(stateDiffBucket)
-		if bucket == nil {
-			return bbolt.ErrBucketNotFound
-		}
-		key := makeKeyForStateDiffTree(2, math.PowerOf2(16))
-		return bucket.Put(append(key, stateSuffix...), []byte{1})
-	})
-	require.NoError(t, err)
-
-	cache, err := populateStateDiffCacheFromDB(db, 0)
-	require.NoError(t, err)
-	require.NotNil(t, cache)
-	require.Equal(t, uint64(0), cache.getOffset())
-	require.NotNil(t, cache.getAnchor(0))
-	require.Equal(t, true, cache.levelHasData(0))
-	require.Equal(t, false, cache.levelHasData(1))
-	require.Equal(t, true, cache.levelHasData(2))
-}
-
-func TestStateDiff_PopulateStateDiffCacheFromDB_InvalidLevelKey(t *testing.T) {
-	setDefaultStateDiffExponents()
-
-	db := setupDB(t)
-	st, _ := createState(t, 0, version.Phase0)
-	require.NoError(t, setOffsetInDB(db, 0))
-	require.NoError(t, db.saveStateByDiff(context.Background(), st))
-
-	require.NoError(t, db.db.Update(func(tx *bbolt.Tx) error {
-		bucket := tx.Bucket(stateDiffBucket)
-		if bucket == nil {
-			return bbolt.ErrBucketNotFound
-		}
-		key := makeKeyForStateDiffTree(2, 1)
-		return bucket.Put(append(key, stateSuffix...), []byte{1})
-	}))
-
-	_, err := populateStateDiffCacheFromDB(db, 0)
-	require.ErrorIs(t, ErrStateDiffCorrupted, err)
-}
-
-func TestStateDiff_GetBaseAndDiffChainSkipsEmptyLevels(t *testing.T) {
-	setDefaultStateDiffExponents()
-
-	db := setupDB(t)
-	require.NoError(t, setOffsetInDB(db, 0))
-	st, _ := createState(t, 0, version.Phase0)
-	require.NoError(t, db.saveFullSnapshot(st))
-
-	cache, err := populateStateDiffCacheFromDB(db, 0)
-	require.NoError(t, err)
-	cache.levelsWithData[0] = true
-	cache.levelsWithData[1] = false
-	cache.levelsWithData[2] = true
-	db.stateDiffCache = cache
-
-	slot := primitives.Slot(math.PowerOf2(18) + math.PowerOf2(16))
-	key := makeKeyForStateDiffTree(2, uint64(slot))
-	require.NoError(t, db.db.Update(func(tx *bbolt.Tx) error {
-		bucket := tx.Bucket(stateDiffBucket)
-		if bucket == nil {
-			return bbolt.ErrBucketNotFound
-		}
-		if err := bucket.Put(append(key, stateSuffix...), []byte{1}); err != nil {
-			return err
-		}
-		if err := bucket.Put(append(key, validatorSuffix...), []byte{2}); err != nil {
-			return err
-		}
-		return bucket.Put(append(key, balancesSuffix...), []byte{3})
-	}))
-
-	_, diffChain, err := db.getBaseAndDiffChain(0, slot)
-	require.NoError(t, err)
-	require.Equal(t, 1, len(diffChain))
-}
-
 func TestStateDiff_SaveAndReadFullSnapshot(t *testing.T) {
 	setDefaultStateDiffExponents()
 
@@ -853,10 +659,8 @@ func setOffsetInDB(s *Store, offset uint64) error {
 }
 
 func setDefaultStateDiffExponents() {
-	setStateDiffExponents([]int{21, 18, 16, 13, 11, 9, 5})
-}
-
-func setStateDiffExponents(exponents []int) {
-	globalFlags := flags.GlobalFlags{StateDiffExponents: exponents}
+	globalFlags := flags.GlobalFlags{
+		StateDiffExponents: []int{21, 18, 16, 13, 11, 9, 5},
+	}
 	flags.Init(&globalFlags)
 }

beacon-chain/db/kv/state_summary.go

@@ -2,7 +2,6 @@ package kv
 
 import (
 	"context"
-	"slices"
 
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
@@ -48,11 +47,7 @@ func (s *Store) StateSummary(ctx context.Context, blockRoot [32]byte) (*ethpb.St
 	}
 	var enc []byte
 	if err := s.db.View(func(tx *bolt.Tx) error {
-		rawEnc := tx.Bucket(stateSummaryBucket).Get(blockRoot[:])
-		if len(rawEnc) == 0 {
-			return nil
-		}
-		enc = slices.Clone(rawEnc)
+		enc = tx.Bucket(stateSummaryBucket).Get(blockRoot[:])
 		return nil
 	}); err != nil {
 		return nil, err

beacon-chain/db/kv/state_test.go

@@ -26,6 +26,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/testing/assert"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
 	"github.com/OffchainLabs/prysm/v7/testing/util"
+	logTest "github.com/sirupsen/logrus/hooks/test"
 	bolt "go.etcd.io/bbolt"
 )
 
@@ -1348,7 +1349,7 @@ func TestStore_CanSaveRetrieveStateUsingStateDiff(t *testing.T) {
 
 		readSt, err := db.State(context.Background(), [32]byte{'A'})
 		require.IsNil(t, readSt)
-		require.ErrorIs(t, err, ErrNotFoundState)
+		require.ErrorContains(t, "neither state summary nor block found", err)
 	})
 
 	t.Run("Slot not in tree", func(t *testing.T) {
@@ -1476,8 +1477,14 @@ func TestStore_CanSaveRetrieveStateUsingStateDiff(t *testing.T) {
 					require.NoError(t, err)
 
 					readSt, err := db.State(context.Background(), r)
-					require.ErrorIs(t, err, ErrNotFoundState)
-					require.IsNil(t, readSt)
+					require.NoError(t, err)
+					require.NotNil(t, readSt)
+
+					stSSZ, err := st.MarshalSSZ()
+					require.NoError(t, err)
+					readStSSZ, err := readSt.MarshalSSZ()
+					require.NoError(t, err)
+					require.DeepSSZEqual(t, stSSZ, readStSSZ)
 				})
 			}
 		})
@@ -1571,8 +1578,14 @@ func TestStore_CanSaveRetrieveStateUsingStateDiff(t *testing.T) {
 					require.NoError(t, err)
 
 					readSt, err := db.State(context.Background(), r)
-					require.ErrorIs(t, err, ErrNotFoundState)
-					require.IsNil(t, readSt)
+					require.NoError(t, err)
+					require.NotNil(t, readSt)
+
+					stSSZ, err := st.MarshalSSZ()
+					require.NoError(t, err)
+					readStSSZ, err := readSt.MarshalSSZ()
+					require.NoError(t, err)
+					require.DeepSSZEqual(t, stSSZ, readStSSZ)
 				})
 			}
 		})
@@ -1581,6 +1594,7 @@ func TestStore_CanSaveRetrieveStateUsingStateDiff(t *testing.T) {
 
 func TestStore_HasStateUsingStateDiff(t *testing.T) {
 	t.Run("No state summary or block", func(t *testing.T) {
+		hook := logTest.NewGlobal()
 		db := setupDB(t)
 		featCfg := &features.Flags{}
 		featCfg.EnableStateDiff = true
@@ -1593,6 +1607,7 @@ func TestStore_HasStateUsingStateDiff(t *testing.T) {
 
 		hasSt := db.HasState(t.Context(), [32]byte{'A'})
 		require.Equal(t, false, hasSt)
+		require.LogsContain(t, hook, "neither state summary nor block found")
 	})
 
 	t.Run("slot in tree or not", func(t *testing.T) {

beacon-chain/forkchoice/doubly-linked-tree/BUILD.bazel

@@ -6,6 +6,7 @@ go_library(
         "doc.go",
         "errors.go",
         "forkchoice.go",
+        "last_root.go",
         "log.go",
         "metrics.go",
         "node.go",
@@ -50,6 +51,7 @@ go_test(
     srcs = [
         "ffg_update_test.go",
         "forkchoice_test.go",
+        "last_root_test.go",
         "no_vote_test.go",
         "node_test.go",
         "on_tick_test.go",

beacon-chain/forkchoice/doubly-linked-tree/forkchoice.go

@@ -32,6 +32,7 @@ func New() *ForkChoice {
 		finalizedCheckpoint:           &forkchoicetypes.Checkpoint{},
 		proposerBoostRoot:             [32]byte{},
 		nodeByRoot:                    make(map[[fieldparams.RootLength]byte]*Node),
+		nodeByPayload:                 make(map[[fieldparams.RootLength]byte]*Node),
 		slashedIndices:                make(map[primitives.ValidatorIndex]bool),
 		receivedBlocksLastEpoch:       [fieldparams.SlotsPerEpoch]primitives.Slot{},
 	}

beacon-chain/forkchoice/doubly-linked-tree/last_root.go

@@ -0,0 +1,26 @@
+package doublylinkedtree
+
+import (
+	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v7/time/slots"
+)
+
+// LastRoot returns the last canonical block root in the given epoch
+func (f *ForkChoice) LastRoot(epoch primitives.Epoch) [32]byte {
+	head := f.store.headNode
+	headEpoch := slots.ToEpoch(head.slot)
+	epochEnd, err := slots.EpochEnd(epoch)
+	if err != nil {
+		return [32]byte{}
+	}
+	if headEpoch <= epoch {
+		return head.root
+	}
+	for head != nil && head.slot > epochEnd {
+		head = head.parent
+	}
+	if head == nil {
+		return [32]byte{}
+	}
+	return head.root
+}

beacon-chain/forkchoice/doubly-linked-tree/last_root_test.go

@@ -0,0 +1,38 @@
+package doublylinkedtree
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+)
+
+func TestLastRoot(t *testing.T) {
+	f := setup(0, 0)
+	ctx := t.Context()
+
+	st, root, err := prepareForkchoiceState(ctx, 1, [32]byte{'1'}, params.BeaconConfig().ZeroHash, [32]byte{'1'}, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, root))
+	st, root, err = prepareForkchoiceState(ctx, 2, [32]byte{'2'}, [32]byte{'1'}, [32]byte{'2'}, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, root))
+	st, root, err = prepareForkchoiceState(ctx, 3, [32]byte{'3'}, [32]byte{'1'}, [32]byte{'3'}, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, root))
+	st, root, err = prepareForkchoiceState(ctx, 32, [32]byte{'4'}, [32]byte{'3'}, [32]byte{'4'}, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, root))
+	st, root, err = prepareForkchoiceState(ctx, 33, [32]byte{'5'}, [32]byte{'2'}, [32]byte{'5'}, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, root))
+	st, root, err = prepareForkchoiceState(ctx, 34, [32]byte{'6'}, [32]byte{'5'}, [32]byte{'6'}, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, st, root))
+	headNode := f.store.nodeByRoot[[32]byte{'6'}]
+	f.store.headNode = headNode
+	require.Equal(t, [32]byte{'6'}, f.store.headNode.root)
+	require.Equal(t, [32]byte{'2'}, f.LastRoot(0))
+	require.Equal(t, [32]byte{'6'}, f.LastRoot(1))
+	require.Equal(t, [32]byte{'6'}, f.LastRoot(2))
+}

beacon-chain/forkchoice/doubly-linked-tree/optimistic_sync.go

@@ -94,5 +94,6 @@ func (s *Store) removeNodeAndChildren(ctx context.Context, node *Node, invalidRo
 		s.previousProposerBoostScore = 0
 	}
 	delete(s.nodeByRoot, node.root)
+	delete(s.nodeByPayload, node.payloadHash)
 	return invalidRoots, nil
 }

beacon-chain/forkchoice/doubly-linked-tree/store.go

@@ -113,6 +113,7 @@ func (s *Store) insert(ctx context.Context,
 		}
 	}
 
+	s.nodeByPayload[payloadHash] = n
 	s.nodeByRoot[root] = n
 	if parent == nil {
 		if s.treeRootNode == nil {
@@ -121,6 +122,7 @@ func (s *Store) insert(ctx context.Context,
 			s.highestReceivedNode = n
 		} else {
 			delete(s.nodeByRoot, root)
+			delete(s.nodeByPayload, payloadHash)
 			return nil, errInvalidParentRoot
 		}
 	} else {
@@ -189,6 +191,7 @@ func (s *Store) pruneFinalizedNodeByRootMap(ctx context.Context, node, finalized
 
 	node.children = nil
 	delete(s.nodeByRoot, node.root)
+	delete(s.nodeByPayload, node.payloadHash)
 	return nil
 }
 
@@ -270,6 +273,21 @@ func (f *ForkChoice) HighestReceivedBlockSlot() primitives.Slot {
 	return f.store.highestReceivedNode.slot
 }
 
+// HighestReceivedBlockDelay returns the number of slots that the highest
+// received block was late when receiving it. For example, a block was late by 12 slots,
+// then this method is expected to return 12.
+func (f *ForkChoice) HighestReceivedBlockDelay() primitives.Slot {
+	n := f.store.highestReceivedNode
+	if n == nil {
+		return 0
+	}
+	sss, err := slots.SinceSlotStart(n.slot, f.store.genesisTime, n.timestamp)
+	if err != nil {
+		return 0
+	}
+	return primitives.Slot(uint64(sss/time.Second) / params.BeaconConfig().SecondsPerSlot)
+}
+
 // ReceivedBlocksLastEpoch returns the number of blocks received in the last epoch
 func (f *ForkChoice) ReceivedBlocksLastEpoch() (uint64, error) {
 	count := uint64(0)

beacon-chain/forkchoice/doubly-linked-tree/store_test.go

@@ -128,9 +128,10 @@ func TestStore_Insert(t *testing.T) {
 	// The new node does not have a parent.
 	treeRootNode := &Node{slot: 0, root: indexToHash(0)}
 	nodeByRoot := map[[32]byte]*Node{indexToHash(0): treeRootNode}
+	nodeByPayload := map[[32]byte]*Node{indexToHash(0): treeRootNode}
 	jc := &forkchoicetypes.Checkpoint{Epoch: 0}
 	fc := &forkchoicetypes.Checkpoint{Epoch: 0}
-	s := &Store{nodeByRoot: nodeByRoot, treeRootNode: treeRootNode, justifiedCheckpoint: jc, finalizedCheckpoint: fc, highestReceivedNode: &Node{}}
+	s := &Store{nodeByRoot: nodeByRoot, treeRootNode: treeRootNode, nodeByPayload: nodeByPayload, justifiedCheckpoint: jc, finalizedCheckpoint: fc, highestReceivedNode: &Node{}}
 	payloadHash := [32]byte{'a'}
 	ctx := t.Context()
 	_, blk, err := prepareForkchoiceState(ctx, 100, indexToHash(100), indexToHash(0), payloadHash, 1, 1)
@@ -237,6 +238,7 @@ func TestStore_Prune_NoDanglingBranch(t *testing.T) {
 	s.finalizedCheckpoint.Root = indexToHash(1)
 	require.NoError(t, s.prune(t.Context()))
 	require.Equal(t, len(s.nodeByRoot), 1)
+	require.Equal(t, len(s.nodeByPayload), 1)
 }
 
 // This test starts with the following branching diagram
@@ -317,6 +319,8 @@ func TestStore_PruneMapsNodes(t *testing.T) {
 	s.finalizedCheckpoint.Root = indexToHash(1)
 	require.NoError(t, s.prune(t.Context()))
 	require.Equal(t, len(s.nodeByRoot), 1)
+	require.Equal(t, len(s.nodeByPayload), 1)
+
 }
 
 func TestForkChoice_ReceivedBlocksLastEpoch(t *testing.T) {
@@ -335,6 +339,7 @@ func TestForkChoice_ReceivedBlocksLastEpoch(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, uint64(1), count)
 	require.Equal(t, primitives.Slot(1), f.HighestReceivedBlockSlot())
+	require.Equal(t, primitives.Slot(0), f.HighestReceivedBlockDelay())
 
 	// 64
 	// Received block last epoch is 1
@@ -347,6 +352,7 @@ func TestForkChoice_ReceivedBlocksLastEpoch(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, uint64(1), count)
 	require.Equal(t, primitives.Slot(64), f.HighestReceivedBlockSlot())
+	require.Equal(t, primitives.Slot(0), f.HighestReceivedBlockDelay())
 
 	// 64 65
 	// Received block last epoch is 2
@@ -359,6 +365,7 @@ func TestForkChoice_ReceivedBlocksLastEpoch(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, uint64(2), count)
 	require.Equal(t, primitives.Slot(65), f.HighestReceivedBlockSlot())
+	require.Equal(t, primitives.Slot(1), f.HighestReceivedBlockDelay())
 
 	// 64 65 66
 	// Received block last epoch is 3
@@ -710,3 +717,17 @@ func TestStore_CleanupInserting(t *testing.T) {
 	require.NotNil(t, f.InsertNode(ctx, st, blk))
 	require.Equal(t, false, f.HasNode(blk.Root()))
 }
+
+func TestStore_HighestReceivedBlockDelay(t *testing.T) {
+	f := ForkChoice{
+		store: &Store{
+			genesisTime: time.Unix(0, 0),
+			highestReceivedNode: &Node{
+				slot:      10,
+				timestamp: time.Unix(int64(((10 + 12) * params.BeaconConfig().SecondsPerSlot)), 0), // 12 slots late
+			},
+		},
+	}
+
+	require.Equal(t, primitives.Slot(12), f.HighestReceivedBlockDelay())
+}

beacon-chain/forkchoice/doubly-linked-tree/types.go

@@ -36,6 +36,7 @@ type Store struct {
 	treeRootNode                  *Node                                  // the root node of the store tree.
 	headNode                      *Node                                  // last head Node
 	nodeByRoot                    map[[fieldparams.RootLength]byte]*Node // nodes indexed by roots.
+	nodeByPayload                 map[[fieldparams.RootLength]byte]*Node // nodes indexed by payload Hash
 	slashedIndices                map[primitives.ValidatorIndex]bool     // the list of equivocating validator indices
 	originRoot                    [fieldparams.RootLength]byte           // The genesis block root
 	genesisTime                   time.Time

beacon-chain/forkchoice/interfaces.go

@@ -67,11 +67,13 @@ type FastGetter interface {
 	HasNode([32]byte) bool
 	HighestReceivedBlockSlot() primitives.Slot
 	HighestReceivedBlockRoot() [32]byte
+	HighestReceivedBlockDelay() primitives.Slot
 	IsCanonical(root [32]byte) bool
 	IsOptimistic(root [32]byte) (bool, error)
 	IsViableForCheckpoint(*forkchoicetypes.Checkpoint) (bool, error)
 	JustifiedCheckpoint() *forkchoicetypes.Checkpoint
 	JustifiedPayloadBlockHash() [32]byte
+	LastRoot(primitives.Epoch) [32]byte
 	NodeCount() int
 	PreviousJustifiedCheckpoint() *forkchoicetypes.Checkpoint
 	ProposerBoost() [fieldparams.RootLength]byte

beacon-chain/forkchoice/ro.go

@@ -121,6 +121,13 @@ func (ro *ROForkChoice) HighestReceivedBlockRoot() [32]byte {
 	return ro.getter.HighestReceivedBlockRoot()
 }
 
+// HighestReceivedBlockDelay delegates to the underlying forkchoice call, under a lock.
+func (ro *ROForkChoice) HighestReceivedBlockDelay() primitives.Slot {
+	ro.l.RLock()
+	defer ro.l.RUnlock()
+	return ro.getter.HighestReceivedBlockDelay()
+}
+
 // ReceivedBlocksLastEpoch delegates to the underlying forkchoice call, under a lock.
 func (ro *ROForkChoice) ReceivedBlocksLastEpoch() (uint64, error) {
 	ro.l.RLock()
@@ -156,6 +163,13 @@ func (ro *ROForkChoice) Slot(root [32]byte) (primitives.Slot, error) {
 	return ro.getter.Slot(root)
 }
 
+// LastRoot delegates to the underlying forkchoice call, under a lock.
+func (ro *ROForkChoice) LastRoot(e primitives.Epoch) [32]byte {
+	ro.l.RLock()
+	defer ro.l.RUnlock()
+	return ro.getter.LastRoot(e)
+}
+
 // DependentRoot delegates to the underlying forkchoice call, under a lock.
 func (ro *ROForkChoice) DependentRoot(epoch primitives.Epoch) ([32]byte, error) {
 	ro.l.RLock()

beacon-chain/forkchoice/ro_test.go

@@ -30,6 +30,7 @@ const (
 	nodeCountCalled
 	highestReceivedBlockSlotCalled
 	highestReceivedBlockRootCalled
+	highestReceivedBlockDelayCalled
 	receivedBlocksLastEpochCalled
 	weightCalled
 	isOptimisticCalled
@@ -117,6 +118,11 @@ func TestROLocking(t *testing.T) {
 			call: highestReceivedBlockSlotCalled,
 			cb:   func(g FastGetter) { g.HighestReceivedBlockSlot() },
 		},
+		{
+			name: "highestReceivedBlockDelayCalled",
+			call: highestReceivedBlockDelayCalled,
+			cb:   func(g FastGetter) { g.HighestReceivedBlockDelay() },
+		},
 		{
 			name: "receivedBlocksLastEpochCalled",
 			call: receivedBlocksLastEpochCalled,
@@ -142,6 +148,11 @@ func TestROLocking(t *testing.T) {
 			call: slotCalled,
 			cb:   func(g FastGetter) { _, err := g.Slot([32]byte{}); _discard(t, err) },
 		},
+		{
+			name: "lastRootCalled",
+			call: lastRootCalled,
+			cb:   func(g FastGetter) { g.LastRoot(0) },
+		},
 		{
 			name: "targetRootForEpochCalled",
 			call: targetRootForEpochCalled,
@@ -254,6 +265,11 @@ func (ro *mockROForkchoice) HighestReceivedBlockRoot() [32]byte {
 	return [32]byte{}
 }
 
+func (ro *mockROForkchoice) HighestReceivedBlockDelay() primitives.Slot {
+	ro.calls = append(ro.calls, highestReceivedBlockDelayCalled)
+	return 0
+}
+
 func (ro *mockROForkchoice) ReceivedBlocksLastEpoch() (uint64, error) {
 	ro.calls = append(ro.calls, receivedBlocksLastEpochCalled)
 	return 0, nil
@@ -279,6 +295,11 @@ func (ro *mockROForkchoice) Slot(_ [32]byte) (primitives.Slot, error) {
 	return 0, nil
 }
 
+func (ro *mockROForkchoice) LastRoot(_ primitives.Epoch) [32]byte {
+	ro.calls = append(ro.calls, lastRootCalled)
+	return [32]byte{}
+}
+
 // DependentRoot impoements FastGetter.
 func (ro *mockROForkchoice) DependentRoot(_ primitives.Epoch) ([32]byte, error) {
 	ro.calls = append(ro.calls, dependentRootCalled)

beacon-chain/node/node.go

@@ -550,12 +550,6 @@ func openDB(ctx context.Context, dbPath string, clearer *dbClearer) (*kv.Store,
 		cfg := features.Get()
 		cfg.EnableStateDiff = false
 		features.Init(cfg)
-	} else if errors.Is(err, kv.ErrStateDiffExponentMismatch) {
-		log.WithError(err).Error("State-diff configuration mismatch; restart aborted. Use the stored exponents or re-sync the database.")
-		return nil, err
-	} else if errors.Is(err, kv.ErrStateDiffMissingSnapshot) || errors.Is(err, kv.ErrStateDiffCorrupted) {
-		log.WithError(err).Error("State-diff database corrupted; restart aborted. Delete database and re-sync from genesis/checkpoint.")
-		return nil, err
 	} else if err != nil {
 		return nil, errors.Wrapf(err, "could not create database at %s", dbPath)
 	}

beacon-chain/p2p/gossip_topic_mappings.go

@@ -25,7 +25,6 @@ var gossipTopicMappings = map[string]func() proto.Message{
 	LightClientOptimisticUpdateTopicFormat:    func() proto.Message { return &ethpb.LightClientOptimisticUpdateAltair{} },
 	LightClientFinalityUpdateTopicFormat:      func() proto.Message { return &ethpb.LightClientFinalityUpdateAltair{} },
 	DataColumnSubnetTopicFormat:               func() proto.Message { return &ethpb.DataColumnSidecar{} },
-	PayloadAttestationMessageTopicFormat:      func() proto.Message { return &ethpb.PayloadAttestationMessage{} },
 }
 
 // GossipTopicMappings is a function to return the assigned data type
@@ -145,7 +144,4 @@ func init() {
 
 	// Specially handle Fulu objects.
 	GossipTypeMapping[reflect.TypeFor[*ethpb.SignedBeaconBlockFulu]()] = BlockSubnetTopicFormat
-
-	// Payload attestation messages.
-	GossipTypeMapping[reflect.TypeFor[*ethpb.PayloadAttestationMessage]()] = PayloadAttestationMessageTopicFormat
 }

beacon-chain/p2p/testing/p2p.go

@@ -138,9 +138,6 @@ func connect(a, b host.Host) error {
 func (p *TestP2P) ReceiveRPC(topic string, msg proto.Message) {
 	h, err := libp2p.New(libp2p.ResourceManager(&network.NullResourceManager{}))
 	require.NoError(p.t, err)
-	p.t.Cleanup(func() {
-		require.NoError(p.t, h.Close())
-	})
 	if err := connect(h, p.BHost); err != nil {
 		p.t.Fatalf("Failed to connect two peers for RPC: %v", err)
 	}
@@ -172,9 +169,6 @@ func (p *TestP2P) ReceiveRPC(topic string, msg proto.Message) {
 func (p *TestP2P) ReceivePubSub(topic string, msg proto.Message) {
 	h, err := libp2p.New(libp2p.ResourceManager(&network.NullResourceManager{}))
 	require.NoError(p.t, err)
-	p.t.Cleanup(func() {
-		require.NoError(p.t, h.Close())
-	})
 	ps, err := pubsub.NewFloodSub(context.Background(), h,
 		pubsub.WithMessageSigning(false),
 		pubsub.WithStrictSignatureVerification(false),

beacon-chain/p2p/topics.go

@@ -46,8 +46,6 @@ const (
 	GossipLightClientOptimisticUpdateMessage = "light_client_optimistic_update"
 	// GossipDataColumnSidecarMessage is the name for the data column sidecar message type.
 	GossipDataColumnSidecarMessage = "data_column_sidecar"
-	// GossipPayloadAttestationMessage is the name for the payload attestation message type.
-	GossipPayloadAttestationMessage = "payload_attestation_message"
 
 	// Topic Formats
 	//
@@ -77,8 +75,6 @@ const (
 	LightClientOptimisticUpdateTopicFormat = GossipProtocolAndDigest + GossipLightClientOptimisticUpdateMessage
 	// DataColumnSubnetTopicFormat is the topic format for the data column subnet.
 	DataColumnSubnetTopicFormat = GossipProtocolAndDigest + GossipDataColumnSidecarMessage + "_%d"
-	// PayloadAttestationMessageTopicFormat is the topic format for payload attestation messages.
-	PayloadAttestationMessageTopicFormat = GossipProtocolAndDigest + GossipPayloadAttestationMessage
 )
 
 // topic is a struct representing a single gossipsub topic.
@@ -145,7 +141,7 @@ func (s *Service) allTopics() []topic {
 	cfg := params.BeaconConfig()
 	// bellatrix: no special topics; electra: blobs topics handled all together
 	genesis, altair, capella := cfg.GenesisEpoch, cfg.AltairForkEpoch, cfg.CapellaForkEpoch
-	deneb, fulu, gloas, future := cfg.DenebForkEpoch, cfg.FuluForkEpoch, cfg.GloasForkEpoch, cfg.FarFutureEpoch
+	deneb, fulu, future := cfg.DenebForkEpoch, cfg.FuluForkEpoch, cfg.FarFutureEpoch
 	// Templates are starter topics - they have a placeholder digest and the subnet is set to the maximum value
 	// for the subnet (see how this is used in allSubnetsBelow). These are not directly returned by the method,
 	// they are copied and modified for each digest where they apply based on the start and end epochs.
@@ -162,7 +158,6 @@ func (s *Service) allTopics() []topic {
 		newTopic(altair, future, empty, GossipLightClientOptimisticUpdateMessage),
 		newTopic(altair, future, empty, GossipLightClientFinalityUpdateMessage),
 		newTopic(capella, future, empty, GossipBlsToExecutionChangeMessage),
-		newTopic(gloas, future, empty, GossipPayloadAttestationMessage),
 	}
 	last := params.GetNetworkScheduleEntry(genesis)
 	schedule := []params.NetworkScheduleEntry{last}

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

@@ -82,20 +82,20 @@ func (b *BeaconState) SetExecutionPayloadBid(h interfaces.ROExecutionPayloadBid)
 	parentBlockRoot := h.ParentBlockRoot()
 	blockHash := h.BlockHash()
 	randao := h.PrevRandao()
-	blobKzgCommitments := h.BlobKzgCommitments()
+	blobKzgCommitmentsRoot := h.BlobKzgCommitmentsRoot()
 	feeRecipient := h.FeeRecipient()
 	b.latestExecutionPayloadBid = &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:    parentBlockHash[:],
-		ParentBlockRoot:    parentBlockRoot[:],
-		BlockHash:          blockHash[:],
-		PrevRandao:         randao[:],
-		GasLimit:           h.GasLimit(),
-		BuilderIndex:       h.BuilderIndex(),
-		Slot:               h.Slot(),
-		Value:              h.Value(),
-		ExecutionPayment:   h.ExecutionPayment(),
-		BlobKzgCommitments: blobKzgCommitments,
-		FeeRecipient:       feeRecipient[:],
+		ParentBlockHash:        parentBlockHash[:],
+		ParentBlockRoot:        parentBlockRoot[:],
+		BlockHash:              blockHash[:],
+		PrevRandao:             randao[:],
+		GasLimit:               h.GasLimit(),
+		BuilderIndex:           h.BuilderIndex(),
+		Slot:                   h.Slot(),
+		Value:                  h.Value(),
+		ExecutionPayment:       h.ExecutionPayment(),
+		BlobKzgCommitmentsRoot: blobKzgCommitmentsRoot[:],
+		FeeRecipient:           feeRecipient[:],
 	}
 	b.markFieldAsDirty(types.LatestExecutionPayloadBid)
 

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

@@ -14,17 +14,17 @@ import (
 )
 
 type testExecutionPayloadBid struct {
-	parentBlockHash    [32]byte
-	parentBlockRoot    [32]byte
-	blockHash          [32]byte
-	prevRandao         [32]byte
-	blobKzgCommitments [][]byte
-	feeRecipient       [20]byte
-	gasLimit           uint64
-	builderIndex       primitives.BuilderIndex
-	slot               primitives.Slot
-	value              primitives.Gwei
-	executionPayment   primitives.Gwei
+	parentBlockHash        [32]byte
+	parentBlockRoot        [32]byte
+	blockHash              [32]byte
+	prevRandao             [32]byte
+	blobKzgCommitmentsRoot [32]byte
+	feeRecipient           [20]byte
+	gasLimit               uint64
+	builderIndex           primitives.BuilderIndex
+	slot                   primitives.Slot
+	value                  primitives.Gwei
+	executionPayment       primitives.Gwei
 }
 
 func (t testExecutionPayloadBid) ParentBlockHash() [32]byte { return t.parentBlockHash }
@@ -40,12 +40,9 @@ func (t testExecutionPayloadBid) Value() primitives.Gwei { return t.value }
 func (t testExecutionPayloadBid) ExecutionPayment() primitives.Gwei {
 	return t.executionPayment
 }
-func (t testExecutionPayloadBid) BlobKzgCommitments() [][]byte { return t.blobKzgCommitments }
-func (t testExecutionPayloadBid) BlobKzgCommitmentCount() uint64 {
-	return uint64(len(t.blobKzgCommitments))
-}
-func (t testExecutionPayloadBid) FeeRecipient() [20]byte { return t.feeRecipient }
-func (t testExecutionPayloadBid) IsNil() bool            { return false }
+func (t testExecutionPayloadBid) BlobKzgCommitmentsRoot() [32]byte { return t.blobKzgCommitmentsRoot }
+func (t testExecutionPayloadBid) FeeRecipient() [20]byte           { return t.feeRecipient }
+func (t testExecutionPayloadBid) IsNil() bool                      { return false }
 
 func TestSetExecutionPayloadBid(t *testing.T) {
 	t.Run("previous fork returns expected error", func(t *testing.T) {
@@ -60,7 +57,7 @@ func TestSetExecutionPayloadBid(t *testing.T) {
 			parentBlockRoot = [32]byte(bytes.Repeat([]byte{0xCD}, 32))
 			blockHash       = [32]byte(bytes.Repeat([]byte{0xEF}, 32))
 			prevRandao      = [32]byte(bytes.Repeat([]byte{0x11}, 32))
-			blobCommitments = [][]byte{bytes.Repeat([]byte{0x22}, 48)}
+			blobRoot        = [32]byte(bytes.Repeat([]byte{0x22}, 32))
 			feeRecipient    [20]byte
 		)
 		copy(feeRecipient[:], bytes.Repeat([]byte{0x33}, len(feeRecipient)))
@@ -69,17 +66,17 @@ func TestSetExecutionPayloadBid(t *testing.T) {
 			dirtyFields: make(map[types.FieldIndex]bool),
 		}
 		bid := testExecutionPayloadBid{
-			parentBlockHash:    parentBlockHash,
-			parentBlockRoot:    parentBlockRoot,
-			blockHash:          blockHash,
-			prevRandao:         prevRandao,
-			blobKzgCommitments: blobCommitments,
-			feeRecipient:       feeRecipient,
-			gasLimit:           123,
-			builderIndex:       7,
-			slot:               9,
-			value:              11,
-			executionPayment:   22,
+			parentBlockHash:        parentBlockHash,
+			parentBlockRoot:        parentBlockRoot,
+			blockHash:              blockHash,
+			prevRandao:             prevRandao,
+			blobKzgCommitmentsRoot: blobRoot,
+			feeRecipient:           feeRecipient,
+			gasLimit:               123,
+			builderIndex:           7,
+			slot:                   9,
+			value:                  11,
+			executionPayment:       22,
 		}
 
 		require.NoError(t, st.SetExecutionPayloadBid(bid))
@@ -89,7 +86,7 @@ func TestSetExecutionPayloadBid(t *testing.T) {
 		require.DeepEqual(t, parentBlockRoot[:], st.latestExecutionPayloadBid.ParentBlockRoot)
 		require.DeepEqual(t, blockHash[:], st.latestExecutionPayloadBid.BlockHash)
 		require.DeepEqual(t, prevRandao[:], st.latestExecutionPayloadBid.PrevRandao)
-		require.DeepEqual(t, blobCommitments, st.latestExecutionPayloadBid.BlobKzgCommitments)
+		require.DeepEqual(t, blobRoot[:], st.latestExecutionPayloadBid.BlobKzgCommitmentsRoot)
 		require.DeepEqual(t, feeRecipient[:], st.latestExecutionPayloadBid.FeeRecipient)
 		require.Equal(t, uint64(123), st.latestExecutionPayloadBid.GasLimit)
 		require.Equal(t, primitives.BuilderIndex(7), st.latestExecutionPayloadBid.BuilderIndex)

beacon-chain/state/stategen/getter.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
@@ -123,13 +122,8 @@ func (s *State) StateByRootInitialSync(ctx context.Context, blockRoot [32]byte)
 	}
 
 	if s.beaconDB.HasState(ctx, blockRoot) {
-		st, err := s.beaconDB.State(ctx, blockRoot)
-		if err == nil {
-			return st, nil
-		}
-		if !stderrors.Is(err, db.ErrNotFoundState) {
-			return nil, errors.Wrap(err, "failed to retrieve init-sync state from db")
-		}
+		s, err := s.beaconDB.State(ctx, blockRoot)
+		return s, errors.Wrap(err, "failed to retrieve init-sync state from db")
 	}
 
 	startState, err := s.latestAncestor(ctx, blockRoot)
@@ -219,13 +213,7 @@ func (s *State) loadStateByRoot(ctx context.Context, blockRoot [32]byte) (state.
 
 	// Short circuit if the state is already in the DB.
 	if s.beaconDB.HasState(ctx, blockRoot) {
-		st, err := s.beaconDB.State(ctx, blockRoot)
-		if err == nil {
-			return st, nil
-		}
-		if !stderrors.Is(err, db.ErrNotFoundState) {
-			return nil, err
-		}
+		return s.beaconDB.State(ctx, blockRoot)
 	}
 
 	summary, err := s.stateSummary(ctx, blockRoot)

beacon-chain/state/stategen/getter_test.go

@@ -185,71 +185,6 @@ type testSetupSlots struct {
 	lastblock primitives.Slot
 }
 
-type notFoundOnRootDB struct {
-	db.NoHeadAccessDatabase
-	target [32]byte
-}
-
-func (d *notFoundOnRootDB) HasState(ctx context.Context, blockRoot [32]byte) bool {
-	if blockRoot == d.target {
-		return true
-	}
-	return d.NoHeadAccessDatabase.HasState(ctx, blockRoot)
-}
-
-func (d *notFoundOnRootDB) State(ctx context.Context, blockRoot [32]byte) (state.BeaconState, error) {
-	if blockRoot == d.target {
-		return nil, db.ErrNotFoundState
-	}
-	return d.NoHeadAccessDatabase.State(ctx, blockRoot)
-}
-
-func TestStateByRoot_FallsBackToReplayOnNotFoundStateFromDirectRead(t *testing.T) {
-	ctx := t.Context()
-	beaconDB := testDB.SetupDB(t)
-
-	st9, _ := util.DeterministicGenesisState(t, 32)
-	st9, err := ReplayProcessSlots(ctx, st9, 9)
-	require.NoError(t, err)
-
-	hdr := st9.LatestBlockHeader()
-	hdrRoot, err := hdr.HashTreeRoot()
-	require.NoError(t, err)
-
-	st10 := st9.Copy()
-	blk10 := util.NewBeaconBlock()
-	blk10.Block.Slot = 10
-	blk10.Block.ParentRoot = hdrRoot[:]
-	idx10, err := helpers.BeaconProposerIndexAtSlot(ctx, st10, blk10.Block.Slot)
-	require.NoError(t, err)
-	blk10.Block.ProposerIndex = idx10
-	ib10, err := blt.NewSignedBeaconBlock(blk10)
-	require.NoError(t, err)
-
-	st10, err = executeStateTransitionStateGen(ctx, st10, ib10)
-	require.NoError(t, err)
-	st10Root, err := st10.HashTreeRoot(ctx)
-	require.NoError(t, err)
-	blk10.Block.StateRoot = st10Root[:]
-
-	util.SaveBlock(t, ctx, beaconDB, blk10)
-	require.NoError(t, beaconDB.SaveState(ctx, st9, hdrRoot))
-
-	ib10, err = blt.NewSignedBeaconBlock(blk10)
-	require.NoError(t, err)
-	rob10, err := blt.NewROBlock(ib10)
-	require.NoError(t, err)
-
-	service := New(&notFoundOnRootDB{NoHeadAccessDatabase: beaconDB, target: rob10.Root()}, doublylinkedtree.New())
-
-	got, err := service.StateByRoot(ctx, rob10.Root())
-	require.NoError(t, err)
-
-	gotRoot, err := got.HashTreeRoot(ctx)
-	require.NoError(t, err)
-	require.Equal(t, st10Root, gotRoot)
-}
-
 func TestLoadStateByRoot(t *testing.T) {
 	ctx := t.Context()
 	persistEpochBoundary := func(r testChain, slot primitives.Slot) {

beacon-chain/sync/BUILD.bazel

@@ -47,7 +47,6 @@ go_library(
         "subscriber_bls_to_execution_change.go",
         "subscriber_data_column_sidecar.go",
         "subscriber_handlers.go",
-        "subscriber_payload_attestation.go",
         "subscriber_sync_committee_message.go",
         "subscriber_sync_contribution_proof.go",
         "subscription_topic_handler.go",
@@ -59,7 +58,6 @@ go_library(
         "validate_bls_to_execution_change.go",
         "validate_data_column.go",
         "validate_light_client.go",
-        "validate_payload_attestation.go",
         "validate_proposer_slashing.go",
         "validate_sync_committee_message.go",
         "validate_sync_contribution_proof.go",
@@ -116,7 +114,6 @@ go_library(
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
-        "//consensus-types/payload-attestation:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/wrapper:go_default_library",
         "//container/leaky-bucket:go_default_library",
@@ -215,7 +212,6 @@ go_test(
         "validate_bls_to_execution_change_test.go",
         "validate_data_column_test.go",
         "validate_light_client_test.go",
-        "validate_payload_attestation_test.go",
         "validate_proposer_slashing_test.go",
         "validate_sync_committee_message_test.go",
         "validate_sync_contribution_proof_test.go",
@@ -268,7 +264,6 @@ go_test(
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
-        "//consensus-types/payload-attestation:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/wrapper:go_default_library",
         "//container/leaky-bucket:go_default_library",

beacon-chain/sync/options.go

@@ -207,13 +207,6 @@ func WithTrackedValidatorsCache(c *cache.TrackedValidatorsCache) Option {
 	}
 }
 
-func WithPayloadAttestationCache(c *cache.PayloadAttestationCache) Option {
-	return func(s *Service) error {
-		s.payloadAttestationCache = c
-		return nil
-	}
-}
-
 // WithSlasherEnabled configures the sync package to support slashing detection.
 func WithSlasherEnabled(enabled bool) Option {
 	return func(s *Service) error {

beacon-chain/sync/service.go

@@ -38,7 +38,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	payloadattestation "github.com/OffchainLabs/prysm/v7/consensus-types/payload-attestation"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	leakybucket "github.com/OffchainLabs/prysm/v7/container/leaky-bucket"
 	"github.com/OffchainLabs/prysm/v7/crypto/rand"
@@ -122,7 +121,6 @@ type blockchainService interface {
 	blockchain.FinalizationFetcher
 	blockchain.ForkFetcher
 	blockchain.AttestationReceiver
-	blockchain.PayloadAttestationReceiver
 	blockchain.TimeFetcher
 	blockchain.GenesisFetcher
 	blockchain.CanonicalFetcher
@@ -175,7 +173,6 @@ type Service struct {
 	verifierWaiter                   *verification.InitializerWaiter
 	newBlobVerifier                  verification.NewBlobVerifier
 	newColumnsVerifier               verification.NewDataColumnsVerifier
-	newPayloadAttestationVerifier    verification.NewPayloadAttestationMsgVerifier
 	columnSidecarsExecSingleFlight   singleflight.Group
 	reconstructionSingleFlight       singleflight.Group
 	availableBlocker                 coverage.AvailableBlocker
@@ -185,7 +182,6 @@ type Service struct {
 	slasherEnabled                   bool
 	lcStore                          *lightClient.Store
 	dataColumnLogCh                  chan dataColumnLogEntry
-	payloadAttestationCache          *cache.PayloadAttestationCache
 	digestActions                    perDigestSet
 	subscriptionSpawner              func(func()) // see Service.spawn for details
 }
@@ -194,16 +190,15 @@ type Service struct {
 func NewService(ctx context.Context, opts ...Option) *Service {
 	ctx, cancel := context.WithCancel(ctx)
 	r := &Service{
-		ctx:                     ctx,
-		cancel:                  cancel,
-		chainStarted:            abool.New(),
-		cfg:                     &config{clock: startup.NewClock(time.Unix(0, 0), [32]byte{})},
-		slotToPendingBlocks:     gcache.New(pendingBlockExpTime /* exp time */, 0 /* disable janitor */),
-		seenPendingBlocks:       make(map[[32]byte]bool),
-		blkRootToPendingAtts:    make(map[[32]byte][]any),
-		dataColumnLogCh:         make(chan dataColumnLogEntry, 1000),
-		reconstructionRandGen:   rand.NewGenerator(),
-		payloadAttestationCache: &cache.PayloadAttestationCache{},
+		ctx:                   ctx,
+		cancel:                cancel,
+		chainStarted:          abool.New(),
+		cfg:                   &config{clock: startup.NewClock(time.Unix(0, 0), [32]byte{})},
+		slotToPendingBlocks:   gcache.New(pendingBlockExpTime /* exp time */, 0 /* disable janitor */),
+		seenPendingBlocks:     make(map[[32]byte]bool),
+		blkRootToPendingAtts:  make(map[[32]byte][]any),
+		dataColumnLogCh:       make(chan dataColumnLogEntry, 1000),
+		reconstructionRandGen: rand.NewGenerator(),
 	}
 
 	for _, opt := range opts {
@@ -255,12 +250,6 @@ func newDataColumnsVerifierFromInitializer(ini *verification.Initializer) verifi
 	}
 }
 
-func newPayloadAttestationMessageFromInitializer(ini *verification.Initializer) verification.NewPayloadAttestationMsgVerifier {
-	return func(pa payloadattestation.ROMessage, reqs []verification.Requirement) verification.PayloadAttestationMsgVerifier {
-		return ini.NewPayloadAttestationMsgVerifier(pa, reqs)
-	}
-}
-
 // Start the regular sync service.
 func (s *Service) Start() {
 	v, err := s.verifierWaiter.WaitForInitializer(s.ctx)
@@ -270,7 +259,6 @@ func (s *Service) Start() {
 	}
 	s.newBlobVerifier = newBlobVerifierFromInitializer(v)
 	s.newColumnsVerifier = newDataColumnsVerifierFromInitializer(v)
-	s.newPayloadAttestationVerifier = newPayloadAttestationMessageFromInitializer(v)
 
 	go s.verifierRoutine()
 	go s.startDiscoveryAndSubscriptions()

beacon-chain/sync/subscriber.go

@@ -330,18 +330,6 @@ func (s *Service) registerSubscribers(nse params.NetworkScheduleEntry) bool {
 			})
 		})
 	}
-
-	// New gossip topic in Gloas.
-	if params.BeaconConfig().GloasForkEpoch <= nse.Epoch {
-		s.spawn(func() {
-			s.subscribe(
-				p2p.PayloadAttestationMessageTopicFormat,
-				s.validatePayloadAttestation,
-				s.payloadAttestationSubscriber,
-				nse,
-			)
-		})
-	}
 	return true
 }
 

beacon-chain/sync/subscriber_payload_attestation.go

@@ -1,21 +0,0 @@
-package sync
-
-import (
-	"context"
-
-	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"google.golang.org/protobuf/proto"
-)
-
-func (s *Service) payloadAttestationSubscriber(ctx context.Context, msg proto.Message) error {
-	a, ok := msg.(*eth.PayloadAttestationMessage)
-	if !ok {
-		return errWrongMessage
-	}
-
-	if err := s.payloadAttestationCache.Add(a.Data.Slot, a.ValidatorIndex); err != nil {
-		return err
-	}
-
-	return s.cfg.chain.ReceivePayloadAttestationMessage(ctx, a)
-}

beacon-chain/sync/validate_payload_attestation.go

@@ -1,131 +0,0 @@
-package sync
-
-import (
-	"bytes"
-	"context"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/transition"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/verification"
-	payloadattestation "github.com/OffchainLabs/prysm/v7/consensus-types/payload-attestation"
-	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
-	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-	pubsub "github.com/libp2p/go-libp2p-pubsub"
-	"github.com/libp2p/go-libp2p/core/peer"
-	"github.com/pkg/errors"
-)
-
-var (
-	errAlreadySeenPayloadAttestation = errors.New("payload attestation already seen for validator index")
-)
-
-func (s *Service) validatePayloadAttestation(ctx context.Context, pid peer.ID, msg *pubsub.Message) (pubsub.ValidationResult, error) {
-	if pid == s.cfg.p2p.PeerID() {
-		return pubsub.ValidationAccept, nil
-	}
-	if s.cfg.initialSync.Syncing() {
-		return pubsub.ValidationIgnore, nil
-	}
-	ctx, span := trace.StartSpan(ctx, "sync.validatePayloadAttestation")
-	defer span.End()
-
-	if msg.Topic == nil {
-		return pubsub.ValidationReject, p2p.ErrInvalidTopic
-	}
-	m, err := s.decodePubsubMessage(msg)
-	if err != nil {
-		return pubsub.ValidationReject, err
-	}
-	att, ok := m.(*eth.PayloadAttestationMessage)
-	if !ok {
-		return pubsub.ValidationReject, errWrongMessage
-	}
-	pa, err := payloadattestation.NewReadOnly(att)
-	if err != nil {
-		return pubsub.ValidationIgnore, err
-	}
-	v := s.newPayloadAttestationVerifier(pa, verification.GossipPayloadAttestationMessageRequirements)
-
-	// [IGNORE] The message's slot is for the current slot (with a MAXIMUM_GOSSIP_CLOCK_DISPARITY allowance),
-	// i.e. data.slot == current_slot.
-	if err := v.VerifyCurrentSlot(); err != nil {
-		return pubsub.ValidationIgnore, err
-	}
-
-	// [IGNORE] The payload_attestation_message is the first valid message received from the validator with
-	// index payload_attestation_message.validator_index.
-	if s.payloadAttestationCache.Seen(pa.Slot(), pa.ValidatorIndex()) {
-		return pubsub.ValidationIgnore, errAlreadySeenPayloadAttestation
-	}
-
-	// [IGNORE] The message's block data.beacon_block_root has been seen (via gossip or non-gossip sources)
-	// (a client MAY queue attestation for processing once the block is retrieved. Note a client might want to request payload after).
-	if err := v.VerifyBlockRootSeen(s.cfg.chain.InForkchoice); err != nil {
-		// TODO: queue attestation
-		return pubsub.ValidationIgnore, err
-	}
-
-	// [REJECT] The message's block data.beacon_block_root passes validation.
-	if err := v.VerifyBlockRootValid(s.hasBadBlock); err != nil {
-		return pubsub.ValidationReject, err
-	}
-
-	st, err := s.getPtcState(ctx, pa)
-	if err != nil {
-		return pubsub.ValidationIgnore, err
-	}
-
-	// [REJECT] The message's validator index is within the payload committee in get_ptc(state, data.slot).
-	// The state is the head state corresponding to processing the block up to the current slot.
-	if err := v.VerifyValidatorInPTC(ctx, st); err != nil {
-		return pubsub.ValidationReject, err
-	}
-
-	// [REJECT] payload_attestation_message.signature is valid with respect to the validator's public key.
-	if err := v.VerifySignature(st); err != nil {
-		return pubsub.ValidationReject, err
-	}
-
-	msg.ValidatorData = att
-
-	return pubsub.ValidationAccept, nil
-}
-
-func (s *Service) getPtcState(ctx context.Context, pa payloadattestation.ROMessage) (state.ReadOnlyBeaconState, error) {
-	blockRoot := pa.BeaconBlockRoot()
-	blockSlot := pa.Slot()
-	blockEpoch := slots.ToEpoch(blockSlot)
-	headSlot := s.cfg.chain.HeadSlot()
-	headEpoch := slots.ToEpoch(headSlot)
-	headRoot, err := s.cfg.chain.HeadRoot(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	if blockEpoch == headEpoch {
-		if bytes.Equal(blockRoot[:], headRoot) {
-			return s.cfg.chain.HeadStateReadOnly(ctx)
-		}
-
-		headDependent, err := s.cfg.chain.DependentRootForEpoch(bytesutil.ToBytes32(headRoot), blockEpoch)
-		if err != nil {
-			return nil, err
-		}
-		blockDependent, err := s.cfg.chain.DependentRootForEpoch(blockRoot, blockEpoch)
-		if err != nil {
-			return nil, err
-		}
-		if bytes.Equal(headDependent[:], blockDependent[:]) {
-			return s.cfg.chain.HeadStateReadOnly(ctx)
-		}
-	}
-
-	headState, err := s.cfg.chain.HeadState(ctx)
-	if err != nil {
-		return nil, err
-	}
-	return transition.ProcessSlotsUsingNextSlotCache(ctx, headState, headRoot, blockSlot)
-}

beacon-chain/sync/validate_payload_attestation_test.go

@@ -1,165 +0,0 @@
-package sync
-
-import (
-	"bytes"
-	"context"
-	"reflect"
-	"testing"
-	"time"
-
-	mock "github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/testing"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/cache"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p"
-	p2ptest "github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/testing"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/startup"
-	mockSync "github.com/OffchainLabs/prysm/v7/beacon-chain/sync/initial-sync/testing"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/verification"
-	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	payloadattestation "github.com/OffchainLabs/prysm/v7/consensus-types/payload-attestation"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/OffchainLabs/prysm/v7/testing/util"
-	pubsub "github.com/libp2p/go-libp2p-pubsub"
-	pb "github.com/libp2p/go-libp2p-pubsub/pb"
-	"github.com/pkg/errors"
-)
-
-func TestValidatePayloadAttestationMessage_IncorrectTopic(t *testing.T) {
-	ctx := context.Background()
-	p := p2ptest.NewTestP2P(t)
-	chainService := &mock.ChainService{Genesis: time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot), 0)}
-	s := &Service{
-		payloadAttestationCache: &cache.PayloadAttestationCache{},
-		cfg:                     &config{chain: chainService, p2p: p, initialSync: &mockSync.Sync{}, clock: startup.NewClock(chainService.Genesis, chainService.ValidatorsRoot)}}
-
-	msg := util.HydratePayloadAttestation(&ethpb.PayloadAttestation{}) // Using payload attestation for message should fail.
-	buf := new(bytes.Buffer)
-	_, err := p.Encoding().EncodeGossip(buf, msg)
-	require.NoError(t, err)
-
-	topic := p2p.GossipTypeMapping[reflect.TypeFor[*ethpb.PayloadAttestation]()]
-	digest, err := s.currentForkDigest()
-	require.NoError(t, err)
-	topic = s.addDigestToTopic(topic, digest)
-
-	result, err := s.validatePayloadAttestation(ctx, "", &pubsub.Message{
-		Message: &pb.Message{
-			Data:  buf.Bytes(),
-			Topic: &topic,
-		}})
-	require.ErrorContains(t, "extraction failed for topic", err)
-	require.Equal(t, result, pubsub.ValidationReject)
-}
-
-func TestValidatePayloadAttestationMessage_ErrorPathsWithMock(t *testing.T) {
-	tests := []struct {
-		error    error
-		verifier verification.NewPayloadAttestationMsgVerifier
-		result   pubsub.ValidationResult
-	}{
-		{
-			error: errors.New("incorrect slot"),
-			verifier: func(pa payloadattestation.ROMessage, reqs []verification.Requirement) verification.PayloadAttestationMsgVerifier {
-				return &verification.MockPayloadAttestation{ErrIncorrectPayloadAttSlot: errors.New("incorrect slot")}
-			},
-			result: pubsub.ValidationIgnore,
-		},
-		{
-			error: errors.New("block root seen"),
-			verifier: func(pa payloadattestation.ROMessage, reqs []verification.Requirement) verification.PayloadAttestationMsgVerifier {
-				return &verification.MockPayloadAttestation{ErrPayloadAttBlockRootNotSeen: errors.New("block root seen")}
-			},
-			result: pubsub.ValidationIgnore,
-		},
-		{
-			error: errors.New("block root invalid"),
-			verifier: func(pa payloadattestation.ROMessage, reqs []verification.Requirement) verification.PayloadAttestationMsgVerifier {
-				return &verification.MockPayloadAttestation{ErrPayloadAttBlockRootInvalid: errors.New("block root invalid")}
-			},
-			result: pubsub.ValidationReject,
-		},
-		{
-			error: errors.New("validator not in PTC"),
-			verifier: func(pa payloadattestation.ROMessage, reqs []verification.Requirement) verification.PayloadAttestationMsgVerifier {
-				return &verification.MockPayloadAttestation{ErrIncorrectPayloadAttValidator: errors.New("validator not in PTC")}
-			},
-			result: pubsub.ValidationReject,
-		},
-		{
-			error: errors.New("incorrect signature"),
-			verifier: func(pa payloadattestation.ROMessage, reqs []verification.Requirement) verification.PayloadAttestationMsgVerifier {
-				return &verification.MockPayloadAttestation{ErrInvalidMessageSignature: errors.New("incorrect signature")}
-			},
-			result: pubsub.ValidationReject,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.error.Error(), func(t *testing.T) {
-			ctx := context.Background()
-			p := p2ptest.NewTestP2P(t)
-			chainService := &mock.ChainService{Genesis: time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot), 0)}
-			s := &Service{
-				payloadAttestationCache: &cache.PayloadAttestationCache{},
-				cfg:                     &config{chain: chainService, p2p: p, initialSync: &mockSync.Sync{}, clock: startup.NewClock(chainService.Genesis, chainService.ValidatorsRoot)}}
-			s.newPayloadAttestationVerifier = tt.verifier
-
-			msg := newPayloadAttestationMessage()
-			buf := new(bytes.Buffer)
-			_, err := p.Encoding().EncodeGossip(buf, msg)
-			require.NoError(t, err)
-
-			topic := p2p.GossipTypeMapping[reflect.TypeFor[*ethpb.PayloadAttestationMessage]()]
-			digest, err := s.currentForkDigest()
-			require.NoError(t, err)
-			topic = s.addDigestToTopic(topic, digest)
-
-			result, err := s.validatePayloadAttestation(ctx, "", &pubsub.Message{
-				Message: &pb.Message{
-					Data:  buf.Bytes(),
-					Topic: &topic,
-				}})
-
-			require.ErrorContains(t, tt.error.Error(), err)
-			require.Equal(t, result, tt.result)
-		})
-	}
-}
-
-func TestValidatePayloadAttestationMessage_Accept(t *testing.T) {
-	ctx := context.Background()
-	p := p2ptest.NewTestP2P(t)
-	chainService := &mock.ChainService{Genesis: time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot), 0)}
-	s := &Service{
-		payloadAttestationCache: &cache.PayloadAttestationCache{},
-		cfg:                     &config{chain: chainService, p2p: p, initialSync: &mockSync.Sync{}, clock: startup.NewClock(chainService.Genesis, chainService.ValidatorsRoot)}}
-	s.newPayloadAttestationVerifier = func(pa payloadattestation.ROMessage, reqs []verification.Requirement) verification.PayloadAttestationMsgVerifier {
-		return &verification.MockPayloadAttestation{}
-	}
-
-	msg := newPayloadAttestationMessage()
-	buf := new(bytes.Buffer)
-	_, err := p.Encoding().EncodeGossip(buf, msg)
-	require.NoError(t, err)
-
-	topic := p2p.GossipTypeMapping[reflect.TypeFor[*ethpb.PayloadAttestationMessage]()]
-	digest, err := s.currentForkDigest()
-	require.NoError(t, err)
-	topic = s.addDigestToTopic(topic, digest)
-
-	result, err := s.validatePayloadAttestation(ctx, "", &pubsub.Message{
-		Message: &pb.Message{
-			Data:  buf.Bytes(),
-			Topic: &topic,
-		}})
-	require.NoError(t, err)
-	require.Equal(t, result, pubsub.ValidationAccept)
-}
-
-func newPayloadAttestationMessage() *ethpb.PayloadAttestationMessage {
-	return &ethpb.PayloadAttestationMessage{
-		ValidatorIndex: 0,
-		Data:           util.HydratePayloadAttestationData(&ethpb.PayloadAttestationData{Slot: 1}),
-		Signature:      make([]byte, fieldparams.BLSSignatureLength),
-	}
-}

beacon-chain/verification/BUILD.bazel

@@ -15,16 +15,12 @@ go_library(
         "log.go",
         "metrics.go",
         "mock.go",
-        "payload_attestation.go",
-        "payload_attestation_mock.go",
-        "requirements.go",
         "result.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/verification",
     visibility = ["//visibility:public"],
     deps = [
         "//beacon-chain/blockchain/kzg:go_default_library",
-        "//beacon-chain/core/gloas:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
@@ -36,7 +32,6 @@ go_library(
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
-        "//consensus-types/payload-attestation:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
@@ -62,14 +57,12 @@ go_test(
         "data_column_test.go",
         "filesystem_test.go",
         "initializer_test.go",
-        "payload_attestation_test.go",
         "result_test.go",
         "verification_test.go",
     ],
     embed = [":go_default_library"],
     deps = [
         "//beacon-chain/blockchain/kzg:go_default_library",
-        "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/db:go_default_library",
@@ -80,10 +73,8 @@ go_test(
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
-        "//consensus-types/payload-attestation:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//crypto/bls:go_default_library",
-        "//crypto/bls/common:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/interop:go_default_library",

beacon-chain/verification/blob.go

@@ -14,6 +14,24 @@ import (
 	"github.com/pkg/errors"
 )
 
+const (
+	RequireBlobIndexInBounds Requirement = iota
+	RequireNotFromFutureSlot
+	RequireSlotAboveFinalized
+	RequireValidProposerSignature
+	RequireSidecarParentSeen
+	RequireSidecarParentValid
+	RequireSidecarParentSlotLower
+	RequireSidecarDescendsFromFinalized
+	RequireSidecarInclusionProven
+	RequireSidecarKzgProofVerified
+	RequireSidecarProposerExpected
+
+	// Data columns specific.
+	RequireValidFields
+	RequireCorrectSubnet
+)
+
 var allBlobSidecarRequirements = []Requirement{
 	RequireBlobIndexInBounds,
 	RequireNotFromFutureSlot,

beacon-chain/verification/initializer.go

@@ -12,7 +12,6 @@ import (
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	payloadattestation "github.com/OffchainLabs/prysm/v7/consensus-types/payload-attestation"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"golang.org/x/sync/singleflight"
@@ -87,16 +86,6 @@ func (ini *Initializer) NewDataColumnsVerifier(roDataColumns []blocks.RODataColu
 	}
 }
 
-// NewPayloadAttestationMsgVerifier creates a PayloadAttestationMsgVerifier for a single payload attestation message,
-// with the given set of requirements.
-func (ini *Initializer) NewPayloadAttestationMsgVerifier(pa payloadattestation.ROMessage, reqs []Requirement) *PayloadAttMsgVerifier {
-	return &PayloadAttMsgVerifier{
-		sharedResources: ini.shared,
-		results:         newResults(reqs...),
-		pa:              pa,
-	}
-}
-
 // InitializerWaiter provides an Initializer once all dependent resources are ready
 // via the WaitForInitializer method.
 type InitializerWaiter struct {

beacon-chain/verification/interface.go

@@ -3,10 +3,8 @@ package verification
 import (
 	"context"
 
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	payloadattestation "github.com/OffchainLabs/prysm/v7/consensus-types/payload-attestation"
 )
 
 // BlobVerifier defines the methods implemented by the ROBlobVerifier.
@@ -56,18 +54,3 @@ type DataColumnsVerifier interface {
 // NewDataColumnsVerifier is a function signature that can be used to mock a setup where a
 // column verifier can be easily initialized.
 type NewDataColumnsVerifier func(dataColumns []blocks.RODataColumn, reqs []Requirement) DataColumnsVerifier
-
-// PayloadAttestationMsgVerifier defines the methods implemented by the ROPayloadAttestation.
-type PayloadAttestationMsgVerifier interface {
-	VerifyCurrentSlot() error
-	VerifyBlockRootSeen(blockRootSeen func([32]byte) bool) error
-	VerifyBlockRootValid(func([32]byte) bool) error
-	VerifyValidatorInPTC(context.Context, state.ReadOnlyBeaconState) error
-	VerifySignature(state.ReadOnlyBeaconState) error
-	VerifiedPayloadAttestation() (payloadattestation.VerifiedROMessage, error)
-	SatisfyRequirement(Requirement)
-}
-
-// NewPayloadAttestationMsgVerifier is a function signature that can be used by code that needs to be
-// able to mock Initializer.NewPayloadAttestationMsgVerifier without complex setup.
-type NewPayloadAttestationMsgVerifier func(pa payloadattestation.ROMessage, reqs []Requirement) PayloadAttestationMsgVerifier

beacon-chain/verification/payload_attestation.go

@@ -1,177 +0,0 @@
-package verification
-
-import (
-	"context"
-	"fmt"
-	"slices"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	payloadattestation "github.com/OffchainLabs/prysm/v7/consensus-types/payload-attestation"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-	"github.com/pkg/errors"
-)
-
-// RequirementList defines a list of requirements.
-type RequirementList []Requirement
-
-// PayloadAttGossipRequirements defines the list of requirements for gossip payload attestation messages.
-var PayloadAttGossipRequirements = []Requirement{
-	RequireCurrentSlot,
-	RequireMessageNotSeen,
-	RequireValidatorInPTC,
-	RequireBlockRootSeen,
-	RequireBlockRootValid,
-	RequireSignatureValid,
-}
-
-// GossipPayloadAttestationMessageRequirements is a requirement list for gossip payload attestation messages.
-var GossipPayloadAttestationMessageRequirements = RequirementList(PayloadAttGossipRequirements)
-
-var (
-	ErrIncorrectPayloadAttSlot      = errors.New("payload att slot does not match the current slot")
-	ErrPayloadAttBlockRootNotSeen   = errors.New("block root not seen")
-	ErrPayloadAttBlockRootInvalid   = errors.New("block root invalid")
-	ErrIncorrectPayloadAttValidator = errors.New("validator not present in payload timeliness committee")
-	ErrInvalidPayloadAttMessage     = errors.New("invalid payload attestation message")
-)
-
-var _ PayloadAttestationMsgVerifier = &PayloadAttMsgVerifier{}
-
-// PayloadAttMsgVerifier is a read-only verifier for payload attestation messages.
-type PayloadAttMsgVerifier struct {
-	*sharedResources
-	results *results
-	pa      payloadattestation.ROMessage
-}
-
-// VerifyCurrentSlot verifies if the current slot matches the expected slot.
-// Represents the following spec verification:
-// [IGNORE] data.slot is the current slot.
-func (v *PayloadAttMsgVerifier) VerifyCurrentSlot() (err error) {
-	defer v.record(RequireCurrentSlot, &err)
-
-	currentSlot := v.clock.CurrentSlot()
-	if v.pa.Slot() != currentSlot {
-		return fmt.Errorf("%w: got %d want %d", ErrIncorrectPayloadAttSlot, v.pa.Slot(), currentSlot)
-	}
-
-	return nil
-}
-
-// VerifyBlockRootSeen verifies if the block root has been seen before.
-// Represents the following spec verification:
-// [IGNORE] The attestation's data.beacon_block_root has been seen (via both gossip and non-gossip sources).
-func (v *PayloadAttMsgVerifier) VerifyBlockRootSeen(blockRootSeen func([32]byte) bool) (err error) {
-	defer v.record(RequireBlockRootSeen, &err)
-	if blockRootSeen != nil && blockRootSeen(v.pa.BeaconBlockRoot()) {
-		return nil
-	}
-	return fmt.Errorf("%w: root=%#x", ErrPayloadAttBlockRootNotSeen, v.pa.BeaconBlockRoot())
-}
-
-// VerifyBlockRootValid verifies if the block root is valid.
-// Represents the following spec verification:
-// [REJECT] The beacon block with root data.beacon_block_root passes validation.
-func (v *PayloadAttMsgVerifier) VerifyBlockRootValid(badBlock func([32]byte) bool) (err error) {
-	defer v.record(RequireBlockRootValid, &err)
-
-	if badBlock != nil && badBlock(v.pa.BeaconBlockRoot()) {
-		return fmt.Errorf("%w: root=%#x", ErrPayloadAttBlockRootInvalid, v.pa.BeaconBlockRoot())
-	}
-
-	return nil
-}
-
-// VerifyValidatorInPTC verifies if the validator is present.
-// Represents the following spec verification:
-// [REJECT] The validator index is within the payload committee in get_ptc(state, data.slot). For the current's slot head state.
-func (v *PayloadAttMsgVerifier) VerifyValidatorInPTC(ctx context.Context, st state.ReadOnlyBeaconState) (err error) {
-	defer v.record(RequireValidatorInPTC, &err)
-
-	ptc, err := gloas.PayloadCommittee(ctx, st, v.pa.Slot())
-	if err != nil {
-		return err
-	}
-
-	if slices.Index(ptc, v.pa.ValidatorIndex()) == -1 {
-		return fmt.Errorf("%w: validatorIndex=%d", ErrIncorrectPayloadAttValidator, v.pa.ValidatorIndex())
-	}
-
-	return nil
-}
-
-// VerifySignature verifies the signature of the payload attestation message.
-// Represents the following spec verification:
-// [REJECT] The signature of payload_attestation_message.signature is valid with respect to the validator index.
-func (v *PayloadAttMsgVerifier) VerifySignature(st state.ReadOnlyBeaconState) (err error) {
-	defer v.record(RequireSignatureValid, &err)
-
-	err = validatePayloadAttestationMessageSignature(st, v.pa)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// VerifiedPayloadAttestation returns a verified payload attestation message by checking all requirements.
-func (v *PayloadAttMsgVerifier) VerifiedPayloadAttestation() (payloadattestation.VerifiedROMessage, error) {
-	if v.results.allSatisfied() {
-		return payloadattestation.NewVerifiedROMessage(v.pa), nil
-	}
-	return payloadattestation.VerifiedROMessage{}, ErrInvalidPayloadAttMessage
-}
-
-// SatisfyRequirement allows the caller to manually mark a requirement as satisfied.
-func (v *PayloadAttMsgVerifier) SatisfyRequirement(req Requirement) {
-	v.record(req, nil)
-}
-
-// ValidatePayloadAttestationMessageSignature verifies the signature of a payload attestation message.
-func validatePayloadAttestationMessageSignature(st state.ReadOnlyBeaconState, payloadAtt payloadattestation.ROMessage) error {
-	val, err := st.ValidatorAtIndex(payloadAtt.ValidatorIndex())
-	if err != nil {
-		return fmt.Errorf("validator %d: %w", payloadAtt.ValidatorIndex(), err)
-	}
-
-	pub, err := bls.PublicKeyFromBytes(val.PublicKey)
-	if err != nil {
-		return fmt.Errorf("public key: %w", err)
-	}
-
-	s := payloadAtt.Signature()
-	sig, err := bls.SignatureFromBytes(s[:])
-	if err != nil {
-		return fmt.Errorf("signature bytes: %w", err)
-	}
-
-	currentEpoch := slots.ToEpoch(st.Slot())
-	domain, err := signing.Domain(st.Fork(), currentEpoch, params.BeaconConfig().DomainPTCAttester, st.GenesisValidatorsRoot())
-	if err != nil {
-		return fmt.Errorf("domain: %w", err)
-	}
-
-	root, err := payloadAtt.SigningRoot(domain)
-	if err != nil {
-		return fmt.Errorf("signing root: %w", err)
-	}
-
-	if !sig.Verify(pub, root[:]) {
-		return fmt.Errorf("verify signature: %w", signing.ErrSigFailedToVerify)
-	}
-	return nil
-}
-
-// record records the result of a requirement verification.
-func (v *PayloadAttMsgVerifier) record(req Requirement, err *error) {
-	if err == nil || *err == nil {
-		v.results.record(req, nil)
-		return
-	}
-
-	v.results.record(req, *err)
-}

beacon-chain/verification/payload_attestation_mock.go

@@ -1,46 +0,0 @@
-package verification
-
-import (
-	"context"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	payloadattestation "github.com/OffchainLabs/prysm/v7/consensus-types/payload-attestation"
-)
-
-type MockPayloadAttestation struct {
-	ErrIncorrectPayloadAttSlot      error
-	ErrIncorrectPayloadAttValidator error
-	ErrPayloadAttBlockRootNotSeen   error
-	ErrPayloadAttBlockRootInvalid   error
-	ErrInvalidPayloadAttMessage     error
-	ErrInvalidMessageSignature      error
-	ErrUnsatisfiedRequirement       error
-}
-
-var _ PayloadAttestationMsgVerifier = &MockPayloadAttestation{}
-
-func (m *MockPayloadAttestation) VerifyCurrentSlot() error {
-	return m.ErrIncorrectPayloadAttSlot
-}
-
-func (m *MockPayloadAttestation) VerifyValidatorInPTC(ctx context.Context, st state.ReadOnlyBeaconState) error {
-	return m.ErrIncorrectPayloadAttValidator
-}
-
-func (m *MockPayloadAttestation) VerifyBlockRootSeen(_ func([32]byte) bool) error {
-	return m.ErrPayloadAttBlockRootNotSeen
-}
-
-func (m *MockPayloadAttestation) VerifyBlockRootValid(func([32]byte) bool) error {
-	return m.ErrPayloadAttBlockRootInvalid
-}
-
-func (m *MockPayloadAttestation) VerifySignature(st state.ReadOnlyBeaconState) (err error) {
-	return m.ErrInvalidMessageSignature
-}
-
-func (m *MockPayloadAttestation) VerifiedPayloadAttestation() (payloadattestation.VerifiedROMessage, error) {
-	return payloadattestation.VerifiedROMessage{}, nil
-}
-
-func (m *MockPayloadAttestation) SatisfyRequirement(req Requirement) {}

beacon-chain/verification/payload_attestation_test.go

@@ -1,167 +0,0 @@
-package verification
-
-import (
-	"bytes"
-	"context"
-	"testing"
-	"time"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/startup"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	payloadattestation "github.com/OffchainLabs/prysm/v7/consensus-types/payload-attestation"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls/common"
-	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	testutil "github.com/OffchainLabs/prysm/v7/testing/util"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-)
-
-func TestPayloadAttestationVerifyCurrentSlot(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	now := time.Unix(1000, 0)
-	genesis := now.Add(-time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second)
-	clock := startup.NewClock(genesis, [32]byte{}, startup.WithNower(func() time.Time { return now }))
-	ini := &Initializer{shared: &sharedResources{clock: clock}}
-
-	msg := newPayloadAttestationMessage(primitives.Slot(1), 0, bytes.Repeat([]byte{0x11}, 32))
-	pa, err := payloadattestation.NewReadOnly(msg)
-	require.NoError(t, err)
-	v := ini.NewPayloadAttestationMsgVerifier(pa, GossipPayloadAttestationMessageRequirements)
-	require.NoError(t, v.VerifyCurrentSlot())
-
-	msg = newPayloadAttestationMessage(primitives.Slot(2), 0, bytes.Repeat([]byte{0x11}, 32))
-	pa, err = payloadattestation.NewReadOnly(msg)
-	require.NoError(t, err)
-	v = ini.NewPayloadAttestationMsgVerifier(pa, GossipPayloadAttestationMessageRequirements)
-	require.ErrorIs(t, v.VerifyCurrentSlot(), ErrIncorrectPayloadAttSlot)
-}
-
-func TestPayloadAttestationVerifyBlockRootSeenAndValid(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	ini := &Initializer{shared: &sharedResources{}}
-	root := bytes.Repeat([]byte{0x22}, 32)
-	var root32 [32]byte
-	copy(root32[:], root)
-
-	msg := newPayloadAttestationMessage(primitives.Slot(1), 0, root)
-	pa, err := payloadattestation.NewReadOnly(msg)
-	require.NoError(t, err)
-	v := ini.NewPayloadAttestationMsgVerifier(pa, GossipPayloadAttestationMessageRequirements)
-
-	require.NoError(t, v.VerifyBlockRootSeen(func(r [32]byte) bool { return r == root32 }))
-	require.ErrorIs(t, v.VerifyBlockRootSeen(func([32]byte) bool { return false }), ErrPayloadAttBlockRootNotSeen)
-
-	require.NoError(t, v.VerifyBlockRootValid(func([32]byte) bool { return false }))
-	require.ErrorIs(t, v.VerifyBlockRootValid(func([32]byte) bool { return true }), ErrPayloadAttBlockRootInvalid)
-}
-
-func TestPayloadAttestationVerifyValidatorInPTC(t *testing.T) {
-	setupPayloadAttTestConfig(t)
-
-	_, pk := newKey(t)
-	st := newTestState(t, []*eth.Validator{activeValidator(pk)}, 1)
-	msg := newPayloadAttestationMessage(primitives.Slot(1), 0, bytes.Repeat([]byte{0x33}, 32))
-	pa, err := payloadattestation.NewReadOnly(msg)
-	require.NoError(t, err)
-	v := (&Initializer{shared: &sharedResources{}}).NewPayloadAttestationMsgVerifier(pa, GossipPayloadAttestationMessageRequirements)
-	require.NoError(t, v.VerifyValidatorInPTC(context.Background(), st))
-
-	msg = newPayloadAttestationMessage(primitives.Slot(1), 1, bytes.Repeat([]byte{0x33}, 32))
-	pa, err = payloadattestation.NewReadOnly(msg)
-	require.NoError(t, err)
-	v = (&Initializer{shared: &sharedResources{}}).NewPayloadAttestationMsgVerifier(pa, GossipPayloadAttestationMessageRequirements)
-	require.ErrorIs(t, v.VerifyValidatorInPTC(context.Background(), st), ErrIncorrectPayloadAttValidator)
-}
-
-func TestPayloadAttestationVerifySignature(t *testing.T) {
-	setupPayloadAttTestConfig(t)
-
-	sk, pk := newKey(t)
-	st := newTestState(t, []*eth.Validator{activeValidator(pk)}, 1)
-	root := bytes.Repeat([]byte{0x44}, 32)
-	data := &eth.PayloadAttestationData{
-		BeaconBlockRoot:   root,
-		Slot:              1,
-		PayloadPresent:    true,
-		BlobDataAvailable: true,
-	}
-	msg := &eth.PayloadAttestationMessage{
-		ValidatorIndex: 0,
-		Data:           data,
-		Signature:      signPayloadAttestationMessage(t, st, data, sk),
-	}
-	pa, err := payloadattestation.NewReadOnly(msg)
-	require.NoError(t, err)
-	v := (&Initializer{shared: &sharedResources{}}).NewPayloadAttestationMsgVerifier(pa, GossipPayloadAttestationMessageRequirements)
-	require.NoError(t, v.VerifySignature(st))
-
-	sk2, _ := newKey(t)
-	msg.Signature = signPayloadAttestationMessage(t, st, data, sk2)
-	pa, err = payloadattestation.NewReadOnly(msg)
-	require.NoError(t, err)
-	v = (&Initializer{shared: &sharedResources{}}).NewPayloadAttestationMsgVerifier(pa, GossipPayloadAttestationMessageRequirements)
-	require.ErrorIs(t, v.VerifySignature(st), signing.ErrSigFailedToVerify)
-}
-
-func newPayloadAttestationMessage(slot primitives.Slot, idx primitives.ValidatorIndex, root []byte) *eth.PayloadAttestationMessage {
-	return &eth.PayloadAttestationMessage{
-		ValidatorIndex: idx,
-		Data: &eth.PayloadAttestationData{
-			BeaconBlockRoot:   root,
-			Slot:              slot,
-			PayloadPresent:    true,
-			BlobDataAvailable: true,
-		},
-		Signature: []byte{0x01},
-	}
-}
-
-func newTestState(t *testing.T, vals []*eth.Validator, slot primitives.Slot) state.BeaconState {
-	st, err := testutil.NewBeaconStateGloas()
-	require.NoError(t, err)
-	for _, v := range vals {
-		require.NoError(t, st.AppendValidator(v))
-		require.NoError(t, st.AppendBalance(v.EffectiveBalance))
-	}
-	require.NoError(t, st.SetSlot(slot))
-	require.NoError(t, helpers.UpdateCommitteeCache(t.Context(), st, slots.ToEpoch(slot)))
-	return st
-}
-
-func setupPayloadAttTestConfig(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig().Copy()
-	cfg.SlotsPerEpoch = 1
-	cfg.MaxEffectiveBalanceElectra = cfg.MaxEffectiveBalance
-	params.OverrideBeaconConfig(cfg)
-}
-
-func activeValidator(pub []byte) *eth.Validator {
-	return &eth.Validator{
-		PublicKey:                  pub,
-		EffectiveBalance:           params.BeaconConfig().MaxEffectiveBalance,
-		WithdrawalCredentials:      make([]byte, 32),
-		ExitEpoch:                  params.BeaconConfig().FarFutureEpoch,
-		WithdrawableEpoch:          params.BeaconConfig().FarFutureEpoch,
-	}
-}
-
-func newKey(t *testing.T) (common.SecretKey, []byte) {
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	return sk, sk.PublicKey().Marshal()
-}
-
-func signPayloadAttestationMessage(t *testing.T, st state.ReadOnlyBeaconState, data *eth.PayloadAttestationData, sk common.SecretKey) []byte {
-	domain, err := signing.Domain(st.Fork(), slots.ToEpoch(st.Slot()), params.BeaconConfig().DomainPTCAttester, st.GenesisValidatorsRoot())
-	require.NoError(t, err)
-	root, err := signing.ComputeSigningRoot(data, domain)
-	require.NoError(t, err)
-	sig := sk.Sign(root[:])
-	return sig.Marshal()
-}

beacon-chain/verification/requirements.go

@@ -1,27 +0,0 @@
-package verification
-
-const (
-	RequireBlobIndexInBounds Requirement = iota
-	RequireNotFromFutureSlot
-	RequireSlotAboveFinalized
-	RequireValidProposerSignature
-	RequireSidecarParentSeen
-	RequireSidecarParentValid
-	RequireSidecarParentSlotLower
-	RequireSidecarDescendsFromFinalized
-	RequireSidecarInclusionProven
-	RequireSidecarKzgProofVerified
-	RequireSidecarProposerExpected
-
-	// Data columns specific.
-	RequireValidFields
-	RequireCorrectSubnet
-
-	// Payload attestation specific.
-	RequireCurrentSlot
-	RequireMessageNotSeen
-	RequireValidatorInPTC
-	RequireBlockRootSeen
-	RequireBlockRootValid
-	RequireSignatureValid
-)

beacon-chain/verification/result.go

@@ -29,22 +29,6 @@ func (r Requirement) String() string {
 		return "RequireSidecarKzgProofVerified"
 	case RequireSidecarProposerExpected:
 		return "RequireSidecarProposerExpected"
-	case RequireValidFields:
-		return "RequireValidFields"
-	case RequireCorrectSubnet:
-		return "RequireCorrectSubnet"
-	case RequireCurrentSlot:
-		return "RequireCurrentSlot"
-	case RequireMessageNotSeen:
-		return "RequireMessageNotSeen"
-	case RequireValidatorInPTC:
-		return "RequireValidatorInPTC"
-	case RequireBlockRootSeen:
-		return "RequireBlockRootSeen"
-	case RequireBlockRootValid:
-		return "RequireBlockRootValid"
-	case RequireSignatureValid:
-		return "RequireSignatureValid"
 	default:
 		return unknownRequirementName
 	}

beacon-chain/verification/result_test.go

@@ -61,16 +61,3 @@ func TestAllBlobRequirementsHaveStrings(t *testing.T) {
 		require.NotEqual(t, unknownRequirementName, allBlobSidecarRequirements[i].String())
 	}
 }
-
-func TestPayloadAttestationRequirementsHaveStrings(t *testing.T) {
-	blobReqs := make(map[Requirement]struct{}, len(allBlobSidecarRequirements))
-	for i := range allBlobSidecarRequirements {
-		blobReqs[allBlobSidecarRequirements[i]] = struct{}{}
-	}
-	for i := range PayloadAttGossipRequirements {
-		req := PayloadAttGossipRequirements[i]
-		require.NotEqual(t, unknownRequirementName, req.String())
-		_, overlaps := blobReqs[req]
-		require.Equal(t, false, overlaps)
-	}
-}

changelog/bastin_fix-logging-issue.md

@@ -1,3 +0,0 @@
-### Changed
-
-- Fixed the logging issue described in #16314.

changelog/james-prysm_simplify-parse-beacon-block.md

@@ -1,3 +0,0 @@
-### Ignored
-
-- improving maintainability and deduplication on get and post block parsing.

changelog/potuz_forkchoice_unused_highestblockdelay.md

@@ -1,2 +0,0 @@
-### Ignored
-- Remove unused `HighestBlockDelay` method in forkchoice.

changelog/potuz_forkchoice_unused_last_root.md

@@ -1,2 +0,0 @@
-### Ignored
-- Remove unused method in forkchoice.

changelog/potuz_remove_unused_map.md

@@ -1,2 +0,0 @@
-### Ignored
-- Remove unused map in forkchoice.

changelog/pvl-bbolt-read-copy.md

@@ -1,3 +0,0 @@
-### Fixed
-
-- Fixed some database slices that were used outside of a read transaction. See [bbolt README](https://github.com/etcd-io/bbolt/blob/7b38172caf8cde993d187be4b8738fbe9266fde8/README.md?plain=1#L852) for more on this caveat.

changelog/satushh-close-host.md

@@ -1,2 +0,0 @@
-### Ignored
-- Close opened host in test helpers

changelog/tt_gossip_payload.md

@@ -1,3 +0,0 @@
-### Added
-
-- Added support for Payload attestation gossip net in gloas

changelog/tt_move-kzg-commitments.md

@@ -1,3 +0,0 @@
-### Changed
-
-- Moved blob KZG commitments into `ExecutionPayloadBid` and removed them from `ExecutionPayloadEnvelope` for Gloas.

changelog/tt_ro-payload-envelope.md

@@ -1,3 +0,0 @@
-### Added
-
-- Add read only wrapper for execution payload envelope for gloas

cmd/beacon-chain/execution/log.go

@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package execution
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "cmd/beacon-chain/execution")

cmd/beacon-chain/flags/base.go

@@ -356,11 +356,6 @@ var (
 		Usage: "A comma-separated list of exponents (of 2) in decreasing order, defining the state diff hierarchy levels. The last exponent must be greater than or equal to 5.",
 		Value: cli.NewIntSlice(21, 18, 16, 13, 11, 9, 5),
 	}
-	// StateDiffValidateOnStartup validates state diff data on startup.
-	StateDiffValidateOnStartup = &cli.BoolFlag{
-		Name:  "disable-hdiff-validate-on-startup",
-		Usage: "Disables state-diff validation on startup (enabled by default).",
-	}
 	// DisableEphemeralLogFile disables the 24 hour debug log file.
 	DisableEphemeralLogFile = &cli.BoolFlag{
 		Name:  "disable-ephemeral-log-file",

cmd/beacon-chain/flags/config.go

@@ -9,25 +9,24 @@ import (
 	"github.com/urfave/cli/v2"
 )
 
-const MaxStateDiffExponent = 30
+const maxStateDiffExponents = 30
 
 // GlobalFlags specifies all the global flags for the
 // beacon node.
 type GlobalFlags struct {
-	StateDiffValidateOnStartup      bool
-	Supernode                       bool
-	DisableGetBlobsV2               bool
-	SemiSupernode                   bool
 	SubscribeToAllSubnets           bool
-	BlobBatchLimitBurstFactor       int
-	DataColumnBatchLimit            int
-	BlockBatchLimit                 int
-	MaxConcurrentDials              int
-	MinimumPeersPerSubnet           int
+	Supernode                       bool
+	SemiSupernode                   bool
+	DisableGetBlobsV2               bool
 	MinimumSyncPeers                int
-	DataColumnBatchLimitBurstFactor int
+	MinimumPeersPerSubnet           int
+	MaxConcurrentDials              int
+	BlockBatchLimit                 int
 	BlockBatchLimitBurstFactor      int
 	BlobBatchLimit                  int
+	BlobBatchLimitBurstFactor       int
+	DataColumnBatchLimit            int
+	DataColumnBatchLimitBurstFactor int
 	StateDiffExponents              []int
 }
 
@@ -81,7 +80,6 @@ func ConfigureGlobalFlags(ctx *cli.Context) error {
 
 	// State-diff-exponents
 	cfg.StateDiffExponents = ctx.IntSlice(StateDiffExponents.Name)
-	cfg.StateDiffValidateOnStartup = !ctx.Bool(StateDiffValidateOnStartup.Name)
 	if features.Get().EnableStateDiff {
 		if err := validateStateDiffExponents(cfg.StateDiffExponents); err != nil {
 			return err
@@ -90,9 +88,6 @@ func ConfigureGlobalFlags(ctx *cli.Context) error {
 		if ctx.IsSet(StateDiffExponents.Name) {
 			log.Warn("--state-diff-exponents is set but --enable-state-diff is not; the value will be ignored.")
 		}
-		if ctx.IsSet(StateDiffValidateOnStartup.Name) {
-			log.Warn("--disable-hdiff-validate-on-startup is set but --enable-state-diff is not; the value will be ignored.")
-		}
 	}
 
 	cfg.BlockBatchLimit = ctx.Int(BlockBatchLimit.Name)
@@ -137,7 +132,7 @@ func validateStateDiffExponents(exponents []int) error {
 	if exponents[length-1] < 5 {
 		return errors.New("the last state diff exponent must be at least 5")
 	}
-	prev := MaxStateDiffExponent + 1
+	prev := maxStateDiffExponents + 1
 	for _, exp := range exponents {
 		if exp >= prev {
 			return errors.New("state diff exponents must be in strictly decreasing order, and each exponent must be <= 30")

cmd/beacon-chain/main.go

@@ -161,7 +161,6 @@ var appFlags = []cli.Flag{
 	dasFlags.BlobRetentionEpochFlag,
 	flags.BatchVerifierLimit,
 	flags.StateDiffExponents,
-	flags.StateDiffValidateOnStartup,
 	flags.DisableEphemeralLogFile,
 }
 
@@ -189,8 +188,8 @@ func before(ctx *cli.Context) error {
 		return errors.Wrap(err, "failed to parse log vmodule")
 	}
 
-	// set the global logging level and data
-	logs.SetLoggingLevelAndData(verbosityLevel, vmodule, maxLevel, ctx.Bool(flags.DisableEphemeralLogFile.Name))
+	// set the global logging level to allow for the highest verbosity requested
+	logs.SetLoggingLevel(max(verbosityLevel, maxLevel))
 
 	format := ctx.String(cmd.LogFormat.Name)
 	switch format {
@@ -211,7 +210,6 @@ func before(ctx *cli.Context) error {
 			Formatter:     formatter,
 			Writer:        os.Stderr,
 			AllowedLevels: logrus.AllLevels[:max(verbosityLevel, maxLevel)+1],
-			Identifier:    logs.LogTargetUser,
 		})
 	case "fluentd":
 		f := joonix.NewFormatter()

cmd/beacon-chain/usage.go

@@ -75,7 +75,6 @@ var appHelpFlagGroups = []flagGroup{
 			flags.RPCPort,
 			flags.BatchVerifierLimit,
 			flags.StateDiffExponents,
-			flags.StateDiffValidateOnStartup,
 		},
 	},
 	{

cmd/validator/main.go

@@ -164,8 +164,8 @@ func main() {
 				return errors.Wrap(err, "failed to parse log vmodule")
 			}
 
-			// set the global logging level and data
-			logs.SetLoggingLevelAndData(verbosityLevel, vmodule, maxLevel, ctx.Bool(flags.DisableEphemeralLogFile.Name))
+			// set the global logging level to allow for the highest verbosity requested
+			logs.SetLoggingLevel(max(maxLevel, verbosityLevel))
 
 			logFileName := ctx.String(cmd.LogFileName.Name)
 
@@ -188,7 +188,6 @@ func main() {
 					Formatter:     formatter,
 					Writer:        os.Stderr,
 					AllowedLevels: logrus.AllLevels[:max(verbosityLevel, maxLevel)+1],
-					Identifier:    logs.LogTargetUser,
 				})
 			case "fluentd":
 				f := joonix.NewFormatter()

consensus-types/blocks/BUILD.bazel

@@ -4,7 +4,6 @@ go_library(
     name = "go_default_library",
     srcs = [
         "execution.go",
-        "execution_payload_envelope.go",
         "factory.go",
         "get_payload.go",
         "getters.go",
@@ -46,7 +45,6 @@ go_library(
 go_test(
     name = "go_default_test",
     srcs = [
-        "execution_payload_envelope_test.go",
         "execution_test.go",
         "factory_test.go",
         "getters_test.go",

consensus-types/blocks/execution_payload_envelope.go

@@ -1,131 +0,0 @@
-package blocks
-
-import (
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	field_params "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	consensus_types "github.com/OffchainLabs/prysm/v7/consensus-types"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"google.golang.org/protobuf/proto"
-)
-
-type signedExecutionPayloadEnvelope struct {
-	s *ethpb.SignedExecutionPayloadEnvelope
-}
-
-type executionPayloadEnvelope struct {
-	p *ethpb.ExecutionPayloadEnvelope
-}
-
-// WrappedROSignedExecutionPayloadEnvelope wraps a signed execution payload envelope proto in a read-only interface.
-func WrappedROSignedExecutionPayloadEnvelope(s *ethpb.SignedExecutionPayloadEnvelope) (interfaces.ROSignedExecutionPayloadEnvelope, error) {
-	w := signedExecutionPayloadEnvelope{s: s}
-	if w.IsNil() {
-		return nil, consensus_types.ErrNilObjectWrapped
-	}
-	return w, nil
-}
-
-// WrappedROExecutionPayloadEnvelope wraps an execution payload envelope proto in a read-only interface.
-func WrappedROExecutionPayloadEnvelope(p *ethpb.ExecutionPayloadEnvelope) (interfaces.ROExecutionPayloadEnvelope, error) {
-	w := &executionPayloadEnvelope{p: p}
-	if w.IsNil() {
-		return nil, consensus_types.ErrNilObjectWrapped
-	}
-	return w, nil
-}
-
-// Envelope returns the execution payload envelope as a read-only interface.
-func (s signedExecutionPayloadEnvelope) Envelope() (interfaces.ROExecutionPayloadEnvelope, error) {
-	return WrappedROExecutionPayloadEnvelope(s.s.Message)
-}
-
-// Signature returns the BLS signature as a 96-byte array.
-func (s signedExecutionPayloadEnvelope) Signature() [field_params.BLSSignatureLength]byte {
-	return [field_params.BLSSignatureLength]byte(s.s.Signature)
-}
-
-// IsNil reports whether the signed envelope or its contents are invalid.
-func (s signedExecutionPayloadEnvelope) IsNil() bool {
-	if s.s == nil {
-		return true
-	}
-	if len(s.s.Signature) != field_params.BLSSignatureLength {
-		return true
-	}
-	if len(s.s.Message.BeaconBlockRoot) != field_params.RootLength {
-		return true
-	}
-	if len(s.s.Message.StateRoot) != field_params.RootLength {
-		return true
-	}
-	if s.s.Message.ExecutionRequests == nil {
-		return true
-	}
-	if s.s.Message.Payload == nil {
-		return true
-	}
-	w := executionPayloadEnvelope{p: s.s.Message}
-	return w.IsNil()
-}
-
-// SigningRoot computes the signing root for the signed envelope with the provided domain.
-func (s signedExecutionPayloadEnvelope) SigningRoot(domain []byte) (root [32]byte, err error) {
-	return signing.ComputeSigningRoot(s.s.Message, domain)
-}
-
-// Proto returns the underlying protobuf message.
-func (s signedExecutionPayloadEnvelope) Proto() proto.Message {
-	return s.s
-}
-
-// IsNil reports whether the envelope or its required fields are invalid.
-func (p *executionPayloadEnvelope) IsNil() bool {
-	if p.p == nil {
-		return true
-	}
-	if p.p.Payload == nil {
-		return true
-	}
-	if len(p.p.BeaconBlockRoot) != field_params.RootLength {
-		return true
-	}
-	return false
-}
-
-// IsBlinded reports whether the envelope contains a blinded payload.
-func (p *executionPayloadEnvelope) IsBlinded() bool {
-	return false
-}
-
-// Execution returns the execution payload as a read-only interface.
-func (p *executionPayloadEnvelope) Execution() (interfaces.ExecutionData, error) {
-	return WrappedExecutionPayloadDeneb(p.p.Payload)
-}
-
-// ExecutionRequests returns the execution requests attached to the envelope.
-func (p *executionPayloadEnvelope) ExecutionRequests() *enginev1.ExecutionRequests {
-	return ethpb.CopyExecutionRequests(p.p.ExecutionRequests)
-}
-
-// BuilderIndex returns the proposer/builder index for the envelope.
-func (p *executionPayloadEnvelope) BuilderIndex() primitives.BuilderIndex {
-	return p.p.BuilderIndex
-}
-
-// BeaconBlockRoot returns the beacon block root referenced by the envelope.
-func (p *executionPayloadEnvelope) BeaconBlockRoot() [field_params.RootLength]byte {
-	return [field_params.RootLength]byte(p.p.BeaconBlockRoot)
-}
-
-// Slot returns the slot of the envelope.
-func (p *executionPayloadEnvelope) Slot() primitives.Slot {
-	return p.p.Slot
-}
-
-// StateRoot returns the state root carried by the envelope.
-func (p *executionPayloadEnvelope) StateRoot() [field_params.RootLength]byte {
-	return [field_params.RootLength]byte(p.p.StateRoot)
-}

consensus-types/blocks/execution_payload_envelope_test.go

@@ -1,136 +0,0 @@
-package blocks_test
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	consensus_types "github.com/OffchainLabs/prysm/v7/consensus-types"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/assert"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-)
-
-func validExecutionPayloadEnvelope() *ethpb.ExecutionPayloadEnvelope {
-	payload := &enginev1.ExecutionPayloadDeneb{
-		ParentHash:    bytes.Repeat([]byte{0x01}, 32),
-		FeeRecipient:  bytes.Repeat([]byte{0x02}, 20),
-		StateRoot:     bytes.Repeat([]byte{0x03}, 32),
-		ReceiptsRoot:  bytes.Repeat([]byte{0x04}, 32),
-		LogsBloom:     bytes.Repeat([]byte{0x05}, 256),
-		PrevRandao:    bytes.Repeat([]byte{0x06}, 32),
-		BlockNumber:   1,
-		GasLimit:      2,
-		GasUsed:       3,
-		Timestamp:     4,
-		BaseFeePerGas: bytes.Repeat([]byte{0x07}, 32),
-		BlockHash:     bytes.Repeat([]byte{0x08}, 32),
-		Transactions:  [][]byte{},
-		Withdrawals:   []*enginev1.Withdrawal{},
-		BlobGasUsed:   0,
-		ExcessBlobGas: 0,
-	}
-
-	return &ethpb.ExecutionPayloadEnvelope{
-		Payload: payload,
-		ExecutionRequests: &enginev1.ExecutionRequests{
-			Deposits: []*enginev1.DepositRequest{
-				{
-					Pubkey:                bytes.Repeat([]byte{0x09}, 48),
-					WithdrawalCredentials: bytes.Repeat([]byte{0x0A}, 32),
-					Signature:             bytes.Repeat([]byte{0x0B}, 96),
-				},
-			},
-		},
-		BuilderIndex:    10,
-		BeaconBlockRoot: bytes.Repeat([]byte{0xAA}, 32),
-		Slot:            9,
-		StateRoot:       bytes.Repeat([]byte{0xBB}, 32),
-	}
-}
-
-func TestWrappedROExecutionPayloadEnvelope(t *testing.T) {
-	t.Run("returns error on nil payload", func(t *testing.T) {
-		invalid := validExecutionPayloadEnvelope()
-		invalid.Payload = nil
-		_, err := blocks.WrappedROExecutionPayloadEnvelope(invalid)
-		require.Equal(t, consensus_types.ErrNilObjectWrapped, err)
-	})
-
-	t.Run("returns error on invalid beacon root length", func(t *testing.T) {
-		invalid := validExecutionPayloadEnvelope()
-		invalid.BeaconBlockRoot = []byte{0x01}
-		_, err := blocks.WrappedROExecutionPayloadEnvelope(invalid)
-		require.Equal(t, consensus_types.ErrNilObjectWrapped, err)
-	})
-
-	t.Run("wraps and exposes fields", func(t *testing.T) {
-		env := validExecutionPayloadEnvelope()
-		wrapped, err := blocks.WrappedROExecutionPayloadEnvelope(env)
-		require.NoError(t, err)
-
-		require.Equal(t, primitives.BuilderIndex(10), wrapped.BuilderIndex())
-		require.Equal(t, primitives.Slot(9), wrapped.Slot())
-		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0xAA}, 32)), wrapped.BeaconBlockRoot())
-		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0xBB}, 32)), wrapped.StateRoot())
-
-		reqs := wrapped.ExecutionRequests()
-		require.NotNil(t, reqs)
-		if len(reqs.Deposits) > 0 {
-			reqs.Deposits[0].Pubkey[0] = 0xFF
-			require.NotEqual(t, reqs.Deposits[0].Pubkey[0], env.ExecutionRequests.Deposits[0].Pubkey[0])
-		}
-
-		exec, err := wrapped.Execution()
-		require.NoError(t, err)
-		assert.DeepEqual(t, env.Payload.ParentHash, exec.ParentHash())
-
-		require.Equal(t, false, wrapped.IsBlinded())
-	})
-}
-
-func TestWrappedROSignedExecutionPayloadEnvelope(t *testing.T) {
-	t.Run("returns error for invalid signature length", func(t *testing.T) {
-		signed := &ethpb.SignedExecutionPayloadEnvelope{
-			Message:   validExecutionPayloadEnvelope(),
-			Signature: bytes.Repeat([]byte{0xAA}, 95),
-		}
-		_, err := blocks.WrappedROSignedExecutionPayloadEnvelope(signed)
-		require.Equal(t, consensus_types.ErrNilObjectWrapped, err)
-	})
-
-	t.Run("returns error on nil envelope", func(t *testing.T) {
-		_, err := blocks.WrappedROSignedExecutionPayloadEnvelope(nil)
-		require.Equal(t, consensus_types.ErrNilObjectWrapped, err)
-	})
-
-	t.Run("wraps and provides envelope/signing data", func(t *testing.T) {
-		sig := bytes.Repeat([]byte{0xAB}, 96)
-		signed := &ethpb.SignedExecutionPayloadEnvelope{
-			Message:   validExecutionPayloadEnvelope(),
-			Signature: sig,
-		}
-
-		wrapped, err := blocks.WrappedROSignedExecutionPayloadEnvelope(signed)
-		require.NoError(t, err)
-
-		gotSig := wrapped.Signature()
-		assert.DeepEqual(t, [96]byte(sig), gotSig)
-
-		env, err := wrapped.Envelope()
-		require.NoError(t, err)
-		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0xAA}, 32)), env.BeaconBlockRoot())
-
-		domain := bytes.Repeat([]byte{0xCC}, 32)
-		wantRoot, err := signing.ComputeSigningRoot(signed.Message, domain)
-		require.NoError(t, err)
-		gotRoot, err := wrapped.SigningRoot(domain)
-		require.NoError(t, err)
-		require.Equal(t, wantRoot, gotRoot)
-
-		require.Equal(t, signed, wrapped.Proto())
-	})
-}

consensus-types/blocks/getters_test.go

@@ -671,7 +671,7 @@ func hydrateBeaconBlockBodyGloas() *eth.BeaconBlockBodyGloas {
 				BlockHash:              make([]byte, fieldparams.RootLength),
 				PrevRandao:             make([]byte, fieldparams.RootLength),
 				FeeRecipient:           make([]byte, 20),
-				BlobKzgCommitments:     [][]byte{make([]byte, fieldparams.BLSPubkeyLength)},
+				BlobKzgCommitmentsRoot: make([]byte, fieldparams.RootLength),
 			},
 			Signature: make([]byte, fieldparams.BLSSignatureLength),
 		},

consensus-types/blocks/signed_execution_bid.go

@@ -5,7 +5,6 @@ import (
 	consensus_types "github.com/OffchainLabs/prysm/v7/consensus-types"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 )
 
@@ -44,16 +43,11 @@ func (h executionPayloadBidGloas) IsNil() bool {
 		len(h.payload.ParentBlockRoot) != 32 ||
 		len(h.payload.BlockHash) != 32 ||
 		len(h.payload.PrevRandao) != 32 ||
+		len(h.payload.BlobKzgCommitmentsRoot) != 32 ||
 		len(h.payload.FeeRecipient) != 20 {
 		return true
 	}
 
-	for _, commitment := range h.payload.BlobKzgCommitments {
-		if len(commitment) != 48 {
-			return true
-		}
-	}
-
 	return false
 }
 
@@ -137,14 +131,9 @@ func (h executionPayloadBidGloas) ExecutionPayment() primitives.Gwei {
 	return primitives.Gwei(h.payload.ExecutionPayment)
 }
 
-// BlobKzgCommitments returns the KZG commitments for blobs.
-func (h executionPayloadBidGloas) BlobKzgCommitments() [][]byte {
-	return bytesutil.SafeCopy2dBytes(h.payload.BlobKzgCommitments)
-}
-
-// BlobKzgCommitmentCount returns the number of blob KZG commitments.
-func (h executionPayloadBidGloas) BlobKzgCommitmentCount() uint64 {
-	return uint64(len(h.payload.BlobKzgCommitments))
+// BlobKzgCommitmentsRoot returns the root of the KZG commitments for blobs.
+func (h executionPayloadBidGloas) BlobKzgCommitmentsRoot() [32]byte {
+	return [32]byte(h.payload.BlobKzgCommitmentsRoot)
 }
 
 // FeeRecipient returns the execution address that will receive the builder payment.

consensus-types/blocks/signed_execution_bid_test.go

@@ -15,17 +15,17 @@ import (
 
 func validExecutionPayloadBid() *ethpb.ExecutionPayloadBid {
 	return &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:    bytes.Repeat([]byte{0x01}, 32),
-		ParentBlockRoot:    bytes.Repeat([]byte{0x02}, 32),
-		BlockHash:          bytes.Repeat([]byte{0x03}, 32),
-		PrevRandao:         bytes.Repeat([]byte{0x04}, 32),
-		GasLimit:           123,
-		BuilderIndex:       5,
-		Slot:               6,
-		Value:              7,
-		ExecutionPayment:   8,
-		BlobKzgCommitments: [][]byte{bytes.Repeat([]byte{0x05}, 48)},
-		FeeRecipient:       bytes.Repeat([]byte{0x06}, 20),
+		ParentBlockHash:        bytes.Repeat([]byte{0x01}, 32),
+		ParentBlockRoot:        bytes.Repeat([]byte{0x02}, 32),
+		BlockHash:              bytes.Repeat([]byte{0x03}, 32),
+		PrevRandao:             bytes.Repeat([]byte{0x04}, 32),
+		GasLimit:               123,
+		BuilderIndex:           5,
+		Slot:                   6,
+		Value:                  7,
+		ExecutionPayment:       8,
+		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x05}, 32),
+		FeeRecipient:           bytes.Repeat([]byte{0x06}, 20),
 	}
 }
 
@@ -52,8 +52,8 @@ func TestWrappedROExecutionPayloadBid(t *testing.T) {
 				mutate: func(b *ethpb.ExecutionPayloadBid) { b.PrevRandao = []byte{0x04} },
 			},
 			{
-				name:   "blob kzg commitments length",
-				mutate: func(b *ethpb.ExecutionPayloadBid) { b.BlobKzgCommitments = [][]byte{[]byte{0x05}} },
+				name:   "blob kzg commitments root",
+				mutate: func(b *ethpb.ExecutionPayloadBid) { b.BlobKzgCommitmentsRoot = []byte{0x05} },
 			},
 			{
 				name:   "fee recipient",
@@ -85,8 +85,7 @@ func TestWrappedROExecutionPayloadBid(t *testing.T) {
 		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0x02}, 32)), wrapped.ParentBlockRoot())
 		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0x03}, 32)), wrapped.BlockHash())
 		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0x04}, 32)), wrapped.PrevRandao())
-		assert.DeepEqual(t, [][]byte{bytes.Repeat([]byte{0x05}, 48)}, wrapped.BlobKzgCommitments())
-		require.Equal(t, uint64(1), wrapped.BlobKzgCommitmentCount())
+		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0x05}, 32)), wrapped.BlobKzgCommitmentsRoot())
 		assert.DeepEqual(t, [20]byte(bytes.Repeat([]byte{0x06}, 20)), wrapped.FeeRecipient())
 	})
 }

consensus-types/interfaces/BUILD.bazel

@@ -5,7 +5,6 @@ go_library(
     srcs = [
         "beacon_block.go",
         "error.go",
-        "execution_payload_envelope.go",
         "light_client.go",
         "signed_execution_payload_bid.go",
         "utils.go",

consensus-types/interfaces/execution_payload_envelope.go

@@ -1,27 +0,0 @@
-package interfaces
-
-import (
-	field_params "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	"google.golang.org/protobuf/proto"
-)
-
-type ROSignedExecutionPayloadEnvelope interface {
-	Envelope() (ROExecutionPayloadEnvelope, error)
-	Signature() [field_params.BLSSignatureLength]byte
-	SigningRoot([]byte) ([32]byte, error)
-	IsNil() bool
-	Proto() proto.Message
-}
-
-type ROExecutionPayloadEnvelope interface {
-	Execution() (ExecutionData, error)
-	ExecutionRequests() *enginev1.ExecutionRequests
-	BuilderIndex() primitives.BuilderIndex
-	BeaconBlockRoot() [field_params.RootLength]byte
-	Slot() primitives.Slot
-	StateRoot() [field_params.RootLength]byte
-	IsBlinded() bool
-	IsNil() bool
-}

consensus-types/interfaces/signed_execution_payload_bid.go

@@ -22,8 +22,7 @@ type ROExecutionPayloadBid interface {
 	Slot() primitives.Slot
 	Value() primitives.Gwei
 	ExecutionPayment() primitives.Gwei
-	BlobKzgCommitments() [][]byte
-	BlobKzgCommitmentCount() uint64
+	BlobKzgCommitmentsRoot() [32]byte
 	FeeRecipient() [20]byte
 	IsNil() bool
 }

consensus-types/payload-attestation/BUILD.bazel

@@ -1,15 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["readonly_message.go"],
-    importpath = "github.com/OffchainLabs/prysm/v7/consensus-types/payload-attestation",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//beacon-chain/core/signing:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-    ],
-)

consensus-types/payload-attestation/readonly_message.go

@@ -1,87 +0,0 @@
-package payloadattestation
-
-import (
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/pkg/errors"
-)
-
-var (
-	errNilPayloadAttMessage   = errors.New("received nil payload attestation message")
-	errNilPayloadAttData      = errors.New("received nil payload attestation data")
-	errNilPayloadAttSignature = errors.New("received nil payload attestation signature")
-)
-
-// ROMessage represents a read-only payload attestation message.
-type ROMessage struct {
-	m *ethpb.PayloadAttestationMessage
-}
-
-// validatePayloadAtt checks if the given payload attestation message is valid.
-func validatePayloadAtt(m *ethpb.PayloadAttestationMessage) error {
-	if m == nil {
-		return errNilPayloadAttMessage
-	}
-	if m.Data == nil {
-		return errNilPayloadAttData
-	}
-	if len(m.Signature) == 0 {
-		return errNilPayloadAttSignature
-	}
-	return nil
-}
-
-// NewReadOnly creates a new ReadOnly instance after validating the message.
-func NewReadOnly(m *ethpb.PayloadAttestationMessage) (ROMessage, error) {
-	if err := validatePayloadAtt(m); err != nil {
-		return ROMessage{}, err
-	}
-	return ROMessage{m}, nil
-}
-
-// ValidatorIndex returns the validator index from the payload attestation message.
-func (r *ROMessage) ValidatorIndex() primitives.ValidatorIndex {
-	return r.m.ValidatorIndex
-}
-
-// Signature returns the signature from the payload attestation message.
-func (r *ROMessage) Signature() [96]byte {
-	return bytesutil.ToBytes96(r.m.Signature)
-}
-
-// BeaconBlockRoot returns the beacon block root from the payload attestation message.
-func (r *ROMessage) BeaconBlockRoot() [32]byte {
-	return bytesutil.ToBytes32(r.m.Data.BeaconBlockRoot)
-}
-
-// Slot returns the slot from the payload attestation message.
-func (r *ROMessage) Slot() primitives.Slot {
-	return r.m.Data.Slot
-}
-
-// PayloadPresent returns whether the payload was present.
-func (r *ROMessage) PayloadPresent() bool {
-	return r.m.Data.PayloadPresent
-}
-
-// BlobDataAvailable returns whether blob data was available.
-func (r *ROMessage) BlobDataAvailable() bool {
-	return r.m.Data.BlobDataAvailable
-}
-
-// SigningRoot returns the signing root from the payload attestation message.
-func (r *ROMessage) SigningRoot(domain []byte) ([32]byte, error) {
-	return signing.ComputeSigningRoot(r.m.Data, domain)
-}
-
-// VerifiedROMessage represents a verified read-only payload attestation message.
-type VerifiedROMessage struct {
-	ROMessage
-}
-
-// NewVerifiedROMessage creates a new VerifiedROMessage instance after validating the message.
-func NewVerifiedROMessage(r ROMessage) VerifiedROMessage {
-	return VerifiedROMessage{r}
-}

io/logs/hook.go

@@ -6,28 +6,20 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
-type HookIdentifier string
-
 type WriterHook struct {
 	AllowedLevels []logrus.Level
 	Writer        io.Writer
 	Formatter     logrus.Formatter
-	Identifier    HookIdentifier
 }
 
 func (hook *WriterHook) Levels() []logrus.Level {
-	if len(hook.AllowedLevels) == 0 {
+	if hook.AllowedLevels == nil || len(hook.AllowedLevels) == 0 {
 		return logrus.AllLevels
 	}
 	return hook.AllowedLevels
 }
 
 func (hook *WriterHook) Fire(entry *logrus.Entry) error {
-	val, ok := entry.Data[LogTargetField]
-	if ok && val != hook.Identifier {
-		return nil
-	}
-
 	line, err := hook.Formatter.Format(entry)
 	if err != nil {
 		return err

io/logs/logutil.go

@@ -17,43 +17,11 @@ import (
 	"gopkg.in/natefinch/lumberjack.v2"
 )
 
-var (
-	userVerbosity = logrus.InfoLevel
-	vmodule       = make(map[string]logrus.Level)
-)
+var ephemeralLogFileVerbosity = logrus.DebugLevel
 
-const (
-	ephemeralLogFileVerbosity                = logrus.DebugLevel
-	LogTargetField                           = "log_target"
-	LogTargetEphemeral        HookIdentifier = "ephemeral"
-	LogTargetUser             HookIdentifier = "user"
-)
-
-// SetLoggingLevelAndData sets the base logging level for logrus.
-func SetLoggingLevelAndData(baseVerbosity logrus.Level, vmoduleMap map[string]logrus.Level, maxVmoduleLevel logrus.Level, disableEphemeral bool) {
-	userVerbosity = baseVerbosity
-	vmodule = vmoduleMap
-
-	globalLevel := max(baseVerbosity, maxVmoduleLevel)
-	if !disableEphemeral {
-		globalLevel = max(globalLevel, ephemeralLogFileVerbosity)
-	}
-	logrus.SetLevel(globalLevel)
-}
-
-// PackageVerbosity returns the verbosity of a given package.
-func PackageVerbosity(packagePath string) logrus.Level {
-	bestLen := 0
-	bestLevel := userVerbosity
-	for k, v := range vmodule {
-		if k == packagePath || strings.HasPrefix(packagePath, k+"/") {
-			if len(k) > bestLen {
-				bestLen = len(k)
-				bestLevel = v
-			}
-		}
-	}
-	return bestLevel
+// SetLoggingLevel sets the base logging level for logrus.
+func SetLoggingLevel(lvl logrus.Level) {
+	logrus.SetLevel(max(lvl, ephemeralLogFileVerbosity))
 }
 
 func addLogWriter(w io.Writer) {
@@ -100,7 +68,6 @@ func ConfigurePersistentLogging(logFileName string, format string, lvl logrus.Le
 		Formatter:     formatter,
 		Writer:        f,
 		AllowedLevels: logrus.AllLevels[:max(lvl, maxVmoduleLevel)+1],
-		Identifier:    LogTargetUser,
 	})
 
 	logrus.Debug("File logging initialized")
@@ -134,7 +101,6 @@ func ConfigureEphemeralLogFile(datadirPath string, app string) error {
 		Formatter:     formatter,
 		Writer:        debugWriter,
 		AllowedLevels: logrus.AllLevels[:ephemeralLogFileVerbosity+1],
-		Identifier:    LogTargetEphemeral,
 	})
 
 	logrus.WithField("path", logFilePath).Debug("Ephemeral log file initialized")

proto/engine/v1/gloas.pb.go

@@ -0,0 +1,288 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.36.3
+// 	protoc        v3.21.7
+// source: proto/engine/v1/gloas.proto
+
+package enginev1
+
+import (
+	reflect "reflect"
+	sync "sync"
+
+	github_com_OffchainLabs_prysm_v6_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	_ "github.com/OffchainLabs/prysm/v7/proto/eth/ext"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type ExecutionPayloadEnvelope struct {
+	state              protoimpl.MessageState                                                     `protogen:"open.v1"`
+	Payload            *ExecutionPayloadDeneb                                                     `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
+	ExecutionRequests  *ExecutionRequests                                                         `protobuf:"bytes,2,opt,name=execution_requests,json=executionRequests,proto3" json:"execution_requests,omitempty"`
+	BuilderIndex       github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex `protobuf:"varint,3,opt,name=builder_index,json=builderIndex,proto3" json:"builder_index,omitempty" cast-type:"github.com/OffchainLabs/prysm/v7/consensus-types/primitives.ValidatorIndex"`
+	BeaconBlockRoot    []byte                                                                     `protobuf:"bytes,4,opt,name=beacon_block_root,json=beaconBlockRoot,proto3" json:"beacon_block_root,omitempty" ssz-size:"32"`
+	Slot               github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot           `protobuf:"varint,5,opt,name=slot,proto3" json:"slot,omitempty" cast-type:"github.com/OffchainLabs/prysm/v7/consensus-types/primitives.Slot"`
+	BlobKzgCommitments [][]byte                                                                   `protobuf:"bytes,6,rep,name=blob_kzg_commitments,json=blobKzgCommitments,proto3" json:"blob_kzg_commitments,omitempty" ssz-max:"4096" ssz-size:"?,48"`
+	StateRoot          []byte                                                                     `protobuf:"bytes,7,opt,name=state_root,json=stateRoot,proto3" json:"state_root,omitempty" ssz-size:"32"`
+	unknownFields      protoimpl.UnknownFields
+	sizeCache          protoimpl.SizeCache
+}
+
+func (x *ExecutionPayloadEnvelope) Reset() {
+	*x = ExecutionPayloadEnvelope{}
+	mi := &file_proto_engine_v1_gloas_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *ExecutionPayloadEnvelope) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ExecutionPayloadEnvelope) ProtoMessage() {}
+
+func (x *ExecutionPayloadEnvelope) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_engine_v1_gloas_proto_msgTypes[0]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ExecutionPayloadEnvelope.ProtoReflect.Descriptor instead.
+func (*ExecutionPayloadEnvelope) Descriptor() ([]byte, []int) {
+	return file_proto_engine_v1_gloas_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *ExecutionPayloadEnvelope) GetPayload() *ExecutionPayloadDeneb {
+	if x != nil {
+		return x.Payload
+	}
+	return nil
+}
+
+func (x *ExecutionPayloadEnvelope) GetExecutionRequests() *ExecutionRequests {
+	if x != nil {
+		return x.ExecutionRequests
+	}
+	return nil
+}
+
+func (x *ExecutionPayloadEnvelope) GetBuilderIndex() github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex {
+	if x != nil {
+		return x.BuilderIndex
+	}
+	return github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(0)
+}
+
+func (x *ExecutionPayloadEnvelope) GetBeaconBlockRoot() []byte {
+	if x != nil {
+		return x.BeaconBlockRoot
+	}
+	return nil
+}
+
+func (x *ExecutionPayloadEnvelope) GetSlot() github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot {
+	if x != nil {
+		return x.Slot
+	}
+	return github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(0)
+}
+
+func (x *ExecutionPayloadEnvelope) GetBlobKzgCommitments() [][]byte {
+	if x != nil {
+		return x.BlobKzgCommitments
+	}
+	return nil
+}
+
+func (x *ExecutionPayloadEnvelope) GetStateRoot() []byte {
+	if x != nil {
+		return x.StateRoot
+	}
+	return nil
+}
+
+type SignedExecutionPayloadEnvelope struct {
+	state         protoimpl.MessageState    `protogen:"open.v1"`
+	Message       *ExecutionPayloadEnvelope `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
+	Signature     []byte                    `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty" ssz-size:"96"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *SignedExecutionPayloadEnvelope) Reset() {
+	*x = SignedExecutionPayloadEnvelope{}
+	mi := &file_proto_engine_v1_gloas_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *SignedExecutionPayloadEnvelope) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SignedExecutionPayloadEnvelope) ProtoMessage() {}
+
+func (x *SignedExecutionPayloadEnvelope) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_engine_v1_gloas_proto_msgTypes[1]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use SignedExecutionPayloadEnvelope.ProtoReflect.Descriptor instead.
+func (*SignedExecutionPayloadEnvelope) Descriptor() ([]byte, []int) {
+	return file_proto_engine_v1_gloas_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *SignedExecutionPayloadEnvelope) GetMessage() *ExecutionPayloadEnvelope {
+	if x != nil {
+		return x.Message
+	}
+	return nil
+}
+
+func (x *SignedExecutionPayloadEnvelope) GetSignature() []byte {
+	if x != nil {
+		return x.Signature
+	}
+	return nil
+}
+
+var File_proto_engine_v1_gloas_proto protoreflect.FileDescriptor
+
+var file_proto_engine_v1_gloas_proto_rawDesc = []byte{
+	0x0a, 0x1b, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x76,
+	0x31, 0x2f, 0x67, 0x6c, 0x6f, 0x61, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x65,
+	0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2e, 0x76,
+	0x31, 0x1a, 0x26, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f,
+	0x76, 0x31, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x6e, 0x67,
+	0x69, 0x6e, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1d, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x76, 0x31, 0x2f, 0x65, 0x6c, 0x65, 0x63, 0x74,
+	0x72, 0x61, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f,
+	0x65, 0x74, 0x68, 0x2f, 0x65, 0x78, 0x74, 0x2f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xa3, 0x04, 0x0a, 0x18, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74,
+	0x69, 0x6f, 0x6e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x45, 0x6e, 0x76, 0x65, 0x6c, 0x6f,
+	0x70, 0x65, 0x12, 0x43, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65,
+	0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69,
+	0x6f, 0x6e, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x44, 0x65, 0x6e, 0x65, 0x62, 0x52, 0x07,
+	0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x54, 0x0a, 0x12, 0x65, 0x78, 0x65, 0x63, 0x75,
+	0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65,
+	0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69,
+	0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x52, 0x11, 0x65, 0x78, 0x65, 0x63,
+	0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x12, 0x73, 0x0a,
+	0x0d, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x04, 0x42, 0x4e, 0x82, 0xb5, 0x18, 0x4a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62,
+	0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c, 0x61, 0x62,
+	0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65,
+	0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69,
+	0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49,
+	0x6e, 0x64, 0x65, 0x78, 0x52, 0x0c, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x49, 0x6e, 0x64,
+	0x65, 0x78, 0x12, 0x32, 0x0a, 0x11, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x5f, 0x62, 0x6c, 0x6f,
+	0x63, 0x6b, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a,
+	0xb5, 0x18, 0x02, 0x33, 0x32, 0x52, 0x0f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f,
+	0x63, 0x6b, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x58, 0x0a, 0x04, 0x73, 0x6c, 0x6f, 0x74, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x04, 0x42, 0x44, 0x82, 0xb5, 0x18, 0x40, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62,
+	0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4c, 0x61, 0x62,
+	0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65,
+	0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69,
+	0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x53, 0x6c, 0x6f, 0x74, 0x52, 0x04, 0x73, 0x6c, 0x6f, 0x74,
+	0x12, 0x42, 0x0a, 0x14, 0x62, 0x6c, 0x6f, 0x62, 0x5f, 0x6b, 0x7a, 0x67, 0x5f, 0x63, 0x6f, 0x6d,
+	0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0c, 0x42, 0x10,
+	0x8a, 0xb5, 0x18, 0x04, 0x3f, 0x2c, 0x34, 0x38, 0x92, 0xb5, 0x18, 0x04, 0x34, 0x30, 0x39, 0x36,
+	0x52, 0x12, 0x62, 0x6c, 0x6f, 0x62, 0x4b, 0x7a, 0x67, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d,
+	0x65, 0x6e, 0x74, 0x73, 0x12, 0x25, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x72, 0x6f,
+	0x6f, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x33, 0x32,
+	0x52, 0x09, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x8e, 0x01, 0x0a, 0x1e,
+	0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x50,
+	0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x45, 0x6e, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x12, 0x46,
+	0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2c, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x6e, 0x67, 0x69, 0x6e,
+	0x65, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61,
+	0x79, 0x6c, 0x6f, 0x61, 0x64, 0x45, 0x6e, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x52, 0x07, 0x6d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x24, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74,
+	0x75, 0x72, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x39,
+	0x36, 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x42, 0x3b, 0x5a, 0x39,
+	0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4f, 0x66, 0x66, 0x63, 0x68,
+	0x61, 0x69, 0x6e, 0x4c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x36,
+	0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x2f, 0x76, 0x31,
+	0x3b, 0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x33,
+}
+
+var (
+	file_proto_engine_v1_gloas_proto_rawDescOnce sync.Once
+	file_proto_engine_v1_gloas_proto_rawDescData = file_proto_engine_v1_gloas_proto_rawDesc
+)
+
+func file_proto_engine_v1_gloas_proto_rawDescGZIP() []byte {
+	file_proto_engine_v1_gloas_proto_rawDescOnce.Do(func() {
+		file_proto_engine_v1_gloas_proto_rawDescData = protoimpl.X.CompressGZIP(file_proto_engine_v1_gloas_proto_rawDescData)
+	})
+	return file_proto_engine_v1_gloas_proto_rawDescData
+}
+
+var file_proto_engine_v1_gloas_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_proto_engine_v1_gloas_proto_goTypes = []any{
+	(*ExecutionPayloadEnvelope)(nil),       // 0: ethereum.engine.v1.ExecutionPayloadEnvelope
+	(*SignedExecutionPayloadEnvelope)(nil), // 1: ethereum.engine.v1.SignedExecutionPayloadEnvelope
+	(*ExecutionPayloadDeneb)(nil),          // 2: ethereum.engine.v1.ExecutionPayloadDeneb
+	(*ExecutionRequests)(nil),              // 3: ethereum.engine.v1.ExecutionRequests
+}
+var file_proto_engine_v1_gloas_proto_depIdxs = []int32{
+	2, // 0: ethereum.engine.v1.ExecutionPayloadEnvelope.payload:type_name -> ethereum.engine.v1.ExecutionPayloadDeneb
+	3, // 1: ethereum.engine.v1.ExecutionPayloadEnvelope.execution_requests:type_name -> ethereum.engine.v1.ExecutionRequests
+	0, // 2: ethereum.engine.v1.SignedExecutionPayloadEnvelope.message:type_name -> ethereum.engine.v1.ExecutionPayloadEnvelope
+	3, // [3:3] is the sub-list for method output_type
+	3, // [3:3] is the sub-list for method input_type
+	3, // [3:3] is the sub-list for extension type_name
+	3, // [3:3] is the sub-list for extension extendee
+	0, // [0:3] is the sub-list for field type_name
+}
+
+func init() { file_proto_engine_v1_gloas_proto_init() }
+func file_proto_engine_v1_gloas_proto_init() {
+	if File_proto_engine_v1_gloas_proto != nil {
+		return
+	}
+	file_proto_engine_v1_execution_engine_proto_init()
+	file_proto_engine_v1_electra_proto_init()
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_proto_engine_v1_gloas_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   2,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_proto_engine_v1_gloas_proto_goTypes,
+		DependencyIndexes: file_proto_engine_v1_gloas_proto_depIdxs,
+		MessageInfos:      file_proto_engine_v1_gloas_proto_msgTypes,
+	}.Build()
+	File_proto_engine_v1_gloas_proto = out.File
+	file_proto_engine_v1_gloas_proto_rawDesc = nil
+	file_proto_engine_v1_gloas_proto_goTypes = nil
+	file_proto_engine_v1_gloas_proto_depIdxs = nil
+}

proto/prysm/v1alpha1/cloners.go

@@ -144,17 +144,15 @@ func copySignedExecutionPayloadBid(header *SignedExecutionPayloadBid) *SignedExe
 	}
 	if header.Message != nil {
 		copied.Message = &ExecutionPayloadBid{
-			ParentBlockHash:    bytesutil.SafeCopyBytes(header.Message.ParentBlockHash),
-			ParentBlockRoot:    bytesutil.SafeCopyBytes(header.Message.ParentBlockRoot),
-			BlockHash:          bytesutil.SafeCopyBytes(header.Message.BlockHash),
-			PrevRandao:         bytesutil.SafeCopyBytes(header.Message.PrevRandao),
-			FeeRecipient:       bytesutil.SafeCopyBytes(header.Message.FeeRecipient),
-			GasLimit:           header.Message.GasLimit,
-			BuilderIndex:       header.Message.BuilderIndex,
-			Slot:               header.Message.Slot,
-			Value:              header.Message.Value,
-			ExecutionPayment:   header.Message.ExecutionPayment,
-			BlobKzgCommitments: bytesutil.SafeCopy2dBytes(header.Message.BlobKzgCommitments),
+			ParentBlockHash:        bytesutil.SafeCopyBytes(header.Message.ParentBlockHash),
+			ParentBlockRoot:        bytesutil.SafeCopyBytes(header.Message.ParentBlockRoot),
+			BlockHash:              bytesutil.SafeCopyBytes(header.Message.BlockHash),
+			FeeRecipient:           bytesutil.SafeCopyBytes(header.Message.FeeRecipient),
+			GasLimit:               header.Message.GasLimit,
+			BuilderIndex:           header.Message.BuilderIndex,
+			Slot:                   header.Message.Slot,
+			Value:                  header.Message.Value,
+			BlobKzgCommitmentsRoot: bytesutil.SafeCopyBytes(header.Message.BlobKzgCommitmentsRoot),
 		}
 	}
 	return copied

proto/prysm/v1alpha1/cloners_test.go

@@ -1215,16 +1215,15 @@ func genSignedExecutionPayloadBidGloas() *v1alpha1.SignedExecutionPayloadBid {
 
 func genExecutionPayloadBidGloas() *v1alpha1.ExecutionPayloadBid {
 	return &v1alpha1.ExecutionPayloadBid{
-		ParentBlockHash:    bytes(32),
-		ParentBlockRoot:    bytes(32),
-		BlockHash:          bytes(32),
-		FeeRecipient:       bytes(20),
-		GasLimit:           rand.Uint64(),
-		BuilderIndex:       primitives.BuilderIndex(rand.Uint64()),
-		Slot:               primitives.Slot(rand.Uint64()),
-		Value:              primitives.Gwei(rand.Uint64()),
-		ExecutionPayment:   primitives.Gwei(rand.Uint64()),
-		BlobKzgCommitments: [][]byte{bytes(48)},
+		ParentBlockHash:        bytes(32),
+		ParentBlockRoot:        bytes(32),
+		BlockHash:              bytes(32),
+		FeeRecipient:           bytes(20),
+		GasLimit:               rand.Uint64(),
+		BuilderIndex:           primitives.BuilderIndex(rand.Uint64()),
+		Slot:                   primitives.Slot(rand.Uint64()),
+		Value:                  primitives.Gwei(rand.Uint64()),
+		BlobKzgCommitmentsRoot: bytes(32),
 	}
 }
 

proto/prysm/v1alpha1/gloas.go

@@ -10,17 +10,17 @@ func (header *ExecutionPayloadBid) Copy() *ExecutionPayloadBid {
 		return nil
 	}
 	return &ExecutionPayloadBid{
-		ParentBlockHash:    bytesutil.SafeCopyBytes(header.ParentBlockHash),
-		ParentBlockRoot:    bytesutil.SafeCopyBytes(header.ParentBlockRoot),
-		BlockHash:          bytesutil.SafeCopyBytes(header.BlockHash),
-		PrevRandao:         bytesutil.SafeCopyBytes(header.PrevRandao),
-		FeeRecipient:       bytesutil.SafeCopyBytes(header.FeeRecipient),
-		GasLimit:           header.GasLimit,
-		BuilderIndex:       header.BuilderIndex,
-		Slot:               header.Slot,
-		Value:              header.Value,
-		ExecutionPayment:   header.ExecutionPayment,
-		BlobKzgCommitments: bytesutil.SafeCopy2dBytes(header.BlobKzgCommitments),
+		ParentBlockHash:        bytesutil.SafeCopyBytes(header.ParentBlockHash),
+		ParentBlockRoot:        bytesutil.SafeCopyBytes(header.ParentBlockRoot),
+		BlockHash:              bytesutil.SafeCopyBytes(header.BlockHash),
+		PrevRandao:             bytesutil.SafeCopyBytes(header.PrevRandao),
+		FeeRecipient:           bytesutil.SafeCopyBytes(header.FeeRecipient),
+		GasLimit:               header.GasLimit,
+		BuilderIndex:           header.BuilderIndex,
+		Slot:                   header.Slot,
+		Value:                  header.Value,
+		ExecutionPayment:       header.ExecutionPayment,
+		BlobKzgCommitmentsRoot: bytesutil.SafeCopyBytes(header.BlobKzgCommitmentsRoot),
 	}
 }
 

proto/prysm/v1alpha1/gloas.proto

@@ -33,7 +33,7 @@ option go_package = "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1;eth";
 //     slot: Slot
 //     value: Gwei
 //     execution_payment: Gwei
-//     blob_kzg_commitments: List[KZGCommitment, MAX_BLOB_COMMITMENTS_PER_BLOCK]
+//     blob_kzg_commitments_root: Root
 message ExecutionPayloadBid {
   bytes parent_block_hash = 1 [ (ethereum.eth.ext.ssz_size) = "32" ];
   bytes parent_block_root = 2 [ (ethereum.eth.ext.ssz_size) = "32" ];
@@ -56,10 +56,7 @@ message ExecutionPayloadBid {
     (ethereum.eth.ext.cast_type) =
         "github.com/OffchainLabs/prysm/v7/consensus-types/primitives.Gwei"
   ];
-  repeated bytes blob_kzg_commitments = 11 [
-    (ethereum.eth.ext.ssz_size) = "?,48",
-    (ethereum.eth.ext.ssz_max) = "max_blob_commitments.size"
-  ];
+  bytes blob_kzg_commitments_root = 11 [ (ethereum.eth.ext.ssz_size) = "32" ];
 }
 
 // SignedExecutionPayloadBid wraps an execution payload bid with a signature.
@@ -369,6 +366,7 @@ message BuilderPendingWithdrawal {
 // class DataColumnSidecar(Container):
 //     index: ColumnIndex
 //     column: List[Cell, MAX_BLOB_COMMITMENTS_PER_BLOCK]
+//     kzg_commitents: List[KZGCommitment, MAX_BLOB_COMMITMENTS_PER_BLOCK]
 //     kzg_proofs: List[KZGProof, MAX_BLOB_COMMITMENTS_PER_BLOCK]
 //     slot: Slot
 //     beacon_block_root: Root
@@ -378,6 +376,10 @@ message DataColumnSidecarGloas {
     (ethereum.eth.ext.ssz_size) = "?,bytes_per_cell.size",
     (ethereum.eth.ext.ssz_max) = "max_blob_commitments.size"
   ];
+  repeated bytes kzg_commitments = 3 [
+    (ethereum.eth.ext.ssz_size) = "?,48",
+    (ethereum.eth.ext.ssz_max) = "max_blob_commitments.size"
+  ];
   repeated bytes kzg_proofs = 4 [
     (ethereum.eth.ext.ssz_size) = "?,48",
     (ethereum.eth.ext.ssz_max) = "max_blob_commitments.size"
@@ -400,6 +402,7 @@ message DataColumnSidecarGloas {
 //     builder_index: BuilderIndex
 //     beacon_block_root: Root
 //     slot: Slot
+//     blob_kzg_commitments: List[KZGCommitment, MAX_BLOB_COMMITMENTS_PER_BLOCK]
 //     state_root: Root
 message ExecutionPayloadEnvelope {
   ethereum.engine.v1.ExecutionPayloadDeneb payload = 1;
@@ -412,7 +415,11 @@ message ExecutionPayloadEnvelope {
     (ethereum.eth.ext.cast_type) =
         "github.com/OffchainLabs/prysm/v7/consensus-types/primitives.Slot"
   ];
-  bytes state_root = 6 [ (ethereum.eth.ext.ssz_size) = "32" ];
+  repeated bytes blob_kzg_commitments = 6 [
+    (ethereum.eth.ext.ssz_size) = "?,48",
+    (ethereum.eth.ext.ssz_max) = "max_blob_commitments.size"
+  ];
+  bytes state_root = 7 [ (ethereum.eth.ext.ssz_size) = "32" ];
 }
 
 // SignedExecutionPayloadEnvelope wraps an execution payload envelope with a signature.