Merge branch 'develop' into calculate-post-state

This PR refactors `ProcessExecutionPayload` with `ApplyExecutionPayload`
so caller can use Apply method to calculate post state root. Note that
validations are not required for Apply function. We really need the
state mutation lines that's:
```
1. Ensure latest_block_header.state_root is set (if zero, set it to the pre‑payload HashTreeRoot)...
2. processExecutionRequests()
3. QueueBuilderPayment()
4. SetExecutionPayloadAvailability(state.Slot(), true)
5. SetLatestBlockHash(payload.BlockHash())
```
I decided to keep them there because a. it's cheap b. it makes refactor
cleaner to reason c. API/caller may want to validate envelope and bid
consistency (ex: beacon api has option to validate consensus)

.ethspecify.yml

@@ -1,25 +1,39 @@
-version: v1.7.0-alpha.1
+version: v1.7.0-alpha.2
 style: full
 
 specrefs:
-  search_root: ..
+  search_root: .
+  auto_standardize_names: true
+  auto_add_missing_entries: true
+  require_exceptions_have_fork: true
+
   files:
-    - configs.yml
-    - constants.yml
-    - containers.yml
-    - dataclasses.yml
-    - functions.yml
-    - presets.yml
+    - specrefs/configs.yml
+    - specrefs/constants.yml
+    - specrefs/containers.yml
+    - specrefs/dataclasses.yml
+    - specrefs/functions.yml
+    - specrefs/presets.yml
 
 exceptions:
   presets:
-    # Not implemented: gloas (future fork)
+    # gloas
     - BUILDER_PENDING_WITHDRAWALS_LIMIT#gloas
     - MAX_PAYLOAD_ATTESTATIONS#gloas
     - PTC_SIZE#gloas
 
   constants:
-    # Constants in the KZG library
+    # phase0
+    - BASIS_POINTS#phase0
+    - ENDIANNESS#phase0
+    - MAX_CONCURRENT_REQUESTS#phase0
+    - UINT64_MAX#phase0
+    - UINT64_MAX_SQRT#phase0
+    # altair
+    - PARTICIPATION_FLAG_WEIGHTS#altair
+    # bellatrix
+    - SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY#bellatrix
+    # deneb
     - BLS_MODULUS#deneb
     - BYTES_PER_COMMITMENT#deneb
     - BYTES_PER_FIELD_ELEMENT#deneb
@@ -33,18 +47,9 @@ exceptions:
     - PRIMITIVE_ROOT_OF_UNITY#deneb
     - RANDOM_CHALLENGE_KZG_BATCH_DOMAIN#deneb
     - RANDOM_CHALLENGE_KZG_CELL_BATCH_DOMAIN#fulu
-
-    # Not implemented
-    - BASIS_POINTS#phase0
-    - ENDIANNESS#phase0
-    - MAX_CONCURRENT_REQUESTS#phase0
-    - PARTICIPATION_FLAG_WEIGHTS#altair
-    - SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY#bellatrix
+    # fulu
     - UINT256_MAX#fulu
-    - UINT64_MAX#phase0
-    - UINT64_MAX_SQRT#phase0
-
-    # Not implemented: gloas (future fork)
+    # gloas
     - BUILDER_PAYMENT_THRESHOLD_DENOMINATOR#gloas
     - BUILDER_PAYMENT_THRESHOLD_NUMERATOR#gloas
     - BUILDER_WITHDRAWAL_PREFIX#gloas
@@ -61,61 +66,62 @@ exceptions:
     - PTC_TIMELINESS_INDEX#gloas
 
   configs:
-    # Not implemented: gloas (future fork)
+    # gloas
     - AGGREGATE_DUE_BPS_GLOAS#gloas
     - ATTESTATION_DUE_BPS_GLOAS#gloas
     - CONTRIBUTION_DUE_BPS_GLOAS#gloas
     - GLOAS_FORK_EPOCH#gloas
     - GLOAS_FORK_VERSION#gloas
     - MAX_REQUEST_PAYLOADS#gloas
+    - MIN_BUILDER_WITHDRAWABILITY_DELAY#gloas
     - PAYLOAD_ATTESTATION_DUE_BPS#gloas
     - SYNC_MESSAGE_DUE_BPS_GLOAS#gloas
-    - MIN_BUILDER_WITHDRAWABILITY_DELAY#gloas
 
   ssz_objects:
-    # Not implemented
+    # phase0
     - Eth1Block#phase0
-    - MatrixEntry#fulu
-
-    # Not implemented: capella
+    # capella
     - LightClientBootstrap#capella
     - LightClientFinalityUpdate#capella
     - LightClientOptimisticUpdate#capella
     - LightClientUpdate#capella
-
-    # Not implemented: gloas (future fork)
+    # fulu
+    - MatrixEntry#fulu
+    # gloas
     - BeaconBlockBody#gloas
     - BeaconState#gloas
+    - Builder#gloas
     - BuilderPendingPayment#gloas
     - BuilderPendingWithdrawal#gloas
     - DataColumnSidecar#gloas
-    - ExecutionPayloadEnvelope#gloas
     - ExecutionPayloadBid#gloas
+    - ExecutionPayloadEnvelope#gloas
     - ForkChoiceNode#gloas
     - IndexedPayloadAttestation#gloas
     - PayloadAttestation#gloas
     - PayloadAttestationData#gloas
     - PayloadAttestationMessage#gloas
-    - SignedExecutionPayloadEnvelope#gloas
-    - SignedExecutionPayloadBid#gloas
-    - Builder#gloas
     - ProposerPreferences#gloas
+    - SignedExecutionPayloadBid#gloas
+    - SignedExecutionPayloadEnvelope#gloas
     - SignedProposerPreferences#gloas
 
   dataclasses:
-    # Not implemented
-    - BlobParameters#fulu
-    - ExpectedWithdrawals#capella
-    - ExpectedWithdrawals#electra
+    # phase0
     - LatestMessage#phase0
-    - LightClientStore#altair
-    - OptimisticStore#bellatrix
     - Store#phase0
-
-    # Not implemented: capella
+    # altair
+    - LightClientStore#altair
+    # bellatrix
+    - OptimisticStore#bellatrix
+    # capella
+    - ExpectedWithdrawals#capella
     - LightClientStore#capella
-
-    # Not implemented: gloas (future fork)
+    # electra
+    - ExpectedWithdrawals#electra
+    # fulu
+    - BlobParameters#fulu
+    # gloas
     - ExpectedWithdrawals#gloas
     - LatestMessage#gloas
     - Store#gloas
@@ -140,7 +146,6 @@ 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
@@ -175,7 +180,12 @@ exceptions:
     - verify_cell_kzg_proof_batch#fulu
     - verify_cell_kzg_proof_batch_impl#fulu
 
-    # Not implemented: phase0
+    # phase0
+    - update_proposer_boost_root#phase0
+    - is_proposer_equivocation#phase0
+    - record_block_timeliness#phase0
+    - compute_proposer_score#phase0
+    - get_attestation_score#phase0
     - calculate_committee_fraction#phase0
     - compute_fork_version#phase0
     - compute_pulled_up_tip#phase0
@@ -221,8 +231,7 @@ exceptions:
     - validate_on_attestation#phase0
     - validate_target_epoch_against_current_time#phase0
     - xor#phase0
-
-    # Not implemented: altair
+    # altair
     - compute_merkle_proof#altair
     - compute_sync_committee_period_at_slot#altair
     - get_contribution_and_proof#altair
@@ -244,27 +253,29 @@ exceptions:
     - process_sync_committee_contributions#altair
     - set_or_append_list#altair
     - validate_light_client_update#altair
-
-    # Not implemented: bellatrix
+    # bellatrix
     - get_execution_payload#bellatrix
     - is_merge_transition_block#bellatrix
     - is_optimistic_candidate_block#bellatrix
     - latest_verified_ancestor#bellatrix
     - prepare_execution_payload#bellatrix
-
-    # Not implemented: capella
+    # capella
+    - apply_withdrawals#capella
+    - get_balance_after_withdrawals#capella
     - get_lc_execution_root#capella
+    - get_validators_sweep_withdrawals#capella
     - is_valid_light_client_header#capella
     - prepare_execution_payload#capella
     - process_epoch#capella
+    - update_next_withdrawal_index#capella
+    - update_next_withdrawal_validator_index#capella
     - upgrade_lc_bootstrap_to_capella#capella
     - upgrade_lc_finality_update_to_capella#capella
     - upgrade_lc_header_to_capella#capella
     - upgrade_lc_optimistic_update_to_capella#capella
     - upgrade_lc_store_to_capella#capella
     - upgrade_lc_update_to_capella#capella
-
-    # Not implemented: deneb
+    # deneb
     - get_lc_execution_root#deneb
     - is_valid_light_client_header#deneb
     - prepare_execution_payload#deneb
@@ -274,33 +285,34 @@ exceptions:
     - upgrade_lc_optimistic_update_to_deneb#deneb
     - upgrade_lc_store_to_deneb#deneb
     - upgrade_lc_update_to_deneb#deneb
-
-    # Not implemented: electra
+    # electra
     - compute_weak_subjectivity_period#electra
     - current_sync_committee_gindex_at_slot#electra
     - finalized_root_gindex_at_slot#electra
     - get_eth1_vote#electra
     - get_lc_execution_root#electra
+    - get_pending_partial_withdrawals#electra
+    - get_validators_sweep_withdrawals#electra
     - is_compounding_withdrawal_credential#electra
+    - is_eligible_for_partial_withdrawals#electra
     - is_within_weak_subjectivity_period#electra
     - next_sync_committee_gindex_at_slot#electra
     - normalize_merkle_branch#electra
     - prepare_execution_payload#electra
+    - update_pending_partial_withdrawals#electra
     - upgrade_lc_bootstrap_to_electra#electra
     - upgrade_lc_finality_update_to_electra#electra
     - upgrade_lc_header_to_electra#electra
     - upgrade_lc_optimistic_update_to_electra#electra
     - upgrade_lc_store_to_electra#electra
     - upgrade_lc_update_to_electra#electra
-
-    # Not implemented: fulu
+    # fulu
     - compute_matrix#fulu
     - get_blob_parameters#fulu
     - get_data_column_sidecars_from_block#fulu
     - get_data_column_sidecars_from_column_sidecar#fulu
     - recover_matrix#fulu
-
-    # Not implemented: gloas (future fork)
+    # gloas
     - compute_balance_weighted_acceptance#gloas
     - compute_balance_weighted_selection#gloas
     - compute_fork_version#gloas
@@ -368,49 +380,42 @@ exceptions:
     - verify_execution_payload_bid_signature#gloas
     - add_builder_to_registry#gloas
     - apply_deposit_for_builder#gloas
-    - apply_withdrawals#capella
     - apply_withdrawals#gloas
     - can_builder_cover_bid#gloas
-    - compute_proposer_score#phase0
     - 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
     - get_pending_balance_to_withdraw_for_builder#gloas
-    - get_pending_partial_withdrawals#electra
     - get_proposer_preferences_signature#gloas
     - get_upcoming_proposal_slots#gloas
-    - get_validators_sweep_withdrawals#capella
-    - get_validators_sweep_withdrawals#electra
     - 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_proposer_equivocation#phase0
     - 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
-    - update_next_withdrawal_index#capella
-    - update_next_withdrawal_validator_index#capella
     - update_payload_expected_withdrawals#gloas
-    - update_pending_partial_withdrawals#electra
     - update_proposer_boost_root#gloas
-    - update_proposer_boost_root#phase0
 
   presets:
+    # gloas
     - BUILDER_PENDING_WITHDRAWALS_LIMIT#gloas
     - BUILDER_REGISTRY_LIMIT#gloas
     - MAX_BUILDERS_PER_WITHDRAWALS_SWEEP#gloas

.github/workflows/check-specrefs.yml

@@ -12,11 +12,11 @@ jobs:
     - name: Check version consistency
       run: |
         WORKSPACE_VERSION=$(grep 'consensus_spec_version = ' WORKSPACE | sed 's/.*"\(.*\)"/\1/')
-        ETHSPECIFY_VERSION=$(grep '^version:' specrefs/.ethspecify.yml | sed 's/version: //')
+        ETHSPECIFY_VERSION=$(grep '^version:' .ethspecify.yml | sed 's/version: //')
         if [ "$WORKSPACE_VERSION" != "$ETHSPECIFY_VERSION" ]; then
           echo "Version mismatch between WORKSPACE and ethspecify"
           echo "  WORKSPACE: $WORKSPACE_VERSION"
-          echo "  specrefs/.ethspecify.yml: $ETHSPECIFY_VERSION"
+          echo "  .ethspecify.yml: $ETHSPECIFY_VERSION"
           exit 1
         else
           echo "Versions match: $WORKSPACE_VERSION"
@@ -26,7 +26,7 @@ jobs:
       run: python3 -mpip install ethspecify
 
     - name: Update spec references
-      run: ethspecify process --path=specrefs
+      run: ethspecify
 
     - name: Check for differences
       run: |
@@ -40,4 +40,4 @@ jobs:
         fi
 
     - name: Check spec references
-      run: ethspecify check --path=specrefs
+      run: ethspecify check

.github/workflows/go.yml

@@ -2,7 +2,7 @@ name: Go
 
 on:
   push:
-    branches: [ master ]
+    branches: [ master, develop ]
   pull_request:
     branches: [ '*' ]
   merge_group:

.golangci.yml

@@ -33,9 +33,8 @@ formatters:
     generated: lax
     paths:
       - validator/web/site_data.go
-      - .*_test.go
       - proto
       - tools/analyzers
       - third_party$
       - builtin$
-      - examples$
+      - examples$

WORKSPACE

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

@@ -0,0 +1,19 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "fallback.go",
+        "log.go",
+    ],
+    importpath = "github.com/OffchainLabs/prysm/v7/api/fallback",
+    visibility = ["//visibility:public"],
+    deps = ["@com_github_sirupsen_logrus//:go_default_library"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["fallback_test.go"],
+    embed = [":go_default_library"],
+    deps = ["//testing/assert:go_default_library"],
+)

api/fallback/fallback.go

@@ -0,0 +1,66 @@
+package fallback
+
+import (
+	"context"
+
+	"github.com/sirupsen/logrus"
+)
+
+// HostProvider is the subset of connection-provider methods that EnsureReady
+// needs. Both grpc.GrpcConnectionProvider and rest.RestConnectionProvider
+// satisfy this interface.
+type HostProvider interface {
+	Hosts() []string
+	CurrentHost() string
+	SwitchHost(index int) error
+}
+
+// ReadyChecker can report whether the current endpoint is ready.
+// iface.NodeClient satisfies this implicitly.
+type ReadyChecker interface {
+	IsReady(ctx context.Context) bool
+}
+
+// EnsureReady iterates through the configured hosts and returns true as soon as
+// one responds as ready. It starts from the provider's current host and wraps
+// around using modular arithmetic, performing failover when a host is not ready.
+func EnsureReady(ctx context.Context, provider HostProvider, checker ReadyChecker) bool {
+	hosts := provider.Hosts()
+	numHosts := len(hosts)
+	startingHost := provider.CurrentHost()
+	var attemptedHosts []string
+
+	// Find current index
+	currentIdx := 0
+	for i, h := range hosts {
+		if h == startingHost {
+			currentIdx = i
+			break
+		}
+	}
+
+	for i := range numHosts {
+		if checker.IsReady(ctx) {
+			if len(attemptedHosts) > 0 {
+				log.WithFields(logrus.Fields{
+					"previous": startingHost,
+					"current":  provider.CurrentHost(),
+					"tried":    attemptedHosts,
+				}).Info("Switched to responsive beacon node")
+			}
+			return true
+		}
+		attemptedHosts = append(attemptedHosts, provider.CurrentHost())
+
+		// Try next host if not the last iteration
+		if i < numHosts-1 {
+			nextIdx := (currentIdx + i + 1) % numHosts
+			if err := provider.SwitchHost(nextIdx); err != nil {
+				log.WithError(err).Error("Failed to switch host")
+			}
+		}
+	}
+
+	log.WithField("tried", attemptedHosts).Warn("No responsive beacon node found")
+	return false
+}

api/fallback/fallback_test.go

@@ -0,0 +1,94 @@
+package fallback
+
+import (
+	"context"
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/testing/assert"
+)
+
+// mockHostProvider is a minimal HostProvider for unit tests.
+type mockHostProvider struct {
+	hosts     []string
+	hostIndex int
+}
+
+func (m *mockHostProvider) Hosts() []string { return m.hosts }
+func (m *mockHostProvider) CurrentHost() string {
+	return m.hosts[m.hostIndex%len(m.hosts)]
+}
+func (m *mockHostProvider) SwitchHost(index int) error { m.hostIndex = index; return nil }
+
+// mockReadyChecker records per-call IsReady results in sequence.
+type mockReadyChecker struct {
+	results []bool
+	idx     int
+}
+
+func (m *mockReadyChecker) IsReady(_ context.Context) bool {
+	if m.idx >= len(m.results) {
+		return false
+	}
+	r := m.results[m.idx]
+	m.idx++
+	return r
+}
+
+func TestEnsureReady_SingleHostReady(t *testing.T) {
+	provider := &mockHostProvider{hosts: []string{"http://host1:3500"}, hostIndex: 0}
+	checker := &mockReadyChecker{results: []bool{true}}
+	assert.Equal(t, true, EnsureReady(t.Context(), provider, checker))
+	assert.Equal(t, 0, provider.hostIndex)
+}
+
+func TestEnsureReady_SingleHostNotReady(t *testing.T) {
+	provider := &mockHostProvider{hosts: []string{"http://host1:3500"}, hostIndex: 0}
+	checker := &mockReadyChecker{results: []bool{false}}
+	assert.Equal(t, false, EnsureReady(t.Context(), provider, checker))
+}
+
+func TestEnsureReady_SingleHostError(t *testing.T) {
+	provider := &mockHostProvider{hosts: []string{"http://host1:3500"}, hostIndex: 0}
+	checker := &mockReadyChecker{results: []bool{false}}
+	assert.Equal(t, false, EnsureReady(t.Context(), provider, checker))
+}
+
+func TestEnsureReady_MultipleHostsFirstReady(t *testing.T) {
+	provider := &mockHostProvider{
+		hosts:     []string{"http://host1:3500", "http://host2:3500"},
+		hostIndex: 0,
+	}
+	checker := &mockReadyChecker{results: []bool{true}}
+	assert.Equal(t, true, EnsureReady(t.Context(), provider, checker))
+	assert.Equal(t, 0, provider.hostIndex)
+}
+
+func TestEnsureReady_MultipleHostsFailoverToSecond(t *testing.T) {
+	provider := &mockHostProvider{
+		hosts:     []string{"http://host1:3500", "http://host2:3500"},
+		hostIndex: 0,
+	}
+	checker := &mockReadyChecker{results: []bool{false, true}}
+	assert.Equal(t, true, EnsureReady(t.Context(), provider, checker))
+	assert.Equal(t, 1, provider.hostIndex)
+}
+
+func TestEnsureReady_MultipleHostsNoneReady(t *testing.T) {
+	provider := &mockHostProvider{
+		hosts:     []string{"http://host1:3500", "http://host2:3500", "http://host3:3500"},
+		hostIndex: 0,
+	}
+	checker := &mockReadyChecker{results: []bool{false, false, false}}
+	assert.Equal(t, false, EnsureReady(t.Context(), provider, checker))
+}
+
+func TestEnsureReady_WrapAroundFromNonZeroIndex(t *testing.T) {
+	provider := &mockHostProvider{
+		hosts:     []string{"http://host0:3500", "http://host1:3500", "http://host2:3500"},
+		hostIndex: 1,
+	}
+	// host1 (start) fails, host2 fails, host0 succeeds
+	checker := &mockReadyChecker{results: []bool{false, false, true}}
+	assert.Equal(t, true, EnsureReady(t.Context(), provider, checker))
+	assert.Equal(t, 0, provider.hostIndex)
+}

api/fallback/log.go

@@ -0,0 +1,9 @@
+// Code generated by hack/gen-logs.sh; DO NOT EDIT.
+// This file is created and regenerated automatically. Anything added here might get removed.
+package fallback
+
+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", "api/fallback")

api/grpc/BUILD.bazel

@@ -3,13 +3,16 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
+        "grpc_connection_provider.go",
         "grpcutils.go",
         "log.go",
+        "mock_grpc_provider.go",
         "parameters.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/api/grpc",
     visibility = ["//visibility:public"],
     deps = [
+        "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@org_golang_google_grpc//:go_default_library",
         "@org_golang_google_grpc//metadata:go_default_library",
@@ -18,12 +21,17 @@ go_library(
 
 go_test(
     name = "go_default_test",
-    srcs = ["grpcutils_test.go"],
+    srcs = [
+        "grpc_connection_provider_test.go",
+        "grpcutils_test.go",
+    ],
     embed = [":go_default_library"],
     deps = [
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
+        "@org_golang_google_grpc//:go_default_library",
+        "@org_golang_google_grpc//credentials/insecure:go_default_library",
         "@org_golang_google_grpc//metadata:go_default_library",
     ],
 )

api/grpc/grpc_connection_provider.go

@@ -0,0 +1,186 @@
+package grpc
+
+import (
+	"context"
+	"strings"
+	"sync"
+
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	"google.golang.org/grpc"
+)
+
+// GrpcConnectionProvider manages gRPC connections for failover support.
+// It allows switching between different beacon node endpoints when the current one becomes unavailable.
+// Only one connection is maintained at a time - when switching hosts, the old connection is closed.
+type GrpcConnectionProvider interface {
+	// CurrentConn returns the currently active gRPC connection.
+	// The connection is created lazily on first call.
+	// Returns nil if the provider has been closed.
+	CurrentConn() *grpc.ClientConn
+	// CurrentHost returns the address of the currently active endpoint.
+	CurrentHost() string
+	// Hosts returns all configured endpoint addresses.
+	Hosts() []string
+	// SwitchHost switches to the endpoint at the given index.
+	// The new connection is created lazily on next CurrentConn() call.
+	SwitchHost(index int) error
+	// ConnectionCounter returns a monotonically increasing counter that increments
+	// each time SwitchHost changes the active endpoint. This allows consumers to
+	// detect connection changes even when the host string returns to a previous value
+	// (e.g., host0 → host1 → host0).
+	ConnectionCounter() uint64
+	// Close closes the current connection.
+	Close()
+}
+
+type grpcConnectionProvider struct {
+	// Immutable after construction - no lock needed for reads
+	endpoints []string
+	ctx       context.Context
+	dialOpts  []grpc.DialOption
+
+	// Current connection state (protected by mutex)
+	currentIndex uint64
+	conn         *grpc.ClientConn
+	connCounter  uint64
+
+	mu     sync.Mutex
+	closed bool
+}
+
+// NewGrpcConnectionProvider creates a new connection provider that manages gRPC connections.
+// The endpoint parameter can be a comma-separated list of addresses (e.g., "host1:4000,host2:4000").
+// Only one connection is maintained at a time, created lazily on first use.
+func NewGrpcConnectionProvider(
+	ctx context.Context,
+	endpoint string,
+	dialOpts []grpc.DialOption,
+) (GrpcConnectionProvider, error) {
+	endpoints := parseEndpoints(endpoint)
+	if len(endpoints) == 0 {
+		return nil, errors.New("no gRPC endpoints provided")
+	}
+
+	log.WithFields(logrus.Fields{
+		"endpoints": endpoints,
+		"count":     len(endpoints),
+	}).Info("Initialized gRPC connection provider")
+
+	return &grpcConnectionProvider{
+		endpoints: endpoints,
+		ctx:       ctx,
+		dialOpts:  dialOpts,
+	}, nil
+}
+
+// parseEndpoints splits a comma-separated endpoint string into individual endpoints.
+func parseEndpoints(endpoint string) []string {
+	if endpoint == "" {
+		return nil
+	}
+	endpoints := make([]string, 0, 1)
+	for p := range strings.SplitSeq(endpoint, ",") {
+		if p = strings.TrimSpace(p); p != "" {
+			endpoints = append(endpoints, p)
+		}
+	}
+	return endpoints
+}
+
+func (p *grpcConnectionProvider) CurrentConn() *grpc.ClientConn {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if p.closed {
+		return nil
+	}
+
+	// Return existing connection if available
+	if p.conn != nil {
+		return p.conn
+	}
+
+	// Create connection lazily
+	ep := p.endpoints[p.currentIndex]
+	conn, err := grpc.DialContext(p.ctx, ep, p.dialOpts...)
+	if err != nil {
+		log.WithError(err).WithField("endpoint", ep).Error("Failed to create gRPC connection")
+		return nil
+	}
+
+	p.conn = conn
+	log.WithField("endpoint", ep).Debug("Created gRPC connection")
+	return conn
+}
+
+func (p *grpcConnectionProvider) CurrentHost() string {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	return p.endpoints[p.currentIndex]
+}
+
+func (p *grpcConnectionProvider) Hosts() []string {
+	// Return a copy to maintain immutability
+	hosts := make([]string, len(p.endpoints))
+	copy(hosts, p.endpoints)
+	return hosts
+}
+
+func (p *grpcConnectionProvider) SwitchHost(index int) error {
+	if index < 0 || index >= len(p.endpoints) {
+		return errors.Errorf("invalid host index %d, must be between 0 and %d", index, len(p.endpoints)-1)
+	}
+
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if uint64(index) == p.currentIndex {
+		return nil // Already on this host
+	}
+
+	oldHost := p.endpoints[p.currentIndex]
+	oldConn := p.conn
+
+	p.conn = nil // Clear immediately - new connection created lazily
+	p.currentIndex = uint64(index)
+	p.connCounter++
+
+	// Close old connection asynchronously to avoid blocking the caller
+	if oldConn != nil {
+		go func() {
+			if err := oldConn.Close(); err != nil {
+				log.WithError(err).WithField("endpoint", oldHost).Debug("Failed to close previous connection")
+			}
+		}()
+	}
+
+	log.WithFields(logrus.Fields{
+		"previousHost": oldHost,
+		"newHost":      p.endpoints[index],
+	}).Debug("Switched gRPC endpoint")
+	return nil
+}
+
+func (p *grpcConnectionProvider) ConnectionCounter() uint64 {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	return p.connCounter
+}
+
+func (p *grpcConnectionProvider) Close() {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if p.closed {
+		return
+	}
+	p.closed = true
+
+	if p.conn != nil {
+		if err := p.conn.Close(); err != nil {
+			log.WithError(err).WithField("endpoint", p.endpoints[p.currentIndex]).Debug("Failed to close gRPC connection")
+		}
+		p.conn = nil
+	}
+}

api/grpc/grpc_connection_provider_test.go

@@ -0,0 +1,207 @@
+package grpc
+
+import (
+	"context"
+	"net"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/testing/assert"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+)
+
+func TestParseEndpoints(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected []string
+	}{
+		{"single endpoint", "localhost:4000", []string{"localhost:4000"}},
+		{"multiple endpoints", "host1:4000,host2:4000,host3:4000", []string{"host1:4000", "host2:4000", "host3:4000"}},
+		{"endpoints with spaces", "host1:4000, host2:4000 , host3:4000", []string{"host1:4000", "host2:4000", "host3:4000"}},
+		{"empty string", "", nil},
+		{"only commas", ",,,", []string{}},
+		{"trailing comma", "host1:4000,host2:4000,", []string{"host1:4000", "host2:4000"}},
+		{"leading comma", ",host1:4000,host2:4000", []string{"host1:4000", "host2:4000"}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := parseEndpoints(tt.input)
+			if !reflect.DeepEqual(tt.expected, got) {
+				t.Errorf("parseEndpoints(%q) = %v, want %v", tt.input, got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestNewGrpcConnectionProvider_Errors(t *testing.T) {
+	t.Run("no endpoints", func(t *testing.T) {
+		dialOpts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}
+		_, err := NewGrpcConnectionProvider(context.Background(), "", dialOpts)
+		require.ErrorContains(t, "no gRPC endpoints provided", err)
+	})
+}
+
+func TestGrpcConnectionProvider_LazyConnection(t *testing.T) {
+	// Start only one server but configure provider with two endpoints
+	lis, err := net.Listen("tcp", "127.0.0.1:0")
+	require.NoError(t, err)
+	server := grpc.NewServer()
+	go func() { _ = server.Serve(lis) }()
+	defer server.Stop()
+
+	validAddr := lis.Addr().String()
+	invalidAddr := "127.0.0.1:1" // Port 1 is unlikely to be listening
+
+	// Provider should succeed even though second endpoint is invalid (lazy connections)
+	endpoint := validAddr + "," + invalidAddr
+	ctx := context.Background()
+	dialOpts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}
+	provider, err := NewGrpcConnectionProvider(ctx, endpoint, dialOpts)
+	require.NoError(t, err, "Provider creation should succeed with lazy connections")
+	defer func() { provider.Close() }()
+
+	// First endpoint should work
+	conn := provider.CurrentConn()
+	assert.NotNil(t, conn, "First connection should be created lazily")
+}
+
+func TestGrpcConnectionProvider_SingleConnectionModel(t *testing.T) {
+	// Create provider with 3 endpoints
+	var addrs []string
+	var servers []*grpc.Server
+
+	for range 3 {
+		lis, err := net.Listen("tcp", "127.0.0.1:0")
+		require.NoError(t, err)
+		server := grpc.NewServer()
+		go func() { _ = server.Serve(lis) }()
+		addrs = append(addrs, lis.Addr().String())
+		servers = append(servers, server)
+	}
+	defer func() {
+		for _, s := range servers {
+			s.Stop()
+		}
+	}()
+
+	endpoint := strings.Join(addrs, ",")
+	ctx := context.Background()
+	dialOpts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}
+	provider, err := NewGrpcConnectionProvider(ctx, endpoint, dialOpts)
+	require.NoError(t, err)
+	defer func() { provider.Close() }()
+
+	// Access the internal state to verify single connection behavior
+	p := provider.(*grpcConnectionProvider)
+
+	// Initially no connection
+	p.mu.Lock()
+	assert.Equal(t, (*grpc.ClientConn)(nil), p.conn, "Connection should be nil before access")
+	p.mu.Unlock()
+
+	// Access connection - should create one
+	conn0 := provider.CurrentConn()
+	assert.NotNil(t, conn0)
+
+	p.mu.Lock()
+	assert.NotNil(t, p.conn, "Connection should be created after CurrentConn()")
+	firstConn := p.conn
+	p.mu.Unlock()
+
+	// Call CurrentConn again - should return same connection
+	conn0Again := provider.CurrentConn()
+	assert.Equal(t, conn0, conn0Again, "Should return same connection")
+
+	// Switch to different host - old connection should be closed, new one created lazily
+	require.NoError(t, provider.SwitchHost(1))
+
+	p.mu.Lock()
+	assert.Equal(t, (*grpc.ClientConn)(nil), p.conn, "Connection should be nil after SwitchHost (lazy)")
+	p.mu.Unlock()
+
+	// Get new connection
+	conn1 := provider.CurrentConn()
+	assert.NotNil(t, conn1)
+	assert.NotEqual(t, firstConn, conn1, "Should be a different connection after switching hosts")
+}
+
+// testProvider creates a provider with n test servers and returns cleanup function.
+func testProvider(t *testing.T, n int) (GrpcConnectionProvider, []string, func()) {
+	var addrs []string
+	var cleanups []func()
+
+	for range n {
+		lis, err := net.Listen("tcp", "127.0.0.1:0")
+		require.NoError(t, err)
+		server := grpc.NewServer()
+		go func() { _ = server.Serve(lis) }()
+		addrs = append(addrs, lis.Addr().String())
+		cleanups = append(cleanups, server.Stop)
+	}
+
+	endpoint := strings.Join(addrs, ",")
+
+	ctx := context.Background()
+	dialOpts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}
+	provider, err := NewGrpcConnectionProvider(ctx, endpoint, dialOpts)
+	require.NoError(t, err)
+
+	cleanup := func() {
+		provider.Close()
+		for _, c := range cleanups {
+			c()
+		}
+	}
+	return provider, addrs, cleanup
+}
+
+func TestGrpcConnectionProvider(t *testing.T) {
+	provider, addrs, cleanup := testProvider(t, 3)
+	defer cleanup()
+
+	t.Run("initial state", func(t *testing.T) {
+		assert.Equal(t, 3, len(provider.Hosts()))
+		assert.Equal(t, addrs[0], provider.CurrentHost())
+		assert.NotNil(t, provider.CurrentConn())
+	})
+
+	t.Run("SwitchHost", func(t *testing.T) {
+		require.NoError(t, provider.SwitchHost(1))
+		assert.Equal(t, addrs[1], provider.CurrentHost())
+		assert.NotNil(t, provider.CurrentConn()) // New connection created lazily
+		require.NoError(t, provider.SwitchHost(0))
+		assert.Equal(t, addrs[0], provider.CurrentHost())
+		require.ErrorContains(t, "invalid host index", provider.SwitchHost(-1))
+		require.ErrorContains(t, "invalid host index", provider.SwitchHost(3))
+	})
+
+	t.Run("SwitchHost circular", func(t *testing.T) {
+		// Test round-robin style switching using SwitchHost with manual index
+		indices := []int{1, 2, 0, 1} // Simulate circular switching
+		for i, idx := range indices {
+			require.NoError(t, provider.SwitchHost(idx))
+			assert.Equal(t, addrs[idx], provider.CurrentHost(), "iteration %d", i)
+		}
+	})
+
+	t.Run("Hosts returns copy", func(t *testing.T) {
+		hosts := provider.Hosts()
+		original := hosts[0]
+		hosts[0] = "modified"
+		assert.Equal(t, original, provider.Hosts()[0])
+	})
+}
+
+func TestGrpcConnectionProvider_Close(t *testing.T) {
+	provider, _, cleanup := testProvider(t, 1)
+	defer cleanup()
+
+	assert.NotNil(t, provider.CurrentConn())
+	provider.Close()
+	assert.Equal(t, (*grpc.ClientConn)(nil), provider.CurrentConn())
+	provider.Close() // Double close is safe
+}

api/grpc/mock_grpc_provider.go

@@ -0,0 +1,27 @@
+package grpc
+
+import "google.golang.org/grpc"
+
+// MockGrpcProvider implements GrpcConnectionProvider for testing.
+type MockGrpcProvider struct {
+	MockConn     *grpc.ClientConn
+	MockHosts    []string
+	CurrentIndex int
+	ConnCounter  uint64
+}
+
+func (m *MockGrpcProvider) CurrentConn() *grpc.ClientConn { return m.MockConn }
+func (m *MockGrpcProvider) CurrentHost() string {
+	if len(m.MockHosts) > 0 {
+		return m.MockHosts[m.CurrentIndex]
+	}
+	return ""
+}
+func (m *MockGrpcProvider) Hosts() []string { return m.MockHosts }
+func (m *MockGrpcProvider) SwitchHost(idx int) error {
+	m.CurrentIndex = idx
+	m.ConnCounter++
+	return nil
+}
+func (m *MockGrpcProvider) ConnectionCounter() uint64 { return m.ConnCounter }
+func (m *MockGrpcProvider) Close()                    {}

api/rest/BUILD.bazel

@@ -0,0 +1,34 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "log.go",
+        "mock_rest_provider.go",
+        "rest_connection_provider.go",
+        "rest_handler.go",
+    ],
+    importpath = "github.com/OffchainLabs/prysm/v7/api/rest",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//api:go_default_library",
+        "//api/apiutil:go_default_library",
+        "//api/client:go_default_library",
+        "//config/params:go_default_library",
+        "//network/httputil:go_default_library",
+        "//runtime/version:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+        "@io_opentelemetry_go_contrib_instrumentation_net_http_otelhttp//:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["rest_connection_provider_test.go"],
+    embed = [":go_default_library"],
+    deps = [
+        "//testing/assert:go_default_library",
+        "//testing/require:go_default_library",
+    ],
+)

api/rest/log.go

@@ -0,0 +1,9 @@
+// Code generated by hack/gen-logs.sh; DO NOT EDIT.
+// This file is created and regenerated automatically. Anything added here might get removed.
+package rest
+
+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", "api/rest")

api/rest/mock_rest_provider.go

@@ -0,0 +1,46 @@
+package rest
+
+import (
+	"bytes"
+	"context"
+	"net/http"
+)
+
+// MockRestProvider implements RestConnectionProvider for testing.
+type MockRestProvider struct {
+	MockClient  *http.Client
+	MockHandler Handler
+	MockHosts   []string
+	HostIndex   int
+}
+
+func (m *MockRestProvider) HttpClient() *http.Client { return m.MockClient }
+func (m *MockRestProvider) Handler() Handler         { return m.MockHandler }
+func (m *MockRestProvider) CurrentHost() string {
+	if len(m.MockHosts) > 0 {
+		return m.MockHosts[m.HostIndex%len(m.MockHosts)]
+	}
+	return ""
+}
+func (m *MockRestProvider) Hosts() []string            { return m.MockHosts }
+func (m *MockRestProvider) SwitchHost(index int) error { m.HostIndex = index; return nil }
+
+// MockHandler implements Handler for testing.
+type MockHandler struct {
+	MockHost string
+}
+
+func (m *MockHandler) Get(_ context.Context, _ string, _ any) error { return nil }
+func (m *MockHandler) GetStatusCode(_ context.Context, _ string) (int, error) {
+	return http.StatusOK, nil
+}
+func (m *MockHandler) GetSSZ(_ context.Context, _ string) ([]byte, http.Header, error) {
+	return nil, nil, nil
+}
+func (m *MockHandler) Post(_ context.Context, _ string, _ map[string]string, _ *bytes.Buffer, _ any) error {
+	return nil
+}
+func (m *MockHandler) PostSSZ(_ context.Context, _ string, _ map[string]string, _ *bytes.Buffer) ([]byte, http.Header, error) {
+	return nil, nil, nil
+}
+func (m *MockHandler) Host() string { return m.MockHost }

api/rest/rest_connection_provider.go

@@ -0,0 +1,158 @@
+package rest
+
+import (
+	"net/http"
+	"strings"
+	"sync/atomic"
+	"time"
+
+	"github.com/OffchainLabs/prysm/v7/api/client"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
+)
+
+// RestConnectionProvider manages HTTP client configuration for REST API with failover support.
+// It allows switching between different beacon node REST endpoints when the current one becomes unavailable.
+type RestConnectionProvider interface {
+	// HttpClient returns the configured HTTP client with headers, timeout, and optional tracing.
+	HttpClient() *http.Client
+	// Handler returns the REST handler for making API requests.
+	Handler() Handler
+	// CurrentHost returns the current REST API endpoint URL.
+	CurrentHost() string
+	// Hosts returns all configured REST API endpoint URLs.
+	Hosts() []string
+	// SwitchHost switches to the endpoint at the given index.
+	SwitchHost(index int) error
+}
+
+// RestConnectionProviderOption is a functional option for configuring the REST connection provider.
+type RestConnectionProviderOption func(*restConnectionProvider)
+
+// WithHttpTimeout sets the HTTP client timeout.
+func WithHttpTimeout(timeout time.Duration) RestConnectionProviderOption {
+	return func(p *restConnectionProvider) {
+		p.timeout = timeout
+	}
+}
+
+// WithHttpHeaders sets custom HTTP headers to include in all requests.
+func WithHttpHeaders(headers map[string][]string) RestConnectionProviderOption {
+	return func(p *restConnectionProvider) {
+		p.headers = headers
+	}
+}
+
+// WithTracing enables OpenTelemetry tracing for HTTP requests.
+func WithTracing() RestConnectionProviderOption {
+	return func(p *restConnectionProvider) {
+		p.enableTracing = true
+	}
+}
+
+type restConnectionProvider struct {
+	endpoints     []string
+	httpClient    *http.Client
+	restHandler   *handler
+	currentIndex  atomic.Uint64
+	timeout       time.Duration
+	headers       map[string][]string
+	enableTracing bool
+}
+
+// NewRestConnectionProvider creates a new REST connection provider that manages HTTP client configuration.
+// The endpoint parameter can be a comma-separated list of URLs (e.g., "http://host1:3500,http://host2:3500").
+func NewRestConnectionProvider(endpoint string, opts ...RestConnectionProviderOption) (RestConnectionProvider, error) {
+	endpoints := parseEndpoints(endpoint)
+	if len(endpoints) == 0 {
+		return nil, errors.New("no REST API endpoints provided")
+	}
+
+	p := &restConnectionProvider{
+		endpoints: endpoints,
+	}
+
+	for _, opt := range opts {
+		opt(p)
+	}
+
+	// Build the HTTP transport chain
+	var transport http.RoundTripper = http.DefaultTransport
+
+	// Add custom headers if configured
+	if len(p.headers) > 0 {
+		transport = client.NewCustomHeadersTransport(transport, p.headers)
+	}
+
+	// Add tracing if enabled
+	if p.enableTracing {
+		transport = otelhttp.NewTransport(transport)
+	}
+
+	p.httpClient = &http.Client{
+		Timeout:   p.timeout,
+		Transport: transport,
+	}
+
+	// Create the REST handler with the HTTP client and initial host
+	p.restHandler = newHandler(*p.httpClient, endpoints[0])
+
+	log.WithFields(logrus.Fields{
+		"endpoints": endpoints,
+		"count":     len(endpoints),
+	}).Info("Initialized REST connection provider")
+
+	return p, nil
+}
+
+// parseEndpoints splits a comma-separated endpoint string into individual endpoints.
+func parseEndpoints(endpoint string) []string {
+	if endpoint == "" {
+		return nil
+	}
+	endpoints := make([]string, 0, 1)
+	for p := range strings.SplitSeq(endpoint, ",") {
+		if p = strings.TrimSpace(p); p != "" {
+			endpoints = append(endpoints, p)
+		}
+	}
+	return endpoints
+}
+
+func (p *restConnectionProvider) HttpClient() *http.Client {
+	return p.httpClient
+}
+
+func (p *restConnectionProvider) Handler() Handler {
+	return p.restHandler
+}
+
+func (p *restConnectionProvider) CurrentHost() string {
+	return p.endpoints[p.currentIndex.Load()]
+}
+
+func (p *restConnectionProvider) Hosts() []string {
+	// Return a copy to maintain immutability
+	hosts := make([]string, len(p.endpoints))
+	copy(hosts, p.endpoints)
+	return hosts
+}
+
+func (p *restConnectionProvider) SwitchHost(index int) error {
+	if index < 0 || index >= len(p.endpoints) {
+		return errors.Errorf("invalid host index %d, must be between 0 and %d", index, len(p.endpoints)-1)
+	}
+
+	oldIdx := p.currentIndex.Load()
+	p.currentIndex.Store(uint64(index))
+
+	// Update the rest handler's host
+	p.restHandler.SwitchHost(p.endpoints[index])
+
+	log.WithFields(logrus.Fields{
+		"previousHost": p.endpoints[oldIdx],
+		"newHost":      p.endpoints[index],
+	}).Debug("Switched REST endpoint")
+	return nil
+}

api/rest/rest_connection_provider_test.go

@@ -0,0 +1,80 @@
+package rest
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/testing/assert"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+)
+
+func TestParseEndpoints(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected []string
+	}{
+		{"single endpoint", "http://localhost:3500", []string{"http://localhost:3500"}},
+		{"multiple endpoints", "http://host1:3500,http://host2:3500,http://host3:3500", []string{"http://host1:3500", "http://host2:3500", "http://host3:3500"}},
+		{"endpoints with spaces", "http://host1:3500, http://host2:3500 , http://host3:3500", []string{"http://host1:3500", "http://host2:3500", "http://host3:3500"}},
+		{"empty string", "", nil},
+		{"only commas", ",,,", []string{}},
+		{"trailing comma", "http://host1:3500,http://host2:3500,", []string{"http://host1:3500", "http://host2:3500"}},
+		{"leading comma", ",http://host1:3500,http://host2:3500", []string{"http://host1:3500", "http://host2:3500"}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := parseEndpoints(tt.input)
+			if !reflect.DeepEqual(tt.expected, got) {
+				t.Errorf("parseEndpoints(%q) = %v, want %v", tt.input, got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestNewRestConnectionProvider_Errors(t *testing.T) {
+	t.Run("no endpoints", func(t *testing.T) {
+		_, err := NewRestConnectionProvider("")
+		require.ErrorContains(t, "no REST API endpoints provided", err)
+	})
+}
+
+func TestRestConnectionProvider(t *testing.T) {
+	provider, err := NewRestConnectionProvider("http://host1:3500,http://host2:3500,http://host3:3500")
+	require.NoError(t, err)
+
+	t.Run("initial state", func(t *testing.T) {
+		assert.Equal(t, 3, len(provider.Hosts()))
+		assert.Equal(t, "http://host1:3500", provider.CurrentHost())
+		assert.NotNil(t, provider.HttpClient())
+	})
+
+	t.Run("SwitchHost", func(t *testing.T) {
+		require.NoError(t, provider.SwitchHost(1))
+		assert.Equal(t, "http://host2:3500", provider.CurrentHost())
+		require.NoError(t, provider.SwitchHost(0))
+		assert.Equal(t, "http://host1:3500", provider.CurrentHost())
+		require.ErrorContains(t, "invalid host index", provider.SwitchHost(-1))
+		require.ErrorContains(t, "invalid host index", provider.SwitchHost(3))
+	})
+
+	t.Run("Hosts returns copy", func(t *testing.T) {
+		hosts := provider.Hosts()
+		original := hosts[0]
+		hosts[0] = "modified"
+		assert.Equal(t, original, provider.Hosts()[0])
+	})
+}
+
+func TestRestConnectionProvider_WithOptions(t *testing.T) {
+	headers := map[string][]string{"Authorization": {"Bearer token"}}
+	provider, err := NewRestConnectionProvider(
+		"http://localhost:3500",
+		WithHttpHeaders(headers),
+		WithHttpTimeout(30000000000), // 30 seconds in nanoseconds
+		WithTracing(),
+	)
+	require.NoError(t, err)
+	assert.NotNil(t, provider.HttpClient())
+	assert.Equal(t, "http://localhost:3500", provider.CurrentHost())
+}

api/rest/rest_handler.go

@@ -1,4 +1,4 @@
-package beacon_api
+package rest
 
 import (
 	"bytes"
@@ -21,37 +21,46 @@ import (
 
 type reqOption func(*http.Request)
 
-type RestHandler interface {
+// Handler defines the interface for making REST API requests.
+type Handler interface {
 	Get(ctx context.Context, endpoint string, resp any) error
 	GetStatusCode(ctx context.Context, endpoint string) (int, error)
 	GetSSZ(ctx context.Context, endpoint string) ([]byte, http.Header, error)
 	Post(ctx context.Context, endpoint string, headers map[string]string, data *bytes.Buffer, resp any) error
 	PostSSZ(ctx context.Context, endpoint string, headers map[string]string, data *bytes.Buffer) ([]byte, http.Header, error)
-	HttpClient() *http.Client
 	Host() string
-	SetHost(host string)
 }
 
-type BeaconApiRestHandler struct {
+type handler struct {
 	client       http.Client
 	host         string
 	reqOverrides []reqOption
 }
 
-// NewBeaconApiRestHandler returns a RestHandler
-func NewBeaconApiRestHandler(client http.Client, host string) RestHandler {
-	brh := &BeaconApiRestHandler{
+// newHandler returns a *handler for internal use within the rest package.
+func newHandler(client http.Client, host string) *handler {
+	rh := &handler{
 		client: client,
 		host:   host,
 	}
-	brh.appendAcceptOverride()
-	return brh
+	rh.appendAcceptOverride()
+	return rh
+}
+
+// NewHandler returns a Handler
+func NewHandler(client http.Client, host string) Handler {
+	rh := &handler{
+		client: client,
+		host:   host,
+	}
+	rh.appendAcceptOverride()
+	return rh
 }
 
 // appendAcceptOverride enables the Accept header to be customized at runtime via an environment variable.
 // This is specified as an env var because it is a niche option that prysm may use for performance testing or debugging
 // bug which users are unlikely to need. Using an env var keeps the set of user-facing flags cleaner.
-func (c *BeaconApiRestHandler) appendAcceptOverride() {
+func (c *handler) appendAcceptOverride() {
 	if accept := os.Getenv(params.EnvNameOverrideAccept); accept != "" {
 		c.reqOverrides = append(c.reqOverrides, func(req *http.Request) {
 			req.Header.Set("Accept", accept)
@@ -60,18 +69,18 @@ func (c *BeaconApiRestHandler) appendAcceptOverride() {
 }
 
 // HttpClient returns the underlying HTTP client of the handler
-func (c *BeaconApiRestHandler) HttpClient() *http.Client {
+func (c *handler) HttpClient() *http.Client {
 	return &c.client
 }
 
 // Host returns the underlying HTTP host
-func (c *BeaconApiRestHandler) Host() string {
+func (c *handler) Host() string {
 	return c.host
 }
 
 // Get sends a GET request and decodes the response body as a JSON object into the passed in object.
 // If an HTTP error is returned, the body is decoded as a DefaultJsonError JSON object and returned as the first return value.
-func (c *BeaconApiRestHandler) Get(ctx context.Context, endpoint string, resp any) error {
+func (c *handler) Get(ctx context.Context, endpoint string, resp any) error {
 	url := c.host + endpoint
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
@@ -94,7 +103,7 @@ func (c *BeaconApiRestHandler) Get(ctx context.Context, endpoint string, resp an
 // GetStatusCode sends a GET request and returns only the HTTP status code.
 // This is useful for endpoints like /eth/v1/node/health that communicate status via HTTP codes
 // (200 = ready, 206 = syncing, 503 = unavailable) rather than response bodies.
-func (c *BeaconApiRestHandler) GetStatusCode(ctx context.Context, endpoint string) (int, error) {
+func (c *handler) GetStatusCode(ctx context.Context, endpoint string) (int, error) {
 	url := c.host + endpoint
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
@@ -113,7 +122,7 @@ func (c *BeaconApiRestHandler) GetStatusCode(ctx context.Context, endpoint strin
 	return httpResp.StatusCode, nil
 }
 
-func (c *BeaconApiRestHandler) GetSSZ(ctx context.Context, endpoint string) ([]byte, http.Header, error) {
+func (c *handler) GetSSZ(ctx context.Context, endpoint string) ([]byte, http.Header, error) {
 	url := c.host + endpoint
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
@@ -168,7 +177,7 @@ func (c *BeaconApiRestHandler) GetSSZ(ctx context.Context, endpoint string) ([]b
 
 // Post sends a POST request and decodes the response body as a JSON object into the passed in object.
 // If an HTTP error is returned, the body is decoded as a DefaultJsonError JSON object and returned as the first return value.
-func (c *BeaconApiRestHandler) Post(
+func (c *handler) Post(
 	ctx context.Context,
 	apiEndpoint string,
 	headers map[string]string,
@@ -204,7 +213,7 @@ func (c *BeaconApiRestHandler) Post(
 }
 
 // PostSSZ sends a POST request and prefers an SSZ (application/octet-stream) response body.
-func (c *BeaconApiRestHandler) PostSSZ(
+func (c *handler) PostSSZ(
 	ctx context.Context,
 	apiEndpoint string,
 	headers map[string]string,
@@ -305,6 +314,6 @@ func decodeResp(httpResp *http.Response, resp any) error {
 	return nil
 }
 
-func (c *BeaconApiRestHandler) SetHost(host string) {
+func (c *handler) SwitchHost(host string) {
 	c.host = host
 }

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"`
-	BlobKzgCommitmentsRoot string `json:"blob_kzg_commitments_root"`
+	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"`
 }
 
 type SignedExecutionPayloadBid struct {

api/server/structs/conversions_block.go

@@ -2939,18 +2939,22 @@ 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),
-		BlobKzgCommitmentsRoot: hexutil.Encode(b.BlobKzgCommitmentsRoot),
+		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,
 	}
 }
 
@@ -3187,22 +3191,30 @@ func (b *ExecutionPayloadBid) ToConsensus() (*eth.ExecutionPayloadBid, error) {
 	if err != nil {
 		return nil, server.NewDecodeError(err, "ExecutionPayment")
 	}
-	blobKzgCommitmentsRoot, err := bytesutil.DecodeHexWithLength(b.BlobKzgCommitmentsRoot, fieldparams.RootLength)
+	err = slice.VerifyMaxLength(b.BlobKzgCommitments, fieldparams.MaxBlobCommitmentsPerBlock)
 	if err != nil {
-		return nil, server.NewDecodeError(err, "BlobKzgCommitmentsRoot")
+		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 &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),
-		BlobKzgCommitmentsRoot: blobKzgCommitmentsRoot,
+		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,
 	}, nil
 }
 

beacon-chain/blockchain/BUILD.bazel

@@ -27,7 +27,8 @@ go_library(
         "receive_blob.go",
         "receive_block.go",
         "receive_data_column.go",
-        "receive_proof.go",
+        "receive_execution_payload_envelope.go",
+        "receive_payload_attestation_message.go",
         "service.go",
         "setup_forkchoice.go",
         "tracked_proposer.go",
@@ -50,7 +51,6 @@ go_library(
         "//beacon-chain/core/electra:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/feed:go_default_library",
-        "//beacon-chain/core/feed/operation:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/peerdas:go_default_library",
@@ -76,7 +76,6 @@ go_library(
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
         "//beacon-chain/verification:go_default_library",
-        "//cmd/beacon-chain/flags:go_default_library",
         "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
@@ -88,6 +87,7 @@ 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/execution_engine.go

@@ -101,11 +101,16 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 			if len(lastValidHash) == 0 {
 				lastValidHash = defaultLatestValidHash
 			}
-			invalidRoots, err := s.cfg.ForkChoiceStore.SetOptimisticToInvalid(ctx, headRoot, headBlk.ParentRoot(), bytesutil.ToBytes32(lastValidHash))
+			// this call has guaranteed to have the `headRoot` with its payload in forkchoice.
+			invalidRoots, err := s.cfg.ForkChoiceStore.SetOptimisticToInvalid(ctx, headRoot, headBlk.ParentRoot(), bytesutil.ToBytes32(headPayload.ParentHash()), bytesutil.ToBytes32(lastValidHash))
 			if err != nil {
 				log.WithError(err).Error("Could not set head root to invalid")
 				return nil, nil
 			}
+			// TODO: Gloas, we should not include the head root in this call
+			if len(invalidRoots) == 0 || invalidRoots[0] != headRoot {
+				invalidRoots = append([][32]byte{headRoot}, invalidRoots...)
+			}
 			if err := s.removeInvalidBlockAndState(ctx, invalidRoots); err != nil {
 				log.WithError(err).Error("Could not remove invalid block and state")
 				return nil, nil
@@ -290,10 +295,10 @@ func (s *Service) notifyNewPayload(ctx context.Context, stVersion int, header in
 	return false, errors.WithMessage(ErrUndefinedExecutionEngineError, err.Error())
 }
 
-// reportInvalidBlock deals with the event that an invalid block was detected by the execution layer
-func (s *Service) pruneInvalidBlock(ctx context.Context, root, parentRoot, lvh [32]byte) error {
+// pruneInvalidBlock deals with the event that an invalid block was detected by the execution layer
+func (s *Service) pruneInvalidBlock(ctx context.Context, root, parentRoot, parentHash [32]byte, lvh [32]byte) error {
 	newPayloadInvalidNodeCount.Inc()
-	invalidRoots, err := s.cfg.ForkChoiceStore.SetOptimisticToInvalid(ctx, root, parentRoot, lvh)
+	invalidRoots, err := s.cfg.ForkChoiceStore.SetOptimisticToInvalid(ctx, root, parentRoot, parentHash, lvh)
 	if err != nil {
 		return err
 	}

beacon-chain/blockchain/execution_engine_test.go

@@ -465,9 +465,9 @@ func Test_NotifyForkchoiceUpdateRecursive_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, brd, headRoot)
 
-	// Ensure F and G where removed but their parent E wasn't
-	require.Equal(t, false, fcs.HasNode(brf))
-	require.Equal(t, false, fcs.HasNode(brg))
+	// Ensure F and G's full nodes were removed but their empty (consensus) nodes remain, as does E
+	require.Equal(t, true, fcs.HasNode(brf))
+	require.Equal(t, true, fcs.HasNode(brg))
 	require.Equal(t, true, fcs.HasNode(bre))
 }
 
@@ -703,14 +703,13 @@ func Test_reportInvalidBlock(t *testing.T) {
 	require.NoError(t, fcs.InsertNode(ctx, st, root))
 
 	require.NoError(t, fcs.SetOptimisticToValid(ctx, [32]byte{'A'}))
-	err = service.pruneInvalidBlock(ctx, [32]byte{'D'}, [32]byte{'C'}, [32]byte{'a'})
+	err = service.pruneInvalidBlock(ctx, [32]byte{'D'}, [32]byte{'C'}, [32]byte{'c'}, [32]byte{'a'})
 	require.Equal(t, IsInvalidBlock(err), true)
 	require.Equal(t, InvalidBlockLVH(err), [32]byte{'a'})
 	invalidRoots := InvalidAncestorRoots(err)
-	require.Equal(t, 3, len(invalidRoots))
+	require.Equal(t, 2, len(invalidRoots))
 	require.Equal(t, [32]byte{'D'}, invalidRoots[0])
 	require.Equal(t, [32]byte{'C'}, invalidRoots[1])
-	require.Equal(t, [32]byte{'B'}, invalidRoots[2])
 }
 
 func Test_GetPayloadAttribute(t *testing.T) {
@@ -785,7 +784,7 @@ func Test_GetPayloadAttributeV2(t *testing.T) {
 }
 
 func Test_GetPayloadAttributeV3(t *testing.T) {
-	var testCases = []struct {
+	testCases := []struct {
 		name string
 		st   bstate.BeaconState
 	}{

beacon-chain/blockchain/log_helpers.go

@@ -10,6 +10,7 @@ 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"
@@ -87,36 +88,45 @@ 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 err
+		return errors.Wrap(err, "failed to get slot start time")
 	}
-	level := log.Logger.GetLevel()
+	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")
 	if level >= logrus.DebugLevel {
-		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(moreFields).Info("Synced new block")
+		return nil
 	}
+
+	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/options.go

@@ -5,7 +5,6 @@ import (
 
 	"github.com/OffchainLabs/prysm/v7/async/event"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/cache"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/feed/operation"
 	statefeed "github.com/OffchainLabs/prysm/v7/beacon-chain/core/feed/state"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/db/filesystem"
@@ -227,14 +226,6 @@ func WithDataColumnStorage(b *filesystem.DataColumnStorage) Option {
 	}
 }
 
-// WithProofStorage sets the proof storage backend for the blockchain service.
-func WithProofStorage(p *filesystem.ProofStorage) Option {
-	return func(s *Service) error {
-		s.proofStorage = p
-		return nil
-	}
-}
-
 // WithSyncChecker sets the sync checker for the blockchain service.
 func WithSyncChecker(checker Checker) Option {
 	return func(s *Service) error {
@@ -275,10 +266,3 @@ func WithStartWaitingDataColumnSidecars(c chan bool) Option {
 		return nil
 	}
 }
-
-func WithOperationNotifier(operationNotifier operation.Notifier) Option {
-	return func(s *Service) error {
-		s.cfg.OperationNotifier = operationNotifier
-		return nil
-	}
-}

beacon-chain/blockchain/process_block.go

@@ -15,7 +15,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/db/filesystem"
 	forkchoicetypes "github.com/OffchainLabs/prysm/v7/beacon-chain/forkchoice/types"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/cmd/beacon-chain/flags"
 	"github.com/OffchainLabs/prysm/v7/config/features"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
@@ -114,7 +113,6 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 			s.updateCachesPostBlockProcessing(cfg)
 		}()
 	}
-
 	return nil
 }
 
@@ -234,7 +232,8 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 			postVersionAndHeaders[i].version,
 			postVersionAndHeaders[i].header, b)
 		if err != nil {
-			return s.handleInvalidExecutionError(ctx, err, root, b.Block().ParentRoot())
+			// this call does not have the root in forkchoice yet.
+			return s.handleInvalidExecutionError(ctx, err, root, b.Block().ParentRoot(), [32]byte(postVersionAndHeaders[i].header.ParentHash()))
 		}
 		if isValidPayload {
 			if err := s.validateMergeTransitionBlock(ctx, preVersionAndHeaders[i].version,
@@ -663,17 +662,10 @@ func (s *Service) isDataAvailable(
 		return errors.New("invalid nil beacon block")
 	}
 
-	root, blockVersion := roBlock.Root(), roBlock.Version()
+	root := roBlock.Root()
+	blockVersion := block.Version()
 	if blockVersion >= version.Fulu {
-		if err := s.areExecutionProofsAvailable(ctx, roBlock); err != nil {
-			return fmt.Errorf("are execution proofs available: %w", err)
-		}
-
-		if err := s.areDataColumnsAvailable(ctx, root, block); err != nil {
-			return fmt.Errorf("are data columns available: %w", err)
-		}
-
-		return nil
+		return s.areDataColumnsAvailable(ctx, root, block)
 	}
 
 	if blockVersion >= version.Deneb {
@@ -683,77 +675,6 @@ func (s *Service) isDataAvailable(
 	return nil
 }
 
-// areExecutionProofsAvailable blocks until we have enough execution proofs to import the block,
-// or an error or context cancellation occurs.
-// This check is only performed for lightweight verifier nodes that need zkVM proofs
-// to validate block execution (nodes without execution layer + proof generation capability).
-// A nil result means that the data availability check is successful.
-func (s *Service) areExecutionProofsAvailable(ctx context.Context, roBlock consensusblocks.ROBlock) error {
-	// Return early if zkVM features are disabled (no need to check for execution proofs),
-	// or if the generation proof is enabled (we will generate proofs ourselves).
-	if !features.Get().EnableZkvm || len(flags.Get().ProofGenerationTypes) > 0 {
-		return nil
-	}
-
-	root, slot := roBlock.Root(), roBlock.Block().Slot()
-
-	requiredProofCount := params.BeaconConfig().MinProofsRequired
-	log := log.WithFields(logrus.Fields{
-		"root":               fmt.Sprintf("%#x", root),
-		"slot":               slot,
-		"requiredProofCount": requiredProofCount,
-	})
-
-	// Subscribe to newly execution proofs stored in the database.
-	subscription, identChan := s.proofStorage.Subscribe()
-	defer subscription.Unsubscribe()
-
-	// Return early if we already have enough proofs.
-	if actualProofCount := uint64(s.proofStorage.Summary(root).Count()); actualProofCount >= requiredProofCount {
-		log.WithField("actualProofCount", actualProofCount).Debug("Already have enough execution proofs")
-		return nil
-	}
-
-	// Log for DA checks that cross over into the next slot; helpful for debugging.
-	nextSlot, err := slots.StartTime(s.genesisTime, roBlock.Block().Slot()+1)
-	if err != nil {
-		return fmt.Errorf("start time: %w", err)
-	}
-
-	// Avoid logging if DA check is called after next slot start.
-	if nextSlot.After(time.Now()) {
-		timer := time.AfterFunc(time.Until(nextSlot), func() {
-			actualCount := uint64(s.proofStorage.Summary(root).Count())
-			if actualCount >= requiredProofCount {
-				return
-			}
-
-			log.WithField("proofsRetrieved", actualCount).Warning("Execution proofs still missing at slot end")
-		})
-
-		defer timer.Stop()
-	}
-
-	// Some proofs are missing; wait for them.
-	for {
-		select {
-		case <-ctx.Done():
-			return ctx.Err()
-		case proofIdent := <-identChan:
-			// Skip if the proof is for a different block.
-			if proofIdent.BlockRoot != root {
-				continue
-			}
-
-			// Return if we have enough proofs.
-			if actualProofCount := uint64(s.proofStorage.Summary(root).Count()); actualProofCount >= requiredProofCount {
-				log.WithField("actualProofCount", actualProofCount).Debug("Got enough execution proofs")
-				return nil
-			}
-		}
-	}
-}
-
 // areDataColumnsAvailable blocks until all data columns committed to in the block are available,
 // or an error or context cancellation occurs. A nil result means that the data availability check is successful.
 func (s *Service) areDataColumnsAvailable(
@@ -890,7 +811,14 @@ func (s *Service) areDataColumnsAvailable(
 			}
 
 		case <-ctx.Done():
-			return errors.Wrapf(ctx.Err(), "data column sidecars slot: %d, BlockRoot: %#x, missing: %v", block.Slot(), root, helpers.SortedPrettySliceFromMap(missing))
+			var missingIndices any = "all"
+			missingIndicesCount := len(missing)
+
+			if missingIndicesCount < fieldparams.NumberOfColumns {
+				missingIndices = helpers.SortedPrettySliceFromMap(missing)
+			}
+
+			return errors.Wrapf(ctx.Err(), "data column sidecars slot: %d, BlockRoot: %#x, missing: %v", block.Slot(), root, missingIndices)
 		}
 	}
 }
@@ -1065,9 +993,9 @@ func (s *Service) waitForSync() error {
 	}
 }
 
-func (s *Service) handleInvalidExecutionError(ctx context.Context, err error, blockRoot, parentRoot [fieldparams.RootLength]byte) error {
+func (s *Service) handleInvalidExecutionError(ctx context.Context, err error, blockRoot, parentRoot [32]byte, parentHash [32]byte) error {
 	if IsInvalidBlock(err) && InvalidBlockLVH(err) != [32]byte{} {
-		return s.pruneInvalidBlock(ctx, blockRoot, parentRoot, InvalidBlockLVH(err))
+		return s.pruneInvalidBlock(ctx, blockRoot, parentRoot, parentHash, InvalidBlockLVH(err))
 	}
 	return err
 }

beacon-chain/blockchain/process_block_test.go

@@ -2006,6 +2006,7 @@ func TestNoViableHead_Reboot(t *testing.T) {
 	// Check that we have justified the second epoch
 	jc := service.cfg.ForkChoiceStore.JustifiedCheckpoint()
 	require.Equal(t, primitives.Epoch(2), jc.Epoch)
+	time.Sleep(20 * time.Millisecond) // wait for async forkchoice update to be processed
 
 	// import block 19 to find out that the whole chain 13--18 was in fact
 	// invalid

beacon-chain/blockchain/receive_block.go

@@ -60,12 +60,6 @@ type DataColumnReceiver interface {
 	ReceiveDataColumns([]blocks.VerifiedRODataColumn) error
 }
 
-// ProofReceiver interface defines the methods of chain service for receiving new
-// execution proofs
-type ProofReceiver interface {
-	ReceiveProof(proof *ethpb.ExecutionProof) error
-}
-
 // SlashingReceiver interface defines the methods of chain service for receiving validated slashing over the wire.
 type SlashingReceiver interface {
 	ReceiveAttesterSlashing(ctx context.Context, slashing ethpb.AttSlashing)
@@ -639,7 +633,7 @@ func (s *Service) validateExecutionOnBlock(ctx context.Context, ver int, header
 	isValidPayload, err := s.notifyNewPayload(ctx, ver, header, block)
 	if err != nil {
 		s.cfg.ForkChoiceStore.Lock()
-		err = s.handleInvalidExecutionError(ctx, err, block.Root(), block.Block().ParentRoot())
+		err = s.handleInvalidExecutionError(ctx, err, block.Root(), block.Block().ParentRoot(), [32]byte(header.BlockHash()))
 		s.cfg.ForkChoiceStore.Unlock()
 		return false, err
 	}

beacon-chain/blockchain/receive_execution_payload_envelope.go

@@ -0,0 +1,19 @@
+package blockchain
+
+import (
+	"context"
+
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
+)
+
+// ExecutionPayloadEnvelopeReceiver interface defines the methods of chain service for receiving
+// validated execution payload envelopes.
+type ExecutionPayloadEnvelopeReceiver interface {
+	ReceiveExecutionPayloadEnvelope(context.Context, interfaces.ROSignedExecutionPayloadEnvelope) error
+}
+
+// ReceiveExecutionPayloadEnvelope accepts a signed execution payload envelope.
+func (s *Service) ReceiveExecutionPayloadEnvelope(_ context.Context, _ interfaces.ROSignedExecutionPayloadEnvelope) error {
+	// TODO: wire into execution payload envelope processing pipeline.
+	return nil
+}

beacon-chain/blockchain/receive_payload_attestation_message.go

@@ -0,0 +1,19 @@
+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/receive_proof.go

@@ -1,15 +0,0 @@
-package blockchain
-
-import (
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/pkg/errors"
-)
-
-// ReceiveProof saves an execution proof to storage.
-func (s *Service) ReceiveProof(proof *ethpb.ExecutionProof) error {
-	if err := s.proofStorage.Save([]*ethpb.ExecutionProof{proof}); err != nil {
-		return errors.Wrap(err, "save proof")
-	}
-
-	return nil
-}

beacon-chain/blockchain/service.go

@@ -12,7 +12,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/async/event"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/kzg"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/cache"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/feed/operation"
 	statefeed "github.com/OffchainLabs/prysm/v7/beacon-chain/core/feed/state"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	coreTime "github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
@@ -65,7 +64,6 @@ type Service struct {
 	blockBeingSynced               *currentlySyncingBlock
 	blobStorage                    *filesystem.BlobStorage
 	dataColumnStorage              *filesystem.DataColumnStorage
-	proofStorage                   *filesystem.ProofStorage
 	slasherEnabled                 bool
 	lcStore                        *lightClient.Store
 	startWaitingDataColumnSidecars chan bool // for testing purposes only
@@ -88,7 +86,6 @@ type config struct {
 	P2P                     p2p.Accessor
 	MaxRoutines             int
 	StateNotifier           statefeed.Notifier
-	OperationNotifier       operation.Notifier
 	ForkChoiceStore         f.ForkChoicer
 	AttService              *attestations.Service
 	StateGen                *stategen.State
@@ -212,8 +209,7 @@ func (s *Service) Start() {
 	if err := s.StartFromSavedState(s.cfg.FinalizedStateAtStartUp); err != nil {
 		log.Fatal(err)
 	}
-
-	go s.spawnProcessAttestationsRoutine()
+	s.spawnProcessAttestationsRoutine()
 	go s.runLateBlockTasks()
 }
 

beacon-chain/blockchain/testing/mock.go

@@ -75,7 +75,6 @@ type ChainService struct {
 	SyncingRoot                 [32]byte
 	Blobs                       []blocks.VerifiedROBlob
 	DataColumns                 []blocks.VerifiedRODataColumn
-	Proofs                      []*ethpb.ExecutionProof
 	TargetRoot                  [32]byte
 	MockHeadSlot                *primitives.Slot
 }
@@ -758,9 +757,13 @@ func (c *ChainService) ReceiveDataColumns(dcs []blocks.VerifiedRODataColumn) err
 	return nil
 }
 
-// ReceiveProof implements the same method in chain service
-func (c *ChainService) ReceiveProof(proof *ethpb.ExecutionProof) error {
-	c.Proofs = append(c.Proofs, proof)
+// ReceivePayloadAttestationMessage implements the same method in the chain service.
+func (c *ChainService) ReceivePayloadAttestationMessage(_ context.Context, _ *ethpb.PayloadAttestationMessage) error {
+	return nil
+}
+
+// ReceiveExecutionPayloadEnvelope implements the same method in the chain service.
+func (c *ChainService) ReceiveExecutionPayloadEnvelope(_ context.Context, _ interfaces.ROSignedExecutionPayloadEnvelope) error {
 	return nil
 }
 

beacon-chain/cache/BUILD.bazel

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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,48 @@
+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/altair/BUILD.bazel

@@ -20,6 +20,7 @@ go_library(
         "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/epoch:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
+        "//beacon-chain/core/gloas:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",

beacon-chain/core/altair/attestation.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas"
 	"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/state"
@@ -75,7 +76,11 @@ func ProcessAttestationNoVerifySignature(
 		return nil, err
 	}
 
-	return SetParticipationAndRewardProposer(ctx, beaconState, att.GetData().Target.Epoch, indices, participatedFlags, totalBalance)
+	if err := beaconState.UpdatePendingPaymentWeight(att, indices, participatedFlags); err != nil {
+		return nil, errors.Wrap(err, "failed to update pending payment weight")
+	}
+
+	return SetParticipationAndRewardProposer(ctx, beaconState, att.GetData().Target.Epoch, indices, participatedFlags, totalBalance, att)
 }
 
 // SetParticipationAndRewardProposer retrieves and sets the epoch participation bits in state. Based on the epoch participation, it rewards
@@ -105,7 +110,9 @@ func SetParticipationAndRewardProposer(
 	beaconState state.BeaconState,
 	targetEpoch primitives.Epoch,
 	indices []uint64,
-	participatedFlags map[uint8]bool, totalBalance uint64) (state.BeaconState, error) {
+	participatedFlags map[uint8]bool,
+	totalBalance uint64,
+	att ethpb.Att) (state.BeaconState, error) {
 	var proposerRewardNumerator uint64
 	currentEpoch := time.CurrentEpoch(beaconState)
 	var stateErr error
@@ -299,6 +306,19 @@ func AttestationParticipationFlagIndices(beaconState state.ReadOnlyBeaconState,
 		participatedFlags[targetFlagIndex] = true
 	}
 	matchedSrcTgtHead := matchedHead && matchedSrcTgt
+
+	var beaconBlockRoot [32]byte
+	copy(beaconBlockRoot[:], data.BeaconBlockRoot)
+	matchingPayload, err := gloas.MatchingPayload(
+		beaconState,
+		beaconBlockRoot,
+		data.Slot,
+		uint64(data.CommitteeIndex),
+	)
+	if err != nil {
+		return nil, err
+	}
+	matchedSrcTgtHead = matchedSrcTgtHead && matchingPayload
 	if matchedSrcTgtHead && delay == cfg.MinAttestationInclusionDelay {
 		participatedFlags[headFlagIndex] = true
 	}

beacon-chain/core/altair/attestation_test.go

@@ -1,7 +1,9 @@
 package altair_test
 
 import (
+	"bytes"
 	"fmt"
+	"reflect"
 	"testing"
 
 	"github.com/OffchainLabs/go-bitfield"
@@ -556,7 +558,7 @@ func TestSetParticipationAndRewardProposer(t *testing.T) {
 
 			b, err := helpers.TotalActiveBalance(beaconState)
 			require.NoError(t, err)
-			st, err := altair.SetParticipationAndRewardProposer(t.Context(), beaconState, test.epoch, test.indices, test.participatedFlags, b)
+			st, err := altair.SetParticipationAndRewardProposer(t.Context(), beaconState, test.epoch, test.indices, test.participatedFlags, b, &ethpb.Attestation{})
 			require.NoError(t, err)
 
 			i, err := helpers.BeaconProposerIndex(t.Context(), st)
@@ -775,11 +777,67 @@ func TestAttestationParticipationFlagIndices(t *testing.T) {
 				headFlagIndex:   true,
 			},
 		},
+		{
+			name: "gloas same-slot committee index non-zero errors",
+			inputState: func() state.BeaconState {
+				stateSlot := primitives.Slot(5)
+				slot := primitives.Slot(3)
+				targetRoot := bytes.Repeat([]byte{0xAA}, 32)
+				headRoot := bytes.Repeat([]byte{0xBB}, 32)
+				prevRoot := bytes.Repeat([]byte{0xCC}, 32)
+				return buildGloasStateForFlags(t, stateSlot, slot, targetRoot, headRoot, prevRoot, 0, 0)
+			}(),
+			inputData: &ethpb.AttestationData{
+				Slot:            3,
+				CommitteeIndex:  1, // invalid for same-slot
+				BeaconBlockRoot: bytes.Repeat([]byte{0xBB}, 32),
+				Source:          &ethpb.Checkpoint{Root: bytes.Repeat([]byte{0xDD}, 32)},
+				Target: &ethpb.Checkpoint{
+					Epoch: 0,
+					Root:  bytes.Repeat([]byte{0xAA}, 32),
+				},
+			},
+			inputDelay:           1,
+			participationIndices: nil,
+		},
+		{
+			name: "gloas payload availability matches committee index",
+			inputState: func() state.BeaconState {
+				stateSlot := primitives.Slot(5)
+				slot := primitives.Slot(3)
+				targetRoot := bytes.Repeat([]byte{0xAA}, 32)
+				headRoot := bytes.Repeat([]byte{0xBB}, 32)
+				// Same prev root to make SameSlotAttestation false and use payload availability.
+				return buildGloasStateForFlags(t, stateSlot, slot, targetRoot, headRoot, headRoot, 1, slot)
+			}(),
+			inputData: &ethpb.AttestationData{
+				Slot:            3,
+				CommitteeIndex:  1,
+				BeaconBlockRoot: bytes.Repeat([]byte{0xBB}, 32),
+				Source:          &ethpb.Checkpoint{Root: bytes.Repeat([]byte{0xDD}, 32)},
+				Target: &ethpb.Checkpoint{
+					Epoch: 0,
+					Root:  bytes.Repeat([]byte{0xAA}, 32),
+				},
+			},
+			inputDelay: 1,
+			participationIndices: map[uint8]bool{
+				sourceFlagIndex: true,
+				targetFlagIndex: true,
+				headFlagIndex:   true,
+			},
+		},
 	}
 	for _, test := range tests {
 		flagIndices, err := altair.AttestationParticipationFlagIndices(test.inputState, test.inputData, test.inputDelay)
+		if test.participationIndices == nil {
+			require.ErrorContains(t, "committee index", err)
+			continue
+		}
 		require.NoError(t, err)
-		require.DeepEqual(t, test.participationIndices, flagIndices)
+		if !reflect.DeepEqual(test.participationIndices, flagIndices) {
+			t.Fatalf("unexpected participation indices: got %v want %v", flagIndices, test.participationIndices)
+		}
 	}
 }
 
@@ -858,3 +916,61 @@ func TestMatchingStatus(t *testing.T) {
 		require.Equal(t, test.matchedHead, head)
 	}
 }
+
+func buildGloasStateForFlags(t *testing.T, stateSlot, slot primitives.Slot, targetRoot, headRoot, prevRoot []byte, availabilityBit uint8, availabilitySlot primitives.Slot) state.BeaconState {
+	t.Helper()
+
+	cfg := params.BeaconConfig()
+	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
+	blockRoots[0] = targetRoot
+	blockRoots[slot%cfg.SlotsPerHistoricalRoot] = headRoot
+	blockRoots[(slot-1)%cfg.SlotsPerHistoricalRoot] = prevRoot
+
+	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
+	for i := range stateRoots {
+		stateRoots[i] = make([]byte, fieldparams.RootLength)
+	}
+	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
+	for i := range randaoMixes {
+		randaoMixes[i] = make([]byte, fieldparams.RootLength)
+	}
+
+	execPayloadAvailability := make([]byte, cfg.SlotsPerHistoricalRoot/8)
+	idx := availabilitySlot % cfg.SlotsPerHistoricalRoot
+	byteIndex := idx / 8
+	bitIndex := idx % 8
+	if availabilityBit == 1 {
+		execPayloadAvailability[byteIndex] |= 1 << bitIndex
+	}
+
+	checkpointRoot := bytes.Repeat([]byte{0xDD}, fieldparams.RootLength)
+	justified := &ethpb.Checkpoint{Root: checkpointRoot}
+
+	stProto := &ethpb.BeaconStateGloas{
+		Slot:                         stateSlot,
+		GenesisValidatorsRoot:        bytes.Repeat([]byte{0x11}, fieldparams.RootLength),
+		BlockRoots:                   blockRoots,
+		StateRoots:                   stateRoots,
+		RandaoMixes:                  randaoMixes,
+		ExecutionPayloadAvailability: execPayloadAvailability,
+		CurrentJustifiedCheckpoint:   justified,
+		PreviousJustifiedCheckpoint:  justified,
+		Validators: []*ethpb.Validator{
+			{
+				EffectiveBalance:      cfg.MinActivationBalance,
+				WithdrawalCredentials: append([]byte{cfg.ETH1AddressWithdrawalPrefixByte}, bytes.Repeat([]byte{0x01}, 31)...),
+			},
+		},
+		Balances:               []uint64{cfg.MinActivationBalance},
+		BuilderPendingPayments: make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2),
+		Fork: &ethpb.Fork{
+			CurrentVersion:  bytes.Repeat([]byte{0x01}, 4),
+			PreviousVersion: bytes.Repeat([]byte{0x01}, 4),
+			Epoch:           0,
+		},
+	}
+
+	beaconState, err := state_native.InitializeFromProtoGloas(stProto)
+	require.NoError(t, err)
+	return beaconState
+}

beacon-chain/core/blocks/attestation.go

@@ -111,10 +111,21 @@ func VerifyAttestationNoVerifySignature(
 	var indexedAtt ethpb.IndexedAtt
 
 	if att.Version() >= version.Electra {
-		if att.GetData().CommitteeIndex != 0 {
-			return errors.New("committee index must be 0 post-Electra")
+		ci := att.GetData().CommitteeIndex
+		// Spec v1.7.0-alpha pseudocode:
+		//
+		//	# [Modified in Gloas:EIP7732]
+		//	assert data.index < 2
+		//
+		if beaconState.Version() >= version.Gloas {
+			if ci >= 2 {
+				return fmt.Errorf("incorrect committee index %d", ci)
+			}
+		} else {
+			if ci != 0 {
+				return errors.New("committee index must be 0 between Electra and Gloas forks")
+			}
 		}
-
 		aggBits := att.GetAggregationBits()
 		committeeIndices := att.CommitteeBitsVal().BitIndices()
 		committees := make([][]primitives.ValidatorIndex, len(committeeIndices))

beacon-chain/core/blocks/attestation_test.go

@@ -1,6 +1,7 @@
 package blocks_test
 
 import (
+	"bytes"
 	"context"
 	"testing"
 
@@ -262,7 +263,7 @@ func TestVerifyAttestationNoVerifySignature_Electra(t *testing.T) {
 			CommitteeBits:   bitfield.NewBitvector64(),
 		}
 		err = blocks.VerifyAttestationNoVerifySignature(context.TODO(), beaconState, att)
-		assert.ErrorContains(t, "committee index must be 0 post-Electra", err)
+		assert.ErrorContains(t, "committee index must be 0", err)
 	})
 	t.Run("index of committee too big", func(t *testing.T) {
 		aggBits := bitfield.NewBitlist(3)
@@ -314,6 +315,75 @@ func TestVerifyAttestationNoVerifySignature_Electra(t *testing.T) {
 	})
 }
 
+func TestVerifyAttestationNoVerifySignature_GloasCommitteeIndexLimit(t *testing.T) {
+	cfg := params.BeaconConfig()
+	stateSlot := cfg.MinAttestationInclusionDelay + 1
+
+	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
+	for i := range blockRoots {
+		blockRoots[i] = make([]byte, fieldparams.RootLength)
+	}
+	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
+	for i := range stateRoots {
+		stateRoots[i] = make([]byte, fieldparams.RootLength)
+	}
+	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
+	for i := range randaoMixes {
+		randaoMixes[i] = make([]byte, fieldparams.RootLength)
+	}
+
+	checkpointRoot := bytes.Repeat([]byte{0xAA}, fieldparams.RootLength)
+	justified := &ethpb.Checkpoint{Epoch: 0, Root: checkpointRoot}
+
+	gloasStateProto := &ethpb.BeaconStateGloas{
+		Slot:                         stateSlot,
+		GenesisValidatorsRoot:        bytes.Repeat([]byte{0x11}, fieldparams.RootLength),
+		BlockRoots:                   blockRoots,
+		StateRoots:                   stateRoots,
+		RandaoMixes:                  randaoMixes,
+		ExecutionPayloadAvailability: make([]byte, cfg.SlotsPerHistoricalRoot/8),
+		CurrentJustifiedCheckpoint:   justified,
+		PreviousJustifiedCheckpoint:  justified,
+		Validators: []*ethpb.Validator{
+			{
+				EffectiveBalance:      cfg.MinActivationBalance,
+				WithdrawalCredentials: append([]byte{cfg.ETH1AddressWithdrawalPrefixByte}, bytes.Repeat([]byte{0x01}, 31)...),
+			},
+		},
+		Balances:               []uint64{cfg.MinActivationBalance},
+		BuilderPendingPayments: make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2),
+		Fork: &ethpb.Fork{
+			CurrentVersion:  bytes.Repeat([]byte{0x01}, 4),
+			PreviousVersion: bytes.Repeat([]byte{0x01}, 4),
+			Epoch:           0,
+		},
+	}
+
+	beaconState, err := state_native.InitializeFromProtoGloas(gloasStateProto)
+	require.NoError(t, err)
+
+	committeeBits := bitfield.NewBitvector64()
+	committeeBits.SetBitAt(0, true)
+	aggBits := bitfield.NewBitlist(1)
+	aggBits.SetBitAt(0, true)
+
+	att := &ethpb.AttestationElectra{
+		Data: &ethpb.AttestationData{
+			Slot:            0,
+			CommitteeIndex:  2, // invalid for Gloas (must be <2)
+			BeaconBlockRoot: blockRoots[0],
+			Source:          justified,
+			Target:          justified,
+		},
+		AggregationBits: aggBits,
+		CommitteeBits:   committeeBits,
+		Signature:       bytes.Repeat([]byte{0x00}, fieldparams.BLSSignatureLength),
+	}
+
+	err = blocks.VerifyAttestationNoVerifySignature(context.TODO(), beaconState, att)
+	assert.ErrorContains(t, "incorrect committee index 2", err)
+}
+
 func TestConvertToIndexed_OK(t *testing.T) {
 	helpers.ClearCache()
 	validators := make([]*ethpb.Validator, 2*params.BeaconConfig().SlotsPerEpoch)
@@ -583,6 +653,7 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 }
 
 func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing.T) {
+	helpers.ClearCache()
 	ctx := t.Context()
 	numOfValidators := uint64(params.BeaconConfig().SlotsPerEpoch.Mul(4))
 	validators := make([]*ethpb.Validator, numOfValidators)

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

@@ -46,9 +46,6 @@ const (
 
 	// DataColumnReceived is sent after a data column has been seen after gossip validation rules.
 	DataColumnReceived = 12
-
-	// ExecutionProofReceived is sent after a execution proof object has been received from gossip or rpc.
-	ExecutionProofReceived = 13
 )
 
 // UnAggregatedAttReceivedData is the data sent with UnaggregatedAttReceived events.
@@ -80,11 +77,6 @@ type BLSToExecutionChangeReceivedData struct {
 	Change *ethpb.SignedBLSToExecutionChange
 }
 
-// ExecutionProofReceivedData is the data sent with ExecutionProofReceived events.
-type ExecutionProofReceivedData struct {
-	ExecutionProof *ethpb.ExecutionProof
-}
-
 // BlobSidecarReceivedData is the data sent with BlobSidecarReceived events.
 type BlobSidecarReceivedData struct {
 	Blob *blocks.VerifiedROBlob

beacon-chain/core/gloas/BUILD.bazel

@@ -3,7 +3,11 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
+        "attestation.go",
         "bid.go",
+        "deposit_request.go",
+        "log.go",
+        "payload.go",
         "payload_attestation.go",
         "pending_payment.go",
         "proposer_slashing.go",
@@ -12,6 +16,7 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/requests:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/state:go_default_library",
@@ -25,17 +30,23 @@ go_library(
         "//crypto/bls/common:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
     ],
 )
 
 go_test(
     name = "go_default_test",
     srcs = [
+        "attestation_test.go",
         "bid_test.go",
+        "deposit_request_test.go",
         "payload_attestation_test.go",
+        "payload_test.go",
         "pending_payment_test.go",
         "proposer_slashing_test.go",
     ],
@@ -45,6 +56,7 @@ go_test(
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
+        "//beacon-chain/state/testing:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",

beacon-chain/core/gloas/attestation.go

@@ -0,0 +1,52 @@
+package gloas
+
+import (
+	"fmt"
+
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v7/runtime/version"
+	"github.com/pkg/errors"
+)
+
+// MatchingPayload returns true if the attestation's committee index matches the expected payload index.
+//
+// For pre-Gloas forks, this always returns true.
+//
+// Spec v1.7.0-alpha (pseudocode):
+//
+//	# [New in Gloas:EIP7732]
+//	if is_attestation_same_slot(state, data):
+//	    assert data.index == 0
+//	    payload_matches = True
+//	else:
+//	    slot_index = data.slot % SLOTS_PER_HISTORICAL_ROOT
+//	    payload_index = state.execution_payload_availability[slot_index]
+//	    payload_matches = data.index == payload_index
+func MatchingPayload(
+	beaconState state.ReadOnlyBeaconState,
+	beaconBlockRoot [32]byte,
+	slot primitives.Slot,
+	committeeIndex uint64,
+) (bool, error) {
+	if beaconState.Version() < version.Gloas {
+		return true, nil
+	}
+
+	sameSlot, err := beaconState.IsAttestationSameSlot(beaconBlockRoot, slot)
+	if err != nil {
+		return false, errors.Wrap(err, "failed to get same slot attestation status")
+	}
+	if sameSlot {
+		if committeeIndex != 0 {
+			return false, fmt.Errorf("committee index %d for same slot attestation must be 0", committeeIndex)
+		}
+		return true, nil
+	}
+
+	executionPayloadAvail, err := beaconState.ExecutionPayloadAvailability(slot)
+	if err != nil {
+		return false, errors.Wrap(err, "failed to get execution payload availability status")
+	}
+	return executionPayloadAvail == committeeIndex, nil
+}

beacon-chain/core/gloas/attestation_test.go

@@ -0,0 +1,110 @@
+package gloas
+
+import (
+	"bytes"
+	"testing"
+
+	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/runtime/version"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+)
+
+func buildStateWithBlockRoots(t *testing.T, stateSlot primitives.Slot, roots map[primitives.Slot][]byte) *state_native.BeaconState {
+	t.Helper()
+
+	cfg := params.BeaconConfig()
+	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
+	for slot, root := range roots {
+		blockRoots[slot%cfg.SlotsPerHistoricalRoot] = root
+	}
+
+	stProto := &ethpb.BeaconStateGloas{
+		Slot:       stateSlot,
+		BlockRoots: blockRoots,
+	}
+
+	state, err := state_native.InitializeFromProtoGloas(stProto)
+	require.NoError(t, err)
+	return state.(*state_native.BeaconState)
+}
+
+func TestMatchingPayload(t *testing.T) {
+	t.Run("pre-gloas always true", func(t *testing.T) {
+		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
+		require.NoError(t, err)
+
+		ok, err := MatchingPayload(stIface, [32]byte{}, 0, 123)
+		require.NoError(t, err)
+		require.Equal(t, true, ok)
+	})
+
+	t.Run("same slot requires committee index 0", func(t *testing.T) {
+		root := bytes.Repeat([]byte{0xAA}, 32)
+		state := buildStateWithBlockRoots(t, 6, map[primitives.Slot][]byte{
+			4: root,
+			3: bytes.Repeat([]byte{0xBB}, 32),
+		})
+
+		var rootArr [32]byte
+		copy(rootArr[:], root)
+
+		ok, err := MatchingPayload(state, rootArr, 4, 1)
+		require.ErrorContains(t, "committee index", err)
+		require.Equal(t, false, ok)
+	})
+
+	t.Run("same slot matches when committee index is 0", func(t *testing.T) {
+		root := bytes.Repeat([]byte{0xAA}, 32)
+		state := buildStateWithBlockRoots(t, 6, map[primitives.Slot][]byte{
+			4: root,
+			3: bytes.Repeat([]byte{0xBB}, 32),
+		})
+
+		var rootArr [32]byte
+		copy(rootArr[:], root)
+
+		ok, err := MatchingPayload(state, rootArr, 4, 0)
+		require.NoError(t, err)
+		require.Equal(t, true, ok)
+	})
+
+	t.Run("non same slot checks payload availability", func(t *testing.T) {
+		cfg := params.BeaconConfig()
+		root := bytes.Repeat([]byte{0xAA}, 32)
+		blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
+		blockRoots[4%cfg.SlotsPerHistoricalRoot] = bytes.Repeat([]byte{0xCC}, 32)
+		blockRoots[3%cfg.SlotsPerHistoricalRoot] = bytes.Repeat([]byte{0xBB}, 32)
+
+		availability := make([]byte, cfg.SlotsPerHistoricalRoot/8)
+		slotIndex := uint64(4)
+		availability[slotIndex/8] = byte(1 << (slotIndex % 8))
+
+		stIface, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+			Slot:                         6,
+			BlockRoots:                   blockRoots,
+			ExecutionPayloadAvailability: availability,
+			Fork: &ethpb.Fork{
+				CurrentVersion:  bytes.Repeat([]byte{0x66}, 4),
+				PreviousVersion: bytes.Repeat([]byte{0x66}, 4),
+				Epoch:           0,
+			},
+		})
+		require.NoError(t, err)
+		state := stIface.(*state_native.BeaconState)
+		require.Equal(t, version.Gloas, state.Version())
+
+		var rootArr [32]byte
+		copy(rootArr[:], root)
+
+		ok, err := MatchingPayload(state, rootArr, 4, 1)
+		require.NoError(t, err)
+		require.Equal(t, true, ok)
+
+		ok, err = MatchingPayload(state, rootArr, 4, 0)
+		require.NoError(t, err)
+		require.Equal(t, false, ok)
+	})
+}

beacon-chain/core/gloas/bid.go

@@ -17,27 +17,56 @@ import (
 )
 
 // ProcessExecutionPayloadBid processes a signed execution payload bid in the Gloas fork.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// process_execution_payload_bid(state: BeaconState, block: BeaconBlock):
 //
-//	signed_bid = block.body.signed_execution_payload_bid
-//	bid = signed_bid.message
-//	builder_index = bid.builder_index
-//	amount = bid.value
-//	if builder_index == BUILDER_INDEX_SELF_BUILD:
-//	  assert amount == 0
-//	  assert signed_bid.signature == G2_POINT_AT_INFINITY
-//	else:
-//	  assert is_active_builder(state, builder_index)
-//	  assert can_builder_cover_bid(state, builder_index, amount)
-//	  assert verify_execution_payload_bid_signature(state, signed_bid)
-//	assert bid.slot == block.slot
-//	assert bid.parent_block_hash == state.latest_block_hash
-//	assert bid.parent_block_root == block.parent_root
-//	assert bid.prev_randao == get_randao_mix(state, get_current_epoch(state))
-//	if amount > 0:
-//	  state.builder_pending_payments[...] = BuilderPendingPayment(weight=0, withdrawal=BuilderPendingWithdrawal(fee_recipient=bid.fee_recipient, amount=amount, builder_index=builder_index))
-//	state.latest_execution_payload_bid = bid
+//	<spec fn="process_execution_payload_bid" fork="gloas" hash="823c9f3a">
+//	def process_execution_payload_bid(state: BeaconState, block: BeaconBlock) -> None:
+//	    signed_bid = block.body.signed_execution_payload_bid
+//	    bid = signed_bid.message
+//	    builder_index = bid.builder_index
+//	    amount = bid.value
+//
+//	    # For self-builds, amount must be zero regardless of withdrawal credential prefix
+//	    if builder_index == BUILDER_INDEX_SELF_BUILD:
+//	        assert amount == 0
+//	        assert signed_bid.signature == bls.G2_POINT_AT_INFINITY
+//	    else:
+//	        # Verify that the builder is active
+//	        assert is_active_builder(state, builder_index)
+//	        # Verify that the builder has funds to cover the bid
+//	        assert can_builder_cover_bid(state, builder_index, amount)
+//	        # 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
+//	    assert bid.parent_block_hash == state.latest_block_hash
+//	    assert bid.parent_block_root == block.parent_root
+//	    assert bid.prev_randao == get_randao_mix(state, get_current_epoch(state))
+//
+//	    # Record the pending payment if there is some payment
+//	    if amount > 0:
+//	        pending_payment = BuilderPendingPayment(
+//	            weight=0,
+//	            withdrawal=BuilderPendingWithdrawal(
+//	                fee_recipient=bid.fee_recipient,
+//	                amount=amount,
+//	                builder_index=builder_index,
+//	            ),
+//	        )
+//	        state.builder_pending_payments[SLOTS_PER_EPOCH + bid.slot % SLOTS_PER_EPOCH] = (
+//	            pending_payment
+//	        )
+//
+//	    # Cache the signed execution payload bid
+//	    state.latest_execution_payload_bid = bid
+//	</spec>
 func ProcessExecutionPayloadBid(st state.BeaconState, block interfaces.ReadOnlyBeaconBlock) error {
 	signedBid, err := block.Body().SignedExecutionPayloadBid()
 	if err != nil {
@@ -86,6 +115,12 @@ 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,6 +184,28 @@ 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)
@@ -194,17 +216,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,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
-		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,
+		BlobKzgCommitments: blobCommitmentsForSlot(slot, 1),
+		FeeRecipient:       bytes.Repeat([]byte{0xFF}, 20),
 	}
 	signed := &ethpb.SignedExecutionPayloadBid{
 		Message:   bid,
@@ -236,16 +258,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,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xCC}, 32),
-		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,
+		BlobKzgCommitments: blobCommitmentsForSlot(slot, 1),
+		FeeRecipient:       bytes.Repeat([]byte{0xDD}, 20),
 	}
 	signed := &ethpb.SignedExecutionPayloadBid{
 		Message:   bid,
@@ -280,17 +302,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,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
-		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,
+		BlobKzgCommitments: blobCommitmentsForSlot(slot, 1),
+		FeeRecipient:       bytes.Repeat([]byte{0xFF}, 20),
 	}
 
 	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
@@ -341,17 +363,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,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x05}, 32),
-		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,
+		BlobKzgCommitments: blobCommitmentsForSlot(slot, 1),
+		FeeRecipient:       bytes.Repeat([]byte{0x06}, 20),
 	}
 	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
 	sig := signBid(t, sk, bid, state.Fork(), genesis)
@@ -394,17 +416,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,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
-		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,
+		BlobKzgCommitments: blobCommitmentsForSlot(slot, 1),
+		FeeRecipient:       bytes.Repeat([]byte{0xFF}, 20),
 	}
 	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
 	sig := signBid(t, sk, bid, state.Fork(), genesis)
@@ -436,17 +458,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,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
-		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,
+		BlobKzgCommitments: blobCommitmentsForSlot(slot, 1),
+		FeeRecipient:       bytes.Repeat([]byte{0xFF}, 20),
 	}
 	// Use an invalid signature.
 	invalidSig := [96]byte{1}
@@ -463,6 +485,42 @@ 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)
@@ -478,17 +536,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,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xCC}, 32),
-		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,
+		BlobKzgCommitments: blobCommitmentsForSlot(slot, 1),
+		FeeRecipient:       bytes.Repeat([]byte{0xDD}, 20),
 	}
 	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
 	sig := signBid(t, sk, bid, state.Fork(), genesis)
@@ -520,17 +578,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,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x44}, 32),
-		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,
+		BlobKzgCommitments: blobCommitmentsForSlot(slot, 1),
+		FeeRecipient:       bytes.Repeat([]byte{0x55}, 20),
 	}
 	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
 	sig := signBid(t, sk, bid, state.Fork(), genesis)
@@ -563,17 +621,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,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x44}, 32),
-		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,
+		BlobKzgCommitments: blobCommitmentsForSlot(slot, 1),
+		FeeRecipient:       bytes.Repeat([]byte{0x55}, 20),
 	}
 	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
 	sig := signBid(t, sk, bid, state.Fork(), genesis)
@@ -605,17 +663,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,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x44}, 32),
-		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,
+		BlobKzgCommitments: blobCommitmentsForSlot(slot, 1),
+		FeeRecipient:       bytes.Repeat([]byte{0x55}, 20),
 	}
 	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
 	sig := signBid(t, sk, bid, state.Fork(), genesis)

beacon-chain/core/gloas/deposit_request.go

@@ -0,0 +1,180 @@
+package gloas
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
+	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/runtime/version"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+)
+
+func processDepositRequests(ctx context.Context, beaconState state.BeaconState, requests []*enginev1.DepositRequest) error {
+	if len(requests) == 0 {
+		return nil
+	}
+
+	for _, receipt := range requests {
+		if err := processDepositRequest(beaconState, receipt); err != nil {
+			return errors.Wrap(err, "could not apply deposit request")
+		}
+	}
+	return nil
+}
+
+// processDepositRequest processes the specific deposit request
+//
+//	<spec fn="process_deposit_request" fork="gloas" hash="3c6b0310">
+//	def process_deposit_request(state: BeaconState, deposit_request: DepositRequest) -> None:
+//	    # [New in Gloas:EIP7732]
+//	    builder_pubkeys = [b.pubkey for b in state.builders]
+//	    validator_pubkeys = [v.pubkey for v in state.validators]
+//
+//	    # [New in Gloas:EIP7732]
+//	    # Regardless of the withdrawal credentials prefix, if a builder/validator
+//	    # already exists with this pubkey, apply the deposit to their balance
+//	    is_builder = deposit_request.pubkey in builder_pubkeys
+//	    is_validator = deposit_request.pubkey in validator_pubkeys
+//	    is_builder_prefix = is_builder_withdrawal_credential(deposit_request.withdrawal_credentials)
+//	    if is_builder or (is_builder_prefix and not is_validator):
+//	        # Apply builder deposits immediately
+//	        apply_deposit_for_builder(
+//	            state,
+//	            deposit_request.pubkey,
+//	            deposit_request.withdrawal_credentials,
+//	            deposit_request.amount,
+//	            deposit_request.signature,
+//	            state.slot,
+//	        )
+//	        return
+//
+//	    # Add validator deposits to the queue
+//	    state.pending_deposits.append(
+//	        PendingDeposit(
+//	            pubkey=deposit_request.pubkey,
+//	            withdrawal_credentials=deposit_request.withdrawal_credentials,
+//	            amount=deposit_request.amount,
+//	            signature=deposit_request.signature,
+//	            slot=state.slot,
+//	        )
+//	    )
+//	</spec>
+func processDepositRequest(beaconState state.BeaconState, request *enginev1.DepositRequest) error {
+	if request == nil {
+		return errors.New("nil deposit request")
+	}
+
+	applied, err := applyBuilderDepositRequest(beaconState, request)
+	if err != nil {
+		return errors.Wrap(err, "could not apply builder deposit")
+	}
+	if applied {
+		return nil
+	}
+
+	if err := beaconState.AppendPendingDeposit(&ethpb.PendingDeposit{
+		PublicKey:             request.Pubkey,
+		WithdrawalCredentials: request.WithdrawalCredentials,
+		Amount:                request.Amount,
+		Signature:             request.Signature,
+		Slot:                  beaconState.Slot(),
+	}); err != nil {
+		return errors.Wrap(err, "could not append deposit request")
+	}
+	return nil
+}
+
+// <spec fn="apply_deposit_for_builder" fork="gloas" hash="e4bc98c7">
+// def apply_deposit_for_builder(
+//
+//	state: BeaconState,
+//	pubkey: BLSPubkey,
+//	withdrawal_credentials: Bytes32,
+//	amount: uint64,
+//	signature: BLSSignature,
+//	slot: Slot,
+//
+// ) -> None:
+//
+//	builder_pubkeys = [b.pubkey for b in state.builders]
+//	if pubkey not in builder_pubkeys:
+//	    # Verify the deposit signature (proof of possession) which is not checked by the deposit contract
+//	    if is_valid_deposit_signature(pubkey, withdrawal_credentials, amount, signature):
+//	        add_builder_to_registry(state, pubkey, withdrawal_credentials, amount, slot)
+//	else:
+//	    # Increase balance by deposit amount
+//	    builder_index = builder_pubkeys.index(pubkey)
+//	    state.builders[builder_index].balance += amount
+//
+// </spec>
+func applyBuilderDepositRequest(beaconState state.BeaconState, request *enginev1.DepositRequest) (bool, error) {
+	if beaconState.Version() < version.Gloas {
+		return false, nil
+	}
+
+	pubkey := bytesutil.ToBytes48(request.Pubkey)
+	_, isValidator := beaconState.ValidatorIndexByPubkey(pubkey)
+	idx, isBuilder := beaconState.BuilderIndexByPubkey(pubkey)
+	isBuilderPrefix := IsBuilderWithdrawalCredential(request.WithdrawalCredentials)
+	if !isBuilder && (!isBuilderPrefix || isValidator) {
+		return false, nil
+	}
+
+	if isBuilder {
+		if err := beaconState.IncreaseBuilderBalance(idx, request.Amount); err != nil {
+			return false, err
+		}
+		return true, nil
+	}
+
+	if err := applyDepositForNewBuilder(
+		beaconState,
+		request.Pubkey,
+		request.WithdrawalCredentials,
+		request.Amount,
+		request.Signature,
+	); err != nil {
+		return false, err
+	}
+	return true, nil
+}
+
+func applyDepositForNewBuilder(
+	beaconState state.BeaconState,
+	pubkey []byte,
+	withdrawalCredentials []byte,
+	amount uint64,
+	signature []byte,
+) error {
+	pubkeyBytes := bytesutil.ToBytes48(pubkey)
+	valid, err := helpers.IsValidDepositSignature(&ethpb.Deposit_Data{
+		PublicKey:             pubkey,
+		WithdrawalCredentials: withdrawalCredentials,
+		Amount:                amount,
+		Signature:             signature,
+	})
+	if err != nil {
+		return errors.Wrap(err, "could not verify deposit signature")
+	}
+	if !valid {
+		log.WithFields(logrus.Fields{
+			"pubkey": fmt.Sprintf("%x", pubkey),
+		}).Warn("ignoring builder deposit: invalid signature")
+		return nil
+	}
+
+	withdrawalCredBytes := bytesutil.ToBytes32(withdrawalCredentials)
+	return beaconState.AddBuilderFromDeposit(pubkeyBytes, withdrawalCredBytes, amount)
+}
+
+func IsBuilderWithdrawalCredential(withdrawalCredentials []byte) bool {
+	return len(withdrawalCredentials) == fieldparams.RootLength &&
+		withdrawalCredentials[0] == params.BeaconConfig().BuilderWithdrawalPrefixByte
+}

beacon-chain/core/gloas/deposit_request_test.go

@@ -0,0 +1,150 @@
+package gloas
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
+	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
+	stateTesting "github.com/OffchainLabs/prysm/v7/beacon-chain/state/testing"
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/crypto/bls"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+)
+
+func TestProcessDepositRequests_EmptyAndNil(t *testing.T) {
+	st := newGloasState(t, nil, nil)
+
+	t.Run("empty requests continues", func(t *testing.T) {
+		err := processDepositRequests(t.Context(), st, []*enginev1.DepositRequest{})
+		require.NoError(t, err)
+	})
+
+	t.Run("nil request errors", func(t *testing.T) {
+		err := processDepositRequests(t.Context(), st, []*enginev1.DepositRequest{nil})
+		require.ErrorContains(t, "nil deposit request", err)
+	})
+}
+
+func TestProcessDepositRequest_BuilderDepositAddsBuilder(t *testing.T) {
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+
+	cred := builderWithdrawalCredentials()
+	pd := stateTesting.GeneratePendingDeposit(t, sk, 1234, cred, 0)
+	req := depositRequestFromPending(pd, 1)
+
+	st := newGloasState(t, nil, nil)
+	err = processDepositRequest(st, req)
+	require.NoError(t, err)
+
+	idx, ok := st.BuilderIndexByPubkey(toBytes48(req.Pubkey))
+	require.Equal(t, true, ok)
+
+	builder, err := st.Builder(idx)
+	require.NoError(t, err)
+	require.NotNil(t, builder)
+	require.DeepEqual(t, req.Pubkey, builder.Pubkey)
+	require.DeepEqual(t, []byte{cred[0]}, builder.Version)
+	require.DeepEqual(t, cred[12:], builder.ExecutionAddress)
+	require.Equal(t, uint64(1234), uint64(builder.Balance))
+	require.Equal(t, params.BeaconConfig().FarFutureEpoch, builder.WithdrawableEpoch)
+
+	pending, err := st.PendingDeposits()
+	require.NoError(t, err)
+	require.Equal(t, 0, len(pending))
+}
+
+func TestProcessDepositRequest_ExistingBuilderIncreasesBalance(t *testing.T) {
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+
+	pubkey := sk.PublicKey().Marshal()
+	builders := []*ethpb.Builder{
+		{
+			Pubkey:            pubkey,
+			Version:           []byte{0},
+			ExecutionAddress:  bytes.Repeat([]byte{0x11}, 20),
+			Balance:           5,
+			WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
+		},
+	}
+	st := newGloasState(t, nil, builders)
+
+	cred := validatorWithdrawalCredentials()
+	pd := stateTesting.GeneratePendingDeposit(t, sk, 200, cred, 0)
+	req := depositRequestFromPending(pd, 9)
+
+	err = processDepositRequest(st, req)
+	require.NoError(t, err)
+
+	idx, ok := st.BuilderIndexByPubkey(toBytes48(pubkey))
+	require.Equal(t, true, ok)
+	builder, err := st.Builder(idx)
+	require.NoError(t, err)
+	require.Equal(t, uint64(205), uint64(builder.Balance))
+
+	pending, err := st.PendingDeposits()
+	require.NoError(t, err)
+	require.Equal(t, 0, len(pending))
+}
+
+func TestApplyDepositForBuilder_InvalidSignatureIgnoresDeposit(t *testing.T) {
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+
+	cred := builderWithdrawalCredentials()
+	st := newGloasState(t, nil, nil)
+	err = applyDepositForNewBuilder(st, sk.PublicKey().Marshal(), cred[:], 100, make([]byte, 96))
+	require.NoError(t, err)
+
+	_, ok := st.BuilderIndexByPubkey(toBytes48(sk.PublicKey().Marshal()))
+	require.Equal(t, false, ok)
+}
+
+func newGloasState(t *testing.T, validators []*ethpb.Validator, builders []*ethpb.Builder) state.BeaconState {
+	t.Helper()
+
+	st, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
+		DepositRequestsStartIndex: params.BeaconConfig().UnsetDepositRequestsStartIndex,
+		Validators:                validators,
+		Balances:                  make([]uint64, len(validators)),
+		PendingDeposits:           []*ethpb.PendingDeposit{},
+		Builders:                  builders,
+	})
+	require.NoError(t, err)
+
+	return st
+}
+
+func depositRequestFromPending(pd *ethpb.PendingDeposit, index uint64) *enginev1.DepositRequest {
+	return &enginev1.DepositRequest{
+		Pubkey:                pd.PublicKey,
+		WithdrawalCredentials: pd.WithdrawalCredentials,
+		Amount:                pd.Amount,
+		Signature:             pd.Signature,
+		Index:                 index,
+	}
+}
+
+func builderWithdrawalCredentials() [32]byte {
+	var cred [32]byte
+	cred[0] = params.BeaconConfig().BuilderWithdrawalPrefixByte
+	copy(cred[12:], bytes.Repeat([]byte{0x22}, 20))
+	return cred
+}
+
+func validatorWithdrawalCredentials() [32]byte {
+	var cred [32]byte
+	cred[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+	copy(cred[12:], bytes.Repeat([]byte{0x33}, 20))
+	return cred
+}
+
+func toBytes48(b []byte) [48]byte {
+	var out [48]byte
+	copy(out[:], b)
+	return out
+}

beacon-chain/core/gloas/log.go

@@ -0,0 +1,9 @@
+// Code generated by hack/gen-logs.sh; DO NOT EDIT.
+// This file is created and regenerated automatically. Anything added here might get removed.
+package gloas
+
+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", "beacon-chain/core/gloas")

beacon-chain/core/gloas/payload.go

@@ -0,0 +1,361 @@
+package gloas
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	requests "github.com/OffchainLabs/prysm/v7/beacon-chain/core/requests"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v7/crypto/bls"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
+	"github.com/OffchainLabs/prysm/v7/time/slots"
+	"github.com/pkg/errors"
+)
+
+// ProcessExecutionPayload processes the signed execution payload envelope for the Gloas fork.
+//
+//	<spec fn="process_execution_payload" fork="gloas" hash="36bd3af3">
+//	def process_execution_payload(
+//	    state: BeaconState,
+//	    # [Modified in Gloas:EIP7732]
+//	    # Removed `body`
+//	    # [New in Gloas:EIP7732]
+//	    signed_envelope: SignedExecutionPayloadEnvelope,
+//	    execution_engine: ExecutionEngine,
+//	    # [New in Gloas:EIP7732]
+//	    verify: bool = True,
+//	) -> None:
+//	    envelope = signed_envelope.message
+//	    payload = envelope.payload
+//
+//	    # Verify signature
+//	    if verify:
+//	        assert verify_execution_payload_envelope_signature(state, signed_envelope)
+//
+//	    # Cache latest block header state root
+//	    previous_state_root = hash_tree_root(state)
+//	    if state.latest_block_header.state_root == Root():
+//	        state.latest_block_header.state_root = previous_state_root
+//
+//	    # Verify consistency with the beacon block
+//	    assert envelope.beacon_block_root == hash_tree_root(state.latest_block_header)
+//	    assert envelope.slot == state.slot
+//
+//	    # Verify consistency with the committed bid
+//	    committed_bid = state.latest_execution_payload_bid
+//	    assert envelope.builder_index == committed_bid.builder_index
+//	    assert committed_bid.prev_randao == payload.prev_randao
+//
+//	    # Verify consistency with expected withdrawals
+//	    assert hash_tree_root(payload.withdrawals) == hash_tree_root(state.payload_expected_withdrawals)
+//
+//	    # Verify the gas_limit
+//	    assert committed_bid.gas_limit == payload.gas_limit
+//	    # Verify the block hash
+//	    assert committed_bid.block_hash == payload.block_hash
+//	    # Verify consistency of the parent hash with respect to the previous execution payload
+//	    assert payload.parent_hash == state.latest_block_hash
+//	    # Verify timestamp
+//	    assert payload.timestamp == compute_time_at_slot(state, state.slot)
+//	    # Verify the execution payload is valid
+//	    versioned_hashes = [
+//	        kzg_commitment_to_versioned_hash(commitment)
+//	        # [Modified in Gloas:EIP7732]
+//	        for commitment in committed_bid.blob_kzg_commitments
+//	    ]
+//	    requests = envelope.execution_requests
+//	    assert execution_engine.verify_and_notify_new_payload(
+//	        NewPayloadRequest(
+//	            execution_payload=payload,
+//	            versioned_hashes=versioned_hashes,
+//	            parent_beacon_block_root=state.latest_block_header.parent_root,
+//	            execution_requests=requests,
+//	        )
+//	    )
+//
+//	    def for_ops(operations: Sequence[Any], fn: Callable[[BeaconState, Any], None]) -> None:
+//	        for operation in operations:
+//	            fn(state, operation)
+//
+//	    for_ops(requests.deposits, process_deposit_request)
+//	    for_ops(requests.withdrawals, process_withdrawal_request)
+//	    for_ops(requests.consolidations, process_consolidation_request)
+//
+//	    # Queue the builder payment
+//	    payment = state.builder_pending_payments[SLOTS_PER_EPOCH + state.slot % SLOTS_PER_EPOCH]
+//	    amount = payment.withdrawal.amount
+//	    if amount > 0:
+//	        state.builder_pending_withdrawals.append(payment.withdrawal)
+//	    state.builder_pending_payments[SLOTS_PER_EPOCH + state.slot % SLOTS_PER_EPOCH] = (
+//	        BuilderPendingPayment()
+//	    )
+//
+//	    # Cache the execution payload hash
+//	    state.execution_payload_availability[state.slot % SLOTS_PER_HISTORICAL_ROOT] = 0b1
+//	    state.latest_block_hash = payload.block_hash
+//
+//	    # Verify the state root
+//	    if verify:
+//	        assert envelope.state_root == hash_tree_root(state)
+//	</spec>
+func ProcessExecutionPayload(
+	ctx context.Context,
+	st state.BeaconState,
+	signedEnvelope interfaces.ROSignedExecutionPayloadEnvelope,
+) error {
+	if err := verifyExecutionPayloadEnvelopeSignature(st, signedEnvelope); err != nil {
+		return errors.Wrap(err, "signature verification failed")
+	}
+
+	envelope, err := signedEnvelope.Envelope()
+	if err != nil {
+		return errors.Wrap(err, "could not get envelope from signed envelope")
+	}
+
+	if err := ApplyExecutionPayload(ctx, st, envelope); err != nil {
+		return err
+	}
+
+	r, err := st.HashTreeRoot(ctx)
+	if err != nil {
+		return errors.Wrap(err, "could not get hash tree root")
+	}
+	if r != envelope.StateRoot() {
+		return fmt.Errorf("state root mismatch: expected %#x, got %#x", envelope.StateRoot(), r)
+	}
+
+	return nil
+}
+
+// ApplyExecutionPayload applies the execution payload envelope to the state and performs the same
+// consistency checks as the full processing path. This keeps the post-payload state root computation
+// on a shared code path, even though some bid/payload checks are not strictly required for the root itself.
+func ApplyExecutionPayload(
+	ctx context.Context,
+	st state.BeaconState,
+	envelope interfaces.ROExecutionPayloadEnvelope,
+) error {
+	latestHeader := st.LatestBlockHeader()
+	if len(latestHeader.StateRoot) == 0 || bytes.Equal(latestHeader.StateRoot, make([]byte, 32)) {
+		previousStateRoot, err := st.HashTreeRoot(ctx)
+		if err != nil {
+			return errors.Wrap(err, "could not compute state root")
+		}
+		latestHeader.StateRoot = previousStateRoot[:]
+		if err := st.SetLatestBlockHeader(latestHeader); err != nil {
+			return errors.Wrap(err, "could not set latest block header")
+		}
+	}
+
+	blockHeaderRoot, err := latestHeader.HashTreeRoot()
+	if err != nil {
+		return errors.Wrap(err, "could not compute block header root")
+	}
+
+	beaconBlockRoot := envelope.BeaconBlockRoot()
+	if !bytes.Equal(beaconBlockRoot[:], blockHeaderRoot[:]) {
+		return errors.Errorf("envelope beacon block root does not match state latest block header root: envelope=%#x, header=%#x", beaconBlockRoot, blockHeaderRoot)
+	}
+
+	if envelope.Slot() != st.Slot() {
+		return errors.Errorf("envelope slot does not match state slot: envelope=%d, state=%d", envelope.Slot(), st.Slot())
+	}
+
+	latestBid, err := st.LatestExecutionPayloadBid()
+	if err != nil {
+		return errors.Wrap(err, "could not get latest execution payload bid")
+	}
+	if latestBid == nil {
+		return errors.New("latest execution payload bid is nil")
+	}
+	if envelope.BuilderIndex() != latestBid.BuilderIndex() {
+		return errors.Errorf("envelope builder index does not match committed bid builder index: envelope=%d, bid=%d", envelope.BuilderIndex(), latestBid.BuilderIndex())
+	}
+
+	payload, err := envelope.Execution()
+	if err != nil {
+		return errors.Wrap(err, "could not get execution payload from envelope")
+	}
+	latestBidPrevRandao := latestBid.PrevRandao()
+	if !bytes.Equal(payload.PrevRandao(), latestBidPrevRandao[:]) {
+		return errors.Errorf("payload prev randao does not match committed bid prev randao: payload=%#x, bid=%#x", payload.PrevRandao(), latestBidPrevRandao)
+	}
+
+	withdrawals, err := payload.Withdrawals()
+	if err != nil {
+		return errors.Wrap(err, "could not get withdrawals from payload")
+	}
+
+	ok, err := st.WithdrawalsMatchPayloadExpected(withdrawals)
+	if err != nil {
+		return errors.Wrap(err, "could not validate payload withdrawals")
+	}
+	if !ok {
+		return errors.New("payload withdrawals do not match expected withdrawals")
+	}
+
+	if latestBid.GasLimit() != payload.GasLimit() {
+		return errors.Errorf("committed bid gas limit does not match payload gas limit: bid=%d, payload=%d", latestBid.GasLimit(), payload.GasLimit())
+	}
+
+	bidBlockHash := latestBid.BlockHash()
+	payloadBlockHash := payload.BlockHash()
+	if !bytes.Equal(bidBlockHash[:], payloadBlockHash) {
+		return errors.Errorf("committed bid block hash does not match payload block hash: bid=%#x, payload=%#x", bidBlockHash, payloadBlockHash)
+	}
+
+	latestBlockHash, err := st.LatestBlockHash()
+	if err != nil {
+		return errors.Wrap(err, "could not get latest block hash")
+	}
+	if !bytes.Equal(payload.ParentHash(), latestBlockHash[:]) {
+		return errors.Errorf("payload parent hash does not match state latest block hash: payload=%#x, state=%#x", payload.ParentHash(), latestBlockHash)
+	}
+
+	t, err := slots.StartTime(st.GenesisTime(), st.Slot())
+	if err != nil {
+		return errors.Wrap(err, "could not compute timestamp")
+	}
+	if payload.Timestamp() != uint64(t.Unix()) {
+		return errors.Errorf("payload timestamp does not match expected timestamp: payload=%d, expected=%d", payload.Timestamp(), uint64(t.Unix()))
+	}
+
+	if err := processExecutionRequests(ctx, st, envelope.ExecutionRequests()); err != nil {
+		return errors.Wrap(err, "could not process execution requests")
+	}
+
+	if err := st.QueueBuilderPayment(); err != nil {
+		return errors.Wrap(err, "could not queue builder payment")
+	}
+
+	if err := st.SetExecutionPayloadAvailability(st.Slot(), true); err != nil {
+		return errors.Wrap(err, "could not set execution payload availability")
+	}
+
+	if err := st.SetLatestBlockHash([32]byte(payload.BlockHash())); err != nil {
+		return errors.Wrap(err, "could not set latest block hash")
+	}
+
+	return nil
+}
+
+func envelopePublicKey(st state.BeaconState, builderIdx primitives.BuilderIndex) (bls.PublicKey, error) {
+	if builderIdx == params.BeaconConfig().BuilderIndexSelfBuild {
+		return proposerPublicKey(st)
+	}
+	return builderPublicKey(st, builderIdx)
+}
+
+func proposerPublicKey(st state.BeaconState) (bls.PublicKey, error) {
+	header := st.LatestBlockHeader()
+	if header == nil {
+		return nil, fmt.Errorf("latest block header is nil")
+	}
+	proposerPubkey := st.PubkeyAtIndex(header.ProposerIndex)
+	publicKey, err := bls.PublicKeyFromBytes(proposerPubkey[:])
+	if err != nil {
+		return nil, fmt.Errorf("invalid proposer public key: %w", err)
+	}
+	return publicKey, nil
+}
+
+func builderPublicKey(st state.BeaconState, builderIdx primitives.BuilderIndex) (bls.PublicKey, error) {
+	builder, err := st.Builder(builderIdx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get builder: %w", err)
+	}
+	if builder == nil {
+		return nil, fmt.Errorf("builder at index %d not found", builderIdx)
+	}
+	publicKey, err := bls.PublicKeyFromBytes(builder.Pubkey)
+	if err != nil {
+		return nil, fmt.Errorf("invalid builder public key: %w", err)
+	}
+	return publicKey, nil
+}
+
+// processExecutionRequests processes deposits, withdrawals, and consolidations from execution requests.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// for op in requests.deposits: process_deposit_request(state, op)
+// for op in requests.withdrawals: process_withdrawal_request(state, op)
+// for op in requests.consolidations: process_consolidation_request(state, op)
+func processExecutionRequests(ctx context.Context, st state.BeaconState, rqs *enginev1.ExecutionRequests) error {
+	if err := processDepositRequests(ctx, st, rqs.Deposits); err != nil {
+		return errors.Wrap(err, "could not process deposit requests")
+	}
+
+	var err error
+	st, err = requests.ProcessWithdrawalRequests(ctx, st, rqs.Withdrawals)
+	if err != nil {
+		return errors.Wrap(err, "could not process withdrawal requests")
+	}
+	err = requests.ProcessConsolidationRequests(ctx, st, rqs.Consolidations)
+	if err != nil {
+		return errors.Wrap(err, "could not process consolidation requests")
+	}
+	return nil
+}
+
+// verifyExecutionPayloadEnvelopeSignature verifies the BLS signature on a signed execution payload envelope.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// builder_index = signed_envelope.message.builder_index
+// if builder_index == BUILDER_INDEX_SELF_BUILD:
+//
+//	validator_index = state.latest_block_header.proposer_index
+//	pubkey = state.validators[validator_index].pubkey
+//
+// else:
+//
+//	pubkey = state.builders[builder_index].pubkey
+//
+// signing_root = compute_signing_root(
+//
+//	signed_envelope.message, get_domain(state, DOMAIN_BEACON_BUILDER)
+//
+// )
+// return bls.Verify(pubkey, signing_root, signed_envelope.signature)
+func verifyExecutionPayloadEnvelopeSignature(st state.BeaconState, signedEnvelope interfaces.ROSignedExecutionPayloadEnvelope) error {
+	envelope, err := signedEnvelope.Envelope()
+	if err != nil {
+		return fmt.Errorf("failed to get envelope: %w", err)
+	}
+
+	builderIdx := envelope.BuilderIndex()
+	publicKey, err := envelopePublicKey(st, builderIdx)
+	if err != nil {
+		return err
+	}
+
+	signatureBytes := signedEnvelope.Signature()
+	signature, err := bls.SignatureFromBytes(signatureBytes[:])
+	if err != nil {
+		return fmt.Errorf("invalid signature format: %w", err)
+	}
+
+	currentEpoch := slots.ToEpoch(envelope.Slot())
+	domain, err := signing.Domain(
+		st.Fork(),
+		currentEpoch,
+		params.BeaconConfig().DomainBeaconBuilder,
+		st.GenesisValidatorsRoot(),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to compute signing domain: %w", err)
+	}
+
+	signingRoot, err := signedEnvelope.SigningRoot(domain)
+	if err != nil {
+		return fmt.Errorf("failed to compute signing root: %w", err)
+	}
+
+	if !signature.Verify(publicKey, signingRoot[:]) {
+		return fmt.Errorf("signature verification failed: %w", signing.ErrSigFailedToVerify)
+	}
+
+	return nil
+}

beacon-chain/core/gloas/payload_attestation.go

@@ -24,14 +24,21 @@ import (
 )
 
 // ProcessPayloadAttestations validates payload attestations in a block body.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// process_payload_attestation(state: BeaconState, payload_attestation: PayloadAttestation):
 //
-//	data = payload_attestation.data
-//	assert data.beacon_block_root == state.latest_block_header.parent_root
-//	assert data.slot + 1 == state.slot
-//	indexed = get_indexed_payload_attestation(state, data.slot, payload_attestation)
-//	assert is_valid_indexed_payload_attestation(state, indexed)
+//	<spec fn="process_payload_attestation" fork="gloas" hash="f46bf0b0">
+//	def process_payload_attestation(
+//	    state: BeaconState, payload_attestation: PayloadAttestation
+//	) -> None:
+//	    data = payload_attestation.data
+//
+//	    # Check that the attestation is for the parent beacon block
+//	    assert data.beacon_block_root == state.latest_block_header.parent_root
+//	    # Check that the attestation is for the previous slot
+//	    assert data.slot + 1 == state.slot
+//	    # Verify signature
+//	    indexed_payload_attestation = get_indexed_payload_attestation(state, payload_attestation)
+//	    assert is_valid_indexed_payload_attestation(state, indexed_payload_attestation)
+//	</spec>
 func ProcessPayloadAttestations(ctx context.Context, st state.BeaconState, body interfaces.ReadOnlyBeaconBlockBody) error {
 	atts, err := body.PayloadAttestations()
 	if err != nil {
@@ -70,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
 	}
@@ -89,19 +96,26 @@ func indexedPayloadAttestation(ctx context.Context, st state.ReadOnlyBeaconState
 	}, nil
 }
 
-// payloadCommittee returns the payload timeliness committee for a given slot for the state.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// get_ptc(state: BeaconState, slot: Slot) -> Vector[ValidatorIndex, PTC_SIZE]:
+// PayloadCommittee returns the payload timeliness committee for a given slot for the state.
 //
-//	epoch = compute_epoch_at_slot(slot)
-//	seed = hash(get_seed(state, epoch, DOMAIN_PTC_ATTESTER) + uint_to_bytes(slot))
-//	indices = []
-//	committees_per_slot = get_committee_count_per_slot(state, epoch)
-//	for i in range(committees_per_slot):
-//	  committee = get_beacon_committee(state, slot, CommitteeIndex(i))
-//	  indices.extend(committee)
-//	return compute_balance_weighted_selection(state, indices, seed, size=PTC_SIZE, shuffle_indices=False)
-func payloadCommittee(ctx context.Context, st state.ReadOnlyBeaconState, slot primitives.Slot) ([]primitives.ValidatorIndex, error) {
+//	<spec fn="get_ptc" fork="gloas" hash="ae15f761">
+//	def get_ptc(state: BeaconState, slot: Slot) -> Vector[ValidatorIndex, PTC_SIZE]:
+//	    """
+//	    Get the payload timeliness committee for the given ``slot``.
+//	    """
+//	    epoch = compute_epoch_at_slot(slot)
+//	    seed = hash(get_seed(state, epoch, DOMAIN_PTC_ATTESTER) + uint_to_bytes(slot))
+//	    indices: List[ValidatorIndex] = []
+//	    # Concatenate all committees for this slot in order
+//	    committees_per_slot = get_committee_count_per_slot(state, epoch)
+//	    for i in range(committees_per_slot):
+//	        committee = get_beacon_committee(state, slot, CommitteeIndex(i))
+//	        indices.extend(committee)
+//	    return compute_balance_weighted_selection(
+//	        state, indices, seed, size=PTC_SIZE, shuffle_indices=False
+//	    )
+//	</spec>
+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 {
@@ -114,17 +128,32 @@ func payloadCommittee(ctx context.Context, st state.ReadOnlyBeaconState, slot pr
 	}
 
 	committeesPerSlot := helpers.SlotCommitteeCount(activeCount)
-	out := make([]primitives.ValidatorIndex, 0, activeCount/uint64(params.BeaconConfig().SlotsPerEpoch))
 
-	for i := primitives.CommitteeIndex(0); i < primitives.CommitteeIndex(committeesPerSlot); i++ {
-		committee, err := helpers.BeaconCommitteeFromState(ctx, st, slot, i)
-		if err != nil {
-			return nil, errors.Wrapf(err, "failed to get beacon committee %d", i)
+	selected := make([]primitives.ValidatorIndex, 0, fieldparams.PTCSize)
+	var i uint64
+	for uint64(len(selected)) < fieldparams.PTCSize {
+		if ctx.Err() != nil {
+			return nil, ctx.Err()
+		}
+
+		for committeeIndex := primitives.CommitteeIndex(0); committeeIndex < primitives.CommitteeIndex(committeesPerSlot); committeeIndex++ {
+			if uint64(len(selected)) >= fieldparams.PTCSize {
+				break
+			}
+
+			committee, err := helpers.BeaconCommitteeFromState(ctx, st, slot, committeeIndex)
+			if err != nil {
+				return nil, errors.Wrapf(err, "failed to get beacon committee %d", committeeIndex)
+			}
+
+			selected, i, err = selectByBalanceFill(ctx, st, committee, seed, selected, i)
+			if err != nil {
+				return nil, errors.Wrapf(err, "failed to sample beacon committee %d", committeeIndex)
+			}
 		}
-		out = append(out, committee...)
 	}
 
-	return selectByBalance(ctx, st, out, seed, fieldparams.PTCSize)
+	return selected, nil
 }
 
 // ptcSeed computes the seed for the payload timeliness committee.
@@ -137,56 +166,87 @@ func ptcSeed(st state.ReadOnlyBeaconState, epoch primitives.Epoch, slot primitiv
 }
 
 // selectByBalance selects a balance-weighted subset of input candidates.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// compute_balance_weighted_selection(state, indices, seed, size, shuffle_indices):
-// Note: shuffle_indices is false for PTC.
 //
-//	total = len(indices); selected = []; i = 0
-//	while len(selected) < size:
-//	  next = i % total
-//	  if shuffle_indices: next = compute_shuffled_index(next, total, seed)
-//	  if compute_balance_weighted_acceptance(state, indices[next], seed, i):
-//	    selected.append(indices[next])
-//	  i += 1
-func selectByBalance(ctx context.Context, st state.ReadOnlyBeaconState, candidates []primitives.ValidatorIndex, seed [32]byte, count uint64) ([]primitives.ValidatorIndex, error) {
-	if len(candidates) == 0 {
-		return nil, errors.New("no candidates for balance weighted selection")
-	}
-
+//	<spec fn="compute_balance_weighted_selection" fork="gloas" hash="2c9f1c23">
+//	def compute_balance_weighted_selection(
+//	    state: BeaconState,
+//	    indices: Sequence[ValidatorIndex],
+//	    seed: Bytes32,
+//	    size: uint64,
+//	    shuffle_indices: bool,
+//	) -> Sequence[ValidatorIndex]:
+//	    """
+//	    Return ``size`` indices sampled by effective balance, using ``indices``
+//	    as candidates. If ``shuffle_indices`` is ``True``, candidate indices
+//	    are themselves sampled from ``indices`` by shuffling it, otherwise
+//	    ``indices`` is traversed in order.
+//	    """
+//	    total = uint64(len(indices))
+//	    assert total > 0
+//	    selected: List[ValidatorIndex] = []
+//	    i = uint64(0)
+//	    while len(selected) < size:
+//	        next_index = i % total
+//	        if shuffle_indices:
+//	            next_index = compute_shuffled_index(next_index, total, seed)
+//	        candidate_index = indices[next_index]
+//	        if compute_balance_weighted_acceptance(state, candidate_index, seed, i):
+//	            selected.append(candidate_index)
+//	        i += 1
+//	    return selected
+//	</spec>
+func selectByBalanceFill(
+	ctx context.Context,
+	st state.ReadOnlyBeaconState,
+	candidates []primitives.ValidatorIndex,
+	seed [32]byte,
+	selected []primitives.ValidatorIndex,
+	i uint64,
+) ([]primitives.ValidatorIndex, uint64, error) {
 	hashFunc := hash.CustomSHA256Hasher()
 	// Pre-allocate buffer for hash input: seed (32 bytes) + round counter (8 bytes).
 	var buf [40]byte
 	copy(buf[:], seed[:])
 	maxBalance := params.BeaconConfig().MaxEffectiveBalanceElectra
 
-	selected := make([]primitives.ValidatorIndex, 0, count)
-	total := uint64(len(candidates))
-	for i := uint64(0); uint64(len(selected)) < count; i++ {
+	for _, idx := range candidates {
 		if ctx.Err() != nil {
-			return nil, ctx.Err()
+			return nil, i, ctx.Err()
 		}
-		idx := candidates[i%total]
+
 		ok, err := acceptByBalance(st, idx, buf[:], hashFunc, maxBalance, i)
 		if err != nil {
-			return nil, err
+			return nil, i, err
 		}
 		if ok {
 			selected = append(selected, idx)
 		}
+		if uint64(len(selected)) == fieldparams.PTCSize {
+			break
+		}
+		i++
 	}
-	return selected, nil
+
+	return selected, i, nil
 }
 
 // acceptByBalance determines if a validator is accepted based on its effective balance.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// compute_balance_weighted_acceptance(state, index, seed, i):
 //
-//	MAX_RANDOM_VALUE = 2**16 - 1
-//	random_bytes = hash(seed + uint_to_bytes(i // 16))
-//	offset = i % 16 * 2
-//	random_value = bytes_to_uint64(random_bytes[offset:offset+2])
-//	effective_balance = state.validators[index].effective_balance
-//	return effective_balance * MAX_RANDOM_VALUE >= MAX_EFFECTIVE_BALANCE_ELECTRA * random_value
+//	<spec fn="compute_balance_weighted_acceptance" fork="gloas" hash="9954dcd0">
+//	def compute_balance_weighted_acceptance(
+//	    state: BeaconState, index: ValidatorIndex, seed: Bytes32, i: uint64
+//	) -> bool:
+//	    """
+//	    Return whether to accept the selection of the validator ``index``, with probability
+//	    proportional to its ``effective_balance``, and randomness given by ``seed`` and ``i``.
+//	    """
+//	    MAX_RANDOM_VALUE = 2**16 - 1
+//	    random_bytes = hash(seed + uint_to_bytes(i // 16))
+//	    offset = i % 16 * 2
+//	    random_value = bytes_to_uint64(random_bytes[offset : offset + 2])
+//	    effective_balance = state.validators[index].effective_balance
+//	    return effective_balance * MAX_RANDOM_VALUE >= MAX_EFFECTIVE_BALANCE_ELECTRA * random_value
+//	</spec>
 func acceptByBalance(st state.ReadOnlyBeaconState, idx primitives.ValidatorIndex, seedBuf []byte, hashFunc func([]byte) [32]byte, maxBalance uint64, round uint64) (bool, error) {
 	// Reuse the seed buffer by overwriting the last 8 bytes with the round counter.
 	binary.LittleEndian.PutUint64(seedBuf[len(seedBuf)-8:], round/16)
@@ -203,16 +263,26 @@ func acceptByBalance(st state.ReadOnlyBeaconState, idx primitives.ValidatorIndex
 }
 
 // validIndexedPayloadAttestation verifies the signature of an indexed payload attestation.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// is_valid_indexed_payload_attestation(state: BeaconState, indexed_payload_attestation: IndexedPayloadAttestation) -> bool:
 //
-//	indices = indexed_payload_attestation.attesting_indices
-//	return len(indices) > 0 and indices == sorted(indices) and
-//	  bls.FastAggregateVerify(
-//	    [state.validators[i].pubkey for i in indices],
-//	    compute_signing_root(indexed_payload_attestation.data, get_domain(state, DOMAIN_PTC_ATTESTER, compute_epoch_at_slot(attestation.data.slot)),
-//	    indexed_payload_attestation.signature,
-//	  )
+//	<spec fn="is_valid_indexed_payload_attestation" fork="gloas" hash="d76e0f89">
+//	def is_valid_indexed_payload_attestation(
+//	    state: BeaconState, attestation: IndexedPayloadAttestation
+//	) -> bool:
+//	    """
+//	    Check if ``attestation`` is non-empty, has sorted indices, and has
+//	    a valid aggregate signature.
+//	    """
+//	    # Verify indices are non-empty and sorted
+//	    indices = 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)
+//	</spec>
 func validIndexedPayloadAttestation(st state.ReadOnlyBeaconState, att *consensus_types.IndexedPayloadAttestation) error {
 	indices := att.AttestingIndices
 	if len(indices) == 0 || !slices.IsSorted(indices) {

beacon-chain/core/gloas/payload_test.go

@@ -0,0 +1,349 @@
+package gloas
+
+import (
+	"bytes"
+	"context"
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
+	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v7/crypto/bls"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+	"github.com/OffchainLabs/prysm/v7/time/slots"
+	"google.golang.org/protobuf/proto"
+)
+
+type payloadFixture struct {
+	state       state.BeaconState
+	signed      interfaces.ROSignedExecutionPayloadEnvelope
+	signedProto *ethpb.SignedExecutionPayloadEnvelope
+	envelope    *ethpb.ExecutionPayloadEnvelope
+	payload     *enginev1.ExecutionPayloadDeneb
+	slot        primitives.Slot
+}
+
+func buildPayloadFixture(t *testing.T, mutate func(payload *enginev1.ExecutionPayloadDeneb, bid *ethpb.ExecutionPayloadBid, envelope *ethpb.ExecutionPayloadEnvelope)) payloadFixture {
+	t.Helper()
+
+	cfg := params.BeaconConfig()
+	slot := primitives.Slot(5)
+	builderIdx := primitives.BuilderIndex(0)
+
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+	pk := sk.PublicKey().Marshal()
+
+	randao := bytes.Repeat([]byte{0xAA}, 32)
+	parentHash := bytes.Repeat([]byte{0xBB}, 32)
+	blockHash := bytes.Repeat([]byte{0xCC}, 32)
+
+	withdrawals := []*enginev1.Withdrawal{
+		{Index: 0, ValidatorIndex: 1, Address: bytes.Repeat([]byte{0x01}, 20), Amount: 0},
+	}
+
+	payload := &enginev1.ExecutionPayloadDeneb{
+		ParentHash:    parentHash,
+		FeeRecipient:  bytes.Repeat([]byte{0x01}, 20),
+		StateRoot:     bytes.Repeat([]byte{0x02}, 32),
+		ReceiptsRoot:  bytes.Repeat([]byte{0x03}, 32),
+		LogsBloom:     bytes.Repeat([]byte{0x04}, 256),
+		PrevRandao:    randao,
+		BlockNumber:   1,
+		GasLimit:      1,
+		GasUsed:       0,
+		Timestamp:     100,
+		ExtraData:     []byte{},
+		BaseFeePerGas: bytes.Repeat([]byte{0x05}, 32),
+		BlockHash:     blockHash,
+		Transactions:  [][]byte{},
+		Withdrawals:   withdrawals,
+		BlobGasUsed:   0,
+		ExcessBlobGas: 0,
+	}
+
+	bid := &ethpb.ExecutionPayloadBid{
+		ParentBlockHash:        parentHash,
+		ParentBlockRoot:        bytes.Repeat([]byte{0xDD}, 32),
+		BlockHash:              blockHash,
+		PrevRandao:             randao,
+		GasLimit:               1,
+		BuilderIndex:           builderIdx,
+		Slot:                   slot,
+		Value:                  0,
+		ExecutionPayment:       0,
+		FeeRecipient:           bytes.Repeat([]byte{0xEE}, 20),
+	}
+
+	header := &ethpb.BeaconBlockHeader{
+		Slot:       slot,
+		ParentRoot: bytes.Repeat([]byte{0x11}, 32),
+		StateRoot:  bytes.Repeat([]byte{0x22}, 32),
+		BodyRoot:   bytes.Repeat([]byte{0x33}, 32),
+	}
+	headerRoot, err := header.HashTreeRoot()
+	require.NoError(t, err)
+
+	envelope := &ethpb.ExecutionPayloadEnvelope{
+		Slot:               slot,
+		BuilderIndex:       builderIdx,
+		BeaconBlockRoot:    headerRoot[:],
+		Payload:            payload,
+		ExecutionRequests:  &enginev1.ExecutionRequests{},
+	}
+
+	if mutate != nil {
+		mutate(payload, bid, envelope)
+	}
+
+	genesisRoot := bytes.Repeat([]byte{0xAB}, 32)
+	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
+	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
+	for i := range blockRoots {
+		blockRoots[i] = bytes.Repeat([]byte{0x44}, 32)
+		stateRoots[i] = bytes.Repeat([]byte{0x55}, 32)
+	}
+	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
+	for i := range randaoMixes {
+		randaoMixes[i] = randao
+	}
+
+	withdrawalCreds := make([]byte, 32)
+	withdrawalCreds[0] = cfg.ETH1AddressWithdrawalPrefixByte
+
+	eth1Data := &ethpb.Eth1Data{
+		DepositRoot:  bytes.Repeat([]byte{0x66}, 32),
+		DepositCount: 0,
+		BlockHash:    bytes.Repeat([]byte{0x77}, 32),
+	}
+
+	vals := []*ethpb.Validator{
+		{
+			PublicKey:             pk,
+			WithdrawalCredentials: withdrawalCreds,
+			EffectiveBalance:      cfg.MinActivationBalance + 1_000,
+		},
+	}
+	balances := []uint64{cfg.MinActivationBalance + 1_000}
+
+	payments := make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2)
+	for i := range payments {
+		payments[i] = &ethpb.BuilderPendingPayment{
+			Withdrawal: &ethpb.BuilderPendingWithdrawal{
+				FeeRecipient: make([]byte, 20),
+			},
+		}
+	}
+
+	executionPayloadAvailability := make([]byte, cfg.SlotsPerHistoricalRoot/8)
+
+	builders := make([]*ethpb.Builder, builderIdx+1)
+	builders[builderIdx] = &ethpb.Builder{
+		Pubkey:            pk,
+		Version:           []byte{0},
+		ExecutionAddress:  bytes.Repeat([]byte{0x09}, 20),
+		Balance:           0,
+		DepositEpoch:      0,
+		WithdrawableEpoch: 0,
+	}
+
+	genesisTime := uint64(0)
+	slotSeconds := cfg.SecondsPerSlot * uint64(slot)
+	if payload.Timestamp > slotSeconds {
+		genesisTime = payload.Timestamp - slotSeconds
+	}
+
+	stProto := &ethpb.BeaconStateGloas{
+		Slot:                  slot,
+		GenesisTime:           genesisTime,
+		GenesisValidatorsRoot: genesisRoot,
+		Fork: &ethpb.Fork{
+			CurrentVersion:  bytes.Repeat([]byte{0x01}, 4),
+			PreviousVersion: bytes.Repeat([]byte{0x01}, 4),
+			Epoch:           0,
+		},
+		LatestBlockHeader:            header,
+		BlockRoots:                   blockRoots,
+		StateRoots:                   stateRoots,
+		RandaoMixes:                  randaoMixes,
+		Eth1Data:                     eth1Data,
+		Validators:                   vals,
+		Balances:                     balances,
+		LatestBlockHash:              payload.ParentHash,
+		LatestExecutionPayloadBid:    bid,
+		BuilderPendingPayments:       payments,
+		ExecutionPayloadAvailability: executionPayloadAvailability,
+		BuilderPendingWithdrawals:    []*ethpb.BuilderPendingWithdrawal{},
+		PayloadExpectedWithdrawals:   payload.Withdrawals,
+		Builders:                     builders,
+	}
+
+	st, err := state_native.InitializeFromProtoGloas(stProto)
+	require.NoError(t, err)
+
+	expected := st.Copy()
+	ctx := context.Background()
+	require.NoError(t, processExecutionRequests(ctx, expected, envelope.ExecutionRequests))
+	require.NoError(t, expected.QueueBuilderPayment())
+	require.NoError(t, expected.SetExecutionPayloadAvailability(slot, true))
+	var blockHashArr [32]byte
+	copy(blockHashArr[:], payload.BlockHash)
+	require.NoError(t, expected.SetLatestBlockHash(blockHashArr))
+	expectedRoot, err := expected.HashTreeRoot(ctx)
+	require.NoError(t, err)
+	envelope.StateRoot = expectedRoot[:]
+
+	epoch := slots.ToEpoch(slot)
+	domain, err := signing.Domain(st.Fork(), epoch, cfg.DomainBeaconBuilder, st.GenesisValidatorsRoot())
+	require.NoError(t, err)
+	signingRoot, err := signing.ComputeSigningRoot(envelope, domain)
+	require.NoError(t, err)
+	signature := sk.Sign(signingRoot[:]).Marshal()
+
+	signedProto := &ethpb.SignedExecutionPayloadEnvelope{
+		Message:   envelope,
+		Signature: signature,
+	}
+	signed, err := blocks.WrappedROSignedExecutionPayloadEnvelope(signedProto)
+	require.NoError(t, err)
+
+	return payloadFixture{
+		state:       st,
+		signed:      signed,
+		signedProto: signedProto,
+		envelope:    envelope,
+		payload:     payload,
+		slot:        slot,
+	}
+}
+
+func TestProcessExecutionPayload_Success(t *testing.T) {
+	fixture := buildPayloadFixture(t, nil)
+	require.NoError(t, ProcessExecutionPayload(t.Context(), fixture.state, fixture.signed))
+
+	latestHash, err := fixture.state.LatestBlockHash()
+	require.NoError(t, err)
+	var expectedHash [32]byte
+	copy(expectedHash[:], fixture.payload.BlockHash)
+	require.Equal(t, expectedHash, latestHash)
+
+	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
+	paymentIndex := slotsPerEpoch + (fixture.slot % slotsPerEpoch)
+	payments, err := fixture.state.BuilderPendingPayments()
+	require.NoError(t, err)
+	payment := payments[paymentIndex]
+	require.NotNil(t, payment)
+	require.Equal(t, primitives.Gwei(0), payment.Withdrawal.Amount)
+}
+
+func TestProcessExecutionPayload_PrevRandaoMismatch(t *testing.T) {
+	fixture := buildPayloadFixture(t, func(_ *enginev1.ExecutionPayloadDeneb, bid *ethpb.ExecutionPayloadBid, _ *ethpb.ExecutionPayloadEnvelope) {
+		bid.PrevRandao = bytes.Repeat([]byte{0xFF}, 32)
+	})
+
+	err := ProcessExecutionPayload(t.Context(), fixture.state, fixture.signed)
+	require.ErrorContains(t, "prev randao", err)
+}
+
+func TestQueueBuilderPayment_ZeroAmountClearsSlot(t *testing.T) {
+	fixture := buildPayloadFixture(t, nil)
+
+	require.NoError(t, fixture.state.QueueBuilderPayment())
+
+	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
+	paymentIndex := slotsPerEpoch + (fixture.slot % slotsPerEpoch)
+	payments, err := fixture.state.BuilderPendingPayments()
+	require.NoError(t, err)
+	payment := payments[paymentIndex]
+	require.NotNil(t, payment)
+	require.Equal(t, primitives.Gwei(0), payment.Withdrawal.Amount)
+}
+
+func TestVerifyExecutionPayloadEnvelopeSignature(t *testing.T) {
+	fixture := buildPayloadFixture(t, nil)
+
+	t.Run("self build", func(t *testing.T) {
+		proposerSk, err := bls.RandKey()
+		require.NoError(t, err)
+		proposerPk := proposerSk.PublicKey().Marshal()
+
+		stPb, ok := fixture.state.ToProtoUnsafe().(*ethpb.BeaconStateGloas)
+		require.Equal(t, true, ok)
+		stPb = proto.Clone(stPb).(*ethpb.BeaconStateGloas)
+		stPb.Validators[0].PublicKey = proposerPk
+		st, err := state_native.InitializeFromProtoUnsafeGloas(stPb)
+		require.NoError(t, err)
+
+		msg := proto.Clone(fixture.signedProto.Message).(*ethpb.ExecutionPayloadEnvelope)
+		msg.BuilderIndex = params.BeaconConfig().BuilderIndexSelfBuild
+
+		epoch := slots.ToEpoch(msg.Slot)
+		domain, err := signing.Domain(st.Fork(), epoch, params.BeaconConfig().DomainBeaconBuilder, st.GenesisValidatorsRoot())
+		require.NoError(t, err)
+		signingRoot, err := signing.ComputeSigningRoot(msg, domain)
+		require.NoError(t, err)
+		signature := proposerSk.Sign(signingRoot[:]).Marshal()
+
+		signedProto := &ethpb.SignedExecutionPayloadEnvelope{
+			Message:   msg,
+			Signature: signature,
+		}
+		signed, err := blocks.WrappedROSignedExecutionPayloadEnvelope(signedProto)
+		require.NoError(t, err)
+
+		require.NoError(t, verifyExecutionPayloadEnvelopeSignature(st, signed))
+	})
+
+	t.Run("builder", func(t *testing.T) {
+		signed, err := blocks.WrappedROSignedExecutionPayloadEnvelope(fixture.signedProto)
+		require.NoError(t, err)
+
+		require.NoError(t, verifyExecutionPayloadEnvelopeSignature(fixture.state, signed))
+	})
+
+	t.Run("invalid signature", func(t *testing.T) {
+		t.Run("self build", func(t *testing.T) {
+			proposerSk, err := bls.RandKey()
+			require.NoError(t, err)
+			proposerPk := proposerSk.PublicKey().Marshal()
+
+			stPb, ok := fixture.state.ToProtoUnsafe().(*ethpb.BeaconStateGloas)
+			require.Equal(t, true, ok)
+			stPb = proto.Clone(stPb).(*ethpb.BeaconStateGloas)
+			stPb.Validators[0].PublicKey = proposerPk
+			st, err := state_native.InitializeFromProtoUnsafeGloas(stPb)
+			require.NoError(t, err)
+
+			msg := proto.Clone(fixture.signedProto.Message).(*ethpb.ExecutionPayloadEnvelope)
+			msg.BuilderIndex = params.BeaconConfig().BuilderIndexSelfBuild
+
+			signedProto := &ethpb.SignedExecutionPayloadEnvelope{
+				Message:   msg,
+				Signature: bytes.Repeat([]byte{0xFF}, 96),
+			}
+			badSigned, err := blocks.WrappedROSignedExecutionPayloadEnvelope(signedProto)
+			require.NoError(t, err)
+
+			err = verifyExecutionPayloadEnvelopeSignature(st, badSigned)
+			require.ErrorContains(t, "invalid signature format", err)
+		})
+
+		t.Run("builder", func(t *testing.T) {
+			signedProto := &ethpb.SignedExecutionPayloadEnvelope{
+				Message:   fixture.signedProto.Message,
+				Signature: bytes.Repeat([]byte{0xFF}, 96),
+			}
+			badSigned, err := blocks.WrappedROSignedExecutionPayloadEnvelope(signedProto)
+			require.NoError(t, err)
+
+			err = verifyExecutionPayloadEnvelopeSignature(fixture.state, badSigned)
+			require.ErrorContains(t, "invalid signature format", err)
+		})
+	})
+}

beacon-chain/core/gloas/pending_payment.go

@@ -10,17 +10,21 @@ import (
 )
 
 // ProcessBuilderPendingPayments processes the builder pending payments from the previous epoch.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// def process_builder_pending_payments(state: BeaconState) -> None:
 //
-//	quorum = get_builder_payment_quorum_threshold(state)
-//	for payment in state.builder_pending_payments[:SLOTS_PER_EPOCH]:
-//	    if payment.weight >= quorum:
-//	        state.builder_pending_withdrawals.append(payment.withdrawal)
+//	<spec fn="process_builder_pending_payments" fork="gloas" hash="10da48dd">
+//	def process_builder_pending_payments(state: BeaconState) -> None:
+//	    """
+//	    Processes the builder pending payments from the previous epoch.
+//	    """
+//	    quorum = get_builder_payment_quorum_threshold(state)
+//	    for payment in state.builder_pending_payments[:SLOTS_PER_EPOCH]:
+//	        if payment.weight >= quorum:
+//	            state.builder_pending_withdrawals.append(payment.withdrawal)
 //
-//	old_payments = state.builder_pending_payments[SLOTS_PER_EPOCH:]
-//	new_payments = [BuilderPendingPayment() for _ in range(SLOTS_PER_EPOCH)]
-//	state.builder_pending_payments = old_payments + new_payments
+//	    old_payments = state.builder_pending_payments[SLOTS_PER_EPOCH:]
+//	    new_payments = [BuilderPendingPayment() for _ in range(SLOTS_PER_EPOCH)]
+//	    state.builder_pending_payments = old_payments + new_payments
+//	</spec>
 func ProcessBuilderPendingPayments(state state.BeaconState) error {
 	quorum, err := builderQuorumThreshold(state)
 	if err != nil {
@@ -53,12 +57,16 @@ func ProcessBuilderPendingPayments(state state.BeaconState) error {
 }
 
 // builderQuorumThreshold calculates the quorum threshold for builder payments.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// def get_builder_payment_quorum_threshold(state: BeaconState) -> uint64:
 //
-//	per_slot_balance = get_total_active_balance(state) // SLOTS_PER_EPOCH
-//	quorum = per_slot_balance * BUILDER_PAYMENT_THRESHOLD_NUMERATOR
-//	return uint64(quorum // BUILDER_PAYMENT_THRESHOLD_DENOMINATOR)
+//	<spec fn="get_builder_payment_quorum_threshold" fork="gloas" hash="a64b7ffb">
+//	def get_builder_payment_quorum_threshold(state: BeaconState) -> uint64:
+//	    """
+//	    Calculate the quorum threshold for builder payments.
+//	    """
+//	    per_slot_balance = get_total_active_balance(state) // SLOTS_PER_EPOCH
+//	    quorum = per_slot_balance * BUILDER_PAYMENT_THRESHOLD_NUMERATOR
+//	    return uint64(quorum // BUILDER_PAYMENT_THRESHOLD_DENOMINATOR)
+//	</spec>
 func builderQuorumThreshold(state state.ReadOnlyBeaconState) (primitives.Gwei, error) {
 	activeBalance, err := helpers.TotalActiveBalance(state)
 	if err != nil {

beacon-chain/core/gloas/proposer_slashing.go

@@ -11,16 +11,20 @@ import (
 )
 
 // RemoveBuilderPendingPayment removes the pending builder payment for the proposal slot.
-// Spec v1.7.0 (pseudocode):
 //
+//	<spec fn="process_proposer_slashing" fork="gloas" lines="22-32" hash="4da721ef">
+//	# [New in Gloas:EIP7732]
+//	# Remove the BuilderPendingPayment corresponding to
+//	# this proposal if it is still in the 2-epoch window.
 //	slot = header_1.slot
 //	proposal_epoch = compute_epoch_at_slot(slot)
 //	if proposal_epoch == get_current_epoch(state):
-//	  payment_index = SLOTS_PER_EPOCH + slot % SLOTS_PER_EPOCH
-//	  state.builder_pending_payments[payment_index] = BuilderPendingPayment()
+//	    payment_index = SLOTS_PER_EPOCH + slot % SLOTS_PER_EPOCH
+//	    state.builder_pending_payments[payment_index] = BuilderPendingPayment()
 //	elif proposal_epoch == get_previous_epoch(state):
-//	  payment_index = slot % SLOTS_PER_EPOCH
-//	  state.builder_pending_payments[payment_index] = BuilderPendingPayment()
+//	    payment_index = slot % SLOTS_PER_EPOCH
+//	    state.builder_pending_payments[payment_index] = BuilderPendingPayment()
+//	</spec>
 func RemoveBuilderPendingPayment(st state.BeaconState, header *eth.BeaconBlockHeader) error {
 	proposalEpoch := slots.ToEpoch(header.Slot)
 	currentEpoch := time.CurrentEpoch(st)

beacon-chain/core/transition/transition.go

@@ -143,10 +143,11 @@ func ProcessSlot(ctx context.Context, state state.BeaconState) (state.BeaconStat
 		return nil, err
 	}
 
-	// Spec v1.6.1 (pseudocode):
+	// <spec fn="process_slot" fork="gloas" lines="11-13" hash="62b28839">
 	// # [New in Gloas:EIP7732]
 	// # Unset the next payload availability
 	// state.execution_payload_availability[(state.slot + 1) % SLOTS_PER_HISTORICAL_ROOT] = 0b0
+	// </spec>
 	if state.Version() >= version.Gloas {
 		index := uint64((state.Slot() + 1) % params.BeaconConfig().SlotsPerHistoricalRoot)
 		if err := state.UpdateExecutionPayloadAvailabilityAtIndex(index, 0x0); err != nil {

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),
-			BlobKzgCommitmentsRoot: make([]byte, 32),
+			BlobKzgCommitments:     [][]byte{make([]byte, 48)},
 		},
 		Eth1Data: &ethpb.Eth1Data{
 			DepositRoot: make([]byte, 32),

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -116,17 +116,32 @@ func CalculateStateRoot(
 	rollback state.BeaconState,
 	signed interfaces.ReadOnlySignedBeaconBlock,
 ) ([32]byte, error) {
-	ctx, span := trace.StartSpan(ctx, "core.state.CalculateStateRoot")
+	st, err := CalculatePostState(ctx, rollback, signed)
+	if err != nil {
+		return [32]byte{}, err
+	}
+	return st.HashTreeRoot(ctx)
+}
+
+// CalculatePostState returns the post-block state after processing the given
+// block on a copy of the input state. It is identical to CalculateStateRoot
+// but returns the full state instead of just its hash tree root.
+func CalculatePostState(
+	ctx context.Context,
+	rollback state.BeaconState,
+	signed interfaces.ReadOnlySignedBeaconBlock,
+) (state.BeaconState, error) {
+	ctx, span := trace.StartSpan(ctx, "core.state.CalculatePostState")
 	defer span.End()
 	if ctx.Err() != nil {
 		tracing.AnnotateError(span, ctx.Err())
-		return [32]byte{}, ctx.Err()
+		return nil, ctx.Err()
 	}
 	if rollback == nil || rollback.IsNil() {
-		return [32]byte{}, errors.New("nil state")
+		return nil, errors.New("nil state")
 	}
 	if signed == nil || signed.IsNil() || signed.Block().IsNil() {
-		return [32]byte{}, errors.New("nil block")
+		return nil, errors.New("nil block")
 	}
 
 	// Copy state to avoid mutating the state reference.
@@ -137,22 +152,22 @@ func CalculateStateRoot(
 	parentRoot := signed.Block().ParentRoot()
 	state, err = ProcessSlotsUsingNextSlotCache(ctx, state, parentRoot[:], signed.Block().Slot())
 	if err != nil {
-		return [32]byte{}, errors.Wrap(err, "could not process slots")
+		return nil, errors.Wrap(err, "could not process slots")
 	}
 
 	// Execute per block transition.
 	if features.Get().EnableProposerPreprocessing {
 		state, err = processBlockForProposing(ctx, state, signed)
 		if err != nil {
-			return [32]byte{}, errors.Wrap(err, "could not process block for proposing")
+			return nil, errors.Wrap(err, "could not process block for proposing")
 		}
 	} else {
 		state, err = ProcessBlockForStateRoot(ctx, state, signed)
 		if err != nil {
-			return [32]byte{}, errors.Wrap(err, "could not process block")
+			return nil, errors.Wrap(err, "could not process block")
 		}
 	}
-	return state.HashTreeRoot(ctx)
+	return state, nil
 }
 
 // processBlockVerifySigs processes the block and verifies the signatures within it. Block signatures are not verified as this block is not yet signed.

beacon-chain/db/filesystem/BUILD.bazel

@@ -7,6 +7,7 @@ go_library(
         "cache.go",
         "data_column.go",
         "data_column_cache.go",
+        "doc.go",
         "iteration.go",
         "layout.go",
         "layout_by_epoch.go",
@@ -14,8 +15,6 @@ go_library(
         "log.go",
         "metrics.go",
         "mock.go",
-        "proof.go",
-        "proof_cache.go",
         "pruner.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/db/filesystem",
@@ -31,7 +30,6 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//io/file:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/logging:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
@@ -54,7 +52,6 @@ go_test(
         "iteration_test.go",
         "layout_test.go",
         "migration_test.go",
-        "proof_test.go",
         "pruner_test.go",
     ],
     embed = [":go_default_library"],

beacon-chain/db/filesystem/doc.go

@@ -0,0 +1,104 @@
+package filesystem
+
+// nolint:dupword
+/*
+Data column sidecars storage documentation
+==========================================
+
+File organisation
+-----------------
+- The first byte represents the version of the file structure (up to 0xff = 255).
+  We set it to 0x01.
+  Note: This is not strictly needed, but it will help a lot if, in the future,
+        we want to modify the file structure.
+- The next 4 bytes represents the size of a SSZ encoded data column sidecar.
+  (See the `Computation of the maximum size of a DataColumnSidecar` section to a description
+  of how this value is computed).
+- The next 128 bytes represent the index in the file of a given column.
+  The first bit of each byte in the index is set to 0 if there is no data column,
+  and set to 1 if there is a data column.
+  The remaining 7 bits (from 0 to 127) represent the index of the data column.
+  This sentinel bit is needed to distinguish between the column with index 0 and no column.
+  Example: If the column with index 5 is in the 3th position in the file, then indices[5] = 0x80 + 0x03 = 0x83.
+- The rest of the file is a repeat of the SSZ encoded data column sidecars.
+
+
+|------------------------------------------|------------------------------------------------------------------------------------|
+|                Byte offset               |                                     Description                                    |
+|------------------------------------------|------------------------------------------------------------------------------------|
+|                                        0 | version (1 byte) | sszEncodedDataColumnSidecarSize (4 bytes) | indices (128 bytes) |
+|133 +   0*sszEncodedDataColumnSidecarSize | sszEncodedDataColumnSidecar (sszEncodedDataColumnSidecarSize bytes)                |
+|133 +   1*sszEncodedDataColumnSidecarSize | sszEncodedDataColumnSidecar (sszEncodedDataColumnSidecarSize bytes)                |
+|133 +   2*sszEncodedDataColumnSidecarSize | sszEncodedDataColumnSidecar (sszEncodedDataColumnSidecarSize bytes)                |
+|                  ...                     |                                 ...                                                |
+|133 + 127*sszEncodedDataColumnSidecarSize | sszEncodedDataColumnSidecar (sszEncodedDataColumnSidecarSize bytes)                |
+|------------------------------------------|------------------------------------------------------------------------------------|
+
+Each file is named after the block root where the data columns were data columns are committed to.
+Example: `0x259c6d2f6a0bb75e2405cea7cb248e5663dc26b9404fd3bcd777afc20de91c1e.sszs`
+
+Database organisation
+---------------------
+SSZ encoded data column sidecars are stored following the `by-epoch` layout.
+- The first layer is a directory corresponding to the `period`, which corresponds to the epoch divided by the 4096.
+- The second layer is a directory corresponding to the epoch.
+- Then all files are stored in the epoch directory.
+
+Example:
+data-columns
+├── 0
+│   ├── 3638
+│   │   ├── 0x259c6d2f6a0bb75e2405cea7cb248e5663dc26b9404fd3bcd777afc20de91c1e.sszs
+│   │   ├── 0x2a855b1f6e9a2f04f8383e336325bf7d5ba02d1eab3ef90ef183736f8c768533.sszs
+│   │   ├── ...
+│   │   ├── 0xeb78e2b2350a71c640f1e96fea9e42f38e65705ab7e6e100c8bc9c589f2c5f2b.sszs
+│   │   └── 0xeb7ee68da988fd20d773d45aad01dd62527734367a146e2b048715bd68a4e370.sszs
+│   └── 3639
+│       ├── 0x0fd231fe95e57936fa44f6c712c490b9e337a481b661dfd46768901e90444330.sszs
+│       ├── 0x1bf5edff6b6ba2b65b1db325ff3312bbb57da461ef2ae651bd741af851aada3a.sszs
+│       ├── ...
+│       ├── 0xa156a527e631f858fee79fab7ef1fde3f6117a2e1201d47c09fbab0c6780c937.sszs
+│       └── 0xcd80bc535ddc467dea1d19e0c39c1160875ccd1989061bcd8ce206e3c1261c87.sszs
+└── 1
+    ├── 4096
+    │   ├── 0x0d244009093e2bedb72eb265280290199e8c7bf1d90d7583c41af40d9f662269.sszs
+    │   ├── 0x11f420928d8de41c50e735caab0369996824a5299c5f054e097965855925697d.sszs
+    │   ├── ...
+    │   ├── 0xbe91fc782877ed400d95c02c61aebfdd592635d11f8e64c94b46abd84f45c967.sszs
+    │   └── 0xf246189f078f02d30173ff74605cf31c9e65b5e463275ebdbeb40476638135ff.sszs
+    └── 4097
+        ├── 0x454d000674793c479e90504c0fe9827b50bb176ae022dab4e37d6a21471ab570.sszs
+        ├── 0xac5eb7437d7190c48cfa863e3c45f96a7f8af371d47ac12ccda07129a06af763.sszs
+        ├── ...
+        ├── 0xb7df30561d9d92ab5fafdd96bca8b44526497c8debf0fc425c7a0770b2abeb83.sszs
+        └── 0xc1dd0b1ae847b6ec62303a36d08c6a4a2e9e3ec4be3ff70551972a0ee3de9c14.sszs
+
+Computation of the maximum size of a DataColumnSidecar
+------------------------------------------------------
+https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/das-core.md#datacolumnsidecar
+
+
+class DataColumnSidecar(Container):
+    index: ColumnIndex  # Index of column in extended matrix
+    column: List[Cell, MAX_BLOB_COMMITMENTS_PER_BLOCK]
+    kzg_commitments: List[KZGCommitment, MAX_BLOB_COMMITMENTS_PER_BLOCK]
+    kzg_proofs: List[KZGProof, MAX_BLOB_COMMITMENTS_PER_BLOCK]
+    signed_block_header: SignedBeaconBlockHeader
+    kzg_commitments_inclusion_proof: Vector[Bytes32, KZG_COMMITMENTS_INCLUSION_PROOF_DEPTH]
+
+
+- index: 2 bytes (ColumnIndex)
+- `column`: 4,096 (MAX_BLOB_COMMITMENTS_PER_BLOCK) * 64 (FIELD_ELEMENTS_PER_CELL) * 32 bytes (BYTES_PER_FIELD_ELEMENT) = 8,388,608 bytes
+- kzg_commitments: 4,096 (MAX_BLOB_COMMITMENTS_PER_BLOCK) * 48 bytes (KZGCommitment) = 196,608 bytes
+- kzg_proofs: 4,096 (MAX_BLOB_COMMITMENTS_PER_BLOCK) * 48 bytes (KZGProof) = 196,608 bytes
+- signed_block_header: 2 bytes (Slot) + 2 bytes (ValidatorIndex) + 3 * 2 bytes (Root) + 96 bytes (BLSSignature) = 106 bytes
+- kzg_commitments_inclusion_proof: 4 (KZG_COMMITMENTS_INCLUSION_PROOF_DEPTH) * 32 bytes = 128 bytes
+
+TOTAL: 8,782,060 bytes = 70,256,480 bits
+log(70,256,480) / log(2) ~= 26.07
+
+==> 32 bits (4 bytes) are enough to store the maximum size of a data column sidecar.
+
+The maximum size of an SSZ encoded data column can be 2**32 bits = 536,879,912 bytes,
+which left a room of 536,879,912 bytes - 8,782,060 bytes ~= 503 mega bytes to store the extra data needed by SSZ encoding (which is more than enough.)
+*/

beacon-chain/db/filesystem/doc.md

@@ -1,197 +0,0 @@
-# Filesystem storage documentation
-
-This document describes the file formats and database organization for storing data column sidecars and execution proofs.
-
----
-
-# Data column sidecars
-
-## File organisation
-
-- The first byte represents the version of the file structure (up to `0xff = 255`).
-  We set it to `0x01`.
-
-  _(Note: This is not strictly needed, but it will help a lot if, in the future, we want to modify the file structure.)_
-
-- The next 4 bytes represents the size of a SSZ encoded data column sidecar.
-  (See the [Computation of the maximum size of a DataColumnSidecar](#computation-of-the-maximum-size-of-a-datacolumnsidecar) section for a description
-  of how this value is computed).
-
-- The next 128 bytes represent the index in the file of a given column.
-  The first bit of each byte in the index is set to 0 if there is no data column,
-  and set to 1 if there is a data column.
-  The remaining 7 bits (from 0 to 127) represent the index of the data column.
-  This sentinel bit is needed to distinguish between the column with index 0 and no column.
-
-  **Example:** If the column with index 5 is in the 3rd position in the file, then `indices[5] = 0x80 + 0x03 = 0x83`.
-
-- The rest of the file is a repeat of the SSZ encoded data column sidecars.
-
-### File layout
-
-| Byte offset | Description |
-|-------------|-------------|
-| `0` | `version (1 byte) \| sszEncodedDataColumnSidecarSize (4 bytes) \| indices (128 bytes)` |
-| `133 + 0×sszEncodedDataColumnSidecarSize` | `sszEncodedDataColumnSidecar (sszEncodedDataColumnSidecarSize bytes)` |
-| `133 + 1×sszEncodedDataColumnSidecarSize` | `sszEncodedDataColumnSidecar (sszEncodedDataColumnSidecarSize bytes)` |
-| `133 + 2×sszEncodedDataColumnSidecarSize` | `sszEncodedDataColumnSidecar (sszEncodedDataColumnSidecarSize bytes)` |
-| ... | ... |
-| `133 + 127×sszEncodedDataColumnSidecarSize` | `sszEncodedDataColumnSidecar (sszEncodedDataColumnSidecarSize bytes)` |
-
-Each file is named after the block root where the data columns are committed to.
-
-**Example:** `0x259c6d2f6a0bb75e2405cea7cb248e5663dc26b9404fd3bcd777afc20de91c1e.sszs`
-
-## Database organisation
-
-SSZ encoded data column sidecars are stored following the `by-epoch` layout.
-
-- The first layer is a directory corresponding to the `period`, which corresponds to the epoch divided by 4096.
-- The second layer is a directory corresponding to the epoch.
-- Then all files are stored in the epoch directory.
-
-### Example directory structure
-
-```
-data-columns
-├── 0
-│   ├── 3638
-│   │   ├── 0x259c6d2f6a0bb75e2405cea7cb248e5663dc26b9404fd3bcd777afc20de91c1e.sszs
-│   │   ├── 0x2a855b1f6e9a2f04f8383e336325bf7d5ba02d1eab3ef90ef183736f8c768533.sszs
-│   │   ├── ...
-│   │   ├── 0xeb78e2b2350a71c640f1e96fea9e42f38e65705ab7e6e100c8bc9c589f2c5f2b.sszs
-│   │   └── 0xeb7ee68da988fd20d773d45aad01dd62527734367a146e2b048715bd68a4e370.sszs
-│   └── 3639
-│       ├── 0x0fd231fe95e57936fa44f6c712c490b9e337a481b661dfd46768901e90444330.sszs
-│       ├── 0x1bf5edff6b6ba2b65b1db325ff3312bbb57da461ef2ae651bd741af851aada3a.sszs
-│       ├── ...
-│       ├── 0xa156a527e631f858fee79fab7ef1fde3f6117a2e1201d47c09fbab0c6780c937.sszs
-│       └── 0xcd80bc535ddc467dea1d19e0c39c1160875ccd1989061bcd8ce206e3c1261c87.sszs
-└── 1
-    ├── 4096
-    │   ├── 0x0d244009093e2bedb72eb265280290199e8c7bf1d90d7583c41af40d9f662269.sszs
-    │   ├── 0x11f420928d8de41c50e735caab0369996824a5299c5f054e097965855925697d.sszs
-    │   ├── ...
-    │   ├── 0xbe91fc782877ed400d95c02c61aebfdd592635d11f8e64c94b46abd84f45c967.sszs
-    │   └── 0xf246189f078f02d30173ff74605cf31c9e65b5e463275ebdbeb40476638135ff.sszs
-    └── 4097
-        ├── 0x454d000674793c479e90504c0fe9827b50bb176ae022dab4e37d6a21471ab570.sszs
-        ├── 0xac5eb7437d7190c48cfa863e3c45f96a7f8af371d47ac12ccda07129a06af763.sszs
-        ├── ...
-        ├── 0xb7df30561d9d92ab5fafdd96bca8b44526497c8debf0fc425c7a0770b2abeb83.sszs
-        └── 0xc1dd0b1ae847b6ec62303a36d08c6a4a2e9e3ec4be3ff70551972a0ee3de9c14.sszs
-```
-
-## Computation of the maximum size of a `DataColumnSidecar`
-
-Reference: [Ethereum Consensus Specs - Fulu DAS Core](https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/das-core.md#datacolumnsidecar)
-
-```python
-class DataColumnSidecar(Container):
-    index: ColumnIndex  # Index of column in extended matrix
-    column: List[Cell, MAX_BLOB_COMMITMENTS_PER_BLOCK]
-    kzg_commitments: List[KZGCommitment, MAX_BLOB_COMMITMENTS_PER_BLOCK]
-    kzg_proofs: List[KZGProof, MAX_BLOB_COMMITMENTS_PER_BLOCK]
-    signed_block_header: SignedBeaconBlockHeader
-    kzg_commitments_inclusion_proof: Vector[Bytes32, KZG_COMMITMENTS_INCLUSION_PROOF_DEPTH]
-```
-
-### Size breakdown
-
-| Field | Calculation | Size |
-|-------|-------------|------|
-| `index` | `ColumnIndex` | `2 bytes` |
-| `column` | `4,096 (MAX_BLOB_COMMITMENTS_PER_BLOCK) × 64 (FIELD_ELEMENTS_PER_CELL) × 32 bytes (BYTES_PER_FIELD_ELEMENT)` | `8,388,608 bytes` |
-| `kzg_commitments` | `4,096 (MAX_BLOB_COMMITMENTS_PER_BLOCK) × 48 bytes (KZGCommitment)` | `196,608 bytes` |
-| `kzg_proofs` | `4,096 (MAX_BLOB_COMMITMENTS_PER_BLOCK) × 48 bytes (KZGProof)` | `196,608 bytes` |
-| `signed_block_header` | `2 bytes (Slot) + 2 bytes (ValidatorIndex) + 3 × 2 bytes (Root) + 96 bytes (BLSSignature)` | `106 bytes` |
-| `kzg_commitments_inclusion_proof` | `4 (KZG_COMMITMENTS_INCLUSION_PROOF_DEPTH) × 32 bytes` | `128 bytes` |
-
-**TOTAL:** `8,782,060 bytes = 70,256,480 bits`
-
-```
-log(70,256,480) / log(2) ≈ 26.07
-```
-
-**Conclusion:** 32 bits (4 bytes) are enough to store the maximum size of a data column sidecar.
-
-The maximum size of an SSZ encoded data column can be `2³² bits = 536,879,912 bytes`,
-which leaves a room of `536,879,912 bytes - 8,782,060 bytes ≈ 503 megabytes` to store the extra data needed by SSZ encoding (which is more than enough).
-
----
-
-# Execution proofs
-
-## File organisation
-
-Unlike data column sidecars (which have a fixed size per block), execution proofs have variable sizes.
-To handle this, we use an offset table that stores the position and size of each proof.
-
-- The first byte represents the version of the file structure (up to `0xff = 255`).
-  We set it to `0x01`.
-
-- The next 64 bytes represent the offset table with 8 slots (one per proof type).
-  Each slot contains:
-  - 4 bytes for the offset (relative to end of header)
-  - 4 bytes for the size of the SSZ-encoded proof
-
-  If the size is 0, the proof is not present.
-
-- The rest of the file contains the SSZ encoded proofs, stored contiguously.
-
-### File layout
-
-| Byte offset | Description |
-|-------------|-------------|
-| `0` | `version (1 byte) \| offsetTable (64 bytes)` |
-| `65 + offsetTable[0].offset` | `sszEncodedProof (offsetTable[0].size bytes)` |
-| `65 + offsetTable[1].offset` | `sszEncodedProof (offsetTable[1].size bytes)` |
-| ... | ... |
-| `65 + offsetTable[7].offset` | `sszEncodedProof (offsetTable[7].size bytes)` |
-
-**Header size:** 1 (version) + 64 (offset table) = **65 bytes**
-
-### Offset table entry format
-
-Each slot in the offset table (8 bytes per slot):
-- `offset` (4 bytes, big-endian): Offset from end of header where proof data begins
-- `size` (4 bytes, big-endian): Size of the SSZ-encoded proof in bytes
-
-**Note:** Offsets are relative to the end of the header (byte 65), not the start of the file.
-This maximizes the usable range of the 4-byte offset field.
-
-### Reading a proof with `proofID=N (O(1) access)`
-
-1. Read header (65 bytes)
-2. Check slot N: if `size == 0`, proof not present
-3. Seek to `(65 + offset)`, read `size` bytes, SSZ unmarshal
-
-Each file is named after the block root.
-
-**Example:** `0x259c6d2f6a0bb75e2405cea7cb248e5663dc26b9404fd3bcd777afc20de91c1e.sszs`
-
-## Database Organisation
-
-SSZ encoded execution proofs are stored following the same `by-epoch` layout as data column sidecars.
-
-- The first layer is a directory corresponding to the `period`, which corresponds to the epoch divided by 4096.
-- The second layer is a directory corresponding to the epoch.
-- Then all files are stored in the epoch directory.
-
-### Example Directory Structure
-
-```
-proofs
-├── 0
-│   ├── 100
-│   │   ├── 0x259c6d2f6a0bb75e2405cea7cb248e5663dc26b9404fd3bcd777afc20de91c1e.sszs
-│   │   ├── 0x2a855b1f6e9a2f04f8383e336325bf7d5ba02d1eab3ef90ef183736f8c768533.sszs
-│   │   └── ...
-│   └── 101
-│       ├── 0x0fd231fe95e57936fa44f6c712c490b9e337a481b661dfd46768901e90444330.sszs
-│       └── ...
-└── 1
-    └── 4096
-        ├── 0x0d244009093e2bedb72eb265280290199e8c7bf1d90d7583c41af40d9f662269.sszs
-        └── ...
-```

beacon-chain/db/filesystem/metrics.go

@@ -70,36 +70,4 @@ var (
 		Name: "data_column_prune_latency",
 		Help: "Latency of data column prune operations in milliseconds",
 	})
-
-	// Proofs
-	proofSaveLatency = promauto.NewHistogram(prometheus.HistogramOpts{
-		Name:    "proof_storage_save_latency",
-		Help:    "Latency of proof storage save operations in milliseconds",
-		Buckets: []float64{3, 5, 7, 9, 11, 13, 20, 50},
-	})
-	proofFetchLatency = promauto.NewHistogram(prometheus.HistogramOpts{
-		Name:    "proof_storage_get_latency",
-		Help:    "Latency of proof storage get operations in milliseconds",
-		Buckets: []float64{3, 5, 7, 9, 11, 13},
-	})
-	proofPrunedCounter = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "proof_pruned",
-		Help: "Number of proof files pruned.",
-	})
-	proofWrittenCounter = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "proof_written",
-		Help: "Number of proof files written",
-	})
-	proofDiskCount = promauto.NewGauge(prometheus.GaugeOpts{
-		Name: "proof_disk_count",
-		Help: "Approximate number of proof files in storage",
-	})
-	proofFileSyncLatency = promauto.NewSummary(prometheus.SummaryOpts{
-		Name: "proof_file_sync_latency",
-		Help: "Latency of sync operations when saving proofs in milliseconds",
-	})
-	proofPruneLatency = promauto.NewSummary(prometheus.SummaryOpts{
-		Name: "proof_prune_latency",
-		Help: "Latency of proof prune operations in milliseconds",
-	})
 )

beacon-chain/db/filesystem/mock.go

@@ -144,45 +144,3 @@ func NewEphemeralDataColumnStorageWithMocker(t testing.TB) (*DataColumnMocker, *
 	fs, dcs := NewEphemeralDataColumnStorageAndFs(t)
 	return &DataColumnMocker{fs: fs, dcs: dcs}, dcs
 }
-
-// Proofs
-// ------
-
-// NewEphemeralProofStorage should only be used for tests.
-// The instance of ProofStorage returned is backed by an in-memory virtual filesystem,
-// improving test performance and simplifying cleanup.
-func NewEphemeralProofStorage(t testing.TB, opts ...ProofStorageOption) *ProofStorage {
-	return NewWarmedEphemeralProofStorageUsingFs(t, afero.NewMemMapFs(), opts...)
-}
-
-// NewEphemeralProofStorageAndFs can be used by tests that want access to the virtual filesystem
-// in order to interact with it outside the parameters of the ProofStorage API.
-func NewEphemeralProofStorageAndFs(t testing.TB, opts ...ProofStorageOption) (afero.Fs, *ProofStorage) {
-	fs := afero.NewMemMapFs()
-	ps := NewWarmedEphemeralProofStorageUsingFs(t, fs, opts...)
-	return fs, ps
-}
-
-// NewEphemeralProofStorageUsingFs creates a ProofStorage backed by the provided filesystem.
-func NewEphemeralProofStorageUsingFs(t testing.TB, fs afero.Fs, opts ...ProofStorageOption) *ProofStorage {
-	defaultOpts := []ProofStorageOption{
-		WithProofRetentionEpochs(params.BeaconConfig().MinEpochsForDataColumnSidecarsRequest),
-		WithProofFs(fs),
-	}
-	// User opts come last so they can override defaults
-	allOpts := append(defaultOpts, opts...)
-
-	ps, err := NewProofStorage(context.Background(), allOpts...)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	return ps
-}
-
-// NewWarmedEphemeralProofStorageUsingFs creates a ProofStorage with a warmed cache.
-func NewWarmedEphemeralProofStorageUsingFs(t testing.TB, fs afero.Fs, opts ...ProofStorageOption) *ProofStorage {
-	ps := NewEphemeralProofStorageUsingFs(t, fs, opts...)
-	ps.WarmCache()
-	return ps
-}

beacon-chain/db/filesystem/proof.go

@@ -1,964 +0,0 @@
-package filesystem
-
-import (
-	"context"
-	"encoding/binary"
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"path"
-	"path/filepath"
-	"slices"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/OffchainLabs/prysm/v7/async"
-	"github.com/OffchainLabs/prysm/v7/async/event"
-	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v7/io/file"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-	"github.com/spf13/afero"
-)
-
-const (
-	proofVersion         = 0x01
-	proofVersionSize     = 1                                       // bytes
-	maxProofTypes        = 8                                       // ExecutionProofId max value (EXECUTION_PROOF_TYPE_COUNT)
-	proofOffsetSize      = 4                                       // bytes for offset (uint32)
-	proofSizeSize        = 4                                       // bytes for size (uint32)
-	proofSlotSize        = proofOffsetSize + proofSizeSize         // 8 bytes per slot
-	proofOffsetTableSize = maxProofTypes * proofSlotSize           // 64 bytes
-	proofHeaderSize      = proofVersionSize + proofOffsetTableSize // 65 bytes
-	proofsFileExtension  = "sszs"
-	proofPrunePeriod     = 1 * time.Minute
-)
-
-var (
-	errProofIDTooLarge        = errors.New("proof ID too large")
-	errWrongProofBytesWritten = errors.New("wrong number of bytes written")
-	errWrongProofVersion      = errors.New("wrong proof version")
-	errWrongProofBytesRead    = errors.New("wrong number of bytes read")
-	errNoProofBasePath        = errors.New("ProofStorage base path not specified in init")
-	errProofAlreadyExists     = errors.New("proof already exists")
-)
-
-type (
-	// ProofIdent is a unique identifier for a proof.
-	ProofIdent struct {
-		BlockRoot [fieldparams.RootLength]byte
-		Epoch     primitives.Epoch
-		ProofID   uint64
-	}
-
-	// ProofsIdent is a collection of unique identifiers for proofs.
-	ProofsIdent struct {
-		BlockRoot [fieldparams.RootLength]byte
-		Epoch     primitives.Epoch
-		ProofIDs  []uint64
-	}
-
-	// ProofStorage is the concrete implementation of the filesystem backend for saving and retrieving ExecutionProofs.
-	ProofStorage struct {
-		base            string
-		retentionEpochs primitives.Epoch
-		fs              afero.Fs
-		cache           *proofCache
-		proofFeed       *event.Feed
-		pruneMu         sync.RWMutex
-
-		mu      sync.Mutex // protects muChans
-		muChans map[[fieldparams.RootLength]byte]*proofMuChan
-	}
-
-	// ProofStorageOption is a functional option for configuring a ProofStorage.
-	ProofStorageOption func(*ProofStorage) error
-
-	proofMuChan struct {
-		mu      *sync.RWMutex
-		toStore chan []*ethpb.ExecutionProof
-	}
-
-	// proofSlotEntry represents the offset and size for a proof in the file.
-	proofSlotEntry struct {
-		offset uint32
-		size   uint32
-	}
-
-	// proofOffsetTable is the offset table with 8 slots indexed by proofID.
-	proofOffsetTable [maxProofTypes]proofSlotEntry
-
-	// proofFileMetadata contains metadata extracted from a proof file path.
-	proofFileMetadata struct {
-		period    uint64
-		epoch     primitives.Epoch
-		blockRoot [fieldparams.RootLength]byte
-	}
-)
-
-// WithProofBasePath is a required option that sets the base path of proof storage.
-func WithProofBasePath(base string) ProofStorageOption {
-	return func(ps *ProofStorage) error {
-		ps.base = base
-		return nil
-	}
-}
-
-// WithProofRetentionEpochs is an option that changes the number of epochs proofs will be persisted.
-func WithProofRetentionEpochs(e primitives.Epoch) ProofStorageOption {
-	return func(ps *ProofStorage) error {
-		ps.retentionEpochs = e
-		return nil
-	}
-}
-
-// WithProofFs allows the afero.Fs implementation to be customized.
-// Used by tests to substitute an in-memory filesystem.
-func WithProofFs(fs afero.Fs) ProofStorageOption {
-	return func(ps *ProofStorage) error {
-		ps.fs = fs
-		return nil
-	}
-}
-
-// NewProofStorage creates a new instance of the ProofStorage object.
-func NewProofStorage(ctx context.Context, opts ...ProofStorageOption) (*ProofStorage, error) {
-	storage := &ProofStorage{
-		proofFeed: new(event.Feed),
-		muChans:   make(map[[fieldparams.RootLength]byte]*proofMuChan),
-	}
-
-	for _, o := range opts {
-		if err := o(storage); err != nil {
-			return nil, fmt.Errorf("failed to create proof storage: %w", err)
-		}
-	}
-
-	// Allow tests to set up a different fs using WithProofFs.
-	if storage.fs == nil {
-		if storage.base == "" {
-			return nil, errNoProofBasePath
-		}
-
-		storage.base = path.Clean(storage.base)
-		if err := file.MkdirAll(storage.base); err != nil {
-			return nil, fmt.Errorf("failed to create proof storage at %s: %w", storage.base, err)
-		}
-
-		storage.fs = afero.NewBasePathFs(afero.NewOsFs(), storage.base)
-	}
-
-	storage.cache = newProofCache()
-
-	async.RunEvery(ctx, proofPrunePeriod, func() {
-		storage.pruneMu.Lock()
-		defer storage.pruneMu.Unlock()
-
-		storage.prune()
-	})
-
-	return storage, nil
-}
-
-// WarmCache warms the cache of the proof filesystem.
-func (ps *ProofStorage) WarmCache() {
-	start := time.Now()
-	log.Info("Proof filesystem cache warm-up started")
-
-	ps.pruneMu.Lock()
-	defer ps.pruneMu.Unlock()
-
-	// List all period directories
-	periodFileInfos, err := afero.ReadDir(ps.fs, ".")
-	if err != nil {
-		log.WithError(err).Error("Error reading top directory during proof warm cache")
-		return
-	}
-
-	// Iterate through periods
-	for _, periodFileInfo := range periodFileInfos {
-		if !periodFileInfo.IsDir() {
-			continue
-		}
-
-		periodPath := periodFileInfo.Name()
-
-		// List all epoch directories in this period
-		epochFileInfos, err := afero.ReadDir(ps.fs, periodPath)
-		if err != nil {
-			log.WithError(err).WithField("period", periodPath).Error("Error reading period directory during proof warm cache")
-			continue
-		}
-
-		// Iterate through epochs
-		for _, epochFileInfo := range epochFileInfos {
-			if !epochFileInfo.IsDir() {
-				continue
-			}
-
-			epochPath := path.Join(periodPath, epochFileInfo.Name())
-
-			// List all .sszs files in this epoch
-			files, err := ps.listProofEpochFiles(epochPath)
-			if err != nil {
-				log.WithError(err).WithField("epoch", epochPath).Error("Error listing epoch files during proof warm cache")
-				continue
-			}
-
-			// Process all files in this epoch in parallel
-			ps.processProofEpochFiles(files)
-		}
-	}
-
-	// Prune the cache and the filesystem
-	ps.prune()
-
-	totalElapsed := time.Since(start)
-	log.WithField("elapsed", totalElapsed).Info("Proof filesystem cache warm-up complete")
-}
-
-// listProofEpochFiles lists all .sszs files in an epoch directory.
-func (ps *ProofStorage) listProofEpochFiles(epochPath string) ([]string, error) {
-	fileInfos, err := afero.ReadDir(ps.fs, epochPath)
-	if err != nil {
-		return nil, fmt.Errorf("read epoch directory: %w", err)
-	}
-
-	files := make([]string, 0, len(fileInfos))
-	for _, fileInfo := range fileInfos {
-		if fileInfo.IsDir() {
-			continue
-		}
-
-		fileName := fileInfo.Name()
-		if strings.HasSuffix(fileName, "."+proofsFileExtension) {
-			files = append(files, path.Join(epochPath, fileName))
-		}
-	}
-
-	return files, nil
-}
-
-// processProofEpochFiles processes all proof files in an epoch in parallel.
-func (ps *ProofStorage) processProofEpochFiles(files []string) {
-	var wg sync.WaitGroup
-
-	for _, filePath := range files {
-		wg.Go(func() {
-			if err := ps.processProofFile(filePath); err != nil {
-				log.WithError(err).WithField("file", filePath).Error("Error processing proof file during warm cache")
-			}
-		})
-	}
-
-	wg.Wait()
-}
-
-// processProofFile processes a single .sszs proof file for cache warming.
-func (ps *ProofStorage) processProofFile(filePath string) error {
-	// Extract metadata from the file path
-	fileMetadata, err := extractProofFileMetadata(filePath)
-	if err != nil {
-		return fmt.Errorf("extract proof file metadata: %w", err)
-	}
-
-	// Open the file
-	f, err := ps.fs.Open(filePath)
-	if err != nil {
-		return fmt.Errorf("open file: %w", err)
-	}
-
-	defer func() {
-		if closeErr := f.Close(); closeErr != nil {
-			log.WithError(closeErr).WithField("file", filePath).Error("Error closing file during proof warm cache")
-		}
-	}()
-
-	// Read the offset table
-	offsetTable, _, err := ps.readHeader(f)
-	if err != nil {
-		return fmt.Errorf("read header: %w", err)
-	}
-
-	// Add all present proofs to the cache
-	for proofID, entry := range offsetTable {
-		if entry.size == 0 {
-			continue
-		}
-
-		proofIdent := ProofIdent{
-			BlockRoot: fileMetadata.blockRoot,
-			Epoch:     fileMetadata.epoch,
-			ProofID:   uint64(proofID),
-		}
-
-		ps.cache.set(proofIdent)
-	}
-
-	return nil
-}
-
-// Summary returns the ProofStorageSummary for a given root.
-func (ps *ProofStorage) Summary(root [fieldparams.RootLength]byte) ProofStorageSummary {
-	return ps.cache.Summary(root)
-}
-
-// Save saves execution proofs into the database.
-func (ps *ProofStorage) Save(proofs []*ethpb.ExecutionProof) error {
-	startTime := time.Now()
-
-	if len(proofs) == 0 {
-		return nil
-	}
-
-	proofsByRoot := make(map[[fieldparams.RootLength]byte][]*ethpb.ExecutionProof)
-
-	// Group proofs by root.
-	for _, proof := range proofs {
-		// Check if the proof ID is valid.
-		proofID := uint64(proof.ProofId)
-		if proofID >= maxProofTypes {
-			return errProofIDTooLarge
-		}
-
-		// Extract block root from proof.
-		var blockRoot [fieldparams.RootLength]byte
-		copy(blockRoot[:], proof.BlockRoot)
-
-		// Group proofs by root.
-		proofsByRoot[blockRoot] = append(proofsByRoot[blockRoot], proof)
-	}
-
-	for blockRoot, proofsForRoot := range proofsByRoot {
-		// Compute epoch from slot.
-		epoch := slots.ToEpoch(proofsForRoot[0].Slot)
-
-		// Save proofs in the filesystem.
-		if err := ps.saveFilesystem(blockRoot, epoch, proofsForRoot); err != nil {
-			return fmt.Errorf("save filesystem: %w", err)
-		}
-
-		// Get all proof IDs.
-		proofIDs := make([]uint64, 0, len(proofsForRoot))
-		for _, proof := range proofsForRoot {
-			proofIDs = append(proofIDs, uint64(proof.ProofId))
-		}
-
-		// Compute the proofs ident.
-		proofsIdent := ProofsIdent{BlockRoot: blockRoot, Epoch: epoch, ProofIDs: proofIDs}
-
-		// Set proofs in the cache.
-		ps.cache.setMultiple(proofsIdent)
-
-		// Notify the proof feed.
-		ps.proofFeed.Send(proofsIdent)
-	}
-
-	proofSaveLatency.Observe(float64(time.Since(startTime).Milliseconds()))
-
-	return nil
-}
-
-// saveFilesystem saves proofs into the database.
-// This function expects all proofs to belong to the same block.
-func (ps *ProofStorage) saveFilesystem(root [fieldparams.RootLength]byte, epoch primitives.Epoch, proofs []*ethpb.ExecutionProof) error {
-	// Compute the file path.
-	filePath := proofFilePath(root, epoch)
-
-	ps.pruneMu.RLock()
-	defer ps.pruneMu.RUnlock()
-
-	fileMu, toStore := ps.fileMutexChan(root)
-	toStore <- proofs
-
-	fileMu.Lock()
-	defer fileMu.Unlock()
-
-	// Check if the file exists.
-	exists, err := afero.Exists(ps.fs, filePath)
-	if err != nil {
-		return fmt.Errorf("afero exists: %w", err)
-	}
-
-	if exists {
-		if err := ps.saveProofExistingFile(filePath, toStore); err != nil {
-			return fmt.Errorf("save proof existing file: %w", err)
-		}
-
-		return nil
-	}
-
-	if err := ps.saveProofNewFile(filePath, toStore); err != nil {
-		return fmt.Errorf("save proof new file: %w", err)
-	}
-
-	return nil
-}
-
-// Subscribe subscribes to the proof feed.
-// It returns the subscription and a 1-size buffer channel to receive proof idents.
-func (ps *ProofStorage) Subscribe() (event.Subscription, <-chan ProofsIdent) {
-	identsChan := make(chan ProofsIdent, 1)
-	subscription := ps.proofFeed.Subscribe(identsChan)
-	return subscription, identsChan
-}
-
-// Get retrieves execution proofs from the database.
-// If one of the requested proofs is not found, it is just skipped.
-// If proofIDs is nil, then all stored proofs are returned.
-func (ps *ProofStorage) Get(root [fieldparams.RootLength]byte, proofIDs []uint64) ([]*ethpb.ExecutionProof, error) {
-	ps.pruneMu.RLock()
-	defer ps.pruneMu.RUnlock()
-
-	fileMu, _ := ps.fileMutexChan(root)
-	fileMu.RLock()
-	defer fileMu.RUnlock()
-
-	startTime := time.Now()
-
-	// Build all proofIDs if none are provided.
-	if proofIDs == nil {
-		proofIDs = make([]uint64, maxProofTypes)
-		for i := range proofIDs {
-			proofIDs[i] = uint64(i)
-		}
-	}
-
-	summary, ok := ps.cache.get(root)
-	if !ok {
-		// Nothing found in db. Exit early.
-		return nil, nil
-	}
-
-	// Check if any requested proofID exists.
-	if !slices.ContainsFunc(proofIDs, summary.HasProof) {
-		return nil, nil
-	}
-
-	// Compute the file path.
-	filePath := proofFilePath(root, summary.epoch)
-
-	// Open the proof file.
-	file, err := ps.fs.Open(filePath)
-	if err != nil {
-		return nil, fmt.Errorf("proof file open: %w", err)
-	}
-	defer func() {
-		if closeErr := file.Close(); closeErr != nil {
-			log.WithError(closeErr).WithField("file", filePath).Error("Error closing proof file")
-		}
-	}()
-
-	// Read the header.
-	offsetTable, _, err := ps.readHeader(file)
-	if err != nil {
-		return nil, fmt.Errorf("read header: %w", err)
-	}
-
-	// Retrieve proofs from the file.
-	proofs := make([]*ethpb.ExecutionProof, 0, len(proofIDs))
-	for _, proofID := range proofIDs {
-		if proofID >= maxProofTypes {
-			continue
-		}
-
-		entry := offsetTable[proofID]
-		// Skip if the proof is not saved.
-		if entry.size == 0 {
-			continue
-		}
-
-		// Seek to the proof offset (offset is relative to end of header).
-		_, err = file.Seek(proofHeaderSize+int64(entry.offset), io.SeekStart)
-		if err != nil {
-			return nil, fmt.Errorf("seek: %w", err)
-		}
-
-		// Read the SSZ encoded proof.
-		sszProof := make([]byte, entry.size)
-		n, err := io.ReadFull(file, sszProof)
-		if err != nil {
-			return nil, fmt.Errorf("read proof: %w", err)
-		}
-		if n != int(entry.size) {
-			return nil, errWrongProofBytesRead
-		}
-
-		// Unmarshal the proof.
-		proof := new(ethpb.ExecutionProof)
-		if err := proof.UnmarshalSSZ(sszProof); err != nil {
-			return nil, fmt.Errorf("unmarshal proof: %w", err)
-		}
-
-		proofs = append(proofs, proof)
-	}
-
-	proofFetchLatency.Observe(float64(time.Since(startTime).Milliseconds()))
-
-	return proofs, nil
-}
-
-// Remove deletes all proofs for a given root.
-func (ps *ProofStorage) Remove(blockRoot [fieldparams.RootLength]byte) error {
-	ps.pruneMu.RLock()
-	defer ps.pruneMu.RUnlock()
-
-	fileMu, _ := ps.fileMutexChan(blockRoot)
-	fileMu.Lock()
-	defer fileMu.Unlock()
-
-	summary, ok := ps.cache.get(blockRoot)
-	if !ok {
-		// Nothing found in db. Exit early.
-		return nil
-	}
-
-	// Remove the proofs from the cache.
-	ps.cache.evict(blockRoot)
-
-	// Remove the proof file.
-	filePath := proofFilePath(blockRoot, summary.epoch)
-	if err := ps.fs.Remove(filePath); err != nil {
-		return fmt.Errorf("remove: %w", err)
-	}
-
-	return nil
-}
-
-// Clear deletes all files on the filesystem.
-func (ps *ProofStorage) Clear() error {
-	ps.pruneMu.Lock()
-	defer ps.pruneMu.Unlock()
-
-	dirs, err := listDir(ps.fs, ".")
-	if err != nil {
-		return fmt.Errorf("list dir: %w", err)
-	}
-
-	ps.cache.clear()
-
-	for _, dir := range dirs {
-		if err := ps.fs.RemoveAll(dir); err != nil {
-			return fmt.Errorf("remove all: %w", err)
-		}
-	}
-
-	return nil
-}
-
-// saveProofNewFile saves proofs to a new file.
-func (ps *ProofStorage) saveProofNewFile(filePath string, inputProofs chan []*ethpb.ExecutionProof) (err error) {
-	// Initialize the offset table.
-	var offsetTable proofOffsetTable
-
-	var sszEncodedProofs []byte
-	currentOffset := uint32(0)
-
-	for {
-		proofs := pullProofChan(inputProofs)
-		if len(proofs) == 0 {
-			break
-		}
-
-		for _, proof := range proofs {
-			proofID := uint64(proof.ProofId)
-			if proofID >= maxProofTypes {
-				continue
-			}
-
-			// Skip if already in offset table (duplicate).
-			if offsetTable[proofID].size != 0 {
-				continue
-			}
-
-			// SSZ encode the proof.
-			sszProof, err := proof.MarshalSSZ()
-			if err != nil {
-				return fmt.Errorf("marshal proof SSZ: %w", err)
-			}
-
-			proofSize := uint32(len(sszProof))
-
-			// Update offset table.
-			offsetTable[proofID] = proofSlotEntry{
-				offset: currentOffset,
-				size:   proofSize,
-			}
-
-			// Append SSZ encoded proof.
-			sszEncodedProofs = append(sszEncodedProofs, sszProof...)
-			currentOffset += proofSize
-		}
-	}
-
-	if len(sszEncodedProofs) == 0 {
-		// Nothing to save.
-		return nil
-	}
-
-	// Create directory structure.
-	dir := filepath.Dir(filePath)
-	if err := ps.fs.MkdirAll(dir, directoryPermissions()); err != nil {
-		return fmt.Errorf("mkdir all: %w", err)
-	}
-
-	file, err := ps.fs.Create(filePath)
-	if err != nil {
-		return fmt.Errorf("create proof file: %w", err)
-	}
-
-	defer func() {
-		closeErr := file.Close()
-		if closeErr != nil && err == nil {
-			err = closeErr
-		}
-	}()
-
-	// Build the file content.
-	countToWrite := proofHeaderSize + len(sszEncodedProofs)
-	bytes := make([]byte, 0, countToWrite)
-
-	// Write version byte.
-	bytes = append(bytes, byte(proofVersion))
-
-	// Write offset table.
-	bytes = append(bytes, encodeOffsetTable(offsetTable)...)
-
-	// Write SSZ encoded proofs.
-	bytes = append(bytes, sszEncodedProofs...)
-
-	countWritten, err := file.Write(bytes)
-	if err != nil {
-		return fmt.Errorf("write: %w", err)
-	}
-	if countWritten != countToWrite {
-		return errWrongProofBytesWritten
-	}
-
-	syncStart := time.Now()
-	if err := file.Sync(); err != nil {
-		return fmt.Errorf("sync: %w", err)
-	}
-	proofFileSyncLatency.Observe(float64(time.Since(syncStart).Milliseconds()))
-
-	return nil
-}
-
-// saveProofExistingFile saves proofs to an existing file.
-func (ps *ProofStorage) saveProofExistingFile(filePath string, inputProofs chan []*ethpb.ExecutionProof) (err error) {
-	// Open the file for read/write.
-	file, err := ps.fs.OpenFile(filePath, os.O_RDWR, os.FileMode(0600))
-	if err != nil {
-		return fmt.Errorf("open proof file: %w", err)
-	}
-
-	defer func() {
-		closeErr := file.Close()
-		if closeErr != nil && err == nil {
-			err = closeErr
-		}
-	}()
-
-	// Read current header.
-	offsetTable, fileSize, err := ps.readHeader(file)
-	if err != nil {
-		return fmt.Errorf("read header: %w", err)
-	}
-
-	var sszEncodedProofs []byte
-	currentOffset := uint32(fileSize - proofHeaderSize)
-	modified := false
-
-	for {
-		proofs := pullProofChan(inputProofs)
-		if len(proofs) == 0 {
-			break
-		}
-
-		for _, proof := range proofs {
-			proofID := uint64(proof.ProofId)
-			if proofID >= maxProofTypes {
-				continue
-			}
-
-			// Skip if proof already exists.
-			if offsetTable[proofID].size != 0 {
-				continue
-			}
-
-			// SSZ encode the proof.
-			sszProof, err := proof.MarshalSSZ()
-			if err != nil {
-				return fmt.Errorf("marshal proof SSZ: %w", err)
-			}
-
-			proofSize := uint32(len(sszProof))
-
-			// Update offset table.
-			offsetTable[proofID] = proofSlotEntry{
-				offset: currentOffset,
-				size:   proofSize,
-			}
-
-			// Append SSZ encoded proof.
-			sszEncodedProofs = append(sszEncodedProofs, sszProof...)
-			currentOffset += proofSize
-			modified = true
-		}
-	}
-
-	if !modified {
-		return nil
-	}
-
-	// Write updated offset table back to file (at position 1, after version byte).
-	encodedTable := encodeOffsetTable(offsetTable)
-	count, err := file.WriteAt(encodedTable, int64(proofVersionSize))
-	if err != nil {
-		return fmt.Errorf("write offset table: %w", err)
-	}
-	if count != proofOffsetTableSize {
-		return errWrongProofBytesWritten
-	}
-
-	// Append the SSZ encoded proofs to the end of the file.
-	count, err = file.WriteAt(sszEncodedProofs, fileSize)
-	if err != nil {
-		return fmt.Errorf("write SSZ encoded proofs: %w", err)
-	}
-	if count != len(sszEncodedProofs) {
-		return errWrongProofBytesWritten
-	}
-
-	syncStart := time.Now()
-	if err := file.Sync(); err != nil {
-		return fmt.Errorf("sync: %w", err)
-	}
-	proofFileSyncLatency.Observe(float64(time.Since(syncStart).Milliseconds()))
-
-	return nil
-}
-
-// readHeader reads the file header and returns the offset table and file size.
-func (ps *ProofStorage) readHeader(file afero.File) (proofOffsetTable, int64, error) {
-	var header [proofHeaderSize]byte
-	countRead, err := file.ReadAt(header[:], 0)
-	if err != nil {
-		return proofOffsetTable{}, 0, fmt.Errorf("read at: %w", err)
-	}
-	if countRead != proofHeaderSize {
-		return proofOffsetTable{}, 0, errWrongProofBytesRead
-	}
-
-	// Check version.
-	fileVersion := int(header[0])
-	if fileVersion != proofVersion {
-		return proofOffsetTable{}, 0, errWrongProofVersion
-	}
-
-	// Decode offset table and compute file size.
-	var offsetTable proofOffsetTable
-	fileSize := int64(proofHeaderSize)
-	for i := range offsetTable {
-		pos := proofVersionSize + i*proofSlotSize
-		offsetTable[i].offset = binary.BigEndian.Uint32(header[pos : pos+proofOffsetSize])
-		offsetTable[i].size = binary.BigEndian.Uint32(header[pos+proofOffsetSize : pos+proofSlotSize])
-		fileSize += int64(offsetTable[i].size)
-	}
-
-	return offsetTable, fileSize, nil
-}
-
-// prune cleans the cache, the filesystem and mutexes.
-func (ps *ProofStorage) prune() {
-	startTime := time.Now()
-	defer func() {
-		proofPruneLatency.Observe(float64(time.Since(startTime).Milliseconds()))
-	}()
-
-	highestStoredEpoch := ps.cache.HighestEpoch()
-
-	// Check if we need to prune.
-	if highestStoredEpoch < ps.retentionEpochs {
-		return
-	}
-
-	highestEpochToPrune := highestStoredEpoch - ps.retentionEpochs
-	highestPeriodToPrune := proofPeriod(highestEpochToPrune)
-
-	// Prune the cache.
-	prunedCount := ps.cache.pruneUpTo(highestEpochToPrune)
-
-	if prunedCount == 0 {
-		return
-	}
-
-	proofPrunedCounter.Add(float64(prunedCount))
-
-	// Prune the filesystem.
-	periodFileInfos, err := afero.ReadDir(ps.fs, ".")
-	if err != nil {
-		log.WithError(err).Error("Error encountered while reading top directory during proof prune")
-		return
-	}
-
-	for _, periodFileInfo := range periodFileInfos {
-		periodStr := periodFileInfo.Name()
-		period, err := strconv.ParseUint(periodStr, 10, 64)
-		if err != nil {
-			log.WithError(err).Errorf("Error encountered while parsing period %s", periodStr)
-			continue
-		}
-
-		if period < highestPeriodToPrune {
-			// Remove everything lower than highest period to prune.
-			if err := ps.fs.RemoveAll(periodStr); err != nil {
-				log.WithError(err).Error("Error encountered while removing period directory during proof prune")
-			}
-			continue
-		}
-
-		if period > highestPeriodToPrune {
-			// Do not remove anything higher than highest period to prune.
-			continue
-		}
-
-		// if period == highestPeriodToPrune
-		epochFileInfos, err := afero.ReadDir(ps.fs, periodStr)
-		if err != nil {
-			log.WithError(err).Error("Error encountered while reading epoch directory during proof prune")
-			continue
-		}
-
-		for _, epochFileInfo := range epochFileInfos {
-			epochStr := epochFileInfo.Name()
-			epochDir := path.Join(periodStr, epochStr)
-
-			epoch, err := strconv.ParseUint(epochStr, 10, 64)
-			if err != nil {
-				log.WithError(err).Errorf("Error encountered while parsing epoch %s", epochStr)
-				continue
-			}
-
-			if primitives.Epoch(epoch) > highestEpochToPrune {
-				continue
-			}
-
-			if err := ps.fs.RemoveAll(epochDir); err != nil {
-				log.WithError(err).Error("Error encountered while removing epoch directory during proof prune")
-				continue
-			}
-		}
-	}
-
-	ps.mu.Lock()
-	defer ps.mu.Unlock()
-	clear(ps.muChans)
-}
-
-// fileMutexChan returns the file mutex and channel for a given block root.
-func (ps *ProofStorage) fileMutexChan(root [fieldparams.RootLength]byte) (*sync.RWMutex, chan []*ethpb.ExecutionProof) {
-	ps.mu.Lock()
-	defer ps.mu.Unlock()
-
-	mc, ok := ps.muChans[root]
-	if !ok {
-		mc = &proofMuChan{
-			mu:      new(sync.RWMutex),
-			toStore: make(chan []*ethpb.ExecutionProof, 1),
-		}
-		ps.muChans[root] = mc
-		return mc.mu, mc.toStore
-	}
-
-	return mc.mu, mc.toStore
-}
-
-// pullProofChan pulls proofs from the input channel until it is empty.
-func pullProofChan(inputProofs chan []*ethpb.ExecutionProof) []*ethpb.ExecutionProof {
-	proofs := make([]*ethpb.ExecutionProof, 0, maxProofTypes)
-
-	for {
-		select {
-		case batch := <-inputProofs:
-			proofs = append(proofs, batch...)
-		default:
-			return proofs
-		}
-	}
-}
-
-// proofFilePath builds the file path in database for a given root and epoch.
-func proofFilePath(root [fieldparams.RootLength]byte, epoch primitives.Epoch) string {
-	return path.Join(
-		fmt.Sprintf("%d", proofPeriod(epoch)),
-		fmt.Sprintf("%d", epoch),
-		fmt.Sprintf("%#x.%s", root, proofsFileExtension),
-	)
-}
-
-// extractProofFileMetadata extracts the metadata from a proof file path.
-func extractProofFileMetadata(path string) (*proofFileMetadata, error) {
-	// Use filepath.Separator to handle both Windows (\) and Unix (/) path separators
-	parts := strings.Split(path, string(filepath.Separator))
-	if len(parts) != 3 {
-		return nil, fmt.Errorf("unexpected proof file %s", path)
-	}
-
-	period, err := strconv.ParseUint(parts[0], 10, 64)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse period from %s: %w", path, err)
-	}
-
-	epoch, err := strconv.ParseUint(parts[1], 10, 64)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse epoch from %s: %w", path, err)
-	}
-
-	partsRoot := strings.Split(parts[2], ".")
-	if len(partsRoot) != 2 {
-		return nil, fmt.Errorf("failed to parse root from %s", path)
-	}
-
-	blockRootString := partsRoot[0]
-	if len(blockRootString) != 2+2*fieldparams.RootLength || blockRootString[:2] != "0x" {
-		return nil, fmt.Errorf("unexpected proof file name %s", path)
-	}
-
-	if partsRoot[1] != proofsFileExtension {
-		return nil, fmt.Errorf("unexpected extension %s", path)
-	}
-
-	blockRootSlice, err := hex.DecodeString(blockRootString[2:])
-	if err != nil {
-		return nil, fmt.Errorf("decode string from %s: %w", path, err)
-	}
-
-	var blockRoot [fieldparams.RootLength]byte
-	copy(blockRoot[:], blockRootSlice)
-
-	result := &proofFileMetadata{period: period, epoch: primitives.Epoch(epoch), blockRoot: blockRoot}
-	return result, nil
-}
-
-// proofPeriod computes the period of a given epoch.
-func proofPeriod(epoch primitives.Epoch) uint64 {
-	return uint64(epoch / params.BeaconConfig().MinEpochsForDataColumnSidecarsRequest)
-}
-
-// encodeOffsetTable encodes the offset table to bytes.
-func encodeOffsetTable(table proofOffsetTable) []byte {
-	result := make([]byte, proofOffsetTableSize)
-	for i, entry := range table {
-		offset := i * proofSlotSize
-		binary.BigEndian.PutUint32(result[offset:offset+proofOffsetSize], entry.offset)
-		binary.BigEndian.PutUint32(result[offset+proofOffsetSize:offset+proofSlotSize], entry.size)
-	}
-	return result
-}

beacon-chain/db/filesystem/proof_cache.go

@@ -1,206 +0,0 @@
-package filesystem
-
-import (
-	"slices"
-	"sync"
-
-	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-)
-
-// ProofStorageSummary represents cached information about the proofs on disk for each root the cache knows about.
-type ProofStorageSummary struct {
-	epoch    primitives.Epoch
-	proofIDs map[uint64]bool
-}
-
-// HasProof returns true if the proof with the given proofID is available in the filesystem.
-func (s ProofStorageSummary) HasProof(proofID uint64) bool {
-	if s.proofIDs == nil {
-		return false
-	}
-	_, ok := s.proofIDs[proofID]
-	return ok
-}
-
-// Count returns the number of available proofs.
-func (s ProofStorageSummary) Count() int {
-	return len(s.proofIDs)
-}
-
-// All returns all stored proofIDs sorted in ascending order.
-func (s ProofStorageSummary) All() []uint64 {
-	if s.proofIDs == nil {
-		return nil
-	}
-	ids := make([]uint64, 0, len(s.proofIDs))
-	for id := range s.proofIDs {
-		ids = append(ids, id)
-	}
-	slices.Sort(ids)
-	return ids
-}
-
-type proofCache struct {
-	mu                 sync.RWMutex
-	proofCount         float64
-	lowestCachedEpoch  primitives.Epoch
-	highestCachedEpoch primitives.Epoch
-	cache              map[[fieldparams.RootLength]byte]ProofStorageSummary
-}
-
-func newProofCache() *proofCache {
-	return &proofCache{
-		cache:             make(map[[fieldparams.RootLength]byte]ProofStorageSummary),
-		lowestCachedEpoch: params.BeaconConfig().FarFutureEpoch,
-	}
-}
-
-// Summary returns the ProofStorageSummary for `root`.
-// The ProofStorageSummary can be used to check for the presence of proofs based on proofID.
-func (pc *proofCache) Summary(root [fieldparams.RootLength]byte) ProofStorageSummary {
-	pc.mu.RLock()
-	defer pc.mu.RUnlock()
-
-	return pc.cache[root]
-}
-
-// HighestEpoch returns the highest cached epoch.
-func (pc *proofCache) HighestEpoch() primitives.Epoch {
-	pc.mu.RLock()
-	defer pc.mu.RUnlock()
-
-	return pc.highestCachedEpoch
-}
-
-// set adds a proof to the cache.
-func (pc *proofCache) set(ident ProofIdent) {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-
-	summary := pc.cache[ident.BlockRoot]
-	if summary.proofIDs == nil {
-		summary.proofIDs = make(map[uint64]bool)
-	}
-	summary.epoch = ident.Epoch
-
-	if _, exists := summary.proofIDs[ident.ProofID]; exists {
-		pc.cache[ident.BlockRoot] = summary
-		return
-	}
-
-	summary.proofIDs[ident.ProofID] = true
-	pc.lowestCachedEpoch = min(pc.lowestCachedEpoch, ident.Epoch)
-	pc.highestCachedEpoch = max(pc.highestCachedEpoch, ident.Epoch)
-
-	pc.cache[ident.BlockRoot] = summary
-
-	pc.proofCount++
-	proofDiskCount.Set(pc.proofCount)
-	proofWrittenCounter.Inc()
-}
-
-// setMultiple adds multiple proofs to the cache.
-func (pc *proofCache) setMultiple(ident ProofsIdent) {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-
-	summary := pc.cache[ident.BlockRoot]
-	if summary.proofIDs == nil {
-		summary.proofIDs = make(map[uint64]bool)
-	}
-	summary.epoch = ident.Epoch
-
-	addedCount := 0
-	for _, proofID := range ident.ProofIDs {
-		if _, exists := summary.proofIDs[proofID]; exists {
-			continue
-		}
-		summary.proofIDs[proofID] = true
-		addedCount++
-	}
-
-	if addedCount == 0 {
-		pc.cache[ident.BlockRoot] = summary
-		return
-	}
-
-	pc.lowestCachedEpoch = min(pc.lowestCachedEpoch, ident.Epoch)
-	pc.highestCachedEpoch = max(pc.highestCachedEpoch, ident.Epoch)
-
-	pc.cache[ident.BlockRoot] = summary
-
-	pc.proofCount += float64(addedCount)
-	proofDiskCount.Set(pc.proofCount)
-	proofWrittenCounter.Add(float64(addedCount))
-}
-
-// get returns the ProofStorageSummary for the given block root.
-// If the root is not in the cache, the second return value will be false.
-func (pc *proofCache) get(blockRoot [fieldparams.RootLength]byte) (ProofStorageSummary, bool) {
-	pc.mu.RLock()
-	defer pc.mu.RUnlock()
-
-	summary, ok := pc.cache[blockRoot]
-	return summary, ok
-}
-
-// evict removes the ProofStorageSummary for the given block root from the cache.
-func (pc *proofCache) evict(blockRoot [fieldparams.RootLength]byte) int {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-
-	summary, ok := pc.cache[blockRoot]
-	if !ok {
-		return 0
-	}
-
-	deleted := len(summary.proofIDs)
-	delete(pc.cache, blockRoot)
-
-	if deleted > 0 {
-		pc.proofCount -= float64(deleted)
-		proofDiskCount.Set(pc.proofCount)
-	}
-
-	return deleted
-}
-
-// pruneUpTo removes all entries from the cache up to the given target epoch included.
-func (pc *proofCache) pruneUpTo(targetEpoch primitives.Epoch) uint64 {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-
-	prunedCount := uint64(0)
-	newLowestCachedEpoch := params.BeaconConfig().FarFutureEpoch
-	newHighestCachedEpoch := primitives.Epoch(0)
-
-	for blockRoot, summary := range pc.cache {
-		epoch := summary.epoch
-
-		if epoch > targetEpoch {
-			newLowestCachedEpoch = min(newLowestCachedEpoch, epoch)
-			newHighestCachedEpoch = max(newHighestCachedEpoch, epoch)
-		}
-
-		if epoch <= targetEpoch {
-			prunedCount += uint64(len(summary.proofIDs))
-			delete(pc.cache, blockRoot)
-		}
-	}
-
-	if prunedCount > 0 {
-		pc.lowestCachedEpoch = newLowestCachedEpoch
-		pc.highestCachedEpoch = newHighestCachedEpoch
-		pc.proofCount -= float64(prunedCount)
-		proofDiskCount.Set(pc.proofCount)
-	}
-
-	return prunedCount
-}
-
-// clear removes all entries from the cache.
-func (pc *proofCache) clear() uint64 {
-	return pc.pruneUpTo(params.BeaconConfig().FarFutureEpoch)
-}

beacon-chain/db/filesystem/proof_test.go

@@ -1,407 +0,0 @@
-package filesystem
-
-import (
-	"encoding/binary"
-	"os"
-	"testing"
-
-	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/spf13/afero"
-)
-
-func createTestProof(t *testing.T, slot primitives.Slot, proofID uint64, blockRoot [32]byte) *ethpb.ExecutionProof {
-	t.Helper()
-
-	return &ethpb.ExecutionProof{
-		ProofId:   primitives.ExecutionProofId(proofID),
-		Slot:      slot,
-		BlockHash: make([]byte, 32),
-		BlockRoot: blockRoot[:],
-		ProofData: []byte("test proof data for proofID " + string(rune('0'+proofID))),
-	}
-}
-
-// assertProofsEqual compares two proofs by comparing their SSZ-encoded bytes.
-func assertProofsEqual(t *testing.T, expected, actual *ethpb.ExecutionProof) {
-	t.Helper()
-
-	expectedSSZ, err := expected.MarshalSSZ()
-	require.NoError(t, err)
-	actualSSZ, err := actual.MarshalSSZ()
-	require.NoError(t, err)
-	require.DeepEqual(t, expectedSSZ, actualSSZ)
-}
-
-func TestNewProofStorage(t *testing.T) {
-	ctx := t.Context()
-
-	t.Run("No base path", func(t *testing.T) {
-		_, err := NewProofStorage(ctx)
-		require.ErrorIs(t, err, errNoProofBasePath)
-	})
-
-	t.Run("Nominal", func(t *testing.T) {
-		dir := t.TempDir()
-
-		storage, err := NewProofStorage(ctx, WithProofBasePath(dir))
-		require.NoError(t, err)
-		require.Equal(t, dir, storage.base)
-	})
-}
-
-func TestProofSaveAndGet(t *testing.T) {
-	t.Run("proof ID too large", func(t *testing.T) {
-		_, proofStorage := NewEphemeralProofStorageAndFs(t)
-
-		proof := &ethpb.ExecutionProof{
-			ProofId:   primitives.ExecutionProofId(maxProofTypes), // too large
-			Slot:      1,
-			BlockHash: make([]byte, 32),
-			BlockRoot: make([]byte, 32),
-			ProofData: []byte("test"),
-		}
-
-		err := proofStorage.Save([]*ethpb.ExecutionProof{proof})
-		require.ErrorIs(t, err, errProofIDTooLarge)
-	})
-
-	t.Run("save empty slice", func(t *testing.T) {
-		_, proofStorage := NewEphemeralProofStorageAndFs(t)
-
-		err := proofStorage.Save([]*ethpb.ExecutionProof{})
-		require.NoError(t, err)
-	})
-
-	t.Run("save and get single proof", func(t *testing.T) {
-		_, proofStorage := NewEphemeralProofStorageAndFs(t)
-
-		blockRoot := [32]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32}
-		proof := createTestProof(t, 32, 2, blockRoot)
-
-		err := proofStorage.Save([]*ethpb.ExecutionProof{proof})
-		require.NoError(t, err)
-
-		// Check summary
-		summary := proofStorage.Summary(blockRoot)
-		require.Equal(t, true, summary.HasProof(2))
-		require.Equal(t, false, summary.HasProof(0))
-		require.Equal(t, false, summary.HasProof(1))
-		require.Equal(t, 1, summary.Count())
-
-		// Get the proof
-		proofs, err := proofStorage.Get(blockRoot, []uint64{2})
-		require.NoError(t, err)
-		require.Equal(t, 1, len(proofs))
-		assertProofsEqual(t, proof, proofs[0])
-	})
-
-	t.Run("save and get multiple proofs", func(t *testing.T) {
-		_, proofStorage := NewEphemeralProofStorageAndFs(t)
-
-		blockRoot := [32]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32}
-
-		// Save first proof
-		proof1 := createTestProof(t, 32, 0, blockRoot)
-		err := proofStorage.Save([]*ethpb.ExecutionProof{proof1})
-		require.NoError(t, err)
-
-		// Save second proof (should append to existing file)
-		proof2 := createTestProof(t, 32, 3, blockRoot)
-		err = proofStorage.Save([]*ethpb.ExecutionProof{proof2})
-		require.NoError(t, err)
-
-		// Save third proof
-		proof3 := createTestProof(t, 32, 7, blockRoot)
-		err = proofStorage.Save([]*ethpb.ExecutionProof{proof3})
-		require.NoError(t, err)
-
-		// Check summary
-		summary := proofStorage.Summary(blockRoot)
-		require.Equal(t, true, summary.HasProof(0))
-		require.Equal(t, false, summary.HasProof(1))
-		require.Equal(t, false, summary.HasProof(2))
-		require.Equal(t, true, summary.HasProof(3))
-		require.Equal(t, false, summary.HasProof(4))
-		require.Equal(t, false, summary.HasProof(5))
-		require.Equal(t, false, summary.HasProof(6))
-		require.Equal(t, true, summary.HasProof(7))
-		require.Equal(t, 3, summary.Count())
-
-		// Get all proofs
-		proofs, err := proofStorage.Get(blockRoot, nil)
-		require.NoError(t, err)
-		require.Equal(t, 3, len(proofs))
-
-		// Get specific proofs
-		proofs, err = proofStorage.Get(blockRoot, []uint64{0, 3})
-		require.NoError(t, err)
-		require.Equal(t, 2, len(proofs))
-		assertProofsEqual(t, proof1, proofs[0])
-		assertProofsEqual(t, proof2, proofs[1])
-	})
-
-	t.Run("duplicate proof is ignored", func(t *testing.T) {
-		_, proofStorage := NewEphemeralProofStorageAndFs(t)
-
-		blockRoot := [32]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32}
-		proof := createTestProof(t, 32, 2, blockRoot)
-
-		// Save first time
-		err := proofStorage.Save([]*ethpb.ExecutionProof{proof})
-		require.NoError(t, err)
-
-		// Save same proof again (should be silently ignored)
-		err = proofStorage.Save([]*ethpb.ExecutionProof{proof})
-		require.NoError(t, err)
-
-		// Check count
-		summary := proofStorage.Summary(blockRoot)
-		require.Equal(t, 1, summary.Count())
-
-		// Get the proof
-		proofs, err := proofStorage.Get(blockRoot, nil)
-		require.NoError(t, err)
-		require.Equal(t, 1, len(proofs))
-	})
-
-	t.Run("get non-existent root", func(t *testing.T) {
-		_, proofStorage := NewEphemeralProofStorageAndFs(t)
-
-		proofs, err := proofStorage.Get([fieldparams.RootLength]byte{1}, []uint64{0, 1, 2})
-		require.NoError(t, err)
-		require.Equal(t, 0, len(proofs))
-	})
-
-	t.Run("get non-existent proofIDs", func(t *testing.T) {
-		_, proofStorage := NewEphemeralProofStorageAndFs(t)
-
-		blockRoot := [32]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32}
-		proof := createTestProof(t, 32, 2, blockRoot)
-
-		err := proofStorage.Save([]*ethpb.ExecutionProof{proof})
-		require.NoError(t, err)
-
-		// Try to get proofIDs that don't exist
-		proofs, err := proofStorage.Get(blockRoot, []uint64{0, 1, 3, 4})
-		require.NoError(t, err)
-		require.Equal(t, 0, len(proofs))
-	})
-}
-
-func TestProofRemove(t *testing.T) {
-	t.Run("remove non-existent", func(t *testing.T) {
-		_, proofStorage := NewEphemeralProofStorageAndFs(t)
-		err := proofStorage.Remove([fieldparams.RootLength]byte{1})
-		require.NoError(t, err)
-	})
-
-	t.Run("remove existing", func(t *testing.T) {
-		_, proofStorage := NewEphemeralProofStorageAndFs(t)
-
-		blockRoot1 := [32]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32}
-		blockRoot2 := [32]byte{32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1}
-
-		proof1 := createTestProof(t, 32, 0, blockRoot1)
-		proof2 := createTestProof(t, 64, 1, blockRoot2)
-
-		err := proofStorage.Save([]*ethpb.ExecutionProof{proof1})
-		require.NoError(t, err)
-		err = proofStorage.Save([]*ethpb.ExecutionProof{proof2})
-		require.NoError(t, err)
-
-		// Remove first proof
-		err = proofStorage.Remove(blockRoot1)
-		require.NoError(t, err)
-
-		// Check first proof is gone
-		summary := proofStorage.Summary(blockRoot1)
-		require.Equal(t, 0, summary.Count())
-
-		proofs, err := proofStorage.Get(blockRoot1, nil)
-		require.NoError(t, err)
-		require.Equal(t, 0, len(proofs))
-
-		// Check second proof still exists
-		summary = proofStorage.Summary(blockRoot2)
-		require.Equal(t, 1, summary.Count())
-
-		proofs, err = proofStorage.Get(blockRoot2, nil)
-		require.NoError(t, err)
-		require.Equal(t, 1, len(proofs))
-	})
-}
-
-func TestProofClear(t *testing.T) {
-	_, proofStorage := NewEphemeralProofStorageAndFs(t)
-
-	blockRoot1 := [32]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32}
-	blockRoot2 := [32]byte{32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1}
-
-	proof1 := createTestProof(t, 32, 0, blockRoot1)
-	proof2 := createTestProof(t, 64, 1, blockRoot2)
-
-	err := proofStorage.Save([]*ethpb.ExecutionProof{proof1})
-	require.NoError(t, err)
-	err = proofStorage.Save([]*ethpb.ExecutionProof{proof2})
-	require.NoError(t, err)
-
-	// Clear all
-	err = proofStorage.Clear()
-	require.NoError(t, err)
-
-	// Check both are gone
-	summary := proofStorage.Summary(blockRoot1)
-	require.Equal(t, 0, summary.Count())
-
-	summary = proofStorage.Summary(blockRoot2)
-	require.Equal(t, 0, summary.Count())
-}
-
-func TestProofWarmCache(t *testing.T) {
-	fs, proofStorage := NewEphemeralProofStorageAndFs(t)
-
-	blockRoot1 := [32]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32}
-	blockRoot2 := [32]byte{32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1}
-
-	// Save proofs
-	proof1a := createTestProof(t, 32, 0, blockRoot1)
-	proof1b := createTestProof(t, 32, 3, blockRoot1)
-	proof2 := createTestProof(t, 64, 5, blockRoot2)
-
-	err := proofStorage.Save([]*ethpb.ExecutionProof{proof1a})
-	require.NoError(t, err)
-	err = proofStorage.Save([]*ethpb.ExecutionProof{proof1b})
-	require.NoError(t, err)
-	err = proofStorage.Save([]*ethpb.ExecutionProof{proof2})
-	require.NoError(t, err)
-
-	// Verify files exist
-	files, err := afero.ReadDir(fs, "0/1")
-	require.NoError(t, err)
-	require.Equal(t, 1, len(files))
-
-	files, err = afero.ReadDir(fs, "0/2")
-	require.NoError(t, err)
-	require.Equal(t, 1, len(files))
-
-	// Create a new storage with the same filesystem
-	proofStorage2 := NewEphemeralProofStorageUsingFs(t, fs)
-
-	// Before warm cache, cache should be empty
-	summary := proofStorage2.Summary(blockRoot1)
-	require.Equal(t, 0, summary.Count())
-
-	// Warm cache
-	proofStorage2.WarmCache()
-
-	// After warm cache, cache should be populated
-	summary = proofStorage2.Summary(blockRoot1)
-	require.Equal(t, 2, summary.Count())
-	require.Equal(t, true, summary.HasProof(0))
-	require.Equal(t, true, summary.HasProof(3))
-
-	summary = proofStorage2.Summary(blockRoot2)
-	require.Equal(t, 1, summary.Count())
-	require.Equal(t, true, summary.HasProof(5))
-}
-
-func TestProofSubscribe(t *testing.T) {
-	_, proofStorage := NewEphemeralProofStorageAndFs(t)
-
-	sub, ch := proofStorage.Subscribe()
-	defer sub.Unsubscribe()
-
-	blockRoot := [32]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32}
-	proof := createTestProof(t, 32, 2, blockRoot)
-
-	err := proofStorage.Save([]*ethpb.ExecutionProof{proof})
-	require.NoError(t, err)
-
-	// Should receive notification
-	ident := <-ch
-	require.Equal(t, blockRoot, ident.BlockRoot)
-	require.DeepEqual(t, []uint64{2}, ident.ProofIDs)
-	require.Equal(t, primitives.Epoch(1), ident.Epoch)
-}
-
-func TestProofReadHeader(t *testing.T) {
-	t.Run("wrong version", func(t *testing.T) {
-		_, proofStorage := NewEphemeralProofStorageAndFs(t)
-
-		blockRoot := [32]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32}
-		proof := createTestProof(t, 32, 0, blockRoot)
-
-		err := proofStorage.Save([]*ethpb.ExecutionProof{proof})
-		require.NoError(t, err)
-
-		// Get the file path
-		filePath := proofFilePath(blockRoot, 1)
-
-		// Alter the version
-		file, err := proofStorage.fs.OpenFile(filePath, os.O_RDWR, os.FileMode(0600))
-		require.NoError(t, err)
-
-		_, err = file.Write([]byte{42}) // wrong version
-		require.NoError(t, err)
-
-		// Try to read header
-		_, _, err = proofStorage.readHeader(file)
-		require.ErrorIs(t, err, errWrongProofVersion)
-
-		err = file.Close()
-		require.NoError(t, err)
-	})
-}
-
-func TestEncodeOffsetTable(t *testing.T) {
-	var table proofOffsetTable
-	table[0] = proofSlotEntry{offset: 0, size: 100}
-	table[3] = proofSlotEntry{offset: 100, size: 200}
-	table[7] = proofSlotEntry{offset: 300, size: 300}
-
-	encoded := encodeOffsetTable(table)
-	require.Equal(t, proofOffsetTableSize, len(encoded))
-
-	// Decode manually and verify
-	var decoded proofOffsetTable
-	for i := range decoded {
-		pos := i * proofSlotSize
-		decoded[i].offset = binary.BigEndian.Uint32(encoded[pos : pos+proofOffsetSize])
-		decoded[i].size = binary.BigEndian.Uint32(encoded[pos+proofOffsetSize : pos+proofSlotSize])
-	}
-	require.Equal(t, table, decoded)
-}
-
-func TestProofFilePath(t *testing.T) {
-	blockRoot := [32]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32}
-	epoch := primitives.Epoch(100)
-
-	path := proofFilePath(blockRoot, epoch)
-	require.Equal(t, "0/100/0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20.sszs", path)
-}
-
-func TestExtractProofFileMetadata(t *testing.T) {
-	t.Run("valid path", func(t *testing.T) {
-		path := "0/100/0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20.sszs"
-		metadata, err := extractProofFileMetadata(path)
-		require.NoError(t, err)
-
-		expectedRoot := [32]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32}
-		require.Equal(t, uint64(0), metadata.period)
-		require.Equal(t, primitives.Epoch(100), metadata.epoch)
-		require.Equal(t, expectedRoot, metadata.blockRoot)
-	})
-
-	t.Run("invalid path - wrong number of parts", func(t *testing.T) {
-		_, err := extractProofFileMetadata("invalid/path.sszs")
-		require.ErrorContains(t, "unexpected proof file", err)
-	})
-
-	t.Run("invalid path - wrong extension", func(t *testing.T) {
-		_, err := extractProofFileMetadata("0/100/0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20.txt")
-		require.ErrorContains(t, "unexpected extension", err)
-	})
-}

beacon-chain/db/iface/interface.go

@@ -66,6 +66,10 @@ type ReadOnlyDatabase interface {
 	OriginCheckpointBlockRoot(ctx context.Context) ([32]byte, error)
 	BackfillStatus(context.Context) (*dbval.BackfillStatus, error)
 
+	// Execution payload envelope operations (Gloas+).
+	ExecutionPayloadEnvelope(ctx context.Context, blockRoot [32]byte) (*ethpb.SignedBlindedExecutionPayloadEnvelope, error)
+	HasExecutionPayloadEnvelope(ctx context.Context, blockRoot [32]byte) bool
+
 	// P2P Metadata operations.
 	MetadataSeqNum(ctx context.Context) (uint64, error)
 }
@@ -115,6 +119,10 @@ type NoHeadAccessDatabase interface {
 	SaveLightClientUpdate(ctx context.Context, period uint64, update interfaces.LightClientUpdate) error
 	SaveLightClientBootstrap(ctx context.Context, blockRoot []byte, bootstrap interfaces.LightClientBootstrap) error
 
+	// Execution payload envelope operations (Gloas+).
+	SaveExecutionPayloadEnvelope(ctx context.Context, envelope *ethpb.SignedExecutionPayloadEnvelope) error
+	DeleteExecutionPayloadEnvelope(ctx context.Context, blockRoot [32]byte) error
+
 	CleanUpDirtyStates(ctx context.Context, slotsPerArchivedPoint primitives.Slot) error
 	DeleteHistoricalDataBeforeSlot(ctx context.Context, slot primitives.Slot, batchSize int) (int, error)
 

beacon-chain/db/kv/BUILD.bazel

@@ -13,6 +13,7 @@ go_library(
         "encoding.go",
         "error.go",
         "execution_chain.go",
+        "execution_payload_envelope.go",
         "finalized_block_roots.go",
         "genesis.go",
         "key.go",
@@ -96,6 +97,7 @@ go_test(
         "deposit_contract_test.go",
         "encoding_test.go",
         "execution_chain_test.go",
+        "execution_payload_envelope_test.go",
         "finalized_block_roots_test.go",
         "genesis_test.go",
         "init_test.go",

beacon-chain/db/kv/archived_point.go

@@ -2,6 +2,7 @@ package kv
 
 import (
 	"context"
+	"slices"
 
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
@@ -33,6 +34,9 @@ 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.
@@ -51,6 +55,9 @@ 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

@@ -517,6 +517,10 @@ func (s *Store) DeleteHistoricalDataBeforeSlot(ctx context.Context, cutoffSlot p
 				return errors.Wrap(err, "could not delete validators")
 			}
 
+			// TODO: execution payload envelopes (Gloas+) are keyed by execution payload
+			// block hash, not beacon block root, so they cannot be pruned in this loop.
+			// A separate pruning mechanism is needed (e.g. secondary index or cursor scan).
+
 			numSlotsDeleted++
 		}
 
@@ -812,7 +816,10 @@ 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)
-		addr = bkt.Get(bytesutil.Uint64ToBytesBigEndian(uint64(id)))
+		stored := bkt.Get(bytesutil.Uint64ToBytesBigEndian(uint64(id)))
+		if len(stored) > 0 {
+			addr = slices.Clone(stored)
+		}
 		// 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.
@@ -826,7 +833,7 @@ func (s *Store) FeeRecipientByValidatorID(ctx context.Context, id primitives.Val
 			if err := decode(ctx, enc, reg); err != nil {
 				return err
 			}
-			addr = reg.FeeRecipient
+			addr = slices.Clone(reg.FeeRecipient)
 		}
 		return nil
 	})
@@ -1247,6 +1254,12 @@ func unmarshalBlock(_ context.Context, enc []byte) (interfaces.ReadOnlySignedBea
 		if err := rawBlock.UnmarshalSSZ(enc[len(fuluBlindKey):]); err != nil {
 			return nil, errors.Wrap(err, "could not unmarshal blinded Fulu block")
 		}
+	case hasGloasKey(enc):
+		// post Gloas we save the full beacon block as EIP-7732 separates beacon block and payload
+		rawBlock = &ethpb.SignedBeaconBlockGloas{}
+		if err := rawBlock.UnmarshalSSZ(enc[len(gloasKey):]); err != nil {
+			return nil, errors.Wrap(err, "could not unmarshal Gloas block")
+		}
 	default:
 		// Marshal block bytes to phase 0 beacon block.
 		rawBlock = &ethpb.SignedBeaconBlock{}
@@ -1277,6 +1290,11 @@ func encodeBlock(blk interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
 func keyForBlock(blk interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
 	v := blk.Version()
 
+	if v >= version.Gloas {
+		// Gloas blocks are never blinded (no execution payload in block body).
+		return gloasKey, nil
+	}
+
 	if v >= version.Fulu {
 		if blk.IsBlinded() {
 			return fuluBlindKey, nil

beacon-chain/db/kv/blocks_test.go

@@ -151,6 +151,17 @@ var blockTests = []struct {
 			}
 			return blocks.NewSignedBeaconBlock(b)
 		}},
+	{
+		name: "gloas",
+		newBlock: func(slot primitives.Slot, root []byte) (interfaces.ReadOnlySignedBeaconBlock, error) {
+			b := util.NewBeaconBlockGloas()
+			b.Block.Slot = slot
+			if root != nil {
+				b.Block.ParentRoot = root
+			}
+			return blocks.NewSignedBeaconBlock(b)
+		},
+	},
 }
 
 func TestStore_SaveBlock_NoDuplicates(t *testing.T) {
@@ -211,7 +222,7 @@ func TestStore_BlocksCRUD(t *testing.T) {
 			retrievedBlock, err = db.Block(ctx, blockRoot)
 			require.NoError(t, err)
 			wanted := retrievedBlock
-			if retrievedBlock.Version() >= version.Bellatrix {
+			if retrievedBlock.Version() >= version.Bellatrix && retrievedBlock.Version() < version.Gloas {
 				wanted, err = retrievedBlock.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -643,7 +654,7 @@ func TestStore_BlocksCRUD_NoCache(t *testing.T) {
 			require.NoError(t, err)
 
 			wanted := blk
-			if blk.Version() >= version.Bellatrix {
+			if blk.Version() >= version.Bellatrix && blk.Version() < version.Gloas {
 				wanted, err = blk.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -1014,7 +1025,7 @@ func TestStore_SaveBlock_CanGetHighestAt(t *testing.T) {
 			b, err := db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted := block1
-			if block1.Version() >= version.Bellatrix {
+			if block1.Version() >= version.Bellatrix && block1.Version() < version.Gloas {
 				wanted, err = wanted.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -1032,7 +1043,7 @@ func TestStore_SaveBlock_CanGetHighestAt(t *testing.T) {
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted2 := block2
-			if block2.Version() >= version.Bellatrix {
+			if block2.Version() >= version.Bellatrix && block2.Version() < version.Gloas {
 				wanted2, err = block2.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -1050,7 +1061,7 @@ func TestStore_SaveBlock_CanGetHighestAt(t *testing.T) {
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted = block3
-			if block3.Version() >= version.Bellatrix {
+			if block3.Version() >= version.Bellatrix && block3.Version() < version.Gloas {
 				wanted, err = wanted.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -1086,7 +1097,7 @@ func TestStore_GenesisBlock_CanGetHighestAt(t *testing.T) {
 			b, err := db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted := block1
-			if block1.Version() >= version.Bellatrix {
+			if block1.Version() >= version.Bellatrix && block1.Version() < version.Gloas {
 				wanted, err = block1.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -1103,7 +1114,7 @@ func TestStore_GenesisBlock_CanGetHighestAt(t *testing.T) {
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted = genesisBlock
-			if genesisBlock.Version() >= version.Bellatrix {
+			if genesisBlock.Version() >= version.Bellatrix && genesisBlock.Version() < version.Gloas {
 				wanted, err = genesisBlock.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -1120,7 +1131,7 @@ func TestStore_GenesisBlock_CanGetHighestAt(t *testing.T) {
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted = genesisBlock
-			if genesisBlock.Version() >= version.Bellatrix {
+			if genesisBlock.Version() >= version.Bellatrix && genesisBlock.Version() < version.Gloas {
 				wanted, err = genesisBlock.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -1216,7 +1227,7 @@ func TestStore_BlocksBySlot_BlockRootsBySlot(t *testing.T) {
 			require.NoError(t, err)
 
 			wanted := b1
-			if b1.Version() >= version.Bellatrix {
+			if b1.Version() >= version.Bellatrix && b1.Version() < version.Gloas {
 				wanted, err = b1.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -1232,7 +1243,7 @@ func TestStore_BlocksBySlot_BlockRootsBySlot(t *testing.T) {
 				t.Fatalf("Expected 2 blocks, received %d blocks", len(retrievedBlocks))
 			}
 			wanted = b2
-			if b2.Version() >= version.Bellatrix {
+			if b2.Version() >= version.Bellatrix && b2.Version() < version.Gloas {
 				wanted, err = b2.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -1242,7 +1253,7 @@ func TestStore_BlocksBySlot_BlockRootsBySlot(t *testing.T) {
 			require.NoError(t, err)
 			assert.Equal(t, true, proto.Equal(wantedPb, retrieved0Pb), "Wanted: %v, received: %v", retrievedBlocks[0], wanted)
 			wanted = b3
-			if b3.Version() >= version.Bellatrix {
+			if b3.Version() >= version.Bellatrix && b3.Version() < version.Gloas {
 				wanted, err = b3.ToBlinded()
 				require.NoError(t, err)
 			}

beacon-chain/db/kv/custody_test.go

@@ -67,7 +67,6 @@ func getSubscriptionStatusFromDB(t *testing.T, db *Store) bool {
 	return subscribed
 }
 
-
 func TestUpdateCustodyInfo(t *testing.T) {
 	ctx := t.Context()
 

beacon-chain/db/kv/deposit_contract.go

@@ -3,6 +3,7 @@ package kv
 import (
 	"context"
 	"fmt"
+	"slices"
 
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
 	"github.com/ethereum/go-ethereum/common"
@@ -17,7 +18,10 @@ 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)
-		addr = chainInfo.Get(depositContractAddressKey)
+		stored := chainInfo.Get(depositContractAddressKey)
+		if len(stored) > 0 {
+			addr = slices.Clone(stored)
+		}
 		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/execution_payload_envelope.go

@@ -0,0 +1,123 @@
+package kv
+
+import (
+	"context"
+
+	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/golang/snappy"
+	"github.com/pkg/errors"
+	bolt "go.etcd.io/bbolt"
+)
+
+// SaveExecutionPayloadEnvelope blinds and saves a signed execution payload envelope keyed by
+// beacon block root. The envelope is stored in blinded form: the full execution payload is replaced
+// with its block hash. The full payload can later be retrieved from the EL via
+// engine_getPayloadBodiesByHash.
+func (s *Store) SaveExecutionPayloadEnvelope(ctx context.Context, env *ethpb.SignedExecutionPayloadEnvelope) error {
+	_, span := trace.StartSpan(ctx, "BeaconDB.SaveExecutionPayloadEnvelope")
+	defer span.End()
+
+	if env == nil || env.Message == nil || env.Message.Payload == nil {
+		return errors.New("cannot save nil execution payload envelope")
+	}
+
+	blockRoot := bytesutil.ToBytes32(env.Message.BeaconBlockRoot)
+	blinded := blindEnvelope(env)
+
+	enc, err := encodeBlindedEnvelope(blinded)
+	if err != nil {
+		return err
+	}
+
+	return s.db.Update(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(executionPayloadEnvelopesBucket)
+		return bkt.Put(blockRoot[:], enc)
+	})
+}
+
+// ExecutionPayloadEnvelope retrieves the blinded signed execution payload envelope by beacon block root.
+func (s *Store) ExecutionPayloadEnvelope(ctx context.Context, blockRoot [32]byte) (*ethpb.SignedBlindedExecutionPayloadEnvelope, error) {
+	_, span := trace.StartSpan(ctx, "BeaconDB.ExecutionPayloadEnvelope")
+	defer span.End()
+
+	var enc []byte
+	if err := s.db.View(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(executionPayloadEnvelopesBucket)
+		enc = bkt.Get(blockRoot[:])
+		return nil
+	}); err != nil {
+		return nil, err
+	}
+	if enc == nil {
+		return nil, errors.Wrap(ErrNotFound, "execution payload envelope not found")
+	}
+	return decodeBlindedEnvelope(enc)
+}
+
+// HasExecutionPayloadEnvelope checks whether an execution payload envelope exists for the given beacon block root.
+func (s *Store) HasExecutionPayloadEnvelope(ctx context.Context, blockRoot [32]byte) bool {
+	_, span := trace.StartSpan(ctx, "BeaconDB.HasExecutionPayloadEnvelope")
+	defer span.End()
+
+	var exists bool
+	if err := s.db.View(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(executionPayloadEnvelopesBucket)
+		exists = bkt.Get(blockRoot[:]) != nil
+		return nil
+	}); err != nil {
+		return false
+	}
+	return exists
+}
+
+// DeleteExecutionPayloadEnvelope removes a signed execution payload envelope by beacon block root.
+func (s *Store) DeleteExecutionPayloadEnvelope(ctx context.Context, blockRoot [32]byte) error {
+	_, span := trace.StartSpan(ctx, "BeaconDB.DeleteExecutionPayloadEnvelope")
+	defer span.End()
+
+	return s.db.Update(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(executionPayloadEnvelopesBucket)
+		return bkt.Delete(blockRoot[:])
+	})
+}
+
+// blindEnvelope converts a full signed envelope to its blinded form by replacing
+// the execution payload with its block hash. This avoids computing the expensive
+// payload hash tree root on the critical path.
+func blindEnvelope(env *ethpb.SignedExecutionPayloadEnvelope) *ethpb.SignedBlindedExecutionPayloadEnvelope {
+	return &ethpb.SignedBlindedExecutionPayloadEnvelope{
+		Message: &ethpb.BlindedExecutionPayloadEnvelope{
+			BlockHash:         env.Message.Payload.BlockHash,
+			ExecutionRequests: env.Message.ExecutionRequests,
+			BuilderIndex:      env.Message.BuilderIndex,
+			BeaconBlockRoot:   env.Message.BeaconBlockRoot,
+			Slot:              env.Message.Slot,
+			StateRoot:         env.Message.StateRoot,
+		},
+		Signature: env.Signature,
+	}
+}
+
+// encodeBlindedEnvelope SSZ-encodes and snappy-compresses a blinded envelope for storage.
+func encodeBlindedEnvelope(env *ethpb.SignedBlindedExecutionPayloadEnvelope) ([]byte, error) {
+	sszBytes, err := env.MarshalSSZ()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not marshal blinded envelope")
+	}
+	return snappy.Encode(nil, sszBytes), nil
+}
+
+// decodeBlindedEnvelope snappy-decompresses and SSZ-decodes a blinded envelope from storage.
+func decodeBlindedEnvelope(enc []byte) (*ethpb.SignedBlindedExecutionPayloadEnvelope, error) {
+	dec, err := snappy.Decode(nil, enc)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not snappy decode envelope")
+	}
+	blinded := &ethpb.SignedBlindedExecutionPayloadEnvelope{}
+	if err := blinded.UnmarshalSSZ(dec); err != nil {
+		return nil, errors.Wrap(err, "could not unmarshal blinded envelope")
+	}
+	return blinded, nil
+}

beacon-chain/db/kv/execution_payload_envelope_test.go

@@ -0,0 +1,124 @@
+package kv
+
+import (
+	"context"
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
+	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 testEnvelope(t *testing.T) *ethpb.SignedExecutionPayloadEnvelope {
+	t.Helper()
+	return &ethpb.SignedExecutionPayloadEnvelope{
+		Message: &ethpb.ExecutionPayloadEnvelope{
+			Payload: &enginev1.ExecutionPayloadDeneb{
+				ParentHash:    bytesutil.PadTo([]byte("parent"), 32),
+				FeeRecipient:  bytesutil.PadTo([]byte("fee"), 20),
+				StateRoot:     bytesutil.PadTo([]byte("stateroot"), 32),
+				ReceiptsRoot:  bytesutil.PadTo([]byte("receipts"), 32),
+				LogsBloom:     bytesutil.PadTo([]byte{}, 256),
+				PrevRandao:    bytesutil.PadTo([]byte("randao"), 32),
+				BlockNumber:   100,
+				GasLimit:      30000000,
+				GasUsed:       21000,
+				Timestamp:     1000,
+				ExtraData:     []byte("extra"),
+				BaseFeePerGas: bytesutil.PadTo([]byte{1}, 32),
+				BlockHash:     bytesutil.PadTo([]byte("blockhash"), 32),
+				Transactions:  [][]byte{[]byte("tx1"), []byte("tx2")},
+				Withdrawals:   []*enginev1.Withdrawal{{Index: 1, ValidatorIndex: 2, Address: bytesutil.PadTo([]byte("addr"), 20), Amount: 100}},
+				BlobGasUsed:   131072,
+				ExcessBlobGas: 0,
+			},
+			ExecutionRequests: &enginev1.ExecutionRequests{},
+			BuilderIndex:      primitives.BuilderIndex(42),
+			BeaconBlockRoot:   bytesutil.PadTo([]byte("beaconroot"), 32),
+			Slot:              primitives.Slot(99),
+			StateRoot:         bytesutil.PadTo([]byte("envelopestateroot"), 32),
+		},
+		Signature: bytesutil.PadTo([]byte("sig"), 96),
+	}
+}
+
+func TestStore_SaveAndRetrieveExecutionPayloadEnvelope(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	env := testEnvelope(t)
+
+	// Keyed by beacon block root.
+	blockRoot := bytesutil.ToBytes32(env.Message.BeaconBlockRoot)
+
+	// Initially should not exist.
+	assert.Equal(t, false, db.HasExecutionPayloadEnvelope(ctx, blockRoot))
+
+	// Save (always blinds internally).
+	require.NoError(t, db.SaveExecutionPayloadEnvelope(ctx, env))
+
+	// Should exist now.
+	assert.Equal(t, true, db.HasExecutionPayloadEnvelope(ctx, blockRoot))
+
+	// Load and verify it's blinded.
+	loaded, err := db.ExecutionPayloadEnvelope(ctx, blockRoot)
+	require.NoError(t, err)
+
+	// Verify metadata is preserved.
+	assert.Equal(t, env.Message.Slot, loaded.Message.Slot)
+	assert.Equal(t, env.Message.BuilderIndex, loaded.Message.BuilderIndex)
+	assert.DeepEqual(t, env.Message.BeaconBlockRoot, loaded.Message.BeaconBlockRoot)
+	assert.DeepEqual(t, env.Message.StateRoot, loaded.Message.StateRoot)
+	assert.DeepEqual(t, env.Signature, loaded.Signature)
+
+	// BlockHash should be the payload's block hash (not a hash tree root).
+	assert.DeepEqual(t, env.Message.Payload.BlockHash, loaded.Message.BlockHash)
+}
+
+func TestStore_DeleteExecutionPayloadEnvelope(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	env := testEnvelope(t)
+	blockRoot := bytesutil.ToBytes32(env.Message.BeaconBlockRoot)
+
+	require.NoError(t, db.SaveExecutionPayloadEnvelope(ctx, env))
+	assert.Equal(t, true, db.HasExecutionPayloadEnvelope(ctx, blockRoot))
+
+	require.NoError(t, db.DeleteExecutionPayloadEnvelope(ctx, blockRoot))
+	assert.Equal(t, false, db.HasExecutionPayloadEnvelope(ctx, blockRoot))
+}
+
+func TestStore_ExecutionPayloadEnvelope_NotFound(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	nonExistent := bytesutil.ToBytes32([]byte("nonexistent"))
+
+	_, err := db.ExecutionPayloadEnvelope(ctx, nonExistent)
+	require.ErrorContains(t, "not found", err)
+}
+
+func TestStore_SaveExecutionPayloadEnvelope_NilRejected(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+
+	err := db.SaveExecutionPayloadEnvelope(ctx, nil)
+	require.ErrorContains(t, "nil", err)
+}
+
+func TestBlindEnvelope_PreservesBlockHash(t *testing.T) {
+	env := testEnvelope(t)
+
+	blinded := blindEnvelope(env)
+
+	// Should contain the block hash from the payload, not a hash tree root.
+	assert.DeepEqual(t, env.Message.Payload.BlockHash, blinded.Message.BlockHash)
+
+	// Metadata should be preserved.
+	assert.Equal(t, env.Message.BuilderIndex, blinded.Message.BuilderIndex)
+	assert.Equal(t, env.Message.Slot, blinded.Message.Slot)
+	assert.DeepEqual(t, env.Message.BeaconBlockRoot, blinded.Message.BeaconBlockRoot)
+	assert.DeepEqual(t, env.Message.StateRoot, blinded.Message.StateRoot)
+	assert.DeepEqual(t, env.Signature, blinded.Signature)
+}

beacon-chain/db/kv/key.go

@@ -87,3 +87,10 @@ func hasFuluBlindKey(enc []byte) bool {
 	}
 	return bytes.Equal(enc[:len(fuluBlindKey)], fuluBlindKey)
 }
+
+func hasGloasKey(enc []byte) bool {
+	if len(gloasKey) >= len(enc) {
+		return false
+	}
+	return bytes.Equal(enc[:len(gloasKey)], gloasKey)
+}

beacon-chain/db/kv/kv.go

@@ -126,6 +126,7 @@ var Buckets = [][]byte{
 	feeRecipientBucket,
 	registrationBucket,
 	custodyBucket,
+	executionPayloadEnvelopesBucket,
 }
 
 // KVStoreOption is a functional option that modifies a kv.Store.

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, pubKey)
+		keys = append(keys, bytes.Clone(pubKey))
 		return nil
 	}); err != nil {
 		return nil, err

beacon-chain/db/kv/schema.go

@@ -7,16 +7,17 @@ package kv
 // it easy to scan for keys that have a certain shard number as a prefix and return those
 // corresponding attestations.
 var (
-	blocksBucket          = []byte("blocks")
-	stateBucket           = []byte("state")
-	stateSummaryBucket    = []byte("state-summary")
-	chainMetadataBucket   = []byte("chain-metadata")
-	checkpointBucket      = []byte("check-point")
-	powchainBucket        = []byte("powchain")
-	stateValidatorsBucket = []byte("state-validators")
-	feeRecipientBucket    = []byte("fee-recipient")
-	registrationBucket    = []byte("registration")
-	stateDiffBucket       = []byte("state-diff")
+	blocksBucket                    = []byte("blocks")
+	stateBucket                     = []byte("state")
+	stateSummaryBucket              = []byte("state-summary")
+	chainMetadataBucket             = []byte("chain-metadata")
+	checkpointBucket                = []byte("check-point")
+	powchainBucket                  = []byte("powchain")
+	stateValidatorsBucket           = []byte("state-validators")
+	feeRecipientBucket              = []byte("fee-recipient")
+	registrationBucket              = []byte("registration")
+	stateDiffBucket                 = []byte("state-diff")
+	executionPayloadEnvelopesBucket = []byte("execution-payload-envelopes")
 
 	// Light Client Updates Bucket
 	lightClientUpdatesBucket       = []byte("light-client-updates")
@@ -60,6 +61,8 @@ var (
 	electraBlindKey            = []byte("blind-electra")
 	fuluKey                    = []byte("fulu")
 	fuluBlindKey               = []byte("blind-fulu")
+	gloasKey                   = []byte("gloas")
+	// No gloasBlindKey needed - Gloas blocks are never blinded (no execution payload in block body).
 
 	// block root included in the beacon state used by weak subjectivity initial sync
 	originCheckpointBlockRootKey = []byte("origin-checkpoint-block-root")

beacon-chain/db/kv/state_diff.go

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

beacon-chain/db/kv/state_summary.go

@@ -2,6 +2,7 @@ package kv
 
 import (
 	"context"
+	"slices"
 
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
@@ -47,7 +48,11 @@ 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 {
-		enc = tx.Bucket(stateSummaryBucket).Get(blockRoot[:])
+		rawEnc := tx.Bucket(stateSummaryBucket).Get(blockRoot[:])
+		if len(rawEnc) == 0 {
+			return nil
+		}
+		enc = slices.Clone(rawEnc)
 		return nil
 	}); err != nil {
 		return nil, err

beacon-chain/execution/BUILD.bazel

@@ -8,6 +8,7 @@ go_library(
         "deposit.go",
         "engine_client.go",
         "errors.go",
+        "graffiti_info.go",
         "log.go",
         "log_processing.go",
         "metrics.go",
@@ -89,6 +90,7 @@ go_test(
         "engine_client_fuzz_test.go",
         "engine_client_test.go",
         "execution_chain_test.go",
+        "graffiti_info_test.go",
         "init_test.go",
         "log_processing_test.go",
         "mock_test.go",

beacon-chain/execution/engine_client.go

@@ -61,7 +61,17 @@ var (
 	}
 )
 
+// ClientVersionV1 represents the response from engine_getClientVersionV1.
+type ClientVersionV1 struct {
+	Code    string `json:"code"`
+	Name    string `json:"name"`
+	Version string `json:"version"`
+	Commit  string `json:"commit"`
+}
+
 const (
+	// GetClientVersionMethod is the engine_getClientVersionV1 method for JSON-RPC.
+	GetClientVersionMethod = "engine_getClientVersionV1"
 	// NewPayloadMethod v1 request string for JSON-RPC.
 	NewPayloadMethod = "engine_newPayloadV1"
 	// NewPayloadMethodV2 v2 request string for JSON-RPC.
@@ -350,6 +360,24 @@ func (s *Service) ExchangeCapabilities(ctx context.Context) ([]string, error) {
 	return elSupportedEndpointsSlice, nil
 }
 
+// GetClientVersion calls engine_getClientVersionV1 to retrieve EL client information.
+func (s *Service) GetClientVersion(ctx context.Context) ([]ClientVersionV1, error) {
+	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.GetClientVersion")
+	defer span.End()
+
+	// Per spec, we send our own client info as the parameter
+	clVersion := ClientVersionV1{
+		Code:    CLCode,
+		Name:    Name,
+		Version: version.SemanticVersion(),
+		Commit:  version.GetCommitPrefix(),
+	}
+
+	var result []ClientVersionV1
+	err := s.rpcClient.CallContext(ctx, &result, GetClientVersionMethod, clVersion)
+	return result, handleRPCError(err)
+}
+
 // GetTerminalBlockHash returns the valid terminal block hash based on total difficulty.
 //
 // Spec code:

beacon-chain/execution/graffiti_info.go

@@ -0,0 +1,134 @@
+package execution
+
+import (
+	"strings"
+	"sync"
+
+	"github.com/OffchainLabs/prysm/v7/runtime/version"
+)
+
+const (
+	// CLCode is the two-letter client code for Prysm.
+	CLCode = "PR"
+	Name   = "Prysm"
+)
+
+// GraffitiInfo holds version information for generating block graffiti.
+// It is thread-safe and can be updated by the execution service and read by the validator server.
+type GraffitiInfo struct {
+	mu       sync.RWMutex
+	elCode   string // From engine_getClientVersionV1
+	elCommit string // From engine_getClientVersionV1
+	logOnce  sync.Once
+}
+
+// NewGraffitiInfo creates a new GraffitiInfo.
+func NewGraffitiInfo() *GraffitiInfo {
+	return &GraffitiInfo{}
+}
+
+// UpdateFromEngine updates the EL client information.
+func (g *GraffitiInfo) UpdateFromEngine(code, commit string) {
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	g.elCode = code
+	g.elCommit = strings.TrimPrefix(commit, "0x")
+}
+
+// GenerateGraffiti generates graffiti using the flexible standard
+// with the provided user graffiti from the validator client request.
+// It places user graffiti first, then appends as much client info as space allows.
+//
+// A space separator is added between user graffiti and client info when it
+// fits without reducing the client version tier.
+//
+// Available Space | Format
+// ≥13 bytes       | user + space + EL(2)+commit(4)+CL(2)+commit(4)  e.g. "Sushi GEabcdPRe4f6"
+// 12 bytes        | user + EL(2)+commit(4)+CL(2)+commit(4)          e.g. "12345678901234567890GEabcdPRe4f6"
+// 9-11 bytes      | user + space + EL(2)+commit(2)+CL(2)+commit(2)  e.g. "12345678901234567890123 GEabPRe4"
+// 8 bytes         | user + EL(2)+commit(2)+CL(2)+commit(2)          e.g. "123456789012345678901234GEabPRe4"
+// 5-7 bytes       | user + space + EL(2)+CL(2)                      e.g. "123456789012345678901234567 GEPR"
+// 4 bytes         | user + EL(2)+CL(2)                              e.g. "1234567890123456789012345678GEPR"
+// 3 bytes         | user + space + code(2)                          e.g. "12345678901234567890123456789 GE"
+// 2 bytes         | user + code(2)                                  e.g. "123456789012345678901234567890GE"
+// <2 bytes        | user only                                       e.g. "1234567890123456789012345678901x"
+func (g *GraffitiInfo) GenerateGraffiti(userGraffiti []byte) [32]byte {
+	g.mu.RLock()
+	defer g.mu.RUnlock()
+
+	var result [32]byte
+	userStr := string(userGraffiti)
+	// Trim trailing null bytes
+	for len(userStr) > 0 && userStr[len(userStr)-1] == 0 {
+		userStr = userStr[:len(userStr)-1]
+	}
+
+	available := 32 - len(userStr)
+
+	clCommit := version.GetCommitPrefix()
+	clCommit4 := truncateCommit(clCommit, 4)
+	clCommit2 := truncateCommit(clCommit, 2)
+
+	// If no EL info, clear EL commits but still include CL info
+	var elCommit4, elCommit2 string
+	if g.elCode != "" {
+		elCommit4 = truncateCommit(g.elCommit, 4)
+		elCommit2 = truncateCommit(g.elCommit, 2)
+	}
+
+	// Add a space separator between user graffiti and client info,
+	// but only if it won't reduce the space available for client version info.
+	space := func(minForTier int) string {
+		if len(userStr) > 0 && available >= minForTier+1 {
+			return " "
+		}
+		return ""
+	}
+
+	var graffiti string
+	switch {
+	case available >= 12:
+		// Full: user+EL(2)+commit(4)+CL(2)+commit(4)
+		graffiti = userStr + space(12) + g.elCode + elCommit4 + CLCode + clCommit4
+	case available >= 8:
+		// Reduced commits: user+EL(2)+commit(2)+CL(2)+commit(2)
+		graffiti = userStr + space(8) + g.elCode + elCommit2 + CLCode + clCommit2
+	case available >= 4:
+		// Codes only: user+EL(2)+CL(2)
+		graffiti = userStr + space(4) + g.elCode + CLCode
+	case available >= 2:
+		// Single code: user+code(2)
+		if g.elCode != "" {
+			graffiti = userStr + space(2) + g.elCode
+		} else {
+			graffiti = userStr + space(2) + CLCode
+		}
+	default:
+		// User graffiti only
+		graffiti = userStr
+	}
+
+	g.logOnce.Do(func() {
+		logGraffitiInfo(graffiti, available)
+	})
+
+	copy(result[:], graffiti)
+	return result
+}
+
+// logGraffitiInfo logs the graffiti that will be used.
+func logGraffitiInfo(graffiti string, available int) {
+	if available >= 2 {
+		log.WithField("graffiti", graffiti).Info("Graffiti includes client version info appended after user graffiti")
+		return
+	}
+	log.WithField("graffiti", graffiti).Info("Prysm adds consensus and execution debugging information to the end of the graffiti field when possible. To prevent deletion of debugging info, please consider using a shorter graffiti")
+}
+
+// truncateCommit returns the first n characters of the commit string.
+func truncateCommit(commit string, n int) string {
+	if len(commit) <= n {
+		return commit
+	}
+	return commit[:n]
+}

beacon-chain/execution/graffiti_info_test.go

@@ -0,0 +1,250 @@
+package execution
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+)
+
+func TestGraffitiInfo_GenerateGraffiti(t *testing.T) {
+	tests := []struct {
+		name         string
+		elCode       string
+		elCommit     string
+		userGraffiti []byte
+		wantPrefix   string // user graffiti appears first
+		wantSuffix   string // client version info appended after
+	}{
+		// No EL info cases (CL info "PR" + commit still included when space allows)
+		{
+			name:         "No EL - empty user graffiti",
+			elCode:       "",
+			elCommit:     "",
+			userGraffiti: []byte{},
+			wantPrefix:   "PR", // Only CL code + commit (no user graffiti to prefix)
+		},
+		{
+			name:         "No EL - short user graffiti",
+			elCode:       "",
+			elCommit:     "",
+			userGraffiti: []byte("my validator"),
+			wantPrefix:   "my validator",
+			wantSuffix:   " PR", // space + CL code appended
+		},
+		{
+			name:         "No EL - 28 char user graffiti (4 bytes available)",
+			elCode:       "",
+			elCommit:     "",
+			userGraffiti: []byte("1234567890123456789012345678"), // 28 chars, 4 bytes available = codes only
+			wantPrefix:   "1234567890123456789012345678",
+			wantSuffix:   "PR", // CL code (no EL, so just PR)
+		},
+		{
+			name:         "No EL - 30 char user graffiti (2 bytes available)",
+			elCode:       "",
+			elCommit:     "",
+			userGraffiti: []byte("123456789012345678901234567890"), // 30 chars, 2 bytes available = fits PR
+			wantPrefix:   "123456789012345678901234567890",
+			wantSuffix:   "PR",
+		},
+		{
+			name:         "No EL - 31 char user graffiti (1 byte available)",
+			elCode:       "",
+			elCommit:     "",
+			userGraffiti: []byte("1234567890123456789012345678901"), // 31 chars, 1 byte available = not enough for code
+			wantPrefix:   "1234567890123456789012345678901",         // User only
+		},
+		{
+			name:         "No EL - 32 char user graffiti (0 bytes available)",
+			elCode:       "",
+			elCommit:     "",
+			userGraffiti: []byte("12345678901234567890123456789012"),
+			wantPrefix:   "12345678901234567890123456789012", // User only
+		},
+		// With EL info - flexible standard format cases
+		{
+			name:         "With EL - full format (empty user graffiti)",
+			elCode:       "GE",
+			elCommit:     "abcd1234",
+			userGraffiti: []byte{},
+			wantPrefix:   "GEabcdPR", // No user graffiti, starts with client info
+		},
+		{
+			name:         "With EL - full format (short user graffiti)",
+			elCode:       "GE",
+			elCommit:     "abcd1234",
+			userGraffiti: []byte("Bob"),
+			wantPrefix:   "Bob",
+			wantSuffix:   " GEabcdPR", // space + EL(2)+commit(4)+CL(2)+commit(4)
+		},
+		{
+			name:         "With EL - full format (20 char user, 12 bytes available) - no space, would reduce tier",
+			elCode:       "GE",
+			elCommit:     "abcd1234",
+			userGraffiti: []byte("12345678901234567890"), // 20 chars, leaves exactly 12 bytes = full format, no room for space
+			wantPrefix:   "12345678901234567890",
+			wantSuffix:   "GEabcdPR",
+		},
+		{
+			name:         "With EL - full format (19 char user, 13 bytes available) - space fits",
+			elCode:       "GE",
+			elCommit:     "abcd1234",
+			userGraffiti: []byte("1234567890123456789"), // 19 chars, leaves 13 bytes = full format + space
+			wantPrefix:   "1234567890123456789",
+			wantSuffix:   " GEabcdPR", 
+		},
+		{
+			name:         "With EL - reduced commits (24 char user, 8 bytes available) - no space, would reduce tier",
+			elCode:       "GE",
+			elCommit:     "abcd1234",
+			userGraffiti: []byte("123456789012345678901234"), // 24 chars, leaves exactly 8 bytes = reduced format, no room for space
+			wantPrefix:   "123456789012345678901234",
+			wantSuffix:   "GEabPR", 
+		},
+		{
+			name:         "With EL - reduced commits (23 char user, 9 bytes available) - space fits",
+			elCode:       "GE",
+			elCommit:     "abcd1234",
+			userGraffiti: []byte("12345678901234567890123"), // 23 chars, leaves 9 bytes = reduced format + space
+			wantPrefix:   "12345678901234567890123",
+			wantSuffix:   " GEabPR", 
+		},
+		{
+			name:         "With EL - codes only (28 char user, 4 bytes available) - no space, would reduce tier",
+			elCode:       "GE",
+			elCommit:     "abcd1234",
+			userGraffiti: []byte("1234567890123456789012345678"), // 28 chars, leaves exactly 4 bytes = codes only, no room for space
+			wantPrefix:   "1234567890123456789012345678",
+			wantSuffix:   "GEPR",
+		},
+		{
+			name:         "With EL - codes only (27 char user, 5 bytes available) - space fits",
+			elCode:       "GE",
+			elCommit:     "abcd1234",
+			userGraffiti: []byte("123456789012345678901234567"), // 27 chars, leaves 5 bytes = codes only + space
+			wantPrefix:   "123456789012345678901234567",
+			wantSuffix:   " GEPR",
+		},
+		{
+			name:         "With EL - EL code only (30 char user, 2 bytes available) - no space, would reduce tier",
+			elCode:       "GE",
+			elCommit:     "abcd1234",
+			userGraffiti: []byte("123456789012345678901234567890"), // 30 chars, leaves exactly 2 bytes = EL code only, no room for space
+			wantPrefix:   "123456789012345678901234567890",
+			wantSuffix:   "GE",
+		},
+		{
+			name:         "With EL - EL code only (29 char user, 3 bytes available) - space fits",
+			elCode:       "GE",
+			elCommit:     "abcd1234",
+			userGraffiti: []byte("12345678901234567890123456789"), // 29 chars, leaves 3 bytes = EL code + space
+			wantPrefix:   "12345678901234567890123456789",
+			wantSuffix:   " GE",
+		},
+		{
+			name:         "With EL - user only (31 char user, 1 byte available)",
+			elCode:       "GE",
+			elCommit:     "abcd1234",
+			userGraffiti: []byte("1234567890123456789012345678901"), // 31 chars, leaves 1 byte = not enough for code
+			wantPrefix:   "1234567890123456789012345678901",         // User only
+		},
+		{
+			name:         "With EL - user only (32 char user, 0 bytes available)",
+			elCode:       "GE",
+			elCommit:     "abcd1234",
+			userGraffiti: []byte("12345678901234567890123456789012"),
+			wantPrefix:   "12345678901234567890123456789012",
+		},
+		// Null byte handling
+		{
+			name:         "Null bytes - input with trailing nulls",
+			elCode:       "GE",
+			elCommit:     "abcd1234",
+			userGraffiti: append([]byte("test"), 0, 0, 0),
+			wantPrefix:   "test",
+			wantSuffix:   " GEabcdPR",
+		},
+		// 0x prefix handling - some ELs return 0x-prefixed commits
+		{
+			name:         "0x prefix - stripped from EL commit",
+			elCode:       "GE",
+			elCommit:     "0xabcd1234",
+			userGraffiti: []byte{},
+			wantPrefix:   "GEabcdPR",
+		},
+		{
+			name:         "No 0x prefix - commit used as-is",
+			elCode:       "NM",
+			elCommit:     "abcd1234",
+			userGraffiti: []byte{},
+			wantPrefix:   "NMabcdPR",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			g := NewGraffitiInfo()
+			if tt.elCode != "" {
+				g.UpdateFromEngine(tt.elCode, tt.elCommit)
+			}
+
+			result := g.GenerateGraffiti(tt.userGraffiti)
+			resultStr := string(result[:])
+			trimmed := trimNullBytes(resultStr)
+
+			// Check prefix (user graffiti comes first)
+			require.Equal(t, true, len(trimmed) >= len(tt.wantPrefix), "Result too short for prefix check")
+			require.Equal(t, tt.wantPrefix, trimmed[:len(tt.wantPrefix)], "Prefix mismatch")
+
+			// Check suffix if specified (client version info appended)
+			if tt.wantSuffix != "" {
+				require.Equal(t, true, len(trimmed) >= len(tt.wantSuffix), "Result too short for suffix check")
+				// The suffix should appear somewhere after the prefix
+				afterPrefix := trimmed[len(tt.wantPrefix):]
+				require.Equal(t, true, len(afterPrefix) >= len(tt.wantSuffix), "Not enough room for suffix after prefix")
+				require.Equal(t, tt.wantSuffix, afterPrefix[:len(tt.wantSuffix)], "Suffix mismatch")
+			}
+		})
+	}
+}
+
+func TestGraffitiInfo_UpdateFromEngine(t *testing.T) {
+	g := NewGraffitiInfo()
+
+	// Initially no EL info - should still have CL info (PR + commit)
+	result := g.GenerateGraffiti([]byte{})
+	resultStr := trimNullBytes(string(result[:]))
+	require.Equal(t, "PR", resultStr[:2], "Expected CL info before update")
+
+	// Update with EL info
+	g.UpdateFromEngine("GE", "1234abcd")
+
+	result = g.GenerateGraffiti([]byte{})
+	resultStr = trimNullBytes(string(result[:]))
+	require.Equal(t, "GE1234PR", resultStr[:8], "Expected EL+CL info after update")
+}
+
+func TestTruncateCommit(t *testing.T) {
+	tests := []struct {
+		commit string
+		n      int
+		want   string
+	}{
+		{"abcd1234", 4, "abcd"},
+		{"ab", 4, "ab"},
+		{"", 4, ""},
+		{"abcdef", 2, "ab"},
+	}
+
+	for _, tt := range tests {
+		got := truncateCommit(tt.commit, tt.n)
+		require.Equal(t, tt.want, got)
+	}
+}
+
+func trimNullBytes(s string) string {
+	for len(s) > 0 && s[len(s)-1] == 0 {
+		s = s[:len(s)-1]
+	}
+	return s
+}

beacon-chain/execution/options.go

@@ -124,3 +124,11 @@ func WithVerifierWaiter(v *verification.InitializerWaiter) Option {
 		return nil
 	}
 }
+
+// WithGraffitiInfo sets the GraffitiInfo for client version tracking.
+func WithGraffitiInfo(g *GraffitiInfo) Option {
+	return func(s *Service) error {
+		s.graffitiInfo = g
+		return nil
+	}
+}

beacon-chain/execution/service.go

@@ -162,6 +162,7 @@ type Service struct {
 	verifierWaiter          *verification.InitializerWaiter
 	blobVerifier            verification.NewBlobVerifier
 	capabilityCache         *capabilityCache
+	graffitiInfo            *GraffitiInfo
 }
 
 // NewService sets up a new instance with an ethclient when given a web3 endpoint as a string in the config.
@@ -318,6 +319,28 @@ func (s *Service) updateConnectedETH1(state bool) {
 	s.updateBeaconNodeStats()
 }
 
+// GraffitiInfo returns the GraffitiInfo struct for graffiti generation.
+func (s *Service) GraffitiInfo() *GraffitiInfo {
+	return s.graffitiInfo
+}
+
+// updateGraffitiInfo fetches EL client version and updates the graffiti info.
+func (s *Service) updateGraffitiInfo() {
+	if s.graffitiInfo == nil {
+		return
+	}
+	ctx, cancel := context.WithTimeout(s.ctx, time.Second)
+	defer cancel()
+	versions, err := s.GetClientVersion(ctx)
+	if err != nil {
+		log.WithError(err).Debug("Could not get execution client version for graffiti")
+		return
+	}
+	if len(versions) >= 1 {
+		s.graffitiInfo.UpdateFromEngine(versions[0].Code, versions[0].Commit)
+	}
+}
+
 // refers to the latest eth1 block which follows the condition: eth1_timestamp +
 // SECONDS_PER_ETH1_BLOCK * ETH1_FOLLOW_DISTANCE <= current_unix_time
 func (s *Service) followedBlockHeight(ctx context.Context) (uint64, error) {
@@ -598,6 +621,12 @@ func (s *Service) run(done <-chan struct{}) {
 	chainstartTicker := time.NewTicker(logPeriod)
 	defer chainstartTicker.Stop()
 
+	// Update graffiti info 4 times per epoch (~96 seconds with 12s slots and 32 slots/epoch)
+	graffitiTicker := time.NewTicker(96 * time.Second)
+	defer graffitiTicker.Stop()
+	// Initial update
+	s.updateGraffitiInfo()
+
 	for {
 		select {
 		case <-done:
@@ -622,6 +651,8 @@ func (s *Service) run(done <-chan struct{}) {
 				continue
 			}
 			s.logTillChainStart(context.Background())
+		case <-graffitiTicker.C:
+			s.updateGraffitiInfo()
 		}
 	}
 }

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

@@ -6,7 +6,7 @@ go_library(
         "doc.go",
         "errors.go",
         "forkchoice.go",
-        "last_root.go",
+        "gloas.go",
         "log.go",
         "metrics.go",
         "node.go",
@@ -33,6 +33,7 @@ go_library(
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/forkchoice:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
@@ -51,7 +52,6 @@ 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

@@ -31,8 +31,8 @@ func New() *ForkChoice {
 		prevJustifiedCheckpoint:       &forkchoicetypes.Checkpoint{},
 		finalizedCheckpoint:           &forkchoicetypes.Checkpoint{},
 		proposerBoostRoot:             [32]byte{},
-		nodeByRoot:                    make(map[[fieldparams.RootLength]byte]*Node),
-		nodeByPayload:                 make(map[[fieldparams.RootLength]byte]*Node),
+		emptyNodeByRoot:               make(map[[fieldparams.RootLength]byte]*PayloadNode),
+		fullNodeByRoot:                make(map[[fieldparams.RootLength]byte]*PayloadNode),
 		slashedIndices:                make(map[primitives.ValidatorIndex]bool),
 		receivedBlocksLastEpoch:       [fieldparams.SlotsPerEpoch]primitives.Slot{},
 	}
@@ -44,7 +44,7 @@ func New() *ForkChoice {
 
 // NodeCount returns the current number of nodes in the Store.
 func (f *ForkChoice) NodeCount() int {
-	return len(f.store.nodeByRoot)
+	return len(f.store.emptyNodeByRoot)
 }
 
 // Head returns the head root from fork choice store.
@@ -65,14 +65,14 @@ func (f *ForkChoice) Head(
 		return [32]byte{}, errors.Wrap(err, "could not apply proposer boost score")
 	}
 
-	if err := f.store.treeRootNode.applyWeightChanges(ctx); err != nil {
+	if err := f.store.applyWeightChangesConsensusNode(ctx, f.store.treeRootNode); err != nil {
 		return [32]byte{}, errors.Wrap(err, "could not apply weight changes")
 	}
 
 	jc := f.JustifiedCheckpoint()
 	fc := f.FinalizedCheckpoint()
 	currentEpoch := slots.EpochsSinceGenesis(f.store.genesisTime)
-	if err := f.store.treeRootNode.updateBestDescendant(ctx, jc.Epoch, fc.Epoch, currentEpoch); err != nil {
+	if err := f.store.updateBestDescendantConsensusNode(ctx, f.store.treeRootNode, jc.Epoch, fc.Epoch, currentEpoch); err != nil {
 		return [32]byte{}, errors.Wrap(err, "could not update best descendant")
 	}
 	return f.store.head(ctx)
@@ -119,14 +119,14 @@ func (f *ForkChoice) InsertNode(ctx context.Context, state state.BeaconState, ro
 		return errInvalidNilCheckpoint
 	}
 	finalizedEpoch := fc.Epoch
-	node, err := f.store.insert(ctx, roblock, justifiedEpoch, finalizedEpoch)
+	pn, err := f.store.insert(ctx, roblock, justifiedEpoch, finalizedEpoch)
 	if err != nil {
 		return err
 	}
 
-	jc, fc = f.store.pullTips(state, node, jc, fc)
+	jc, fc = f.store.pullTips(state, pn.node, jc, fc)
 	if err := f.updateCheckpoints(ctx, jc, fc); err != nil {
-		_, remErr := f.store.removeNode(ctx, node)
+		_, remErr := f.store.removeNode(ctx, pn)
 		if remErr != nil {
 			log.WithError(remErr).Error("Could not remove node")
 		}
@@ -149,49 +149,63 @@ func (f *ForkChoice) updateCheckpoints(ctx context.Context, jc, fc *ethpb.Checkp
 	if fc.Epoch <= f.store.finalizedCheckpoint.Epoch {
 		return nil
 	}
-	f.store.finalizedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: fc.Epoch,
-		Root: bytesutil.ToBytes32(fc.Root)}
+	f.store.finalizedCheckpoint = &forkchoicetypes.Checkpoint{
+		Epoch: fc.Epoch,
+		Root:  bytesutil.ToBytes32(fc.Root),
+	}
 	return f.store.prune(ctx)
 }
 
 // HasNode returns true if the node exists in fork choice store,
 // false else wise.
 func (f *ForkChoice) HasNode(root [32]byte) bool {
-	_, ok := f.store.nodeByRoot[root]
+	_, ok := f.store.emptyNodeByRoot[root]
 	return ok
 }
 
 // IsCanonical returns true if the given root is part of the canonical chain.
 func (f *ForkChoice) IsCanonical(root [32]byte) bool {
-	node, ok := f.store.nodeByRoot[root]
-	if !ok || node == nil {
+	// It is fine to pick empty node here since we only check if the beacon block is canonical.
+	pn, ok := f.store.emptyNodeByRoot[root]
+	if !ok || pn == nil {
 		return false
 	}
 
-	if node.bestDescendant == nil {
+	if pn.node.bestDescendant == nil {
+		// The node doesn't have any children
 		if f.store.headNode.bestDescendant == nil {
-			return node == f.store.headNode
+			// headNode is itself head.
+			return pn.node == f.store.headNode
 		}
-		return node == f.store.headNode.bestDescendant
+		// headNode is not actualized and there are some descendants
+		return pn.node == f.store.headNode.bestDescendant
 	}
+	// The node has children
 	if f.store.headNode.bestDescendant == nil {
-		return node.bestDescendant == f.store.headNode
+		return pn.node.bestDescendant == f.store.headNode
 	}
-	return node.bestDescendant == f.store.headNode.bestDescendant
+	return pn.node.bestDescendant == f.store.headNode.bestDescendant
 }
 
 // IsOptimistic returns true if the given root has been optimistically synced.
+// TODO: Gloas, the current implementation uses the result of the full block for
+// the given root. In gloas this would be incorrect and we should specify the
+// payload content, thus we should expose a full/empty version of this call.
 func (f *ForkChoice) IsOptimistic(root [32]byte) (bool, error) {
 	if f.store.allTipsAreInvalid {
 		return true, nil
 	}
 
-	node, ok := f.store.nodeByRoot[root]
-	if !ok || node == nil {
+	en, ok := f.store.emptyNodeByRoot[root]
+	if !ok || en == nil {
 		return true, ErrNilNode
 	}
+	fn := f.store.fullNodeByRoot[root]
+	if fn != nil {
+		return fn.optimistic, nil
+	}
 
-	return node.optimistic, nil
+	return en.optimistic, nil
 }
 
 // AncestorRoot returns the ancestor root of input block root at a given slot.
@@ -199,17 +213,21 @@ func (f *ForkChoice) AncestorRoot(ctx context.Context, root [32]byte, slot primi
 	ctx, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.AncestorRoot")
 	defer span.End()
 
-	node, ok := f.store.nodeByRoot[root]
-	if !ok || node == nil {
+	pn, ok := f.store.emptyNodeByRoot[root]
+	if !ok || pn == nil {
 		return [32]byte{}, errors.Wrap(ErrNilNode, "could not determine ancestor root")
 	}
 
-	n := node
-	for n != nil && n.slot > slot {
+	n := pn.node
+	for n.slot > slot {
 		if ctx.Err() != nil {
 			return [32]byte{}, ctx.Err()
 		}
-		n = n.parent
+		if n.parent == nil {
+			n = nil
+			break
+		}
+		n = n.parent.node
 	}
 
 	if n == nil {
@@ -222,10 +240,11 @@ func (f *ForkChoice) AncestorRoot(ctx context.Context, root [32]byte, slot primi
 // IsViableForCheckpoint returns whether the root passed is a checkpoint root for any
 // known chain in forkchoice.
 func (f *ForkChoice) IsViableForCheckpoint(cp *forkchoicetypes.Checkpoint) (bool, error) {
-	node, ok := f.store.nodeByRoot[cp.Root]
-	if !ok || node == nil {
+	pn, ok := f.store.emptyNodeByRoot[cp.Root]
+	if !ok || pn == nil {
 		return false, nil
 	}
+	node := pn.node
 	epochStart, err := slots.EpochStart(cp.Epoch)
 	if err != nil {
 		return false, err
@@ -234,10 +253,13 @@ func (f *ForkChoice) IsViableForCheckpoint(cp *forkchoicetypes.Checkpoint) (bool
 		return false, nil
 	}
 
-	if len(node.children) == 0 {
+	// If it's the start of the epoch, it is a checkpoint
+	if node.slot == epochStart {
 		return true, nil
 	}
-	if node.slot == epochStart {
+	// If there are no descendants of this beacon block, it is is viable as a checkpoint
+	children := f.store.allConsensusChildren(node)
+	if len(children) == 0 {
 		return true, nil
 	}
 	if !features.Get().IgnoreUnviableAttestations {
@@ -247,7 +269,8 @@ func (f *ForkChoice) IsViableForCheckpoint(cp *forkchoicetypes.Checkpoint) (bool
 			return true, nil
 		}
 	}
-	for _, child := range node.children {
+	// If some child is after the start of the epoch, the checkpoint is viable.
+	for _, child := range children {
 		if child.slot > epochStart {
 			return true, nil
 		}
@@ -288,7 +311,7 @@ func (f *ForkChoice) updateBalances() error {
 		if vote.currentRoot != vote.nextRoot || oldBalance != newBalance {
 			// Ignore the vote if the root is not in fork choice
 			// store, that means we have not seen the block before.
-			nextNode, ok := f.store.nodeByRoot[vote.nextRoot]
+			nextNode, ok := f.store.emptyNodeByRoot[vote.nextRoot]
 			if ok && vote.nextRoot != zHash {
 				// Protection against nil node
 				if nextNode == nil {
@@ -297,7 +320,7 @@ func (f *ForkChoice) updateBalances() error {
 				nextNode.balance += newBalance
 			}
 
-			currentNode, ok := f.store.nodeByRoot[vote.currentRoot]
+			currentNode, ok := f.store.emptyNodeByRoot[vote.currentRoot]
 			if ok && vote.currentRoot != zHash {
 				// Protection against nil node
 				if currentNode == nil {
@@ -338,13 +361,13 @@ func (f *ForkChoice) ProposerBoost() [fieldparams.RootLength]byte {
 	return f.store.proposerBoost()
 }
 
-// SetOptimisticToValid sets the node with the given root as a fully validated node
+// SetOptimisticToValid sets the node with the given root as a fully validated node. The payload for this root MUST have been processed.
 func (f *ForkChoice) SetOptimisticToValid(ctx context.Context, root [fieldparams.RootLength]byte) error {
-	node, ok := f.store.nodeByRoot[root]
-	if !ok || node == nil {
+	fn, ok := f.store.fullNodeByRoot[root]
+	if !ok || fn == nil {
 		return errors.Wrap(ErrNilNode, "could not set node to valid")
 	}
-	return node.setNodeAndParentValidated(ctx)
+	return f.store.setNodeAndParentValidated(ctx, fn)
 }
 
 // PreviousJustifiedCheckpoint of fork choice store.
@@ -363,8 +386,8 @@ func (f *ForkChoice) FinalizedCheckpoint() *forkchoicetypes.Checkpoint {
 }
 
 // SetOptimisticToInvalid removes a block with an invalid execution payload from fork choice store
-func (f *ForkChoice) SetOptimisticToInvalid(ctx context.Context, root, parentRoot, payloadHash [fieldparams.RootLength]byte) ([][32]byte, error) {
-	return f.store.setOptimisticToInvalid(ctx, root, parentRoot, payloadHash)
+func (f *ForkChoice) SetOptimisticToInvalid(ctx context.Context, root, parentRoot, parentHash, payloadHash [fieldparams.RootLength]byte) ([][32]byte, error) {
+	return f.store.setOptimisticToInvalid(ctx, root, parentRoot, parentHash, payloadHash)
 }
 
 // InsertSlashedIndex adds the given slashed validator index to the
@@ -387,7 +410,7 @@ func (f *ForkChoice) InsertSlashedIndex(_ context.Context, index primitives.Vali
 		return
 	}
 
-	node, ok := f.store.nodeByRoot[f.votes[index].currentRoot]
+	node, ok := f.store.emptyNodeByRoot[f.votes[index].currentRoot]
 	if !ok || node == nil {
 		return
 	}
@@ -422,22 +445,30 @@ func (f *ForkChoice) UpdateFinalizedCheckpoint(fc *forkchoicetypes.Checkpoint) e
 }
 
 // CommonAncestor returns the common ancestor root and slot between the two block roots r1 and r2.
+// This is payload aware. Consider the following situation
+// [A,full] <--- [B, full] <---[C,pending]
+//
+//	\---------[B, empty] <--[D, pending]
+//
+// Then even though C and D both descend from the beacon block B, their common ancestor is A.
+// Notice that also this function **requires** that the two roots are actually contending blocks! otherwise the
+// behavior is not defined.
 func (f *ForkChoice) CommonAncestor(ctx context.Context, r1 [32]byte, r2 [32]byte) ([32]byte, primitives.Slot, error) {
 	ctx, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.CommonAncestorRoot")
 	defer span.End()
 
-	n1, ok := f.store.nodeByRoot[r1]
-	if !ok || n1 == nil {
+	en1, ok := f.store.emptyNodeByRoot[r1]
+	if !ok || en1 == nil {
 		return [32]byte{}, 0, forkchoice.ErrUnknownCommonAncestor
 	}
 
 	// Do nothing if the input roots are the same.
 	if r1 == r2 {
-		return r1, n1.slot, nil
+		return r1, en1.node.slot, nil
 	}
 
-	n2, ok := f.store.nodeByRoot[r2]
-	if !ok || n2 == nil {
+	en2, ok := f.store.emptyNodeByRoot[r2]
+	if !ok || en2 == nil {
 		return [32]byte{}, 0, forkchoice.ErrUnknownCommonAncestor
 	}
 
@@ -445,23 +476,23 @@ func (f *ForkChoice) CommonAncestor(ctx context.Context, r1 [32]byte, r2 [32]byt
 		if ctx.Err() != nil {
 			return [32]byte{}, 0, ctx.Err()
 		}
-		if n1.slot > n2.slot {
-			n1 = n1.parent
+		if en1.node.slot > en2.node.slot {
+			en1 = en1.node.parent
 			// Reaches the end of the tree and unable to find common ancestor.
 			// This should not happen at runtime as the finalized
 			// node has to be a common ancestor
-			if n1 == nil {
+			if en1 == nil {
 				return [32]byte{}, 0, forkchoice.ErrUnknownCommonAncestor
 			}
 		} else {
-			n2 = n2.parent
+			en2 = en2.node.parent
 			// Reaches the end of the tree and unable to find common ancestor.
-			if n2 == nil {
+			if en2 == nil {
 				return [32]byte{}, 0, forkchoice.ErrUnknownCommonAncestor
 			}
 		}
-		if n1 == n2 {
-			return n1.root, n1.slot, nil
+		if en1 == en2 {
+			return en1.node.root, en1.node.slot, nil
 		}
 	}
 }
@@ -508,35 +539,17 @@ func (f *ForkChoice) CachedHeadRoot() [32]byte {
 
 // FinalizedPayloadBlockHash returns the hash of the payload at the finalized checkpoint
 func (f *ForkChoice) FinalizedPayloadBlockHash() [32]byte {
-	root := f.FinalizedCheckpoint().Root
-	node, ok := f.store.nodeByRoot[root]
-	if !ok || node == nil {
-		// This should not happen
-		return [32]byte{}
-	}
-	return node.payloadHash
+	return f.store.latestHashForRoot(f.FinalizedCheckpoint().Root)
 }
 
 // JustifiedPayloadBlockHash returns the hash of the payload at the justified checkpoint
 func (f *ForkChoice) JustifiedPayloadBlockHash() [32]byte {
-	root := f.JustifiedCheckpoint().Root
-	node, ok := f.store.nodeByRoot[root]
-	if !ok || node == nil {
-		// This should not happen
-		return [32]byte{}
-	}
-	return node.payloadHash
+	return f.store.latestHashForRoot(f.JustifiedCheckpoint().Root)
 }
 
 // UnrealizedJustifiedPayloadBlockHash returns the hash of the payload at the unrealized justified checkpoint
 func (f *ForkChoice) UnrealizedJustifiedPayloadBlockHash() [32]byte {
-	root := f.store.unrealizedJustifiedCheckpoint.Root
-	node, ok := f.store.nodeByRoot[root]
-	if !ok || node == nil {
-		// This should not happen
-		return [32]byte{}
-	}
-	return node.payloadHash
+	return f.store.latestHashForRoot(f.store.unrealizedJustifiedCheckpoint.Root)
 }
 
 // ForkChoiceDump returns a full dump of forkchoice.
@@ -560,7 +573,7 @@ func (f *ForkChoice) ForkChoiceDump(ctx context.Context) (*forkchoice2.Dump, err
 	nodes := make([]*forkchoice2.Node, 0, f.NodeCount())
 	var err error
 	if f.store.treeRootNode != nil {
-		nodes, err = f.store.treeRootNode.nodeTreeDump(ctx, nodes)
+		nodes, err = f.store.nodeTreeDump(ctx, f.store.treeRootNode, nodes)
 		if err != nil {
 			return nil, err
 		}
@@ -589,7 +602,7 @@ func (f *ForkChoice) SetBalancesByRooter(handler forkchoice.BalancesByRooter) {
 
 // Weight returns the weight of the given root if found on the store
 func (f *ForkChoice) Weight(root [32]byte) (uint64, error) {
-	n, ok := f.store.nodeByRoot[root]
+	n, ok := f.store.emptyNodeByRoot[root]
 	if !ok || n == nil {
 		return 0, ErrNilNode
 	}
@@ -617,11 +630,11 @@ func (f *ForkChoice) updateJustifiedBalances(ctx context.Context, root [32]byte)
 
 // Slot returns the slot of the given root if it's known to forkchoice
 func (f *ForkChoice) Slot(root [32]byte) (primitives.Slot, error) {
-	n, ok := f.store.nodeByRoot[root]
+	n, ok := f.store.emptyNodeByRoot[root]
 	if !ok || n == nil {
 		return 0, ErrNilNode
 	}
-	return n.slot, nil
+	return n.node.slot, nil
 }
 
 // DependentRoot returns the last root of the epoch prior to the requested ecoch in the canonical chain.
@@ -629,7 +642,7 @@ func (f *ForkChoice) DependentRoot(epoch primitives.Epoch) ([32]byte, error) {
 	return f.DependentRootForEpoch(f.CachedHeadRoot(), epoch)
 }
 
-// DependentRootForEpoch return the last root of the epoch prior to the requested ecoch for the given root.
+// DependentRootForEpoch return the last root of the epoch prior to the requested epoch for the given root.
 func (f *ForkChoice) DependentRootForEpoch(root [32]byte, epoch primitives.Epoch) ([32]byte, error) {
 	tr, err := f.TargetRootForEpoch(root, epoch)
 	if err != nil {
@@ -638,18 +651,18 @@ func (f *ForkChoice) DependentRootForEpoch(root [32]byte, epoch primitives.Epoch
 	if tr == [32]byte{} {
 		return [32]byte{}, nil
 	}
-	node, ok := f.store.nodeByRoot[tr]
-	if !ok || node == nil {
+	en, ok := f.store.emptyNodeByRoot[tr]
+	if !ok || en == nil {
 		return [32]byte{}, ErrNilNode
 	}
-	if slots.ToEpoch(node.slot) >= epoch {
-		if node.parent != nil {
-			node = node.parent
+	if slots.ToEpoch(en.node.slot) >= epoch {
+		if en.node.parent != nil {
+			en = en.node.parent
 		} else {
 			return f.store.finalizedDependentRoot, nil
 		}
 	}
-	return node.root, nil
+	return en.node.root, nil
 }
 
 // TargetRootForEpoch returns the root of the target block for a given epoch.
@@ -661,46 +674,48 @@ func (f *ForkChoice) DependentRootForEpoch(root [32]byte, epoch primitives.Epoch
 // which case we return the root of the checkpoint of the chain containing the
 // passed root, at the given epoch
 func (f *ForkChoice) TargetRootForEpoch(root [32]byte, epoch primitives.Epoch) ([32]byte, error) {
-	n, ok := f.store.nodeByRoot[root]
+	n, ok := f.store.emptyNodeByRoot[root]
 	if !ok || n == nil {
 		return [32]byte{}, ErrNilNode
 	}
-	nodeEpoch := slots.ToEpoch(n.slot)
+	node := n.node
+	nodeEpoch := slots.ToEpoch(node.slot)
 	if epoch > nodeEpoch {
-		return n.root, nil
+		return node.root, nil
 	}
-	if n.target == nil {
+	if node.target == nil {
 		return [32]byte{}, nil
 	}
-	targetRoot := n.target.root
+	targetRoot := node.target.root
 	if epoch == nodeEpoch {
 		return targetRoot, nil
 	}
-	targetNode, ok := f.store.nodeByRoot[targetRoot]
+	targetNode, ok := f.store.emptyNodeByRoot[targetRoot]
 	if !ok || targetNode == nil {
 		return [32]byte{}, ErrNilNode
 	}
 	// If slot 0 was not missed we consider a previous block to go back at least one epoch
-	if nodeEpoch == slots.ToEpoch(targetNode.slot) {
-		targetNode = targetNode.parent
+	if nodeEpoch == slots.ToEpoch(targetNode.node.slot) {
+		targetNode = targetNode.node.parent
 		if targetNode == nil {
 			return [32]byte{}, ErrNilNode
 		}
 	}
-	return f.TargetRootForEpoch(targetNode.root, epoch)
+	return f.TargetRootForEpoch(targetNode.node.root, epoch)
 }
 
 // ParentRoot returns the block root of the parent node if it is in forkchoice.
 // The exception is for the finalized checkpoint root which we return the zero
 // hash.
 func (f *ForkChoice) ParentRoot(root [32]byte) ([32]byte, error) {
-	n, ok := f.store.nodeByRoot[root]
+	n, ok := f.store.emptyNodeByRoot[root]
 	if !ok || n == nil {
 		return [32]byte{}, ErrNilNode
 	}
 	// Return the zero hash for the tree root
-	if n.parent == nil {
+	parent := n.node.parent
+	if parent == nil {
 		return [32]byte{}, nil
 	}
-	return n.parent.root, nil
+	return parent.node.root, nil
 }

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

@@ -3,7 +3,6 @@ package doublylinkedtree
 import (
 	"context"
 	"encoding/binary"
-	"errors"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/forkchoice"
@@ -104,9 +103,9 @@ func TestForkChoice_UpdateBalancesPositiveChange(t *testing.T) {
 	f.justifiedBalances = []uint64{10, 20, 30}
 	require.NoError(t, f.updateBalances())
 	s := f.store
-	assert.Equal(t, uint64(10), s.nodeByRoot[indexToHash(1)].balance)
-	assert.Equal(t, uint64(20), s.nodeByRoot[indexToHash(2)].balance)
-	assert.Equal(t, uint64(30), s.nodeByRoot[indexToHash(3)].balance)
+	assert.Equal(t, uint64(10), s.emptyNodeByRoot[indexToHash(1)].balance)
+	assert.Equal(t, uint64(20), s.emptyNodeByRoot[indexToHash(2)].balance)
+	assert.Equal(t, uint64(30), s.emptyNodeByRoot[indexToHash(3)].balance)
 }
 
 func TestForkChoice_UpdateBalancesNegativeChange(t *testing.T) {
@@ -122,9 +121,9 @@ func TestForkChoice_UpdateBalancesNegativeChange(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 	s := f.store
-	s.nodeByRoot[indexToHash(1)].balance = 100
-	s.nodeByRoot[indexToHash(2)].balance = 100
-	s.nodeByRoot[indexToHash(3)].balance = 100
+	s.emptyNodeByRoot[indexToHash(1)].balance = 100
+	s.emptyNodeByRoot[indexToHash(2)].balance = 100
+	s.emptyNodeByRoot[indexToHash(3)].balance = 100
 
 	f.balances = []uint64{100, 100, 100}
 	f.votes = []Vote{
@@ -135,9 +134,9 @@ func TestForkChoice_UpdateBalancesNegativeChange(t *testing.T) {
 
 	f.justifiedBalances = []uint64{10, 20, 30}
 	require.NoError(t, f.updateBalances())
-	assert.Equal(t, uint64(10), s.nodeByRoot[indexToHash(1)].balance)
-	assert.Equal(t, uint64(20), s.nodeByRoot[indexToHash(2)].balance)
-	assert.Equal(t, uint64(30), s.nodeByRoot[indexToHash(3)].balance)
+	assert.Equal(t, uint64(10), s.emptyNodeByRoot[indexToHash(1)].balance)
+	assert.Equal(t, uint64(20), s.emptyNodeByRoot[indexToHash(2)].balance)
+	assert.Equal(t, uint64(30), s.emptyNodeByRoot[indexToHash(3)].balance)
 }
 
 func TestForkChoice_UpdateBalancesUnderflow(t *testing.T) {
@@ -153,9 +152,9 @@ func TestForkChoice_UpdateBalancesUnderflow(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 	s := f.store
-	s.nodeByRoot[indexToHash(1)].balance = 100
-	s.nodeByRoot[indexToHash(2)].balance = 100
-	s.nodeByRoot[indexToHash(3)].balance = 100
+	s.emptyNodeByRoot[indexToHash(1)].balance = 100
+	s.emptyNodeByRoot[indexToHash(2)].balance = 100
+	s.emptyNodeByRoot[indexToHash(3)].balance = 100
 
 	f.balances = []uint64{125, 125, 125}
 	f.votes = []Vote{
@@ -166,9 +165,9 @@ func TestForkChoice_UpdateBalancesUnderflow(t *testing.T) {
 
 	f.justifiedBalances = []uint64{10, 20, 30}
 	require.NoError(t, f.updateBalances())
-	assert.Equal(t, uint64(0), s.nodeByRoot[indexToHash(1)].balance)
-	assert.Equal(t, uint64(0), s.nodeByRoot[indexToHash(2)].balance)
-	assert.Equal(t, uint64(5), s.nodeByRoot[indexToHash(3)].balance)
+	assert.Equal(t, uint64(0), s.emptyNodeByRoot[indexToHash(1)].balance)
+	assert.Equal(t, uint64(0), s.emptyNodeByRoot[indexToHash(2)].balance)
+	assert.Equal(t, uint64(5), s.emptyNodeByRoot[indexToHash(3)].balance)
 }
 
 func TestForkChoice_IsCanonical(t *testing.T) {
@@ -224,12 +223,12 @@ func TestForkChoice_IsCanonicalReorg(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 
-	f.store.nodeByRoot[[32]byte{'3'}].balance = 10
-	require.NoError(t, f.store.treeRootNode.applyWeightChanges(ctx))
-	require.Equal(t, uint64(10), f.store.nodeByRoot[[32]byte{'1'}].weight)
-	require.Equal(t, uint64(0), f.store.nodeByRoot[[32]byte{'2'}].weight)
+	f.store.emptyNodeByRoot[[32]byte{'3'}].balance = 10
+	require.NoError(t, f.store.applyWeightChangesConsensusNode(ctx, f.store.treeRootNode))
+	require.Equal(t, uint64(10), f.store.emptyNodeByRoot[[32]byte{'1'}].node.weight)
+	require.Equal(t, uint64(0), f.store.emptyNodeByRoot[[32]byte{'2'}].node.weight)
 
-	require.NoError(t, f.store.treeRootNode.updateBestDescendant(ctx, 1, 1, 1))
+	require.NoError(t, f.store.updateBestDescendantConsensusNode(ctx, f.store.treeRootNode, 1, 1, 1))
 	require.DeepEqual(t, [32]byte{'3'}, f.store.treeRootNode.bestDescendant.root)
 
 	r1 := [32]byte{'1'}
@@ -260,7 +259,7 @@ func TestForkChoice_AncestorRoot(t *testing.T) {
 	st, roblock, err = prepareForkchoiceState(ctx, 5, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	f.store.treeRootNode = f.store.nodeByRoot[indexToHash(1)]
+	f.store.treeRootNode = f.store.emptyNodeByRoot[indexToHash(1)].node
 	f.store.treeRootNode.parent = nil
 
 	r, err := f.AncestorRoot(ctx, indexToHash(3), 6)
@@ -342,21 +341,21 @@ func TestForkChoice_RemoveEquivocating(t *testing.T) {
 
 	// Process b's slashing, c is now head
 	f.InsertSlashedIndex(ctx, 1)
-	require.Equal(t, uint64(200), f.store.nodeByRoot[[32]byte{'b'}].balance)
+	require.Equal(t, uint64(200), f.store.emptyNodeByRoot[[32]byte{'b'}].balance)
 	f.justifiedBalances = []uint64{100, 200, 200, 300}
 	head, err = f.Head(ctx)
-	require.Equal(t, uint64(200), f.store.nodeByRoot[[32]byte{'b'}].weight)
-	require.Equal(t, uint64(300), f.store.nodeByRoot[[32]byte{'c'}].weight)
+	require.Equal(t, uint64(200), f.store.emptyNodeByRoot[[32]byte{'b'}].weight)
+	require.Equal(t, uint64(300), f.store.emptyNodeByRoot[[32]byte{'c'}].weight)
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'c'}, head)
 
 	// Process b's slashing again, should be a noop
 	f.InsertSlashedIndex(ctx, 1)
-	require.Equal(t, uint64(200), f.store.nodeByRoot[[32]byte{'b'}].balance)
+	require.Equal(t, uint64(200), f.store.emptyNodeByRoot[[32]byte{'b'}].balance)
 	f.justifiedBalances = []uint64{100, 200, 200, 300}
 	head, err = f.Head(ctx)
-	require.Equal(t, uint64(200), f.store.nodeByRoot[[32]byte{'b'}].weight)
-	require.Equal(t, uint64(300), f.store.nodeByRoot[[32]byte{'c'}].weight)
+	require.Equal(t, uint64(200), f.store.emptyNodeByRoot[[32]byte{'b'}].weight)
+	require.Equal(t, uint64(300), f.store.emptyNodeByRoot[[32]byte{'c'}].weight)
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'c'}, head)
 
@@ -514,58 +513,6 @@ func TestStore_CommonAncestor(t *testing.T) {
 		})
 	}
 
-	// a -- b -- c -- d
-	f = setup(0, 0)
-	st, roblock, err = prepareForkchoiceState(ctx, 0, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 1, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 2, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 1)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 3, [32]byte{'d'}, [32]byte{'c'}, [32]byte{}, 1, 1)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	tests = []struct {
-		name     string
-		r1       [32]byte
-		r2       [32]byte
-		wantRoot [32]byte
-		wantSlot primitives.Slot
-	}{
-		{
-			name:     "Common ancestor between a and b is a",
-			r1:       [32]byte{'a'},
-			r2:       [32]byte{'b'},
-			wantRoot: [32]byte{'a'},
-			wantSlot: 0,
-		},
-		{
-			name:     "Common ancestor between b and d is b",
-			r1:       [32]byte{'d'},
-			r2:       [32]byte{'b'},
-			wantRoot: [32]byte{'b'},
-			wantSlot: 1,
-		},
-		{
-			name:     "Common ancestor between d and a is a",
-			r1:       [32]byte{'d'},
-			r2:       [32]byte{'a'},
-			wantRoot: [32]byte{'a'},
-			wantSlot: 0,
-		},
-	}
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			gotRoot, gotSlot, err := f.CommonAncestor(ctx, tc.r1, tc.r2)
-			require.NoError(t, err)
-			require.Equal(t, tc.wantRoot, gotRoot)
-			require.Equal(t, tc.wantSlot, gotSlot)
-		})
-	}
-
 	// Equal inputs should return the same root.
 	r, s, err := f.CommonAncestor(ctx, [32]byte{'b'}, [32]byte{'b'})
 	require.NoError(t, err)
@@ -588,10 +535,9 @@ func TestStore_CommonAncestor(t *testing.T) {
 		unrealizedJustifiedEpoch: 1,
 		finalizedEpoch:           1,
 		unrealizedFinalizedEpoch: 1,
-		optimistic:               true,
 	}
 
-	f.store.nodeByRoot[[32]byte{'y'}] = n
+	f.store.emptyNodeByRoot[[32]byte{'y'}] = &PayloadNode{node: n, optimistic: true}
 	// broken link
 	_, _, err = f.CommonAncestor(ctx, [32]byte{'y'}, [32]byte{'a'})
 	require.ErrorIs(t, err, forkchoice.ErrUnknownCommonAncestor)
@@ -610,7 +556,8 @@ func TestStore_InsertChain(t *testing.T) {
 	require.NoError(t, err)
 	roblock, err := blocks.NewROBlockWithRoot(wsb, root)
 	require.NoError(t, err)
-	blks = append(blks, &forkchoicetypes.BlockAndCheckpoints{Block: roblock,
+	blks = append(blks, &forkchoicetypes.BlockAndCheckpoints{
+		Block:               roblock,
 		JustifiedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: params.BeaconConfig().ZeroHash[:]},
 		FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: params.BeaconConfig().ZeroHash[:]},
 	})
@@ -625,7 +572,8 @@ func TestStore_InsertChain(t *testing.T) {
 		require.NoError(t, err)
 		roblock, err := blocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		blks = append(blks, &forkchoicetypes.BlockAndCheckpoints{Block: roblock,
+		blks = append(blks, &forkchoicetypes.BlockAndCheckpoints{
+			Block:               roblock,
 			JustifiedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: params.BeaconConfig().ZeroHash[:]},
 			FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: params.BeaconConfig().ZeroHash[:]},
 		})
@@ -742,7 +690,7 @@ func TestWeight(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 
-	n, ok := f.store.nodeByRoot[root]
+	n, ok := f.store.emptyNodeByRoot[root]
 	require.Equal(t, true, ok)
 	n.weight = 10
 	w, err := f.Weight(root)
@@ -914,16 +862,3 @@ func TestForkchoiceParentRoot(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, zeroHash, root)
 }
-
-func TestForkChoice_CleanupInserting(t *testing.T) {
-	f := setup(0, 0)
-	ctx := t.Context()
-	st, roblock, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 2, 2)
-	f.SetBalancesByRooter(func(_ context.Context, _ [32]byte) ([]uint64, error) {
-		return f.justifiedBalances, errors.New("mock err")
-	})
-
-	require.NoError(t, err)
-	require.NotNil(t, f.InsertNode(ctx, st, roblock))
-	require.Equal(t, false, f.HasNode(roblock.Root()))
-}

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

@@ -0,0 +1,289 @@
+package doublylinkedtree
+
+import (
+	"bytes"
+	"context"
+	"slices"
+
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	forkchoice2 "github.com/OffchainLabs/prysm/v7/consensus-types/forkchoice"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	"github.com/pkg/errors"
+)
+
+func (s *Store) resolveParentPayloadStatus(block interfaces.ReadOnlyBeaconBlock, parent **PayloadNode, blockHash *[32]byte) error {
+	sb, err := block.Body().SignedExecutionPayloadBid()
+	if err != nil {
+		return err
+	}
+	wb, err := blocks.WrappedROSignedExecutionPayloadBid(sb)
+	if err != nil {
+		return errors.Wrap(err, "failed to wrap signed bid")
+	}
+	bid, err := wb.Bid()
+	if err != nil {
+		return errors.Wrap(err, "failed to get bid from wrapped bid")
+	}
+	*blockHash = bid.BlockHash()
+	parentRoot := block.ParentRoot()
+	*parent = s.emptyNodeByRoot[parentRoot]
+	if *parent == nil {
+		// This is the tree root node.
+		return nil
+	}
+	if bid.ParentBlockHash() == (*parent).node.blockHash {
+		// block builds on full
+		*parent = s.fullNodeByRoot[(*parent).node.root]
+	}
+	return nil
+}
+
+// applyWeightChangesConsensusNode recomputes the weight of the node passed as an argument and all of its descendants,
+// using the current balance stored in each node.
+func (s *Store) applyWeightChangesConsensusNode(ctx context.Context, n *Node) error {
+	// Recursively calling the children to sum their weights.
+	en := s.emptyNodeByRoot[n.root]
+	if err := s.applyWeightChangesPayloadNode(ctx, en); err != nil {
+		return err
+	}
+	childrenWeight := en.weight
+	fn := s.fullNodeByRoot[n.root]
+	if fn != nil {
+		if err := s.applyWeightChangesPayloadNode(ctx, fn); err != nil {
+			return err
+		}
+		childrenWeight += fn.weight
+	}
+	if n.root == params.BeaconConfig().ZeroHash {
+		return nil
+	}
+	n.weight = n.balance + childrenWeight
+	return nil
+}
+
+// applyWeightChangesPayloadNode recomputes the weight of the node passed as an argument and all of its descendants,
+// using the current balance stored in each node.
+func (s *Store) applyWeightChangesPayloadNode(ctx context.Context, n *PayloadNode) error {
+	// Recursively calling the children to sum their weights.
+	childrenWeight := uint64(0)
+	for _, child := range n.children {
+		if ctx.Err() != nil {
+			return ctx.Err()
+		}
+		if err := s.applyWeightChangesConsensusNode(ctx, child); err != nil {
+			return err
+		}
+		childrenWeight += child.weight
+	}
+	n.weight = n.balance + childrenWeight
+	return nil
+}
+
+// allConsensusChildren returns the list of all consensus blocks that build on the given node.
+func (s *Store) allConsensusChildren(n *Node) []*Node {
+	en := s.emptyNodeByRoot[n.root]
+	fn, ok := s.fullNodeByRoot[n.root]
+	if ok {
+		return append(slices.Clone(en.children), fn.children...)
+	}
+	return en.children
+}
+
+// setNodeAndParentValidated sets the current node and all the ancestors as validated (i.e. non-optimistic).
+func (s *Store) setNodeAndParentValidated(ctx context.Context, pn *PayloadNode) error {
+	if ctx.Err() != nil {
+		return ctx.Err()
+	}
+
+	if !pn.optimistic {
+		return nil
+	}
+	pn.optimistic = false
+	if pn.full {
+		// set the empty node also a as valid
+		en := s.emptyNodeByRoot[pn.node.root]
+		en.optimistic = false
+	}
+	if pn.node.parent == nil {
+		return nil
+	}
+	return s.setNodeAndParentValidated(ctx, pn.node.parent)
+}
+
+// fullParent returns the latest full node that this block builds on.
+func (s *Store) fullParent(pn *PayloadNode) *PayloadNode {
+	parent := pn.node.parent
+	for ; parent != nil && !parent.full; parent = parent.node.parent {
+	}
+	return parent
+}
+
+// parentHash return the payload hash of the latest full node that this block builds on.
+func (s *Store) parentHash(pn *PayloadNode) [32]byte {
+	fullParent := s.fullParent(pn)
+	if fullParent == nil {
+		return [32]byte{}
+	}
+	return fullParent.node.blockHash
+}
+
+// latestHashForRoot returns the latest payload hash for the given block root.
+func (s *Store) latestHashForRoot(root [32]byte) [32]byte {
+	// try to get the full node first
+	fn := s.fullNodeByRoot[root]
+	if fn != nil {
+		return fn.node.blockHash
+	}
+	en := s.emptyNodeByRoot[root]
+	if en == nil {
+		// This should not happen
+		return [32]byte{}
+	}
+	return s.parentHash(en)
+}
+
+// updateBestDescendantPayloadNode updates the best descendant of this node and its
+// children.
+func (s *Store) updateBestDescendantPayloadNode(ctx context.Context, n *PayloadNode, justifiedEpoch, finalizedEpoch, currentEpoch primitives.Epoch) error {
+	if ctx.Err() != nil {
+		return ctx.Err()
+	}
+
+	var bestChild *Node
+	bestWeight := uint64(0)
+	for _, child := range n.children {
+		if child == nil {
+			return errors.Wrap(ErrNilNode, "could not update best descendant")
+		}
+		if err := s.updateBestDescendantConsensusNode(ctx, child, justifiedEpoch, finalizedEpoch, currentEpoch); err != nil {
+			return err
+		}
+		childLeadsToViableHead := child.leadsToViableHead(justifiedEpoch, currentEpoch)
+		if childLeadsToViableHead && bestChild == nil {
+			// The child leads to a viable head, but the current
+			// parent's best child doesn't.
+			bestWeight = child.weight
+			bestChild = child
+		} else if childLeadsToViableHead {
+			// If both are viable, compare their weights.
+			if child.weight == bestWeight {
+				// Tie-breaker of equal weights by root.
+				if bytes.Compare(child.root[:], bestChild.root[:]) > 0 {
+					bestChild = child
+				}
+			} else if child.weight > bestWeight {
+				bestChild = child
+				bestWeight = child.weight
+			}
+		}
+	}
+	if bestChild == nil {
+		n.bestDescendant = nil
+	} else {
+		if bestChild.bestDescendant == nil {
+			n.bestDescendant = bestChild
+		} else {
+			n.bestDescendant = bestChild.bestDescendant
+		}
+	}
+	return nil
+}
+
+// updateBestDescendantConsensusNode updates the best descendant of this node and its
+// children.
+func (s *Store) updateBestDescendantConsensusNode(ctx context.Context, n *Node, justifiedEpoch, finalizedEpoch, currentEpoch primitives.Epoch) error {
+	if ctx.Err() != nil {
+		return ctx.Err()
+	}
+	if len(s.allConsensusChildren(n)) == 0 {
+		n.bestDescendant = nil
+		return nil
+	}
+
+	en := s.emptyNodeByRoot[n.root]
+	if err := s.updateBestDescendantPayloadNode(ctx, en, justifiedEpoch, finalizedEpoch, currentEpoch); err != nil {
+		return err
+	}
+	fn := s.fullNodeByRoot[n.root]
+	if fn == nil {
+		n.bestDescendant = en.bestDescendant
+		return nil
+	}
+	// TODO GLOAS: pick between full or empty
+	if err := s.updateBestDescendantPayloadNode(ctx, fn, justifiedEpoch, finalizedEpoch, currentEpoch); err != nil {
+		return err
+	}
+	n.bestDescendant = fn.bestDescendant
+	return nil
+}
+
+// choosePayloadContent chooses between empty or full for the passed consensus node. TODO Gloas: use PTC to choose.
+func (s *Store) choosePayloadContent(n *Node) *PayloadNode {
+	if n == nil {
+		return nil
+	}
+	fn := s.fullNodeByRoot[n.root]
+	if fn != nil {
+		return fn
+	}
+	return s.emptyNodeByRoot[n.root]
+}
+
+// nodeTreeDump appends to the given list all the nodes descending from this one
+func (s *Store) nodeTreeDump(ctx context.Context, n *Node, nodes []*forkchoice2.Node) ([]*forkchoice2.Node, error) {
+	if ctx.Err() != nil {
+		return nil, ctx.Err()
+	}
+	var parentRoot [32]byte
+	if n.parent != nil {
+		parentRoot = n.parent.node.root
+	}
+	target := [32]byte{}
+	if n.target != nil {
+		target = n.target.root
+	}
+	optimistic := false
+	if n.parent != nil {
+		optimistic = n.parent.optimistic
+	}
+	en := s.emptyNodeByRoot[n.root]
+	timestamp := en.timestamp
+	fn := s.fullNodeByRoot[n.root]
+	if fn != nil {
+		optimistic = fn.optimistic
+		timestamp = fn.timestamp
+	}
+	thisNode := &forkchoice2.Node{
+		Slot:                     n.slot,
+		BlockRoot:                n.root[:],
+		ParentRoot:               parentRoot[:],
+		JustifiedEpoch:           n.justifiedEpoch,
+		FinalizedEpoch:           n.finalizedEpoch,
+		UnrealizedJustifiedEpoch: n.unrealizedJustifiedEpoch,
+		UnrealizedFinalizedEpoch: n.unrealizedFinalizedEpoch,
+		Balance:                  n.balance,
+		Weight:                   n.weight,
+		ExecutionOptimistic:      optimistic,
+		ExecutionBlockHash:       n.blockHash[:],
+		Timestamp:                timestamp,
+		Target:                   target[:],
+	}
+	if optimistic {
+		thisNode.Validity = forkchoice2.Optimistic
+	} else {
+		thisNode.Validity = forkchoice2.Valid
+	}
+
+	nodes = append(nodes, thisNode)
+	var err error
+	children := s.allConsensusChildren(n)
+	for _, child := range children {
+		nodes, err = s.nodeTreeDump(ctx, child, nodes)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}

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

@@ -1,26 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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/node.go

@@ -1,95 +1,17 @@
 package doublylinkedtree
 
 import (
-	"bytes"
-	"context"
 	"time"
 
 	"github.com/OffchainLabs/prysm/v7/config/params"
-	forkchoice2 "github.com/OffchainLabs/prysm/v7/consensus-types/forkchoice"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/time/slots"
-	"github.com/pkg/errors"
 )
 
 // ProcessAttestationsThreshold is the amount of time after which we
 // process attestations for the current slot
 const ProcessAttestationsThreshold = 10 * time.Second
 
-// applyWeightChanges recomputes the weight of the node passed as an argument and all of its descendants,
-// using the current balance stored in each node.
-func (n *Node) applyWeightChanges(ctx context.Context) error {
-	// Recursively calling the children to sum their weights.
-	childrenWeight := uint64(0)
-	for _, child := range n.children {
-		if ctx.Err() != nil {
-			return ctx.Err()
-		}
-		if err := child.applyWeightChanges(ctx); err != nil {
-			return err
-		}
-		childrenWeight += child.weight
-	}
-	if n.root == params.BeaconConfig().ZeroHash {
-		return nil
-	}
-	n.weight = n.balance + childrenWeight
-	return nil
-}
-
-// updateBestDescendant updates the best descendant of this node and its
-// children.
-func (n *Node) updateBestDescendant(ctx context.Context, justifiedEpoch, finalizedEpoch, currentEpoch primitives.Epoch) error {
-	if ctx.Err() != nil {
-		return ctx.Err()
-	}
-	if len(n.children) == 0 {
-		n.bestDescendant = nil
-		return nil
-	}
-
-	var bestChild *Node
-	bestWeight := uint64(0)
-	hasViableDescendant := false
-	for _, child := range n.children {
-		if child == nil {
-			return errors.Wrap(ErrNilNode, "could not update best descendant")
-		}
-		if err := child.updateBestDescendant(ctx, justifiedEpoch, finalizedEpoch, currentEpoch); err != nil {
-			return err
-		}
-		childLeadsToViableHead := child.leadsToViableHead(justifiedEpoch, currentEpoch)
-		if childLeadsToViableHead && !hasViableDescendant {
-			// The child leads to a viable head, but the current
-			// parent's best child doesn't.
-			bestWeight = child.weight
-			bestChild = child
-			hasViableDescendant = true
-		} else if childLeadsToViableHead {
-			// If both are viable, compare their weights.
-			if child.weight == bestWeight {
-				// Tie-breaker of equal weights by root.
-				if bytes.Compare(child.root[:], bestChild.root[:]) > 0 {
-					bestChild = child
-				}
-			} else if child.weight > bestWeight {
-				bestChild = child
-				bestWeight = child.weight
-			}
-		}
-	}
-	if hasViableDescendant {
-		if bestChild.bestDescendant == nil {
-			n.bestDescendant = bestChild
-		} else {
-			n.bestDescendant = bestChild.bestDescendant
-		}
-	} else {
-		n.bestDescendant = nil
-	}
-	return nil
-}
-
 // viableForHead returns true if the node is viable to head.
 // Any node with different finalized or justified epoch than
 // the ones in fork choice store should not be viable to head.
@@ -110,30 +32,13 @@ func (n *Node) leadsToViableHead(justifiedEpoch, currentEpoch primitives.Epoch)
 	return n.bestDescendant.viableForHead(justifiedEpoch, currentEpoch)
 }
 
-// setNodeAndParentValidated sets the current node and all the ancestors as validated (i.e. non-optimistic).
-func (n *Node) setNodeAndParentValidated(ctx context.Context) error {
-	if ctx.Err() != nil {
-		return ctx.Err()
-	}
-
-	if !n.optimistic {
-		return nil
-	}
-	n.optimistic = false
-
-	if n.parent == nil {
-		return nil
-	}
-	return n.parent.setNodeAndParentValidated(ctx)
-}
-
 // arrivedEarly returns whether this node was inserted before the first
 // threshold to orphan a block.
 // Note that genesisTime has seconds granularity, therefore we use a strict
 // inequality < here. For example a block that arrives 3.9999 seconds into the
 // slot will have secs = 3 below.
-func (n *Node) arrivedEarly(genesis time.Time) (bool, error) {
-	sss, err := slots.SinceSlotStart(n.slot, genesis, n.timestamp.Truncate(time.Second)) // Truncate such that 3.9999 seconds will have a value of 3.
+func (n *PayloadNode) arrivedEarly(genesis time.Time) (bool, error) {
+	sss, err := slots.SinceSlotStart(n.node.slot, genesis, n.timestamp.Truncate(time.Second)) // Truncate such that 3.9999 seconds will have a value of 3.
 	votingWindow := params.BeaconConfig().SlotComponentDuration(params.BeaconConfig().AttestationDueBPS)
 	return sss < votingWindow, err
 }
@@ -143,52 +48,7 @@ func (n *Node) arrivedEarly(genesis time.Time) (bool, error) {
 // Note that genesisTime has seconds granularity, therefore we use an
 // inequality >= here. For example a block that arrives 10.00001 seconds into the
 // slot will have secs = 10 below.
-func (n *Node) arrivedAfterOrphanCheck(genesis time.Time) (bool, error) {
-	secs, err := slots.SinceSlotStart(n.slot, genesis, n.timestamp.Truncate(time.Second)) // Truncate such that 10.00001 seconds will have a value of 10.
+func (n *PayloadNode) arrivedAfterOrphanCheck(genesis time.Time) (bool, error) {
+	secs, err := slots.SinceSlotStart(n.node.slot, genesis, n.timestamp.Truncate(time.Second)) // Truncate such that 10.00001 seconds will have a value of 10.
 	return secs >= ProcessAttestationsThreshold, err
 }
-
-// nodeTreeDump appends to the given list all the nodes descending from this one
-func (n *Node) nodeTreeDump(ctx context.Context, nodes []*forkchoice2.Node) ([]*forkchoice2.Node, error) {
-	if ctx.Err() != nil {
-		return nil, ctx.Err()
-	}
-	var parentRoot [32]byte
-	if n.parent != nil {
-		parentRoot = n.parent.root
-	}
-	target := [32]byte{}
-	if n.target != nil {
-		target = n.target.root
-	}
-	thisNode := &forkchoice2.Node{
-		Slot:                     n.slot,
-		BlockRoot:                n.root[:],
-		ParentRoot:               parentRoot[:],
-		JustifiedEpoch:           n.justifiedEpoch,
-		FinalizedEpoch:           n.finalizedEpoch,
-		UnrealizedJustifiedEpoch: n.unrealizedJustifiedEpoch,
-		UnrealizedFinalizedEpoch: n.unrealizedFinalizedEpoch,
-		Balance:                  n.balance,
-		Weight:                   n.weight,
-		ExecutionOptimistic:      n.optimistic,
-		ExecutionBlockHash:       n.payloadHash[:],
-		Timestamp:                n.timestamp,
-		Target:                   target[:],
-	}
-	if n.optimistic {
-		thisNode.Validity = forkchoice2.Optimistic
-	} else {
-		thisNode.Validity = forkchoice2.Valid
-	}
-
-	nodes = append(nodes, thisNode)
-	var err error
-	for _, child := range n.children {
-		nodes, err = child.nodeTreeDump(ctx, nodes)
-		if err != nil {
-			return nil, err
-		}
-	}
-	return nodes, nil
-}

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

@@ -27,15 +27,15 @@ func TestNode_ApplyWeightChanges_PositiveChange(t *testing.T) {
 	// The updated balances of each node is 100
 	s := f.store
 
-	s.nodeByRoot[indexToHash(1)].balance = 100
-	s.nodeByRoot[indexToHash(2)].balance = 100
-	s.nodeByRoot[indexToHash(3)].balance = 100
+	s.emptyNodeByRoot[indexToHash(1)].balance = 100
+	s.emptyNodeByRoot[indexToHash(2)].balance = 100
+	s.emptyNodeByRoot[indexToHash(3)].balance = 100
 
-	assert.NoError(t, s.treeRootNode.applyWeightChanges(ctx))
+	assert.NoError(t, s.applyWeightChangesConsensusNode(ctx, s.treeRootNode))
 
-	assert.Equal(t, uint64(300), s.nodeByRoot[indexToHash(1)].weight)
-	assert.Equal(t, uint64(200), s.nodeByRoot[indexToHash(2)].weight)
-	assert.Equal(t, uint64(100), s.nodeByRoot[indexToHash(3)].weight)
+	assert.Equal(t, uint64(300), s.emptyNodeByRoot[indexToHash(1)].node.weight)
+	assert.Equal(t, uint64(200), s.emptyNodeByRoot[indexToHash(2)].node.weight)
+	assert.Equal(t, uint64(100), s.emptyNodeByRoot[indexToHash(3)].node.weight)
 }
 
 func TestNode_ApplyWeightChanges_NegativeChange(t *testing.T) {
@@ -53,19 +53,19 @@ func TestNode_ApplyWeightChanges_NegativeChange(t *testing.T) {
 
 	// The updated balances of each node is 100
 	s := f.store
-	s.nodeByRoot[indexToHash(1)].weight = 400
-	s.nodeByRoot[indexToHash(2)].weight = 400
-	s.nodeByRoot[indexToHash(3)].weight = 400
+	s.emptyNodeByRoot[indexToHash(1)].weight = 400
+	s.emptyNodeByRoot[indexToHash(2)].weight = 400
+	s.emptyNodeByRoot[indexToHash(3)].weight = 400
 
-	s.nodeByRoot[indexToHash(1)].balance = 100
-	s.nodeByRoot[indexToHash(2)].balance = 100
-	s.nodeByRoot[indexToHash(3)].balance = 100
+	s.emptyNodeByRoot[indexToHash(1)].balance = 100
+	s.emptyNodeByRoot[indexToHash(2)].balance = 100
+	s.emptyNodeByRoot[indexToHash(3)].balance = 100
 
-	assert.NoError(t, s.treeRootNode.applyWeightChanges(ctx))
+	assert.NoError(t, s.applyWeightChangesConsensusNode(ctx, s.treeRootNode))
 
-	assert.Equal(t, uint64(300), s.nodeByRoot[indexToHash(1)].weight)
-	assert.Equal(t, uint64(200), s.nodeByRoot[indexToHash(2)].weight)
-	assert.Equal(t, uint64(100), s.nodeByRoot[indexToHash(3)].weight)
+	assert.Equal(t, uint64(300), s.emptyNodeByRoot[indexToHash(1)].node.weight)
+	assert.Equal(t, uint64(200), s.emptyNodeByRoot[indexToHash(2)].node.weight)
+	assert.Equal(t, uint64(100), s.emptyNodeByRoot[indexToHash(3)].node.weight)
 }
 
 func TestNode_UpdateBestDescendant_NonViableChild(t *testing.T) {
@@ -78,7 +78,7 @@ func TestNode_UpdateBestDescendant_NonViableChild(t *testing.T) {
 
 	// Verify parent's best child and best descendant are `none`.
 	s := f.store
-	assert.Equal(t, 1, len(s.treeRootNode.children))
+	assert.Equal(t, 1, len(s.allConsensusChildren(s.treeRootNode)))
 	nilBestDescendant := s.treeRootNode.bestDescendant == nil
 	assert.Equal(t, true, nilBestDescendant)
 }
@@ -92,8 +92,9 @@ func TestNode_UpdateBestDescendant_ViableChild(t *testing.T) {
 	require.NoError(t, f.InsertNode(ctx, state, blk))
 
 	s := f.store
-	assert.Equal(t, 1, len(s.treeRootNode.children))
-	assert.Equal(t, s.treeRootNode.children[0], s.treeRootNode.bestDescendant)
+	children := s.allConsensusChildren(s.treeRootNode)
+	assert.Equal(t, 1, len(children))
+	assert.Equal(t, children[0], s.treeRootNode.bestDescendant)
 }
 
 func TestNode_UpdateBestDescendant_HigherWeightChild(t *testing.T) {
@@ -108,32 +109,34 @@ func TestNode_UpdateBestDescendant_HigherWeightChild(t *testing.T) {
 	require.NoError(t, f.InsertNode(ctx, state, blk))
 
 	s := f.store
-	s.nodeByRoot[indexToHash(1)].weight = 100
-	s.nodeByRoot[indexToHash(2)].weight = 200
-	assert.NoError(t, s.treeRootNode.updateBestDescendant(ctx, 1, 1, 1))
+	s.emptyNodeByRoot[indexToHash(1)].weight = 100
+	s.emptyNodeByRoot[indexToHash(2)].weight = 200
+	assert.NoError(t, s.updateBestDescendantConsensusNode(ctx, s.treeRootNode, 1, 1, 1))
 
-	assert.Equal(t, 2, len(s.treeRootNode.children))
-	assert.Equal(t, s.treeRootNode.children[1], s.treeRootNode.bestDescendant)
+	children := s.allConsensusChildren(s.treeRootNode)
+	assert.Equal(t, 2, len(children))
+	assert.Equal(t, children[1], s.treeRootNode.bestDescendant)
 }
 
 func TestNode_UpdateBestDescendant_LowerWeightChild(t *testing.T) {
 	f := setup(1, 1)
 	ctx := t.Context()
 	// Input child is the best descendant
-	state, blk, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, indexToHash(101), 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	state, blk, err = prepareForkchoiceState(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk, err = prepareForkchoiceState(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, indexToHash(102), 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
 
 	s := f.store
-	s.nodeByRoot[indexToHash(1)].weight = 200
-	s.nodeByRoot[indexToHash(2)].weight = 100
-	assert.NoError(t, s.treeRootNode.updateBestDescendant(ctx, 1, 1, 1))
+	s.emptyNodeByRoot[indexToHash(1)].node.weight = 200
+	s.emptyNodeByRoot[indexToHash(2)].node.weight = 100
+	assert.NoError(t, s.updateBestDescendantConsensusNode(ctx, s.treeRootNode, 1, 1, 1))
 
-	assert.Equal(t, 2, len(s.treeRootNode.children))
-	assert.Equal(t, s.treeRootNode.children[0], s.treeRootNode.bestDescendant)
+	children := s.allConsensusChildren(s.treeRootNode)
+	assert.Equal(t, 2, len(children))
+	assert.Equal(t, children[0], s.treeRootNode.bestDescendant)
 }
 
 func TestNode_ViableForHead(t *testing.T) {
@@ -176,44 +179,44 @@ func TestNode_LeadsToViableHead(t *testing.T) {
 	require.NoError(t, f.InsertNode(ctx, state, blk))
 
 	require.Equal(t, true, f.store.treeRootNode.leadsToViableHead(4, 5))
-	require.Equal(t, true, f.store.nodeByRoot[indexToHash(5)].leadsToViableHead(4, 5))
-	require.Equal(t, false, f.store.nodeByRoot[indexToHash(2)].leadsToViableHead(4, 5))
-	require.Equal(t, false, f.store.nodeByRoot[indexToHash(4)].leadsToViableHead(4, 5))
+	require.Equal(t, true, f.store.emptyNodeByRoot[indexToHash(5)].node.leadsToViableHead(4, 5))
+	require.Equal(t, false, f.store.emptyNodeByRoot[indexToHash(2)].node.leadsToViableHead(4, 5))
+	require.Equal(t, false, f.store.emptyNodeByRoot[indexToHash(4)].node.leadsToViableHead(4, 5))
 }
 
 func TestNode_SetFullyValidated(t *testing.T) {
 	f := setup(1, 1)
 	ctx := t.Context()
-	storeNodes := make([]*Node, 6)
-	storeNodes[0] = f.store.treeRootNode
+	storeNodes := make([]*PayloadNode, 6)
+	storeNodes[0] = f.store.fullNodeByRoot[params.BeaconConfig().ZeroHash]
 	// insert blocks in the fork pattern (optimistic status in parenthesis)
 	//
 	// 0 (false) -- 1 (false) -- 2 (false) -- 3 (true) -- 4 (true)
 	//               \
 	//                 -- 5 (true)
 	//
-	state, blk, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, indexToHash(101), 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	storeNodes[1] = f.store.nodeByRoot[blk.Root()]
-	require.NoError(t, f.SetOptimisticToValid(ctx, params.BeaconConfig().ZeroHash))
-	state, blk, err = prepareForkchoiceState(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, state, blk))
-	storeNodes[2] = f.store.nodeByRoot[blk.Root()]
+	storeNodes[1] = f.store.fullNodeByRoot[blk.Root()]
 	require.NoError(t, f.SetOptimisticToValid(ctx, indexToHash(1)))
-	state, blk, err = prepareForkchoiceState(ctx, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk, err = prepareForkchoiceState(ctx, 2, indexToHash(2), indexToHash(1), indexToHash(102), 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	storeNodes[3] = f.store.nodeByRoot[blk.Root()]
-	state, blk, err = prepareForkchoiceState(ctx, 4, indexToHash(4), indexToHash(3), params.BeaconConfig().ZeroHash, 1, 1)
+	storeNodes[2] = f.store.fullNodeByRoot[blk.Root()]
+	require.NoError(t, f.SetOptimisticToValid(ctx, indexToHash(2)))
+	state, blk, err = prepareForkchoiceState(ctx, 3, indexToHash(3), indexToHash(2), indexToHash(103), 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	storeNodes[4] = f.store.nodeByRoot[blk.Root()]
-	state, blk, err = prepareForkchoiceState(ctx, 5, indexToHash(5), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1)
+	storeNodes[3] = f.store.fullNodeByRoot[blk.Root()]
+	state, blk, err = prepareForkchoiceState(ctx, 4, indexToHash(4), indexToHash(3), indexToHash(104), 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	storeNodes[5] = f.store.nodeByRoot[blk.Root()]
+	storeNodes[4] = f.store.fullNodeByRoot[blk.Root()]
+	state, blk, err = prepareForkchoiceState(ctx, 5, indexToHash(5), indexToHash(1), indexToHash(105), 1, 1)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, state, blk))
+	storeNodes[5] = f.store.fullNodeByRoot[blk.Root()]
 
 	opt, err := f.IsOptimistic(indexToHash(5))
 	require.NoError(t, err)
@@ -223,7 +226,7 @@ func TestNode_SetFullyValidated(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, true, opt)
 
-	require.NoError(t, f.store.nodeByRoot[indexToHash(4)].setNodeAndParentValidated(ctx))
+	require.NoError(t, f.store.setNodeAndParentValidated(ctx, f.store.fullNodeByRoot[indexToHash(4)]))
 
 	// block 5 should still be optimistic
 	opt, err = f.IsOptimistic(indexToHash(5))
@@ -240,20 +243,20 @@ func TestNode_SetFullyValidated(t *testing.T) {
 	require.Equal(t, false, opt)
 
 	respNodes := make([]*forkchoice.Node, 0)
-	respNodes, err = f.store.treeRootNode.nodeTreeDump(ctx, respNodes)
+	respNodes, err = f.store.nodeTreeDump(ctx, f.store.treeRootNode, respNodes)
 	require.NoError(t, err)
 	require.Equal(t, len(respNodes), f.NodeCount())
 
 	for i, respNode := range respNodes {
-		require.Equal(t, storeNodes[i].slot, respNode.Slot)
-		require.DeepEqual(t, storeNodes[i].root[:], respNode.BlockRoot)
-		require.Equal(t, storeNodes[i].balance, respNode.Balance)
-		require.Equal(t, storeNodes[i].weight, respNode.Weight)
+		require.Equal(t, storeNodes[i].node.slot, respNode.Slot)
+		require.DeepEqual(t, storeNodes[i].node.root[:], respNode.BlockRoot)
+		require.Equal(t, storeNodes[i].node.balance, respNode.Balance)
+		require.Equal(t, storeNodes[i].node.weight, respNode.Weight)
 		require.Equal(t, storeNodes[i].optimistic, respNode.ExecutionOptimistic)
-		require.Equal(t, storeNodes[i].justifiedEpoch, respNode.JustifiedEpoch)
-		require.Equal(t, storeNodes[i].unrealizedJustifiedEpoch, respNode.UnrealizedJustifiedEpoch)
-		require.Equal(t, storeNodes[i].finalizedEpoch, respNode.FinalizedEpoch)
-		require.Equal(t, storeNodes[i].unrealizedFinalizedEpoch, respNode.UnrealizedFinalizedEpoch)
+		require.Equal(t, storeNodes[i].node.justifiedEpoch, respNode.JustifiedEpoch)
+		require.Equal(t, storeNodes[i].node.unrealizedJustifiedEpoch, respNode.UnrealizedJustifiedEpoch)
+		require.Equal(t, storeNodes[i].node.finalizedEpoch, respNode.FinalizedEpoch)
+		require.Equal(t, storeNodes[i].node.unrealizedFinalizedEpoch, respNode.UnrealizedFinalizedEpoch)
 		require.Equal(t, storeNodes[i].timestamp, respNode.Timestamp)
 	}
 }
@@ -272,10 +275,10 @@ func TestNode_TimeStampsChecks(t *testing.T) {
 	headRoot, err := f.Head(ctx)
 	require.NoError(t, err)
 	require.Equal(t, root, headRoot)
-	early, err := f.store.headNode.arrivedEarly(f.store.genesisTime)
+	early, err := f.store.choosePayloadContent(f.store.headNode).arrivedEarly(f.store.genesisTime)
 	require.NoError(t, err)
 	require.Equal(t, true, early)
-	late, err := f.store.headNode.arrivedAfterOrphanCheck(f.store.genesisTime)
+	late, err := f.store.choosePayloadContent(f.store.headNode).arrivedAfterOrphanCheck(f.store.genesisTime)
 	require.NoError(t, err)
 	require.Equal(t, false, late)
 
@@ -289,10 +292,10 @@ func TestNode_TimeStampsChecks(t *testing.T) {
 	headRoot, err = f.Head(ctx)
 	require.NoError(t, err)
 	require.Equal(t, root, headRoot)
-	early, err = f.store.headNode.arrivedEarly(f.store.genesisTime)
+	early, err = f.store.choosePayloadContent(f.store.headNode).arrivedEarly(f.store.genesisTime)
 	require.NoError(t, err)
 	require.Equal(t, false, early)
-	late, err = f.store.headNode.arrivedAfterOrphanCheck(f.store.genesisTime)
+	late, err = f.store.choosePayloadContent(f.store.headNode).arrivedAfterOrphanCheck(f.store.genesisTime)
 	require.NoError(t, err)
 	require.Equal(t, false, late)
 
@@ -305,10 +308,10 @@ func TestNode_TimeStampsChecks(t *testing.T) {
 	headRoot, err = f.Head(ctx)
 	require.NoError(t, err)
 	require.Equal(t, root, headRoot)
-	early, err = f.store.headNode.arrivedEarly(f.store.genesisTime)
+	early, err = f.store.choosePayloadContent(f.store.headNode).arrivedEarly(f.store.genesisTime)
 	require.NoError(t, err)
 	require.Equal(t, false, early)
-	late, err = f.store.headNode.arrivedAfterOrphanCheck(f.store.genesisTime)
+	late, err = f.store.choosePayloadContent(f.store.headNode).arrivedAfterOrphanCheck(f.store.genesisTime)
 	require.NoError(t, err)
 	require.Equal(t, true, late)
 
@@ -320,10 +323,10 @@ func TestNode_TimeStampsChecks(t *testing.T) {
 	headRoot, err = f.Head(ctx)
 	require.NoError(t, err)
 	require.Equal(t, root, headRoot)
-	early, err = f.store.headNode.arrivedEarly(f.store.genesisTime)
+	early, err = f.store.choosePayloadContent(f.store.headNode).arrivedEarly(f.store.genesisTime)
 	require.ErrorContains(t, "invalid timestamp", err)
 	require.Equal(t, true, early)
-	late, err = f.store.headNode.arrivedAfterOrphanCheck(f.store.genesisTime)
+	late, err = f.store.choosePayloadContent(f.store.headNode).arrivedAfterOrphanCheck(f.store.genesisTime)
 	require.ErrorContains(t, "invalid timestamp", err)
 	require.Equal(t, false, late)
 }

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

@@ -7,93 +7,141 @@ import (
 	"github.com/pkg/errors"
 )
 
-func (s *Store) setOptimisticToInvalid(ctx context.Context, root, parentRoot, lastValidHash [32]byte) ([][32]byte, error) {
+// setOptimisticToInvalid removes invalid nodes from forkchoice. It does NOT remove the empty node for the passed root.
+func (s *Store) setOptimisticToInvalid(ctx context.Context, root, parentRoot, parentHash, lastValidHash [32]byte) ([][32]byte, error) {
 	invalidRoots := make([][32]byte, 0)
-	node, ok := s.nodeByRoot[root]
-	if !ok {
-		node, ok = s.nodeByRoot[parentRoot]
-		if !ok || node == nil {
-			return invalidRoots, errors.Wrap(ErrNilNode, "could not set node to invalid")
+	n := s.fullNodeByRoot[root]
+	if n == nil {
+		// The offending node with its payload is not in forkchoice. Try with the parent
+		n = s.emptyNodeByRoot[parentRoot]
+		if n == nil {
+			return invalidRoots, errors.Wrap(ErrNilNode, "could not set node to invalid, could not find consensus parent")
 		}
-		// return early if the parent is LVH
-		if node.payloadHash == lastValidHash {
+		if n.node.blockHash == lastValidHash {
+			// The parent node must have been full and with a valid payload
 			return invalidRoots, nil
 		}
-	} else {
-		if node == nil {
-			return invalidRoots, errors.Wrap(ErrNilNode, "could not set node to invalid")
+		if n.node.blockHash == parentHash {
+			// The parent was full and invalid
+			n = s.fullNodeByRoot[parentRoot]
+			if n == nil {
+				return invalidRoots, errors.Wrap(ErrNilNode, "could not set node to invalid, could not find full parent")
+			}
+		} else {
+			// The parent is empty and we don't yet know if it's valid or not
+			for n = n.node.parent; n != nil; n = n.node.parent {
+				if ctx.Err() != nil {
+					return invalidRoots, ctx.Err()
+				}
+				if n.node.blockHash == lastValidHash {
+					// The node built on empty and the whole chain was valid
+					return invalidRoots, nil
+				}
+				if n.node.blockHash == parentHash {
+					// The parent was full and invalid
+					break
+				}
+			}
+			if n == nil {
+				return nil, errors.Wrap(ErrNilNode, "could not set node to invalid, could not find full parent in ancestry")
+			}
 		}
-		if node.parent.root != parentRoot {
-			return invalidRoots, errInvalidParentRoot
+	} else {
+		// check consistency with the parent information
+		if n.node.parent == nil {
+			return nil, ErrNilNode
+		}
+		if n.node.parent.node.root != parentRoot {
+			return nil, errInvalidParentRoot
 		}
 	}
-	firstInvalid := node
-	for ; firstInvalid.parent != nil && firstInvalid.parent.payloadHash != lastValidHash; firstInvalid = firstInvalid.parent {
+	// n points to a full node that has an invalid payload in forkchoice. We need to find the fist node in the chain that is actually invalid.
+	startNode := n
+	fp := s.fullParent(n)
+	for ; fp != nil && fp.node.blockHash != lastValidHash; fp = s.fullParent(fp) {
 		if ctx.Err() != nil {
 			return invalidRoots, ctx.Err()
 		}
+		n = fp
 	}
 	// Deal with the case that the last valid payload is in a different fork
 	// This means we are dealing with an EE that does not follow the spec
-	if firstInvalid.parent == nil {
+	if fp == nil {
 		// return early if the invalid node was not imported
-		if node.root == parentRoot {
+		if startNode.node.root != root {
 			return invalidRoots, nil
 		}
-		firstInvalid = node
+		// Remove just the imported invalid root
+		n = startNode
 	}
-	return s.removeNode(ctx, firstInvalid)
+	return s.removeNode(ctx, n)
 }
 
 // removeNode removes the node with the given root and all of its children
 // from the Fork Choice Store.
-func (s *Store) removeNode(ctx context.Context, node *Node) ([][32]byte, error) {
+func (s *Store) removeNode(ctx context.Context, pn *PayloadNode) ([][32]byte, error) {
 	invalidRoots := make([][32]byte, 0)
 
-	if node == nil {
+	if pn == nil {
 		return invalidRoots, errors.Wrap(ErrNilNode, "could not remove node")
 	}
-	if !node.optimistic || node.parent == nil {
+	if !pn.optimistic || pn.node.parent == nil {
 		return invalidRoots, errInvalidOptimisticStatus
 	}
-
-	children := node.parent.children
+	children := pn.node.parent.children
 	if len(children) == 1 {
-		node.parent.children = []*Node{}
+		pn.node.parent.children = []*Node{}
 	} else {
 		for i, n := range children {
-			if n == node {
+			if n == pn.node {
 				if i != len(children)-1 {
 					children[i] = children[len(children)-1]
 				}
-				node.parent.children = children[:len(children)-1]
+				pn.node.parent.children = children[:len(children)-1]
 				break
 			}
 		}
 	}
-	return s.removeNodeAndChildren(ctx, node, invalidRoots)
+	return s.removeNodeAndChildren(ctx, pn, invalidRoots)
 }
 
 // removeNodeAndChildren removes `node` and all of its descendant from the Store
-func (s *Store) removeNodeAndChildren(ctx context.Context, node *Node, invalidRoots [][32]byte) ([][32]byte, error) {
+func (s *Store) removeNodeAndChildren(ctx context.Context, pn *PayloadNode, invalidRoots [][32]byte) ([][32]byte, error) {
 	var err error
-	for _, child := range node.children {
+	// If we are removing an empty node, then remove the full node as well if it exists.
+	if !pn.full {
+		fn, ok := s.fullNodeByRoot[pn.node.root]
+		if ok {
+			invalidRoots, err = s.removeNodeAndChildren(ctx, fn, invalidRoots)
+			if err != nil {
+				return invalidRoots, err
+			}
+		}
+	}
+	// Now we remove the full node's children.
+	for _, child := range pn.children {
 		if ctx.Err() != nil {
 			return invalidRoots, ctx.Err()
 		}
-		if invalidRoots, err = s.removeNodeAndChildren(ctx, child, invalidRoots); err != nil {
+		// We need to remove only the empty node here since the recursion will take care of the full one.
+		en := s.emptyNodeByRoot[child.root]
+		if invalidRoots, err = s.removeNodeAndChildren(ctx, en, invalidRoots); err != nil {
 			return invalidRoots, err
 		}
 	}
-	invalidRoots = append(invalidRoots, node.root)
-	if node.root == s.proposerBoostRoot {
-		s.proposerBoostRoot = [32]byte{}
+	// Only append the root for the empty nodes.
+	if pn.full {
+		delete(s.fullNodeByRoot, pn.node.root)
+	} else {
+		invalidRoots = append(invalidRoots, pn.node.root)
+		if pn.node.root == s.proposerBoostRoot {
+			s.proposerBoostRoot = [32]byte{}
+		}
+		if pn.node.root == s.previousProposerBoostRoot {
+			s.previousProposerBoostRoot = params.BeaconConfig().ZeroHash
+			s.previousProposerBoostScore = 0
+		}
+		delete(s.emptyNodeByRoot, pn.node.root)
 	}
-	if node.root == s.previousProposerBoostRoot {
-		s.previousProposerBoostRoot = params.BeaconConfig().ZeroHash
-		s.previousProposerBoostScore = 0
-	}
-	delete(s.nodeByRoot, node.root)
-	delete(s.nodeByPayload, node.payloadHash)
 	return invalidRoots, nil
 }

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

@@ -23,93 +23,35 @@ import (
 // And every block in the Fork choice is optimistic.
 func TestPruneInvalid(t *testing.T) {
 	tests := []struct {
+		name             string
 		root             [32]byte // the root of the new INVALID block
 		parentRoot       [32]byte // the root of the parent block
-		payload          [32]byte // the last valid hash
+		parentHash       [32]byte // the execution hash of the parent block
+		lastValidHash    [32]byte // the last valid execution hash
 		wantedNodeNumber int
 		wantedRoots      [][32]byte
 		wantedErr        error
 	}{
 		{ // Bogus LVH, root not in forkchoice
-			[32]byte{'x'},
-			[32]byte{'i'},
-			[32]byte{'R'},
-			13,
-			[][32]byte{},
-			nil,
+			name: "bogus LVH not in forkchoice",
+			root: [32]byte{'x'}, parentRoot: [32]byte{'i'}, parentHash: [32]byte{'I'}, lastValidHash: [32]byte{'R'},
+			wantedNodeNumber: 13, wantedRoots: [][32]byte{},
+		},
+		{ // Bogus LVH
+			name: "bogus LVH",
+			root: [32]byte{'i'}, parentRoot: [32]byte{'h'}, parentHash: [32]byte{'H'}, lastValidHash: [32]byte{'R'},
+			wantedNodeNumber: 13, wantedRoots: [][32]byte{},
 		},
 		{
-			// Bogus LVH
-			[32]byte{'i'},
-			[32]byte{'h'},
-			[32]byte{'R'},
-			12,
-			[][32]byte{{'i'}},
-			nil,
+			name: "wanted j",
+			root: [32]byte{'j'}, parentRoot: [32]byte{'b'}, parentHash: [32]byte{'B'}, lastValidHash: [32]byte{'B'},
+			wantedNodeNumber: 13, wantedRoots: [][32]byte{},
 		},
 		{
-			[32]byte{'j'},
-			[32]byte{'b'},
-			[32]byte{'B'},
-			12,
-			[][32]byte{{'j'}},
-			nil,
-		},
-		{
-			[32]byte{'c'},
-			[32]byte{'b'},
-			[32]byte{'B'},
-			4,
-			[][32]byte{{'f'}, {'e'}, {'i'}, {'h'}, {'l'},
-				{'k'}, {'g'}, {'d'}, {'c'}},
-			nil,
-		},
-		{
-			[32]byte{'i'},
-			[32]byte{'h'},
-			[32]byte{'H'},
-			12,
-			[][32]byte{{'i'}},
-			nil,
-		},
-		{
-			[32]byte{'h'},
-			[32]byte{'g'},
-			[32]byte{'G'},
-			11,
-			[][32]byte{{'i'}, {'h'}},
-			nil,
-		},
-		{
-			[32]byte{'g'},
-			[32]byte{'d'},
-			[32]byte{'D'},
-			8,
-			[][32]byte{{'i'}, {'h'}, {'l'}, {'k'}, {'g'}},
-			nil,
-		},
-		{
-			[32]byte{'i'},
-			[32]byte{'h'},
-			[32]byte{'D'},
-			8,
-			[][32]byte{{'i'}, {'h'}, {'l'}, {'k'}, {'g'}},
-			nil,
-		},
-		{
-			[32]byte{'f'},
-			[32]byte{'e'},
-			[32]byte{'D'},
-			11,
-			[][32]byte{{'f'}, {'e'}},
-			nil,
-		},
-		{
-			[32]byte{'h'},
-			[32]byte{'g'},
-			[32]byte{'C'},
-			5,
-			[][32]byte{
+			name: "wanted 5",
+			root: [32]byte{'c'}, parentRoot: [32]byte{'b'}, parentHash: [32]byte{'B'}, lastValidHash: [32]byte{'B'},
+			wantedNodeNumber: 5,
+			wantedRoots: [][32]byte{
 				{'f'},
 				{'e'},
 				{'i'},
@@ -119,106 +61,118 @@ func TestPruneInvalid(t *testing.T) {
 				{'g'},
 				{'d'},
 			},
-			nil,
 		},
 		{
-			[32]byte{'g'},
-			[32]byte{'d'},
-			[32]byte{'E'},
-			8,
-			[][32]byte{{'i'}, {'h'}, {'l'}, {'k'}, {'g'}},
-			nil,
+			name: "wanted i",
+			root: [32]byte{'i'}, parentRoot: [32]byte{'h'}, parentHash: [32]byte{'H'}, lastValidHash: [32]byte{'H'},
+			wantedNodeNumber: 13, wantedRoots: [][32]byte{},
 		},
 		{
-			[32]byte{'z'},
-			[32]byte{'j'},
-			[32]byte{'B'},
-			12,
-			[][32]byte{{'j'}},
-			nil,
+			name: "wanted i and h",
+			root: [32]byte{'h'}, parentRoot: [32]byte{'g'}, parentHash: [32]byte{'G'}, lastValidHash: [32]byte{'G'},
+			wantedNodeNumber: 12, wantedRoots: [][32]byte{{'i'}},
 		},
 		{
-			[32]byte{'z'},
-			[32]byte{'j'},
-			[32]byte{'J'},
-			13,
-			[][32]byte{},
-			nil,
+			name: "wanted i--g",
+			root: [32]byte{'g'}, parentRoot: [32]byte{'d'}, parentHash: [32]byte{'D'}, lastValidHash: [32]byte{'D'},
+			wantedNodeNumber: 9, wantedRoots: [][32]byte{{'i'}, {'h'}, {'l'}, {'k'}},
 		},
 		{
-			[32]byte{'j'},
-			[32]byte{'a'},
-			[32]byte{'B'},
-			0,
-			[][32]byte{},
-			errInvalidParentRoot,
+			name: "wanted 9",
+			root: [32]byte{'i'}, parentRoot: [32]byte{'h'}, parentHash: [32]byte{'H'}, lastValidHash: [32]byte{'D'},
+			wantedNodeNumber: 9, wantedRoots: [][32]byte{{'i'}, {'h'}, {'l'}, {'k'}},
 		},
 		{
-			[32]byte{'z'},
-			[32]byte{'h'},
-			[32]byte{'D'},
-			8,
-			[][32]byte{{'i'}, {'h'}, {'l'}, {'k'}, {'g'}},
-			nil,
+			name: "wanted f and e",
+			root: [32]byte{'f'}, parentRoot: [32]byte{'e'}, parentHash: [32]byte{'E'}, lastValidHash: [32]byte{'D'},
+			wantedNodeNumber: 12, wantedRoots: [][32]byte{{'f'}},
 		},
 		{
-			[32]byte{'z'},
-			[32]byte{'h'},
-			[32]byte{'D'},
-			8,
-			[][32]byte{{'i'}, {'h'}, {'l'}, {'k'}, {'g'}},
-			nil,
+			name: "wanted 6",
+			root: [32]byte{'h'}, parentRoot: [32]byte{'g'}, parentHash: [32]byte{'G'}, lastValidHash: [32]byte{'C'},
+			wantedNodeNumber: 6,
+			wantedRoots: [][32]byte{
+				{'f'}, {'e'}, {'i'}, {'h'}, {'l'}, {'k'}, {'g'},
+			},
+		},
+		{
+			name: "wanted 9 again",
+			root: [32]byte{'g'}, parentRoot: [32]byte{'d'}, parentHash: [32]byte{'D'}, lastValidHash: [32]byte{'E'},
+			wantedNodeNumber: 9, wantedRoots: [][32]byte{{'i'}, {'h'}, {'l'}, {'k'}},
+		},
+		{
+			name: "wanted 13",
+			root: [32]byte{'z'}, parentRoot: [32]byte{'j'}, parentHash: [32]byte{'J'}, lastValidHash: [32]byte{'B'},
+			wantedNodeNumber: 13, wantedRoots: [][32]byte{},
+		},
+		{
+			name: "wanted empty",
+			root: [32]byte{'z'}, parentRoot: [32]byte{'j'}, parentHash: [32]byte{'J'}, lastValidHash: [32]byte{'J'},
+			wantedNodeNumber: 13, wantedRoots: [][32]byte{},
+		},
+		{
+			name: "errInvalidParentRoot",
+			root: [32]byte{'j'}, parentRoot: [32]byte{'a'}, parentHash: [32]byte{'A'}, lastValidHash: [32]byte{'B'},
+			wantedErr: errInvalidParentRoot,
+		},
+		{
+			name: "root z",
+			root: [32]byte{'z'}, parentRoot: [32]byte{'h'}, parentHash: [32]byte{'H'}, lastValidHash: [32]byte{'D'},
+			wantedNodeNumber: 9, wantedRoots: [][32]byte{{'i'}, {'h'}, {'l'}, {'k'}},
 		},
 	}
 	for _, tc := range tests {
-		ctx := t.Context()
-		f := setup(1, 1)
-
-		state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
-		require.NoError(t, err)
-		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
-		require.NoError(t, err)
-		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		state, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 1)
-		require.NoError(t, err)
-		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		state, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'j'}, [32]byte{'b'}, [32]byte{'J'}, 1, 1)
-		require.NoError(t, err)
-		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		state, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{'c'}, [32]byte{'D'}, 1, 1)
-		require.NoError(t, err)
-		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		state, blkRoot, err = prepareForkchoiceState(ctx, 104, [32]byte{'e'}, [32]byte{'d'}, [32]byte{'E'}, 1, 1)
-		require.NoError(t, err)
-		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		state, blkRoot, err = prepareForkchoiceState(ctx, 104, [32]byte{'g'}, [32]byte{'d'}, [32]byte{'G'}, 1, 1)
-		require.NoError(t, err)
-		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		state, blkRoot, err = prepareForkchoiceState(ctx, 105, [32]byte{'f'}, [32]byte{'e'}, [32]byte{'F'}, 1, 1)
-		require.NoError(t, err)
-		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		state, blkRoot, err = prepareForkchoiceState(ctx, 105, [32]byte{'h'}, [32]byte{'g'}, [32]byte{'H'}, 1, 1)
-		require.NoError(t, err)
-		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		state, blkRoot, err = prepareForkchoiceState(ctx, 105, [32]byte{'k'}, [32]byte{'g'}, [32]byte{'K'}, 1, 1)
-		require.NoError(t, err)
-		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		state, blkRoot, err = prepareForkchoiceState(ctx, 106, [32]byte{'i'}, [32]byte{'h'}, [32]byte{'I'}, 1, 1)
-		require.NoError(t, err)
-		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		state, blkRoot, err = prepareForkchoiceState(ctx, 106, [32]byte{'l'}, [32]byte{'k'}, [32]byte{'L'}, 1, 1)
-		require.NoError(t, err)
-		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-
-		roots, err := f.store.setOptimisticToInvalid(t.Context(), tc.root, tc.parentRoot, tc.payload)
-		if tc.wantedErr == nil {
+		t.Run(tc.name, func(t *testing.T) {
+			ctx := t.Context()
+			f := setup(1, 1)
+			require.NoError(t, f.SetOptimisticToValid(ctx, [32]byte{}))
+			state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
 			require.NoError(t, err)
-			require.DeepEqual(t, tc.wantedRoots, roots)
-			require.Equal(t, tc.wantedNodeNumber, f.NodeCount())
-		} else {
-			require.ErrorIs(t, tc.wantedErr, err)
-		}
+			require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+			state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
+			require.NoError(t, err)
+			require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+			state, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 1)
+			require.NoError(t, err)
+			require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+			state, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'j'}, [32]byte{'b'}, [32]byte{'J'}, 1, 1)
+			require.NoError(t, err)
+			require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+			state, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{'c'}, [32]byte{'D'}, 1, 1)
+			require.NoError(t, err)
+			require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+			state, blkRoot, err = prepareForkchoiceState(ctx, 104, [32]byte{'e'}, [32]byte{'d'}, [32]byte{'E'}, 1, 1)
+			require.NoError(t, err)
+			require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+			state, blkRoot, err = prepareForkchoiceState(ctx, 104, [32]byte{'g'}, [32]byte{'d'}, [32]byte{'G'}, 1, 1)
+			require.NoError(t, err)
+			require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+			state, blkRoot, err = prepareForkchoiceState(ctx, 105, [32]byte{'f'}, [32]byte{'e'}, [32]byte{'F'}, 1, 1)
+			require.NoError(t, err)
+			require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+			state, blkRoot, err = prepareForkchoiceState(ctx, 105, [32]byte{'h'}, [32]byte{'g'}, [32]byte{'H'}, 1, 1)
+			require.NoError(t, err)
+			require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+			state, blkRoot, err = prepareForkchoiceState(ctx, 105, [32]byte{'k'}, [32]byte{'g'}, [32]byte{'K'}, 1, 1)
+			require.NoError(t, err)
+			require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+			state, blkRoot, err = prepareForkchoiceState(ctx, 106, [32]byte{'i'}, [32]byte{'h'}, [32]byte{'I'}, 1, 1)
+			require.NoError(t, err)
+			require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+			state, blkRoot, err = prepareForkchoiceState(ctx, 106, [32]byte{'l'}, [32]byte{'k'}, [32]byte{'L'}, 1, 1)
+			require.NoError(t, err)
+			require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+
+			roots, err := f.store.setOptimisticToInvalid(t.Context(), tc.root, tc.parentRoot, tc.parentHash, tc.lastValidHash)
+			if tc.wantedErr == nil {
+				require.NoError(t, err)
+				require.Equal(t, len(tc.wantedRoots), len(roots))
+				require.DeepEqual(t, tc.wantedRoots, roots)
+				require.Equal(t, tc.wantedNodeNumber, f.NodeCount())
+			} else {
+				require.ErrorIs(t, tc.wantedErr, err)
+			}
+		})
 	}
 }
 
@@ -240,11 +194,40 @@ func TestSetOptimisticToInvalid_ProposerBoost(t *testing.T) {
 	f.store.previousProposerBoostScore = 10
 	f.store.previousProposerBoostRoot = [32]byte{'b'}
 
-	_, err = f.SetOptimisticToInvalid(ctx, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'A'})
+	_, err = f.SetOptimisticToInvalid(ctx, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'B'}, [32]byte{'A'})
 	require.NoError(t, err)
+	// proposer boost is still applied to c
+	require.Equal(t, uint64(10), f.store.previousProposerBoostScore)
+	require.Equal(t, [32]byte{}, f.store.proposerBoostRoot)
+	require.Equal(t, [32]byte{'b'}, f.store.previousProposerBoostRoot)
+}
+
+func TestSetOptimisticToInvalid_ProposerBoost_Older(t *testing.T) {
+	ctx := t.Context()
+	f := setup(1, 1)
+
+	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+	state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+	state, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 1)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+	state, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{'c'}, [32]byte{'D'}, 1, 1)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+	f.store.proposerBoostRoot = [32]byte{'d'}
+	f.store.previousProposerBoostScore = 10
+	f.store.previousProposerBoostRoot = [32]byte{'c'}
+
+	_, err = f.SetOptimisticToInvalid(ctx, [32]byte{'d'}, [32]byte{'c'}, [32]byte{'C'}, [32]byte{'A'})
+	require.NoError(t, err)
+	// proposer boost is still applied to c
 	require.Equal(t, uint64(0), f.store.previousProposerBoostScore)
-	require.DeepEqual(t, [32]byte{}, f.store.proposerBoostRoot)
-	require.DeepEqual(t, params.BeaconConfig().ZeroHash, f.store.previousProposerBoostRoot)
+	require.Equal(t, [32]byte{}, f.store.proposerBoostRoot)
+	require.Equal(t, [32]byte{}, f.store.previousProposerBoostRoot)
 }
 
 // This is a regression test (10565)
@@ -272,10 +255,9 @@ func TestSetOptimisticToInvalid_CorrectChildren(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
-	_, err = f.store.setOptimisticToInvalid(ctx, [32]byte{'d'}, [32]byte{'a'}, [32]byte{'A'})
+	_, err = f.store.setOptimisticToInvalid(ctx, [32]byte{'d'}, [32]byte{'a'}, [32]byte{'A'}, [32]byte{'A'})
 	require.NoError(t, err)
-	require.Equal(t, 2, len(f.store.nodeByRoot[[32]byte{'a'}].children))
-
+	require.Equal(t, 2, len(f.store.fullNodeByRoot[[32]byte{'a'}].children))
 }
 
 // Pow       |      Pos
@@ -322,13 +304,13 @@ func TestSetOptimisticToInvalid_ForkAtMerge(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, root))
 
-	roots, err := f.SetOptimisticToInvalid(ctx, [32]byte{'x'}, [32]byte{'d'}, [32]byte{})
+	roots, err := f.SetOptimisticToInvalid(ctx, [32]byte{'x'}, [32]byte{'d'}, [32]byte{'D'}, [32]byte{})
 	require.NoError(t, err)
-	require.Equal(t, 4, len(roots))
+	require.Equal(t, 3, len(roots))
 	sort.Slice(roots, func(i, j int) bool {
 		return bytesutil.BytesToUint64BigEndian(roots[i][:]) < bytesutil.BytesToUint64BigEndian(roots[j][:])
 	})
-	require.DeepEqual(t, roots, [][32]byte{{'b'}, {'c'}, {'d'}, {'e'}})
+	require.DeepEqual(t, roots, [][32]byte{{'c'}, {'d'}, {'e'}})
 }
 
 // Pow       |      Pos
@@ -375,13 +357,13 @@ func TestSetOptimisticToInvalid_ForkAtMerge_bis(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, root))
 
-	roots, err := f.SetOptimisticToInvalid(ctx, [32]byte{'x'}, [32]byte{'d'}, [32]byte{})
+	roots, err := f.SetOptimisticToInvalid(ctx, [32]byte{'x'}, [32]byte{'d'}, [32]byte{'D'}, [32]byte{})
 	require.NoError(t, err)
-	require.Equal(t, 4, len(roots))
+	require.Equal(t, 3, len(roots))
 	sort.Slice(roots, func(i, j int) bool {
 		return bytesutil.BytesToUint64BigEndian(roots[i][:]) < bytesutil.BytesToUint64BigEndian(roots[j][:])
 	})
-	require.DeepEqual(t, roots, [][32]byte{{'b'}, {'c'}, {'d'}, {'e'}})
+	require.DeepEqual(t, roots, [][32]byte{{'c'}, {'d'}, {'e'}})
 }
 
 func TestSetOptimisticToValid(t *testing.T) {

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

@@ -11,7 +11,7 @@ func (f *ForkChoice) applyProposerBoostScore() error {
 	s := f.store
 	proposerScore := uint64(0)
 	if s.previousProposerBoostRoot != params.BeaconConfig().ZeroHash {
-		previousNode, ok := s.nodeByRoot[s.previousProposerBoostRoot]
+		previousNode, ok := s.emptyNodeByRoot[s.previousProposerBoostRoot]
 		if !ok || previousNode == nil {
 			log.WithError(errInvalidProposerBoostRoot).Errorf("invalid prev root %#x", s.previousProposerBoostRoot)
 		} else {
@@ -20,7 +20,7 @@ func (f *ForkChoice) applyProposerBoostScore() error {
 	}
 
 	if s.proposerBoostRoot != params.BeaconConfig().ZeroHash {
-		currentNode, ok := s.nodeByRoot[s.proposerBoostRoot]
+		currentNode, ok := s.emptyNodeByRoot[s.proposerBoostRoot]
 		if !ok || currentNode == nil {
 			log.WithError(errInvalidProposerBoostRoot).Errorf("invalid current root %#x", s.proposerBoostRoot)
 		} else {

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

@@ -166,14 +166,14 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		// (1: 48) -> (2: 38) -> (3: 10)
 		//		    \--------------->(4: 18)
 		//
-		node1 := f.store.nodeByRoot[indexToHash(1)]
-		require.Equal(t, node1.weight, uint64(48))
-		node2 := f.store.nodeByRoot[indexToHash(2)]
-		require.Equal(t, node2.weight, uint64(38))
-		node3 := f.store.nodeByRoot[indexToHash(3)]
-		require.Equal(t, node3.weight, uint64(10))
-		node4 := f.store.nodeByRoot[indexToHash(4)]
-		require.Equal(t, node4.weight, uint64(18))
+		node1 := f.store.emptyNodeByRoot[indexToHash(1)]
+		require.Equal(t, node1.node.weight, uint64(48))
+		node2 := f.store.emptyNodeByRoot[indexToHash(2)]
+		require.Equal(t, node2.node.weight, uint64(38))
+		node3 := f.store.emptyNodeByRoot[indexToHash(3)]
+		require.Equal(t, node3.node.weight, uint64(10))
+		node4 := f.store.emptyNodeByRoot[indexToHash(4)]
+		require.Equal(t, node4.node.weight, uint64(18))
 
 		// Regression: process attestations for C, check that it
 		// becomes head, we need two attestations to have C.weight = 30 > 24 = D.weight