increase crawl timeout

Co-authored-by: Manu NALEPA <enalepa@offchainlabs.com>

.github/workflows/go.yml

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

.gitignore

@@ -38,6 +38,7 @@ metaData
 
 # execution API authentication
 jwt.hex
+execution/
 
 # manual testing
 tmp

.golangci.yml

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

BUILD.bazel

@@ -1,4 +1,5 @@
 load("@bazel_gazelle//:def.bzl", "gazelle")
+load("@com_github_atlassian_bazel_tools//gometalinter:def.bzl", "gometalinter")
 load("@com_github_atlassian_bazel_tools//goimports:def.bzl", "goimports")
 load("@io_kubernetes_build//defs:run_in_workspace.bzl", "workspace_binary")
 load("@io_bazel_rules_go//go:def.bzl", "nogo")
@@ -54,6 +55,15 @@ alias(
     visibility = ["//visibility:public"],
 )
 
+gometalinter(
+    name = "gometalinter",
+    config = "//:.gometalinter.json",
+    paths = [
+        "./...",
+    ],
+    prefix = prefix,
+)
+
 goimports(
     name = "goimports",
     display_diffs = True,

CHANGELOG.md

@@ -4,25 +4,6 @@ All notable changes to this project will be documented in this file.
 
 The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.
 
-## [v7.1.2](https://github.com/prysmaticlabs/prysm/compare/v7.1.1...v7.1.2) - 2026-01-07
-
-Happy new year! This patch release is very small. The main improvement is better management of pending attestation aggregation via [PR 16153](https://github.com/OffchainLabs/prysm/pull/16153).
-
-### Added
-
-- `primitives.BuilderIndex`: SSZ `uint64` wrapper for builder registry indices. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16169)
-
-### Changed
-
-- the /eth/v2/beacon/pool/attestations and /eth/v1/beacon/pool/sync_committees now returns a 503 error if the node is still syncing, the rest api is also working in a similar process to gRPC broadcasting immediately now. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16152)
-- `validateDataColumn`: Remove error logs. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16157)
-- Pending aggregates: When multiple aggregated attestations only differing by the aggregator index are in the pending queue, only process one of them. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16153)
-
-### Fixed
-
-- Fix the missing fork version object mapping for Fulu in light client p2p. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16151)
-- Do not process slots and copy states for next epoch proposers after Fulu. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16168)
-
 ## [v7.1.1](https://github.com/prysmaticlabs/prysm/compare/v7.1.0...v7.1.1) - 2025-12-18
 
 Release highlights:

DEPENDENCIES.md

@@ -72,7 +72,7 @@ Do NOT add new `go_repository` to the WORKSPACE file. All dependencies should li
 
 To enable conditional compilation and custom configuration for tests (where compiled code has more 
 debug info, while not being completely optimized), we rely on Go's build tags/constraints mechanism 
-(see official docs on [build constraints](https://pkg.go.dev/go/build#hdr-Build_Constraints)). 
+(see official docs on [build constraints](https://golang.org/pkg/go/build/#hdr-Build_Constraints)). 
 Therefore, whenever using `go test`, do not forget to pass in extra build tag, eg:
 
 ```bash

INTEROP.md

@@ -9,7 +9,7 @@ This README details how to setup Prysm for interop testing for usage with other
 
 ## Installation & Setup
 
-1. Install [Bazel](https://bazel.build/install) **(Recommended)**
+1. Install [Bazel](https://docs.bazel.build/versions/master/install.html) **(Recommended)**
 2. `git clone https://github.com/OffchainLabs/prysm && cd prysm`
 3. `bazel build //cmd/...`
 

README.md

@@ -15,7 +15,7 @@
 
 ## 📖 Overview
 
-This is the core repository for Prysm, a [Golang](https://go.dev/) implementation of the [Ethereum Consensus](https://ethereum.org/en/developers/docs/consensus-mechanisms/#proof-of-stake) [specification](https://github.com/ethereum/consensus-specs), developed by [Offchain Labs](https://www.offchainlabs.com).
+This is the core repository for Prysm, a [Golang](https://golang.org/) implementation of the [Ethereum Consensus](https://ethereum.org/en/developers/docs/consensus-mechanisms/#proof-of-stake) [specification](https://github.com/ethereum/consensus-specs), developed by [Offchain Labs](https://www.offchainlabs.com).
 
 See the [Changelog](https://github.com/OffchainLabs/prysm/releases) for details of the latest releases and upcoming breaking changes.
 
@@ -23,7 +23,7 @@ See the [Changelog](https://github.com/OffchainLabs/prysm/releases) for details
 
 ## 🚀 Getting Started
 
-A detailed set of installation and usage instructions as well as breakdowns of each individual component are available in the **[official documentation portal](https://prysm.offchainlabs.com/docs/)**.
+A detailed set of installation and usage instructions as well as breakdowns of each individual component are available in the **[official documentation portal](https://docs.prylabs.network)**.
 
 💬 **Need help?** Join our **[Discord Community](https://discord.gg/prysm)** for support.
 
@@ -51,7 +51,7 @@ Prysm maintains two permanent branches:
 
 ### 🛠 Contribution Guide
 
-Want to get involved? Check out our **[Contribution Guide](https://prysm.offchainlabs.com/docs/contribute/contribution-guidelines/)** to learn more!
+Want to get involved? Check out our **[Contribution Guide](https://docs.prylabs.network/docs/contribute/contribution-guidelines/)** to learn more!
 
 ---
 

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.6.0"
 
 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-54hTaUNF9nLg+hRr3oHoq0yjZpW3MNiiUUuCQu6Rajk=",
+        "minimal": "sha256-1JHIGg3gVMjvcGYRHR5cwdDgOvX47oR/MWp6gyAeZfA=",
+        "mainnet": "sha256-292h3W2Ffts0YExgDTyxYe9Os7R0bZIXuAaMO8P6kl4=",
     },
     version = consensus_spec_version,
 )
@@ -298,7 +298,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-J+43DrK1pF658kTXTwMS6zGf4KDjvas++m8w2a8swpg=",
+    integrity = "sha256-VzBgrEokvYSMIIXVnSA5XS9I3m9oxpvToQGxC1N5lzw=",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )
@@ -423,6 +423,10 @@ load("@prysm//testing/endtoend:deps.bzl", "e2e_deps")
 
 e2e_deps()
 
+load("@com_github_atlassian_bazel_tools//gometalinter:deps.bzl", "gometalinter_dependencies")
+
+gometalinter_dependencies()
+
 load("@bazel_gazelle//:deps.bzl", "gazelle_dependencies")
 
 gazelle_dependencies(go_sdk = "go_sdk")

api/grpc/BUILD.bazel

@@ -3,16 +3,13 @@ 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",
@@ -21,17 +18,12 @@ go_library(
 
 go_test(
     name = "go_default_test",
-    srcs = [
-        "grpc_connection_provider_test.go",
-        "grpcutils_test.go",
-    ],
+    srcs = ["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

@@ -1,173 +0,0 @@
-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
-	// 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
-
-	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)
-
-	// 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) 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

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

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

api/rest/BUILD.bazel

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

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

@@ -1,49 +0,0 @@
-package rest
-
-import (
-	"bytes"
-	"context"
-	"net/http"
-)
-
-// MockRestProvider implements RestConnectionProvider for testing.
-type MockRestProvider struct {
-	MockClient  *http.Client
-	MockHandler RestHandler
-	MockHosts   []string
-	HostIndex   int
-}
-
-func (m *MockRestProvider) HttpClient() *http.Client { return m.MockClient }
-func (m *MockRestProvider) RestHandler() RestHandler { 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 }
-
-// MockRestHandler implements RestHandler for testing.
-type MockRestHandler struct {
-	MockHost   string
-	MockClient *http.Client
-}
-
-func (m *MockRestHandler) Get(_ context.Context, _ string, _ any) error { return nil }
-func (m *MockRestHandler) GetStatusCode(_ context.Context, _ string) (int, error) {
-	return http.StatusOK, nil
-}
-func (m *MockRestHandler) GetSSZ(_ context.Context, _ string) ([]byte, http.Header, error) {
-	return nil, nil, nil
-}
-func (m *MockRestHandler) Post(_ context.Context, _ string, _ map[string]string, _ *bytes.Buffer, _ any) error {
-	return nil
-}
-func (m *MockRestHandler) PostSSZ(_ context.Context, _ string, _ map[string]string, _ *bytes.Buffer) ([]byte, http.Header, error) {
-	return nil, nil, nil
-}
-func (m *MockRestHandler) HttpClient() *http.Client { return m.MockClient }
-func (m *MockRestHandler) Host() string             { return m.MockHost }
-func (m *MockRestHandler) SwitchHost(host string)   { m.MockHost = host }

api/rest/rest_connection_provider.go

@@ -1,158 +0,0 @@
-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
-	// RestHandler returns the REST handler for making API requests.
-	RestHandler() RestHandler
-	// 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   RestHandler
-	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 = newRestHandler(*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) RestHandler() RestHandler {
-	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

@@ -1,80 +0,0 @@
-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/server/structs/block.go

@@ -503,77 +503,3 @@ func (s *SignedBlindedBeaconBlockFulu) MessageRawJson() ([]byte, error) {
 func (s *SignedBlindedBeaconBlockFulu) SigString() string {
 	return s.Signature
 }
-
-// ----------------------------------------------------------------------------
-// Gloas
-// ----------------------------------------------------------------------------
-
-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"`
-}
-
-type SignedExecutionPayloadBid struct {
-	Message   *ExecutionPayloadBid `json:"message"`
-	Signature string               `json:"signature"`
-}
-
-type PayloadAttestationData struct {
-	BeaconBlockRoot   string `json:"beacon_block_root"`
-	Slot              string `json:"slot"`
-	PayloadPresent    bool   `json:"payload_present"`
-	BlobDataAvailable bool   `json:"blob_data_available"`
-}
-
-type PayloadAttestation struct {
-	AggregationBits string                  `json:"aggregation_bits"`
-	Data            *PayloadAttestationData `json:"data"`
-	Signature       string                  `json:"signature"`
-}
-
-type BeaconBlockBodyGloas struct {
-	RandaoReveal              string                        `json:"randao_reveal"`
-	Eth1Data                  *Eth1Data                     `json:"eth1_data"`
-	Graffiti                  string                        `json:"graffiti"`
-	ProposerSlashings         []*ProposerSlashing           `json:"proposer_slashings"`
-	AttesterSlashings         []*AttesterSlashingElectra    `json:"attester_slashings"`
-	Attestations              []*AttestationElectra         `json:"attestations"`
-	Deposits                  []*Deposit                    `json:"deposits"`
-	VoluntaryExits            []*SignedVoluntaryExit        `json:"voluntary_exits"`
-	SyncAggregate             *SyncAggregate                `json:"sync_aggregate"`
-	BLSToExecutionChanges     []*SignedBLSToExecutionChange `json:"bls_to_execution_changes"`
-	SignedExecutionPayloadBid *SignedExecutionPayloadBid    `json:"signed_execution_payload_bid"`
-	PayloadAttestations       []*PayloadAttestation         `json:"payload_attestations"`
-}
-
-type BeaconBlockGloas struct {
-	Slot          string                `json:"slot"`
-	ProposerIndex string                `json:"proposer_index"`
-	ParentRoot    string                `json:"parent_root"`
-	StateRoot     string                `json:"state_root"`
-	Body          *BeaconBlockBodyGloas `json:"body"`
-}
-
-type SignedBeaconBlockGloas struct {
-	Message   *BeaconBlockGloas `json:"message"`
-	Signature string            `json:"signature"`
-}
-
-var _ SignedMessageJsoner = &SignedBeaconBlockGloas{}
-
-func (s *SignedBeaconBlockGloas) MessageRawJson() ([]byte, error) {
-	return json.Marshal(s.Message)
-}
-
-func (s *SignedBeaconBlockGloas) SigString() string {
-	return s.Signature
-}

api/server/structs/conversions_block.go

@@ -268,8 +268,6 @@ func SignedBeaconBlockMessageJsoner(block interfaces.ReadOnlySignedBeaconBlock)
 		return SignedBlindedBeaconBlockFuluFromConsensus(pbStruct)
 	case *eth.SignedBeaconBlockFulu:
 		return SignedBeaconBlockFuluFromConsensus(pbStruct)
-	case *eth.SignedBeaconBlockGloas:
-		return SignedBeaconBlockGloasFromConsensus(pbStruct)
 	default:
 		return nil, ErrUnsupportedConversion
 	}
@@ -2887,379 +2885,3 @@ func SignedBeaconBlockFuluFromConsensus(b *eth.SignedBeaconBlockFulu) (*SignedBe
 		Signature: hexutil.Encode(b.Signature),
 	}, nil
 }
-
-// ----------------------------------------------------------------------------
-// Gloas
-// ----------------------------------------------------------------------------
-
-func SignedBeaconBlockGloasFromConsensus(b *eth.SignedBeaconBlockGloas) (*SignedBeaconBlockGloas, error) {
-	block, err := BeaconBlockGloasFromConsensus(b.Block)
-	if err != nil {
-		return nil, err
-	}
-	return &SignedBeaconBlockGloas{
-		Message:   block,
-		Signature: hexutil.Encode(b.Signature),
-	}, nil
-}
-
-func BeaconBlockGloasFromConsensus(b *eth.BeaconBlockGloas) (*BeaconBlockGloas, error) {
-	payloadAttestations := make([]*PayloadAttestation, len(b.Body.PayloadAttestations))
-	for i, pa := range b.Body.PayloadAttestations {
-		payloadAttestations[i] = PayloadAttestationFromConsensus(pa)
-	}
-
-	return &BeaconBlockGloas{
-		Slot:          fmt.Sprintf("%d", b.Slot),
-		ProposerIndex: fmt.Sprintf("%d", b.ProposerIndex),
-		ParentRoot:    hexutil.Encode(b.ParentRoot),
-		StateRoot:     hexutil.Encode(b.StateRoot),
-		Body: &BeaconBlockBodyGloas{
-			RandaoReveal:              hexutil.Encode(b.Body.RandaoReveal),
-			Eth1Data:                  Eth1DataFromConsensus(b.Body.Eth1Data),
-			Graffiti:                  hexutil.Encode(b.Body.Graffiti),
-			ProposerSlashings:         ProposerSlashingsFromConsensus(b.Body.ProposerSlashings),
-			AttesterSlashings:         AttesterSlashingsElectraFromConsensus(b.Body.AttesterSlashings),
-			Attestations:              AttsElectraFromConsensus(b.Body.Attestations),
-			Deposits:                  DepositsFromConsensus(b.Body.Deposits),
-			VoluntaryExits:            SignedExitsFromConsensus(b.Body.VoluntaryExits),
-			SyncAggregate:             SyncAggregateFromConsensus(b.Body.SyncAggregate),
-			BLSToExecutionChanges:     SignedBLSChangesFromConsensus(b.Body.BlsToExecutionChanges),
-			SignedExecutionPayloadBid: SignedExecutionPayloadBidFromConsensus(b.Body.SignedExecutionPayloadBid),
-			PayloadAttestations:       payloadAttestations,
-		},
-	}, nil
-}
-
-func SignedExecutionPayloadBidFromConsensus(b *eth.SignedExecutionPayloadBid) *SignedExecutionPayloadBid {
-	return &SignedExecutionPayloadBid{
-		Message:   ExecutionPayloadBidFromConsensus(b.Message),
-		Signature: hexutil.Encode(b.Signature),
-	}
-}
-
-func ExecutionPayloadBidFromConsensus(b *eth.ExecutionPayloadBid) *ExecutionPayloadBid {
-	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),
-	}
-}
-
-func PayloadAttestationFromConsensus(pa *eth.PayloadAttestation) *PayloadAttestation {
-	return &PayloadAttestation{
-		AggregationBits: hexutil.Encode(pa.AggregationBits),
-		Data:            PayloadAttestationDataFromConsensus(pa.Data),
-		Signature:       hexutil.Encode(pa.Signature),
-	}
-}
-
-func PayloadAttestationDataFromConsensus(d *eth.PayloadAttestationData) *PayloadAttestationData {
-	return &PayloadAttestationData{
-		BeaconBlockRoot:   hexutil.Encode(d.BeaconBlockRoot),
-		Slot:              fmt.Sprintf("%d", d.Slot),
-		PayloadPresent:    d.PayloadPresent,
-		BlobDataAvailable: d.BlobDataAvailable,
-	}
-}
-
-func (b *SignedBeaconBlockGloas) ToConsensus() (*eth.SignedBeaconBlockGloas, error) {
-	if b == nil {
-		return nil, errNilValue
-	}
-
-	sig, err := bytesutil.DecodeHexWithLength(b.Signature, fieldparams.BLSSignatureLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Signature")
-	}
-	block, err := b.Message.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Message")
-	}
-	return &eth.SignedBeaconBlockGloas{
-		Block:     block,
-		Signature: sig,
-	}, nil
-}
-
-func (b *BeaconBlockGloas) ToConsensus() (*eth.BeaconBlockGloas, error) {
-	if b == nil {
-		return nil, errNilValue
-	}
-	if b.Body == nil {
-		return nil, server.NewDecodeError(errNilValue, "Body")
-	}
-	if b.Body.Eth1Data == nil {
-		return nil, server.NewDecodeError(errNilValue, "Body.Eth1Data")
-	}
-	if b.Body.SyncAggregate == nil {
-		return nil, server.NewDecodeError(errNilValue, "Body.SyncAggregate")
-	}
-	if b.Body.SignedExecutionPayloadBid == nil {
-		return nil, server.NewDecodeError(errNilValue, "Body.SignedExecutionPayloadBid")
-	}
-
-	slot, err := strconv.ParseUint(b.Slot, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Slot")
-	}
-	proposerIndex, err := strconv.ParseUint(b.ProposerIndex, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "ProposerIndex")
-	}
-	parentRoot, err := bytesutil.DecodeHexWithLength(b.ParentRoot, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "ParentRoot")
-	}
-	stateRoot, err := bytesutil.DecodeHexWithLength(b.StateRoot, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "StateRoot")
-	}
-	body, err := b.Body.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Body")
-	}
-	return &eth.BeaconBlockGloas{
-		Slot:          primitives.Slot(slot),
-		ProposerIndex: primitives.ValidatorIndex(proposerIndex),
-		ParentRoot:    parentRoot,
-		StateRoot:     stateRoot,
-		Body:          body,
-	}, nil
-}
-
-func (b *BeaconBlockBodyGloas) ToConsensus() (*eth.BeaconBlockBodyGloas, error) {
-	if b == nil {
-		return nil, errNilValue
-	}
-
-	randaoReveal, err := bytesutil.DecodeHexWithLength(b.RandaoReveal, fieldparams.BLSSignatureLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "RandaoReveal")
-	}
-	depositRoot, err := bytesutil.DecodeHexWithLength(b.Eth1Data.DepositRoot, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Eth1Data.DepositRoot")
-	}
-	depositCount, err := strconv.ParseUint(b.Eth1Data.DepositCount, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Eth1Data.DepositCount")
-	}
-	blockHash, err := bytesutil.DecodeHexWithLength(b.Eth1Data.BlockHash, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Eth1Data.BlockHash")
-	}
-	graffiti, err := bytesutil.DecodeHexWithLength(b.Graffiti, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Graffiti")
-	}
-	proposerSlashings, err := ProposerSlashingsToConsensus(b.ProposerSlashings)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "ProposerSlashings")
-	}
-	attesterSlashings, err := AttesterSlashingsElectraToConsensus(b.AttesterSlashings)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "AttesterSlashings")
-	}
-	atts, err := AttsElectraToConsensus(b.Attestations)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Attestations")
-	}
-	deposits, err := DepositsToConsensus(b.Deposits)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Deposits")
-	}
-	exits, err := SignedExitsToConsensus(b.VoluntaryExits)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "VoluntaryExits")
-	}
-	syncCommitteeBits, err := bytesutil.DecodeHexWithLength(b.SyncAggregate.SyncCommitteeBits, fieldparams.SyncAggregateSyncCommitteeBytesLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "SyncAggregate.SyncCommitteeBits")
-	}
-	syncCommitteeSig, err := bytesutil.DecodeHexWithLength(b.SyncAggregate.SyncCommitteeSignature, fieldparams.BLSSignatureLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "SyncAggregate.SyncCommitteeSignature")
-	}
-	blsChanges, err := SignedBLSChangesToConsensus(b.BLSToExecutionChanges)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "BLSToExecutionChanges")
-	}
-	signedBid, err := b.SignedExecutionPayloadBid.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "SignedExecutionPayloadBid")
-	}
-	payloadAttestations, err := PayloadAttestationsToConsensus(b.PayloadAttestations)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "PayloadAttestations")
-	}
-
-	return &eth.BeaconBlockBodyGloas{
-		RandaoReveal: randaoReveal,
-		Eth1Data: &eth.Eth1Data{
-			DepositRoot:  depositRoot,
-			DepositCount: depositCount,
-			BlockHash:    blockHash,
-		},
-		Graffiti:          graffiti,
-		ProposerSlashings: proposerSlashings,
-		AttesterSlashings: attesterSlashings,
-		Attestations:      atts,
-		Deposits:          deposits,
-		VoluntaryExits:    exits,
-		SyncAggregate: &eth.SyncAggregate{
-			SyncCommitteeBits:      syncCommitteeBits,
-			SyncCommitteeSignature: syncCommitteeSig,
-		},
-		BlsToExecutionChanges:     blsChanges,
-		SignedExecutionPayloadBid: signedBid,
-		PayloadAttestations:       payloadAttestations,
-	}, nil
-}
-
-func (b *SignedExecutionPayloadBid) ToConsensus() (*eth.SignedExecutionPayloadBid, error) {
-	if b == nil {
-		return nil, errNilValue
-	}
-	sig, err := bytesutil.DecodeHexWithLength(b.Signature, fieldparams.BLSSignatureLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Signature")
-	}
-	message, err := b.Message.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Message")
-	}
-	return &eth.SignedExecutionPayloadBid{
-		Message:   message,
-		Signature: sig,
-	}, nil
-}
-
-func (b *ExecutionPayloadBid) ToConsensus() (*eth.ExecutionPayloadBid, error) {
-	if b == nil {
-		return nil, errNilValue
-	}
-	parentBlockHash, err := bytesutil.DecodeHexWithLength(b.ParentBlockHash, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "ParentBlockHash")
-	}
-	parentBlockRoot, err := bytesutil.DecodeHexWithLength(b.ParentBlockRoot, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "ParentBlockRoot")
-	}
-	blockHash, err := bytesutil.DecodeHexWithLength(b.BlockHash, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "BlockHash")
-	}
-	prevRandao, err := bytesutil.DecodeHexWithLength(b.PrevRandao, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "PrevRandao")
-	}
-	feeRecipient, err := bytesutil.DecodeHexWithLength(b.FeeRecipient, fieldparams.FeeRecipientLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "FeeRecipient")
-	}
-	gasLimit, err := strconv.ParseUint(b.GasLimit, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "GasLimit")
-	}
-	builderIndex, err := strconv.ParseUint(b.BuilderIndex, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "BuilderIndex")
-	}
-	slot, err := strconv.ParseUint(b.Slot, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Slot")
-	}
-	value, err := strconv.ParseUint(b.Value, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Value")
-	}
-	executionPayment, err := strconv.ParseUint(b.ExecutionPayment, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "ExecutionPayment")
-	}
-	blobKzgCommitmentsRoot, err := bytesutil.DecodeHexWithLength(b.BlobKzgCommitmentsRoot, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "BlobKzgCommitmentsRoot")
-	}
-	return &eth.ExecutionPayloadBid{
-		ParentBlockHash:        parentBlockHash,
-		ParentBlockRoot:        parentBlockRoot,
-		BlockHash:              blockHash,
-		PrevRandao:             prevRandao,
-		FeeRecipient:           feeRecipient,
-		GasLimit:               gasLimit,
-		BuilderIndex:           primitives.BuilderIndex(builderIndex),
-		Slot:                   primitives.Slot(slot),
-		Value:                  primitives.Gwei(value),
-		ExecutionPayment:       primitives.Gwei(executionPayment),
-		BlobKzgCommitmentsRoot: blobKzgCommitmentsRoot,
-	}, nil
-}
-
-func PayloadAttestationsToConsensus(pa []*PayloadAttestation) ([]*eth.PayloadAttestation, error) {
-	if pa == nil {
-		return nil, errNilValue
-	}
-	result := make([]*eth.PayloadAttestation, len(pa))
-	for i, p := range pa {
-		converted, err := p.ToConsensus()
-		if err != nil {
-			return nil, server.NewDecodeError(err, fmt.Sprintf("[%d]", i))
-		}
-		result[i] = converted
-	}
-	return result, nil
-}
-
-func (p *PayloadAttestation) ToConsensus() (*eth.PayloadAttestation, error) {
-	if p == nil {
-		return nil, errNilValue
-	}
-	aggregationBits, err := hexutil.Decode(p.AggregationBits)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "AggregationBits")
-	}
-	data, err := p.Data.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Data")
-	}
-	sig, err := bytesutil.DecodeHexWithLength(p.Signature, fieldparams.BLSSignatureLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Signature")
-	}
-	return &eth.PayloadAttestation{
-		AggregationBits: aggregationBits,
-		Data:            data,
-		Signature:       sig,
-	}, nil
-}
-
-func (d *PayloadAttestationData) ToConsensus() (*eth.PayloadAttestationData, error) {
-	if d == nil {
-		return nil, errNilValue
-	}
-	beaconBlockRoot, err := bytesutil.DecodeHexWithLength(d.BeaconBlockRoot, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "BeaconBlockRoot")
-	}
-	slot, err := strconv.ParseUint(d.Slot, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Slot")
-	}
-	return &eth.PayloadAttestationData{
-		BeaconBlockRoot:   beaconBlockRoot,
-		Slot:              primitives.Slot(slot),
-		PayloadPresent:    d.PayloadPresent,
-		BlobDataAvailable: d.BlobDataAvailable,
-	}, nil
-}

beacon-chain/blockchain/BUILD.bazel

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

beacon-chain/blockchain/kzg/BUILD.bazel

@@ -13,7 +13,7 @@ go_library(
     deps = [
         "//consensus-types/blocks:go_default_library",
         "@com_github_crate_crypto_go_kzg_4844//:go_default_library",
-        "@com_github_ethereum_c_kzg_4844_v2//bindings/go:go_default_library",
+        "@com_github_ethereum_c_kzg_4844//bindings/go:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_ethereum_go_ethereum//crypto/kzg4844:go_default_library",
         "@com_github_pkg_errors//:go_default_library",

beacon-chain/blockchain/kzg/kzg.go

@@ -110,7 +110,7 @@ func VerifyCellKZGProofBatch(commitmentsBytes []Bytes48, cellIndices []uint64, c
 	ckzgCells := make([]ckzg4844.Cell, len(cells))
 
 	for i := range cells {
-		ckzgCells[i] = ckzg4844.Cell(cells[i])
+		copy(ckzgCells[i][:], cells[i][:])
 	}
 	return ckzg4844.VerifyCellKZGProofBatch(commitmentsBytes, cellIndices, ckzgCells, proofsBytes)
 }

beacon-chain/blockchain/metrics.go

@@ -221,19 +221,6 @@ var (
 			Buckets: []float64{1, 2, 4, 8, 16, 32},
 		},
 	)
-	commitmentCount = promauto.NewHistogram(
-		prometheus.HistogramOpts{
-			Name:    "commitment_count_max_21",
-			Help:    "The number of blob KZG commitments per block.",
-			Buckets: []float64{1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21},
-		},
-	)
-	maxBlobsPerBlock = promauto.NewGauge(
-		prometheus.GaugeOpts{
-			Name: "max_blobs_per_block",
-			Help: "The maximum number of blobs allowed in a block.",
-		},
-	)
 )
 
 // reportSlotMetrics reports slot related metrics.

beacon-chain/blockchain/receive_attestation.go

@@ -94,7 +94,6 @@ func (s *Service) spawnProcessAttestationsRoutine() {
 		for {
 			select {
 			case <-s.ctx.Done():
-				ticker.Done()
 				return
 			case slotInterval := <-ticker.C():
 				if slotInterval.Interval > 0 {

beacon-chain/blockchain/receive_block.go

@@ -16,7 +16,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/slasher/types"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v7/config/features"
-	"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"
@@ -259,55 +258,32 @@ func (s *Service) handleDA(ctx context.Context, avs das.AvailabilityChecker, blo
 }
 
 func (s *Service) reportPostBlockProcessing(
-	signedBlock interfaces.SignedBeaconBlock,
+	block interfaces.SignedBeaconBlock,
 	blockRoot [32]byte,
 	receivedTime time.Time,
 	daWaitedTime time.Duration,
 ) {
-	block := signedBlock.Block()
-	if block == nil {
-		log.WithField("blockRoot", blockRoot).Error("Nil block")
-		return
-	}
-
 	// Reports on block and fork choice metrics.
 	cp := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
 	finalized := &ethpb.Checkpoint{Epoch: cp.Epoch, Root: bytesutil.SafeCopyBytes(cp.Root[:])}
-	reportSlotMetrics(block.Slot(), s.HeadSlot(), s.CurrentSlot(), finalized)
+	reportSlotMetrics(block.Block().Slot(), s.HeadSlot(), s.CurrentSlot(), finalized)
 
 	// Log block sync status.
 	cp = s.cfg.ForkChoiceStore.JustifiedCheckpoint()
 	justified := &ethpb.Checkpoint{Epoch: cp.Epoch, Root: bytesutil.SafeCopyBytes(cp.Root[:])}
-	if err := logBlockSyncStatus(block, blockRoot, justified, finalized, receivedTime, s.genesisTime, daWaitedTime); err != nil {
+	if err := logBlockSyncStatus(block.Block(), blockRoot, justified, finalized, receivedTime, s.genesisTime, daWaitedTime); err != nil {
 		log.WithError(err).Error("Unable to log block sync status")
 	}
-
 	// Log payload data
-	if err := logPayload(block); err != nil {
+	if err := logPayload(block.Block()); err != nil {
 		log.WithError(err).Error("Unable to log debug block payload data")
 	}
-
 	// Log state transition data.
-	if err := logStateTransitionData(block); err != nil {
+	if err := logStateTransitionData(block.Block()); err != nil {
 		log.WithError(err).Error("Unable to log state transition data")
 	}
-
 	timeWithoutDaWait := time.Since(receivedTime) - daWaitedTime
 	chainServiceProcessingTime.Observe(float64(timeWithoutDaWait.Milliseconds()))
-
-	body := block.Body()
-	if body == nil {
-		log.WithField("blockRoot", blockRoot).Error("Nil block body")
-		return
-	}
-
-	commitments, err := body.BlobKzgCommitments()
-	if err != nil {
-		log.WithError(err).Error("Unable to get blob KZG commitments")
-	}
-
-	commitmentCount.Observe(float64(len(commitments)))
-	maxBlobsPerBlock.Set(float64(params.BeaconConfig().MaxBlobsPerBlock(block.Slot())))
 }
 
 func (s *Service) executePostFinalizationTasks(ctx context.Context, finalizedState state.BeaconState) {

beacon-chain/blockchain/receive_block_test.go

@@ -17,7 +17,6 @@ import (
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	ethpbv1 "github.com/OffchainLabs/prysm/v7/proto/eth/v1"
@@ -131,10 +130,12 @@ func TestService_ReceiveBlock(t *testing.T) {
 				block: genFullBlock(t, util.DefaultBlockGenConfig(), 1 /*slot*/),
 			},
 			check: func(t *testing.T, s *Service) {
-				notifier := s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier)
-				require.Eventually(t, func() bool {
-					return len(notifier.ReceivedEvents()) >= 1
-				}, 2*time.Second, 10*time.Millisecond, "Expected at least 1 state notification")
+				// Hacky sleep, should use a better way to be able to resolve the race
+				// between event being sent out and processed.
+				time.Sleep(100 * time.Millisecond)
+				if recvd := len(s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier).ReceivedEvents()); recvd < 1 {
+					t.Errorf("Received %d state notifications, expected at least 1", recvd)
+				}
 			},
 		},
 		{
@@ -221,10 +222,10 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 		require.NoError(t, s.ReceiveBlock(ctx, wsb, root, nil))
 	})
 	wg.Wait()
-	notifier := s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier)
-	require.Eventually(t, func() bool {
-		return len(notifier.ReceivedEvents()) >= 1
-	}, 2*time.Second, 10*time.Millisecond, "Expected at least 1 state notification")
+	time.Sleep(100 * time.Millisecond)
+	if recvd := len(s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier).ReceivedEvents()); recvd < 1 {
+		t.Errorf("Received %d state notifications, expected at least 1", recvd)
+	}
 	// Verify fork choice has processed the block. (Genesis block and the new block)
 	assert.Equal(t, 2, s.cfg.ForkChoiceStore.NodeCount())
 }
@@ -264,10 +265,10 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 				block: genFullBlock(t, util.DefaultBlockGenConfig(), 1 /*slot*/),
 			},
 			check: func(t *testing.T, s *Service) {
-				notifier := s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier)
-				require.Eventually(t, func() bool {
-					return len(notifier.ReceivedEvents()) >= 1
-				}, 2*time.Second, 10*time.Millisecond, "Expected at least 1 state notification")
+				time.Sleep(100 * time.Millisecond)
+				if recvd := len(s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier).ReceivedEvents()); recvd < 1 {
+					t.Errorf("Received %d state notifications, expected at least 1", recvd)
+				}
 			},
 		},
 	}
@@ -511,9 +512,8 @@ func Test_executePostFinalizationTasks(t *testing.T) {
 		s.cfg.StateNotifier = notifier
 		s.executePostFinalizationTasks(s.ctx, headState)
 
-		require.Eventually(t, func() bool {
-			return len(notifier.ReceivedEvents()) == 1
-		}, 5*time.Second, 50*time.Millisecond, "Expected exactly 1 state notification")
+		time.Sleep(1 * time.Second) // sleep for a second because event is in a separate go routine
+		require.Equal(t, 1, len(notifier.ReceivedEvents()))
 		e := notifier.ReceivedEvents()[0]
 		assert.Equal(t, statefeed.FinalizedCheckpoint, int(e.Type))
 		fc, ok := e.Data.(*ethpbv1.EventFinalizedCheckpoint)
@@ -552,9 +552,8 @@ func Test_executePostFinalizationTasks(t *testing.T) {
 		s.cfg.StateNotifier = notifier
 		s.executePostFinalizationTasks(s.ctx, headState)
 
-		require.Eventually(t, func() bool {
-			return len(notifier.ReceivedEvents()) == 1
-		}, 5*time.Second, 50*time.Millisecond, "Expected exactly 1 state notification")
+		time.Sleep(1 * time.Second) // sleep for a second because event is in a separate go routine
+		require.Equal(t, 1, len(notifier.ReceivedEvents()))
 		e := notifier.ReceivedEvents()[0]
 		assert.Equal(t, statefeed.FinalizedCheckpoint, int(e.Type))
 		fc, ok := e.Data.(*ethpbv1.EventFinalizedCheckpoint)
@@ -597,13 +596,13 @@ func TestProcessLightClientBootstrap(t *testing.T) {
 
 			s.executePostFinalizationTasks(s.ctx, l.AttestedState)
 
-			// Wait for the light client bootstrap to be saved (runs in goroutine)
-			var b interfaces.LightClientBootstrap
-			require.Eventually(t, func() bool {
-				var err error
-				b, err = s.lcStore.LightClientBootstrap(ctx, [32]byte(cp.Root))
-				return err == nil && b != nil
-			}, 5*time.Second, 50*time.Millisecond, "Light client bootstrap was not saved within timeout")
+			// wait for the goroutine to finish processing
+			time.Sleep(1 * time.Second)
+
+			// Check that the light client bootstrap is saved
+			b, err := s.lcStore.LightClientBootstrap(ctx, [32]byte(cp.Root))
+			require.NoError(t, err)
+			require.NotNil(t, b)
 
 			btst, err := lightClient.NewLightClientBootstrapFromBeaconState(ctx, l.FinalizedState.Slot(), l.FinalizedState, l.FinalizedBlock)
 			require.NoError(t, err)

beacon-chain/blockchain/service.go

@@ -14,6 +14,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/cache"
 	statefeed "github.com/OffchainLabs/prysm/v7/beacon-chain/core/feed/state"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
 	coreTime "github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/transition"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/db"
@@ -29,6 +30,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/stategen"
+	"github.com/OffchainLabs/prysm/v7/cmd/beacon-chain/flags"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
@@ -289,6 +291,19 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 		return errors.Wrap(err, "failed to initialize blockchain service")
 	}
 
+	if !params.FuluEnabled() {
+		return nil
+	}
+
+	earliestAvailableSlot, custodySubnetCount, err := s.updateCustodyInfoInDB(saved.Slot())
+	if err != nil {
+		return errors.Wrap(err, "could not get and save custody group count")
+	}
+
+	if _, _, err := s.cfg.P2P.UpdateCustodyInfo(earliestAvailableSlot, custodySubnetCount); err != nil {
+		return errors.Wrap(err, "update custody info")
+	}
+
 	return nil
 }
 
@@ -453,6 +468,73 @@ func (s *Service) removeStartupState() {
 	s.cfg.FinalizedStateAtStartUp = nil
 }
 
+// UpdateCustodyInfoInDB updates the custody information in the database.
+// It returns the (potentially updated) custody group count and the earliest available slot.
+func (s *Service) updateCustodyInfoInDB(slot primitives.Slot) (primitives.Slot, uint64, error) {
+	isSupernode := flags.Get().Supernode
+	isSemiSupernode := flags.Get().SemiSupernode
+
+	cfg := params.BeaconConfig()
+	custodyRequirement := cfg.CustodyRequirement
+
+	// Check if the node was previously subscribed to all data subnets, and if so,
+	// store the new status accordingly.
+	wasSupernode, err := s.cfg.BeaconDB.UpdateSubscribedToAllDataSubnets(s.ctx, isSupernode)
+	if err != nil {
+		return 0, 0, errors.Wrap(err, "update subscribed to all data subnets")
+	}
+
+	// Compute the target custody group count based on current flag configuration.
+	targetCustodyGroupCount := custodyRequirement
+
+	// Supernode: custody all groups (either currently set or previously enabled)
+	if isSupernode {
+		targetCustodyGroupCount = cfg.NumberOfCustodyGroups
+	}
+
+	// Semi-supernode: custody minimum needed for reconstruction, or custody requirement if higher
+	if isSemiSupernode {
+		semiSupernodeCustody, err := peerdas.MinimumCustodyGroupCountToReconstruct()
+		if err != nil {
+			return 0, 0, errors.Wrap(err, "minimum custody group count")
+		}
+
+		targetCustodyGroupCount = max(custodyRequirement, semiSupernodeCustody)
+	}
+
+	// Safely compute the fulu fork slot.
+	fuluForkSlot, err := fuluForkSlot()
+	if err != nil {
+		return 0, 0, errors.Wrap(err, "fulu fork slot")
+	}
+
+	// If slot is before the fulu fork slot, then use the earliest stored slot as the reference slot.
+	if slot < fuluForkSlot {
+		slot, err = s.cfg.BeaconDB.EarliestSlot(s.ctx)
+		if err != nil {
+			return 0, 0, errors.Wrap(err, "earliest slot")
+		}
+	}
+
+	earliestAvailableSlot, actualCustodyGroupCount, err := s.cfg.BeaconDB.UpdateCustodyInfo(s.ctx, slot, targetCustodyGroupCount)
+	if err != nil {
+		return 0, 0, errors.Wrap(err, "update custody info")
+	}
+
+	if isSupernode {
+		log.WithFields(logrus.Fields{
+			"current": actualCustodyGroupCount,
+			"target":  cfg.NumberOfCustodyGroups,
+		}).Info("Supernode mode enabled. Will custody all data columns going forward.")
+	}
+
+	if wasSupernode && !isSupernode {
+		log.Warningf("Because the `--%s` flag was previously used, the node will continue to act as a super node.", flags.Supernode.Name)
+	}
+
+	return earliestAvailableSlot, actualCustodyGroupCount, nil
+}
+
 func spawnCountdownIfPreGenesis(ctx context.Context, genesisTime time.Time, db db.HeadAccessDatabase) {
 	currentTime := prysmTime.Now()
 	if currentTime.After(genesisTime) {
@@ -469,3 +551,19 @@ func spawnCountdownIfPreGenesis(ctx context.Context, genesisTime time.Time, db d
 	}
 	go slots.CountdownToGenesis(ctx, genesisTime, uint64(gState.NumValidators()), gRoot)
 }
+
+func fuluForkSlot() (primitives.Slot, error) {
+	cfg := params.BeaconConfig()
+
+	fuluForkEpoch := cfg.FuluForkEpoch
+	if fuluForkEpoch == cfg.FarFutureEpoch {
+		return cfg.FarFutureSlot, nil
+	}
+
+	forkFuluSlot, err := slots.EpochStart(fuluForkEpoch)
+	if err != nil {
+		return 0, errors.Wrap(err, "epoch start")
+	}
+
+	return forkFuluSlot, nil
+}

beacon-chain/blockchain/service_test.go

@@ -23,9 +23,11 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/startup"
 	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/stategen"
+	"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"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	consensusblocks "github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
@@ -594,3 +596,218 @@ func TestNotifyIndex(t *testing.T) {
 		t.Errorf("Notifier channel did not receive the index")
 	}
 }
+
+func TestUpdateCustodyInfoInDB(t *testing.T) {
+	const (
+		fuluForkEpoch         = 10
+		custodyRequirement    = uint64(4)
+		earliestStoredSlot    = primitives.Slot(12)
+		numberOfCustodyGroups = uint64(64)
+	)
+
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig()
+	cfg.FuluForkEpoch = fuluForkEpoch
+	cfg.CustodyRequirement = custodyRequirement
+	cfg.NumberOfCustodyGroups = numberOfCustodyGroups
+	params.OverrideBeaconConfig(cfg)
+
+	ctx := t.Context()
+	pbBlock := util.NewBeaconBlock()
+	pbBlock.Block.Slot = 12
+	signedBeaconBlock, err := blocks.NewSignedBeaconBlock(pbBlock)
+	require.NoError(t, err)
+
+	roBlock, err := blocks.NewROBlock(signedBeaconBlock)
+	require.NoError(t, err)
+
+	t.Run("CGC increases before fulu", func(t *testing.T) {
+		service, requirements := minimalTestService(t)
+		err = requirements.db.SaveBlock(ctx, roBlock)
+		require.NoError(t, err)
+
+		// Before Fulu
+		// -----------
+		actualEas, actualCgc, err := service.updateCustodyInfoInDB(15)
+		require.NoError(t, err)
+		require.Equal(t, earliestStoredSlot, actualEas)
+		require.Equal(t, custodyRequirement, actualCgc)
+
+		actualEas, actualCgc, err = service.updateCustodyInfoInDB(17)
+		require.NoError(t, err)
+		require.Equal(t, earliestStoredSlot, actualEas)
+		require.Equal(t, custodyRequirement, actualCgc)
+
+		resetFlags := flags.Get()
+		gFlags := new(flags.GlobalFlags)
+		gFlags.Supernode = true
+		flags.Init(gFlags)
+		defer flags.Init(resetFlags)
+
+		actualEas, actualCgc, err = service.updateCustodyInfoInDB(19)
+		require.NoError(t, err)
+		require.Equal(t, earliestStoredSlot, actualEas)
+		require.Equal(t, numberOfCustodyGroups, actualCgc)
+
+		// After Fulu
+		// ----------
+		actualEas, actualCgc, err = service.updateCustodyInfoInDB(fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1)
+		require.NoError(t, err)
+		require.Equal(t, earliestStoredSlot, actualEas)
+		require.Equal(t, numberOfCustodyGroups, actualCgc)
+	})
+
+	t.Run("CGC increases after fulu", func(t *testing.T) {
+		service, requirements := minimalTestService(t)
+		err = requirements.db.SaveBlock(ctx, roBlock)
+		require.NoError(t, err)
+
+		// Before Fulu
+		// -----------
+		actualEas, actualCgc, err := service.updateCustodyInfoInDB(15)
+		require.NoError(t, err)
+		require.Equal(t, earliestStoredSlot, actualEas)
+		require.Equal(t, custodyRequirement, actualCgc)
+
+		actualEas, actualCgc, err = service.updateCustodyInfoInDB(17)
+		require.NoError(t, err)
+		require.Equal(t, earliestStoredSlot, actualEas)
+		require.Equal(t, custodyRequirement, actualCgc)
+
+		// After Fulu
+		// ----------
+		resetFlags := flags.Get()
+		gFlags := new(flags.GlobalFlags)
+		gFlags.Supernode = true
+		flags.Init(gFlags)
+		defer flags.Init(resetFlags)
+
+		slot := fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1
+		actualEas, actualCgc, err = service.updateCustodyInfoInDB(slot)
+		require.NoError(t, err)
+		require.Equal(t, slot, actualEas)
+		require.Equal(t, numberOfCustodyGroups, actualCgc)
+
+		actualEas, actualCgc, err = service.updateCustodyInfoInDB(slot + 2)
+		require.NoError(t, err)
+		require.Equal(t, slot, actualEas)
+		require.Equal(t, numberOfCustodyGroups, actualCgc)
+	})
+
+	t.Run("Supernode downgrade prevented", func(t *testing.T) {
+		service, requirements := minimalTestService(t)
+		err = requirements.db.SaveBlock(ctx, roBlock)
+		require.NoError(t, err)
+
+		// Enable supernode
+		resetFlags := flags.Get()
+		gFlags := new(flags.GlobalFlags)
+		gFlags.Supernode = true
+		flags.Init(gFlags)
+
+		slot := fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1
+		actualEas, actualCgc, err := service.updateCustodyInfoInDB(slot)
+		require.NoError(t, err)
+		require.Equal(t, slot, actualEas)
+		require.Equal(t, numberOfCustodyGroups, actualCgc)
+
+		// Try to downgrade by removing flag
+		gFlags.Supernode = false
+		flags.Init(gFlags)
+		defer flags.Init(resetFlags)
+
+		// Should still be supernode
+		actualEas, actualCgc, err = service.updateCustodyInfoInDB(slot + 2)
+		require.NoError(t, err)
+		require.Equal(t, slot, actualEas)
+		require.Equal(t, numberOfCustodyGroups, actualCgc) // Still 64, not downgraded
+	})
+
+	t.Run("Semi-supernode downgrade prevented", func(t *testing.T) {
+		service, requirements := minimalTestService(t)
+		err = requirements.db.SaveBlock(ctx, roBlock)
+		require.NoError(t, err)
+
+		// Enable semi-supernode
+		resetFlags := flags.Get()
+		gFlags := new(flags.GlobalFlags)
+		gFlags.SemiSupernode = true
+		flags.Init(gFlags)
+
+		slot := fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1
+		actualEas, actualCgc, err := service.updateCustodyInfoInDB(slot)
+		require.NoError(t, err)
+		require.Equal(t, slot, actualEas)
+		semiSupernodeCustody := numberOfCustodyGroups / 2 // 64
+		require.Equal(t, semiSupernodeCustody, actualCgc) // Semi-supernode custodies 64 groups
+
+		// Try to downgrade by removing flag
+		gFlags.SemiSupernode = false
+		flags.Init(gFlags)
+		defer flags.Init(resetFlags)
+
+		// UpdateCustodyInfo should prevent downgrade - custody count should remain at 64
+		actualEas, actualCgc, err = service.updateCustodyInfoInDB(slot + 2)
+		require.NoError(t, err)
+		require.Equal(t, slot, actualEas)
+		require.Equal(t, semiSupernodeCustody, actualCgc) // Still 64 due to downgrade prevention by UpdateCustodyInfo
+	})
+
+	t.Run("Semi-supernode to supernode upgrade allowed", func(t *testing.T) {
+		service, requirements := minimalTestService(t)
+		err = requirements.db.SaveBlock(ctx, roBlock)
+		require.NoError(t, err)
+
+		// Start with semi-supernode
+		resetFlags := flags.Get()
+		gFlags := new(flags.GlobalFlags)
+		gFlags.SemiSupernode = true
+		flags.Init(gFlags)
+
+		slot := fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1
+		actualEas, actualCgc, err := service.updateCustodyInfoInDB(slot)
+		require.NoError(t, err)
+		require.Equal(t, slot, actualEas)
+		semiSupernodeCustody := numberOfCustodyGroups / 2 // 64
+		require.Equal(t, semiSupernodeCustody, actualCgc) // Semi-supernode custodies 64 groups
+
+		// Upgrade to full supernode
+		gFlags.SemiSupernode = false
+		gFlags.Supernode = true
+		flags.Init(gFlags)
+		defer flags.Init(resetFlags)
+
+		// Should upgrade to full supernode
+		upgradeSlot := slot + 2
+		actualEas, actualCgc, err = service.updateCustodyInfoInDB(upgradeSlot)
+		require.NoError(t, err)
+		require.Equal(t, upgradeSlot, actualEas)           // Earliest slot updates when upgrading
+		require.Equal(t, numberOfCustodyGroups, actualCgc) // Upgraded to 128
+	})
+
+	t.Run("Semi-supernode with high validator requirements uses higher custody", func(t *testing.T) {
+		service, requirements := minimalTestService(t)
+		err = requirements.db.SaveBlock(ctx, roBlock)
+		require.NoError(t, err)
+
+		// Enable semi-supernode
+		resetFlags := flags.Get()
+		gFlags := new(flags.GlobalFlags)
+		gFlags.SemiSupernode = true
+		flags.Init(gFlags)
+		defer flags.Init(resetFlags)
+
+		// Mock a high custody requirement (simulating many validators)
+		// We need to override the custody requirement calculation
+		// For this test, we'll verify the logic by checking if custodyRequirement > 64
+		// Since custodyRequirement in minimalTestService is 4, we can't test the high case here
+		// This would require a different test setup with actual validators
+		slot := fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1
+		actualEas, actualCgc, err := service.updateCustodyInfoInDB(slot)
+		require.NoError(t, err)
+		require.Equal(t, slot, actualEas)
+		semiSupernodeCustody := numberOfCustodyGroups / 2 // 64
+		// With low validator requirements (4), should use semi-supernode minimum (64)
+		require.Equal(t, semiSupernodeCustody, actualCgc)
+	})
+}

beacon-chain/blockchain/setup_test.go

@@ -89,7 +89,7 @@ func (mb *mockBroadcaster) BroadcastLightClientFinalityUpdate(_ context.Context,
 	return nil
 }
 
-func (mb *mockBroadcaster) BroadcastDataColumnSidecars(_ context.Context, _ []blocks.VerifiedRODataColumn, _ []blocks.PartialDataColumn) error {
+func (mb *mockBroadcaster) BroadcastDataColumnSidecars(_ context.Context, _ []blocks.VerifiedRODataColumn) error {
 	mb.broadcastCalled = true
 	return nil
 }

beacon-chain/core/altair/deposit.go

@@ -3,6 +3,7 @@ package altair
 import (
 	"context"
 
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v7/config/params"
@@ -23,7 +24,7 @@ func ProcessPreGenesisDeposits(
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process deposit")
 	}
-	beaconState, err = helpers.ActivateValidatorWithEffectiveBalance(beaconState, deposits)
+	beaconState, err = blocks.ActivateValidatorWithEffectiveBalance(beaconState, deposits)
 	if err != nil {
 		return nil, err
 	}
@@ -36,7 +37,7 @@ func ProcessDeposits(
 	beaconState state.BeaconState,
 	deposits []*ethpb.Deposit,
 ) (state.BeaconState, error) {
-	allSignaturesVerified, err := helpers.BatchVerifyDepositsSignatures(ctx, deposits)
+	allSignaturesVerified, err := blocks.BatchVerifyDepositsSignatures(ctx, deposits)
 	if err != nil {
 		return nil, err
 	}
@@ -81,7 +82,7 @@ func ProcessDeposits(
 //	  signature=deposit.data.signature,
 //	 )
 func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, allSignaturesVerified bool) (state.BeaconState, error) {
-	if err := helpers.VerifyDeposit(beaconState, deposit); err != nil {
+	if err := blocks.VerifyDeposit(beaconState, deposit); err != nil {
 		if deposit == nil || deposit.Data == nil {
 			return nil, err
 		}
@@ -121,7 +122,7 @@ func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, allSi
 	index, ok := beaconState.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubKey))
 	if !ok {
 		if !allSignaturesVerified {
-			valid, err := helpers.IsValidDepositSignature(data)
+			valid, err := blocks.IsValidDepositSignature(data)
 			if err != nil {
 				return nil, err
 			}

beacon-chain/core/blocks/BUILD.bazel

@@ -5,6 +5,7 @@ go_library(
     srcs = [
         "attestation.go",
         "attester_slashing.go",
+        "deposit.go",
         "error.go",
         "eth1_data.go",
         "exit.go",
@@ -20,7 +21,6 @@ go_library(
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks",
     visibility = ["//visibility:public"],
     deps = [
-        "//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",
@@ -33,6 +33,8 @@ go_library(
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
+        "//container/trie:go_default_library",
+        "//contracts/deposit:go_default_library",
         "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
@@ -59,6 +61,7 @@ go_test(
         "attester_slashing_test.go",
         "block_operations_fuzz_test.go",
         "block_regression_test.go",
+        "deposit_test.go",
         "eth1_data_test.go",
         "exit_test.go",
         "exports_test.go",
@@ -87,6 +90,7 @@ go_test(
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//container/trie:go_default_library",
         "//crypto/bls:go_default_library",
         "//crypto/bls/common:go_default_library",
         "//crypto/hash:go_default_library",

beacon-chain/core/blocks/block_operations_fuzz_test.go

@@ -3,7 +3,6 @@ package blocks
 import (
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	v "github.com/OffchainLabs/prysm/v7/beacon-chain/core/validators"
 	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
@@ -319,7 +318,7 @@ func TestFuzzverifyDeposit_10000(t *testing.T) {
 		fuzzer.Fuzz(deposit)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
 		require.NoError(t, err)
-		err = helpers.VerifyDeposit(s, deposit)
+		err = VerifyDeposit(s, deposit)
 		_ = err
 		fuzz.FreeMemory(i)
 	}

beacon-chain/core/blocks/deposit.go

@@ -1,4 +1,4 @@
-package helpers
+package blocks
 
 import (
 	"context"

beacon-chain/core/blocks/deposit_test.go

@@ -1,9 +1,9 @@
-package helpers_test
+package blocks_test
 
 import (
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
 	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
@@ -45,7 +45,7 @@ func TestBatchVerifyDepositsSignatures_Ok(t *testing.T) {
 
 	deposit.Proof = proof
 	require.NoError(t, err)
-	verified, err := helpers.BatchVerifyDepositsSignatures(t.Context(), []*ethpb.Deposit{deposit})
+	verified, err := blocks.BatchVerifyDepositsSignatures(t.Context(), []*ethpb.Deposit{deposit})
 	require.NoError(t, err)
 	require.Equal(t, true, verified)
 }
@@ -68,7 +68,7 @@ func TestBatchVerifyDepositsSignatures_InvalidSignature(t *testing.T) {
 
 	deposit.Proof = proof
 	require.NoError(t, err)
-	verified, err := helpers.BatchVerifyDepositsSignatures(t.Context(), []*ethpb.Deposit{deposit})
+	verified, err := blocks.BatchVerifyDepositsSignatures(t.Context(), []*ethpb.Deposit{deposit})
 	require.NoError(t, err)
 	require.Equal(t, false, verified)
 }
@@ -99,7 +99,7 @@ func TestVerifyDeposit_MerkleBranchFailsVerification(t *testing.T) {
 	})
 	require.NoError(t, err)
 	want := "deposit root did not verify"
-	err = helpers.VerifyDeposit(beaconState, deposit)
+	err = blocks.VerifyDeposit(beaconState, deposit)
 	require.ErrorContains(t, want, err)
 }
 
@@ -123,7 +123,7 @@ func TestIsValidDepositSignature_Ok(t *testing.T) {
 	require.NoError(t, err)
 	sig := sk.Sign(sr[:])
 	depositData.Signature = sig.Marshal()
-	valid, err := helpers.IsValidDepositSignature(depositData)
+	valid, err := blocks.IsValidDepositSignature(depositData)
 	require.NoError(t, err)
 	require.Equal(t, true, valid)
 }
@@ -163,7 +163,7 @@ func TestBatchVerifyPendingDepositsSignatures_Ok(t *testing.T) {
 	sig2 := sk2.Sign(sr2[:])
 	pendingDeposit2.Signature = sig2.Marshal()
 
-	verified, err := helpers.BatchVerifyPendingDepositsSignatures(t.Context(), []*ethpb.PendingDeposit{pendingDeposit, pendingDeposit2})
+	verified, err := blocks.BatchVerifyPendingDepositsSignatures(t.Context(), []*ethpb.PendingDeposit{pendingDeposit, pendingDeposit2})
 	require.NoError(t, err)
 	require.Equal(t, true, verified)
 }
@@ -174,7 +174,7 @@ func TestBatchVerifyPendingDepositsSignatures_InvalidSignature(t *testing.T) {
 		WithdrawalCredentials: make([]byte, 32),
 		Signature:             make([]byte, 96),
 	}
-	verified, err := helpers.BatchVerifyPendingDepositsSignatures(t.Context(), []*ethpb.PendingDeposit{pendingDeposit})
+	verified, err := blocks.BatchVerifyPendingDepositsSignatures(t.Context(), []*ethpb.PendingDeposit{pendingDeposit})
 	require.NoError(t, err)
 	require.Equal(t, false, verified)
 }

beacon-chain/core/blocks/proposer_slashing.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 
-	"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/signing"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
@@ -12,7 +11,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
 	"github.com/OffchainLabs/prysm/v7/time/slots"
 	"github.com/pkg/errors"
 	"google.golang.org/protobuf/proto"
@@ -128,16 +126,7 @@ func processProposerSlashing(
 	if exitInfo == nil {
 		return nil, errors.New("exit info is required to process proposer slashing")
 	}
-
 	var err error
-	// [New in Gloas:EIP7732]: remove the BuilderPendingPayment corresponding to the slashed proposer within 2 epoch window
-	if beaconState.Version() >= version.Gloas {
-		err = gloas.RemoveBuilderPendingPayment(beaconState, slashing.Header_1.Header)
-		if err != nil {
-			return nil, err
-		}
-	}
-
 	beaconState, err = validators.SlashValidator(ctx, beaconState, slashing.Header_1.Header.ProposerIndex, exitInfo)
 	if err != nil {
 		return nil, errors.Wrapf(err, "could not slash proposer index %d", slashing.Header_1.Header.ProposerIndex)

beacon-chain/core/electra/BUILD.bazel

@@ -12,13 +12,16 @@ go_library(
         "log.go",
         "registry_updates.go",
         "transition.go",
+        "transition_no_verify_sig.go",
         "upgrade.go",
         "validator.go",
+        "withdrawals.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/electra",
     visibility = ["//visibility:public"],
     deps = [
         "//beacon-chain/core/altair:go_default_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/helpers:go_default_library",
@@ -41,6 +44,8 @@ go_library(
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/math:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
     ],
@@ -57,14 +62,17 @@ go_test(
         "error_test.go",
         "export_test.go",
         "registry_updates_test.go",
+        "transition_no_verify_sig_test.go",
         "transition_test.go",
         "upgrade_test.go",
         "validator_test.go",
+        "withdrawals_test.go",
     ],
     data = glob(["testdata/**"]),
     embed = [":go_default_library"],
     deps = [
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
@@ -77,12 +85,16 @@ go_test(
         "//encoding/bytesutil:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//testing/assert:go_default_library",
         "//testing/fuzz:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
     ],
 )

beacon-chain/core/electra/consolidations.go

@@ -3,14 +3,19 @@ package electra
 import (
 	"bytes"
 	"context"
+	"fmt"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"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/primitives"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
 	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
+	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/time/slots"
+	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/pkg/errors"
 )
 
@@ -90,6 +95,217 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 	return nil
 }
 
+// ProcessConsolidationRequests implements the spec definition below. This method makes mutating
+// calls to the beacon state.
+//
+//	def process_consolidation_request(
+//	    state: BeaconState,
+//	    consolidation_request: ConsolidationRequest
+//	) -> None:
+//	    if is_valid_switch_to_compounding_request(state, consolidation_request):
+//	        validator_pubkeys = [v.pubkey for v in state.validators]
+//	        request_source_pubkey = consolidation_request.source_pubkey
+//	        source_index = ValidatorIndex(validator_pubkeys.index(request_source_pubkey))
+//	        switch_to_compounding_validator(state, source_index)
+//	        return
+//
+//	    # Verify that source != target, so a consolidation cannot be used as an exit.
+//	    if consolidation_request.source_pubkey == consolidation_request.target_pubkey:
+//	        return
+//	    # If the pending consolidations queue is full, consolidation requests are ignored
+//	    if len(state.pending_consolidations) == PENDING_CONSOLIDATIONS_LIMIT:
+//	        return
+//	    # If there is too little available consolidation churn limit, consolidation requests are ignored
+//	    if get_consolidation_churn_limit(state) <= MIN_ACTIVATION_BALANCE:
+//	        return
+//
+//	    validator_pubkeys = [v.pubkey for v in state.validators]
+//	    # Verify pubkeys exists
+//	    request_source_pubkey = consolidation_request.source_pubkey
+//	    request_target_pubkey = consolidation_request.target_pubkey
+//	    if request_source_pubkey not in validator_pubkeys:
+//	        return
+//	    if request_target_pubkey not in validator_pubkeys:
+//	        return
+//	    source_index = ValidatorIndex(validator_pubkeys.index(request_source_pubkey))
+//	    target_index = ValidatorIndex(validator_pubkeys.index(request_target_pubkey))
+//	    source_validator = state.validators[source_index]
+//	    target_validator = state.validators[target_index]
+//
+//	    # Verify source withdrawal credentials
+//	    has_correct_credential = has_execution_withdrawal_credential(source_validator)
+//	    is_correct_source_address = (
+//	        source_validator.withdrawal_credentials[12:] == consolidation_request.source_address
+//	    )
+//	    if not (has_correct_credential and is_correct_source_address):
+//	        return
+//
+//	    # Verify that target has compounding withdrawal credentials
+//	    if not has_compounding_withdrawal_credential(target_validator):
+//	        return
+//
+//	    # Verify the source and the target are active
+//	    current_epoch = get_current_epoch(state)
+//	    if not is_active_validator(source_validator, current_epoch):
+//	        return
+//	    if not is_active_validator(target_validator, current_epoch):
+//	        return
+//	    # Verify exits for source and target have not been initiated
+//	    if source_validator.exit_epoch != FAR_FUTURE_EPOCH:
+//	        return
+//	    if target_validator.exit_epoch != FAR_FUTURE_EPOCH:
+//	        return
+//
+//	    # Verify the source has been active long enough
+//	    if current_epoch < source_validator.activation_epoch + SHARD_COMMITTEE_PERIOD:
+//	        return
+//
+//	    # Verify the source has no pending withdrawals in the queue
+//	    if get_pending_balance_to_withdraw(state, source_index) > 0:
+//	        return
+//	    # Initiate source validator exit and append pending consolidation
+//	    source_validator.exit_epoch = compute_consolidation_epoch_and_update_churn(
+//	        state, source_validator.effective_balance
+//	    )
+//	    source_validator.withdrawable_epoch = Epoch(
+//	        source_validator.exit_epoch + MIN_VALIDATOR_WITHDRAWABILITY_DELAY
+//	    )
+//	    state.pending_consolidations.append(PendingConsolidation(
+//	        source_index=source_index,
+//	        target_index=target_index
+//	    ))
+func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, reqs []*enginev1.ConsolidationRequest) error {
+	if len(reqs) == 0 || st == nil {
+		return nil
+	}
+	curEpoch := slots.ToEpoch(st.Slot())
+	ffe := params.BeaconConfig().FarFutureEpoch
+	minValWithdrawDelay := params.BeaconConfig().MinValidatorWithdrawabilityDelay
+	pcLimit := params.BeaconConfig().PendingConsolidationsLimit
+
+	for _, cr := range reqs {
+		if cr == nil {
+			return errors.New("nil consolidation request")
+		}
+		if ctx.Err() != nil {
+			return fmt.Errorf("cannot process consolidation requests: %w", ctx.Err())
+		}
+		if IsValidSwitchToCompoundingRequest(st, cr) {
+			srcIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(cr.SourcePubkey))
+			if !ok {
+				log.Error("Failed to find source validator index")
+				continue
+			}
+			if err := SwitchToCompoundingValidator(st, srcIdx); err != nil {
+				log.WithError(err).Error("Failed to switch to compounding validator")
+			}
+			continue
+		}
+		sourcePubkey := bytesutil.ToBytes48(cr.SourcePubkey)
+		targetPubkey := bytesutil.ToBytes48(cr.TargetPubkey)
+		if sourcePubkey == targetPubkey {
+			continue
+		}
+
+		if npc, err := st.NumPendingConsolidations(); err != nil {
+			return fmt.Errorf("failed to fetch number of pending consolidations: %w", err) // This should never happen.
+		} else if npc >= pcLimit {
+			continue
+		}
+
+		activeBal, err := helpers.TotalActiveBalance(st)
+		if err != nil {
+			return err
+		}
+		churnLimit := helpers.ConsolidationChurnLimit(primitives.Gwei(activeBal))
+		if churnLimit <= primitives.Gwei(params.BeaconConfig().MinActivationBalance) {
+			continue
+		}
+
+		srcIdx, ok := st.ValidatorIndexByPubkey(sourcePubkey)
+		if !ok {
+			continue
+		}
+		tgtIdx, ok := st.ValidatorIndexByPubkey(targetPubkey)
+		if !ok {
+			continue
+		}
+
+		srcV, err := st.ValidatorAtIndex(srcIdx)
+		if err != nil {
+			return fmt.Errorf("failed to fetch source validator: %w", err) // This should never happen.
+		}
+
+		roSrcV, err := state_native.NewValidator(srcV)
+		if err != nil {
+			return err
+		}
+
+		tgtV, err := st.ValidatorAtIndexReadOnly(tgtIdx)
+		if err != nil {
+			return fmt.Errorf("failed to fetch target validator: %w", err) // This should never happen.
+		}
+
+		// Verify source withdrawal credentials
+		if !roSrcV.HasExecutionWithdrawalCredentials() {
+			continue
+		}
+		// Confirm source_validator.withdrawal_credentials[12:] == consolidation_request.source_address
+		if len(srcV.WithdrawalCredentials) != 32 || len(cr.SourceAddress) != 20 || !bytes.HasSuffix(srcV.WithdrawalCredentials, cr.SourceAddress) {
+			continue
+		}
+
+		// Target validator must have their withdrawal credentials set appropriately.
+		if !tgtV.HasCompoundingWithdrawalCredentials() {
+			continue
+		}
+
+		// Both validators must be active.
+		if !helpers.IsActiveValidator(srcV, curEpoch) || !helpers.IsActiveValidatorUsingTrie(tgtV, curEpoch) {
+			continue
+		}
+		// Neither validator is exiting.
+		if srcV.ExitEpoch != ffe || tgtV.ExitEpoch() != ffe {
+			continue
+		}
+
+		e, overflow := math.SafeAdd(uint64(srcV.ActivationEpoch), uint64(params.BeaconConfig().ShardCommitteePeriod))
+		if overflow {
+			log.Error("Overflow when adding activation epoch and shard committee period")
+			continue
+		}
+		if uint64(curEpoch) < e {
+			continue
+		}
+		hasBal, err := st.HasPendingBalanceToWithdraw(srcIdx)
+		if err != nil {
+			log.WithError(err).Error("Failed to fetch pending balance to withdraw")
+			continue
+		}
+		if hasBal {
+			continue
+		}
+
+		// Initiate the exit of the source validator.
+		exitEpoch, err := ComputeConsolidationEpochAndUpdateChurn(ctx, st, primitives.Gwei(srcV.EffectiveBalance))
+		if err != nil {
+			log.WithError(err).Error("Failed to compute consolidation epoch")
+			continue
+		}
+		srcV.ExitEpoch = exitEpoch
+		srcV.WithdrawableEpoch = exitEpoch + minValWithdrawDelay
+		if err := st.UpdateValidatorAtIndex(srcIdx, srcV); err != nil {
+			return fmt.Errorf("failed to update validator: %w", err) // This should never happen.
+		}
+
+		if err := st.AppendPendingConsolidation(&eth.PendingConsolidation{SourceIndex: srcIdx, TargetIndex: tgtIdx}); err != nil {
+			return fmt.Errorf("failed to append pending consolidation: %w", err) // This should never happen.
+		}
+	}
+
+	return nil
+}
+
 // IsValidSwitchToCompoundingRequest returns true if the given consolidation request is valid for switching to compounding.
 //
 // Spec code:

beacon-chain/core/electra/consolidations_test.go

@@ -8,6 +8,8 @@ import (
 	"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/primitives"
+	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
@@ -201,6 +203,275 @@ func TestProcessPendingConsolidations(t *testing.T) {
 	}
 }
 
+func TestProcessConsolidationRequests(t *testing.T) {
+	tests := []struct {
+		name     string
+		state    state.BeaconState
+		reqs     []*enginev1.ConsolidationRequest
+		validate func(*testing.T, state.BeaconState)
+		wantErr  bool
+	}{
+		{
+			name: "nil request",
+			state: func() state.BeaconState {
+				st := &eth.BeaconStateElectra{}
+				s, err := state_native.InitializeFromProtoElectra(st)
+				require.NoError(t, err)
+				return s
+			}(),
+			reqs: []*enginev1.ConsolidationRequest{nil},
+			validate: func(t *testing.T, st state.BeaconState) {
+				require.DeepEqual(t, st, st)
+			},
+			wantErr: true,
+		},
+		{
+			name: "one valid request",
+			state: func() state.BeaconState {
+				st := &eth.BeaconStateElectra{
+					Slot:       params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().ShardCommitteePeriod)),
+					Validators: createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
+				}
+				// Validator scenario setup. See comments in reqs section.
+				st.Validators[3].WithdrawalCredentials = bytesutil.Bytes32(0)
+				st.Validators[8].WithdrawalCredentials = bytesutil.Bytes32(1)
+				st.Validators[9].ActivationEpoch = params.BeaconConfig().FarFutureEpoch
+				st.Validators[12].ActivationEpoch = params.BeaconConfig().FarFutureEpoch
+				st.Validators[13].ExitEpoch = 10
+				st.Validators[16].ExitEpoch = 10
+				st.PendingPartialWithdrawals = []*eth.PendingPartialWithdrawal{
+					{
+						Index:  17,
+						Amount: 100,
+					},
+				}
+				s, err := state_native.InitializeFromProtoElectra(st)
+				require.NoError(t, err)
+				return s
+			}(),
+			reqs: []*enginev1.ConsolidationRequest{
+				// Source doesn't have withdrawal credentials.
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
+					SourcePubkey:  []byte("val_3"),
+					TargetPubkey:  []byte("val_4"),
+				},
+				// Source withdrawal credentials don't match the consolidation address.
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)), // Should be 5
+					SourcePubkey:  []byte("val_5"),
+					TargetPubkey:  []byte("val_6"),
+				},
+				// Target does not have their withdrawal credentials set appropriately. (Using eth1 address prefix)
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(7)),
+					SourcePubkey:  []byte("val_7"),
+					TargetPubkey:  []byte("val_8"),
+				},
+				// Source is inactive.
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(9)),
+					SourcePubkey:  []byte("val_9"),
+					TargetPubkey:  []byte("val_10"),
+				},
+				// Target is inactive.
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(11)),
+					SourcePubkey:  []byte("val_11"),
+					TargetPubkey:  []byte("val_12"),
+				},
+				// Source is exiting.
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(13)),
+					SourcePubkey:  []byte("val_13"),
+					TargetPubkey:  []byte("val_14"),
+				},
+				// Target is exiting.
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(15)),
+					SourcePubkey:  []byte("val_15"),
+					TargetPubkey:  []byte("val_16"),
+				},
+				// Source doesn't exist
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)),
+					SourcePubkey:  []byte("INVALID"),
+					TargetPubkey:  []byte("val_0"),
+				},
+				// Target doesn't exist
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)),
+					SourcePubkey:  []byte("val_0"),
+					TargetPubkey:  []byte("INVALID"),
+				},
+				// Source == target
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)),
+					SourcePubkey:  []byte("val_0"),
+					TargetPubkey:  []byte("val_0"),
+				},
+				// Has pending partial withdrawal
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)),
+					SourcePubkey:  []byte("val_17"),
+					TargetPubkey:  []byte("val_1"),
+				},
+				// Valid consolidation request. This should be last to ensure invalid requests do
+				// not end the processing early.
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
+					SourcePubkey:  []byte("val_1"),
+					TargetPubkey:  []byte("val_2"),
+				},
+			},
+			validate: func(t *testing.T, st state.BeaconState) {
+				// Verify a pending consolidation is created.
+				numPC, err := st.NumPendingConsolidations()
+				require.NoError(t, err)
+				require.Equal(t, uint64(1), numPC)
+				pcs, err := st.PendingConsolidations()
+				require.NoError(t, err)
+				require.Equal(t, primitives.ValidatorIndex(1), pcs[0].SourceIndex)
+				require.Equal(t, primitives.ValidatorIndex(2), pcs[0].TargetIndex)
+
+				// Verify the source validator is exiting.
+				src, err := st.ValidatorAtIndex(1)
+				require.NoError(t, err)
+				require.NotEqual(t, params.BeaconConfig().FarFutureEpoch, src.ExitEpoch, "source validator exit epoch not updated")
+				require.Equal(t, params.BeaconConfig().MinValidatorWithdrawabilityDelay, src.WithdrawableEpoch-src.ExitEpoch, "source validator withdrawable epoch not set correctly")
+			},
+		},
+		{
+			name: "pending consolidations limit reached",
+			state: func() state.BeaconState {
+				st := &eth.BeaconStateElectra{
+					Validators:            createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
+					PendingConsolidations: make([]*eth.PendingConsolidation, params.BeaconConfig().PendingConsolidationsLimit),
+				}
+				s, err := state_native.InitializeFromProtoElectra(st)
+				require.NoError(t, err)
+				return s
+			}(),
+			reqs: []*enginev1.ConsolidationRequest{
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
+					SourcePubkey:  []byte("val_1"),
+					TargetPubkey:  []byte("val_2"),
+				},
+			},
+			validate: func(t *testing.T, st state.BeaconState) {
+				// Verify no pending consolidation is created.
+				numPC, err := st.NumPendingConsolidations()
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().PendingConsolidationsLimit, numPC)
+
+				// Verify the source validator is not exiting.
+				src, err := st.ValidatorAtIndex(1)
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().FarFutureEpoch, src.ExitEpoch, "source validator exit epoch should not be updated")
+				require.Equal(t, params.BeaconConfig().FarFutureEpoch, src.WithdrawableEpoch, "source validator withdrawable epoch should not be updated")
+			},
+		},
+		{
+			name: "pending consolidations limit reached during processing",
+			state: func() state.BeaconState {
+				st := &eth.BeaconStateElectra{
+					Slot:                  params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().ShardCommitteePeriod)),
+					Validators:            createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
+					PendingConsolidations: make([]*eth.PendingConsolidation, params.BeaconConfig().PendingConsolidationsLimit-1),
+				}
+				s, err := state_native.InitializeFromProtoElectra(st)
+				require.NoError(t, err)
+				return s
+			}(),
+			reqs: []*enginev1.ConsolidationRequest{
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
+					SourcePubkey:  []byte("val_1"),
+					TargetPubkey:  []byte("val_2"),
+				},
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(3)),
+					SourcePubkey:  []byte("val_3"),
+					TargetPubkey:  []byte("val_4"),
+				},
+			},
+			validate: func(t *testing.T, st state.BeaconState) {
+				// Verify a pending consolidation is created.
+				numPC, err := st.NumPendingConsolidations()
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().PendingConsolidationsLimit, numPC)
+
+				// The first consolidation was appended.
+				pcs, err := st.PendingConsolidations()
+				require.NoError(t, err)
+				require.Equal(t, primitives.ValidatorIndex(1), pcs[params.BeaconConfig().PendingConsolidationsLimit-1].SourceIndex)
+				require.Equal(t, primitives.ValidatorIndex(2), pcs[params.BeaconConfig().PendingConsolidationsLimit-1].TargetIndex)
+
+				// Verify the second source validator is not exiting.
+				src, err := st.ValidatorAtIndex(3)
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().FarFutureEpoch, src.ExitEpoch, "source validator exit epoch should not be updated")
+				require.Equal(t, params.BeaconConfig().FarFutureEpoch, src.WithdrawableEpoch, "source validator withdrawable epoch should not be updated")
+			},
+		},
+		{
+			name: "pending consolidations limit reached and compounded consolidation after",
+			state: func() state.BeaconState {
+				st := &eth.BeaconStateElectra{
+					Slot:                  params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().ShardCommitteePeriod)),
+					Validators:            createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
+					PendingConsolidations: make([]*eth.PendingConsolidation, params.BeaconConfig().PendingConsolidationsLimit),
+				}
+				// To allow compounding consolidation requests.
+				st.Validators[3].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+				s, err := state_native.InitializeFromProtoElectra(st)
+				require.NoError(t, err)
+				return s
+			}(),
+			reqs: []*enginev1.ConsolidationRequest{
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
+					SourcePubkey:  []byte("val_1"),
+					TargetPubkey:  []byte("val_2"),
+				},
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(3)),
+					SourcePubkey:  []byte("val_3"),
+					TargetPubkey:  []byte("val_3"),
+				},
+			},
+			validate: func(t *testing.T, st state.BeaconState) {
+				// Verify a pending consolidation is created.
+				numPC, err := st.NumPendingConsolidations()
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().PendingConsolidationsLimit, numPC)
+
+				// Verify that the last consolidation was included
+				src, err := st.ValidatorAtIndex(3)
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().CompoundingWithdrawalPrefixByte, src.WithdrawalCredentials[0], "source validator was not compounded")
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := electra.ProcessConsolidationRequests(context.TODO(), tt.state, tt.reqs)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ProcessWithdrawalRequests() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !tt.wantErr {
+				require.NoError(t, err)
+			}
+			if tt.validate != nil {
+				tt.validate(t, tt.state)
+			}
+		})
+	}
+}
+
 func TestIsValidSwitchToCompoundingRequest(t *testing.T) {
 	st, _ := util.DeterministicGenesisStateElectra(t, 1)
 	t.Run("nil source pubkey", func(t *testing.T) {

beacon-chain/core/electra/deposits.go

@@ -3,6 +3,7 @@ package electra
 import (
 	"context"
 
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
@@ -12,6 +13,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/contracts/deposit"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
+	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/OffchainLabs/prysm/v7/time/slots"
@@ -35,7 +37,7 @@ func ProcessDeposits(
 	defer span.End()
 	// Attempt to verify all deposit signatures at once, if this fails then fall back to processing
 	// individual deposits with signature verification enabled.
-	allSignaturesVerified, err := helpers.BatchVerifyDepositsSignatures(ctx, deposits)
+	allSignaturesVerified, err := blocks.BatchVerifyDepositsSignatures(ctx, deposits)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not verify deposit signatures in batch")
 	}
@@ -80,7 +82,7 @@ func ProcessDeposits(
 //	  signature=deposit.data.signature,
 //	 )
 func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, allSignaturesVerified bool) (state.BeaconState, error) {
-	if err := helpers.VerifyDeposit(beaconState, deposit); err != nil {
+	if err := blocks.VerifyDeposit(beaconState, deposit); err != nil {
 		if deposit == nil || deposit.Data == nil {
 			return nil, err
 		}
@@ -375,7 +377,7 @@ func batchProcessNewPendingDeposits(ctx context.Context, state state.BeaconState
 		return nil
 	}
 
-	allSignaturesVerified, err := helpers.BatchVerifyPendingDepositsSignatures(ctx, pendingDeposits)
+	allSignaturesVerified, err := blocks.BatchVerifyPendingDepositsSignatures(ctx, pendingDeposits)
 	if err != nil {
 		return errors.Wrap(err, "batch signature verification failed")
 	}
@@ -384,7 +386,7 @@ func batchProcessNewPendingDeposits(ctx context.Context, state state.BeaconState
 		validSig := allSignaturesVerified
 
 		if !allSignaturesVerified {
-			validSig, err = helpers.IsValidDepositSignature(&ethpb.Deposit_Data{
+			validSig, err = blocks.IsValidDepositSignature(&ethpb.Deposit_Data{
 				PublicKey:             bytesutil.SafeCopyBytes(pd.PublicKey),
 				WithdrawalCredentials: bytesutil.SafeCopyBytes(pd.WithdrawalCredentials),
 				Amount:                pd.Amount,
@@ -439,7 +441,7 @@ func ApplyPendingDeposit(ctx context.Context, st state.BeaconState, deposit *eth
 	defer span.End()
 	index, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(deposit.PublicKey))
 	if !ok {
-		verified, err := helpers.IsValidDepositSignature(&ethpb.Deposit_Data{
+		verified, err := blocks.IsValidDepositSignature(&ethpb.Deposit_Data{
 			PublicKey:             bytesutil.SafeCopyBytes(deposit.PublicKey),
 			WithdrawalCredentials: bytesutil.SafeCopyBytes(deposit.WithdrawalCredentials),
 			Amount:                deposit.Amount,
@@ -535,3 +537,62 @@ func GetValidatorFromDeposit(pubKey []byte, withdrawalCredentials []byte, amount
 	validator.EffectiveBalance = min(amount-(amount%params.BeaconConfig().EffectiveBalanceIncrement), maxEffectiveBalance)
 	return validator, nil
 }
+
+// ProcessDepositRequests is a function as part of electra to process execution layer deposits
+func ProcessDepositRequests(ctx context.Context, beaconState state.BeaconState, requests []*enginev1.DepositRequest) (state.BeaconState, error) {
+	_, span := trace.StartSpan(ctx, "electra.ProcessDepositRequests")
+	defer span.End()
+
+	if len(requests) == 0 {
+		return beaconState, nil
+	}
+
+	var err error
+	for _, receipt := range requests {
+		beaconState, err = processDepositRequest(beaconState, receipt)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not apply deposit request")
+		}
+	}
+	return beaconState, nil
+}
+
+// processDepositRequest processes the specific deposit request
+// def process_deposit_request(state: BeaconState, deposit_request: DepositRequest) -> None:
+//
+//	# Set deposit request start index
+//	if state.deposit_requests_start_index == UNSET_DEPOSIT_REQUESTS_START_INDEX:
+//	    state.deposit_requests_start_index = deposit_request.index
+//
+//	# Create pending deposit
+//	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,
+//	))
+func processDepositRequest(beaconState state.BeaconState, request *enginev1.DepositRequest) (state.BeaconState, error) {
+	requestsStartIndex, err := beaconState.DepositRequestsStartIndex()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get deposit requests start index")
+	}
+	if request == nil {
+		return nil, errors.New("nil deposit request")
+	}
+	if requestsStartIndex == params.BeaconConfig().UnsetDepositRequestsStartIndex {
+		if err := beaconState.SetDepositRequestsStartIndex(request.Index); err != nil {
+			return nil, errors.Wrap(err, "could not set deposit requests start index")
+		}
+	}
+	if err := beaconState.AppendPendingDeposit(&ethpb.PendingDeposit{
+		PublicKey:             bytesutil.SafeCopyBytes(request.Pubkey),
+		WithdrawalCredentials: bytesutil.SafeCopyBytes(request.WithdrawalCredentials),
+		Amount:                request.Amount,
+		Signature:             bytesutil.SafeCopyBytes(request.Signature),
+		Slot:                  beaconState.Slot(),
+	}); err != nil {
+		return nil, errors.Wrap(err, "could not append deposit request")
+	}
+	return beaconState, nil
+}

beacon-chain/core/electra/deposits_test.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/electra"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
 	stateTesting "github.com/OffchainLabs/prysm/v7/beacon-chain/state/testing"
@@ -14,6 +15,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/crypto/bls"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
 	"github.com/OffchainLabs/prysm/v7/testing/util"
@@ -359,6 +361,60 @@ func TestBatchProcessNewPendingDeposits(t *testing.T) {
 	})
 }
 
+func TestProcessDepositRequests(t *testing.T) {
+	st, _ := util.DeterministicGenesisStateElectra(t, 1)
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+	require.NoError(t, st.SetDepositRequestsStartIndex(1))
+
+	t.Run("empty requests continues", func(t *testing.T) {
+		newSt, err := electra.ProcessDepositRequests(t.Context(), st, []*enginev1.DepositRequest{})
+		require.NoError(t, err)
+		require.DeepEqual(t, newSt, st)
+	})
+	t.Run("nil request errors", func(t *testing.T) {
+		_, err = electra.ProcessDepositRequests(t.Context(), st, []*enginev1.DepositRequest{nil})
+		require.ErrorContains(t, "nil deposit request", err)
+	})
+
+	vals := st.Validators()
+	vals[0].PublicKey = sk.PublicKey().Marshal()
+	vals[0].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+	require.NoError(t, st.SetValidators(vals))
+	bals := st.Balances()
+	bals[0] = params.BeaconConfig().MinActivationBalance + 2000
+	require.NoError(t, st.SetBalances(bals))
+	require.NoError(t, st.SetPendingDeposits(make([]*eth.PendingDeposit, 0))) // reset pbd as the determinitstic state populates this already
+	withdrawalCred := make([]byte, 32)
+	withdrawalCred[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
+	depositMessage := &eth.DepositMessage{
+		PublicKey:             sk.PublicKey().Marshal(),
+		Amount:                1000,
+		WithdrawalCredentials: withdrawalCred,
+	}
+	domain, err := signing.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
+	require.NoError(t, err)
+	sr, err := signing.ComputeSigningRoot(depositMessage, domain)
+	require.NoError(t, err)
+	sig := sk.Sign(sr[:])
+	requests := []*enginev1.DepositRequest{
+		{
+			Pubkey:                depositMessage.PublicKey,
+			Index:                 0,
+			WithdrawalCredentials: depositMessage.WithdrawalCredentials,
+			Amount:                depositMessage.Amount,
+			Signature:             sig.Marshal(),
+		},
+	}
+	st, err = electra.ProcessDepositRequests(t.Context(), st, requests)
+	require.NoError(t, err)
+
+	pbd, err := st.PendingDeposits()
+	require.NoError(t, err)
+	require.Equal(t, 1, len(pbd))
+	require.Equal(t, uint64(1000), pbd[0].Amount)
+}
+
 func TestProcessDeposit_Electra_Simple(t *testing.T) {
 	deps, _, err := util.DeterministicDepositsAndKeysSameValidator(3)
 	require.NoError(t, err)

beacon-chain/core/electra/error.go

@@ -6,11 +6,6 @@ type execReqErr struct {
 	error
 }
 
-// NewExecReqError creates a new execReqErr.
-func NewExecReqError(msg string) error {
-	return execReqErr{errors.New(msg)}
-}
-
 // IsExecutionRequestError returns true if the error has `execReqErr`.
 func IsExecutionRequestError(e error) bool {
 	if e == nil {

beacon-chain/core/electra/transition_no_verify_sig.go

@@ -1,12 +1,10 @@
-package transition
+package electra
 
 import (
 	"context"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/electra"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	coreRequests "github.com/OffchainLabs/prysm/v7/beacon-chain/core/requests"
 	v "github.com/OffchainLabs/prysm/v7/beacon-chain/core/validators"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
@@ -49,7 +47,7 @@ var (
 //      # [New in Electra:EIP7251]
 //      for_ops(body.execution_payload.consolidation_requests, process_consolidation_request)
 
-func electraOperations(ctx context.Context, st state.BeaconState, block interfaces.ReadOnlyBeaconBlock) (state.BeaconState, error) {
+func ProcessOperations(ctx context.Context, st state.BeaconState, block interfaces.ReadOnlyBeaconBlock) (state.BeaconState, error) {
 	var err error
 
 	// 6110 validations are in VerifyOperationLengths
@@ -65,60 +63,59 @@ func electraOperations(ctx context.Context, st state.BeaconState, block interfac
 			return nil, errors.Wrap(err, "could not update total active balance cache")
 		}
 	}
-	st, err = blocks.ProcessProposerSlashings(ctx, st, bb.ProposerSlashings(), exitInfo)
+	st, err = ProcessProposerSlashings(ctx, st, bb.ProposerSlashings(), exitInfo)
 	if err != nil {
-		return nil, errors.Wrap(ErrProcessProposerSlashingsFailed, err.Error())
+		return nil, errors.Wrap(err, "could not process altair proposer slashing")
 	}
-	st, err = blocks.ProcessAttesterSlashings(ctx, st, bb.AttesterSlashings(), exitInfo)
+	st, err = ProcessAttesterSlashings(ctx, st, bb.AttesterSlashings(), exitInfo)
 	if err != nil {
-		return nil, errors.Wrap(ErrProcessAttesterSlashingsFailed, err.Error())
+		return nil, errors.Wrap(err, "could not process altair attester slashing")
 	}
-	st, err = electra.ProcessAttestationsNoVerifySignature(ctx, st, block)
+	st, err = ProcessAttestationsNoVerifySignature(ctx, st, block)
 	if err != nil {
-		return nil, errors.Wrap(ErrProcessAttestationsFailed, err.Error())
+		return nil, errors.Wrap(err, "could not process altair attestation")
 	}
-	if _, err := electra.ProcessDeposits(ctx, st, bb.Deposits()); err != nil {
-		return nil, errors.Wrap(ErrProcessDepositsFailed, err.Error())
+	if _, err := ProcessDeposits(ctx, st, bb.Deposits()); err != nil { // new in electra
+		return nil, errors.Wrap(err, "could not process altair deposit")
 	}
-	st, err = blocks.ProcessVoluntaryExits(ctx, st, bb.VoluntaryExits(), exitInfo)
+	st, err = ProcessVoluntaryExits(ctx, st, bb.VoluntaryExits(), exitInfo)
 	if err != nil {
-		return nil, errors.Wrap(ErrProcessVoluntaryExitsFailed, err.Error())
+		return nil, errors.Wrap(err, "could not process voluntary exits")
 	}
-	st, err = blocks.ProcessBLSToExecutionChanges(st, block)
+	st, err = ProcessBLSToExecutionChanges(st, block)
 	if err != nil {
-		return nil, errors.Wrap(ErrProcessBLSChangesFailed, err.Error())
+		return nil, errors.Wrap(err, "could not process bls-to-execution changes")
 	}
 	// new in electra
 	requests, err := bb.ExecutionRequests()
 	if err != nil {
-		return nil, electra.NewExecReqError(errors.Wrap(err, "could not get execution requests").Error())
+		return nil, errors.Wrap(err, "could not get execution requests")
 	}
 	for _, d := range requests.Deposits {
 		if d == nil {
-			return nil, electra.NewExecReqError("nil deposit request")
+			return nil, errors.New("nil deposit request")
 		}
 	}
-	st, err = coreRequests.ProcessDepositRequests(ctx, st, requests.Deposits)
+	st, err = ProcessDepositRequests(ctx, st, requests.Deposits)
 	if err != nil {
-		return nil, electra.NewExecReqError(errors.Wrap(err, "could not process deposit requests").Error())
+		return nil, execReqErr{errors.Wrap(err, "could not process deposit requests")}
 	}
-
 	for _, w := range requests.Withdrawals {
 		if w == nil {
-			return nil, electra.NewExecReqError("nil withdrawal request")
+			return nil, errors.New("nil withdrawal request")
 		}
 	}
-	st, err = coreRequests.ProcessWithdrawalRequests(ctx, st, requests.Withdrawals)
+	st, err = ProcessWithdrawalRequests(ctx, st, requests.Withdrawals)
 	if err != nil {
-		return nil, electra.NewExecReqError(errors.Wrap(err, "could not process withdrawal requests").Error())
+		return nil, execReqErr{errors.Wrap(err, "could not process withdrawal requests")}
 	}
 	for _, c := range requests.Consolidations {
 		if c == nil {
-			return nil, electra.NewExecReqError("nil consolidation request")
+			return nil, errors.New("nil consolidation request")
 		}
 	}
-	if err := coreRequests.ProcessConsolidationRequests(ctx, st, requests.Consolidations); err != nil {
-		return nil, electra.NewExecReqError(errors.Wrap(err, "could not process consolidation requests").Error())
+	if err := ProcessConsolidationRequests(ctx, st, requests.Consolidations); err != nil {
+		return nil, execReqErr{errors.Wrap(err, "could not process consolidation requests")}
 	}
 	return st, nil
 }

beacon-chain/core/electra/transition_no_verify_sig_test.go

@@ -0,0 +1,60 @@
+package electra_test
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/electra"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	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/testing/util"
+)
+
+func TestProcessOperationsWithNilRequests(t *testing.T) {
+	tests := []struct {
+		name      string
+		modifyBlk func(blockElectra *ethpb.SignedBeaconBlockElectra)
+		errMsg    string
+	}{
+		{
+			name: "Nil deposit request",
+			modifyBlk: func(blk *ethpb.SignedBeaconBlockElectra) {
+				blk.Block.Body.ExecutionRequests.Deposits = []*enginev1.DepositRequest{nil}
+			},
+			errMsg: "nil deposit request",
+		},
+		{
+			name: "Nil withdrawal request",
+			modifyBlk: func(blk *ethpb.SignedBeaconBlockElectra) {
+				blk.Block.Body.ExecutionRequests.Withdrawals = []*enginev1.WithdrawalRequest{nil}
+			},
+			errMsg: "nil withdrawal request",
+		},
+		{
+			name: "Nil consolidation request",
+			modifyBlk: func(blk *ethpb.SignedBeaconBlockElectra) {
+				blk.Block.Body.ExecutionRequests.Consolidations = []*enginev1.ConsolidationRequest{nil}
+			},
+			errMsg: "nil consolidation request",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			st, ks := util.DeterministicGenesisStateElectra(t, 128)
+			blk, err := util.GenerateFullBlockElectra(st, ks, util.DefaultBlockGenConfig(), 1)
+			require.NoError(t, err)
+
+			tc.modifyBlk(blk)
+
+			b, err := blocks.NewSignedBeaconBlock(blk)
+			require.NoError(t, err)
+
+			require.NoError(t, st.SetSlot(1))
+
+			_, err = electra.ProcessOperations(t.Context(), st, b.Block())
+			require.ErrorContains(t, tc.errMsg, err)
+		})
+	}
+}

beacon-chain/core/electra/withdrawals.go

@@ -1,4 +1,4 @@
-package requests
+package electra
 
 import (
 	"bytes"
@@ -88,7 +88,7 @@ import (
 //	        withdrawable_epoch=withdrawable_epoch,
 //	    ))
 func ProcessWithdrawalRequests(ctx context.Context, st state.BeaconState, wrs []*enginev1.WithdrawalRequest) (state.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "requests.ProcessWithdrawalRequests")
+	ctx, span := trace.StartSpan(ctx, "electra.ProcessWithdrawalRequests")
 	defer span.End()
 	currentEpoch := slots.ToEpoch(st.Slot())
 	if len(wrs) == 0 {

beacon-chain/core/electra/withdrawals_test.go

@@ -1,9 +1,9 @@
-package requests_test
+package electra_test
 
 import (
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/requests"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/electra"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
@@ -289,7 +289,7 @@ func TestProcessWithdrawRequests(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 
-			got, err := requests.ProcessWithdrawalRequests(t.Context(), tt.args.st, tt.args.wrs)
+			got, err := electra.ProcessWithdrawalRequests(t.Context(), tt.args.st, tt.args.wrs)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("ProcessWithdrawalRequests() error = %v, wantErr %v", err, tt.wantErr)
 				return

beacon-chain/core/gloas/BUILD.bazel

@@ -1,66 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "bid.go",
-        "payload_attestation.go",
-        "pending_payment.go",
-        "proposer_slashing.go",
-    ],
-    importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/signing:go_default_library",
-        "//beacon-chain/core/time:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//config/fieldparams:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types:go_default_library",
-        "//consensus-types/blocks:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//crypto/bls:go_default_library",
-        "//crypto/bls/common:go_default_library",
-        "//crypto/hash:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = [
-        "bid_test.go",
-        "payload_attestation_test.go",
-        "pending_payment_test.go",
-        "proposer_slashing_test.go",
-    ],
-    embed = [":go_default_library"],
-    deps = [
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/signing:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/state-native:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/blocks:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//crypto/bls:go_default_library",
-        "//crypto/bls/common:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/engine/v1:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/validator-client:go_default_library",
-        "//runtime/version:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/util:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_prysmaticlabs_fastssz//:go_default_library",
-        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
-        "@org_golang_google_protobuf//proto:go_default_library",
-    ],
-)

beacon-chain/core/gloas/bid.go

@@ -1,193 +0,0 @@
-package gloas
-
-import (
-	"fmt"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"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/crypto/bls"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls/common"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-	"github.com/pkg/errors"
-)
-
-// 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
-func ProcessExecutionPayloadBid(st state.BeaconState, block interfaces.ReadOnlyBeaconBlock) error {
-	signedBid, err := block.Body().SignedExecutionPayloadBid()
-	if err != nil {
-		return errors.Wrap(err, "failed to get signed execution payload bid")
-	}
-
-	wrappedBid, err := blocks.WrappedROSignedExecutionPayloadBid(signedBid)
-	if err != nil {
-		return errors.Wrap(err, "failed to wrap signed bid")
-	}
-
-	bid, err := wrappedBid.Bid()
-	if err != nil {
-		return errors.Wrap(err, "failed to get bid from wrapped bid")
-	}
-
-	builderIndex := bid.BuilderIndex()
-	amount := bid.Value()
-
-	if builderIndex == params.BeaconConfig().BuilderIndexSelfBuild {
-		if amount != 0 {
-			return fmt.Errorf("self-build amount must be zero, got %d", amount)
-		}
-		if wrappedBid.Signature() != common.InfiniteSignature {
-			return errors.New("self-build signature must be point at infinity")
-		}
-	} else {
-		ok, err := st.IsActiveBuilder(builderIndex)
-		if err != nil {
-			return errors.Wrap(err, "builder active check failed")
-		}
-		if !ok {
-			return fmt.Errorf("builder %d is not active", builderIndex)
-		}
-
-		ok, err = st.CanBuilderCoverBid(builderIndex, amount)
-		if err != nil {
-			return errors.Wrap(err, "builder balance check failed")
-		}
-		if !ok {
-			return fmt.Errorf("builder %d cannot cover bid amount %d", builderIndex, amount)
-		}
-
-		if err := validatePayloadBidSignature(st, wrappedBid); err != nil {
-			return errors.Wrap(err, "bid signature validation failed")
-		}
-	}
-
-	if err := validateBidConsistency(st, bid, block); err != nil {
-		return errors.Wrap(err, "bid consistency validation failed")
-	}
-
-	if amount > 0 {
-		feeRecipient := bid.FeeRecipient()
-		pendingPayment := &ethpb.BuilderPendingPayment{
-			Weight: 0,
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: feeRecipient[:],
-				Amount:       amount,
-				BuilderIndex: builderIndex,
-			},
-		}
-		slotIndex := params.BeaconConfig().SlotsPerEpoch + (bid.Slot() % params.BeaconConfig().SlotsPerEpoch)
-		if err := st.SetBuilderPendingPayment(slotIndex, pendingPayment); err != nil {
-			return errors.Wrap(err, "failed to set pending payment")
-		}
-	}
-
-	if err := st.SetExecutionPayloadBid(bid); err != nil {
-		return errors.Wrap(err, "failed to cache execution payload bid")
-	}
-
-	return nil
-}
-
-// validateBidConsistency checks that the bid is consistent with the current beacon state.
-func validateBidConsistency(st state.BeaconState, bid interfaces.ROExecutionPayloadBid, block interfaces.ReadOnlyBeaconBlock) error {
-	if bid.Slot() != block.Slot() {
-		return fmt.Errorf("bid slot %d does not match block slot %d", bid.Slot(), block.Slot())
-	}
-
-	latestBlockHash, err := st.LatestBlockHash()
-	if err != nil {
-		return errors.Wrap(err, "failed to get latest block hash")
-	}
-	if bid.ParentBlockHash() != latestBlockHash {
-		return fmt.Errorf("bid parent block hash mismatch: got %x, expected %x",
-			bid.ParentBlockHash(), latestBlockHash)
-	}
-
-	if bid.ParentBlockRoot() != block.ParentRoot() {
-		return fmt.Errorf("bid parent block root mismatch: got %x, expected %x",
-			bid.ParentBlockRoot(), block.ParentRoot())
-	}
-
-	randaoMix, err := helpers.RandaoMix(st, slots.ToEpoch(st.Slot()))
-	if err != nil {
-		return errors.Wrap(err, "failed to get randao mix")
-	}
-	if bid.PrevRandao() != [32]byte(randaoMix) {
-		return fmt.Errorf("bid prev randao mismatch: got %x, expected %x", bid.PrevRandao(), randaoMix)
-	}
-
-	return nil
-}
-
-// validatePayloadBidSignature verifies the BLS signature on a signed execution payload bid.
-// It validates that the signature was created by the builder specified in the bid
-// using the appropriate domain for the beacon builder.
-func validatePayloadBidSignature(st state.ReadOnlyBeaconState, signedBid interfaces.ROSignedExecutionPayloadBid) error {
-	bid, err := signedBid.Bid()
-	if err != nil {
-		return errors.Wrap(err, "failed to get bid")
-	}
-
-	pubkey, err := st.BuilderPubkey(bid.BuilderIndex())
-	if err != nil {
-		return errors.Wrap(err, "failed to get builder pubkey")
-	}
-
-	publicKey, err := bls.PublicKeyFromBytes(pubkey[:])
-	if err != nil {
-		return errors.Wrap(err, "invalid builder public key")
-	}
-
-	signatureBytes := signedBid.Signature()
-	signature, err := bls.SignatureFromBytes(signatureBytes[:])
-	if err != nil {
-		return errors.Wrap(err, "invalid signature format")
-	}
-
-	currentEpoch := slots.ToEpoch(bid.Slot())
-	domain, err := signing.Domain(
-		st.Fork(),
-		currentEpoch,
-		params.BeaconConfig().DomainBeaconBuilder,
-		st.GenesisValidatorsRoot(),
-	)
-	if err != nil {
-		return errors.Wrap(err, "failed to compute signing domain")
-	}
-
-	signingRoot, err := signedBid.SigningRoot(domain)
-	if err != nil {
-		return errors.Wrap(err, "failed to compute signing root")
-	}
-
-	if !signature.Verify(publicKey, signingRoot[:]) {
-		return signing.ErrSigFailedToVerify
-	}
-
-	return nil
-}

beacon-chain/core/gloas/bid_test.go

@@ -1,633 +0,0 @@
-package gloas
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	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/interfaces"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls/common"
-	"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"
-	validatorpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1/validator-client"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-	fastssz "github.com/prysmaticlabs/fastssz"
-	"google.golang.org/protobuf/proto"
-)
-
-type stubBlockBody struct {
-	signedBid *ethpb.SignedExecutionPayloadBid
-}
-
-func (s stubBlockBody) Version() int                                 { return version.Gloas }
-func (s stubBlockBody) RandaoReveal() [96]byte                       { return [96]byte{} }
-func (s stubBlockBody) Eth1Data() *ethpb.Eth1Data                    { return nil }
-func (s stubBlockBody) Graffiti() [32]byte                           { return [32]byte{} }
-func (s stubBlockBody) ProposerSlashings() []*ethpb.ProposerSlashing { return nil }
-func (s stubBlockBody) AttesterSlashings() []ethpb.AttSlashing       { return nil }
-func (s stubBlockBody) Attestations() []ethpb.Att                    { return nil }
-func (s stubBlockBody) Deposits() []*ethpb.Deposit                   { return nil }
-func (s stubBlockBody) VoluntaryExits() []*ethpb.SignedVoluntaryExit { return nil }
-func (s stubBlockBody) SyncAggregate() (*ethpb.SyncAggregate, error) { return nil, nil }
-func (s stubBlockBody) IsNil() bool                                  { return s.signedBid == nil }
-func (s stubBlockBody) HashTreeRoot() ([32]byte, error)              { return [32]byte{}, nil }
-func (s stubBlockBody) Proto() (proto.Message, error)                { return nil, nil }
-func (s stubBlockBody) Execution() (interfaces.ExecutionData, error) { return nil, nil }
-func (s stubBlockBody) BLSToExecutionChanges() ([]*ethpb.SignedBLSToExecutionChange, error) {
-	return nil, nil
-}
-func (s stubBlockBody) BlobKzgCommitments() ([][]byte, error) { return nil, nil }
-func (s stubBlockBody) ExecutionRequests() (*enginev1.ExecutionRequests, error) {
-	return nil, nil
-}
-func (s stubBlockBody) PayloadAttestations() ([]*ethpb.PayloadAttestation, error) {
-	return nil, nil
-}
-func (s stubBlockBody) SignedExecutionPayloadBid() (*ethpb.SignedExecutionPayloadBid, error) {
-	return s.signedBid, nil
-}
-func (s stubBlockBody) MarshalSSZ() ([]byte, error)         { return nil, nil }
-func (s stubBlockBody) MarshalSSZTo([]byte) ([]byte, error) { return nil, nil }
-func (s stubBlockBody) UnmarshalSSZ([]byte) error           { return nil }
-func (s stubBlockBody) SizeSSZ() int                        { return 0 }
-
-type stubBlock struct {
-	slot       primitives.Slot
-	proposer   primitives.ValidatorIndex
-	parentRoot [32]byte
-	body       stubBlockBody
-	v          int
-}
-
-var (
-	_ interfaces.ReadOnlyBeaconBlockBody = (*stubBlockBody)(nil)
-	_ interfaces.ReadOnlyBeaconBlock     = (*stubBlock)(nil)
-)
-
-func (s stubBlock) Slot() primitives.Slot                    { return s.slot }
-func (s stubBlock) ProposerIndex() primitives.ValidatorIndex { return s.proposer }
-func (s stubBlock) ParentRoot() [32]byte                     { return s.parentRoot }
-func (s stubBlock) StateRoot() [32]byte                      { return [32]byte{} }
-func (s stubBlock) Body() interfaces.ReadOnlyBeaconBlockBody { return s.body }
-func (s stubBlock) IsNil() bool                              { return false }
-func (s stubBlock) IsBlinded() bool                          { return false }
-func (s stubBlock) HashTreeRoot() ([32]byte, error)          { return [32]byte{}, nil }
-func (s stubBlock) Proto() (proto.Message, error)            { return nil, nil }
-func (s stubBlock) MarshalSSZ() ([]byte, error)              { return nil, nil }
-func (s stubBlock) MarshalSSZTo([]byte) ([]byte, error)      { return nil, nil }
-func (s stubBlock) UnmarshalSSZ([]byte) error                { return nil }
-func (s stubBlock) SizeSSZ() int                             { return 0 }
-func (s stubBlock) Version() int                             { return s.v }
-func (s stubBlock) AsSignRequestObject() (validatorpb.SignRequestObject, error) {
-	return nil, nil
-}
-func (s stubBlock) HashTreeRootWith(*fastssz.Hasher) error { return nil }
-
-func buildGloasState(t *testing.T, slot primitives.Slot, proposerIdx primitives.ValidatorIndex, builderIdx primitives.BuilderIndex, balance uint64, randao [32]byte, latestHash [32]byte, builderPubkey [48]byte) *state_native.BeaconState {
-	t.Helper()
-
-	cfg := params.BeaconConfig()
-	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range blockRoots {
-		blockRoots[i] = bytes.Repeat([]byte{0xAA}, 32)
-		stateRoots[i] = bytes.Repeat([]byte{0xBB}, 32)
-	}
-	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
-	for i := range randaoMixes {
-		randaoMixes[i] = randao[:]
-	}
-
-	withdrawalCreds := make([]byte, 32)
-	withdrawalCreds[0] = cfg.BuilderWithdrawalPrefixByte
-
-	validatorCount := int(proposerIdx) + 1
-	validators := make([]*ethpb.Validator, validatorCount)
-	balances := make([]uint64, validatorCount)
-	for i := range validatorCount {
-		validators[i] = &ethpb.Validator{
-			PublicKey:                  builderPubkey[:],
-			WithdrawalCredentials:      withdrawalCreds,
-			EffectiveBalance:           balance,
-			Slashed:                    false,
-			ActivationEligibilityEpoch: 0,
-			ActivationEpoch:            0,
-			ExitEpoch:                  cfg.FarFutureEpoch,
-			WithdrawableEpoch:          cfg.FarFutureEpoch,
-		}
-		balances[i] = balance
-	}
-
-	payments := make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2)
-	for i := range payments {
-		payments[i] = &ethpb.BuilderPendingPayment{Withdrawal: &ethpb.BuilderPendingWithdrawal{}}
-	}
-
-	var builders []*ethpb.Builder
-	if builderIdx != params.BeaconConfig().BuilderIndexSelfBuild {
-		builderCount := int(builderIdx) + 1
-		builders = make([]*ethpb.Builder, builderCount)
-		builders[builderCount-1] = &ethpb.Builder{
-			Pubkey:            builderPubkey[:],
-			Version:           []byte{0},
-			ExecutionAddress:  bytes.Repeat([]byte{0x01}, 20),
-			Balance:           primitives.Gwei(balance),
-			DepositEpoch:      0,
-			WithdrawableEpoch: cfg.FarFutureEpoch,
-		}
-	}
-
-	stProto := &ethpb.BeaconStateGloas{
-		Slot:                  slot,
-		GenesisValidatorsRoot: bytes.Repeat([]byte{0x11}, 32),
-		Fork: &ethpb.Fork{
-			CurrentVersion:  bytes.Repeat([]byte{0x22}, 4),
-			PreviousVersion: bytes.Repeat([]byte{0x22}, 4),
-			Epoch:           0,
-		},
-		BlockRoots:                blockRoots,
-		StateRoots:                stateRoots,
-		RandaoMixes:               randaoMixes,
-		Validators:                validators,
-		Balances:                  balances,
-		LatestBlockHash:           latestHash[:],
-		BuilderPendingPayments:    payments,
-		BuilderPendingWithdrawals: []*ethpb.BuilderPendingWithdrawal{},
-		Builders:                  builders,
-		FinalizedCheckpoint: &ethpb.Checkpoint{
-			Epoch: 1,
-		},
-	}
-
-	st, err := state_native.InitializeFromProtoGloas(stProto)
-	require.NoError(t, err)
-	return st.(*state_native.BeaconState)
-}
-
-func signBid(t *testing.T, sk common.SecretKey, bid *ethpb.ExecutionPayloadBid, fork *ethpb.Fork, genesisRoot [32]byte) [96]byte {
-	t.Helper()
-	epoch := slots.ToEpoch(primitives.Slot(bid.Slot))
-	domain, err := signing.Domain(fork, epoch, params.BeaconConfig().DomainBeaconBuilder, genesisRoot[:])
-	require.NoError(t, err)
-	root, err := signing.ComputeSigningRoot(bid, domain)
-	require.NoError(t, err)
-	sig := sk.Sign(root[:]).Marshal()
-	var out [96]byte
-	copy(out[:], sig)
-	return out
-}
-
-func TestProcessExecutionPayloadBid_SelfBuildSuccess(t *testing.T) {
-	slot := primitives.Slot(12)
-	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[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  0,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0xFF}, 20),
-	}
-	signed := &ethpb.SignedExecutionPayloadBid{
-		Message:   bid,
-		Signature: common.InfiniteSignature[:],
-	}
-
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	require.NoError(t, ProcessExecutionPayloadBid(state, block))
-
-	stateProto, ok := state.ToProto().(*ethpb.BeaconStateGloas)
-	require.Equal(t, true, ok)
-	slotIndex := params.BeaconConfig().SlotsPerEpoch + (slot % params.BeaconConfig().SlotsPerEpoch)
-	require.Equal(t, primitives.Gwei(0), stateProto.BuilderPendingPayments[slotIndex].Withdrawal.Amount)
-}
-
-func TestProcessExecutionPayloadBid_SelfBuildNonZeroAmountFails(t *testing.T) {
-	slot := primitives.Slot(2)
-	proposerIdx := primitives.ValidatorIndex(0)
-	builderIdx := params.BeaconConfig().BuilderIndexSelfBuild
-	randao := [32]byte{}
-	latestHash := [32]byte{1}
-	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),
-	}
-	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, "self-build amount must be zero", err)
-}
-
-func TestProcessExecutionPayloadBid_PendingPaymentAndCacheBid(t *testing.T) {
-	slot := primitives.Slot(8)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	pub := sk.PublicKey().Marshal()
-	var pubKey [48]byte
-	copy(pubKey[:], pub)
-
-	balance := params.BeaconConfig().MinActivationBalance + 1_000_000
-	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),
-	}
-
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{
-		Message:   bid,
-		Signature: sig[:],
-	}
-
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx, // not self-build
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	require.NoError(t, ProcessExecutionPayloadBid(state, block))
-
-	stateProto, ok := state.ToProto().(*ethpb.BeaconStateGloas)
-	require.Equal(t, true, ok)
-	slotIndex := params.BeaconConfig().SlotsPerEpoch + (slot % params.BeaconConfig().SlotsPerEpoch)
-	require.Equal(t, primitives.Gwei(500_000), stateProto.BuilderPendingPayments[slotIndex].Withdrawal.Amount)
-
-	require.NotNil(t, stateProto.LatestExecutionPayloadBid)
-	require.Equal(t, primitives.BuilderIndex(1), stateProto.LatestExecutionPayloadBid.BuilderIndex)
-	require.Equal(t, primitives.Gwei(500_000), stateProto.LatestExecutionPayloadBid.Value)
-}
-
-func TestProcessExecutionPayloadBid_BuilderNotActive(t *testing.T) {
-	slot := primitives.Slot(4)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0x01}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0x02}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
-	// Make builder inactive by setting withdrawable_epoch.
-	stateProto := state.ToProto().(*ethpb.BeaconStateGloas)
-	stateProto.Builders[int(builderIdx)].WithdrawableEpoch = 0
-	stateIface, err := state_native.InitializeFromProtoGloas(stateProto)
-	require.NoError(t, err)
-	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),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	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, "is not active", err)
-}
-
-func TestProcessExecutionPayloadBid_CannotCoverBid(t *testing.T) {
-	slot := primitives.Slot(5)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0x0A}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0x0B}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+10, randao, latestHash, pubKey)
-	stateProto := state.ToProto().(*ethpb.BeaconStateGloas)
-	// Add pending balances to push below required balance.
-	stateProto.BuilderPendingWithdrawals = []*ethpb.BuilderPendingWithdrawal{
-		{Amount: 15, BuilderIndex: builderIdx},
-	}
-	stateProto.BuilderPendingPayments = []*ethpb.BuilderPendingPayment{
-		{Withdrawal: &ethpb.BuilderPendingWithdrawal{Amount: 20, BuilderIndex: builderIdx}},
-	}
-	stateIface, err := state_native.InitializeFromProtoGloas(stateProto)
-	require.NoError(t, err)
-	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),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	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, "cannot cover bid amount", err)
-}
-
-func TestProcessExecutionPayloadBid_InvalidSignature(t *testing.T) {
-	slot := primitives.Slot(6)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	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),
-	}
-	// Use an invalid signature.
-	invalidSig := [96]byte{1}
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: invalidSig[:]}
-	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, "bid signature validation failed", err)
-}
-
-func TestProcessExecutionPayloadBid_SlotMismatch(t *testing.T) {
-	slot := primitives.Slot(10)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	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),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	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, "bid slot", err)
-}
-
-func TestProcessExecutionPayloadBid_ParentHashMismatch(t *testing.T) {
-	slot := primitives.Slot(11)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	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),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	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, "parent block hash mismatch", err)
-}
-
-func TestProcessExecutionPayloadBid_ParentRootMismatch(t *testing.T) {
-	slot := primitives.Slot(12)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
-
-	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),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bytes.Repeat([]byte{0x99}, 32)), // mismatch
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err = ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "parent block root mismatch", err)
-}
-
-func TestProcessExecutionPayloadBid_PrevRandaoMismatch(t *testing.T) {
-	slot := primitives.Slot(13)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	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),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	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, "prev randao mismatch", err)
-}

beacon-chain/core/gloas/payload_attestation.go

@@ -1,274 +0,0 @@
-package gloas
-
-import (
-	"bytes"
-	"context"
-	"encoding/binary"
-	"fmt"
-	"slices"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	consensus_types "github.com/OffchainLabs/prysm/v7/consensus-types"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls"
-	"github.com/OffchainLabs/prysm/v7/crypto/hash"
-	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
-	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-	"github.com/pkg/errors"
-)
-
-// 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)
-func ProcessPayloadAttestations(ctx context.Context, st state.BeaconState, body interfaces.ReadOnlyBeaconBlockBody) error {
-	atts, err := body.PayloadAttestations()
-	if err != nil {
-		return errors.Wrap(err, "failed to get payload attestations from block body")
-	}
-	if len(atts) == 0 {
-		return nil
-	}
-
-	header := st.LatestBlockHeader()
-
-	for i, att := range atts {
-		data := att.Data
-		if !bytes.Equal(data.BeaconBlockRoot, header.ParentRoot) {
-			return fmt.Errorf("payload attestation %d has wrong parent: got %x want %x", i, data.BeaconBlockRoot, header.ParentRoot)
-		}
-
-		dataSlot, err := data.Slot.SafeAdd(1)
-		if err != nil {
-			return errors.Wrapf(err, "payload attestation %d has invalid slot addition", i)
-		}
-		if dataSlot != st.Slot() {
-			return fmt.Errorf("payload attestation %d has wrong slot: got %d want %d", i, data.Slot+1, st.Slot())
-		}
-
-		indexed, err := indexedPayloadAttestation(ctx, st, att)
-		if err != nil {
-			return errors.Wrapf(err, "payload attestation %d failed to convert to indexed form", i)
-		}
-		if err := validIndexedPayloadAttestation(st, indexed); err != nil {
-			return errors.Wrapf(err, "payload attestation %d failed to verify indexed form", i)
-		}
-	}
-	return nil
-}
-
-// 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)
-	if err != nil {
-		return nil, err
-	}
-	indices := make([]primitives.ValidatorIndex, 0, len(committee))
-	for i, idx := range committee {
-		if att.AggregationBits.BitAt(uint64(i)) {
-			indices = append(indices, idx)
-		}
-	}
-	slices.Sort(indices)
-
-	return &consensus_types.IndexedPayloadAttestation{
-		AttestingIndices: indices,
-		Data:             att.Data,
-		Signature:        att.Signature,
-	}, 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]:
-//
-//	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) {
-	epoch := slots.ToEpoch(slot)
-	seed, err := ptcSeed(st, epoch, slot)
-	if err != nil {
-		return nil, err
-	}
-
-	activeCount, err := helpers.ActiveValidatorCount(ctx, st, epoch)
-	if err != nil {
-		return nil, err
-	}
-
-	committeesPerSlot := helpers.SlotCommitteeCount(activeCount)
-
-	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)
-			}
-		}
-	}
-
-	return selected, nil
-}
-
-// ptcSeed computes the seed for the payload timeliness committee.
-func ptcSeed(st state.ReadOnlyBeaconState, epoch primitives.Epoch, slot primitives.Slot) ([32]byte, error) {
-	seed, err := helpers.Seed(st, epoch, params.BeaconConfig().DomainPTCAttester)
-	if err != nil {
-		return [32]byte{}, err
-	}
-	return hash.Hash(append(seed[:], bytesutil.Bytes8(uint64(slot))...)), nil
-}
-
-// 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 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
-
-	for _, idx := range candidates {
-		if ctx.Err() != nil {
-			return nil, i, ctx.Err()
-		}
-
-		ok, err := acceptByBalance(st, idx, buf[:], hashFunc, maxBalance, i)
-		if err != nil {
-			return nil, i, err
-		}
-		if ok {
-			selected = append(selected, idx)
-		}
-		if uint64(len(selected)) == fieldparams.PTCSize {
-			break
-		}
-		i++
-	}
-
-	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
-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)
-	random := hashFunc(seedBuf)
-	offset := (round % 16) * 2
-	randomValue := uint64(binary.LittleEndian.Uint16(random[offset : offset+2])) // 16-bit draw per spec
-
-	val, err := st.ValidatorAtIndex(idx)
-	if err != nil {
-		return false, errors.Wrapf(err, "validator %d", idx)
-	}
-
-	return val.EffectiveBalance*fieldparams.MaxRandomValueElectra >= maxBalance*randomValue, nil
-}
-
-// 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,
-//	  )
-func validIndexedPayloadAttestation(st state.ReadOnlyBeaconState, att *consensus_types.IndexedPayloadAttestation) error {
-	indices := att.AttestingIndices
-	if len(indices) == 0 || !slices.IsSorted(indices) {
-		return errors.New("attesting indices empty or unsorted")
-	}
-
-	pubkeys := make([]bls.PublicKey, len(indices))
-	for i, idx := range indices {
-		val, err := st.ValidatorAtIndexReadOnly(idx)
-		if err != nil {
-			return errors.Wrapf(err, "validator %d", idx)
-		}
-		keyBytes := val.PublicKey()
-		key, err := bls.PublicKeyFromBytes(keyBytes[:])
-		if err != nil {
-			return errors.Wrapf(err, "pubkey %d", idx)
-		}
-		pubkeys[i] = key
-	}
-
-	domain, err := signing.Domain(st.Fork(), slots.ToEpoch(att.Data.Slot), params.BeaconConfig().DomainPTCAttester, st.GenesisValidatorsRoot())
-	if err != nil {
-		return err
-	}
-	root, err := signing.ComputeSigningRoot(att.Data, domain)
-	if err != nil {
-		return err
-	}
-	sig, err := bls.SignatureFromBytes(att.Signature)
-	if err != nil {
-		return err
-	}
-
-	if !sig.FastAggregateVerify(pubkeys, root) {
-		return errors.New("invalid signature")
-	}
-	return nil
-}

beacon-chain/core/gloas/payload_attestation_test.go

@@ -1,305 +0,0 @@
-package gloas_test
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/OffchainLabs/go-bitfield"
-	"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/signing"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"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"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls/common"
-	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	testutil "github.com/OffchainLabs/prysm/v7/testing/util"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-)
-
-func TestProcessPayloadAttestations_WrongParent(t *testing.T) {
-	setupTestConfig(t)
-
-	_, pk := newKey(t)
-	st := newTestState(t, []*eth.Validator{activeValidator(pk)}, 1)
-	require.NoError(t, st.SetSlot(2))
-	parentRoot := bytes.Repeat([]byte{0xaa}, 32)
-	require.NoError(t, st.SetLatestBlockHeader(&eth.BeaconBlockHeader{ParentRoot: parentRoot}))
-
-	att := &eth.PayloadAttestation{
-		Data: &eth.PayloadAttestationData{
-			BeaconBlockRoot: bytes.Repeat([]byte{0xbb}, 32),
-			Slot:            1,
-		},
-		AggregationBits: bitfield.NewBitvector512(),
-		Signature:       make([]byte, 96),
-	}
-	body := buildBody(t, att)
-
-	err := gloas.ProcessPayloadAttestations(t.Context(), st, body)
-	require.ErrorContains(t, "wrong parent", err)
-}
-
-func TestProcessPayloadAttestations_WrongSlot(t *testing.T) {
-	setupTestConfig(t)
-
-	_, pk := newKey(t)
-	st := newTestState(t, []*eth.Validator{activeValidator(pk)}, 1)
-	require.NoError(t, st.SetSlot(3))
-	parentRoot := bytes.Repeat([]byte{0xaa}, 32)
-	require.NoError(t, st.SetLatestBlockHeader(&eth.BeaconBlockHeader{ParentRoot: parentRoot}))
-
-	att := &eth.PayloadAttestation{
-		Data: &eth.PayloadAttestationData{
-			BeaconBlockRoot: parentRoot,
-			Slot:            1,
-		},
-		AggregationBits: bitfield.NewBitvector512(),
-		Signature:       make([]byte, 96),
-	}
-	body := buildBody(t, att)
-
-	err := gloas.ProcessPayloadAttestations(t.Context(), st, body)
-	require.ErrorContains(t, "wrong slot", err)
-}
-
-func TestProcessPayloadAttestations_InvalidSignature(t *testing.T) {
-	setupTestConfig(t)
-
-	_, pk1 := newKey(t)
-	sk2, pk2 := newKey(t)
-	vals := []*eth.Validator{activeValidator(pk1), activeValidator(pk2)}
-	st := newTestState(t, vals, 2)
-	parentRoot := bytes.Repeat([]byte{0xaa}, 32)
-	require.NoError(t, st.SetLatestBlockHeader(&eth.BeaconBlockHeader{ParentRoot: parentRoot}))
-
-	attData := &eth.PayloadAttestationData{
-		BeaconBlockRoot: parentRoot,
-		Slot:            1,
-	}
-	att := &eth.PayloadAttestation{
-		Data:            attData,
-		AggregationBits: setBits(bitfield.NewBitvector512(), 0),
-		Signature:       signAttestation(t, st, attData, []common.SecretKey{sk2}),
-	}
-	body := buildBody(t, att)
-
-	err := gloas.ProcessPayloadAttestations(t.Context(), st, body)
-	require.ErrorContains(t, "failed to verify indexed form", err)
-	require.ErrorContains(t, "invalid signature", err)
-}
-
-func TestProcessPayloadAttestations_EmptyAggregationBits(t *testing.T) {
-	setupTestConfig(t)
-
-	_, pk := newKey(t)
-	st := newTestState(t, []*eth.Validator{activeValidator(pk)}, 1)
-	require.NoError(t, st.SetSlot(2))
-	parentRoot := bytes.Repeat([]byte{0xaa}, 32)
-	require.NoError(t, st.SetLatestBlockHeader(&eth.BeaconBlockHeader{ParentRoot: parentRoot}))
-
-	attData := &eth.PayloadAttestationData{
-		BeaconBlockRoot: parentRoot,
-		Slot:            1,
-	}
-	att := &eth.PayloadAttestation{
-		Data:            attData,
-		AggregationBits: bitfield.NewBitvector512(),
-		Signature:       make([]byte, 96),
-	}
-	body := buildBody(t, att)
-
-	err := gloas.ProcessPayloadAttestations(t.Context(), st, body)
-	require.ErrorContains(t, "failed to verify indexed form", err)
-	require.ErrorContains(t, "attesting indices empty or unsorted", err)
-}
-
-func TestProcessPayloadAttestations_HappyPath(t *testing.T) {
-	helpers.ClearCache()
-	setupTestConfig(t)
-
-	sk1, pk1 := newKey(t)
-	sk2, pk2 := newKey(t)
-	vals := []*eth.Validator{activeValidator(pk1), activeValidator(pk2)}
-
-	st := newTestState(t, vals, 2)
-	parentRoot := bytes.Repeat([]byte{0xaa}, 32)
-	require.NoError(t, st.SetLatestBlockHeader(&eth.BeaconBlockHeader{ParentRoot: parentRoot}))
-
-	attData := &eth.PayloadAttestationData{
-		BeaconBlockRoot: parentRoot,
-		Slot:            1,
-	}
-	aggBits := bitfield.NewBitvector512()
-	aggBits.SetBitAt(0, true)
-	aggBits.SetBitAt(1, true)
-
-	att := &eth.PayloadAttestation{
-		Data:            attData,
-		AggregationBits: aggBits,
-		Signature:       signAttestation(t, st, attData, []common.SecretKey{sk1, sk2}),
-	}
-	body := buildBody(t, att)
-
-	err := gloas.ProcessPayloadAttestations(t.Context(), st, body)
-	require.NoError(t, err)
-}
-
-func TestProcessPayloadAttestations_MultipleAttestations(t *testing.T) {
-	helpers.ClearCache()
-	setupTestConfig(t)
-
-	sk1, pk1 := newKey(t)
-	sk2, pk2 := newKey(t)
-	vals := []*eth.Validator{activeValidator(pk1), activeValidator(pk2)}
-
-	st := newTestState(t, vals, 2)
-	parentRoot := bytes.Repeat([]byte{0xaa}, 32)
-	require.NoError(t, st.SetLatestBlockHeader(&eth.BeaconBlockHeader{ParentRoot: parentRoot}))
-
-	attData1 := &eth.PayloadAttestationData{
-		BeaconBlockRoot: parentRoot,
-		Slot:            1,
-	}
-	attData2 := &eth.PayloadAttestationData{
-		BeaconBlockRoot: parentRoot,
-		Slot:            1,
-	}
-
-	att1 := &eth.PayloadAttestation{
-		Data:            attData1,
-		AggregationBits: setBits(bitfield.NewBitvector512(), 0),
-		Signature:       signAttestation(t, st, attData1, []common.SecretKey{sk1}),
-	}
-	att2 := &eth.PayloadAttestation{
-		Data:            attData2,
-		AggregationBits: setBits(bitfield.NewBitvector512(), 1),
-		Signature:       signAttestation(t, st, attData2, []common.SecretKey{sk2}),
-	}
-
-	body := buildBody(t, att1, att2)
-
-	err := gloas.ProcessPayloadAttestations(t.Context(), st, body)
-	require.NoError(t, err)
-}
-
-func TestProcessPayloadAttestations_IndexedVerificationError(t *testing.T) {
-	setupTestConfig(t)
-
-	_, pk := newKey(t)
-	st := newTestState(t, []*eth.Validator{activeValidator(pk)}, 1)
-	parentRoot := bytes.Repeat([]byte{0xaa}, 32)
-	require.NoError(t, st.SetLatestBlockHeader(&eth.BeaconBlockHeader{ParentRoot: parentRoot}))
-
-	attData := &eth.PayloadAttestationData{
-		BeaconBlockRoot: parentRoot,
-		Slot:            0,
-	}
-	att := &eth.PayloadAttestation{
-		Data:            attData,
-		AggregationBits: setBits(bitfield.NewBitvector512(), 0),
-		Signature:       make([]byte, 96),
-	}
-	body := buildBody(t, att)
-
-	errState := &validatorLookupErrState{
-		BeaconState: st,
-		errIndex:    0,
-	}
-	err := gloas.ProcessPayloadAttestations(t.Context(), errState, body)
-	require.ErrorContains(t, "failed to verify indexed form", err)
-	require.ErrorContains(t, "validator 0", err)
-}
-
-func newTestState(t *testing.T, vals []*eth.Validator, slot primitives.Slot) state.BeaconState {
-	st, err := testutil.NewBeaconState()
-	require.NoError(t, err)
-	for _, v := range vals {
-		require.NoError(t, st.AppendValidator(v))
-		require.NoError(t, st.AppendBalance(v.EffectiveBalance))
-	}
-	require.NoError(t, st.SetSlot(slot))
-	require.NoError(t, helpers.UpdateCommitteeCache(t.Context(), st, slots.ToEpoch(slot)))
-	return st
-}
-
-func setupTestConfig(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig().Copy()
-	cfg.SlotsPerEpoch = 1
-	cfg.MaxEffectiveBalanceElectra = cfg.MaxEffectiveBalance
-	params.OverrideBeaconConfig(cfg)
-}
-
-func buildBody(t *testing.T, atts ...*eth.PayloadAttestation) interfaces.ReadOnlyBeaconBlockBody {
-	body := &eth.BeaconBlockBodyGloas{
-		PayloadAttestations:   atts,
-		RandaoReveal:          make([]byte, 96),
-		Eth1Data:              &eth.Eth1Data{},
-		Graffiti:              make([]byte, 32),
-		ProposerSlashings:     []*eth.ProposerSlashing{},
-		AttesterSlashings:     []*eth.AttesterSlashingElectra{},
-		Attestations:          []*eth.AttestationElectra{},
-		Deposits:              []*eth.Deposit{},
-		VoluntaryExits:        []*eth.SignedVoluntaryExit{},
-		SyncAggregate:         &eth.SyncAggregate{},
-		BlsToExecutionChanges: []*eth.SignedBLSToExecutionChange{},
-	}
-	wrapped, err := blocks.NewBeaconBlockBody(body)
-	require.NoError(t, err)
-	return wrapped
-}
-
-func setBits(bits bitfield.Bitvector512, idx uint64) bitfield.Bitvector512 {
-	bits.SetBitAt(idx, true)
-	return bits
-}
-
-func activeValidator(pub []byte) *eth.Validator {
-	return &eth.Validator{
-		PublicKey:                  pub,
-		EffectiveBalance:           params.BeaconConfig().MaxEffectiveBalance,
-		WithdrawalCredentials:      make([]byte, 32),
-		ActivationEligibilityEpoch: 0,
-		ActivationEpoch:            0,
-		ExitEpoch:                  params.BeaconConfig().FarFutureEpoch,
-		WithdrawableEpoch:          params.BeaconConfig().FarFutureEpoch,
-	}
-}
-
-func newKey(t *testing.T) (common.SecretKey, []byte) {
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	return sk, sk.PublicKey().Marshal()
-}
-
-func signAttestation(t *testing.T, st state.ReadOnlyBeaconState, data *eth.PayloadAttestationData, sks []common.SecretKey) []byte {
-	domain, err := signing.Domain(st.Fork(), slots.ToEpoch(data.Slot), params.BeaconConfig().DomainPTCAttester, st.GenesisValidatorsRoot())
-	require.NoError(t, err)
-	root, err := signing.ComputeSigningRoot(data, domain)
-	require.NoError(t, err)
-
-	sigs := make([]common.Signature, len(sks))
-	for i, sk := range sks {
-		sigs[i] = sk.Sign(root[:])
-	}
-	agg := bls.AggregateSignatures(sigs)
-	return agg.Marshal()
-}
-
-type validatorLookupErrState struct {
-	state.BeaconState
-	errIndex primitives.ValidatorIndex
-}
-
-// ValidatorAtIndexReadOnly is overridden to simulate a missing validator lookup.
-func (s *validatorLookupErrState) ValidatorAtIndexReadOnly(idx primitives.ValidatorIndex) (state.ReadOnlyValidator, error) {
-	if idx == s.errIndex {
-		return nil, state.ErrNilValidatorsInState
-	}
-	return s.BeaconState.ValidatorAtIndexReadOnly(idx)
-}

beacon-chain/core/gloas/pending_payment.go

@@ -1,76 +0,0 @@
-package gloas
-
-import (
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"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/pkg/errors"
-)
-
-// 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)
-//
-//	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
-func ProcessBuilderPendingPayments(state state.BeaconState) error {
-	quorum, err := builderQuorumThreshold(state)
-	if err != nil {
-		return errors.Wrap(err, "could not compute builder payment quorum threshold")
-	}
-
-	payments, err := state.BuilderPendingPayments()
-	if err != nil {
-		return errors.Wrap(err, "could not get builder pending payments")
-	}
-
-	slotsPerEpoch := uint64(params.BeaconConfig().SlotsPerEpoch)
-	var withdrawals []*ethpb.BuilderPendingWithdrawal
-	for _, payment := range payments[:slotsPerEpoch] {
-		if quorum > payment.Weight {
-			continue
-		}
-		withdrawals = append(withdrawals, payment.Withdrawal)
-	}
-
-	if err := state.AppendBuilderPendingWithdrawals(withdrawals); err != nil {
-		return errors.Wrap(err, "could not append builder pending withdrawals")
-	}
-
-	if err := state.RotateBuilderPendingPayments(); err != nil {
-		return errors.Wrap(err, "could not rotate builder pending payments")
-	}
-
-	return nil
-}
-
-// 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)
-func builderQuorumThreshold(state state.ReadOnlyBeaconState) (primitives.Gwei, error) {
-	activeBalance, err := helpers.TotalActiveBalance(state)
-	if err != nil {
-		return 0, errors.Wrap(err, "could not get total active balance")
-	}
-
-	cfg := params.BeaconConfig()
-	slotsPerEpoch := uint64(cfg.SlotsPerEpoch)
-	numerator := cfg.BuilderPaymentThresholdNumerator
-	denominator := cfg.BuilderPaymentThresholdDenominator
-
-	activeBalancePerSlot := activeBalance / slotsPerEpoch
-	quorum := (activeBalancePerSlot * numerator) / denominator
-	return primitives.Gwei(quorum), nil
-}

beacon-chain/core/gloas/pending_payment_test.go

@@ -1,119 +0,0 @@
-package gloas
-
-import (
-	"slices"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	"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/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-)
-
-func TestBuilderQuorumThreshold(t *testing.T) {
-	helpers.ClearCache()
-	cfg := params.BeaconConfig()
-
-	validators := []*ethpb.Validator{
-		{EffectiveBalance: cfg.MaxEffectiveBalance, ActivationEpoch: 0, ExitEpoch: 1},
-		{EffectiveBalance: cfg.MaxEffectiveBalance, ActivationEpoch: 0, ExitEpoch: 1},
-	}
-	st, err := state_native.InitializeFromProtoUnsafeGloas(&ethpb.BeaconStateGloas{Validators: validators})
-	require.NoError(t, err)
-
-	got, err := builderQuorumThreshold(st)
-	require.NoError(t, err)
-
-	total := uint64(len(validators)) * cfg.MaxEffectiveBalance
-	perSlot := total / uint64(cfg.SlotsPerEpoch)
-	want := (perSlot * cfg.BuilderPaymentThresholdNumerator) / cfg.BuilderPaymentThresholdDenominator
-	require.Equal(t, primitives.Gwei(want), got)
-}
-
-func TestProcessBuilderPendingPayments(t *testing.T) {
-	helpers.ClearCache()
-	cfg := params.BeaconConfig()
-
-	buildPayments := func(weights ...primitives.Gwei) []*ethpb.BuilderPendingPayment {
-		p := make([]*ethpb.BuilderPendingPayment, 2*int(cfg.SlotsPerEpoch))
-		for i := range p {
-			p[i] = &ethpb.BuilderPendingPayment{
-				Withdrawal: &ethpb.BuilderPendingWithdrawal{FeeRecipient: make([]byte, 20)},
-			}
-		}
-		for i, w := range weights {
-			p[i].Weight = w
-			p[i].Withdrawal.Amount = 1
-		}
-		return p
-	}
-
-	validators := []*ethpb.Validator{
-		{EffectiveBalance: cfg.MaxEffectiveBalance, ActivationEpoch: 0, ExitEpoch: 1},
-		{EffectiveBalance: cfg.MaxEffectiveBalance, ActivationEpoch: 0, ExitEpoch: 1},
-	}
-	pbSt, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{Validators: validators})
-	require.NoError(t, err)
-
-	total := uint64(len(validators)) * cfg.MaxEffectiveBalance
-	perSlot := total / uint64(cfg.SlotsPerEpoch)
-	quorum := (perSlot * cfg.BuilderPaymentThresholdNumerator) / cfg.BuilderPaymentThresholdDenominator
-	slotsPerEpoch := int(cfg.SlotsPerEpoch)
-
-	t.Run("append qualifying withdrawals", func(t *testing.T) {
-		payments := buildPayments(primitives.Gwei(quorum+1), primitives.Gwei(quorum+2))
-		st := &testProcessState{BeaconState: pbSt, payments: payments}
-
-		require.NoError(t, ProcessBuilderPendingPayments(st))
-		require.Equal(t, 2, len(st.withdrawals))
-		require.Equal(t, payments[0].Withdrawal, st.withdrawals[0])
-		require.Equal(t, payments[1].Withdrawal, st.withdrawals[1])
-
-		require.Equal(t, 2*slotsPerEpoch, len(st.payments))
-		for i := slotsPerEpoch; i < 2*slotsPerEpoch; i++ {
-			require.Equal(t, primitives.Gwei(0), st.payments[i].Weight)
-			require.Equal(t, primitives.Gwei(0), st.payments[i].Withdrawal.Amount)
-			require.Equal(t, 20, len(st.payments[i].Withdrawal.FeeRecipient))
-		}
-	})
-
-	t.Run("no withdrawals when below quorum", func(t *testing.T) {
-		payments := buildPayments(primitives.Gwei(quorum - 1))
-		st := &testProcessState{BeaconState: pbSt, payments: payments}
-
-		require.NoError(t, ProcessBuilderPendingPayments(st))
-		require.Equal(t, 0, len(st.withdrawals))
-	})
-}
-
-type testProcessState struct {
-	state.BeaconState
-	payments    []*ethpb.BuilderPendingPayment
-	withdrawals []*ethpb.BuilderPendingWithdrawal
-}
-
-func (t *testProcessState) BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment, error) {
-	return t.payments, nil
-}
-
-func (t *testProcessState) AppendBuilderPendingWithdrawals(withdrawals []*ethpb.BuilderPendingWithdrawal) error {
-	t.withdrawals = append(t.withdrawals, withdrawals...)
-	return nil
-}
-
-func (t *testProcessState) RotateBuilderPendingPayments() error {
-	slotsPerEpoch := int(params.BeaconConfig().SlotsPerEpoch)
-	rotated := slices.Clone(t.payments[slotsPerEpoch:])
-	for range slotsPerEpoch {
-		rotated = append(rotated, &ethpb.BuilderPendingPayment{
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: make([]byte, 20),
-			},
-		})
-	}
-	t.payments = rotated
-	return nil
-}

beacon-chain/core/gloas/proposer_slashing.go

@@ -1,43 +0,0 @@
-package gloas
-
-import (
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-	"github.com/pkg/errors"
-)
-
-// RemoveBuilderPendingPayment removes the pending builder payment for the proposal slot.
-// Spec v1.7.0 (pseudocode):
-//
-//	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()
-//	elif proposal_epoch == get_previous_epoch(state):
-//	  payment_index = slot % SLOTS_PER_EPOCH
-//	  state.builder_pending_payments[payment_index] = BuilderPendingPayment()
-func RemoveBuilderPendingPayment(st state.BeaconState, header *eth.BeaconBlockHeader) error {
-	proposalEpoch := slots.ToEpoch(header.Slot)
-	currentEpoch := time.CurrentEpoch(st)
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-
-	var paymentIndex primitives.Slot
-	if proposalEpoch == currentEpoch {
-		paymentIndex = slotsPerEpoch + header.Slot%slotsPerEpoch
-	} else if proposalEpoch+1 == currentEpoch {
-		paymentIndex = header.Slot % slotsPerEpoch
-	} else {
-		return nil
-	}
-
-	if err := st.ClearBuilderPendingPayment(paymentIndex); err != nil {
-		return errors.Wrap(err, "could not clear builder pending payment")
-	}
-
-	return nil
-}

beacon-chain/core/gloas/proposer_slashing_test.go

@@ -1,112 +0,0 @@
-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"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-)
-
-func TestRemoveBuilderPendingPayment_CurrentEpoch(t *testing.T) {
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	stateSlot := slotsPerEpoch*2 + 1
-	headerSlot := slotsPerEpoch * 2
-
-	st := newGloasStateWithPayments(t, stateSlot)
-	paymentIndex := int(slotsPerEpoch + headerSlot%slotsPerEpoch)
-
-	setPendingPayment(t, st, paymentIndex, 123)
-
-	err := RemoveBuilderPendingPayment(st, &eth.BeaconBlockHeader{Slot: headerSlot})
-	require.NoError(t, err)
-
-	got := getPendingPayment(t, st, paymentIndex)
-	require.NotNil(t, got.Withdrawal)
-	require.DeepEqual(t, make([]byte, 20), got.Withdrawal.FeeRecipient)
-	require.Equal(t, uint64(0), uint64(got.Withdrawal.Amount))
-}
-
-func TestRemoveBuilderPendingPayment_PreviousEpoch(t *testing.T) {
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	stateSlot := slotsPerEpoch*2 + 1
-	headerSlot := slotsPerEpoch + 7
-
-	st := newGloasStateWithPayments(t, stateSlot)
-	paymentIndex := int(headerSlot % slotsPerEpoch)
-
-	setPendingPayment(t, st, paymentIndex, 456)
-
-	err := RemoveBuilderPendingPayment(st, &eth.BeaconBlockHeader{Slot: headerSlot})
-	require.NoError(t, err)
-
-	got := getPendingPayment(t, st, paymentIndex)
-	require.NotNil(t, got.Withdrawal)
-	require.DeepEqual(t, make([]byte, 20), got.Withdrawal.FeeRecipient)
-	require.Equal(t, uint64(0), uint64(got.Withdrawal.Amount))
-}
-
-func TestRemoveBuilderPendingPayment_OlderThanTwoEpoch(t *testing.T) {
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	stateSlot := slotsPerEpoch*4 + 1 // current epoch far ahead
-	headerSlot := slotsPerEpoch * 2  // two epochs behind
-
-	st := newGloasStateWithPayments(t, stateSlot)
-	paymentIndex := int(headerSlot % slotsPerEpoch)
-
-	original := getPendingPayment(t, st, paymentIndex)
-
-	err := RemoveBuilderPendingPayment(st, &eth.BeaconBlockHeader{Slot: headerSlot})
-	require.NoError(t, err)
-
-	after := getPendingPayment(t, st, paymentIndex)
-	require.DeepEqual(t, original.Withdrawal.FeeRecipient, after.Withdrawal.FeeRecipient)
-	require.Equal(t, original.Withdrawal.Amount, after.Withdrawal.Amount)
-}
-
-func newGloasStateWithPayments(t *testing.T, slot primitives.Slot) state.BeaconState {
-	t.Helper()
-
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	paymentCount := int(slotsPerEpoch * 2)
-	payments := make([]*eth.BuilderPendingPayment, paymentCount)
-	for i := range payments {
-		payments[i] = &eth.BuilderPendingPayment{
-			Withdrawal: &eth.BuilderPendingWithdrawal{
-				FeeRecipient: bytes.Repeat([]byte{0x01}, 20),
-				Amount:       1,
-			},
-		}
-	}
-
-	st, err := state_native.InitializeFromProtoUnsafeGloas(&eth.BeaconStateGloas{
-		Slot:                   slot,
-		BuilderPendingPayments: payments,
-	})
-	require.NoError(t, err)
-	return st
-}
-
-func setPendingPayment(t *testing.T, st state.BeaconState, index int, amount uint64) {
-	t.Helper()
-
-	payment := &eth.BuilderPendingPayment{
-		Withdrawal: &eth.BuilderPendingWithdrawal{
-			FeeRecipient: bytes.Repeat([]byte{0x02}, 20),
-			Amount:       primitives.Gwei(amount),
-		},
-	}
-	require.NoError(t, st.SetBuilderPendingPayment(primitives.Slot(index), payment))
-}
-
-func getPendingPayment(t *testing.T, st state.BeaconState, index int) *eth.BuilderPendingPayment {
-	t.Helper()
-
-	stateProto := st.ToProtoUnsafe().(*eth.BeaconStateGloas)
-
-	return stateProto.BuilderPendingPayments[index]
-}

beacon-chain/core/helpers/BUILD.bazel

@@ -6,7 +6,6 @@ go_library(
         "attestation.go",
         "beacon_committee.go",
         "block.go",
-        "deposit.go",
         "genesis.go",
         "legacy.go",
         "log.go",
@@ -24,7 +23,6 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//beacon-chain/cache:go_default_library",
-        "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/state:go_default_library",
@@ -33,7 +31,6 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
         "//container/trie:go_default_library",
-        "//contracts/deposit:go_default_library",
         "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
@@ -57,7 +54,6 @@ go_test(
         "attestation_test.go",
         "beacon_committee_test.go",
         "block_test.go",
-        "deposit_test.go",
         "legacy_test.go",
         "private_access_fuzz_noop_test.go",  # keep
         "private_access_test.go",
@@ -76,7 +72,6 @@ go_test(
     tags = ["CI_race_detection"],
     deps = [
         "//beacon-chain/cache:go_default_library",
-        "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/state:go_default_library",
@@ -85,8 +80,6 @@ go_test(
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
-        "//container/trie:go_default_library",
-        "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/core/peerdas/BUILD.bazel

@@ -33,7 +33,6 @@ go_library(
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
-        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@org_golang_x_sync//errgroup:go_default_library",
     ],
 )

beacon-chain/core/peerdas/p2p_interface.go

@@ -1,15 +1,11 @@
 package peerdas
 
 import (
-	stderrors "errors"
-	"iter"
-
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/kzg"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v7/container/trie"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/ethereum/go-ethereum/p2p/enr"
 	"github.com/pkg/errors"
 )
@@ -20,7 +16,6 @@ var (
 	ErrIndexTooLarge               = errors.New("column index is larger than the specified columns count")
 	ErrNoKzgCommitments            = errors.New("no KZG commitments found")
 	ErrMismatchLength              = errors.New("mismatch in the length of the column, commitments or proofs")
-	ErrEmptySegment                = errors.New("empty segment in batch")
 	ErrInvalidKZGProof             = errors.New("invalid KZG proof")
 	ErrBadRootLength               = errors.New("bad root length")
 	ErrInvalidInclusionProof       = errors.New("invalid inclusion proof")
@@ -62,127 +57,62 @@ func VerifyDataColumnSidecar(sidecar blocks.RODataColumn) error {
 	return nil
 }
 
-// CellProofBundleSegment is returned when a batch fails. The caller can call
-// the `.Verify` method to verify just this segment.
-type CellProofBundleSegment struct {
-	indices     []uint64
-	commitments []kzg.Bytes48
-	cells       []kzg.Cell
-	proofs      []kzg.Bytes48
-}
-
-// Verify verifies this segment without batching.
-func (s CellProofBundleSegment) Verify() error {
-	if len(s.cells) == 0 {
-		return ErrEmptySegment
-	}
-	verified, err := kzg.VerifyCellKZGProofBatch(s.commitments, s.indices, s.cells, s.proofs)
-	if err != nil {
-		return stderrors.Join(err, ErrInvalidKZGProof)
-	}
-	if !verified {
-		return ErrInvalidKZGProof
-	}
-	return nil
-}
-
-func VerifyDataColumnsCellsKZGProofs(sizeHint int, cellProofsIter iter.Seq[blocks.CellProofBundle]) error {
-	// ignore the failed segment list since we are just passing in one segment.
-	_, err := BatchVerifyDataColumnsCellsKZGProofs(sizeHint, []iter.Seq[blocks.CellProofBundle]{cellProofsIter})
-	return err
-}
-
-// BatchVerifyDataColumnsCellsKZGProofs verifies if the KZG proofs are correct.
+// VerifyDataColumnsSidecarKZGProofs verifies if the KZG proofs are correct.
 // Note: We are slightly deviating from the specification here:
 // The specification verifies the KZG proofs for each sidecar separately,
 // while we are verifying all the KZG proofs from multiple sidecars in a batch.
 // This is done to improve performance since the internal KZG library is way more
-// efficient when verifying in batch. If the batch fails, the failed segments
-// are returned to the caller so that they may try segment by segment without
-// batching. On success the failed segment list is empty.
-//
+// efficient when verifying in batch.
 // https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/p2p-interface.md#verify_data_column_sidecar_kzg_proofs
-func BatchVerifyDataColumnsCellsKZGProofs(sizeHint int, cellProofsIters []iter.Seq[blocks.CellProofBundle]) ( /* failed segment list */ []CellProofBundleSegment, error) {
-	commitments := make([]kzg.Bytes48, 0, sizeHint)
-	indices := make([]uint64, 0, sizeHint)
-	cells := make([]kzg.Cell, 0, sizeHint)
-	proofs := make([]kzg.Bytes48, 0, sizeHint)
+func VerifyDataColumnsSidecarKZGProofs(sidecars []blocks.RODataColumn) error {
+	// Compute the total count.
+	count := 0
+	for _, sidecar := range sidecars {
+		count += len(sidecar.Column)
+	}
 
-	var anySegmentEmpty bool
-	var segments []CellProofBundleSegment
-	for _, cellProofsIter := range cellProofsIters {
-		startIdx := len(cells)
-		for bundle := range cellProofsIter {
+	commitments := make([]kzg.Bytes48, 0, count)
+	indices := make([]uint64, 0, count)
+	cells := make([]kzg.Cell, 0, count)
+	proofs := make([]kzg.Bytes48, 0, count)
+
+	for _, sidecar := range sidecars {
+		for i := range sidecar.Column {
 			var (
 				commitment kzg.Bytes48
 				cell       kzg.Cell
 				proof      kzg.Bytes48
 			)
 
-			if len(bundle.Commitment) != len(commitment) ||
-				len(bundle.Cell) != len(cell) ||
-				len(bundle.Proof) != len(proof) {
-				return nil, ErrMismatchLength
+			commitmentBytes := sidecar.KzgCommitments[i]
+			cellBytes := sidecar.Column[i]
+			proofBytes := sidecar.KzgProofs[i]
+
+			if len(commitmentBytes) != len(commitment) ||
+				len(cellBytes) != len(cell) ||
+				len(proofBytes) != len(proof) {
+				return ErrMismatchLength
 			}
 
-			copy(commitment[:], bundle.Commitment)
-			copy(cell[:], bundle.Cell)
-			copy(proof[:], bundle.Proof)
+			copy(commitment[:], commitmentBytes)
+			copy(cell[:], cellBytes)
+			copy(proof[:], proofBytes)
 
 			commitments = append(commitments, commitment)
-			indices = append(indices, bundle.ColumnIndex)
+			indices = append(indices, sidecar.Index)
 			cells = append(cells, cell)
 			proofs = append(proofs, proof)
 		}
-		if len(cells[startIdx:]) == 0 {
-			anySegmentEmpty = true
-		}
-		segments = append(segments, CellProofBundleSegment{
-			indices:     indices[startIdx:],
-			commitments: commitments[startIdx:],
-			cells:       cells[startIdx:],
-			proofs:      proofs[startIdx:],
-		})
-	}
-
-	if anySegmentEmpty {
-		return segments, ErrEmptySegment
 	}
 
 	// Batch verify that the cells match the corresponding commitments and proofs.
 	verified, err := kzg.VerifyCellKZGProofBatch(commitments, indices, cells, proofs)
 	if err != nil {
-		return segments, stderrors.Join(err, ErrInvalidKZGProof)
+		return errors.Wrap(err, "verify cell KZG proof batch")
 	}
 
 	if !verified {
-		return segments, ErrInvalidKZGProof
-	}
-
-	return nil, nil
-}
-
-// verifyKzgCommitmentsInclusionProof is the shared implementation for inclusion proof verification.
-func verifyKzgCommitmentsInclusionProof(bodyRoot []byte, kzgCommitments [][]byte, inclusionProof [][]byte) error {
-	if len(bodyRoot) != fieldparams.RootLength {
-		return ErrBadRootLength
-	}
-
-	leaves := blocks.LeavesFromCommitments(kzgCommitments)
-
-	sparse, err := trie.GenerateTrieFromItems(leaves, fieldparams.LogMaxBlobCommitments)
-	if err != nil {
-		return errors.Wrap(err, "generate trie from items")
-	}
-
-	hashTreeRoot, err := sparse.HashTreeRoot()
-	if err != nil {
-		return errors.Wrap(err, "hash tree root")
-	}
-
-	verified := trie.VerifyMerkleProof(bodyRoot, hashTreeRoot[:], kzgPosition, inclusionProof)
-	if !verified {
-		return ErrInvalidInclusionProof
+		return ErrInvalidKZGProof
 	}
 
 	return nil
@@ -194,23 +124,30 @@ func VerifyDataColumnSidecarInclusionProof(sidecar blocks.RODataColumn) error {
 	if sidecar.SignedBlockHeader == nil || sidecar.SignedBlockHeader.Header == nil {
 		return ErrNilBlockHeader
 	}
-	return verifyKzgCommitmentsInclusionProof(
-		sidecar.SignedBlockHeader.Header.BodyRoot,
-		sidecar.KzgCommitments,
-		sidecar.KzgCommitmentsInclusionProof,
-	)
-}
 
-// VerifyPartialDataColumnHeaderInclusionProof verifies if the KZG commitments are included in the beacon block.
-func VerifyPartialDataColumnHeaderInclusionProof(header *ethpb.PartialDataColumnHeader) error {
-	if header.SignedBlockHeader == nil || header.SignedBlockHeader.Header == nil {
-		return ErrNilBlockHeader
+	root := sidecar.SignedBlockHeader.Header.BodyRoot
+	if len(root) != fieldparams.RootLength {
+		return ErrBadRootLength
 	}
-	return verifyKzgCommitmentsInclusionProof(
-		header.SignedBlockHeader.Header.BodyRoot,
-		header.KzgCommitments,
-		header.KzgCommitmentsInclusionProof,
-	)
+
+	leaves := blocks.LeavesFromCommitments(sidecar.KzgCommitments)
+
+	sparse, err := trie.GenerateTrieFromItems(leaves, fieldparams.LogMaxBlobCommitments)
+	if err != nil {
+		return errors.Wrap(err, "generate trie from items")
+	}
+
+	hashTreeRoot, err := sparse.HashTreeRoot()
+	if err != nil {
+		return errors.Wrap(err, "hash tree root")
+	}
+
+	verified := trie.VerifyMerkleProof(root, hashTreeRoot[:], kzgPosition, sidecar.KzgCommitmentsInclusionProof)
+	if !verified {
+		return ErrInvalidInclusionProof
+	}
+
+	return nil
 }
 
 // ComputeSubnetForDataColumnSidecar computes the subnet for a data column sidecar.

beacon-chain/core/peerdas/p2p_interface_test.go

@@ -3,7 +3,6 @@ package peerdas_test
 import (
 	"crypto/rand"
 	"fmt"
-	"iter"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/kzg"
@@ -73,7 +72,7 @@ func TestVerifyDataColumnSidecarKZGProofs(t *testing.T) {
 		sidecars := generateRandomSidecars(t, seed, blobCount)
 		sidecars[0].Column[0] = sidecars[0].Column[0][:len(sidecars[0].Column[0])-1] // Remove one byte to create size mismatch
 
-		err := peerdas.VerifyDataColumnsCellsKZGProofs(0, blocks.RODataColumnsToCellProofBundles(sidecars))
+		err := peerdas.VerifyDataColumnsSidecarKZGProofs(sidecars)
 		require.ErrorIs(t, err, peerdas.ErrMismatchLength)
 	})
 
@@ -81,15 +80,14 @@ func TestVerifyDataColumnSidecarKZGProofs(t *testing.T) {
 		sidecars := generateRandomSidecars(t, seed, blobCount)
 		sidecars[0].Column[0][0]++ // It is OK to overflow
 
-		err := peerdas.VerifyDataColumnsCellsKZGProofs(0, blocks.RODataColumnsToCellProofBundles(sidecars))
+		err := peerdas.VerifyDataColumnsSidecarKZGProofs(sidecars)
 		require.ErrorIs(t, err, peerdas.ErrInvalidKZGProof)
 	})
 
 	t.Run("nominal", func(t *testing.T) {
 		sidecars := generateRandomSidecars(t, seed, blobCount)
-		failedSegments, err := peerdas.BatchVerifyDataColumnsCellsKZGProofs(blobCount, []iter.Seq[blocks.CellProofBundle]{blocks.RODataColumnsToCellProofBundles(sidecars)})
+		err := peerdas.VerifyDataColumnsSidecarKZGProofs(sidecars)
 		require.NoError(t, err)
-		require.Equal(t, 0, len(failedSegments))
 	})
 }
 
@@ -275,7 +273,7 @@ func BenchmarkVerifyDataColumnSidecarKZGProofs_SameCommitments_NoBatch(b *testin
 		for _, sidecar := range sidecars {
 			sidecars := []blocks.RODataColumn{sidecar}
 			b.StartTimer()
-			err := peerdas.VerifyDataColumnsCellsKZGProofs(0, blocks.RODataColumnsToCellProofBundles(sidecars))
+			err := peerdas.VerifyDataColumnsSidecarKZGProofs(sidecars)
 			b.StopTimer()
 			require.NoError(b, err)
 		}
@@ -310,7 +308,7 @@ func BenchmarkVerifyDataColumnSidecarKZGProofs_DiffCommitments_Batch(b *testing.
 				}
 
 				b.StartTimer()
-				err := peerdas.VerifyDataColumnsCellsKZGProofs(0, blocks.RODataColumnsToCellProofBundles(allSidecars))
+				err := peerdas.VerifyDataColumnsSidecarKZGProofs(allSidecars)
 				b.StopTimer()
 				require.NoError(b, err)
 			}
@@ -343,7 +341,7 @@ func BenchmarkVerifyDataColumnSidecarKZGProofs_DiffCommitments_Batch4(b *testing
 
 		for _, sidecars := range allSidecars {
 			b.StartTimer()
-			err := peerdas.VerifyDataColumnsCellsKZGProofs(len(allSidecars), blocks.RODataColumnsToCellProofBundles(sidecars))
+			err := peerdas.VerifyDataColumnsSidecarKZGProofs(sidecars)
 			b.StopTimer()
 			require.NoError(b, err)
 		}

beacon-chain/core/peerdas/reconstruction.go

@@ -5,7 +5,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/OffchainLabs/go-bitfield"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/kzg"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
@@ -340,8 +339,7 @@ func ComputeCellsAndProofsFromFlat(blobs [][]byte, cellProofs [][]byte) ([][]kzg
 }
 
 // ComputeCellsAndProofsFromStructured computes the cells and proofs from blobs and cell proofs.
-// commitmentCount is required to return the correct sized bitlist even if we see a nil slice of blobsAndProofs.
-func ComputeCellsAndProofsFromStructured(commitmentCount uint64, blobsAndProofs []*pb.BlobAndProofV2) (bitfield.Bitlist /* parts included */, [][]kzg.Cell, [][]kzg.Proof, error) {
+func ComputeCellsAndProofsFromStructured(blobsAndProofs []*pb.BlobAndProofV2) ([][]kzg.Cell, [][]kzg.Proof, error) {
 	start := time.Now()
 	defer func() {
 		cellsAndProofsFromStructuredComputationTime.Observe(float64(time.Since(start).Milliseconds()))
@@ -349,24 +347,14 @@ func ComputeCellsAndProofsFromStructured(commitmentCount uint64, blobsAndProofs
 
 	var wg errgroup.Group
 
-	var blobsPresent int
-	for _, blobAndProof := range blobsAndProofs {
-		if blobAndProof != nil {
-			blobsPresent++
-		}
-	}
-	cellsPerBlob := make([][]kzg.Cell, blobsPresent)
-	proofsPerBlob := make([][]kzg.Proof, blobsPresent)
-	included := bitfield.NewBitlist(commitmentCount)
+	cellsPerBlob := make([][]kzg.Cell, len(blobsAndProofs))
+	proofsPerBlob := make([][]kzg.Proof, len(blobsAndProofs))
 
-	var j int
 	for i, blobAndProof := range blobsAndProofs {
 		if blobAndProof == nil {
-			continue
+			return nil, nil, ErrNilBlobAndProof
 		}
-		included.SetBitAt(uint64(i), true)
 
-		compactIndex := j
 		wg.Go(func() error {
 			var kzgBlob kzg.Blob
 			if copy(kzgBlob[:], blobAndProof.Blob) != len(kzgBlob) {
@@ -393,18 +381,17 @@ func ComputeCellsAndProofsFromStructured(commitmentCount uint64, blobsAndProofs
 				kzgProofs = append(kzgProofs, kzgProof)
 			}
 
-			cellsPerBlob[compactIndex] = cells
-			proofsPerBlob[compactIndex] = kzgProofs
+			cellsPerBlob[i] = cells
+			proofsPerBlob[i] = kzgProofs
 			return nil
 		})
-		j++
 	}
 
 	if err := wg.Wait(); err != nil {
-		return nil, nil, nil, err
+		return nil, nil, err
 	}
 
-	return included, cellsPerBlob, proofsPerBlob, nil
+	return cellsPerBlob, proofsPerBlob, nil
 }
 
 // ReconstructBlobs reconstructs blobs from data column sidecars without computing KZG proofs or creating sidecars.

beacon-chain/core/peerdas/reconstruction_test.go

@@ -479,9 +479,8 @@ func TestComputeCellsAndProofsFromFlat(t *testing.T) {
 
 func TestComputeCellsAndProofsFromStructured(t *testing.T) {
 	t.Run("nil blob and proof", func(t *testing.T) {
-		included, _, _, err := peerdas.ComputeCellsAndProofsFromStructured(0, []*pb.BlobAndProofV2{nil})
-		require.NoError(t, err)
-		require.Equal(t, uint64(0), included.Count())
+		_, _, err := peerdas.ComputeCellsAndProofsFromStructured([]*pb.BlobAndProofV2{nil})
+		require.ErrorIs(t, err, peerdas.ErrNilBlobAndProof)
 	})
 
 	t.Run("nominal", func(t *testing.T) {
@@ -534,8 +533,7 @@ func TestComputeCellsAndProofsFromStructured(t *testing.T) {
 		require.NoError(t, err)
 
 		// Test ComputeCellsAndProofs
-		included, actualCellsPerBlob, actualProofsPerBlob, err := peerdas.ComputeCellsAndProofsFromStructured(uint64(len(blobsAndProofs)), blobsAndProofs)
-		require.Equal(t, included.Count(), uint64(len(actualCellsPerBlob)))
+		actualCellsPerBlob, actualProofsPerBlob, err := peerdas.ComputeCellsAndProofsFromStructured(blobsAndProofs)
 		require.NoError(t, err)
 		require.Equal(t, blobCount, len(actualCellsPerBlob))
 

beacon-chain/core/peerdas/validator.go

@@ -3,7 +3,6 @@ package peerdas
 import (
 	"time"
 
-	"github.com/OffchainLabs/go-bitfield"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/kzg"
 	beaconState "github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
@@ -24,13 +23,11 @@ var (
 var (
 	_ ConstructionPopulator = (*BlockReconstructionSource)(nil)
 	_ ConstructionPopulator = (*SidecarReconstructionSource)(nil)
-	_ ConstructionPopulator = (*PartialDataColumnHeaderReconstructionSource)(nil)
 )
 
 const (
-	BlockType                   = "BeaconBlock"
-	SidecarType                 = "DataColumnSidecar"
-	PartialDataColumnHeaderType = "PartialDataColumnHeader"
+	BlockType   = "BeaconBlock"
+	SidecarType = "DataColumnSidecar"
 )
 
 type (
@@ -57,10 +54,6 @@ type (
 		blocks.VerifiedRODataColumn
 	}
 
-	PartialDataColumnHeaderReconstructionSource struct {
-		*ethpb.PartialDataColumnHeader
-	}
-
 	blockInfo struct {
 		signedBlockHeader *ethpb.SignedBeaconBlockHeader
 		kzgCommitments    [][]byte
@@ -78,11 +71,6 @@ func PopulateFromSidecar(sidecar blocks.VerifiedRODataColumn) *SidecarReconstruc
 	return &SidecarReconstructionSource{VerifiedRODataColumn: sidecar}
 }
 
-// PopulateFromPartialHeader creates a PartialDataColumnHeaderReconstructionSource from a partial header
-func PopulateFromPartialHeader(header *ethpb.PartialDataColumnHeader) *PartialDataColumnHeaderReconstructionSource {
-	return &PartialDataColumnHeaderReconstructionSource{PartialDataColumnHeader: header}
-}
-
 // ValidatorsCustodyRequirement returns the number of custody groups regarding the validator indices attached to the beacon node.
 // https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#validator-custody
 func ValidatorsCustodyRequirement(state beaconState.ReadOnlyBeaconState, validatorsIndex map[primitives.ValidatorIndex]bool) (uint64, error) {
@@ -155,40 +143,6 @@ func DataColumnSidecars(cellsPerBlob [][]kzg.Cell, proofsPerBlob [][]kzg.Proof,
 	return roSidecars, nil
 }
 
-func PartialColumns(included bitfield.Bitlist, cellsPerBlob [][]kzg.Cell, proofsPerBlob [][]kzg.Proof, src ConstructionPopulator) ([]blocks.PartialDataColumn, error) {
-	start := time.Now()
-	const numberOfColumns = uint64(fieldparams.NumberOfColumns)
-	cells, proofs, err := rotateRowsToCols(cellsPerBlob, proofsPerBlob, numberOfColumns)
-	if err != nil {
-		return nil, errors.Wrap(err, "rotate cells and proofs")
-	}
-	info, err := src.extract()
-	if err != nil {
-		return nil, errors.Wrap(err, "extract block info")
-	}
-
-	dataColumns := make([]blocks.PartialDataColumn, 0, numberOfColumns)
-	for idx := range numberOfColumns {
-		dc, err := blocks.NewPartialDataColumn(info.signedBlockHeader, idx, info.kzgCommitments, info.kzgInclusionProof)
-		if err != nil {
-			return nil, errors.Wrap(err, "new ro data column")
-		}
-
-		for i := range len(info.kzgCommitments) {
-			if !included.BitAt(uint64(i)) {
-				continue
-			}
-			dc.ExtendFromVerfifiedCell(uint64(i), cells[idx][0], proofs[idx][0])
-			cells[idx] = cells[idx][1:]
-			proofs[idx] = proofs[idx][1:]
-		}
-		dataColumns = append(dataColumns, dc)
-	}
-
-	dataColumnComputationTime.Observe(float64(time.Since(start).Milliseconds()))
-	return dataColumns, nil
-}
-
 // Slot returns the slot of the source
 func (s *BlockReconstructionSource) Slot() primitives.Slot {
 	return s.Block().Slot()
@@ -300,43 +254,3 @@ func (s *SidecarReconstructionSource) extract() (*blockInfo, error) {
 
 	return info, nil
 }
-
-// Slot returns the slot from the partial data column header
-func (p *PartialDataColumnHeaderReconstructionSource) Slot() primitives.Slot {
-	return p.SignedBlockHeader.Header.Slot
-}
-
-// Root returns the block root computed from the header
-func (p *PartialDataColumnHeaderReconstructionSource) Root() [fieldparams.RootLength]byte {
-	root, err := p.SignedBlockHeader.Header.HashTreeRoot()
-	if err != nil {
-		return [fieldparams.RootLength]byte{}
-	}
-	return root
-}
-
-// ProposerIndex returns the proposer index from the header
-func (p *PartialDataColumnHeaderReconstructionSource) ProposerIndex() primitives.ValidatorIndex {
-	return p.SignedBlockHeader.Header.ProposerIndex
-}
-
-// Commitments returns the KZG commitments from the header
-func (p *PartialDataColumnHeaderReconstructionSource) Commitments() ([][]byte, error) {
-	return p.KzgCommitments, nil
-}
-
-// Type returns the type of the source
-func (p *PartialDataColumnHeaderReconstructionSource) Type() string {
-	return PartialDataColumnHeaderType
-}
-
-// extract extracts the block information from the partial header
-func (p *PartialDataColumnHeaderReconstructionSource) extract() (*blockInfo, error) {
-	info := &blockInfo{
-		signedBlockHeader: p.SignedBlockHeader,
-		kzgCommitments:    p.KzgCommitments,
-		kzgInclusionProof: p.KzgCommitmentsInclusionProof,
-	}
-
-	return info, nil
-}

beacon-chain/core/peerdas/validator_test.go

@@ -267,31 +267,4 @@ func TestReconstructionSource(t *testing.T) {
 
 		require.Equal(t, peerdas.SidecarType, src.Type())
 	})
-
-	t.Run("from partial header", func(t *testing.T) {
-		referenceSidecar := sidecars[0]
-		partialHeader := &ethpb.PartialDataColumnHeader{
-			SignedBlockHeader:            referenceSidecar.SignedBlockHeader,
-			KzgCommitments:               referenceSidecar.KzgCommitments,
-			KzgCommitmentsInclusionProof: referenceSidecar.KzgCommitmentsInclusionProof,
-		}
-
-		src := peerdas.PopulateFromPartialHeader(partialHeader)
-		require.Equal(t, referenceSidecar.SignedBlockHeader.Header.Slot, src.Slot())
-
-		// Compute expected root
-		expectedRoot, err := referenceSidecar.SignedBlockHeader.Header.HashTreeRoot()
-		require.NoError(t, err)
-		require.Equal(t, expectedRoot, src.Root())
-
-		require.Equal(t, referenceSidecar.SignedBlockHeader.Header.ProposerIndex, src.ProposerIndex())
-
-		commitments, err := src.Commitments()
-		require.NoError(t, err)
-		require.Equal(t, 2, len(commitments))
-		require.DeepEqual(t, commitment1, commitments[0])
-		require.DeepEqual(t, commitment2, commitments[1])
-
-		require.Equal(t, peerdas.PartialDataColumnHeaderType, src.Type())
-	})
 }

beacon-chain/core/requests/BUILD.bazel

@@ -1,60 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "consolidations.go",
-        "deposits.go",
-        "log.go",
-        "withdrawals.go",
-    ],
-    importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/requests",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/validators:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/state-native:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//crypto/bls/common:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//math:go_default_library",
-        "//monitoring/tracing/trace:go_default_library",
-        "//proto/engine/v1:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//runtime/version:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/math:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = [
-        "consolidations_test.go",
-        "deposits_test.go",
-        "withdrawals_test.go",
-    ],
-    deps = [
-        ":go_default_library",
-        "//beacon-chain/core/signing:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/state-native:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//crypto/bls:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/engine/v1:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/util:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
-    ],
-)

beacon-chain/core/requests/consolidations.go

@@ -1,365 +0,0 @@
-package requests
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	"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/primitives"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls/common"
-	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
-	prysmMath "github.com/OffchainLabs/prysm/v7/math"
-	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-	"github.com/ethereum/go-ethereum/common/math"
-	"github.com/pkg/errors"
-)
-
-// ProcessConsolidationRequests implements the spec definition below. This method makes mutating
-// calls to the beacon state.
-//
-//	def process_consolidation_request(
-//	    state: BeaconState,
-//	    consolidation_request: ConsolidationRequest
-//	) -> None:
-//	    if is_valid_switch_to_compounding_request(state, consolidation_request):
-//	        validator_pubkeys = [v.pubkey for v in state.validators]
-//	        request_source_pubkey = consolidation_request.source_pubkey
-//	        source_index = ValidatorIndex(validator_pubkeys.index(request_source_pubkey))
-//	        switch_to_compounding_validator(state, source_index)
-//	        return
-//
-//	    # Verify that source != target, so a consolidation cannot be used as an exit.
-//	    if consolidation_request.source_pubkey == consolidation_request.target_pubkey:
-//	        return
-//	    # If the pending consolidations queue is full, consolidation requests are ignored
-//	    if len(state.pending_consolidations) == PENDING_CONSOLIDATIONS_LIMIT:
-//	        return
-//	    # If there is too little available consolidation churn limit, consolidation requests are ignored
-//	    if get_consolidation_churn_limit(state) <= MIN_ACTIVATION_BALANCE:
-//	        return
-//
-//	    validator_pubkeys = [v.pubkey for v in state.validators]
-//	    # Verify pubkeys exists
-//	    request_source_pubkey = consolidation_request.source_pubkey
-//	    request_target_pubkey = consolidation_request.target_pubkey
-//	    if request_source_pubkey not in validator_pubkeys:
-//	        return
-//	    if request_target_pubkey not in validator_pubkeys:
-//	        return
-//	    source_index = ValidatorIndex(validator_pubkeys.index(request_source_pubkey))
-//	    target_index = ValidatorIndex(validator_pubkeys.index(request_target_pubkey))
-//	    source_validator = state.validators[source_index]
-//	    target_validator = state.validators[target_index]
-//
-//	    # Verify source withdrawal credentials
-//	    has_correct_credential = has_execution_withdrawal_credential(source_validator)
-//	    is_correct_source_address = (
-//	        source_validator.withdrawal_credentials[12:] == consolidation_request.source_address
-//	    )
-//	    if not (has_correct_credential and is_correct_source_address):
-//	        return
-//
-//	    # Verify that target has compounding withdrawal credentials
-//	    if not has_compounding_withdrawal_credential(target_validator):
-//	        return
-//
-//	    # Verify the source and the target are active
-//	    current_epoch = get_current_epoch(state)
-//	    if not is_active_validator(source_validator, current_epoch):
-//	        return
-//	    if not is_active_validator(target_validator, current_epoch):
-//	        return
-//	    # Verify exits for source and target have not been initiated
-//	    if source_validator.exit_epoch != FAR_FUTURE_EPOCH:
-//	        return
-//	    if target_validator.exit_epoch != FAR_FUTURE_EPOCH:
-//	        return
-//
-//	    # Verify the source has been active long enough
-//	    if current_epoch < source_validator.activation_epoch + SHARD_COMMITTEE_PERIOD:
-//	        return
-//
-//	    # Verify the source has no pending withdrawals in the queue
-//	    if get_pending_balance_to_withdraw(state, source_index) > 0:
-//	        return
-//	    # Initiate source validator exit and append pending consolidation
-//	    source_validator.exit_epoch = compute_consolidation_epoch_and_update_churn(
-//	        state, source_validator.effective_balance
-//	    )
-//	    source_validator.withdrawable_epoch = Epoch(
-//	        source_validator.exit_epoch + MIN_VALIDATOR_WITHDRAWABILITY_DELAY
-//	    )
-//	    state.pending_consolidations.append(PendingConsolidation(
-//	        source_index=source_index,
-//	        target_index=target_index
-//	    ))
-func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, reqs []*enginev1.ConsolidationRequest) error {
-	ctx, span := trace.StartSpan(ctx, "requests.ProcessConsolidationRequests")
-	defer span.End()
-
-	if len(reqs) == 0 || st == nil {
-		return nil
-	}
-	curEpoch := slots.ToEpoch(st.Slot())
-	ffe := params.BeaconConfig().FarFutureEpoch
-	minValWithdrawDelay := params.BeaconConfig().MinValidatorWithdrawabilityDelay
-	pcLimit := params.BeaconConfig().PendingConsolidationsLimit
-
-	for _, cr := range reqs {
-		if cr == nil {
-			return errors.New("nil consolidation request")
-		}
-		if ctx.Err() != nil {
-			return fmt.Errorf("cannot process consolidation requests: %w", ctx.Err())
-		}
-
-		if isValidSwitchToCompoundingRequest(st, cr) {
-			srcIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(cr.SourcePubkey))
-			if !ok {
-				log.Error("Failed to find source validator index")
-				continue
-			}
-			if err := switchToCompoundingValidator(st, srcIdx); err != nil {
-				log.WithError(err).Error("Failed to switch to compounding validator")
-			}
-			continue
-		}
-
-		sourcePubkey := bytesutil.ToBytes48(cr.SourcePubkey)
-		targetPubkey := bytesutil.ToBytes48(cr.TargetPubkey)
-		if sourcePubkey == targetPubkey {
-			continue
-		}
-
-		if npc, err := st.NumPendingConsolidations(); err != nil {
-			return fmt.Errorf("failed to fetch number of pending consolidations: %w", err) // This should never happen.
-		} else if npc >= pcLimit {
-			continue
-		}
-
-		activeBal, err := helpers.TotalActiveBalance(st)
-		if err != nil {
-			return err
-		}
-		churnLimit := helpers.ConsolidationChurnLimit(primitives.Gwei(activeBal))
-		if churnLimit <= primitives.Gwei(params.BeaconConfig().MinActivationBalance) {
-			continue
-		}
-
-		srcIdx, ok := st.ValidatorIndexByPubkey(sourcePubkey)
-		if !ok {
-			continue
-		}
-		tgtIdx, ok := st.ValidatorIndexByPubkey(targetPubkey)
-		if !ok {
-			continue
-		}
-
-		srcV, err := st.ValidatorAtIndex(srcIdx)
-		if err != nil {
-			return fmt.Errorf("failed to fetch source validator: %w", err) // This should never happen.
-		}
-
-		roSrcV, err := state_native.NewValidator(srcV)
-		if err != nil {
-			return err
-		}
-
-		tgtV, err := st.ValidatorAtIndexReadOnly(tgtIdx)
-		if err != nil {
-			return fmt.Errorf("failed to fetch target validator: %w", err) // This should never happen.
-		}
-
-		// Verify source withdrawal credentials.
-		if !roSrcV.HasExecutionWithdrawalCredentials() {
-			continue
-		}
-		// Confirm source_validator.withdrawal_credentials[12:] == consolidation_request.source_address.
-		if len(srcV.WithdrawalCredentials) != 32 || len(cr.SourceAddress) != 20 || !bytes.HasSuffix(srcV.WithdrawalCredentials, cr.SourceAddress) {
-			continue
-		}
-
-		// Target validator must have their withdrawal credentials set appropriately.
-		if !tgtV.HasCompoundingWithdrawalCredentials() {
-			continue
-		}
-
-		// Both validators must be active.
-		if !helpers.IsActiveValidator(srcV, curEpoch) || !helpers.IsActiveValidatorUsingTrie(tgtV, curEpoch) {
-			continue
-		}
-		// Neither validator is exiting.
-		if srcV.ExitEpoch != ffe || tgtV.ExitEpoch() != ffe {
-			continue
-		}
-
-		e, overflow := math.SafeAdd(uint64(srcV.ActivationEpoch), uint64(params.BeaconConfig().ShardCommitteePeriod))
-		if overflow {
-			log.Error("Overflow when adding activation epoch and shard committee period")
-			continue
-		}
-		if uint64(curEpoch) < e {
-			continue
-		}
-
-		hasBal, err := st.HasPendingBalanceToWithdraw(srcIdx)
-		if err != nil {
-			log.WithError(err).Error("Failed to fetch pending balance to withdraw")
-			continue
-		}
-		if hasBal {
-			continue
-		}
-
-		exitEpoch, err := computeConsolidationEpochAndUpdateChurn(st, primitives.Gwei(srcV.EffectiveBalance))
-		if err != nil {
-			log.WithError(err).Error("Failed to compute consolidation epoch")
-			continue
-		}
-		srcV.ExitEpoch = exitEpoch
-		srcV.WithdrawableEpoch = exitEpoch + minValWithdrawDelay
-		if err := st.UpdateValidatorAtIndex(srcIdx, srcV); err != nil {
-			return fmt.Errorf("failed to update validator: %w", err) // This should never happen.
-		}
-
-		if err := st.AppendPendingConsolidation(&eth.PendingConsolidation{SourceIndex: srcIdx, TargetIndex: tgtIdx}); err != nil {
-			return fmt.Errorf("failed to append pending consolidation: %w", err) // This should never happen.
-		}
-	}
-
-	return nil
-}
-
-func isValidSwitchToCompoundingRequest(st state.BeaconState, req *enginev1.ConsolidationRequest) bool {
-	if req.SourcePubkey == nil || req.TargetPubkey == nil {
-		return false
-	}
-
-	if !bytes.Equal(req.SourcePubkey, req.TargetPubkey) {
-		return false
-	}
-
-	srcIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(req.SourcePubkey))
-	if !ok {
-		return false
-	}
-	srcV, err := st.ValidatorAtIndexReadOnly(srcIdx)
-	if err != nil {
-		return false
-	}
-
-	sourceAddress := req.SourceAddress
-	withdrawalCreds := srcV.GetWithdrawalCredentials()
-	if len(withdrawalCreds) != 32 || len(sourceAddress) != 20 || !bytes.HasSuffix(withdrawalCreds, sourceAddress) {
-		return false
-	}
-
-	if !srcV.HasETH1WithdrawalCredentials() {
-		return false
-	}
-
-	curEpoch := slots.ToEpoch(st.Slot())
-	if !helpers.IsActiveValidatorUsingTrie(srcV, curEpoch) {
-		return false
-	}
-
-	if srcV.ExitEpoch() != params.BeaconConfig().FarFutureEpoch {
-		return false
-	}
-
-	return true
-}
-
-func switchToCompoundingValidator(st state.BeaconState, idx primitives.ValidatorIndex) error {
-	v, err := st.ValidatorAtIndex(idx)
-	if err != nil {
-		return err
-	}
-	if len(v.WithdrawalCredentials) == 0 {
-		return errors.New("validator has no withdrawal credentials")
-	}
-
-	v.WithdrawalCredentials[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
-	if err := st.UpdateValidatorAtIndex(idx, v); err != nil {
-		return err
-	}
-	return queueExcessActiveBalance(st, idx)
-}
-
-func queueExcessActiveBalance(st state.BeaconState, idx primitives.ValidatorIndex) error {
-	bal, err := st.BalanceAtIndex(idx)
-	if err != nil {
-		return err
-	}
-
-	if bal > params.BeaconConfig().MinActivationBalance {
-		if err := st.UpdateBalancesAtIndex(idx, params.BeaconConfig().MinActivationBalance); err != nil {
-			return err
-		}
-		excessBalance := bal - params.BeaconConfig().MinActivationBalance
-		val, err := st.ValidatorAtIndexReadOnly(idx)
-		if err != nil {
-			return err
-		}
-		pk := val.PublicKey()
-		return st.AppendPendingDeposit(&eth.PendingDeposit{
-			PublicKey:             pk[:],
-			WithdrawalCredentials: val.GetWithdrawalCredentials(),
-			Amount:                excessBalance,
-			Signature:             common.InfiniteSignature[:],
-			Slot:                  params.BeaconConfig().GenesisSlot,
-		})
-	}
-	return nil
-}
-
-func computeConsolidationEpochAndUpdateChurn(st state.BeaconState, consolidationBalance primitives.Gwei) (primitives.Epoch, error) {
-	earliestEpoch, err := st.EarliestConsolidationEpoch()
-	if err != nil {
-		return 0, err
-	}
-	earliestConsolidationEpoch := max(earliestEpoch, helpers.ActivationExitEpoch(slots.ToEpoch(st.Slot())))
-
-	activeBal, err := helpers.TotalActiveBalance(st)
-	if err != nil {
-		return 0, err
-	}
-	perEpochConsolidationChurn := helpers.ConsolidationChurnLimit(primitives.Gwei(activeBal))
-
-	var consolidationBalanceToConsume primitives.Gwei
-	if earliestEpoch < earliestConsolidationEpoch {
-		consolidationBalanceToConsume = perEpochConsolidationChurn
-	} else {
-		consolidationBalanceToConsume, err = st.ConsolidationBalanceToConsume()
-		if err != nil {
-			return 0, err
-		}
-	}
-
-	if consolidationBalance > consolidationBalanceToConsume {
-		balanceToProcess := consolidationBalance - consolidationBalanceToConsume
-		additionalEpochs, err := prysmMath.Div64(uint64(balanceToProcess-1), uint64(perEpochConsolidationChurn))
-		if err != nil {
-			return 0, err
-		}
-		additionalEpochs++
-		earliestConsolidationEpoch += primitives.Epoch(additionalEpochs)
-		consolidationBalanceToConsume += primitives.Gwei(additionalEpochs) * perEpochConsolidationChurn
-	}
-
-	if err := st.SetConsolidationBalanceToConsume(consolidationBalanceToConsume - consolidationBalance); err != nil {
-		return 0, err
-	}
-	if err := st.SetEarliestConsolidationEpoch(earliestConsolidationEpoch); err != nil {
-		return 0, err
-	}
-
-	return earliestConsolidationEpoch, nil
-}

beacon-chain/core/requests/consolidations_test.go

@@ -1,316 +0,0 @@
-package requests_test
-
-import (
-	"context"
-	"fmt"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/requests"
-	"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/primitives"
-	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-)
-
-func createValidatorsWithTotalActiveBalance(totalBal primitives.Gwei) []*eth.Validator {
-	num := totalBal / primitives.Gwei(params.BeaconConfig().MinActivationBalance)
-	vals := make([]*eth.Validator, num)
-	for i := range vals {
-		wd := make([]byte, 32)
-		wd[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
-		wd[31] = byte(i)
-
-		vals[i] = &eth.Validator{
-			ActivationEpoch:       primitives.Epoch(0),
-			EffectiveBalance:      params.BeaconConfig().MinActivationBalance,
-			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
-			PublicKey:             fmt.Appendf(nil, "val_%d", i),
-			WithdrawableEpoch:     params.BeaconConfig().FarFutureEpoch,
-			WithdrawalCredentials: wd,
-		}
-	}
-	if totalBal%primitives.Gwei(params.BeaconConfig().MinActivationBalance) != 0 {
-		vals = append(vals, &eth.Validator{
-			ActivationEpoch:  primitives.Epoch(0),
-			ExitEpoch:        params.BeaconConfig().FarFutureEpoch,
-			EffectiveBalance: uint64(totalBal) % params.BeaconConfig().MinActivationBalance,
-		})
-	}
-	return vals
-}
-
-func TestProcessConsolidationRequests(t *testing.T) {
-	tests := []struct {
-		name     string
-		state    state.BeaconState
-		reqs     []*enginev1.ConsolidationRequest
-		validate func(*testing.T, state.BeaconState)
-		wantErr  bool
-	}{
-		{
-			name: "nil request",
-			state: func() state.BeaconState {
-				st := &eth.BeaconStateElectra{}
-				s, err := state_native.InitializeFromProtoElectra(st)
-				require.NoError(t, err)
-				return s
-			}(),
-			reqs: []*enginev1.ConsolidationRequest{nil},
-			validate: func(t *testing.T, st state.BeaconState) {
-				require.DeepEqual(t, st, st)
-			},
-			wantErr: true,
-		},
-		{
-			name: "one valid request",
-			state: func() state.BeaconState {
-				st := &eth.BeaconStateElectra{
-					Slot:       params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().ShardCommitteePeriod)),
-					Validators: createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
-				}
-				// Validator scenario setup. See comments in reqs section.
-				st.Validators[3].WithdrawalCredentials = bytesutil.Bytes32(0)
-				st.Validators[8].WithdrawalCredentials = bytesutil.Bytes32(1)
-				st.Validators[9].ActivationEpoch = params.BeaconConfig().FarFutureEpoch
-				st.Validators[12].ActivationEpoch = params.BeaconConfig().FarFutureEpoch
-				st.Validators[13].ExitEpoch = 10
-				st.Validators[16].ExitEpoch = 10
-				st.PendingPartialWithdrawals = []*eth.PendingPartialWithdrawal{
-					{
-						Index:  17,
-						Amount: 100,
-					},
-				}
-				s, err := state_native.InitializeFromProtoElectra(st)
-				require.NoError(t, err)
-				return s
-			}(),
-			reqs: []*enginev1.ConsolidationRequest{
-				// Source doesn't have withdrawal credentials.
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
-					SourcePubkey:  []byte("val_3"),
-					TargetPubkey:  []byte("val_4"),
-				},
-				// Source withdrawal credentials don't match the consolidation address.
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)), // Should be 5
-					SourcePubkey:  []byte("val_5"),
-					TargetPubkey:  []byte("val_6"),
-				},
-				// Target does not have their withdrawal credentials set appropriately. (Using eth1 address prefix)
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(7)),
-					SourcePubkey:  []byte("val_7"),
-					TargetPubkey:  []byte("val_8"),
-				},
-				// Source is inactive.
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(9)),
-					SourcePubkey:  []byte("val_9"),
-					TargetPubkey:  []byte("val_10"),
-				},
-				// Target is inactive.
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(11)),
-					SourcePubkey:  []byte("val_11"),
-					TargetPubkey:  []byte("val_12"),
-				},
-				// Source is exiting.
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(13)),
-					SourcePubkey:  []byte("val_13"),
-					TargetPubkey:  []byte("val_14"),
-				},
-				// Target is exiting.
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(15)),
-					SourcePubkey:  []byte("val_15"),
-					TargetPubkey:  []byte("val_16"),
-				},
-				// Source doesn't exist
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)),
-					SourcePubkey:  []byte("INVALID"),
-					TargetPubkey:  []byte("val_0"),
-				},
-				// Target doesn't exist
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)),
-					SourcePubkey:  []byte("val_0"),
-					TargetPubkey:  []byte("INVALID"),
-				},
-				// Source == target
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)),
-					SourcePubkey:  []byte("val_0"),
-					TargetPubkey:  []byte("val_0"),
-				},
-				// Has pending partial withdrawal
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)),
-					SourcePubkey:  []byte("val_17"),
-					TargetPubkey:  []byte("val_1"),
-				},
-				// Valid consolidation request. This should be last to ensure invalid requests do
-				// not end the processing early.
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
-					SourcePubkey:  []byte("val_1"),
-					TargetPubkey:  []byte("val_2"),
-				},
-			},
-			validate: func(t *testing.T, st state.BeaconState) {
-				// Verify a pending consolidation is created.
-				numPC, err := st.NumPendingConsolidations()
-				require.NoError(t, err)
-				require.Equal(t, uint64(1), numPC)
-				pcs, err := st.PendingConsolidations()
-				require.NoError(t, err)
-				require.Equal(t, primitives.ValidatorIndex(1), pcs[0].SourceIndex)
-				require.Equal(t, primitives.ValidatorIndex(2), pcs[0].TargetIndex)
-
-				// Verify the source validator is exiting.
-				src, err := st.ValidatorAtIndex(1)
-				require.NoError(t, err)
-				require.NotEqual(t, params.BeaconConfig().FarFutureEpoch, src.ExitEpoch, "source validator exit epoch not updated")
-				require.Equal(t, params.BeaconConfig().MinValidatorWithdrawabilityDelay, src.WithdrawableEpoch-src.ExitEpoch, "source validator withdrawable epoch not set correctly")
-			},
-			wantErr: false,
-		},
-		{
-			name: "pending consolidations limit reached",
-			state: func() state.BeaconState {
-				st := &eth.BeaconStateElectra{
-					Validators:            createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
-					PendingConsolidations: make([]*eth.PendingConsolidation, params.BeaconConfig().PendingConsolidationsLimit),
-				}
-				s, err := state_native.InitializeFromProtoElectra(st)
-				require.NoError(t, err)
-				return s
-			}(),
-			reqs: []*enginev1.ConsolidationRequest{
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
-					SourcePubkey:  []byte("val_1"),
-					TargetPubkey:  []byte("val_2"),
-				},
-			},
-			validate: func(t *testing.T, st state.BeaconState) {
-				// Verify no pending consolidation is created.
-				numPC, err := st.NumPendingConsolidations()
-				require.NoError(t, err)
-				require.Equal(t, params.BeaconConfig().PendingConsolidationsLimit, numPC)
-
-				// Verify the source validator is not exiting.
-				src, err := st.ValidatorAtIndex(1)
-				require.NoError(t, err)
-				require.Equal(t, params.BeaconConfig().FarFutureEpoch, src.ExitEpoch, "source validator exit epoch should not be updated")
-				require.Equal(t, params.BeaconConfig().FarFutureEpoch, src.WithdrawableEpoch, "source validator withdrawable epoch should not be updated")
-			},
-			wantErr: false,
-		},
-		{
-			name: "pending consolidations limit reached during processing",
-			state: func() state.BeaconState {
-				st := &eth.BeaconStateElectra{
-					Slot:                  params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().ShardCommitteePeriod)),
-					Validators:            createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
-					PendingConsolidations: make([]*eth.PendingConsolidation, params.BeaconConfig().PendingConsolidationsLimit-1),
-				}
-				s, err := state_native.InitializeFromProtoElectra(st)
-				require.NoError(t, err)
-				return s
-			}(),
-			reqs: []*enginev1.ConsolidationRequest{
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
-					SourcePubkey:  []byte("val_1"),
-					TargetPubkey:  []byte("val_2"),
-				},
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(3)),
-					SourcePubkey:  []byte("val_3"),
-					TargetPubkey:  []byte("val_4"),
-				},
-			},
-			validate: func(t *testing.T, st state.BeaconState) {
-				// Verify a pending consolidation is created.
-				numPC, err := st.NumPendingConsolidations()
-				require.NoError(t, err)
-				require.Equal(t, params.BeaconConfig().PendingConsolidationsLimit, numPC)
-
-				// The first consolidation was appended.
-				pcs, err := st.PendingConsolidations()
-				require.NoError(t, err)
-				require.Equal(t, primitives.ValidatorIndex(1), pcs[params.BeaconConfig().PendingConsolidationsLimit-1].SourceIndex)
-				require.Equal(t, primitives.ValidatorIndex(2), pcs[params.BeaconConfig().PendingConsolidationsLimit-1].TargetIndex)
-
-				// Verify the second source validator is not exiting.
-				src, err := st.ValidatorAtIndex(3)
-				require.NoError(t, err)
-				require.Equal(t, params.BeaconConfig().FarFutureEpoch, src.ExitEpoch, "source validator exit epoch should not be updated")
-				require.Equal(t, params.BeaconConfig().FarFutureEpoch, src.WithdrawableEpoch, "source validator withdrawable epoch should not be updated")
-			},
-			wantErr: false,
-		},
-		{
-			name: "pending consolidations limit reached and compounded consolidation after",
-			state: func() state.BeaconState {
-				st := &eth.BeaconStateElectra{
-					Slot:                  params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().ShardCommitteePeriod)),
-					Validators:            createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
-					PendingConsolidations: make([]*eth.PendingConsolidation, params.BeaconConfig().PendingConsolidationsLimit),
-				}
-				// To allow compounding consolidation requests.
-				st.Validators[3].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
-				s, err := state_native.InitializeFromProtoElectra(st)
-				require.NoError(t, err)
-				return s
-			}(),
-			reqs: []*enginev1.ConsolidationRequest{
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
-					SourcePubkey:  []byte("val_1"),
-					TargetPubkey:  []byte("val_2"),
-				},
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(3)),
-					SourcePubkey:  []byte("val_3"),
-					TargetPubkey:  []byte("val_3"),
-				},
-			},
-			validate: func(t *testing.T, st state.BeaconState) {
-				// Verify a pending consolidation is created.
-				numPC, err := st.NumPendingConsolidations()
-				require.NoError(t, err)
-				require.Equal(t, params.BeaconConfig().PendingConsolidationsLimit, numPC)
-
-				// Verify that the last consolidation was included
-				src, err := st.ValidatorAtIndex(3)
-				require.NoError(t, err)
-				require.Equal(t, params.BeaconConfig().CompoundingWithdrawalPrefixByte, src.WithdrawalCredentials[0], "source validator was not compounded")
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := requests.ProcessConsolidationRequests(context.TODO(), tt.state, tt.reqs)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("ProcessWithdrawalRequests() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !tt.wantErr {
-				require.NoError(t, err)
-			}
-			if tt.validate != nil {
-				tt.validate(t, tt.state)
-			}
-		})
-	}
-}

beacon-chain/core/requests/deposits.go

@@ -1,73 +0,0 @@
-package requests
-
-import (
-	"context"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/pkg/errors"
-)
-
-// ProcessDepositRequests processes execution layer deposits requests.
-func ProcessDepositRequests(ctx context.Context, beaconState state.BeaconState, reqs []*enginev1.DepositRequest) (state.BeaconState, error) {
-	_, span := trace.StartSpan(ctx, "requests.ProcessDepositRequests")
-	defer span.End()
-
-	if len(reqs) == 0 {
-		return beaconState, nil
-	}
-
-	var err error
-	for _, req := range reqs {
-		beaconState, err = processDepositRequest(beaconState, req)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not apply deposit request")
-		}
-	}
-	return beaconState, nil
-}
-
-// processDepositRequest processes the specific deposit request
-//
-// def process_deposit_request(state: BeaconState, deposit_request: DepositRequest) -> None:
-//
-//	# Set deposit request start index
-//	if state.deposit_requests_start_index == UNSET_DEPOSIT_REQUESTS_START_INDEX:
-//	    state.deposit_requests_start_index = deposit_request.index
-//
-//	# Create pending deposit
-//	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,
-//	))
-func processDepositRequest(beaconState state.BeaconState, req *enginev1.DepositRequest) (state.BeaconState, error) {
-	requestsStartIndex, err := beaconState.DepositRequestsStartIndex()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get deposit requests start index")
-	}
-	if req == nil {
-		return nil, errors.New("nil deposit request")
-	}
-	if requestsStartIndex == params.BeaconConfig().UnsetDepositRequestsStartIndex {
-		if err := beaconState.SetDepositRequestsStartIndex(req.Index); err != nil {
-			return nil, errors.Wrap(err, "could not set deposit requests start index")
-		}
-	}
-	if err := beaconState.AppendPendingDeposit(&ethpb.PendingDeposit{
-		PublicKey:             bytesutil.SafeCopyBytes(req.Pubkey),
-		WithdrawalCredentials: bytesutil.SafeCopyBytes(req.WithdrawalCredentials),
-		Amount:                req.Amount,
-		Signature:             bytesutil.SafeCopyBytes(req.Signature),
-		Slot:                  beaconState.Slot(),
-	}); err != nil {
-		return nil, errors.Wrap(err, "could not append deposit request")
-	}
-	return beaconState, nil
-}

beacon-chain/core/requests/deposits_test.go

@@ -1,70 +0,0 @@
-package requests_test
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/requests"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls"
-	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/OffchainLabs/prysm/v7/testing/util"
-)
-
-func TestProcessDepositRequests(t *testing.T) {
-	st, _ := util.DeterministicGenesisStateElectra(t, 1)
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	require.NoError(t, st.SetDepositRequestsStartIndex(1))
-
-	t.Run("empty requests continues", func(t *testing.T) {
-		newSt, err := requests.ProcessDepositRequests(t.Context(), st, []*enginev1.DepositRequest{})
-		require.NoError(t, err)
-		require.DeepEqual(t, newSt, st)
-	})
-	t.Run("nil request errors", func(t *testing.T) {
-		_, err = requests.ProcessDepositRequests(t.Context(), st, []*enginev1.DepositRequest{nil})
-		require.ErrorContains(t, "nil deposit request", err)
-	})
-
-	vals := st.Validators()
-	vals[0].PublicKey = sk.PublicKey().Marshal()
-	vals[0].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
-	require.NoError(t, st.SetValidators(vals))
-	bals := st.Balances()
-	bals[0] = params.BeaconConfig().MinActivationBalance + 2000
-	require.NoError(t, st.SetBalances(bals))
-	require.NoError(t, st.SetPendingDeposits(make([]*eth.PendingDeposit, 0))) // reset pbd as the deterministic state populates this already
-	withdrawalCred := make([]byte, 32)
-	withdrawalCred[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
-	depositMessage := &eth.DepositMessage{
-		PublicKey:             sk.PublicKey().Marshal(),
-		Amount:                1000,
-		WithdrawalCredentials: withdrawalCred,
-	}
-	domain, err := signing.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
-	require.NoError(t, err)
-	sr, err := signing.ComputeSigningRoot(depositMessage, domain)
-	require.NoError(t, err)
-	sig := sk.Sign(sr[:])
-	reqs := []*enginev1.DepositRequest{
-		{
-			Pubkey:                depositMessage.PublicKey,
-			Index:                 0,
-			WithdrawalCredentials: depositMessage.WithdrawalCredentials,
-			Amount:                depositMessage.Amount,
-			Signature:             sig.Marshal(),
-		},
-	}
-	st, err = requests.ProcessDepositRequests(t.Context(), st, reqs)
-	require.NoError(t, err)
-
-	pbd, err := st.PendingDeposits()
-	require.NoError(t, err)
-	require.Equal(t, 1, len(pbd))
-	require.Equal(t, uint64(1000), pbd[0].Amount)
-	require.DeepEqual(t, bytesutil.SafeCopyBytes(reqs[0].Pubkey), pbd[0].PublicKey)
-}

beacon-chain/core/requests/log.go

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

beacon-chain/core/transition/BUILD.bazel

@@ -3,8 +3,6 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
-        "electra.go",
-        "errors.go",
         "log.go",
         "skip_slot_cache.go",
         "state.go",
@@ -27,7 +25,6 @@ go_library(
         "//beacon-chain/core/execution:go_default_library",
         "//beacon-chain/core/fulu:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/requests:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/core/transition/interop:go_default_library",
         "//beacon-chain/core/validators:go_default_library",
@@ -65,14 +62,11 @@ go_test(
         "altair_transition_no_verify_sig_test.go",
         "bellatrix_transition_no_verify_sig_test.go",
         "benchmarks_test.go",
-        "electra_test.go",
-        "exports_test.go",
         "skip_slot_cache_test.go",
         "state_fuzz_test.go",
         "state_test.go",
         "trailing_slot_state_cache_test.go",
         "transition_fuzz_test.go",
-        "transition_gloas_test.go",
         "transition_no_verify_sig_test.go",
         "transition_test.go",
     ],
@@ -108,7 +102,6 @@ go_test(
         "//time/slots:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
-        "@com_github_stretchr_testify//require:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )

beacon-chain/core/transition/electra_test.go

@@ -1,216 +0,0 @@
-package transition_test
-
-import (
-	"context"
-	"errors"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/transition"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/OffchainLabs/prysm/v7/testing/util"
-)
-
-func TestProcessOperationsWithNilRequests(t *testing.T) {
-	tests := []struct {
-		name      string
-		modifyBlk func(blockElectra *ethpb.SignedBeaconBlockElectra)
-		errMsg    string
-	}{
-		{
-			name: "Nil deposit request",
-			modifyBlk: func(blk *ethpb.SignedBeaconBlockElectra) {
-				blk.Block.Body.ExecutionRequests.Deposits = []*enginev1.DepositRequest{nil}
-			},
-			errMsg: "nil deposit request",
-		},
-		{
-			name: "Nil withdrawal request",
-			modifyBlk: func(blk *ethpb.SignedBeaconBlockElectra) {
-				blk.Block.Body.ExecutionRequests.Withdrawals = []*enginev1.WithdrawalRequest{nil}
-			},
-			errMsg: "nil withdrawal request",
-		},
-		{
-			name: "Nil consolidation request",
-			modifyBlk: func(blk *ethpb.SignedBeaconBlockElectra) {
-				blk.Block.Body.ExecutionRequests.Consolidations = []*enginev1.ConsolidationRequest{nil}
-			},
-			errMsg: "nil consolidation request",
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			st, ks := util.DeterministicGenesisStateElectra(t, 128)
-			blk, err := util.GenerateFullBlockElectra(st, ks, util.DefaultBlockGenConfig(), 1)
-			require.NoError(t, err)
-
-			tc.modifyBlk(blk)
-
-			b, err := blocks.NewSignedBeaconBlock(blk)
-			require.NoError(t, err)
-
-			require.NoError(t, st.SetSlot(1))
-
-			_, err = transition.ElectraOperations(t.Context(), st, b.Block())
-			require.ErrorContains(t, tc.errMsg, err)
-		})
-	}
-}
-
-func TestElectraOperations_ProcessingErrors(t *testing.T) {
-	tests := []struct {
-		name      string
-		modifyBlk func(blk *ethpb.SignedBeaconBlockElectra)
-		errCheck  func(t *testing.T, err error)
-	}{
-		{
-			name: "ErrProcessProposerSlashingsFailed",
-			modifyBlk: func(blk *ethpb.SignedBeaconBlockElectra) {
-				// Create invalid proposer slashing with out-of-bounds proposer index
-				blk.Block.Body.ProposerSlashings = []*ethpb.ProposerSlashing{
-					{
-						Header_1: &ethpb.SignedBeaconBlockHeader{
-							Header: &ethpb.BeaconBlockHeader{
-								Slot:          1,
-								ProposerIndex: 999999, // Invalid index (out of bounds)
-								ParentRoot:    make([]byte, 32),
-								StateRoot:     make([]byte, 32),
-								BodyRoot:      make([]byte, 32),
-							},
-							Signature: make([]byte, 96),
-						},
-						Header_2: &ethpb.SignedBeaconBlockHeader{
-							Header: &ethpb.BeaconBlockHeader{
-								Slot:          1,
-								ProposerIndex: 999999,
-								ParentRoot:    make([]byte, 32),
-								StateRoot:     make([]byte, 32),
-								BodyRoot:      make([]byte, 32),
-							},
-							Signature: make([]byte, 96),
-						},
-					},
-				}
-			},
-			errCheck: func(t *testing.T, err error) {
-				require.ErrorContains(t, "process proposer slashings failed", err)
-				require.Equal(t, true, errors.Is(err, transition.ErrProcessProposerSlashingsFailed))
-			},
-		},
-		{
-			name: "ErrProcessAttestationsFailed",
-			modifyBlk: func(blk *ethpb.SignedBeaconBlockElectra) {
-				// Create attestation with invalid committee index
-				blk.Block.Body.Attestations = []*ethpb.AttestationElectra{
-					{
-						AggregationBits: []byte{0b00000001},
-						Data: &ethpb.AttestationData{
-							Slot:            1,
-							CommitteeIndex:  999999, // Invalid committee index
-							BeaconBlockRoot: make([]byte, 32),
-							Source: &ethpb.Checkpoint{
-								Epoch: 0,
-								Root:  make([]byte, 32),
-							},
-							Target: &ethpb.Checkpoint{
-								Epoch: 0,
-								Root:  make([]byte, 32),
-							},
-						},
-						CommitteeBits: []byte{0b00000001},
-						Signature:     make([]byte, 96),
-					},
-				}
-			},
-			errCheck: func(t *testing.T, err error) {
-				require.ErrorContains(t, "process attestations failed", err)
-				require.Equal(t, true, errors.Is(err, transition.ErrProcessAttestationsFailed))
-			},
-		},
-		{
-			name: "ErrProcessDepositsFailed",
-			modifyBlk: func(blk *ethpb.SignedBeaconBlockElectra) {
-				// Create deposit with invalid proof length
-				blk.Block.Body.Deposits = []*ethpb.Deposit{
-					{
-						Proof: [][]byte{}, // Invalid: empty proof
-						Data: &ethpb.Deposit_Data{
-							PublicKey:             make([]byte, 48),
-							WithdrawalCredentials: make([]byte, 32),
-							Amount:                32000000000, // 32 ETH in Gwei
-							Signature:             make([]byte, 96),
-						},
-					},
-				}
-			},
-			errCheck: func(t *testing.T, err error) {
-				require.ErrorContains(t, "process deposits failed", err)
-				require.Equal(t, true, errors.Is(err, transition.ErrProcessDepositsFailed))
-			},
-		},
-		{
-			name: "ErrProcessVoluntaryExitsFailed",
-			modifyBlk: func(blk *ethpb.SignedBeaconBlockElectra) {
-				// Create voluntary exit with invalid validator index
-				blk.Block.Body.VoluntaryExits = []*ethpb.SignedVoluntaryExit{
-					{
-						Exit: &ethpb.VoluntaryExit{
-							Epoch:          0,
-							ValidatorIndex: 999999, // Invalid index (out of bounds)
-						},
-						Signature: make([]byte, 96),
-					},
-				}
-			},
-			errCheck: func(t *testing.T, err error) {
-				require.ErrorContains(t, "process voluntary exits failed", err)
-				require.Equal(t, true, errors.Is(err, transition.ErrProcessVoluntaryExitsFailed))
-			},
-		},
-		{
-			name: "ErrProcessBLSChangesFailed",
-			modifyBlk: func(blk *ethpb.SignedBeaconBlockElectra) {
-				// Create BLS to execution change with invalid validator index
-				blk.Block.Body.BlsToExecutionChanges = []*ethpb.SignedBLSToExecutionChange{
-					{
-						Message: &ethpb.BLSToExecutionChange{
-							ValidatorIndex:     999999, // Invalid index (out of bounds)
-							FromBlsPubkey:      make([]byte, 48),
-							ToExecutionAddress: make([]byte, 20),
-						},
-						Signature: make([]byte, 96),
-					},
-				}
-			},
-			errCheck: func(t *testing.T, err error) {
-				require.ErrorContains(t, "process BLS to execution changes failed", err)
-				require.Equal(t, true, errors.Is(err, transition.ErrProcessBLSChangesFailed))
-			},
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			ctx := context.Background()
-			st, ks := util.DeterministicGenesisStateElectra(t, 128)
-			blk, err := util.GenerateFullBlockElectra(st, ks, util.DefaultBlockGenConfig(), 1)
-			require.NoError(t, err)
-
-			tc.modifyBlk(blk)
-
-			b, err := blocks.NewSignedBeaconBlock(blk)
-			require.NoError(t, err)
-
-			require.NoError(t, st.SetSlot(primitives.Slot(1)))
-
-			_, err = transition.ElectraOperations(ctx, st, b.Block())
-			require.NotNil(t, err, "Expected an error but got nil")
-			tc.errCheck(t, err)
-		})
-	}
-}

beacon-chain/core/transition/errors.go

@@ -1,19 +0,0 @@
-package transition
-
-import "errors"
-
-var (
-	ErrAttestationsSignatureInvalid          = errors.New("attestations signature invalid")
-	ErrRandaoSignatureInvalid                = errors.New("randao signature invalid")
-	ErrBLSToExecutionChangesSignatureInvalid = errors.New("BLS to execution changes signature invalid")
-	ErrProcessWithdrawalsFailed              = errors.New("process withdrawals failed")
-	ErrProcessRandaoFailed                   = errors.New("process randao failed")
-	ErrProcessEth1DataFailed                 = errors.New("process eth1 data failed")
-	ErrProcessProposerSlashingsFailed        = errors.New("process proposer slashings failed")
-	ErrProcessAttesterSlashingsFailed        = errors.New("process attester slashings failed")
-	ErrProcessAttestationsFailed             = errors.New("process attestations failed")
-	ErrProcessDepositsFailed                 = errors.New("process deposits failed")
-	ErrProcessVoluntaryExitsFailed           = errors.New("process voluntary exits failed")
-	ErrProcessBLSChangesFailed               = errors.New("process BLS to execution changes failed")
-	ErrProcessSyncAggregateFailed            = errors.New("process sync aggregate failed")
-)

beacon-chain/core/transition/exports_test.go

@@ -1,3 +0,0 @@
-package transition
-
-var ElectraOperations = electraOperations

beacon-chain/core/transition/transition.go

@@ -142,18 +142,6 @@ func ProcessSlot(ctx context.Context, state state.BeaconState) (state.BeaconStat
 	); err != nil {
 		return nil, err
 	}
-
-	// Spec v1.6.1 (pseudocode):
-	// # [New in Gloas:EIP7732]
-	// # Unset the next payload availability
-	// state.execution_payload_availability[(state.slot + 1) % SLOTS_PER_HISTORICAL_ROOT] = 0b0
-	if state.Version() >= version.Gloas {
-		index := uint64((state.Slot() + 1) % params.BeaconConfig().SlotsPerHistoricalRoot)
-		if err := state.UpdateExecutionPayloadAvailabilityAtIndex(index, 0x0); err != nil {
-			return nil, err
-		}
-	}
-
 	return state, nil
 }
 

beacon-chain/core/transition/transition_gloas_test.go

@@ -1,141 +0,0 @@
-package transition
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
-	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"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/stretchr/testify/require"
-)
-
-func TestProcessSlot_GloasClearsNextPayloadAvailability(t *testing.T) {
-	slot := primitives.Slot(10)
-	cfg := params.BeaconConfig()
-	nextIdx := uint64((slot + 1) % cfg.SlotsPerHistoricalRoot)
-	byteIdx := nextIdx / 8
-	bitMask := byte(1 << (nextIdx % 8))
-	availability := bytes.Repeat([]byte{0xFF}, int(cfg.SlotsPerHistoricalRoot/8))
-	st := newGloasState(t, slot, availability)
-
-	_, err := ProcessSlot(context.Background(), st)
-	require.NoError(t, err)
-
-	post := st.ToProto().(*ethpb.BeaconStateGloas)
-	require.Equal(t, byte(0xFF)&^bitMask, post.ExecutionPayloadAvailability[byteIdx])
-}
-
-func TestProcessSlot_GloasClearsNextPayloadAvailability_Wrap(t *testing.T) {
-	cfg := params.BeaconConfig()
-	slot := primitives.Slot(cfg.SlotsPerHistoricalRoot - 1)
-	availability := bytes.Repeat([]byte{0xFF}, int(cfg.SlotsPerHistoricalRoot/8))
-	st := newGloasState(t, slot, availability)
-
-	_, err := ProcessSlot(context.Background(), st)
-	require.NoError(t, err)
-
-	post := st.ToProto().(*ethpb.BeaconStateGloas)
-	require.Equal(t, byte(0xFE), post.ExecutionPayloadAvailability[0])
-}
-
-func TestProcessSlot_GloasAvailabilityUpdateError(t *testing.T) {
-	slot := primitives.Slot(7)
-	availability := make([]byte, 1)
-	st := newGloasState(t, slot, availability)
-
-	_, err := ProcessSlot(context.Background(), st)
-	cfg := params.BeaconConfig()
-	idx := uint64((slot + 1) % cfg.SlotsPerHistoricalRoot)
-	byteIdx := idx / 8
-	require.EqualError(t, err, fmt.Sprintf(
-		"bit index %d (byte index %d) out of range for execution payload availability length %d",
-		idx, byteIdx, len(availability),
-	))
-}
-
-func newGloasState(t *testing.T, slot primitives.Slot, availability []byte) state.BeaconState {
-	t.Helper()
-
-	cfg := params.BeaconConfig()
-	protoState := &ethpb.BeaconStateGloas{
-		Slot:                         slot,
-		LatestBlockHeader:            testBeaconBlockHeader(),
-		BlockRoots:                   make([][]byte, cfg.SlotsPerHistoricalRoot),
-		StateRoots:                   make([][]byte, cfg.SlotsPerHistoricalRoot),
-		RandaoMixes:                  make([][]byte, fieldparams.RandaoMixesLength),
-		ExecutionPayloadAvailability: availability,
-		BuilderPendingPayments:       make([]*ethpb.BuilderPendingPayment, int(cfg.SlotsPerEpoch*2)),
-		LatestExecutionPayloadBid: &ethpb.ExecutionPayloadBid{
-			ParentBlockHash:        make([]byte, 32),
-			ParentBlockRoot:        make([]byte, 32),
-			BlockHash:              make([]byte, 32),
-			PrevRandao:             make([]byte, 32),
-			FeeRecipient:           make([]byte, 20),
-			BlobKzgCommitmentsRoot: make([]byte, 32),
-		},
-		Eth1Data: &ethpb.Eth1Data{
-			DepositRoot: make([]byte, 32),
-			BlockHash:   make([]byte, 32),
-		},
-		PreviousEpochParticipation:  []byte{},
-		CurrentEpochParticipation:   []byte{},
-		JustificationBits:           []byte{0},
-		PreviousJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
-		CurrentJustifiedCheckpoint:  &ethpb.Checkpoint{Root: make([]byte, 32)},
-		FinalizedCheckpoint:         &ethpb.Checkpoint{Root: make([]byte, 32)},
-		CurrentSyncCommittee:        &ethpb.SyncCommittee{},
-		NextSyncCommittee:           &ethpb.SyncCommittee{},
-	}
-
-	for i := range protoState.BlockRoots {
-		protoState.BlockRoots[i] = make([]byte, 32)
-	}
-	for i := range protoState.StateRoots {
-		protoState.StateRoots[i] = make([]byte, 32)
-	}
-	for i := range protoState.RandaoMixes {
-		protoState.RandaoMixes[i] = make([]byte, 32)
-	}
-
-	for i := range protoState.BuilderPendingPayments {
-		protoState.BuilderPendingPayments[i] = &ethpb.BuilderPendingPayment{
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: make([]byte, 20),
-			},
-		}
-	}
-
-	pubkeys := make([][]byte, cfg.SyncCommitteeSize)
-	for i := range pubkeys {
-		pubkeys[i] = make([]byte, fieldparams.BLSPubkeyLength)
-	}
-	aggPubkey := make([]byte, fieldparams.BLSPubkeyLength)
-	protoState.CurrentSyncCommittee = &ethpb.SyncCommittee{
-		Pubkeys:         pubkeys,
-		AggregatePubkey: aggPubkey,
-	}
-	protoState.NextSyncCommittee = &ethpb.SyncCommittee{
-		Pubkeys:         pubkeys,
-		AggregatePubkey: aggPubkey,
-	}
-
-	st, err := state_native.InitializeFromProtoGloas(protoState)
-	require.NoError(t, err)
-	require.Equal(t, version.Gloas, st.Version())
-	return st
-}
-
-func testBeaconBlockHeader() *ethpb.BeaconBlockHeader {
-	return &ethpb.BeaconBlockHeader{
-		ParentRoot: make([]byte, 32),
-		StateRoot:  make([]byte, 32),
-		BodyRoot:   make([]byte, 32),
-	}
-}

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -7,11 +7,12 @@ import (
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/altair"
 	b "github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/electra"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/transition/interop"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/validators"
+	v "github.com/OffchainLabs/prysm/v7/beacon-chain/core/validators"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/config/features"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/crypto/bls"
@@ -69,11 +70,10 @@ func ExecuteStateTransitionNoVerifyAnySig(
 	}
 
 	// Execute per block transition.
-	sigSlice, st, err := ProcessBlockNoVerifyAnySig(ctx, st, signed)
+	set, st, err := ProcessBlockNoVerifyAnySig(ctx, st, signed)
 	if err != nil {
 		return nil, nil, errors.Wrap(err, "could not process block")
 	}
-	set := sigSlice.Batch()
 
 	// State root validation.
 	postStateRoot, err := st.HashTreeRoot(ctx)
@@ -113,7 +113,7 @@ func ExecuteStateTransitionNoVerifyAnySig(
 //	      assert block.state_root == hash_tree_root(state)
 func CalculateStateRoot(
 	ctx context.Context,
-	rollback state.BeaconState,
+	state state.BeaconState,
 	signed interfaces.ReadOnlySignedBeaconBlock,
 ) ([32]byte, error) {
 	ctx, span := trace.StartSpan(ctx, "core.state.CalculateStateRoot")
@@ -122,7 +122,7 @@ func CalculateStateRoot(
 		tracing.AnnotateError(span, ctx.Err())
 		return [32]byte{}, ctx.Err()
 	}
-	if rollback == nil || rollback.IsNil() {
+	if state == nil || state.IsNil() {
 		return [32]byte{}, errors.New("nil state")
 	}
 	if signed == nil || signed.IsNil() || signed.Block().IsNil() {
@@ -130,7 +130,7 @@ func CalculateStateRoot(
 	}
 
 	// Copy state to avoid mutating the state reference.
-	state := rollback.Copy()
+	state = state.Copy()
 
 	// Execute per slots transition.
 	var err error
@@ -141,103 +141,14 @@ func CalculateStateRoot(
 	}
 
 	// 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")
-		}
-	} else {
-		state, err = ProcessBlockForStateRoot(ctx, state, signed)
-		if err != nil {
-			return [32]byte{}, errors.Wrap(err, "could not process block")
-		}
+	state, err = ProcessBlockForStateRoot(ctx, state, signed)
+	if err != nil {
+		return [32]byte{}, errors.Wrap(err, "could not process block")
 	}
+
 	return state.HashTreeRoot(ctx)
 }
 
-// processBlockVerifySigs processes the block and verifies the signatures within it. Block signatures are not verified as this block is not yet signed.
-func processBlockForProposing(ctx context.Context, st state.BeaconState, signed interfaces.ReadOnlySignedBeaconBlock) (state.BeaconState, error) {
-	var err error
-	var set BlockSignatureBatches
-	set, st, err = ProcessBlockNoVerifyAnySig(ctx, st, signed)
-	if err != nil {
-		return nil, err
-	}
-	// We first try to verify all sigantures batched optimistically. We ignore block proposer signature.
-	sigSet := set.Batch()
-	valid, err := sigSet.Verify()
-	if err != nil || valid {
-		return st, err
-	}
-	// Some signature failed to verify.
-	// Verify Attestations signatures
-	attSigs := set.AttestationSignatures
-	if attSigs == nil {
-		return nil, ErrAttestationsSignatureInvalid
-	}
-	valid, err = attSigs.Verify()
-	if err != nil {
-		return nil, err
-	}
-	if !valid {
-		return nil, ErrAttestationsSignatureInvalid
-	}
-
-	// Verify Randao signature
-	randaoSigs := set.RandaoSignatures
-	if randaoSigs == nil {
-		return nil, ErrRandaoSignatureInvalid
-	}
-	valid, err = randaoSigs.Verify()
-	if err != nil {
-		return nil, err
-	}
-	if !valid {
-		return nil, ErrRandaoSignatureInvalid
-	}
-
-	if signed.Block().Version() < version.Capella {
-		//This should not happen as we must have failed one of the above signatures.
-		return st, nil
-	}
-	// Verify BLS to execution changes signatures
-	blsChangeSigs := set.BLSChangeSignatures
-	if blsChangeSigs == nil {
-		return nil, ErrBLSToExecutionChangesSignatureInvalid
-	}
-	valid, err = blsChangeSigs.Verify()
-	if err != nil {
-		return nil, err
-	}
-	if !valid {
-		return nil, ErrBLSToExecutionChangesSignatureInvalid
-	}
-	// We should not reach this point as one of the above signatures must have failed.
-	return st, nil
-}
-
-// BlockSignatureBatches holds the signature batches for different parts of a beacon block.
-type BlockSignatureBatches struct {
-	RandaoSignatures      *bls.SignatureBatch
-	AttestationSignatures *bls.SignatureBatch
-	BLSChangeSignatures   *bls.SignatureBatch
-}
-
-// Batch returns the batch of signature batches in the BlockSignatureBatches.
-func (b BlockSignatureBatches) Batch() *bls.SignatureBatch {
-	sigs := bls.NewSet()
-	if b.RandaoSignatures != nil {
-		sigs.Join(b.RandaoSignatures)
-	}
-	if b.AttestationSignatures != nil {
-		sigs.Join(b.AttestationSignatures)
-	}
-	if b.BLSChangeSignatures != nil {
-		sigs.Join(b.BLSChangeSignatures)
-	}
-	return sigs
-}
-
 // ProcessBlockNoVerifyAnySig creates a new, modified beacon state by applying block operation
 // transformations as defined in the Ethereum Serenity specification. It does not validate
 // any block signature except for deposit and slashing signatures. It also returns the relevant
@@ -254,48 +165,48 @@ func ProcessBlockNoVerifyAnySig(
 	ctx context.Context,
 	st state.BeaconState,
 	signed interfaces.ReadOnlySignedBeaconBlock,
-) (BlockSignatureBatches, state.BeaconState, error) {
+) (*bls.SignatureBatch, state.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "core.state.ProcessBlockNoVerifyAnySig")
 	defer span.End()
-	set := BlockSignatureBatches{}
 	if err := blocks.BeaconBlockIsNil(signed); err != nil {
-		return set, nil, err
+		return nil, nil, err
 	}
 
 	if st.Version() != signed.Block().Version() {
-		return set, nil, fmt.Errorf("state and block are different version. %d != %d", st.Version(), signed.Block().Version())
+		return nil, nil, fmt.Errorf("state and block are different version. %d != %d", st.Version(), signed.Block().Version())
 	}
 
 	blk := signed.Block()
 	st, err := ProcessBlockForStateRoot(ctx, st, signed)
 	if err != nil {
-		return set, nil, err
+		return nil, nil, err
 	}
 
 	randaoReveal := signed.Block().Body().RandaoReveal()
 	rSet, err := b.RandaoSignatureBatch(ctx, st, randaoReveal[:])
 	if err != nil {
 		tracing.AnnotateError(span, err)
-		return set, nil, errors.Wrap(err, "could not retrieve randao signature set")
+		return nil, nil, errors.Wrap(err, "could not retrieve randao signature set")
 	}
-	set.RandaoSignatures = rSet
 	aSet, err := b.AttestationSignatureBatch(ctx, st, signed.Block().Body().Attestations())
 	if err != nil {
-		return set, nil, errors.Wrap(err, "could not retrieve attestation signature set")
+		return nil, nil, errors.Wrap(err, "could not retrieve attestation signature set")
 	}
-	set.AttestationSignatures = aSet
 
 	// Merge beacon block, randao and attestations signatures into a set.
+	set := bls.NewSet()
+	set.Join(rSet).Join(aSet)
+
 	if blk.Version() >= version.Capella {
 		changes, err := signed.Block().Body().BLSToExecutionChanges()
 		if err != nil {
-			return set, nil, errors.Wrap(err, "could not get BLSToExecutionChanges")
+			return nil, nil, errors.Wrap(err, "could not get BLSToExecutionChanges")
 		}
 		cSet, err := b.BLSChangesSignatureBatch(st, changes)
 		if err != nil {
-			return set, nil, errors.Wrap(err, "could not get BLSToExecutionChanges signatures")
+			return nil, nil, errors.Wrap(err, "could not get BLSToExecutionChanges signatures")
 		}
-		set.BLSChangeSignatures = cSet
+		set.Join(cSet)
 	}
 	return set, st, nil
 }
@@ -357,7 +268,7 @@ func ProcessOperationsNoVerifyAttsSigs(
 			return nil, err
 		}
 	} else {
-		state, err = electraOperations(ctx, state, beaconBlock)
+		state, err = electra.ProcessOperations(ctx, state, beaconBlock)
 		if err != nil {
 			return nil, err
 		}
@@ -415,7 +326,7 @@ func ProcessBlockForStateRoot(
 		if state.Version() >= version.Capella {
 			state, err = b.ProcessWithdrawals(state, executionData)
 			if err != nil {
-				return nil, errors.Wrap(ErrProcessWithdrawalsFailed, err.Error())
+				return nil, errors.Wrap(err, "could not process withdrawals")
 			}
 		}
 		if err = b.ProcessPayload(state, blk.Body()); err != nil {
@@ -427,13 +338,13 @@ func ProcessBlockForStateRoot(
 	state, err = b.ProcessRandaoNoVerify(state, randaoReveal[:])
 	if err != nil {
 		tracing.AnnotateError(span, err)
-		return nil, errors.Wrap(ErrProcessRandaoFailed, err.Error())
+		return nil, errors.Wrap(err, "could not verify and process randao")
 	}
 
 	state, err = b.ProcessEth1DataInBlock(ctx, state, signed.Block().Body().Eth1Data())
 	if err != nil {
 		tracing.AnnotateError(span, err)
-		return nil, errors.Wrap(ErrProcessEth1DataFailed, err.Error())
+		return nil, errors.Wrap(err, "could not process eth1 data")
 	}
 
 	state, err = ProcessOperationsNoVerifyAttsSigs(ctx, state, signed.Block())
@@ -452,7 +363,7 @@ func ProcessBlockForStateRoot(
 	}
 	state, _, err = altair.ProcessSyncAggregate(ctx, state, sa)
 	if err != nil {
-		return nil, errors.Wrap(ErrProcessSyncAggregateFailed, err.Error())
+		return nil, errors.Wrap(err, "process_sync_aggregate failed")
 	}
 
 	return state, nil
@@ -468,35 +379,31 @@ func altairOperations(ctx context.Context, st state.BeaconState, beaconBlock int
 	exitInfo := &validators.ExitInfo{}
 	if hasSlashings || hasExits {
 		// ExitInformation is expensive to compute, only do it if we need it.
-		exitInfo = validators.ExitInformation(st)
+		exitInfo = v.ExitInformation(st)
 		if err := helpers.UpdateTotalActiveBalanceCache(st, exitInfo.TotalActiveBalance); err != nil {
 			return nil, errors.Wrap(err, "could not update total active balance cache")
 		}
 	}
 	st, err = b.ProcessProposerSlashings(ctx, st, beaconBlock.Body().ProposerSlashings(), exitInfo)
 	if err != nil {
-		return nil, errors.Wrap(ErrProcessProposerSlashingsFailed, err.Error())
+		return nil, errors.Wrap(err, "could not process altair proposer slashing")
 	}
 	st, err = b.ProcessAttesterSlashings(ctx, st, beaconBlock.Body().AttesterSlashings(), exitInfo)
 	if err != nil {
-		return nil, errors.Wrap(ErrProcessAttesterSlashingsFailed, err.Error())
+		return nil, errors.Wrap(err, "could not process altair attester slashing")
 	}
 	st, err = altair.ProcessAttestationsNoVerifySignature(ctx, st, beaconBlock)
 	if err != nil {
-		return nil, errors.Wrap(ErrProcessAttestationsFailed, err.Error())
+		return nil, errors.Wrap(err, "could not process altair attestation")
 	}
 	if _, err := altair.ProcessDeposits(ctx, st, beaconBlock.Body().Deposits()); err != nil {
-		return nil, errors.Wrap(ErrProcessDepositsFailed, err.Error())
+		return nil, errors.Wrap(err, "could not process altair deposit")
 	}
 	st, err = b.ProcessVoluntaryExits(ctx, st, beaconBlock.Body().VoluntaryExits(), exitInfo)
 	if err != nil {
-		return nil, errors.Wrap(ErrProcessVoluntaryExitsFailed, err.Error())
+		return nil, errors.Wrap(err, "could not process voluntary exits")
 	}
-	st, err = b.ProcessBLSToExecutionChanges(st, beaconBlock)
-	if err != nil {
-		return nil, errors.Wrap(ErrProcessBLSChangesFailed, err.Error())
-	}
-	return st, nil
+	return b.ProcessBLSToExecutionChanges(st, beaconBlock)
 }
 
 // This calls phase 0 block operations.
@@ -504,32 +411,32 @@ func phase0Operations(ctx context.Context, st state.BeaconState, beaconBlock int
 	var err error
 	hasSlashings := len(beaconBlock.Body().ProposerSlashings()) > 0 || len(beaconBlock.Body().AttesterSlashings()) > 0
 	hasExits := len(beaconBlock.Body().VoluntaryExits()) > 0
-	var exitInfo *validators.ExitInfo
+	var exitInfo *v.ExitInfo
 	if hasSlashings || hasExits {
 		// ExitInformation is expensive to compute, only do it if we need it.
-		exitInfo = validators.ExitInformation(st)
+		exitInfo = v.ExitInformation(st)
 		if err := helpers.UpdateTotalActiveBalanceCache(st, exitInfo.TotalActiveBalance); err != nil {
 			return nil, errors.Wrap(err, "could not update total active balance cache")
 		}
 	}
 	st, err = b.ProcessProposerSlashings(ctx, st, beaconBlock.Body().ProposerSlashings(), exitInfo)
 	if err != nil {
-		return nil, errors.Wrap(ErrProcessProposerSlashingsFailed, err.Error())
+		return nil, errors.Wrap(err, "could not process block proposer slashings")
 	}
 	st, err = b.ProcessAttesterSlashings(ctx, st, beaconBlock.Body().AttesterSlashings(), exitInfo)
 	if err != nil {
-		return nil, errors.Wrap(ErrProcessAttesterSlashingsFailed, err.Error())
+		return nil, errors.Wrap(err, "could not process block attester slashings")
 	}
 	st, err = b.ProcessAttestationsNoVerifySignature(ctx, st, beaconBlock)
 	if err != nil {
-		return nil, errors.Wrap(ErrProcessAttestationsFailed, err.Error())
+		return nil, errors.Wrap(err, "could not process block attestations")
 	}
 	if _, err := altair.ProcessDeposits(ctx, st, beaconBlock.Body().Deposits()); err != nil {
-		return nil, errors.Wrap(ErrProcessDepositsFailed, err.Error())
+		return nil, errors.Wrap(err, "could not process deposits")
 	}
 	st, err = b.ProcessVoluntaryExits(ctx, st, beaconBlock.Body().VoluntaryExits(), exitInfo)
 	if err != nil {
-		return nil, errors.Wrap(ErrProcessVoluntaryExitsFailed, err.Error())
+		return nil, errors.Wrap(err, "could not process voluntary exits")
 	}
 	return st, nil
 }

beacon-chain/core/transition/transition_no_verify_sig_test.go

@@ -132,8 +132,7 @@ func TestProcessBlockNoVerify_PassesProcessingConditions(t *testing.T) {
 	set, _, err := transition.ProcessBlockNoVerifyAnySig(t.Context(), beaconState, wsb)
 	require.NoError(t, err)
 	// Test Signature set verifies.
-	sigSet := set.Batch()
-	verified, err := sigSet.Verify()
+	verified, err := set.Verify()
 	require.NoError(t, err)
 	assert.Equal(t, true, verified, "Could not verify signature set.")
 }
@@ -146,8 +145,7 @@ func TestProcessBlockNoVerifyAnySigAltair_OK(t *testing.T) {
 	require.NoError(t, err)
 	set, _, err := transition.ProcessBlockNoVerifyAnySig(t.Context(), beaconState, wsb)
 	require.NoError(t, err)
-	sigSet := set.Batch()
-	verified, err := sigSet.Verify()
+	verified, err := set.Verify()
 	require.NoError(t, err)
 	require.Equal(t, true, verified, "Could not verify signature set")
 }
@@ -156,9 +154,8 @@ func TestProcessBlockNoVerify_SigSetContainsDescriptions(t *testing.T) {
 	beaconState, block, _, _, _ := createFullBlockWithOperations(t)
 	wsb, err := blocks.NewSignedBeaconBlock(block)
 	require.NoError(t, err)
-	signatures, _, err := transition.ProcessBlockNoVerifyAnySig(t.Context(), beaconState, wsb)
+	set, _, err := transition.ProcessBlockNoVerifyAnySig(t.Context(), beaconState, wsb)
 	require.NoError(t, err)
-	set := signatures.Batch()
 	assert.Equal(t, len(set.Signatures), len(set.Descriptions), "Signatures and descriptions do not match up")
 	assert.Equal(t, "randao signature", set.Descriptions[0])
 	assert.Equal(t, "attestation signature", set.Descriptions[1])

beacon-chain/db/filesystem/data_column.go

@@ -512,11 +512,6 @@ func (dcs *DataColumnStorage) Get(root [fieldparams.RootLength]byte, indices []u
 	if err != nil {
 		return nil, errors.Wrap(err, "data column sidecars file path open")
 	}
-	defer func() {
-		if closeErr := file.Close(); closeErr != nil {
-			log.WithError(closeErr).WithField("file", filePath).Error("Error closing file during Get")
-		}
-	}()
 
 	// Read file metadata.
 	metadata, err := dcs.metadata(file)

beacon-chain/db/iface/interface.go

@@ -89,7 +89,6 @@ type NoHeadAccessDatabase interface {
 	SaveBlocks(ctx context.Context, blocks []interfaces.ReadOnlySignedBeaconBlock) error
 	SaveROBlocks(ctx context.Context, blks []blocks.ROBlock, cache bool) error
 	SaveGenesisBlockRoot(ctx context.Context, blockRoot [32]byte) error
-	SlotByBlockRoot(context.Context, [32]byte) (primitives.Slot, error)
 	// State related methods.
 	SaveState(ctx context.Context, state state.ReadOnlyBeaconState, blockRoot [32]byte) error
 	SaveStates(ctx context.Context, states []state.ReadOnlyBeaconState, blockRoots [][32]byte) error
@@ -97,7 +96,6 @@ type NoHeadAccessDatabase interface {
 	DeleteStates(ctx context.Context, blockRoots [][32]byte) error
 	SaveStateSummary(ctx context.Context, summary *ethpb.StateSummary) error
 	SaveStateSummaries(ctx context.Context, summaries []*ethpb.StateSummary) error
-	SlotInDiffTree(primitives.Slot) (uint64, int, error)
 	// Checkpoint operations.
 	SaveJustifiedCheckpoint(ctx context.Context, checkpoint *ethpb.Checkpoint) error
 	SaveFinalizedCheckpoint(ctx context.Context, checkpoint *ethpb.Checkpoint) error

beacon-chain/db/kv/BUILD.bazel

@@ -32,7 +32,6 @@ go_library(
         "state_diff_helpers.go",
         "state_summary.go",
         "state_summary_cache.go",
-        "testing_helpers.go",
         "utils.go",
         "validated_checkpoint.go",
         "wss.go",

beacon-chain/db/kv/custody_test.go

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

beacon-chain/db/kv/error.go

@@ -22,10 +22,6 @@ var ErrNotFoundFeeRecipient = errors.Wrap(ErrNotFound, "fee recipient")
 // ErrNotFoundMetadataSeqNum is a not found error specifically for the metadata sequence number getter
 var ErrNotFoundMetadataSeqNum = errors.Wrap(ErrNotFound, "metadata sequence number")
 
-// ErrStateDiffIncompatible is returned when state-diff feature is enabled
-// but the database was created without state-diff support.
-var ErrStateDiffIncompatible = errors.New("state-diff feature enabled but database was created without state-diff support")
-
 var errEmptyBlockSlice = errors.New("[]blocks.ROBlock is empty")
 var errIncorrectBlockParent = errors.New("unexpected missing or forked blocks in a []ROBlock")
 var errFinalizedChildNotFound = errors.New("unable to find finalized root descending from backfill batch")

beacon-chain/db/kv/genesis.go

@@ -42,10 +42,6 @@ func (s *Store) SaveGenesisData(ctx context.Context, genesisState state.BeaconSt
 	if err := s.SaveGenesisBlockRoot(ctx, genesisBlkRoot); err != nil {
 		return errors.Wrap(err, "could not save genesis block root")
 	}
-
-	if err := s.initializeStateDiff(0, genesisState); err != nil {
-		return errors.Wrap(err, "failed to initialize state diff for genesis")
-	}
 	return nil
 }
 

beacon-chain/db/kv/kv.go

@@ -203,47 +203,17 @@ func NewKVStore(ctx context.Context, dirPath string, opts ...KVStoreOption) (*St
 		return nil, err
 	}
 
-	if err := kv.startStateDiff(ctx); err != nil {
-		if errors.Is(err, ErrStateDiffIncompatible) {
-			return kv, err
+	if features.Get().EnableStateDiff {
+		sdCache, err := newStateDiffCache(kv)
+		if err != nil {
+			return nil, err
 		}
-		return nil, err
+		kv.stateDiffCache = sdCache
 	}
+
 	return kv, nil
 }
 
-func (kv *Store) startStateDiff(ctx context.Context) error {
-	if !features.Get().EnableStateDiff {
-		return nil
-	}
-	// Check if offset already exists (existing state-diff database).
-	hasOffset, err := kv.hasStateDiffOffset()
-	if err != nil {
-		return err
-	}
-
-	if hasOffset {
-		// Existing state-diff database - restarts not yet supported.
-		return errors.New("restarting with existing state-diff database not yet supported")
-	}
-
-	// Check if this is a new database (no head block).
-	headBlock, err := kv.HeadBlock(ctx)
-	if err != nil {
-		return errors.Wrap(err, "could not get head block")
-	}
-
-	if headBlock == nil {
-		// New database - will be initialized later during checkpoint/genesis sync.
-		// stateDiffCache stays nil until SaveOrigin or SaveGenesisData initializes it.
-		log.Info("State-diff enabled: will be initialized during checkpoint or genesis sync")
-	} else {
-		// Existing database without state-diff - return store with error for caller to handle.
-		return ErrStateDiffIncompatible
-	}
-	return nil
-}
-
 // ClearDB removes the previously stored database in the data directory.
 func (s *Store) ClearDB() error {
 	if err := s.Close(); err != nil {

beacon-chain/db/kv/state.go

@@ -1053,10 +1053,6 @@ func (s *Store) getStateUsingStateDiff(ctx context.Context, blockRoot [32]byte)
 		return nil, err
 	}
 
-	if uint64(slot) < s.getOffset() {
-		return nil, ErrSlotBeforeOffset
-	}
-
 	st, err := s.stateByDiff(ctx, slot)
 	if err != nil {
 		return nil, err
@@ -1074,10 +1070,6 @@ func (s *Store) hasStateUsingStateDiff(ctx context.Context, blockRoot [32]byte)
 		return false, err
 	}
 
-	if uint64(slot) < s.getOffset() {
-		return false, ErrSlotBeforeOffset
-	}
-
 	stateLvl := computeLevel(s.getOffset(), slot)
 	return stateLvl != -1, nil
 }

beacon-chain/db/kv/state_diff.go

@@ -23,16 +23,6 @@ const (
 	The data at level 0 is saved every 2**exponent[0] slots and always contains a full state snapshot that is used as a base for the delta saved at other levels.
 */
 
-// SlotInDiffTree returns whether the given slot is a saving point in the diff tree.
-// If it is, it also returns the offset and level in the tree.
-func (s *Store) SlotInDiffTree(slot primitives.Slot) (uint64, int, error) {
-	offset := s.getOffset()
-	if uint64(slot) < offset {
-		return 0, -1, ErrSlotBeforeOffset
-	}
-	return offset, computeLevel(offset, slot), nil
-}
-
 // saveStateByDiff takes a state and decides between saving a full state snapshot or a diff.
 func (s *Store) saveStateByDiff(ctx context.Context, st state.ReadOnlyBeaconState) error {
 	_, span := trace.StartSpan(ctx, "BeaconDB.saveStateByDiff")
@@ -43,10 +33,13 @@ func (s *Store) saveStateByDiff(ctx context.Context, st state.ReadOnlyBeaconStat
 	}
 
 	slot := st.Slot()
-	offset, lvl, err := s.SlotInDiffTree(slot)
-	if err != nil {
-		return errors.Wrap(err, "could not determine if slot is in diff tree")
+	offset := s.getOffset()
+	if uint64(slot) < offset {
+		return ErrSlotBeforeOffset
 	}
+
+	// Find the level to save the state.
+	lvl := computeLevel(offset, slot)
 	if lvl == -1 {
 		return nil
 	}

beacon-chain/db/kv/state_diff_cache.go

@@ -25,7 +25,7 @@ func newStateDiffCache(s *Store) (*stateDiffCache, error) {
 			return bbolt.ErrBucketNotFound
 		}
 
-		offsetBytes := bucket.Get(offsetKey)
+		offsetBytes := bucket.Get([]byte("offset"))
 		if offsetBytes == nil {
 			return errors.New("state diff cache: offset not found")
 		}

beacon-chain/db/kv/state_diff_helpers.go

@@ -9,19 +9,17 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	statenative "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
 	"github.com/OffchainLabs/prysm/v7/cmd/beacon-chain/flags"
-	"github.com/OffchainLabs/prysm/v7/config/features"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/hdiff"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/math"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	pkgerrors "github.com/pkg/errors"
 	"go.etcd.io/bbolt"
 )
 
 var (
 	offsetKey           = []byte("offset")
-	ErrSlotBeforeOffset = errors.New("slot is before state-diff root offset")
+	ErrSlotBeforeOffset = errors.New("slot is before root offset")
 )
 
 func makeKeyForStateDiffTree(level int, slot uint64) []byte {
@@ -75,9 +73,6 @@ func (s *Store) getAnchorState(offset uint64, lvl int, slot primitives.Slot) (an
 
 // computeLevel computes the level in the diff tree. Returns -1 in case slot should not be in tree.
 func computeLevel(offset uint64, slot primitives.Slot) int {
-	if uint64(slot) < offset {
-		return -1
-	}
 	rel := uint64(slot) - offset
 	for i, exp := range flags.Get().StateDiffExponents {
 		if exp < 2 || exp >= 64 {
@@ -124,66 +119,6 @@ func (s *Store) getOffset() uint64 {
 	return s.stateDiffCache.getOffset()
 }
 
-// hasStateDiffOffset checks if the state-diff offset has been set in the database.
-// This is used to detect if an existing database has state-diff enabled.
-func (s *Store) hasStateDiffOffset() (bool, error) {
-	var hasOffset bool
-	err := s.db.View(func(tx *bbolt.Tx) error {
-		bucket := tx.Bucket(stateDiffBucket)
-		if bucket == nil {
-			return nil
-		}
-		hasOffset = bucket.Get(offsetKey) != nil
-		return nil
-	})
-	return hasOffset, err
-}
-
-// initializeStateDiff sets up the state-diff schema for a new database.
-// This should be called during checkpoint sync or genesis sync.
-func (s *Store) initializeStateDiff(slot primitives.Slot, initialState state.ReadOnlyBeaconState) error {
-	// Return early if the feature is not set
-	if !features.Get().EnableStateDiff {
-		return nil
-	}
-	// Only reinitialize if the offset is different
-	if s.stateDiffCache != nil {
-		if s.stateDiffCache.getOffset() == uint64(slot) {
-			log.WithField("offset", slot).Warning("Ignoring state diff cache reinitialization")
-			return nil
-		}
-	}
-	// Write offset directly to the database (without using cache which doesn't exist yet).
-	err := s.db.Update(func(tx *bbolt.Tx) error {
-		bucket := tx.Bucket(stateDiffBucket)
-		if bucket == nil {
-			return bbolt.ErrBucketNotFound
-		}
-
-		offsetBytes := make([]byte, 8)
-		binary.LittleEndian.PutUint64(offsetBytes, uint64(slot))
-		return bucket.Put(offsetKey, offsetBytes)
-	})
-	if err != nil {
-		return pkgerrors.Wrap(err, "failed to set offset")
-	}
-
-	// Create the state diff cache (this will read the offset from the database).
-	sdCache, err := newStateDiffCache(s)
-	if err != nil {
-		return pkgerrors.Wrap(err, "failed to create state diff cache")
-	}
-	s.stateDiffCache = sdCache
-
-	// Save the initial state as a full snapshot.
-	if err := s.saveFullSnapshot(initialState); err != nil {
-		return pkgerrors.Wrap(err, "failed to save initial snapshot")
-	}
-
-	log.WithField("offset", slot).Info("Initialized state-diff cache")
-	return nil
-}
-
 func keyForSnapshot(v int) ([]byte, error) {
 	switch v {
 	case version.Fulu:

beacon-chain/db/kv/state_diff_test.go

@@ -43,12 +43,8 @@ func TestStateDiff_ComputeLevel(t *testing.T) {
 
 	offset := db.getOffset()
 
-	// should be -1. slot < offset
-	lvl := computeLevel(10, primitives.Slot(9))
-	require.Equal(t, -1, lvl)
-
 	// 2 ** 21
-	lvl = computeLevel(offset, primitives.Slot(math.PowerOf2(21)))
+	lvl := computeLevel(offset, primitives.Slot(math.PowerOf2(21)))
 	require.Equal(t, 0, lvl)
 
 	// 2 ** 21 * 3

beacon-chain/db/kv/state_test.go

@@ -1395,23 +1395,6 @@ func TestStore_CanSaveRetrieveStateUsingStateDiff(t *testing.T) {
 		require.IsNil(t, readSt)
 	})
 
-	t.Run("slot before offset", func(t *testing.T) {
-		db := setupDB(t)
-		setDefaultStateDiffExponents()
-
-		err := setOffsetInDB(db, 10)
-		require.NoError(t, err)
-
-		r := bytesutil.ToBytes32([]byte{'A'})
-		ss := &ethpb.StateSummary{Slot: 9, Root: r[:]}
-		err = db.SaveStateSummary(t.Context(), ss)
-		require.NoError(t, err)
-
-		st, err := db.getStateUsingStateDiff(t.Context(), r)
-		require.ErrorIs(t, err, ErrSlotBeforeOffset)
-		require.IsNil(t, st)
-	})
-
 	t.Run("Full state snapshot", func(t *testing.T) {
 		t.Run("using state summary", func(t *testing.T) {
 			for v := range version.All() {
@@ -1644,21 +1627,4 @@ func TestStore_HasStateUsingStateDiff(t *testing.T) {
 		}
 
 	})
-
-	t.Run("slot before offset", func(t *testing.T) {
-		db := setupDB(t)
-		setDefaultStateDiffExponents()
-
-		err := setOffsetInDB(db, 10)
-		require.NoError(t, err)
-
-		r := bytesutil.ToBytes32([]byte{'B'})
-		ss := &ethpb.StateSummary{Slot: 0, Root: r[:]}
-		err = db.SaveStateSummary(t.Context(), ss)
-		require.NoError(t, err)
-
-		hasState, err := db.hasStateUsingStateDiff(t.Context(), r)
-		require.ErrorIs(t, err, ErrSlotBeforeOffset)
-		require.Equal(t, false, hasState)
-	})
 }

beacon-chain/db/kv/testing_helpers.go

@@ -1,37 +0,0 @@
-package kv
-
-import (
-	"encoding/binary"
-	"testing"
-
-	"go.etcd.io/bbolt"
-)
-
-// InitStateDiffCacheForTesting initializes the state diff cache with the given offset.
-// This is intended for testing purposes when setting up state diff after database creation.
-// This file is only compiled when the "testing" build tag is set.
-func (s *Store) InitStateDiffCacheForTesting(t testing.TB, offset uint64) error {
-	// First, set the offset in the database.
-	err := s.db.Update(func(tx *bbolt.Tx) error {
-		bucket := tx.Bucket(stateDiffBucket)
-		if bucket == nil {
-			return bbolt.ErrBucketNotFound
-		}
-
-		offsetBytes := make([]byte, 8)
-		binary.LittleEndian.PutUint64(offsetBytes, offset)
-		return bucket.Put([]byte("offset"), offsetBytes)
-	})
-
-	if err != nil {
-		return err
-	}
-
-	// Then create the state diff cache.
-	sdCache, err := newStateDiffCache(s)
-	if err != nil {
-		return err
-	}
-	s.stateDiffCache = sdCache
-	return nil
-}

beacon-chain/db/kv/wss.go

@@ -110,8 +110,6 @@ func (s *Store) SaveOrigin(ctx context.Context, serState, serBlock []byte) error
 	if err = s.SaveFinalizedCheckpoint(ctx, chkpt); err != nil {
 		return errors.Wrap(err, "save finalized checkpoint")
 	}
-	if err := s.initializeStateDiff(state.Slot(), state); err != nil {
-		return errors.Wrap(err, "failed to initialize state diff")
-	}
+
 	return nil
 }

beacon-chain/execution/BUILD.bazel

@@ -73,7 +73,6 @@ go_library(
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
-        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_k8s_client_go//tools/cache:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",

beacon-chain/execution/engine_client.go

@@ -7,7 +7,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/OffchainLabs/go-bitfield"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/kzg"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/execution/types"
@@ -59,7 +58,6 @@ var (
 	fuluEngineEndpoints = []string{
 		GetPayloadMethodV5,
 		GetBlobsV2,
-		GetBlobsV3,
 	}
 )
 
@@ -101,8 +99,6 @@ const (
 	GetBlobsV1 = "engine_getBlobsV1"
 	// GetBlobsV2 request string for JSON-RPC.
 	GetBlobsV2 = "engine_getBlobsV2"
-	// GetBlobsV3 request string for JSON-RPC.
-	GetBlobsV3 = "engine_getBlobsV3"
 	// Defines the seconds before timing out engine endpoints with non-block execution semantics.
 	defaultEngineTimeout = time.Second
 )
@@ -126,7 +122,7 @@ type Reconstructor interface {
 		ctx context.Context, blindedBlocks []interfaces.ReadOnlySignedBeaconBlock,
 	) ([]interfaces.SignedBeaconBlock, error)
 	ReconstructBlobSidecars(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, blockRoot [fieldparams.RootLength]byte, hi func(uint64) bool) ([]blocks.VerifiedROBlob, error)
-	ConstructDataColumnSidecars(ctx context.Context, populator peerdas.ConstructionPopulator) ([]blocks.VerifiedRODataColumn, []blocks.PartialDataColumn, error)
+	ConstructDataColumnSidecars(ctx context.Context, populator peerdas.ConstructionPopulator) ([]blocks.VerifiedRODataColumn, error)
 }
 
 // EngineCaller defines a client that can interact with an Ethereum
@@ -557,22 +553,6 @@ func (s *Service) GetBlobsV2(ctx context.Context, versionedHashes []common.Hash)
 	return result, handleRPCError(err)
 }
 
-func (s *Service) GetBlobsV3(ctx context.Context, versionedHashes []common.Hash) ([]*pb.BlobAndProofV2, error) {
-	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.GetBlobsV3")
-	defer span.End()
-	start := time.Now()
-
-	if !s.capabilityCache.has(GetBlobsV3) {
-		return nil, errors.New(fmt.Sprintf("%s is not supported", GetBlobsV3))
-	}
-
-	getBlobsV3RequestsTotal.Inc()
-	result := make([]*pb.BlobAndProofV2, len(versionedHashes))
-	err := s.rpcClient.CallContext(ctx, &result, GetBlobsV3, versionedHashes)
-	getBlobsV3Latency.Observe(time.Since(start).Seconds())
-	return result, handleRPCError(err)
-}
-
 // ReconstructFullBlock takes in a blinded beacon block and reconstructs
 // a beacon block with a full execution payload via the engine API.
 func (s *Service) ReconstructFullBlock(
@@ -683,47 +663,40 @@ func (s *Service) ReconstructBlobSidecars(ctx context.Context, block interfaces.
 	return verifiedBlobs, nil
 }
 
-func (s *Service) ConstructDataColumnSidecars(ctx context.Context, populator peerdas.ConstructionPopulator) ([]blocks.VerifiedRODataColumn, []blocks.PartialDataColumn, error) {
+func (s *Service) ConstructDataColumnSidecars(ctx context.Context, populator peerdas.ConstructionPopulator) ([]blocks.VerifiedRODataColumn, error) {
 	root := populator.Root()
 
 	// Fetch cells and proofs from the execution client using the KZG commitments from the sidecar.
 	commitments, err := populator.Commitments()
 	if err != nil {
-		return nil, nil, wrapWithBlockRoot(err, root, "commitments")
+		return nil, wrapWithBlockRoot(err, root, "commitments")
 	}
 
-	included, cellsPerBlob, proofsPerBlob, err := s.fetchCellsAndProofsFromExecution(ctx, commitments)
-	log.Info("Received cells and proofs from execution client", "included", included, "cells count", len(cellsPerBlob), "err", err)
+	cellsPerBlob, proofsPerBlob, err := s.fetchCellsAndProofsFromExecution(ctx, commitments)
 	if err != nil {
-		return nil, nil, wrapWithBlockRoot(err, root, "fetch cells and proofs from execution client")
+		return nil, wrapWithBlockRoot(err, root, "fetch cells and proofs from execution client")
 	}
 
-	partialColumns, err := peerdas.PartialColumns(included, cellsPerBlob, proofsPerBlob, populator)
-	haveAllBlobs := included.Count() == uint64(len(commitments))
-	log.Info("Constructed partial columns", "haveAllBlobs", haveAllBlobs)
-
-	if haveAllBlobs {
-		// Construct data column sidears from the signed block and cells and proofs.
-		roSidecars, err := peerdas.DataColumnSidecars(cellsPerBlob, proofsPerBlob, populator)
-		if err != nil {
-			return nil, nil, wrapWithBlockRoot(err, populator.Root(), "data column sidcars from column sidecar")
-		}
-
-		// Upgrade the sidecars to verified sidecars.
-		// We trust the execution layer we are connected to, so we can upgrade the sidecar into a verified one.
-		verifiedROSidecars := upgradeSidecarsToVerifiedSidecars(roSidecars)
-
-		return verifiedROSidecars, partialColumns, nil
+	// Return early if nothing is returned from the EL.
+	if len(cellsPerBlob) == 0 {
+		return nil, nil
 	}
 
+	// Construct data column sidears from the signed block and cells and proofs.
+	roSidecars, err := peerdas.DataColumnSidecars(cellsPerBlob, proofsPerBlob, populator)
 	if err != nil {
-		return nil, nil, wrapWithBlockRoot(err, populator.Root(), "partial columns from column sidecar")
+		return nil, wrapWithBlockRoot(err, populator.Root(), "data column sidcars from column sidecar")
 	}
-	return nil, partialColumns, nil
+
+	// Upgrade the sidecars to verified sidecars.
+	// We trust the execution layer we are connected to, so we can upgrade the sidecar into a verified one.
+	verifiedROSidecars := upgradeSidecarsToVerifiedSidecars(roSidecars)
+
+	return verifiedROSidecars, nil
 }
 
 // fetchCellsAndProofsFromExecution fetches cells and proofs from the execution client (using engine_getBlobsV2 execution API method)
-func (s *Service) fetchCellsAndProofsFromExecution(ctx context.Context, kzgCommitments [][]byte) (bitfield.Bitlist /* included parts */, [][]kzg.Cell, [][]kzg.Proof, error) {
+func (s *Service) fetchCellsAndProofsFromExecution(ctx context.Context, kzgCommitments [][]byte) ([][]kzg.Cell, [][]kzg.Proof, error) {
 	// Collect KZG hashes for all blobs.
 	versionedHashes := make([]common.Hash, 0, len(kzgCommitments))
 	for _, commitment := range kzgCommitments {
@@ -731,34 +704,24 @@ func (s *Service) fetchCellsAndProofsFromExecution(ctx context.Context, kzgCommi
 		versionedHashes = append(versionedHashes, versionedHash)
 	}
 
-	var blobAndProofs []*pb.BlobAndProofV2
-
 	// Fetch all blobsAndCellsProofs from the execution client.
-	var err error
-	useV3 := s.capabilityCache.has(GetBlobsV3)
-	if useV3 {
-		// v3 can return a partial response. V2 is all or nothing
-		blobAndProofs, err = s.GetBlobsV3(ctx, versionedHashes)
-	} else {
-		blobAndProofs, err = s.GetBlobsV2(ctx, versionedHashes)
+	blobAndProofV2s, err := s.GetBlobsV2(ctx, versionedHashes)
+	if err != nil {
+		return nil, nil, errors.Wrapf(err, "get blobs V2")
 	}
 
-	if err != nil {
-		return nil, nil, nil, errors.Wrapf(err, "get blobs V2/3")
+	// Return early if nothing is returned from the EL.
+	if len(blobAndProofV2s) == 0 {
+		return nil, nil, nil
 	}
 
 	// Compute cells and proofs from the blobs and cell proofs.
-	included, cellsPerBlob, proofsPerBlob, err := peerdas.ComputeCellsAndProofsFromStructured(uint64(len(kzgCommitments)), blobAndProofs)
+	cellsPerBlob, proofsPerBlob, err := peerdas.ComputeCellsAndProofsFromStructured(blobAndProofV2s)
 	if err != nil {
-		return nil, nil, nil, errors.Wrap(err, "compute cells and proofs")
-	}
-	if included.Count() == uint64(len(kzgCommitments)) {
-		getBlobsV3CompleteResponsesTotal.Inc()
-	} else if included.Count() > 0 {
-		getBlobsV3PartialResponsesTotal.Inc()
+		return nil, nil, errors.Wrap(err, "compute cells and proofs")
 	}
 
-	return included, cellsPerBlob, proofsPerBlob, nil
+	return cellsPerBlob, proofsPerBlob, nil
 }
 
 // upgradeSidecarsToVerifiedSidecars upgrades a list of data column sidecars into verified data column sidecars.

beacon-chain/execution/engine_client_test.go

@@ -2587,7 +2587,7 @@ func TestConstructDataColumnSidecars(t *testing.T) {
 	ctx := context.Background()
 
 	t.Run("GetBlobsV2 is not supported", func(t *testing.T) {
-		_, _, err := client.ConstructDataColumnSidecars(ctx, peerdas.PopulateFromBlock(roBlock))
+		_, err := client.ConstructDataColumnSidecars(ctx, peerdas.PopulateFromBlock(roBlock))
 		require.ErrorContains(t, "engine_getBlobsV2 is not supported", err)
 	})
 
@@ -2598,7 +2598,7 @@ func TestConstructDataColumnSidecars(t *testing.T) {
 		rpcClient, client := setupRpcClientV2(t, srv.URL, client)
 		defer rpcClient.Close()
 
-		dataColumns, _, err := client.ConstructDataColumnSidecars(ctx, peerdas.PopulateFromBlock(roBlock))
+		dataColumns, err := client.ConstructDataColumnSidecars(ctx, peerdas.PopulateFromBlock(roBlock))
 		require.NoError(t, err)
 		require.Equal(t, 0, len(dataColumns))
 	})
@@ -2611,7 +2611,7 @@ func TestConstructDataColumnSidecars(t *testing.T) {
 		rpcClient, client := setupRpcClientV2(t, srv.URL, client)
 		defer rpcClient.Close()
 
-		dataColumns, _, err := client.ConstructDataColumnSidecars(ctx, peerdas.PopulateFromBlock(roBlock))
+		dataColumns, err := client.ConstructDataColumnSidecars(ctx, peerdas.PopulateFromBlock(roBlock))
 		require.NoError(t, err)
 		require.Equal(t, 128, len(dataColumns))
 	})

beacon-chain/execution/metrics.go

@@ -34,25 +34,6 @@ var (
 			Buckets: []float64{25, 50, 100, 200, 500, 1000, 2000, 4000},
 		},
 	)
-	getBlobsV3RequestsTotal = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "beacon_engine_getBlobsV3_requests_total",
-		Help: "Total number of engine_getBlobsV3 requests sent",
-	})
-	getBlobsV3CompleteResponsesTotal = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "beacon_engine_getBlobsV3_complete_responses_total",
-		Help: "Total number of complete engine_getBlobsV3 successful responses received",
-	})
-	getBlobsV3PartialResponsesTotal = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "beacon_engine_getBlobsV3_partial_responses_total",
-		Help: "Total number of engine_getBlobsV3 partial responses received",
-	})
-	getBlobsV3Latency = promauto.NewHistogram(
-		prometheus.HistogramOpts{
-			Name:    "beacon_engine_getBlobsV3_request_duration_seconds",
-			Help:    "Duration of engine_getBlobsV3 requests in seconds",
-			Buckets: []float64{0.025, 0.05, 0.1, 0.2, 0.5, 1, 2, 4},
-		},
-	)
 	errParseCount = promauto.NewCounter(prometheus.CounterOpts{
 		Name: "execution_parse_error_count",
 		Help: "The number of errors that occurred while parsing execution payload",

beacon-chain/execution/testing/mock_engine_client.go

@@ -118,8 +118,8 @@ func (e *EngineClient) ReconstructBlobSidecars(context.Context, interfaces.ReadO
 }
 
 // ConstructDataColumnSidecars is a mock implementation of the ConstructDataColumnSidecars method.
-func (e *EngineClient) ConstructDataColumnSidecars(context.Context, peerdas.ConstructionPopulator) ([]blocks.VerifiedRODataColumn, []blocks.PartialDataColumn, error) {
-	return e.DataColumnSidecars, nil, e.ErrorDataColumnSidecars
+func (e *EngineClient) ConstructDataColumnSidecars(context.Context, peerdas.ConstructionPopulator) ([]blocks.VerifiedRODataColumn, error) {
+	return e.DataColumnSidecars, e.ErrorDataColumnSidecars
 }
 
 // GetTerminalBlockHash --

beacon-chain/light-client/store_test.go

@@ -75,6 +75,7 @@ func TestLightClientStore_SetLastFinalityUpdate(t *testing.T) {
 	p2p := p2pTesting.NewTestP2P(t)
 	lcStore := NewLightClientStore(p2p, new(event.Feed), testDB.SetupDB(t))
 
+	timeForGoroutinesToFinish := 20 * time.Microsecond
 	// update 0 with basic data and no supermajority following an empty lastFinalityUpdate - should save and broadcast
 	l0 := util.NewTestLightClient(t, version.Altair)
 	update0, err := NewLightClientFinalityUpdateFromBeaconState(l0.Ctx, l0.State, l0.Block, l0.AttestedState, l0.AttestedBlock, l0.FinalizedBlock)
@@ -86,9 +87,8 @@ func TestLightClientStore_SetLastFinalityUpdate(t *testing.T) {
 
 	lcStore.SetLastFinalityUpdate(update0, true)
 	require.Equal(t, update0, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	require.Eventually(t, func() bool {
-		return p2p.BroadcastCalled.Load()
-	}, time.Second, 10*time.Millisecond, "Broadcast should have been called after setting a new last finality update when previous is nil")
+	time.Sleep(timeForGoroutinesToFinish) // give some time for the broadcast goroutine to finish
+	require.Equal(t, true, p2p.BroadcastCalled.Load(), "Broadcast should have been called after setting a new last finality update when previous is nil")
 	p2p.BroadcastCalled.Store(false) // Reset for next test
 
 	// update 1 with same finality slot, increased attested slot, and no supermajority - should save but not broadcast
@@ -102,7 +102,7 @@ func TestLightClientStore_SetLastFinalityUpdate(t *testing.T) {
 
 	lcStore.SetLastFinalityUpdate(update1, true)
 	require.Equal(t, update1, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	time.Sleep(50 * time.Millisecond) // Wait briefly to verify broadcast is not called
+	time.Sleep(timeForGoroutinesToFinish) // give some time for the broadcast goroutine to finish
 	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been called after setting a new last finality update without supermajority")
 	p2p.BroadcastCalled.Store(false) // Reset for next test
 
@@ -117,9 +117,8 @@ func TestLightClientStore_SetLastFinalityUpdate(t *testing.T) {
 
 	lcStore.SetLastFinalityUpdate(update2, true)
 	require.Equal(t, update2, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	require.Eventually(t, func() bool {
-		return p2p.BroadcastCalled.Load()
-	}, time.Second, 10*time.Millisecond, "Broadcast should have been called after setting a new last finality update with supermajority")
+	time.Sleep(timeForGoroutinesToFinish) // give some time for the broadcast goroutine to finish
+	require.Equal(t, true, p2p.BroadcastCalled.Load(), "Broadcast should have been called after setting a new last finality update with supermajority")
 	p2p.BroadcastCalled.Store(false) // Reset for next test
 
 	// update 3 with same finality slot, increased attested slot, and supermajority - should save but not broadcast
@@ -133,7 +132,7 @@ func TestLightClientStore_SetLastFinalityUpdate(t *testing.T) {
 
 	lcStore.SetLastFinalityUpdate(update3, true)
 	require.Equal(t, update3, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	time.Sleep(50 * time.Millisecond) // Wait briefly to verify broadcast is not called
+	time.Sleep(timeForGoroutinesToFinish) // give some time for the broadcast goroutine to finish
 	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been when previous was already broadcast")
 
 	// update 4 with increased finality slot, increased attested slot, and supermajority - should save and broadcast
@@ -147,9 +146,8 @@ func TestLightClientStore_SetLastFinalityUpdate(t *testing.T) {
 
 	lcStore.SetLastFinalityUpdate(update4, true)
 	require.Equal(t, update4, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	require.Eventually(t, func() bool {
-		return p2p.BroadcastCalled.Load()
-	}, time.Second, 10*time.Millisecond, "Broadcast should have been called after a new finality update with increased finality slot")
+	time.Sleep(timeForGoroutinesToFinish) // give some time for the broadcast goroutine to finish
+	require.Equal(t, true, p2p.BroadcastCalled.Load(), "Broadcast should have been called after a new finality update with increased finality slot")
 	p2p.BroadcastCalled.Store(false) // Reset for next test
 
 	// update 5 with the same new finality slot, increased attested slot, and supermajority - should save but not broadcast
@@ -163,7 +161,7 @@ func TestLightClientStore_SetLastFinalityUpdate(t *testing.T) {
 
 	lcStore.SetLastFinalityUpdate(update5, true)
 	require.Equal(t, update5, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	time.Sleep(50 * time.Millisecond) // Wait briefly to verify broadcast is not called
+	time.Sleep(timeForGoroutinesToFinish) // give some time for the broadcast goroutine to finish
 	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been called when previous was already broadcast with supermajority")
 
 	// update 6 with the same new finality slot, increased attested slot, and no supermajority - should save but not broadcast
@@ -177,7 +175,7 @@ func TestLightClientStore_SetLastFinalityUpdate(t *testing.T) {
 
 	lcStore.SetLastFinalityUpdate(update6, true)
 	require.Equal(t, update6, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	time.Sleep(50 * time.Millisecond) // Wait briefly to verify broadcast is not called
+	time.Sleep(timeForGoroutinesToFinish) // give some time for the broadcast goroutine to finish
 	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been called when previous was already broadcast with supermajority")
 }
 

beacon-chain/node/BUILD.bazel

@@ -64,6 +64,7 @@ go_library(
         "//monitoring/tracing:go_default_library",
         "//runtime:go_default_library",
         "//runtime/prereqs:go_default_library",
+        "//runtime/version:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",

beacon-chain/node/node.go

@@ -66,6 +66,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/monitoring/prometheus"
 	"github.com/OffchainLabs/prysm/v7/runtime"
 	"github.com/OffchainLabs/prysm/v7/runtime/prereqs"
+	"github.com/OffchainLabs/prysm/v7/runtime/version"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
@@ -134,20 +135,10 @@ type BeaconNode struct {
 
 // New creates a new node instance, sets up configuration options, and registers
 // every required service to the node.
-func New(cliCtx *cli.Context, cancel context.CancelFunc, optFuncs []func(*cli.Context) ([]Option, error), opts ...Option) (*BeaconNode, error) {
+func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*BeaconNode, error) {
 	if err := configureBeacon(cliCtx); err != nil {
 		return nil, errors.Wrap(err, "could not set beacon configuration options")
 	}
-
-	for _, of := range optFuncs {
-		ofo, err := of(cliCtx)
-		if err != nil {
-			return nil, err
-		}
-		if ofo != nil {
-			opts = append(opts, ofo...)
-		}
-	}
 	ctx := cliCtx.Context
 
 	beacon := &BeaconNode{
@@ -478,6 +469,10 @@ func (b *BeaconNode) OperationFeed() event.SubscriberSender {
 func (b *BeaconNode) Start() {
 	b.lock.Lock()
 
+	log.WithFields(logrus.Fields{
+		"version": version.Version(),
+	}).Info("Starting beacon node")
+
 	b.services.StartAll()
 
 	stop := b.stop
@@ -545,12 +540,7 @@ func openDB(ctx context.Context, dbPath string, clearer *dbClearer) (*kv.Store,
 	log.WithField("databasePath", dbPath).Info("Checking DB")
 
 	d, err := kv.NewKVStore(ctx, dbPath)
-	if errors.Is(err, kv.ErrStateDiffIncompatible) {
-		log.WithError(err).Warn("Disabling state-diff feature")
-		cfg := features.Get()
-		cfg.EnableStateDiff = false
-		features.Init(cfg)
-	} else if err != nil {
+	if err != nil {
 		return nil, errors.Wrapf(err, "could not create database at %s", dbPath)
 	}
 
@@ -678,7 +668,6 @@ func (b *BeaconNode) registerP2P(cliCtx *cli.Context) error {
 		DB:                    b.db,
 		StateGen:              b.stateGen,
 		ClockWaiter:           b.ClockWaiter,
-		PartialDataColumns:    b.cliCtx.Bool(flags.PartialDataColumns.Name),
 	})
 	if err != nil {
 		return err