remove docs

Fix the data column broadcast logic for partial and full columns .

.github/workflows/check-specrefs.yml

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

api/fallback/BUILD.bazel

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

api/fallback/fallback.go

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

api/fallback/fallback_test.go

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

api/grpc/grpc_connection_provider.go

@@ -25,11 +25,6 @@ type GrpcConnectionProvider interface {
 	// SwitchHost switches to the endpoint at the given index.
 	// The new connection is created lazily on next CurrentConn() call.
 	SwitchHost(index int) error
-	// ConnectionCounter returns a monotonically increasing counter that increments
-	// each time SwitchHost changes the active endpoint. This allows consumers to
-	// detect connection changes even when the host string returns to a previous value
-	// (e.g., host0 → host1 → host0).
-	ConnectionCounter() uint64
 	// Close closes the current connection.
 	Close()
 }
@@ -43,7 +38,6 @@ type grpcConnectionProvider struct {
 	// Current connection state (protected by mutex)
 	currentIndex uint64
 	conn         *grpc.ClientConn
-	connCounter  uint64
 
 	mu     sync.Mutex
 	closed bool
@@ -144,7 +138,6 @@ func (p *grpcConnectionProvider) SwitchHost(index int) error {
 
 	p.conn = nil // Clear immediately - new connection created lazily
 	p.currentIndex = uint64(index)
-	p.connCounter++
 
 	// Close old connection asynchronously to avoid blocking the caller
 	if oldConn != nil {
@@ -162,12 +155,6 @@ func (p *grpcConnectionProvider) SwitchHost(index int) error {
 	return nil
 }
 
-func (p *grpcConnectionProvider) ConnectionCounter() uint64 {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	return p.connCounter
-}
-
 func (p *grpcConnectionProvider) Close() {
 	p.mu.Lock()
 	defer p.mu.Unlock()

api/grpc/mock_grpc_provider.go

@@ -4,24 +4,17 @@ import "google.golang.org/grpc"
 
 // MockGrpcProvider implements GrpcConnectionProvider for testing.
 type MockGrpcProvider struct {
-	MockConn     *grpc.ClientConn
-	MockHosts    []string
-	CurrentIndex int
-	ConnCounter  uint64
+	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[m.CurrentIndex]
+		return m.MockHosts[0]
 	}
 	return ""
 }
-func (m *MockGrpcProvider) Hosts() []string { return m.MockHosts }
-func (m *MockGrpcProvider) SwitchHost(idx int) error {
-	m.CurrentIndex = idx
-	m.ConnCounter++
-	return nil
-}
-func (m *MockGrpcProvider) ConnectionCounter() uint64 { return m.ConnCounter }
-func (m *MockGrpcProvider) Close()                    {}
+func (m *MockGrpcProvider) Hosts() []string      { return m.MockHosts }
+func (m *MockGrpcProvider) SwitchHost(int) error { return nil }
+func (m *MockGrpcProvider) Close()               {}

api/rest/mock_rest_provider.go

@@ -9,13 +9,13 @@ import (
 // MockRestProvider implements RestConnectionProvider for testing.
 type MockRestProvider struct {
 	MockClient  *http.Client
-	MockHandler Handler
+	MockHandler RestHandler
 	MockHosts   []string
 	HostIndex   int
 }
 
 func (m *MockRestProvider) HttpClient() *http.Client { return m.MockClient }
-func (m *MockRestProvider) Handler() Handler         { return m.MockHandler }
+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)]
@@ -25,22 +25,25 @@ func (m *MockRestProvider) CurrentHost() string {
 func (m *MockRestProvider) Hosts() []string            { return m.MockHosts }
 func (m *MockRestProvider) SwitchHost(index int) error { m.HostIndex = index; return nil }
 
-// MockHandler implements Handler for testing.
-type MockHandler struct {
-	MockHost string
+// MockRestHandler implements RestHandler for testing.
+type MockRestHandler struct {
+	MockHost   string
+	MockClient *http.Client
 }
 
-func (m *MockHandler) Get(_ context.Context, _ string, _ any) error { return nil }
-func (m *MockHandler) GetStatusCode(_ context.Context, _ string) (int, error) {
+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 *MockHandler) GetSSZ(_ context.Context, _ string) ([]byte, http.Header, error) {
+func (m *MockRestHandler) GetSSZ(_ context.Context, _ string) ([]byte, http.Header, error) {
 	return nil, nil, nil
 }
-func (m *MockHandler) Post(_ context.Context, _ string, _ map[string]string, _ *bytes.Buffer, _ any) error {
+func (m *MockRestHandler) Post(_ context.Context, _ string, _ map[string]string, _ *bytes.Buffer, _ any) error {
 	return nil
 }
-func (m *MockHandler) PostSSZ(_ context.Context, _ string, _ map[string]string, _ *bytes.Buffer) ([]byte, http.Header, error) {
+func (m *MockRestHandler) PostSSZ(_ context.Context, _ string, _ map[string]string, _ *bytes.Buffer) ([]byte, http.Header, error) {
 	return nil, nil, nil
 }
-func (m *MockHandler) Host() string { return m.MockHost }
+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

@@ -17,8 +17,8 @@ import (
 type RestConnectionProvider interface {
 	// HttpClient returns the configured HTTP client with headers, timeout, and optional tracing.
 	HttpClient() *http.Client
-	// Handler returns the REST handler for making API requests.
-	Handler() Handler
+	// 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.
@@ -54,7 +54,7 @@ func WithTracing() RestConnectionProviderOption {
 type restConnectionProvider struct {
 	endpoints     []string
 	httpClient    *http.Client
-	restHandler   *handler
+	restHandler   RestHandler
 	currentIndex  atomic.Uint64
 	timeout       time.Duration
 	headers       map[string][]string
@@ -96,7 +96,7 @@ func NewRestConnectionProvider(endpoint string, opts ...RestConnectionProviderOp
 	}
 
 	// Create the REST handler with the HTTP client and initial host
-	p.restHandler = newHandler(*p.httpClient, endpoints[0])
+	p.restHandler = newRestHandler(*p.httpClient, endpoints[0])
 
 	log.WithFields(logrus.Fields{
 		"endpoints": endpoints,
@@ -124,7 +124,7 @@ func (p *restConnectionProvider) HttpClient() *http.Client {
 	return p.httpClient
 }
 
-func (p *restConnectionProvider) Handler() Handler {
+func (p *restConnectionProvider) RestHandler() RestHandler {
 	return p.restHandler
 }
 

api/rest/rest_handler.go

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

beacon-chain/blockchain/BUILD.bazel

@@ -85,7 +85,6 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//io/logs:go_default_library",
         "//math:go_default_library",
         "//monitoring/tracing:go_default_library",
         "//monitoring/tracing/trace:go_default_library",

beacon-chain/blockchain/kzg/kzg.go

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

beacon-chain/blockchain/log_helpers.go

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

beacon-chain/blockchain/setup_test.go

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

beacon-chain/core/gloas/bid.go

@@ -17,50 +17,27 @@ import (
 )
 
 // ProcessExecutionPayloadBid processes a signed execution payload bid in the Gloas fork.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// process_execution_payload_bid(state: BeaconState, block: BeaconBlock):
 //
-//	<spec fn="process_execution_payload_bid" fork="gloas" hash="6dc696bb">
-//	def process_execution_payload_bid(state: BeaconState, block: BeaconBlock) -> None:
-//	    signed_bid = block.body.signed_execution_payload_bid
-//	    bid = signed_bid.message
-//	    builder_index = bid.builder_index
-//	    amount = bid.value
-//
-//	    # For self-builds, amount must be zero regardless of withdrawal credential prefix
-//	    if builder_index == BUILDER_INDEX_SELF_BUILD:
-//	        assert amount == 0
-//	        assert signed_bid.signature == bls.G2_POINT_AT_INFINITY
-//	    else:
-//	        # Verify that the builder is active
-//	        assert is_active_builder(state, builder_index)
-//	        # Verify that the builder has funds to cover the bid
-//	        assert can_builder_cover_bid(state, builder_index, amount)
-//	        # Verify that the bid signature is valid
-//	        assert verify_execution_payload_bid_signature(state, signed_bid)
-//
-//	    # Verify that the bid is for the current slot
-//	    assert bid.slot == block.slot
-//	    # Verify that the bid is for the right parent block
-//	    assert bid.parent_block_hash == state.latest_block_hash
-//	    assert bid.parent_block_root == block.parent_root
-//	    assert bid.prev_randao == get_randao_mix(state, get_current_epoch(state))
-//
-//	    # Record the pending payment if there is some payment
-//	    if amount > 0:
-//	        pending_payment = BuilderPendingPayment(
-//	            weight=0,
-//	            withdrawal=BuilderPendingWithdrawal(
-//	                fee_recipient=bid.fee_recipient,
-//	                amount=amount,
-//	                builder_index=builder_index,
-//	            ),
-//	        )
-//	        state.builder_pending_payments[SLOTS_PER_EPOCH + bid.slot % SLOTS_PER_EPOCH] = (
-//	            pending_payment
-//	        )
-//
-//	    # Cache the signed execution payload bid
-//	    state.latest_execution_payload_bid = bid
-//	</spec>
+//	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 {

beacon-chain/core/gloas/payload_attestation.go

@@ -24,21 +24,14 @@ import (
 )
 
 // ProcessPayloadAttestations validates payload attestations in a block body.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// process_payload_attestation(state: BeaconState, payload_attestation: PayloadAttestation):
 //
-//	<spec fn="process_payload_attestation" fork="gloas" hash="f46bf0b0">
-//	def process_payload_attestation(
-//	    state: BeaconState, payload_attestation: PayloadAttestation
-//	) -> None:
-//	    data = payload_attestation.data
-//
-//	    # Check that the attestation is for the parent beacon block
-//	    assert data.beacon_block_root == state.latest_block_header.parent_root
-//	    # Check that the attestation is for the previous slot
-//	    assert data.slot + 1 == state.slot
-//	    # Verify signature
-//	    indexed_payload_attestation = get_indexed_payload_attestation(state, payload_attestation)
-//	    assert is_valid_indexed_payload_attestation(state, indexed_payload_attestation)
-//	</spec>
+//	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 {
@@ -97,24 +90,17 @@ func indexedPayloadAttestation(ctx context.Context, st state.ReadOnlyBeaconState
 }
 
 // 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]:
 //
-//	<spec fn="get_ptc" fork="gloas" hash="ae15f761">
-//	def get_ptc(state: BeaconState, slot: Slot) -> Vector[ValidatorIndex, PTC_SIZE]:
-//	    """
-//	    Get the payload timeliness committee for the given ``slot``.
-//	    """
-//	    epoch = compute_epoch_at_slot(slot)
-//	    seed = hash(get_seed(state, epoch, DOMAIN_PTC_ATTESTER) + uint_to_bytes(slot))
-//	    indices: List[ValidatorIndex] = []
-//	    # Concatenate all committees for this slot in order
-//	    committees_per_slot = get_committee_count_per_slot(state, epoch)
-//	    for i in range(committees_per_slot):
-//	        committee = get_beacon_committee(state, slot, CommitteeIndex(i))
-//	        indices.extend(committee)
-//	    return compute_balance_weighted_selection(
-//	        state, indices, seed, size=PTC_SIZE, shuffle_indices=False
-//	    )
-//	</spec>
+//	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)
@@ -166,35 +152,17 @@ func ptcSeed(st state.ReadOnlyBeaconState, epoch primitives.Epoch, slot primitiv
 }
 
 // selectByBalance selects a balance-weighted subset of input candidates.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// compute_balance_weighted_selection(state, indices, seed, size, shuffle_indices):
+// Note: shuffle_indices is false for PTC.
 //
-//	<spec fn="compute_balance_weighted_selection" fork="gloas" hash="2c9f1c23">
-//	def compute_balance_weighted_selection(
-//	    state: BeaconState,
-//	    indices: Sequence[ValidatorIndex],
-//	    seed: Bytes32,
-//	    size: uint64,
-//	    shuffle_indices: bool,
-//	) -> Sequence[ValidatorIndex]:
-//	    """
-//	    Return ``size`` indices sampled by effective balance, using ``indices``
-//	    as candidates. If ``shuffle_indices`` is ``True``, candidate indices
-//	    are themselves sampled from ``indices`` by shuffling it, otherwise
-//	    ``indices`` is traversed in order.
-//	    """
-//	    total = uint64(len(indices))
-//	    assert total > 0
-//	    selected: List[ValidatorIndex] = []
-//	    i = uint64(0)
-//	    while len(selected) < size:
-//	        next_index = i % total
-//	        if shuffle_indices:
-//	            next_index = compute_shuffled_index(next_index, total, seed)
-//	        candidate_index = indices[next_index]
-//	        if compute_balance_weighted_acceptance(state, candidate_index, seed, i):
-//	            selected.append(candidate_index)
-//	        i += 1
-//	    return selected
-//	</spec>
+//	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,
@@ -231,22 +199,15 @@ func selectByBalanceFill(
 }
 
 // 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):
 //
-//	<spec fn="compute_balance_weighted_acceptance" fork="gloas" hash="9954dcd0">
-//	def compute_balance_weighted_acceptance(
-//	    state: BeaconState, index: ValidatorIndex, seed: Bytes32, i: uint64
-//	) -> bool:
-//	    """
-//	    Return whether to accept the selection of the validator ``index``, with probability
-//	    proportional to its ``effective_balance``, and randomness given by ``seed`` and ``i``.
-//	    """
-//	    MAX_RANDOM_VALUE = 2**16 - 1
-//	    random_bytes = hash(seed + uint_to_bytes(i // 16))
-//	    offset = i % 16 * 2
-//	    random_value = bytes_to_uint64(random_bytes[offset : offset + 2])
-//	    effective_balance = state.validators[index].effective_balance
-//	    return effective_balance * MAX_RANDOM_VALUE >= MAX_EFFECTIVE_BALANCE_ELECTRA * random_value
-//	</spec>
+//	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)
@@ -263,26 +224,16 @@ func acceptByBalance(st state.ReadOnlyBeaconState, idx primitives.ValidatorIndex
 }
 
 // validIndexedPayloadAttestation verifies the signature of an indexed payload attestation.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// is_valid_indexed_payload_attestation(state: BeaconState, indexed_payload_attestation: IndexedPayloadAttestation) -> bool:
 //
-//	<spec fn="is_valid_indexed_payload_attestation" fork="gloas" hash="cf1e65b5">
-//	def is_valid_indexed_payload_attestation(
-//	    state: BeaconState, indexed_payload_attestation: IndexedPayloadAttestation
-//	) -> bool:
-//	    """
-//	    Check if ``indexed_payload_attestation`` is non-empty, has sorted indices, and has
-//	    a valid aggregate signature.
-//	    """
-//	    # Verify indices are non-empty and sorted
-//	    indices = indexed_payload_attestation.attesting_indices
-//	    if len(indices) == 0 or not indices == sorted(indices):
-//	        return False
-//
-//	    # Verify aggregate signature
-//	    pubkeys = [state.validators[i].pubkey for i in indices]
-//	    domain = get_domain(state, DOMAIN_PTC_ATTESTER, None)
-//	    signing_root = compute_signing_root(indexed_payload_attestation.data, domain)
-//	    return bls.FastAggregateVerify(pubkeys, signing_root, indexed_payload_attestation.signature)
-//	</spec>
+//	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) {

beacon-chain/core/gloas/pending_payment.go

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

beacon-chain/core/gloas/proposer_slashing.go

@@ -11,20 +11,16 @@ import (
 )
 
 // RemoveBuilderPendingPayment removes the pending builder payment for the proposal slot.
+// Spec v1.7.0 (pseudocode):
 //
-//	<spec fn="process_proposer_slashing" fork="gloas" lines="22-32" hash="4da721ef">
-//	# [New in Gloas:EIP7732]
-//	# Remove the BuilderPendingPayment corresponding to
-//	# this proposal if it is still in the 2-epoch window.
 //	slot = header_1.slot
 //	proposal_epoch = compute_epoch_at_slot(slot)
 //	if proposal_epoch == get_current_epoch(state):
-//	    payment_index = SLOTS_PER_EPOCH + slot % SLOTS_PER_EPOCH
-//	    state.builder_pending_payments[payment_index] = BuilderPendingPayment()
+//	  payment_index = SLOTS_PER_EPOCH + slot % SLOTS_PER_EPOCH
+//	  state.builder_pending_payments[payment_index] = BuilderPendingPayment()
 //	elif proposal_epoch == get_previous_epoch(state):
-//	    payment_index = slot % SLOTS_PER_EPOCH
-//	    state.builder_pending_payments[payment_index] = BuilderPendingPayment()
-//	</spec>
+//	  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)

beacon-chain/core/peerdas/BUILD.bazel

@@ -33,6 +33,7 @@ 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,11 +1,15 @@
 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"
 )
@@ -16,6 +20,7 @@ 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")
@@ -57,80 +62,113 @@ func VerifyDataColumnSidecar(sidecar blocks.RODataColumn) error {
 	return nil
 }
 
-// VerifyDataColumnsSidecarKZGProofs verifies if the KZG proofs are correct.
+// 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.
 // 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.
+// 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.
+//
 // https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/p2p-interface.md#verify_data_column_sidecar_kzg_proofs
-func VerifyDataColumnsSidecarKZGProofs(sidecars []blocks.RODataColumn) error {
-	// Compute the total count.
-	count := 0
-	for _, sidecar := range sidecars {
-		count += len(sidecar.Column)
-	}
+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)
 
-	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 anySegmentEmpty bool
+	var segments []CellProofBundleSegment
+	for _, cellProofsIter := range cellProofsIters {
+		startIdx := len(cells)
+		for bundle := range cellProofsIter {
 			var (
 				commitment kzg.Bytes48
 				cell       kzg.Cell
 				proof      kzg.Bytes48
 			)
 
-			commitmentBytes := sidecar.KzgCommitments[i]
-			cellBytes := sidecar.Column[i]
-			proofBytes := sidecar.KzgProofs[i]
-
-			if len(commitmentBytes) != len(commitment) ||
-				len(cellBytes) != len(cell) ||
-				len(proofBytes) != len(proof) {
-				return ErrMismatchLength
+			if len(bundle.Commitment) != len(commitment) ||
+				len(bundle.Cell) != len(cell) ||
+				len(bundle.Proof) != len(proof) {
+				return nil, ErrMismatchLength
 			}
 
-			copy(commitment[:], commitmentBytes)
-			copy(cell[:], cellBytes)
-			copy(proof[:], proofBytes)
+			copy(commitment[:], bundle.Commitment)
+			copy(cell[:], bundle.Cell)
+			copy(proof[:], bundle.Proof)
 
 			commitments = append(commitments, commitment)
-			indices = append(indices, sidecar.Index)
+			indices = append(indices, bundle.ColumnIndex)
 			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 errors.Wrap(err, "verify cell KZG proof batch")
+		return segments, stderrors.Join(err, ErrInvalidKZGProof)
 	}
 
 	if !verified {
-		return ErrInvalidKZGProof
+		return segments, ErrInvalidKZGProof
 	}
 
-	return nil
+	return nil, nil
 }
 
-// VerifyDataColumnSidecarInclusionProof verifies if the given KZG commitments included in the given beacon block.
-// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/p2p-interface.md#verify_data_column_sidecar_inclusion_proof
-func VerifyDataColumnSidecarInclusionProof(sidecar blocks.RODataColumn) error {
-	if sidecar.SignedBlockHeader == nil || sidecar.SignedBlockHeader.Header == nil {
-		return ErrNilBlockHeader
-	}
-
-	root := sidecar.SignedBlockHeader.Header.BodyRoot
-	if len(root) != fieldparams.RootLength {
+// 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(sidecar.KzgCommitments)
+	leaves := blocks.LeavesFromCommitments(kzgCommitments)
 
 	sparse, err := trie.GenerateTrieFromItems(leaves, fieldparams.LogMaxBlobCommitments)
 	if err != nil {
@@ -142,7 +180,7 @@ func VerifyDataColumnSidecarInclusionProof(sidecar blocks.RODataColumn) error {
 		return errors.Wrap(err, "hash tree root")
 	}
 
-	verified := trie.VerifyMerkleProof(root, hashTreeRoot[:], kzgPosition, sidecar.KzgCommitmentsInclusionProof)
+	verified := trie.VerifyMerkleProof(bodyRoot, hashTreeRoot[:], kzgPosition, inclusionProof)
 	if !verified {
 		return ErrInvalidInclusionProof
 	}
@@ -150,6 +188,31 @@ func VerifyDataColumnSidecarInclusionProof(sidecar blocks.RODataColumn) error {
 	return nil
 }
 
+// VerifyDataColumnSidecarInclusionProof verifies if the given KZG commitments included in the given beacon block.
+// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/p2p-interface.md#verify_data_column_sidecar_inclusion_proof
+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
+	}
+	return verifyKzgCommitmentsInclusionProof(
+		header.SignedBlockHeader.Header.BodyRoot,
+		header.KzgCommitments,
+		header.KzgCommitmentsInclusionProof,
+	)
+}
+
 // ComputeSubnetForDataColumnSidecar computes the subnet for a data column sidecar.
 // https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/p2p-interface.md#compute_subnet_for_data_column_sidecar
 func ComputeSubnetForDataColumnSidecar(columnIndex uint64) uint64 {

beacon-chain/core/peerdas/p2p_interface_test.go

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

beacon-chain/core/peerdas/reconstruction.go

@@ -5,6 +5,7 @@ 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"
@@ -339,7 +340,8 @@ func ComputeCellsAndProofsFromFlat(blobs [][]byte, cellProofs [][]byte) ([][]kzg
 }
 
 // ComputeCellsAndProofsFromStructured computes the cells and proofs from blobs and cell proofs.
-func ComputeCellsAndProofsFromStructured(blobsAndProofs []*pb.BlobAndProofV2) ([][]kzg.Cell, [][]kzg.Proof, error) {
+// 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) {
 	start := time.Now()
 	defer func() {
 		cellsAndProofsFromStructuredComputationTime.Observe(float64(time.Since(start).Milliseconds()))
@@ -347,14 +349,24 @@ func ComputeCellsAndProofsFromStructured(blobsAndProofs []*pb.BlobAndProofV2) ([
 
 	var wg errgroup.Group
 
-	cellsPerBlob := make([][]kzg.Cell, len(blobsAndProofs))
-	proofsPerBlob := make([][]kzg.Proof, len(blobsAndProofs))
+	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)
 
+	var j int
 	for i, blobAndProof := range blobsAndProofs {
 		if blobAndProof == nil {
-			return nil, nil, ErrNilBlobAndProof
+			continue
 		}
+		included.SetBitAt(uint64(i), true)
 
+		compactIndex := j
 		wg.Go(func() error {
 			var kzgBlob kzg.Blob
 			if copy(kzgBlob[:], blobAndProof.Blob) != len(kzgBlob) {
@@ -381,17 +393,18 @@ func ComputeCellsAndProofsFromStructured(blobsAndProofs []*pb.BlobAndProofV2) ([
 				kzgProofs = append(kzgProofs, kzgProof)
 			}
 
-			cellsPerBlob[i] = cells
-			proofsPerBlob[i] = kzgProofs
+			cellsPerBlob[compactIndex] = cells
+			proofsPerBlob[compactIndex] = kzgProofs
 			return nil
 		})
+		j++
 	}
 
 	if err := wg.Wait(); err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 
-	return cellsPerBlob, proofsPerBlob, nil
+	return included, 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,8 +479,9 @@ func TestComputeCellsAndProofsFromFlat(t *testing.T) {
 
 func TestComputeCellsAndProofsFromStructured(t *testing.T) {
 	t.Run("nil blob and proof", func(t *testing.T) {
-		_, _, err := peerdas.ComputeCellsAndProofsFromStructured([]*pb.BlobAndProofV2{nil})
-		require.ErrorIs(t, err, peerdas.ErrNilBlobAndProof)
+		included, _, _, err := peerdas.ComputeCellsAndProofsFromStructured(0, []*pb.BlobAndProofV2{nil})
+		require.NoError(t, err)
+		require.Equal(t, uint64(0), included.Count())
 	})
 
 	t.Run("nominal", func(t *testing.T) {
@@ -533,7 +534,8 @@ func TestComputeCellsAndProofsFromStructured(t *testing.T) {
 		require.NoError(t, err)
 
 		// Test ComputeCellsAndProofs
-		actualCellsPerBlob, actualProofsPerBlob, err := peerdas.ComputeCellsAndProofsFromStructured(blobsAndProofs)
+		included, actualCellsPerBlob, actualProofsPerBlob, err := peerdas.ComputeCellsAndProofsFromStructured(uint64(len(blobsAndProofs)), blobsAndProofs)
+		require.Equal(t, included.Count(), uint64(len(actualCellsPerBlob)))
 		require.NoError(t, err)
 		require.Equal(t, blobCount, len(actualCellsPerBlob))
 

beacon-chain/core/peerdas/validator.go

@@ -3,6 +3,7 @@ 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"
@@ -143,6 +144,40 @@ 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()

beacon-chain/core/transition/transition.go

@@ -143,11 +143,10 @@ func ProcessSlot(ctx context.Context, state state.BeaconState) (state.BeaconStat
 		return nil, err
 	}
 
-	// <spec fn="process_slot" fork="gloas" lines="11-13" hash="62b28839">
+	// 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
-	// </spec>
 	if state.Version() >= version.Gloas {
 		index := uint64((state.Slot() + 1) % params.BeaconConfig().SlotsPerHistoricalRoot)
 		if err := state.UpdateExecutionPayloadAvailabilityAtIndex(index, 0x0); err != nil {

beacon-chain/execution/BUILD.bazel

@@ -73,6 +73,7 @@ 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,6 +7,7 @@ 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"
@@ -58,6 +59,7 @@ var (
 	fuluEngineEndpoints = []string{
 		GetPayloadMethodV5,
 		GetBlobsV2,
+		GetBlobsV3,
 	}
 )
 
@@ -99,6 +101,8 @@ 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
 )
@@ -122,7 +126,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, error)
+	ConstructDataColumnSidecars(ctx context.Context, populator peerdas.ConstructionPopulator) ([]blocks.VerifiedRODataColumn, []blocks.PartialDataColumn, error)
 }
 
 // EngineCaller defines a client that can interact with an Ethereum
@@ -553,6 +557,22 @@ 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(
@@ -663,40 +683,47 @@ func (s *Service) ReconstructBlobSidecars(ctx context.Context, block interfaces.
 	return verifiedBlobs, nil
 }
 
-func (s *Service) ConstructDataColumnSidecars(ctx context.Context, populator peerdas.ConstructionPopulator) ([]blocks.VerifiedRODataColumn, error) {
+func (s *Service) ConstructDataColumnSidecars(ctx context.Context, populator peerdas.ConstructionPopulator) ([]blocks.VerifiedRODataColumn, []blocks.PartialDataColumn, 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, wrapWithBlockRoot(err, root, "commitments")
+		return nil, nil, wrapWithBlockRoot(err, root, "commitments")
 	}
 
-	cellsPerBlob, proofsPerBlob, err := s.fetchCellsAndProofsFromExecution(ctx, 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)
 	if err != nil {
-		return nil, wrapWithBlockRoot(err, root, "fetch cells and proofs from execution client")
+		return nil, nil, wrapWithBlockRoot(err, root, "fetch cells and proofs from execution client")
 	}
 
-	// Return early if nothing is returned from the EL.
-	if len(cellsPerBlob) == 0 {
-		return nil, nil
+	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
 	}
 
-	// Construct data column sidears from the signed block and cells and proofs.
-	roSidecars, err := peerdas.DataColumnSidecars(cellsPerBlob, proofsPerBlob, populator)
 	if err != nil {
-		return nil, wrapWithBlockRoot(err, populator.Root(), "data column sidcars from column sidecar")
+		return nil, nil, wrapWithBlockRoot(err, populator.Root(), "partial columns 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, nil
+	return nil, partialColumns, 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) ([][]kzg.Cell, [][]kzg.Proof, error) {
+func (s *Service) fetchCellsAndProofsFromExecution(ctx context.Context, kzgCommitments [][]byte) (bitfield.Bitlist /* included parts */, [][]kzg.Cell, [][]kzg.Proof, error) {
 	// Collect KZG hashes for all blobs.
 	versionedHashes := make([]common.Hash, 0, len(kzgCommitments))
 	for _, commitment := range kzgCommitments {
@@ -704,24 +731,34 @@ func (s *Service) fetchCellsAndProofsFromExecution(ctx context.Context, kzgCommi
 		versionedHashes = append(versionedHashes, versionedHash)
 	}
 
+	var blobAndProofs []*pb.BlobAndProofV2
+
 	// Fetch all blobsAndCellsProofs from the execution client.
-	blobAndProofV2s, err := s.GetBlobsV2(ctx, versionedHashes)
-	if err != nil {
-		return nil, nil, errors.Wrapf(err, "get blobs V2")
+	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)
 	}
 
-	// Return early if nothing is returned from the EL.
-	if len(blobAndProofV2s) == 0 {
-		return nil, nil, nil
+	if err != nil {
+		return nil, nil, nil, errors.Wrapf(err, "get blobs V2/3")
 	}
 
 	// Compute cells and proofs from the blobs and cell proofs.
-	cellsPerBlob, proofsPerBlob, err := peerdas.ComputeCellsAndProofsFromStructured(blobAndProofV2s)
+	included, cellsPerBlob, proofsPerBlob, err := peerdas.ComputeCellsAndProofsFromStructured(uint64(len(kzgCommitments)), blobAndProofs)
 	if err != nil {
-		return nil, nil, errors.Wrap(err, "compute cells and proofs")
+		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 cellsPerBlob, proofsPerBlob, nil
+	return included, 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,6 +34,25 @@ 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, error) {
-	return e.DataColumnSidecars, e.ErrorDataColumnSidecars
+func (e *EngineClient) ConstructDataColumnSidecars(context.Context, peerdas.ConstructionPopulator) ([]blocks.VerifiedRODataColumn, []blocks.PartialDataColumn, error) {
+	return e.DataColumnSidecars, nil, e.ErrorDataColumnSidecars
 }
 
 // GetTerminalBlockHash --

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

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

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

@@ -31,8 +31,8 @@ func New() *ForkChoice {
 		prevJustifiedCheckpoint:       &forkchoicetypes.Checkpoint{},
 		finalizedCheckpoint:           &forkchoicetypes.Checkpoint{},
 		proposerBoostRoot:             [32]byte{},
-		emptyNodeByRoot:               make(map[[fieldparams.RootLength]byte]*PayloadNode),
-		fullNodeByRoot:                make(map[[fieldparams.RootLength]byte]*PayloadNode),
+		nodeByRoot:                    make(map[[fieldparams.RootLength]byte]*Node),
+		nodeByPayload:                 make(map[[fieldparams.RootLength]byte]*Node),
 		slashedIndices:                make(map[primitives.ValidatorIndex]bool),
 		receivedBlocksLastEpoch:       [fieldparams.SlotsPerEpoch]primitives.Slot{},
 	}
@@ -44,7 +44,7 @@ func New() *ForkChoice {
 
 // NodeCount returns the current number of nodes in the Store.
 func (f *ForkChoice) NodeCount() int {
-	return len(f.store.emptyNodeByRoot)
+	return len(f.store.nodeByRoot)
 }
 
 // Head returns the head root from fork choice store.
@@ -119,14 +119,14 @@ func (f *ForkChoice) InsertNode(ctx context.Context, state state.BeaconState, ro
 		return errInvalidNilCheckpoint
 	}
 	finalizedEpoch := fc.Epoch
-	pn, err := f.store.insert(ctx, roblock, justifiedEpoch, finalizedEpoch)
+	node, err := f.store.insert(ctx, roblock, justifiedEpoch, finalizedEpoch)
 	if err != nil {
 		return err
 	}
 
-	jc, fc = f.store.pullTips(state, pn.node, jc, fc)
+	jc, fc = f.store.pullTips(state, node, jc, fc)
 	if err := f.updateCheckpoints(ctx, jc, fc); err != nil {
-		_, remErr := f.store.removeNode(ctx, pn)
+		_, remErr := f.store.removeNode(ctx, node)
 		if remErr != nil {
 			log.WithError(remErr).Error("Could not remove node")
 		}
@@ -157,32 +157,27 @@ func (f *ForkChoice) updateCheckpoints(ctx context.Context, jc, fc *ethpb.Checkp
 // HasNode returns true if the node exists in fork choice store,
 // false else wise.
 func (f *ForkChoice) HasNode(root [32]byte) bool {
-	_, ok := f.store.emptyNodeByRoot[root]
+	_, ok := f.store.nodeByRoot[root]
 	return ok
 }
 
 // IsCanonical returns true if the given root is part of the canonical chain.
 func (f *ForkChoice) IsCanonical(root [32]byte) bool {
-	//It is fine to pick empty node here since we only check if the beacon block is canonical.
-	pn, ok := f.store.emptyNodeByRoot[root]
-	if !ok || pn == nil {
+	node, ok := f.store.nodeByRoot[root]
+	if !ok || node == nil {
 		return false
 	}
 
-	if pn.node.bestDescendant == nil {
-		// The node doesn't have any children
+	if node.bestDescendant == nil {
 		if f.store.headNode.bestDescendant == nil {
-			// headNode is itself head.
-			return pn.node == f.store.headNode
+			return node == f.store.headNode
 		}
-		// headNode is not actualized and there are some descendants
-		return pn.node == f.store.headNode.bestDescendant
+		return node == f.store.headNode.bestDescendant
 	}
-	// The node has children
 	if f.store.headNode.bestDescendant == nil {
-		return pn.node.bestDescendant == f.store.headNode
+		return node.bestDescendant == f.store.headNode
 	}
-	return pn.node.bestDescendant == f.store.headNode.bestDescendant
+	return node.bestDescendant == f.store.headNode.bestDescendant
 }
 
 // IsOptimistic returns true if the given root has been optimistically synced.
@@ -191,7 +186,7 @@ func (f *ForkChoice) IsOptimistic(root [32]byte) (bool, error) {
 		return true, nil
 	}
 
-	node, ok := f.store.emptyNodeByRoot[root]
+	node, ok := f.store.nodeByRoot[root]
 	if !ok || node == nil {
 		return true, ErrNilNode
 	}
@@ -204,21 +199,17 @@ func (f *ForkChoice) AncestorRoot(ctx context.Context, root [32]byte, slot primi
 	ctx, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.AncestorRoot")
 	defer span.End()
 
-	pn, ok := f.store.emptyNodeByRoot[root]
-	if !ok || pn == nil {
+	node, ok := f.store.nodeByRoot[root]
+	if !ok || node == nil {
 		return [32]byte{}, errors.Wrap(ErrNilNode, "could not determine ancestor root")
 	}
 
-	n := pn.node
-	for n.slot > slot {
+	n := node
+	for n != nil && n.slot > slot {
 		if ctx.Err() != nil {
 			return [32]byte{}, ctx.Err()
 		}
-		if n.parent == nil {
-			n = nil
-			break
-		}
-		n = n.parent.node
+		n = n.parent
 	}
 
 	if n == nil {
@@ -231,11 +222,10 @@ func (f *ForkChoice) AncestorRoot(ctx context.Context, root [32]byte, slot primi
 // IsViableForCheckpoint returns whether the root passed is a checkpoint root for any
 // known chain in forkchoice.
 func (f *ForkChoice) IsViableForCheckpoint(cp *forkchoicetypes.Checkpoint) (bool, error) {
-	pn, ok := f.store.emptyNodeByRoot[cp.Root]
-	if !ok || pn == nil {
+	node, ok := f.store.nodeByRoot[cp.Root]
+	if !ok || node == nil {
 		return false, nil
 	}
-	node := pn.node
 	epochStart, err := slots.EpochStart(cp.Epoch)
 	if err != nil {
 		return false, err
@@ -244,13 +234,10 @@ func (f *ForkChoice) IsViableForCheckpoint(cp *forkchoicetypes.Checkpoint) (bool
 		return false, nil
 	}
 
-	// If it's the start of the epoch, it is a checkpoint
-	if node.slot == epochStart {
+	if len(node.children) == 0 {
 		return true, nil
 	}
-	// If there are no descendants of this beacon block, it is is viable as a checkpoint
-	children := f.store.allConsensusChildren(node)
-	if len(children) == 0 {
+	if node.slot == epochStart {
 		return true, nil
 	}
 	if !features.Get().IgnoreUnviableAttestations {
@@ -260,8 +247,7 @@ func (f *ForkChoice) IsViableForCheckpoint(cp *forkchoicetypes.Checkpoint) (bool
 			return true, nil
 		}
 	}
-	// If some child is after the start of the epoch, the checkpoint is viable.
-	for _, child := range children {
+	for _, child := range node.children {
 		if child.slot > epochStart {
 			return true, nil
 		}
@@ -302,7 +288,7 @@ func (f *ForkChoice) updateBalances() error {
 		if vote.currentRoot != vote.nextRoot || oldBalance != newBalance {
 			// Ignore the vote if the root is not in fork choice
 			// store, that means we have not seen the block before.
-			nextNode, ok := f.store.emptyNodeByRoot[vote.nextRoot]
+			nextNode, ok := f.store.nodeByRoot[vote.nextRoot]
 			if ok && vote.nextRoot != zHash {
 				// Protection against nil node
 				if nextNode == nil {
@@ -311,7 +297,7 @@ func (f *ForkChoice) updateBalances() error {
 				nextNode.balance += newBalance
 			}
 
-			currentNode, ok := f.store.emptyNodeByRoot[vote.currentRoot]
+			currentNode, ok := f.store.nodeByRoot[vote.currentRoot]
 			if ok && vote.currentRoot != zHash {
 				// Protection against nil node
 				if currentNode == nil {
@@ -352,13 +338,13 @@ func (f *ForkChoice) ProposerBoost() [fieldparams.RootLength]byte {
 	return f.store.proposerBoost()
 }
 
-// SetOptimisticToValid sets the node with the given root as a fully validated node. The payload for this root MUST have been processed.
+// SetOptimisticToValid sets the node with the given root as a fully validated node
 func (f *ForkChoice) SetOptimisticToValid(ctx context.Context, root [fieldparams.RootLength]byte) error {
-	fn, ok := f.store.fullNodeByRoot[root]
-	if !ok || fn == nil {
+	node, ok := f.store.nodeByRoot[root]
+	if !ok || node == nil {
 		return errors.Wrap(ErrNilNode, "could not set node to valid")
 	}
-	return f.store.setNodeAndParentValidated(ctx, fn)
+	return node.setNodeAndParentValidated(ctx)
 }
 
 // PreviousJustifiedCheckpoint of fork choice store.
@@ -401,7 +387,7 @@ func (f *ForkChoice) InsertSlashedIndex(_ context.Context, index primitives.Vali
 		return
 	}
 
-	node, ok := f.store.emptyNodeByRoot[f.votes[index].currentRoot]
+	node, ok := f.store.nodeByRoot[f.votes[index].currentRoot]
 	if !ok || node == nil {
 		return
 	}
@@ -436,28 +422,22 @@ func (f *ForkChoice) UpdateFinalizedCheckpoint(fc *forkchoicetypes.Checkpoint) e
 }
 
 // CommonAncestor returns the common ancestor root and slot between the two block roots r1 and r2.
-// This is payload aware. Consider the following situation
-// [A,full] <--- [B, full] <---[C,pending]
-//
-//	\---------[B, empty] <--[D, pending]
-//
-// Then even though C and D both descend from the beacon block B, their common ancestor is A.
 func (f *ForkChoice) CommonAncestor(ctx context.Context, r1 [32]byte, r2 [32]byte) ([32]byte, primitives.Slot, error) {
 	ctx, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.CommonAncestorRoot")
 	defer span.End()
 
-	en1, ok := f.store.emptyNodeByRoot[r1]
-	if !ok || en1 == nil {
+	n1, ok := f.store.nodeByRoot[r1]
+	if !ok || n1 == nil {
 		return [32]byte{}, 0, forkchoice.ErrUnknownCommonAncestor
 	}
 
 	// Do nothing if the input roots are the same.
 	if r1 == r2 {
-		return r1, en1.node.slot, nil
+		return r1, n1.slot, nil
 	}
 
-	en2, ok := f.store.emptyNodeByRoot[r2]
-	if !ok || en2 == nil {
+	n2, ok := f.store.nodeByRoot[r2]
+	if !ok || n2 == nil {
 		return [32]byte{}, 0, forkchoice.ErrUnknownCommonAncestor
 	}
 
@@ -465,23 +445,23 @@ func (f *ForkChoice) CommonAncestor(ctx context.Context, r1 [32]byte, r2 [32]byt
 		if ctx.Err() != nil {
 			return [32]byte{}, 0, ctx.Err()
 		}
-		if en1.node.slot > en2.node.slot {
-			en1 = en1.node.parent
+		if n1.slot > n2.slot {
+			n1 = n1.parent
 			// Reaches the end of the tree and unable to find common ancestor.
 			// This should not happen at runtime as the finalized
 			// node has to be a common ancestor
-			if en1 == nil {
+			if n1 == nil {
 				return [32]byte{}, 0, forkchoice.ErrUnknownCommonAncestor
 			}
 		} else {
-			en2 = en2.node.parent
+			n2 = n2.parent
 			// Reaches the end of the tree and unable to find common ancestor.
-			if en2 == nil {
+			if n2 == nil {
 				return [32]byte{}, 0, forkchoice.ErrUnknownCommonAncestor
 			}
 		}
-		if en1 == en2 {
-			return en1.node.root, en1.node.slot, nil
+		if n1 == n2 {
+			return n1.root, n1.slot, nil
 		}
 	}
 }
@@ -528,17 +508,35 @@ func (f *ForkChoice) CachedHeadRoot() [32]byte {
 
 // FinalizedPayloadBlockHash returns the hash of the payload at the finalized checkpoint
 func (f *ForkChoice) FinalizedPayloadBlockHash() [32]byte {
-	return f.store.latestHashForRoot(f.FinalizedCheckpoint().Root)
+	root := f.FinalizedCheckpoint().Root
+	node, ok := f.store.nodeByRoot[root]
+	if !ok || node == nil {
+		// This should not happen
+		return [32]byte{}
+	}
+	return node.payloadHash
 }
 
 // JustifiedPayloadBlockHash returns the hash of the payload at the justified checkpoint
 func (f *ForkChoice) JustifiedPayloadBlockHash() [32]byte {
-	return f.store.latestHashForRoot(f.JustifiedCheckpoint().Root)
+	root := f.JustifiedCheckpoint().Root
+	node, ok := f.store.nodeByRoot[root]
+	if !ok || node == nil {
+		// This should not happen
+		return [32]byte{}
+	}
+	return node.payloadHash
 }
 
 // UnrealizedJustifiedPayloadBlockHash returns the hash of the payload at the unrealized justified checkpoint
 func (f *ForkChoice) UnrealizedJustifiedPayloadBlockHash() [32]byte {
-	return f.store.latestHashForRoot(f.store.unrealizedJustifiedCheckpoint.Root)
+	root := f.store.unrealizedJustifiedCheckpoint.Root
+	node, ok := f.store.nodeByRoot[root]
+	if !ok || node == nil {
+		// This should not happen
+		return [32]byte{}
+	}
+	return node.payloadHash
 }
 
 // ForkChoiceDump returns a full dump of forkchoice.
@@ -591,7 +589,7 @@ func (f *ForkChoice) SetBalancesByRooter(handler forkchoice.BalancesByRooter) {
 
 // Weight returns the weight of the given root if found on the store
 func (f *ForkChoice) Weight(root [32]byte) (uint64, error) {
-	n, ok := f.store.emptyNodeByRoot[root]
+	n, ok := f.store.nodeByRoot[root]
 	if !ok || n == nil {
 		return 0, ErrNilNode
 	}
@@ -619,11 +617,11 @@ func (f *ForkChoice) updateJustifiedBalances(ctx context.Context, root [32]byte)
 
 // Slot returns the slot of the given root if it's known to forkchoice
 func (f *ForkChoice) Slot(root [32]byte) (primitives.Slot, error) {
-	n, ok := f.store.emptyNodeByRoot[root]
+	n, ok := f.store.nodeByRoot[root]
 	if !ok || n == nil {
 		return 0, ErrNilNode
 	}
-	return n.node.slot, nil
+	return n.slot, nil
 }
 
 // DependentRoot returns the last root of the epoch prior to the requested ecoch in the canonical chain.
@@ -631,7 +629,7 @@ func (f *ForkChoice) DependentRoot(epoch primitives.Epoch) ([32]byte, error) {
 	return f.DependentRootForEpoch(f.CachedHeadRoot(), epoch)
 }
 
-// DependentRootForEpoch return the last root of the epoch prior to the requested epoch for the given root.
+// DependentRootForEpoch return the last root of the epoch prior to the requested ecoch for the given root.
 func (f *ForkChoice) DependentRootForEpoch(root [32]byte, epoch primitives.Epoch) ([32]byte, error) {
 	tr, err := f.TargetRootForEpoch(root, epoch)
 	if err != nil {
@@ -640,18 +638,18 @@ func (f *ForkChoice) DependentRootForEpoch(root [32]byte, epoch primitives.Epoch
 	if tr == [32]byte{} {
 		return [32]byte{}, nil
 	}
-	en, ok := f.store.emptyNodeByRoot[tr]
-	if !ok || en == nil {
+	node, ok := f.store.nodeByRoot[tr]
+	if !ok || node == nil {
 		return [32]byte{}, ErrNilNode
 	}
-	if slots.ToEpoch(en.node.slot) >= epoch {
-		if en.node.parent != nil {
-			en = en.node.parent
+	if slots.ToEpoch(node.slot) >= epoch {
+		if node.parent != nil {
+			node = node.parent
 		} else {
 			return f.store.finalizedDependentRoot, nil
 		}
 	}
-	return en.node.root, nil
+	return node.root, nil
 }
 
 // TargetRootForEpoch returns the root of the target block for a given epoch.
@@ -663,48 +661,46 @@ func (f *ForkChoice) DependentRootForEpoch(root [32]byte, epoch primitives.Epoch
 // which case we return the root of the checkpoint of the chain containing the
 // passed root, at the given epoch
 func (f *ForkChoice) TargetRootForEpoch(root [32]byte, epoch primitives.Epoch) ([32]byte, error) {
-	n, ok := f.store.emptyNodeByRoot[root]
+	n, ok := f.store.nodeByRoot[root]
 	if !ok || n == nil {
 		return [32]byte{}, ErrNilNode
 	}
-	node := n.node
-	nodeEpoch := slots.ToEpoch(node.slot)
+	nodeEpoch := slots.ToEpoch(n.slot)
 	if epoch > nodeEpoch {
-		return node.root, nil
+		return n.root, nil
 	}
-	if node.target == nil {
+	if n.target == nil {
 		return [32]byte{}, nil
 	}
-	targetRoot := node.target.root
+	targetRoot := n.target.root
 	if epoch == nodeEpoch {
 		return targetRoot, nil
 	}
-	targetNode, ok := f.store.emptyNodeByRoot[targetRoot]
+	targetNode, ok := f.store.nodeByRoot[targetRoot]
 	if !ok || targetNode == nil {
 		return [32]byte{}, ErrNilNode
 	}
 	// If slot 0 was not missed we consider a previous block to go back at least one epoch
-	if nodeEpoch == slots.ToEpoch(targetNode.node.slot) {
-		targetNode = targetNode.node.parent
+	if nodeEpoch == slots.ToEpoch(targetNode.slot) {
+		targetNode = targetNode.parent
 		if targetNode == nil {
 			return [32]byte{}, ErrNilNode
 		}
 	}
-	return f.TargetRootForEpoch(targetNode.node.root, epoch)
+	return f.TargetRootForEpoch(targetNode.root, epoch)
 }
 
 // ParentRoot returns the block root of the parent node if it is in forkchoice.
 // The exception is for the finalized checkpoint root which we return the zero
 // hash.
 func (f *ForkChoice) ParentRoot(root [32]byte) ([32]byte, error) {
-	n, ok := f.store.emptyNodeByRoot[root]
+	n, ok := f.store.nodeByRoot[root]
 	if !ok || n == nil {
 		return [32]byte{}, ErrNilNode
 	}
 	// Return the zero hash for the tree root
-	parent := n.node.parent
-	if parent == nil {
+	if n.parent == nil {
 		return [32]byte{}, nil
 	}
-	return parent.node.root, nil
+	return n.parent.root, nil
 }

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

@@ -104,9 +104,9 @@ func TestForkChoice_UpdateBalancesPositiveChange(t *testing.T) {
 	f.justifiedBalances = []uint64{10, 20, 30}
 	require.NoError(t, f.updateBalances())
 	s := f.store
-	assert.Equal(t, uint64(10), s.emptyNodeByRoot[indexToHash(1)].balance)
-	assert.Equal(t, uint64(20), s.emptyNodeByRoot[indexToHash(2)].balance)
-	assert.Equal(t, uint64(30), s.emptyNodeByRoot[indexToHash(3)].balance)
+	assert.Equal(t, uint64(10), s.nodeByRoot[indexToHash(1)].balance)
+	assert.Equal(t, uint64(20), s.nodeByRoot[indexToHash(2)].balance)
+	assert.Equal(t, uint64(30), s.nodeByRoot[indexToHash(3)].balance)
 }
 
 func TestForkChoice_UpdateBalancesNegativeChange(t *testing.T) {
@@ -122,9 +122,9 @@ func TestForkChoice_UpdateBalancesNegativeChange(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 	s := f.store
-	s.emptyNodeByRoot[indexToHash(1)].balance = 100
-	s.emptyNodeByRoot[indexToHash(2)].balance = 100
-	s.emptyNodeByRoot[indexToHash(3)].balance = 100
+	s.nodeByRoot[indexToHash(1)].balance = 100
+	s.nodeByRoot[indexToHash(2)].balance = 100
+	s.nodeByRoot[indexToHash(3)].balance = 100
 
 	f.balances = []uint64{100, 100, 100}
 	f.votes = []Vote{
@@ -135,9 +135,9 @@ func TestForkChoice_UpdateBalancesNegativeChange(t *testing.T) {
 
 	f.justifiedBalances = []uint64{10, 20, 30}
 	require.NoError(t, f.updateBalances())
-	assert.Equal(t, uint64(10), s.emptyNodeByRoot[indexToHash(1)].balance)
-	assert.Equal(t, uint64(20), s.emptyNodeByRoot[indexToHash(2)].balance)
-	assert.Equal(t, uint64(30), s.emptyNodeByRoot[indexToHash(3)].balance)
+	assert.Equal(t, uint64(10), s.nodeByRoot[indexToHash(1)].balance)
+	assert.Equal(t, uint64(20), s.nodeByRoot[indexToHash(2)].balance)
+	assert.Equal(t, uint64(30), s.nodeByRoot[indexToHash(3)].balance)
 }
 
 func TestForkChoice_UpdateBalancesUnderflow(t *testing.T) {
@@ -153,9 +153,9 @@ func TestForkChoice_UpdateBalancesUnderflow(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 	s := f.store
-	s.emptyNodeByRoot[indexToHash(1)].balance = 100
-	s.emptyNodeByRoot[indexToHash(2)].balance = 100
-	s.emptyNodeByRoot[indexToHash(3)].balance = 100
+	s.nodeByRoot[indexToHash(1)].balance = 100
+	s.nodeByRoot[indexToHash(2)].balance = 100
+	s.nodeByRoot[indexToHash(3)].balance = 100
 
 	f.balances = []uint64{125, 125, 125}
 	f.votes = []Vote{
@@ -166,9 +166,9 @@ func TestForkChoice_UpdateBalancesUnderflow(t *testing.T) {
 
 	f.justifiedBalances = []uint64{10, 20, 30}
 	require.NoError(t, f.updateBalances())
-	assert.Equal(t, uint64(0), s.emptyNodeByRoot[indexToHash(1)].balance)
-	assert.Equal(t, uint64(0), s.emptyNodeByRoot[indexToHash(2)].balance)
-	assert.Equal(t, uint64(5), s.emptyNodeByRoot[indexToHash(3)].balance)
+	assert.Equal(t, uint64(0), s.nodeByRoot[indexToHash(1)].balance)
+	assert.Equal(t, uint64(0), s.nodeByRoot[indexToHash(2)].balance)
+	assert.Equal(t, uint64(5), s.nodeByRoot[indexToHash(3)].balance)
 }
 
 func TestForkChoice_IsCanonical(t *testing.T) {
@@ -224,10 +224,10 @@ func TestForkChoice_IsCanonicalReorg(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 
-	f.store.emptyNodeByRoot[[32]byte{'3'}].balance = 10
+	f.store.nodeByRoot[[32]byte{'3'}].balance = 10
 	require.NoError(t, f.store.treeRootNode.applyWeightChanges(ctx))
-	require.Equal(t, uint64(10), f.store.emptyNodeByRoot[[32]byte{'1'}].weight)
-	require.Equal(t, uint64(0), f.store.emptyNodeByRoot[[32]byte{'2'}].weight)
+	require.Equal(t, uint64(10), f.store.nodeByRoot[[32]byte{'1'}].weight)
+	require.Equal(t, uint64(0), f.store.nodeByRoot[[32]byte{'2'}].weight)
 
 	require.NoError(t, f.store.treeRootNode.updateBestDescendant(ctx, 1, 1, 1))
 	require.DeepEqual(t, [32]byte{'3'}, f.store.treeRootNode.bestDescendant.root)
@@ -260,7 +260,7 @@ func TestForkChoice_AncestorRoot(t *testing.T) {
 	st, roblock, err = prepareForkchoiceState(ctx, 5, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	f.store.treeRootNode = f.store.emptyNodeByRoot[indexToHash(1)]
+	f.store.treeRootNode = f.store.nodeByRoot[indexToHash(1)]
 	f.store.treeRootNode.parent = nil
 
 	r, err := f.AncestorRoot(ctx, indexToHash(3), 6)
@@ -342,21 +342,21 @@ func TestForkChoice_RemoveEquivocating(t *testing.T) {
 
 	// Process b's slashing, c is now head
 	f.InsertSlashedIndex(ctx, 1)
-	require.Equal(t, uint64(200), f.store.emptyNodeByRoot[[32]byte{'b'}].balance)
+	require.Equal(t, uint64(200), f.store.nodeByRoot[[32]byte{'b'}].balance)
 	f.justifiedBalances = []uint64{100, 200, 200, 300}
 	head, err = f.Head(ctx)
-	require.Equal(t, uint64(200), f.store.emptyNodeByRoot[[32]byte{'b'}].weight)
-	require.Equal(t, uint64(300), f.store.emptyNodeByRoot[[32]byte{'c'}].weight)
+	require.Equal(t, uint64(200), f.store.nodeByRoot[[32]byte{'b'}].weight)
+	require.Equal(t, uint64(300), f.store.nodeByRoot[[32]byte{'c'}].weight)
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'c'}, head)
 
 	// Process b's slashing again, should be a noop
 	f.InsertSlashedIndex(ctx, 1)
-	require.Equal(t, uint64(200), f.store.emptyNodeByRoot[[32]byte{'b'}].balance)
+	require.Equal(t, uint64(200), f.store.nodeByRoot[[32]byte{'b'}].balance)
 	f.justifiedBalances = []uint64{100, 200, 200, 300}
 	head, err = f.Head(ctx)
-	require.Equal(t, uint64(200), f.store.emptyNodeByRoot[[32]byte{'b'}].weight)
-	require.Equal(t, uint64(300), f.store.emptyNodeByRoot[[32]byte{'c'}].weight)
+	require.Equal(t, uint64(200), f.store.nodeByRoot[[32]byte{'b'}].weight)
+	require.Equal(t, uint64(300), f.store.nodeByRoot[[32]byte{'c'}].weight)
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'c'}, head)
 
@@ -591,7 +591,7 @@ func TestStore_CommonAncestor(t *testing.T) {
 		optimistic:               true,
 	}
 
-	f.store.emptyNodeByRoot[[32]byte{'y'}] = n
+	f.store.nodeByRoot[[32]byte{'y'}] = n
 	// broken link
 	_, _, err = f.CommonAncestor(ctx, [32]byte{'y'}, [32]byte{'a'})
 	require.ErrorIs(t, err, forkchoice.ErrUnknownCommonAncestor)
@@ -742,7 +742,7 @@ func TestWeight(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 
-	n, ok := f.store.emptyNodeByRoot[root]
+	n, ok := f.store.nodeByRoot[root]
 	require.Equal(t, true, ok)
 	n.weight = 10
 	w, err := f.Weight(root)

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

@@ -1,97 +0,0 @@
-package doublylinkedtree
-
-import (
-	"context"
-
-	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	"github.com/pkg/errors"
-)
-
-func (s *Store) getNodeInformation(block interfaces.ReadOnlyBeaconBlock, parent *PayloadNode, payloadHash *[32]byte) error {
-	sb, err := block.Body().SignedExecutionPayloadBid()
-	if err != nil {
-		return err
-	}
-	wb, err := blocks.WrappedROSignedExecutionPayloadBid(sb)
-	if err != nil {
-		return errors.Wrap(err, "failed to wrap signed bid")
-	}
-	bid, err := wb.Bid()
-	if err != nil {
-		return errors.Wrap(err, "failed to get bid from wrapped bid")
-	}
-	*payloadHash = bid.BlockHash()
-	if parent == nil {
-		// This is the tree root node.
-		return nil
-	}
-	if bid.ParentBlockHash() == parent.node.payloadHash {
-		//block builds on full
-		parent = s.fullNodeByRoot[parent.node.payloadHash]
-	}
-	return nil
-}
-
-// allConsensusChildren returns the list of all consensus blocks that build on the given node.
-func (s *Store) allConsensusChildren(n *Node) []*Node {
-	en := s.emptyNodeByRoot[n.root]
-	fn, ok := s.fullNodeByRoot[n.root]
-	if ok {
-		return append(en.children, fn.children...)
-	}
-	return en.children
-}
-
-// setNodeAndParentValidated sets the current node and all the ancestors as validated (i.e. non-optimistic).
-func (s *Store) setNodeAndParentValidated(ctx context.Context, pn *PayloadNode) error {
-	if ctx.Err() != nil {
-		return ctx.Err()
-	}
-
-	if !pn.optimistic {
-		return nil
-	}
-	pn.optimistic = false
-	if pn.full {
-		// set the empty node also a as valid
-		en := s.emptyNodeByRoot[pn.node.root]
-		en.optimistic = false
-	}
-	if pn.node.parent == nil {
-		return nil
-	}
-	return s.setNodeAndParentValidated(ctx, pn.node.parent)
-}
-
-// fullParent returns the latest full node that this block builds on.
-func (s *Store) fullParent(pn *PayloadNode) *PayloadNode {
-	parent := pn.node.parent
-	for ; parent != nil && !parent.full; parent = parent.node.parent {
-	}
-	return parent
-}
-
-// parentHash return the payload hash of the latest full node that this block builds on.
-func (s *Store) parentHash(pn *PayloadNode) [32]byte {
-	fullParent := s.fullParent(pn)
-	if fullParent == nil {
-		return [32]byte{}
-	}
-	return fullParent.node.payloadHash
-}
-
-// latestHashForRoot returns the latest payload hash for the given block root.
-func (s *Store) latestHashForRoot(root [32]byte) [32]byte {
-	// try to get the full node first
-	fn, ok := s.fullNodeByRoot[root]
-	if ok && fn != nil {
-		return fn.node.payloadHash
-	}
-	en := s.emptyNodeByRoot[root]
-	if !ok || en == nil {
-		// This should not happen
-		return [32]byte{}
-	}
-	return s.parentHash(en)
-}

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

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

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

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

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

@@ -110,6 +110,23 @@ func (n *Node) leadsToViableHead(justifiedEpoch, currentEpoch primitives.Epoch)
 	return n.bestDescendant.viableForHead(justifiedEpoch, currentEpoch)
 }
 
+// setNodeAndParentValidated sets the current node and all the ancestors as validated (i.e. non-optimistic).
+func (n *Node) setNodeAndParentValidated(ctx context.Context) error {
+	if ctx.Err() != nil {
+		return ctx.Err()
+	}
+
+	if !n.optimistic {
+		return nil
+	}
+	n.optimistic = false
+
+	if n.parent == nil {
+		return nil
+	}
+	return n.parent.setNodeAndParentValidated(ctx)
+}
+
 // arrivedEarly returns whether this node was inserted before the first
 // threshold to orphan a block.
 // Note that genesisTime has seconds granularity, therefore we use a strict

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

@@ -27,15 +27,15 @@ func TestNode_ApplyWeightChanges_PositiveChange(t *testing.T) {
 	// The updated balances of each node is 100
 	s := f.store
 
-	s.emptyNodeByRoot[indexToHash(1)].balance = 100
-	s.emptyNodeByRoot[indexToHash(2)].balance = 100
-	s.emptyNodeByRoot[indexToHash(3)].balance = 100
+	s.nodeByRoot[indexToHash(1)].balance = 100
+	s.nodeByRoot[indexToHash(2)].balance = 100
+	s.nodeByRoot[indexToHash(3)].balance = 100
 
 	assert.NoError(t, s.treeRootNode.applyWeightChanges(ctx))
 
-	assert.Equal(t, uint64(300), s.emptyNodeByRoot[indexToHash(1)].weight)
-	assert.Equal(t, uint64(200), s.emptyNodeByRoot[indexToHash(2)].weight)
-	assert.Equal(t, uint64(100), s.emptyNodeByRoot[indexToHash(3)].weight)
+	assert.Equal(t, uint64(300), s.nodeByRoot[indexToHash(1)].weight)
+	assert.Equal(t, uint64(200), s.nodeByRoot[indexToHash(2)].weight)
+	assert.Equal(t, uint64(100), s.nodeByRoot[indexToHash(3)].weight)
 }
 
 func TestNode_ApplyWeightChanges_NegativeChange(t *testing.T) {
@@ -53,19 +53,19 @@ func TestNode_ApplyWeightChanges_NegativeChange(t *testing.T) {
 
 	// The updated balances of each node is 100
 	s := f.store
-	s.emptyNodeByRoot[indexToHash(1)].weight = 400
-	s.emptyNodeByRoot[indexToHash(2)].weight = 400
-	s.emptyNodeByRoot[indexToHash(3)].weight = 400
+	s.nodeByRoot[indexToHash(1)].weight = 400
+	s.nodeByRoot[indexToHash(2)].weight = 400
+	s.nodeByRoot[indexToHash(3)].weight = 400
 
-	s.emptyNodeByRoot[indexToHash(1)].balance = 100
-	s.emptyNodeByRoot[indexToHash(2)].balance = 100
-	s.emptyNodeByRoot[indexToHash(3)].balance = 100
+	s.nodeByRoot[indexToHash(1)].balance = 100
+	s.nodeByRoot[indexToHash(2)].balance = 100
+	s.nodeByRoot[indexToHash(3)].balance = 100
 
 	assert.NoError(t, s.treeRootNode.applyWeightChanges(ctx))
 
-	assert.Equal(t, uint64(300), s.emptyNodeByRoot[indexToHash(1)].weight)
-	assert.Equal(t, uint64(200), s.emptyNodeByRoot[indexToHash(2)].weight)
-	assert.Equal(t, uint64(100), s.emptyNodeByRoot[indexToHash(3)].weight)
+	assert.Equal(t, uint64(300), s.nodeByRoot[indexToHash(1)].weight)
+	assert.Equal(t, uint64(200), s.nodeByRoot[indexToHash(2)].weight)
+	assert.Equal(t, uint64(100), s.nodeByRoot[indexToHash(3)].weight)
 }
 
 func TestNode_UpdateBestDescendant_NonViableChild(t *testing.T) {
@@ -108,8 +108,8 @@ func TestNode_UpdateBestDescendant_HigherWeightChild(t *testing.T) {
 	require.NoError(t, f.InsertNode(ctx, state, blk))
 
 	s := f.store
-	s.emptyNodeByRoot[indexToHash(1)].weight = 100
-	s.emptyNodeByRoot[indexToHash(2)].weight = 200
+	s.nodeByRoot[indexToHash(1)].weight = 100
+	s.nodeByRoot[indexToHash(2)].weight = 200
 	assert.NoError(t, s.treeRootNode.updateBestDescendant(ctx, 1, 1, 1))
 
 	assert.Equal(t, 2, len(s.treeRootNode.children))
@@ -128,8 +128,8 @@ func TestNode_UpdateBestDescendant_LowerWeightChild(t *testing.T) {
 	require.NoError(t, f.InsertNode(ctx, state, blk))
 
 	s := f.store
-	s.emptyNodeByRoot[indexToHash(1)].weight = 200
-	s.emptyNodeByRoot[indexToHash(2)].weight = 100
+	s.nodeByRoot[indexToHash(1)].weight = 200
+	s.nodeByRoot[indexToHash(2)].weight = 100
 	assert.NoError(t, s.treeRootNode.updateBestDescendant(ctx, 1, 1, 1))
 
 	assert.Equal(t, 2, len(s.treeRootNode.children))
@@ -176,9 +176,9 @@ func TestNode_LeadsToViableHead(t *testing.T) {
 	require.NoError(t, f.InsertNode(ctx, state, blk))
 
 	require.Equal(t, true, f.store.treeRootNode.leadsToViableHead(4, 5))
-	require.Equal(t, true, f.store.emptyNodeByRoot[indexToHash(5)].leadsToViableHead(4, 5))
-	require.Equal(t, false, f.store.emptyNodeByRoot[indexToHash(2)].leadsToViableHead(4, 5))
-	require.Equal(t, false, f.store.emptyNodeByRoot[indexToHash(4)].leadsToViableHead(4, 5))
+	require.Equal(t, true, f.store.nodeByRoot[indexToHash(5)].leadsToViableHead(4, 5))
+	require.Equal(t, false, f.store.nodeByRoot[indexToHash(2)].leadsToViableHead(4, 5))
+	require.Equal(t, false, f.store.nodeByRoot[indexToHash(4)].leadsToViableHead(4, 5))
 }
 
 func TestNode_SetFullyValidated(t *testing.T) {
@@ -195,25 +195,25 @@ func TestNode_SetFullyValidated(t *testing.T) {
 	state, blk, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	storeNodes[1] = f.store.emptyNodeByRoot[blk.Root()]
+	storeNodes[1] = f.store.nodeByRoot[blk.Root()]
 	require.NoError(t, f.SetOptimisticToValid(ctx, params.BeaconConfig().ZeroHash))
 	state, blk, err = prepareForkchoiceState(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	storeNodes[2] = f.store.emptyNodeByRoot[blk.Root()]
+	storeNodes[2] = f.store.nodeByRoot[blk.Root()]
 	require.NoError(t, f.SetOptimisticToValid(ctx, indexToHash(1)))
 	state, blk, err = prepareForkchoiceState(ctx, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	storeNodes[3] = f.store.emptyNodeByRoot[blk.Root()]
+	storeNodes[3] = f.store.nodeByRoot[blk.Root()]
 	state, blk, err = prepareForkchoiceState(ctx, 4, indexToHash(4), indexToHash(3), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	storeNodes[4] = f.store.emptyNodeByRoot[blk.Root()]
+	storeNodes[4] = f.store.nodeByRoot[blk.Root()]
 	state, blk, err = prepareForkchoiceState(ctx, 5, indexToHash(5), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	storeNodes[5] = f.store.emptyNodeByRoot[blk.Root()]
+	storeNodes[5] = f.store.nodeByRoot[blk.Root()]
 
 	opt, err := f.IsOptimistic(indexToHash(5))
 	require.NoError(t, err)
@@ -223,7 +223,7 @@ func TestNode_SetFullyValidated(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, true, opt)
 
-	require.NoError(t, f.store.emptyNodeByRoot[indexToHash(4)].setNodeAndParentValidated(ctx))
+	require.NoError(t, f.store.nodeByRoot[indexToHash(4)].setNodeAndParentValidated(ctx))
 
 	// block 5 should still be optimistic
 	opt, err = f.IsOptimistic(indexToHash(5))

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

@@ -9,9 +9,9 @@ import (
 
 func (s *Store) setOptimisticToInvalid(ctx context.Context, root, parentRoot, lastValidHash [32]byte) ([][32]byte, error) {
 	invalidRoots := make([][32]byte, 0)
-	node, ok := s.emptyNodeByRoot[root]
+	node, ok := s.nodeByRoot[root]
 	if !ok {
-		node, ok = s.emptyNodeByRoot[parentRoot]
+		node, ok = s.nodeByRoot[parentRoot]
 		if !ok || node == nil {
 			return invalidRoots, errors.Wrap(ErrNilNode, "could not set node to invalid")
 		}
@@ -47,69 +47,53 @@ func (s *Store) setOptimisticToInvalid(ctx context.Context, root, parentRoot, la
 
 // removeNode removes the node with the given root and all of its children
 // from the Fork Choice Store.
-func (s *Store) removeNode(ctx context.Context, pn *PayloadNode) ([][32]byte, error) {
+func (s *Store) removeNode(ctx context.Context, node *Node) ([][32]byte, error) {
 	invalidRoots := make([][32]byte, 0)
 
-	if pn == nil {
+	if node == nil {
 		return invalidRoots, errors.Wrap(ErrNilNode, "could not remove node")
 	}
-	if !pn.optimistic || pn.node.parent == nil {
+	if !node.optimistic || node.parent == nil {
 		return invalidRoots, errInvalidOptimisticStatus
 	}
-	children := pn.node.parent.children
+
+	children := node.parent.children
 	if len(children) == 1 {
-		pn.node.parent.children = []*Node{}
+		node.parent.children = []*Node{}
 	} else {
 		for i, n := range children {
-			if n == pn.node {
+			if n == node {
 				if i != len(children)-1 {
 					children[i] = children[len(children)-1]
 				}
-				pn.node.parent.children = children[:len(children)-1]
+				node.parent.children = children[:len(children)-1]
 				break
 			}
 		}
 	}
-	return s.removeNodeAndChildren(ctx, pn, invalidRoots)
+	return s.removeNodeAndChildren(ctx, node, invalidRoots)
 }
 
 // removeNodeAndChildren removes `node` and all of its descendant from the Store
-func (s *Store) removeNodeAndChildren(ctx context.Context, pn *PayloadNode, invalidRoots [][32]byte) ([][32]byte, error) {
+func (s *Store) removeNodeAndChildren(ctx context.Context, node *Node, invalidRoots [][32]byte) ([][32]byte, error) {
 	var err error
-	// If we are removing an empty node, then remove the full node as well if it exists.
-	if !pn.full {
-		fn, ok := s.fullNodeByRoot[pn.node.root]
-		if ok {
-			invalidRoots, err = s.removeNodeAndChildren(ctx, fn, invalidRoots)
-			if err != nil {
-				return invalidRoots, err
-			}
-		}
-	}
-	// Now we remove the full node's children.
-	for _, child := range pn.children {
+	for _, child := range node.children {
 		if ctx.Err() != nil {
 			return invalidRoots, ctx.Err()
 		}
-		// We need to remove only the empty node here since the recursion will take care of the full one.
-		en := s.emptyNodeByRoot[child.root]
-		if invalidRoots, err = s.removeNodeAndChildren(ctx, en, invalidRoots); err != nil {
+		if invalidRoots, err = s.removeNodeAndChildren(ctx, child, invalidRoots); err != nil {
 			return invalidRoots, err
 		}
 	}
-	// Only append the root for the empty nodes.
-	if pn.full {
-		delete(s.fullNodeByRoot, pn.node.root)
-	} else {
-		invalidRoots = append(invalidRoots, pn.node.root)
-		if pn.node.root == s.proposerBoostRoot {
-			s.proposerBoostRoot = [32]byte{}
-		}
-		if pn.node.root == s.previousProposerBoostRoot {
-			s.previousProposerBoostRoot = params.BeaconConfig().ZeroHash
-			s.previousProposerBoostScore = 0
-		}
-		delete(s.emptyNodeByRoot, pn.node.root)
+	invalidRoots = append(invalidRoots, node.root)
+	if node.root == s.proposerBoostRoot {
+		s.proposerBoostRoot = [32]byte{}
 	}
+	if node.root == s.previousProposerBoostRoot {
+		s.previousProposerBoostRoot = params.BeaconConfig().ZeroHash
+		s.previousProposerBoostScore = 0
+	}
+	delete(s.nodeByRoot, node.root)
+	delete(s.nodeByPayload, node.payloadHash)
 	return invalidRoots, nil
 }

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

@@ -274,7 +274,7 @@ func TestSetOptimisticToInvalid_CorrectChildren(t *testing.T) {
 
 	_, err = f.store.setOptimisticToInvalid(ctx, [32]byte{'d'}, [32]byte{'a'}, [32]byte{'A'})
 	require.NoError(t, err)
-	require.Equal(t, 2, len(f.store.emptyNodeByRoot[[32]byte{'a'}].children))
+	require.Equal(t, 2, len(f.store.nodeByRoot[[32]byte{'a'}].children))
 
 }
 

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

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

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

@@ -166,13 +166,13 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		// (1: 48) -> (2: 38) -> (3: 10)
 		//		    \--------------->(4: 18)
 		//
-		node1 := f.store.emptyNodeByRoot[indexToHash(1)]
+		node1 := f.store.nodeByRoot[indexToHash(1)]
 		require.Equal(t, node1.weight, uint64(48))
-		node2 := f.store.emptyNodeByRoot[indexToHash(2)]
+		node2 := f.store.nodeByRoot[indexToHash(2)]
 		require.Equal(t, node2.weight, uint64(38))
-		node3 := f.store.emptyNodeByRoot[indexToHash(3)]
+		node3 := f.store.nodeByRoot[indexToHash(3)]
 		require.Equal(t, node3.weight, uint64(10))
-		node4 := f.store.emptyNodeByRoot[indexToHash(4)]
+		node4 := f.store.nodeByRoot[indexToHash(4)]
 		require.Equal(t, node4.weight, uint64(18))
 
 		// Regression: process attestations for C, check that it

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

@@ -26,7 +26,7 @@ func (s *Store) head(ctx context.Context) ([32]byte, error) {
 	}
 
 	// JustifiedRoot has to be known
-	justifiedNode, ok := s.emptyNodeByRoot[s.justifiedCheckpoint.Root]
+	justifiedNode, ok := s.nodeByRoot[s.justifiedCheckpoint.Root]
 	if !ok || justifiedNode == nil {
 		// If the justifiedCheckpoint is from genesis, then the root is
 		// zeroHash. In this case it should be the root of forkchoice
@@ -66,27 +66,16 @@ func (s *Store) head(ctx context.Context) ([32]byte, error) {
 // It then updates the new node's parent with the best child and descendant node.
 func (s *Store) insert(ctx context.Context,
 	roblock consensus_blocks.ROBlock,
-	justifiedEpoch, finalizedEpoch primitives.Epoch,
-) (*PayloadNode, error) {
+	justifiedEpoch, finalizedEpoch primitives.Epoch) (*Node, error) {
 	ctx, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.insert")
 	defer span.End()
 
 	root := roblock.Root()
-	// Return if the block has been inserted into Store before.
-	if n, ok := s.emptyNodeByRoot[root]; ok {
-		return n, nil
-	}
-
 	block := roblock.Block()
 	slot := block.Slot()
 	parentRoot := block.ParentRoot()
-	parent := s.emptyNodeByRoot[parentRoot]
-	var payloadHash *[32]byte
-	if block.Version() >= version.Gloas {
-		if err := s.getNodeInformation(block, parent, payloadHash); err != nil {
-			return nil, err
-		}
-	} else if block.Version() >= version.Bellatrix {
+	var payloadHash [32]byte
+	if block.Version() >= version.Bellatrix {
 		execution, err := block.Body().Execution()
 		if err != nil {
 			return nil, err
@@ -94,6 +83,12 @@ func (s *Store) insert(ctx context.Context,
 		copy(payloadHash[:], execution.BlockHash())
 	}
 
+	// Return if the block has been inserted into Store before.
+	if n, ok := s.nodeByRoot[root]; ok {
+		return n, nil
+	}
+
+	parent := s.nodeByRoot[parentRoot]
 	n := &Node{
 		slot:                     slot,
 		root:                     root,
@@ -102,47 +97,32 @@ func (s *Store) insert(ctx context.Context,
 		unrealizedJustifiedEpoch: justifiedEpoch,
 		finalizedEpoch:           finalizedEpoch,
 		unrealizedFinalizedEpoch: finalizedEpoch,
-		payloadHash:              *payloadHash,
+		optimistic:               true,
+		payloadHash:              payloadHash,
+		timestamp:                time.Now(),
 	}
+
 	// Set the node's target checkpoint
 	if slot%params.BeaconConfig().SlotsPerEpoch == 0 {
 		n.target = n
 	} else if parent != nil {
-		if slots.ToEpoch(slot) == slots.ToEpoch(parent.node.slot) {
-			n.target = parent.node.target
+		if slots.ToEpoch(slot) == slots.ToEpoch(parent.slot) {
+			n.target = parent.target
 		} else {
-			n.target = parent.node
+			n.target = parent
 		}
 	}
-	var ret *PayloadNode
-	// Make the empty node.It's optimistic status equals it's parent's status.
-	pn := &PayloadNode{
-		node:       n,
-		optimistic: n.parent.optimistic,
-		timestamp:  time.Now(),
-	}
-	s.emptyNodeByRoot[root] = pn
-	ret = pn
-	if block.Version() < version.Gloas {
-		// Make also the full node, this is optimistic until the engine returns the execution payload validation.
-		fn := &PayloadNode{
-			node:       n,
-			optimistic: true,
-			timestamp:  time.Now(),
-			full:       true,
-		}
-		ret = fn
-		s.fullNodeByRoot[root] = fn
-	}
 
+	s.nodeByPayload[payloadHash] = n
+	s.nodeByRoot[root] = n
 	if parent == nil {
 		if s.treeRootNode == nil {
 			s.treeRootNode = n
 			s.headNode = n
 			s.highestReceivedNode = n
 		} else {
-			delete(s.emptyNodeByRoot, root)
-			delete(s.fullNodeByRoot, root)
+			delete(s.nodeByRoot, root)
+			delete(s.nodeByPayload, payloadHash)
 			return nil, errInvalidParentRoot
 		}
 	} else {
@@ -150,7 +130,7 @@ func (s *Store) insert(ctx context.Context,
 		// Apply proposer boost
 		now := time.Now()
 		if now.Before(s.genesisTime) {
-			return ret, nil
+			return n, nil
 		}
 		currentSlot := slots.CurrentSlot(s.genesisTime)
 		sss, err := slots.SinceSlotStart(currentSlot, s.genesisTime, now)
@@ -176,7 +156,7 @@ func (s *Store) insert(ctx context.Context,
 	}
 	// Update metrics.
 	processedBlockCount.Inc()
-	nodeCount.Set(float64(len(s.emptyNodeByRoot)))
+	nodeCount.Set(float64(len(s.nodeByRoot)))
 
 	// Only update received block slot if it's within epoch from current time.
 	if slot+params.BeaconConfig().SlotsPerEpoch > slots.CurrentSlot(s.genesisTime) {
@@ -187,7 +167,7 @@ func (s *Store) insert(ctx context.Context,
 		s.highestReceivedNode = n
 	}
 
-	return ret, nil
+	return n, nil
 }
 
 // pruneFinalizedNodeByRootMap prunes the `nodeByRoot` map
@@ -210,7 +190,8 @@ func (s *Store) pruneFinalizedNodeByRootMap(ctx context.Context, node, finalized
 	}
 
 	node.children = nil
-	delete(s.emptyNodeByRoot, node.root)
+	delete(s.nodeByRoot, node.root)
+	delete(s.nodeByPayload, node.payloadHash)
 	return nil
 }
 
@@ -222,7 +203,7 @@ func (s *Store) prune(ctx context.Context) error {
 
 	finalizedRoot := s.finalizedCheckpoint.Root
 	finalizedEpoch := s.finalizedCheckpoint.Epoch
-	finalizedNode, ok := s.emptyNodeByRoot[finalizedRoot]
+	finalizedNode, ok := s.nodeByRoot[finalizedRoot]
 	if !ok || finalizedNode == nil {
 		return errors.WithMessage(errUnknownFinalizedRoot, fmt.Sprintf("%#x", finalizedRoot))
 	}
@@ -268,7 +249,7 @@ func (s *Store) tips() ([][32]byte, []primitives.Slot) {
 	var roots [][32]byte
 	var slots []primitives.Slot
 
-	for root, node := range s.emptyNodeByRoot {
+	for root, node := range s.nodeByRoot {
 		if len(node.children) == 0 {
 			roots = append(roots, root)
 			slots = append(slots, node.slot)

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

@@ -52,7 +52,7 @@ func TestStore_NodeByRoot(t *testing.T) {
 	}
 
 	require.Equal(t, 3, f.NodeCount())
-	for root, node := range f.store.emptyNodeByRoot {
+	for root, node := range f.store.nodeByRoot {
 		v, ok := expectedRoots[root]
 		require.Equal(t, ok, true)
 		require.Equal(t, v, node)
@@ -128,16 +128,17 @@ func TestStore_Insert(t *testing.T) {
 	// The new node does not have a parent.
 	treeRootNode := &Node{slot: 0, root: indexToHash(0)}
 	nodeByRoot := map[[32]byte]*Node{indexToHash(0): treeRootNode}
+	nodeByPayload := map[[32]byte]*Node{indexToHash(0): treeRootNode}
 	jc := &forkchoicetypes.Checkpoint{Epoch: 0}
 	fc := &forkchoicetypes.Checkpoint{Epoch: 0}
-	s := &Store{emptyNodeByRoot: nodeByRoot, treeRootNode: treeRootNode, justifiedCheckpoint: jc, finalizedCheckpoint: fc, highestReceivedNode: &Node{}}
+	s := &Store{nodeByRoot: nodeByRoot, treeRootNode: treeRootNode, nodeByPayload: nodeByPayload, justifiedCheckpoint: jc, finalizedCheckpoint: fc, highestReceivedNode: &Node{}}
 	payloadHash := [32]byte{'a'}
 	ctx := t.Context()
 	_, blk, err := prepareForkchoiceState(ctx, 100, indexToHash(100), indexToHash(0), payloadHash, 1, 1)
 	require.NoError(t, err)
 	_, err = s.insert(ctx, blk, 1, 1)
 	require.NoError(t, err)
-	assert.Equal(t, 2, len(s.emptyNodeByRoot), "Did not insert block")
+	assert.Equal(t, 2, len(s.nodeByRoot), "Did not insert block")
 	assert.Equal(t, (*Node)(nil), treeRootNode.parent, "Incorrect parent")
 	assert.Equal(t, 1, len(treeRootNode.children), "Incorrect children number")
 	assert.Equal(t, payloadHash, treeRootNode.children[0].payloadHash, "Incorrect payload hash")
@@ -166,7 +167,7 @@ func TestStore_Prune_MoreThanThreshold(t *testing.T) {
 	// Finalized root is at index 99 so everything before 99 should be pruned.
 	s.finalizedCheckpoint.Root = indexToHash(99)
 	require.NoError(t, s.prune(t.Context()))
-	assert.Equal(t, 1, len(s.emptyNodeByRoot), "Incorrect nodes count")
+	assert.Equal(t, 1, len(s.nodeByRoot), "Incorrect nodes count")
 }
 
 func TestStore_Prune_MoreThanOnce(t *testing.T) {
@@ -188,12 +189,12 @@ func TestStore_Prune_MoreThanOnce(t *testing.T) {
 	// Finalized root is at index 11 so everything before 11 should be pruned.
 	s.finalizedCheckpoint.Root = indexToHash(10)
 	require.NoError(t, s.prune(t.Context()))
-	assert.Equal(t, 90, len(s.emptyNodeByRoot), "Incorrect nodes count")
+	assert.Equal(t, 90, len(s.nodeByRoot), "Incorrect nodes count")
 
 	// One more time.
 	s.finalizedCheckpoint.Root = indexToHash(20)
 	require.NoError(t, s.prune(t.Context()))
-	assert.Equal(t, 80, len(s.emptyNodeByRoot), "Incorrect nodes count")
+	assert.Equal(t, 80, len(s.nodeByRoot), "Incorrect nodes count")
 }
 
 func TestStore_Prune_ReturnEarly(t *testing.T) {
@@ -236,7 +237,8 @@ func TestStore_Prune_NoDanglingBranch(t *testing.T) {
 	s := f.store
 	s.finalizedCheckpoint.Root = indexToHash(1)
 	require.NoError(t, s.prune(t.Context()))
-	require.Equal(t, len(s.emptyNodeByRoot), 1)
+	require.Equal(t, len(s.nodeByRoot), 1)
+	require.Equal(t, len(s.nodeByPayload), 1)
 }
 
 // This test starts with the following branching diagram
@@ -316,7 +318,9 @@ func TestStore_PruneMapsNodes(t *testing.T) {
 	s := f.store
 	s.finalizedCheckpoint.Root = indexToHash(1)
 	require.NoError(t, s.prune(t.Context()))
-	require.Equal(t, len(s.emptyNodeByRoot), 1)
+	require.Equal(t, len(s.nodeByRoot), 1)
+	require.Equal(t, len(s.nodeByPayload), 1)
+
 }
 
 func TestForkChoice_ReceivedBlocksLastEpoch(t *testing.T) {

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

@@ -21,26 +21,24 @@ type ForkChoice struct {
 	balancesByRoot      forkchoice.BalancesByRooter // handler to obtain balances for the state with a given root
 }
 
-var _ forkchoice.ForkChoicer = (*ForkChoice)(nil)
-
 // Store defines the fork choice store which includes block nodes and the last view of checkpoint information.
 type Store struct {
-	justifiedCheckpoint           *forkchoicetypes.Checkpoint                   // latest justified epoch in store.
-	unrealizedJustifiedCheckpoint *forkchoicetypes.Checkpoint                   // best unrealized justified checkpoint in store.
-	unrealizedFinalizedCheckpoint *forkchoicetypes.Checkpoint                   // best unrealized finalized checkpoint in store.
-	prevJustifiedCheckpoint       *forkchoicetypes.Checkpoint                   // previous justified checkpoint in store.
-	finalizedCheckpoint           *forkchoicetypes.Checkpoint                   // latest finalized epoch in store.
-	proposerBoostRoot             [fieldparams.RootLength]byte                  // latest block root that was boosted after being received in a timely manner.
-	previousProposerBoostRoot     [fieldparams.RootLength]byte                  // previous block root that was boosted after being received in a timely manner.
-	previousProposerBoostScore    uint64                                        // previous proposer boosted root score.
-	finalizedDependentRoot        [fieldparams.RootLength]byte                  // dependent root at finalized checkpoint.
-	committeeWeight               uint64                                        // tracks the total active validator balance divided by the number of slots per Epoch.
-	treeRootNode                  *Node                                         // the root node of the store tree.
-	headNode                      *Node                                         // last head Node
-	emptyNodeByRoot               map[[fieldparams.RootLength]byte]*PayloadNode // nodes indexed by roots.
-	fullNodeByRoot                map[[fieldparams.RootLength]byte]*PayloadNode // nodes indexed by payload Hash
-	slashedIndices                map[primitives.ValidatorIndex]bool            // the list of equivocating validator indices
-	originRoot                    [fieldparams.RootLength]byte                  // The genesis block root
+	justifiedCheckpoint           *forkchoicetypes.Checkpoint            // latest justified epoch in store.
+	unrealizedJustifiedCheckpoint *forkchoicetypes.Checkpoint            // best unrealized justified checkpoint in store.
+	unrealizedFinalizedCheckpoint *forkchoicetypes.Checkpoint            // best unrealized finalized checkpoint in store.
+	prevJustifiedCheckpoint       *forkchoicetypes.Checkpoint            // previous justified checkpoint in store.
+	finalizedCheckpoint           *forkchoicetypes.Checkpoint            // latest finalized epoch in store.
+	proposerBoostRoot             [fieldparams.RootLength]byte           // latest block root that was boosted after being received in a timely manner.
+	previousProposerBoostRoot     [fieldparams.RootLength]byte           // previous block root that was boosted after being received in a timely manner.
+	previousProposerBoostScore    uint64                                 // previous proposer boosted root score.
+	finalizedDependentRoot        [fieldparams.RootLength]byte           // dependent root at finalized checkpoint.
+	committeeWeight               uint64                                 // tracks the total active validator balance divided by the number of slots per Epoch.
+	treeRootNode                  *Node                                  // the root node of the store tree.
+	headNode                      *Node                                  // last head Node
+	nodeByRoot                    map[[fieldparams.RootLength]byte]*Node // nodes indexed by roots.
+	nodeByPayload                 map[[fieldparams.RootLength]byte]*Node // nodes indexed by payload Hash
+	slashedIndices                map[primitives.ValidatorIndex]bool     // the list of equivocating validator indices
+	originRoot                    [fieldparams.RootLength]byte           // The genesis block root
 	genesisTime                   time.Time
 	highestReceivedNode           *Node                                      // The highest slot node.
 	receivedBlocksLastEpoch       [fieldparams.SlotsPerEpoch]primitives.Slot // Using `highestReceivedSlot`. The slot of blocks received in the last epoch.
@@ -53,26 +51,18 @@ type Node struct {
 	slot                     primitives.Slot              // slot of the block converted to the node.
 	root                     [fieldparams.RootLength]byte // root of the block converted to the node.
 	payloadHash              [fieldparams.RootLength]byte // payloadHash of the block converted to the node.
-	parent                   *PayloadNode                 // parent index of this node.
+	parent                   *Node                        // parent index of this node.
 	target                   *Node                        // target checkpoint for
-	bestDescendant           *Node                        // bestDescendant node of this node.
+	children                 []*Node                      // the list of direct children of this Node
 	justifiedEpoch           primitives.Epoch             // justifiedEpoch of this node.
 	unrealizedJustifiedEpoch primitives.Epoch             // the epoch that would be justified if the block would be advanced to the next epoch.
 	finalizedEpoch           primitives.Epoch             // finalizedEpoch of this node.
 	unrealizedFinalizedEpoch primitives.Epoch             // the epoch that would be finalized if the block would be advanced to the next epoch.
 	balance                  uint64                       // the balance that voted for this node directly
 	weight                   uint64                       // weight of this node: the total balance including children
-}
-
-// PayloadNode defines a full Forkchoice node after the Gloas fork, with the payload status either empty of full
-type PayloadNode struct {
-	node       *Node     // the consensus part of this full forkchoice node
-	children   []*Node   // the list of direct children of this Node
-	full       bool      // whether this node represents a payload present or not
-	balance    uint64    // the balance that voted for this node directly
-	weight     uint64    // weight of this node: the total balance including children
-	optimistic bool      // whether the block has been fully validated or not
-	timestamp  time.Time // The timestamp when the node was inserted.
+	bestDescendant           *Node                        // bestDescendant node of this node.
+	optimistic               bool                         // whether the block has been fully validated or not
+	timestamp                time.Time                    // The timestamp when the node was inserted.
 }
 
 // Vote defines an individual validator's vote.

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

@@ -15,7 +15,7 @@ import (
 )
 
 func (s *Store) setUnrealizedJustifiedEpoch(root [32]byte, epoch primitives.Epoch) error {
-	node, ok := s.emptyNodeByRoot[root]
+	node, ok := s.nodeByRoot[root]
 	if !ok || node == nil {
 		return errors.Wrap(ErrNilNode, "could not set unrealized justified epoch")
 	}
@@ -27,7 +27,7 @@ func (s *Store) setUnrealizedJustifiedEpoch(root [32]byte, epoch primitives.Epoc
 }
 
 func (s *Store) setUnrealizedFinalizedEpoch(root [32]byte, epoch primitives.Epoch) error {
-	node, ok := s.emptyNodeByRoot[root]
+	node, ok := s.nodeByRoot[root]
 	if !ok || node == nil {
 		return errors.Wrap(ErrNilNode, "could not set unrealized finalized epoch")
 	}
@@ -41,7 +41,7 @@ func (s *Store) setUnrealizedFinalizedEpoch(root [32]byte, epoch primitives.Epoc
 // updateUnrealizedCheckpoints "realizes" the unrealized justified and finalized
 // epochs stored within nodes. It should be called at the beginning of each epoch.
 func (f *ForkChoice) updateUnrealizedCheckpoints(ctx context.Context) error {
-	for _, node := range f.store.emptyNodeByRoot {
+	for _, node := range f.store.nodeByRoot {
 		node.justifiedEpoch = node.unrealizedJustifiedEpoch
 		node.finalizedEpoch = node.unrealizedFinalizedEpoch
 		if node.justifiedEpoch > f.store.justifiedCheckpoint.Epoch {

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

@@ -22,12 +22,12 @@ func TestStore_SetUnrealizedEpochs(t *testing.T) {
 	state, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	require.Equal(t, primitives.Epoch(1), f.store.emptyNodeByRoot[[32]byte{'b'}].unrealizedJustifiedEpoch)
-	require.Equal(t, primitives.Epoch(1), f.store.emptyNodeByRoot[[32]byte{'b'}].unrealizedFinalizedEpoch)
+	require.Equal(t, primitives.Epoch(1), f.store.nodeByRoot[[32]byte{'b'}].unrealizedJustifiedEpoch)
+	require.Equal(t, primitives.Epoch(1), f.store.nodeByRoot[[32]byte{'b'}].unrealizedFinalizedEpoch)
 	require.NoError(t, f.store.setUnrealizedJustifiedEpoch([32]byte{'b'}, 2))
 	require.NoError(t, f.store.setUnrealizedFinalizedEpoch([32]byte{'b'}, 2))
-	require.Equal(t, primitives.Epoch(2), f.store.emptyNodeByRoot[[32]byte{'b'}].unrealizedJustifiedEpoch)
-	require.Equal(t, primitives.Epoch(2), f.store.emptyNodeByRoot[[32]byte{'b'}].unrealizedFinalizedEpoch)
+	require.Equal(t, primitives.Epoch(2), f.store.nodeByRoot[[32]byte{'b'}].unrealizedJustifiedEpoch)
+	require.Equal(t, primitives.Epoch(2), f.store.nodeByRoot[[32]byte{'b'}].unrealizedFinalizedEpoch)
 
 	require.ErrorIs(t, errInvalidUnrealizedJustifiedEpoch, f.store.setUnrealizedJustifiedEpoch([32]byte{'b'}, 0))
 	require.ErrorIs(t, errInvalidUnrealizedFinalizedEpoch, f.store.setUnrealizedFinalizedEpoch([32]byte{'b'}, 0))
@@ -78,7 +78,7 @@ func TestStore_LongFork(t *testing.T) {
 	// Add an attestation to c, it is head
 	f.ProcessAttestation(ctx, []uint64{0}, [32]byte{'c'}, 1)
 	f.justifiedBalances = []uint64{100}
-	c := f.store.emptyNodeByRoot[[32]byte{'c'}]
+	c := f.store.nodeByRoot[[32]byte{'c'}]
 	require.Equal(t, primitives.Epoch(2), slots.ToEpoch(c.slot))
 	driftGenesisTime(f, c.slot, 0)
 	headRoot, err := f.Head(ctx)
@@ -91,15 +91,15 @@ func TestStore_LongFork(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	require.NoError(t, f.UpdateJustifiedCheckpoint(ctx, &forkchoicetypes.Checkpoint{Epoch: 2, Root: ha}))
-	d := f.store.emptyNodeByRoot[[32]byte{'d'}]
+	d := f.store.nodeByRoot[[32]byte{'d'}]
 	require.Equal(t, primitives.Epoch(3), slots.ToEpoch(d.slot))
 	driftGenesisTime(f, d.slot, 0)
 	require.Equal(t, true, d.viableForHead(f.store.justifiedCheckpoint.Epoch, slots.ToEpoch(d.slot)))
 	headRoot, err = f.Head(ctx)
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'c'}, headRoot)
-	require.Equal(t, uint64(0), f.store.emptyNodeByRoot[[32]byte{'d'}].weight)
-	require.Equal(t, uint64(100), f.store.emptyNodeByRoot[[32]byte{'c'}].weight)
+	require.Equal(t, uint64(0), f.store.nodeByRoot[[32]byte{'d'}].weight)
+	require.Equal(t, uint64(100), f.store.nodeByRoot[[32]byte{'c'}].weight)
 }
 
 //	Epoch 1                Epoch 2               Epoch 3
@@ -243,8 +243,8 @@ func TestStore_ForkNextEpoch(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'d'}, headRoot)
 	require.Equal(t, primitives.Epoch(2), f.JustifiedCheckpoint().Epoch)
-	require.Equal(t, uint64(0), f.store.emptyNodeByRoot[[32]byte{'d'}].weight)
-	require.Equal(t, uint64(100), f.store.emptyNodeByRoot[[32]byte{'h'}].weight)
+	require.Equal(t, uint64(0), f.store.nodeByRoot[[32]byte{'d'}].weight)
+	require.Equal(t, uint64(100), f.store.nodeByRoot[[32]byte{'h'}].weight)
 	// Set current epoch to 3, and H's unrealized checkpoint. Check it's head
 	driftGenesisTime(f, 99, 0)
 	require.NoError(t, f.store.setUnrealizedJustifiedEpoch([32]byte{'h'}, 2))
@@ -252,8 +252,8 @@ func TestStore_ForkNextEpoch(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'h'}, headRoot)
 	require.Equal(t, primitives.Epoch(2), f.JustifiedCheckpoint().Epoch)
-	require.Equal(t, uint64(0), f.store.emptyNodeByRoot[[32]byte{'d'}].weight)
-	require.Equal(t, uint64(100), f.store.emptyNodeByRoot[[32]byte{'h'}].weight)
+	require.Equal(t, uint64(0), f.store.nodeByRoot[[32]byte{'d'}].weight)
+	require.Equal(t, uint64(100), f.store.nodeByRoot[[32]byte{'h'}].weight)
 }
 
 func TestStore_PullTips_Heuristics(t *testing.T) {
@@ -263,14 +263,14 @@ func TestStore_PullTips_Heuristics(t *testing.T) {
 		st, root, err := prepareForkchoiceState(ctx, 65, [32]byte{'p'}, [32]byte{}, [32]byte{}, 1, 1)
 		require.NoError(tt, err)
 		require.NoError(tt, f.InsertNode(ctx, st, root))
-		f.store.emptyNodeByRoot[[32]byte{'p'}].unrealizedJustifiedEpoch = primitives.Epoch(2)
+		f.store.nodeByRoot[[32]byte{'p'}].unrealizedJustifiedEpoch = primitives.Epoch(2)
 		driftGenesisTime(f, 66, 0)
 
 		st, root, err = prepareForkchoiceState(ctx, 66, [32]byte{'h'}, [32]byte{'p'}, [32]byte{}, 1, 1)
 		require.NoError(tt, err)
 		require.NoError(tt, f.InsertNode(ctx, st, root))
-		require.Equal(tt, primitives.Epoch(2), f.store.emptyNodeByRoot[[32]byte{'h'}].unrealizedJustifiedEpoch)
-		require.Equal(tt, primitives.Epoch(1), f.store.emptyNodeByRoot[[32]byte{'h'}].unrealizedFinalizedEpoch)
+		require.Equal(tt, primitives.Epoch(2), f.store.nodeByRoot[[32]byte{'h'}].unrealizedJustifiedEpoch)
+		require.Equal(tt, primitives.Epoch(1), f.store.nodeByRoot[[32]byte{'h'}].unrealizedFinalizedEpoch)
 	})
 
 	t.Run("Previous Epoch is justified and too early for current", func(tt *testing.T) {
@@ -278,21 +278,21 @@ func TestStore_PullTips_Heuristics(t *testing.T) {
 		st, root, err := prepareForkchoiceState(ctx, 95, [32]byte{'p'}, [32]byte{}, [32]byte{}, 1, 1)
 		require.NoError(tt, err)
 		require.NoError(tt, f.InsertNode(ctx, st, root))
-		f.store.emptyNodeByRoot[[32]byte{'p'}].unrealizedJustifiedEpoch = primitives.Epoch(2)
+		f.store.nodeByRoot[[32]byte{'p'}].unrealizedJustifiedEpoch = primitives.Epoch(2)
 		driftGenesisTime(f, 96, 0)
 
 		st, root, err = prepareForkchoiceState(ctx, 96, [32]byte{'h'}, [32]byte{'p'}, [32]byte{}, 1, 1)
 		require.NoError(tt, err)
 		require.NoError(tt, f.InsertNode(ctx, st, root))
-		require.Equal(tt, primitives.Epoch(2), f.store.emptyNodeByRoot[[32]byte{'h'}].unrealizedJustifiedEpoch)
-		require.Equal(tt, primitives.Epoch(1), f.store.emptyNodeByRoot[[32]byte{'h'}].unrealizedFinalizedEpoch)
+		require.Equal(tt, primitives.Epoch(2), f.store.nodeByRoot[[32]byte{'h'}].unrealizedJustifiedEpoch)
+		require.Equal(tt, primitives.Epoch(1), f.store.nodeByRoot[[32]byte{'h'}].unrealizedFinalizedEpoch)
 	})
 	t.Run("Previous Epoch is justified and not too early for current", func(tt *testing.T) {
 		f := setup(1, 1)
 		st, root, err := prepareForkchoiceState(ctx, 95, [32]byte{'p'}, [32]byte{}, [32]byte{}, 1, 1)
 		require.NoError(tt, err)
 		require.NoError(tt, f.InsertNode(ctx, st, root))
-		f.store.emptyNodeByRoot[[32]byte{'p'}].unrealizedJustifiedEpoch = primitives.Epoch(2)
+		f.store.nodeByRoot[[32]byte{'p'}].unrealizedJustifiedEpoch = primitives.Epoch(2)
 		driftGenesisTime(f, 127, 0)
 
 		st, root, err = prepareForkchoiceState(ctx, 127, [32]byte{'h'}, [32]byte{'p'}, [32]byte{}, 1, 1)
@@ -302,14 +302,14 @@ func TestStore_PullTips_Heuristics(t *testing.T) {
 		// This test checks that the heuristics in pullTips did not apply and
 		// the test continues to compute a bogus unrealized
 		// justification
-		require.Equal(tt, primitives.Epoch(1), f.store.emptyNodeByRoot[[32]byte{'h'}].unrealizedJustifiedEpoch)
+		require.Equal(tt, primitives.Epoch(1), f.store.nodeByRoot[[32]byte{'h'}].unrealizedJustifiedEpoch)
 	})
 	t.Run("Block from previous Epoch", func(tt *testing.T) {
 		f := setup(1, 1)
 		st, root, err := prepareForkchoiceState(ctx, 94, [32]byte{'p'}, [32]byte{}, [32]byte{}, 1, 1)
 		require.NoError(tt, err)
 		require.NoError(tt, f.InsertNode(ctx, st, root))
-		f.store.emptyNodeByRoot[[32]byte{'p'}].unrealizedJustifiedEpoch = primitives.Epoch(2)
+		f.store.nodeByRoot[[32]byte{'p'}].unrealizedJustifiedEpoch = primitives.Epoch(2)
 		driftGenesisTime(f, 96, 0)
 
 		st, root, err = prepareForkchoiceState(ctx, 95, [32]byte{'h'}, [32]byte{'p'}, [32]byte{}, 1, 1)
@@ -319,7 +319,7 @@ func TestStore_PullTips_Heuristics(t *testing.T) {
 		// This test checks that the heuristics in pullTips did not apply and
 		// the test continues to compute a bogus unrealized
 		// justification
-		require.Equal(tt, primitives.Epoch(1), f.store.emptyNodeByRoot[[32]byte{'h'}].unrealizedJustifiedEpoch)
+		require.Equal(tt, primitives.Epoch(1), f.store.nodeByRoot[[32]byte{'h'}].unrealizedJustifiedEpoch)
 	})
 	t.Run("Previous Epoch is not justified", func(tt *testing.T) {
 		f := setup(1, 1)
@@ -335,6 +335,6 @@ func TestStore_PullTips_Heuristics(t *testing.T) {
 		// This test checks that the heuristics in pullTips did not apply and
 		// the test continues to compute a bogus unrealized
 		// justification
-		require.Equal(tt, primitives.Epoch(2), f.store.emptyNodeByRoot[[32]byte{'h'}].unrealizedJustifiedEpoch)
+		require.Equal(tt, primitives.Epoch(2), f.store.nodeByRoot[[32]byte{'h'}].unrealizedJustifiedEpoch)
 	})
 }

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

@@ -284,7 +284,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//        9  10
 	f.store.finalizedCheckpoint.Root = indexToHash(5)
 	require.NoError(t, f.store.prune(t.Context()))
-	assert.Equal(t, 5, len(f.store.emptyNodeByRoot), "Incorrect nodes length after prune")
+	assert.Equal(t, 5, len(f.store.nodeByRoot), "Incorrect nodes length after prune")
 	// we pruned artificially the justified root.
 	f.store.justifiedCheckpoint.Root = indexToHash(5)
 

beacon-chain/forkchoice/interfaces.go

@@ -73,6 +73,7 @@ type FastGetter interface {
 	IsViableForCheckpoint(*forkchoicetypes.Checkpoint) (bool, error)
 	JustifiedCheckpoint() *forkchoicetypes.Checkpoint
 	JustifiedPayloadBlockHash() [32]byte
+	LastRoot(primitives.Epoch) [32]byte
 	NodeCount() int
 	PreviousJustifiedCheckpoint() *forkchoicetypes.Checkpoint
 	ProposerBoost() [fieldparams.RootLength]byte

beacon-chain/forkchoice/ro.go

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

beacon-chain/forkchoice/ro_test.go

@@ -148,6 +148,11 @@ func TestROLocking(t *testing.T) {
 			call: slotCalled,
 			cb:   func(g FastGetter) { _, err := g.Slot([32]byte{}); _discard(t, err) },
 		},
+		{
+			name: "lastRootCalled",
+			call: lastRootCalled,
+			cb:   func(g FastGetter) { g.LastRoot(0) },
+		},
 		{
 			name: "targetRootForEpochCalled",
 			call: targetRootForEpochCalled,
@@ -290,6 +295,11 @@ func (ro *mockROForkchoice) Slot(_ [32]byte) (primitives.Slot, error) {
 	return 0, nil
 }
 
+func (ro *mockROForkchoice) LastRoot(_ primitives.Epoch) [32]byte {
+	ro.calls = append(ro.calls, lastRootCalled)
+	return [32]byte{}
+}
+
 // DependentRoot impoements FastGetter.
 func (ro *mockROForkchoice) DependentRoot(_ primitives.Epoch) ([32]byte, error) {
 	ro.calls = append(ro.calls, dependentRootCalled)

beacon-chain/node/node.go

@@ -678,6 +678,7 @@ 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

beacon-chain/p2p/BUILD.bazel

@@ -52,6 +52,7 @@ go_library(
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/kv:go_default_library",
         "//beacon-chain/p2p/encoder:go_default_library",
+        "//beacon-chain/p2p/partialdatacolumnbroadcaster:go_default_library",
         "//beacon-chain/p2p/peers:go_default_library",
         "//beacon-chain/p2p/peers/peerdata:go_default_library",
         "//beacon-chain/p2p/peers/scorers:go_default_library",

beacon-chain/p2p/broadcaster.go

@@ -343,7 +343,7 @@ func (s *Service) BroadcastLightClientFinalityUpdate(ctx context.Context, update
 // there is at least one peer in each needed subnet. If not, it will attempt to find one before broadcasting.
 // This function is non-blocking. It stops trying to broadcast a given sidecar when more than one slot has passed, or the context is
 // cancelled (whichever comes first).
-func (s *Service) BroadcastDataColumnSidecars(ctx context.Context, sidecars []blocks.VerifiedRODataColumn) error {
+func (s *Service) BroadcastDataColumnSidecars(ctx context.Context, sidecars []blocks.VerifiedRODataColumn, partialColumns []blocks.PartialDataColumn) error {
 	// Increase the number of broadcast attempts.
 	dataColumnSidecarBroadcastAttempts.Add(float64(len(sidecars)))
 
@@ -353,16 +353,15 @@ func (s *Service) BroadcastDataColumnSidecars(ctx context.Context, sidecars []bl
 		return errors.Wrap(err, "current fork digest")
 	}
 
-	go s.broadcastDataColumnSidecars(ctx, forkDigest, sidecars)
+	go s.broadcastDataColumnSidecars(ctx, forkDigest, sidecars, partialColumns)
 
 	return nil
 }
 
-// broadcastDataColumnSidecars broadcasts multiple data column sidecars to the p2p network.
-// For sidecars with available peers, it uses batch publishing.
-// For sidecars without peers, it finds peers first and then publishes individually.
-// Both paths run in parallel. It returns when all broadcasts are complete, or the context is cancelled.
-func (s *Service) broadcastDataColumnSidecars(ctx context.Context, forkDigest [fieldparams.VersionLength]byte, sidecars []blocks.VerifiedRODataColumn) {
+// broadcastDataColumnSidecars broadcasts multiple data column sidecars to the p2p network, after ensuring
+// there is at least one peer in each needed subnet. If not, it will attempt to find one before broadcasting.
+// It returns when all broadcasts are complete, or the context is cancelled (whichever comes first).
+func (s *Service) broadcastDataColumnSidecars(ctx context.Context, forkDigest [fieldparams.VersionLength]byte, sidecars []blocks.VerifiedRODataColumn, partialColumns []blocks.PartialDataColumn) {
 	type rootAndIndex struct {
 		root  [fieldparams.RootLength]byte
 		index uint64
@@ -372,8 +371,8 @@ func (s *Service) broadcastDataColumnSidecars(ctx context.Context, forkDigest [f
 	logLevel := logrus.GetLevel()
 	slotPerRoot := make(map[[fieldparams.RootLength]byte]primitives.Slot, 1)
 
-	topicFunc := func(sidecar blocks.VerifiedRODataColumn) (topic string, wrappedSubIdx uint64, subnet uint64) {
-		subnet = peerdas.ComputeSubnetForDataColumnSidecar(sidecar.Index)
+	topicFunc := func(dcIndex uint64) (topic string, wrappedSubIdx uint64, subnet uint64) {
+		subnet = peerdas.ComputeSubnetForDataColumnSidecar(dcIndex)
 		topic = dataColumnSubnetToTopic(subnet, forkDigest)
 		wrappedSubIdx = subnet + dataColumnSubnetVal
 		return
@@ -386,7 +385,7 @@ func (s *Service) broadcastDataColumnSidecars(ctx context.Context, forkDigest [f
 	for _, sidecar := range sidecars {
 		slotPerRoot[sidecar.BlockRoot()] = sidecar.Slot()
 
-		topic, wrappedSubIdx, _ := topicFunc(sidecar)
+		topic, wrappedSubIdx, _ := topicFunc(sidecar.Index)
 		// Check if we have a peer for this subnet (use RLock for read-only check).
 		mu := s.subnetLocker(wrappedSubIdx)
 		mu.RLock()
@@ -411,7 +410,7 @@ func (s *Service) broadcastDataColumnSidecars(ctx context.Context, forkDigest [f
 			ctx := trace.NewContext(s.ctx, span)
 			defer span.End()
 
-			topic, _, _ := topicFunc(sidecar)
+			topic, _, _ := topicFunc(sidecar.Index)
 
 			if err := s.batchObject(ctx, &messageBatch, sidecar, topic); err != nil {
 				tracing.AnnotateError(span, err)
@@ -419,6 +418,10 @@ func (s *Service) broadcastDataColumnSidecars(ctx context.Context, forkDigest [f
 				return
 			}
 
+			// Increase the number of successful broadcasts.
+			dataColumnSidecarBroadcasts.Inc()
+
+			// Record the timing for log purposes.
 			if logLevel >= logrus.DebugLevel {
 				root := sidecar.BlockRoot()
 				timings.Store(rootAndIndex{root: root, index: sidecar.Index}, time.Now())
@@ -433,7 +436,7 @@ func (s *Service) broadcastDataColumnSidecars(ctx context.Context, forkDigest [f
 			ctx := trace.NewContext(s.ctx, span)
 			defer span.End()
 
-			topic, wrappedSubIdx, subnet := topicFunc(sidecar)
+			topic, wrappedSubIdx, subnet := topicFunc(sidecar.Index)
 
 			// Find peers for this sidecar's subnet.
 			if err := s.findPeersIfNeeded(ctx, wrappedSubIdx, DataColumnSubnetTopicFormat, forkDigest, subnet); err != nil {
@@ -458,6 +461,32 @@ func (s *Service) broadcastDataColumnSidecars(ctx context.Context, forkDigest [f
 		})
 	}
 
+	if s.partialColumnBroadcaster != nil {
+		// Note: There is not batch publish for partial columns.
+		for _, partialColumn := range partialColumns {
+			individualWg.Go(func() {
+				_, span := trace.StartSpan(ctx, "p2p.broadcastPartialDataColumn")
+				ctx := trace.NewContext(s.ctx, span)
+				defer span.End()
+
+				topic, wrappedSubIdx, subnet := topicFunc(partialColumn.Index)
+
+				// Find peers for this sidecar's subnet.
+				if err := s.findPeersIfNeeded(ctx, wrappedSubIdx, DataColumnSubnetTopicFormat, forkDigest, subnet); err != nil {
+					tracing.AnnotateError(span, err)
+					log.WithError(err).Error("Cannot find peers if needed")
+					return
+				}
+
+				fullTopicStr := topic + s.Encoding().ProtocolSuffix()
+				if err := s.partialColumnBroadcaster.Publish(fullTopicStr, partialColumn); err != nil {
+					tracing.AnnotateError(span, err)
+					log.WithError(err).Error("Cannot partial broadcast data column sidecar")
+				}
+			})
+		}
+	}
+
 	// Wait for batch to be populated, then publish.
 	batchWg.Wait()
 	if len(sidecarsWithPeers) > 0 {

beacon-chain/p2p/broadcaster_test.go

@@ -803,7 +803,7 @@ func TestService_BroadcastDataColumn(t *testing.T) {
 	}, 5*time.Second, 10*time.Millisecond, "libp2p mesh did not establish")
 
 	// Broadcast to peers and wait.
-	err = service.BroadcastDataColumnSidecars(ctx, []blocks.VerifiedRODataColumn{verifiedRoSidecar})
+	err = service.BroadcastDataColumnSidecars(ctx, []blocks.VerifiedRODataColumn{verifiedRoSidecar}, nil)
 	require.NoError(t, err)
 
 	// Receive the message.
@@ -867,7 +867,7 @@ func (*rpcOrderTracer) DeliverMessage(*pubsub.Message)        {}
 func (*rpcOrderTracer) RejectMessage(*pubsub.Message, string) {}
 func (*rpcOrderTracer) DuplicateMessage(*pubsub.Message)      {}
 func (*rpcOrderTracer) ThrottlePeer(peer.ID)                  {}
-func (*rpcOrderTracer) RecvRPC(*pubsub.RPC)                   {}
+func (*rpcOrderTracer) RecvRPC(*pubsub.RPC, peer.ID)          {}
 func (*rpcOrderTracer) DropRPC(*pubsub.RPC, peer.ID)          {}
 func (*rpcOrderTracer) UndeliverableMessage(*pubsub.Message)  {}
 
@@ -969,7 +969,7 @@ func TestService_BroadcastDataColumnRoundRobin(t *testing.T) {
 	time.Sleep(100 * time.Millisecond)
 
 	// Broadcast all sidecars.
-	err = service.BroadcastDataColumnSidecars(ctx, verifiedRoSidecars)
+	err = service.BroadcastDataColumnSidecars(ctx, verifiedRoSidecars, nil)
 	require.NoError(t, err)
 	// Give some time for messages to be sent.
 	time.Sleep(100 * time.Millisecond)

beacon-chain/p2p/config.go

@@ -26,6 +26,7 @@ const (
 // Config for the p2p service. These parameters are set from application level flags
 // to initialize the p2p service.
 type Config struct {
+	PartialDataColumns    bool
 	NoDiscovery           bool
 	EnableUPnP            bool
 	StaticPeerID          bool

beacon-chain/p2p/interfaces.go

@@ -4,6 +4,7 @@ import (
 	"context"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/encoder"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/partialdatacolumnbroadcaster"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/peers"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
@@ -28,6 +29,7 @@ type (
 		Broadcaster
 		SetStreamHandler
 		PubSubProvider
+		PartialColumnBroadcasterProvider
 		PubSubTopicUser
 		SenderEncoder
 		PeerManager
@@ -52,7 +54,7 @@ type (
 		BroadcastBlob(ctx context.Context, subnet uint64, blob *ethpb.BlobSidecar) error
 		BroadcastLightClientOptimisticUpdate(ctx context.Context, update interfaces.LightClientOptimisticUpdate) error
 		BroadcastLightClientFinalityUpdate(ctx context.Context, update interfaces.LightClientFinalityUpdate) error
-		BroadcastDataColumnSidecars(ctx context.Context, sidecars []blocks.VerifiedRODataColumn) error
+		BroadcastDataColumnSidecars(ctx context.Context, sidecars []blocks.VerifiedRODataColumn, partialColumns []blocks.PartialDataColumn) error
 	}
 
 	// SetStreamHandler configures p2p to handle streams of a certain topic ID.
@@ -92,6 +94,11 @@ type (
 		PubSub() *pubsub.PubSub
 	}
 
+	// PubSubProvider provides the p2p pubsub protocol.
+	PartialColumnBroadcasterProvider interface {
+		PartialColumnBroadcaster() *partialdatacolumnbroadcaster.PartialColumnBroadcaster
+	}
+
 	// PeerManager abstracts some peer management methods from libp2p.
 	PeerManager interface {
 		Disconnect(peer.ID) error

beacon-chain/p2p/monitoring.go

@@ -157,6 +157,11 @@ var (
 		Help: "The number of publish messages received via rpc for a particular topic",
 	},
 		[]string{"topic"})
+	pubsubRPCPubRecvSize = promauto.NewCounterVec(prometheus.CounterOpts{
+		Name: "p2p_pubsub_rpc_recv_pub_size_total",
+		Help: "The total size of publish messages received via rpc for a particular topic",
+	},
+		[]string{"topic", "is_partial"})
 	pubsubRPCDrop = promauto.NewCounterVec(prometheus.CounterOpts{
 		Name: "p2p_pubsub_rpc_drop_total",
 		Help: "The number of messages dropped via rpc for a particular control message",
@@ -171,6 +176,11 @@ var (
 		Help: "The number of publish messages dropped via rpc for a particular topic",
 	},
 		[]string{"topic"})
+	pubsubRPCPubDropSize = promauto.NewCounterVec(prometheus.CounterOpts{
+		Name: "p2p_pubsub_rpc_drop_pub_size_total",
+		Help: "The total size of publish messages dropped via rpc for a particular topic",
+	},
+		[]string{"topic", "is_partial"})
 	pubsubRPCSent = promauto.NewCounterVec(prometheus.CounterOpts{
 		Name: "p2p_pubsub_rpc_sent_total",
 		Help: "The number of messages sent via rpc for a particular control message",
@@ -185,6 +195,16 @@ var (
 		Help: "The number of publish messages sent via rpc for a particular topic",
 	},
 		[]string{"topic"})
+	pubsubRPCPubSentSize = promauto.NewCounterVec(prometheus.CounterOpts{
+		Name: "gossipsub_pubsub_rpc_sent_pub_size_total",
+		Help: "The total size of publish messages sent via rpc for a particular topic",
+	},
+		[]string{"topic", "is_partial"})
+	pubsubMeshPeers = promauto.NewGaugeVec(prometheus.GaugeOpts{
+		Name: "gossipsub_mesh_peers",
+		Help: "The number of capable peers in mesh",
+	},
+		[]string{"topic", "supports_partial"})
 )
 
 func (s *Service) updateMetrics() {

beacon-chain/p2p/partialdatacolumnbroadcaster/BUILD.bazel

@@ -0,0 +1,27 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "log.go",
+        "metrics.go",
+        "partial.go",
+    ],
+    importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/partialdatacolumnbroadcaster",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//config/params:go_default_library",
+        "//consensus-types/blocks:go_default_library",
+        "//internal/logrusadapter:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "@com_github_libp2p_go_libp2p//core/peer:go_default_library",
+        "@com_github_libp2p_go_libp2p_pubsub//:go_default_library",
+        "@com_github_libp2p_go_libp2p_pubsub//partialmessages:go_default_library",
+        "@com_github_libp2p_go_libp2p_pubsub//partialmessages/bitmap:go_default_library",
+        "@com_github_libp2p_go_libp2p_pubsub//pb:go_default_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_sirupsen_logrus//:go_default_library",
+    ],
+)

beacon-chain/p2p/partialdatacolumnbroadcaster/integrationtest/BUILD.bazel

@@ -0,0 +1,25 @@
+load("@prysm//tools/go:def.bzl", "go_test")
+
+go_test(
+    name = "go_default_test",
+    size = "medium",
+    srcs = ["two_node_test.go"],
+    deps = [
+        "//beacon-chain/core/peerdas:go_default_library",
+        "//beacon-chain/p2p:go_default_library",
+        "//beacon-chain/p2p/encoder:go_default_library",
+        "//beacon-chain/p2p/partialdatacolumnbroadcaster:go_default_library",
+        "//config/fieldparams:go_default_library",
+        "//config/params:go_default_library",
+        "//consensus-types/blocks: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_libp2p_go_libp2p//core/peer:go_default_library",
+        "@com_github_libp2p_go_libp2p//x/simlibp2p:go_default_library",
+        "@com_github_libp2p_go_libp2p_pubsub//:go_default_library",
+        "@com_github_marcopolo_simnet//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+    ],
+)

beacon-chain/p2p/partialdatacolumnbroadcaster/integrationtest/two_node_test.go

@@ -0,0 +1,239 @@
+package integrationtest
+
+import (
+	"context"
+	"crypto/rand"
+	"fmt"
+	"testing"
+	"testing/synctest"
+	"time"
+
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/encoder"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/partialdatacolumnbroadcaster"
+	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/testing/assert"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+	"github.com/OffchainLabs/prysm/v7/testing/util"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	"github.com/libp2p/go-libp2p/core/peer"
+	simlibp2p "github.com/libp2p/go-libp2p/x/simlibp2p"
+	"github.com/marcopolo/simnet"
+	"github.com/sirupsen/logrus"
+)
+
+// TestTwoNodePartialColumnExchange tests that two nodes can exchange partial columns
+// and reconstruct the complete column. Node 1 has cells 0-2, Node 2 has cells 3-5.
+// After exchange, both should have all cells.
+func TestTwoNodePartialColumnExchange(t *testing.T) {
+	synctest.Test(t, func(t *testing.T) {
+		// Create a simulated libp2p network
+		latency := time.Millisecond * 10
+		network, meta, err := simlibp2p.SimpleLibp2pNetwork([]simlibp2p.NodeLinkSettingsAndCount{
+			{LinkSettings: simnet.NodeBiDiLinkSettings{
+				Downlink: simnet.LinkSettings{BitsPerSecond: 20 * simlibp2p.OneMbps, Latency: latency / 2},
+				Uplink:   simnet.LinkSettings{BitsPerSecond: 20 * simlibp2p.OneMbps, Latency: latency / 2},
+			}, Count: 2},
+		}, simlibp2p.NetworkSettings{UseBlankHost: true})
+		require.NoError(t, err)
+		require.NoError(t, network.Start())
+		defer func() {
+			require.NoError(t, network.Close())
+		}()
+		defer func() {
+			for _, node := range meta.Nodes {
+				err := node.Close()
+				if err != nil {
+					panic(err)
+				}
+			}
+		}()
+
+		h1 := meta.Nodes[0]
+		h2 := meta.Nodes[1]
+
+		logger := logrus.New()
+		logger.SetLevel(logrus.DebugLevel)
+		broadcaster1 := partialdatacolumnbroadcaster.NewBroadcaster(logger)
+		broadcaster2 := partialdatacolumnbroadcaster.NewBroadcaster(logger)
+
+		opts1 := broadcaster1.AppendPubSubOpts([]pubsub.Option{
+			pubsub.WithMessageSigning(false),
+			pubsub.WithStrictSignatureVerification(false),
+		})
+		opts2 := broadcaster2.AppendPubSubOpts([]pubsub.Option{
+			pubsub.WithMessageSigning(false),
+			pubsub.WithStrictSignatureVerification(false),
+		})
+
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+		ps1, err := pubsub.NewGossipSub(ctx, h1, opts1...)
+		require.NoError(t, err)
+		ps2, err := pubsub.NewGossipSub(ctx, h2, opts2...)
+		require.NoError(t, err)
+
+		go broadcaster1.Start()
+		go broadcaster2.Start()
+		defer func() {
+			broadcaster1.Stop()
+			broadcaster2.Stop()
+		}()
+
+		// Generate Test Data
+		var blockRoot [fieldparams.RootLength]byte
+		copy(blockRoot[:], []byte("test-block-root"))
+
+		numCells := 6
+		commitments := make([][]byte, numCells)
+		cells := make([][]byte, numCells)
+		proofs := make([][]byte, numCells)
+
+		for i := range numCells {
+			commitments[i] = make([]byte, 48)
+
+			cells[i] = make([]byte, 2048)
+			_, err := rand.Read(cells[i])
+			require.NoError(t, err)
+			proofs[i] = make([]byte, 48)
+			_ = fmt.Appendf(proofs[i][:0], "proof %d", i)
+		}
+
+		roDC, _ := util.CreateTestVerifiedRoDataColumnSidecars(t, []util.DataColumnParam{
+			{
+				BodyRoot:       blockRoot[:],
+				KzgCommitments: commitments,
+				Column:         cells,
+				KzgProofs:      proofs,
+			},
+		})
+
+		pc1, err := blocks.NewPartialDataColumn(roDC[0].DataColumnSidecar.SignedBlockHeader, roDC[0].Index, roDC[0].KzgCommitments, roDC[0].KzgCommitmentsInclusionProof)
+		require.NoError(t, err)
+		pc2, err := blocks.NewPartialDataColumn(roDC[0].DataColumnSidecar.SignedBlockHeader, roDC[0].Index, roDC[0].KzgCommitments, roDC[0].KzgCommitmentsInclusionProof)
+		require.NoError(t, err)
+
+		// Split data
+		for i := range numCells {
+			if i%2 == 0 {
+				pc1.ExtendFromVerfifiedCell(uint64(i), roDC[0].Column[i], roDC[0].KzgProofs[i])
+			} else {
+				pc2.ExtendFromVerfifiedCell(uint64(i), roDC[0].Column[i], roDC[0].KzgProofs[i])
+			}
+		}
+
+		// Setup Topic and Subscriptions
+		digest := params.ForkDigest(0)
+		columnIndex := uint64(12)
+		subnet := peerdas.ComputeSubnetForDataColumnSidecar(columnIndex)
+		topicStr := fmt.Sprintf(p2p.DataColumnSubnetTopicFormat, digest, subnet) +
+			encoder.SszNetworkEncoder{}.ProtocolSuffix()
+
+		time.Sleep(100 * time.Millisecond)
+
+		topic1, err := ps1.Join(topicStr, pubsub.RequestPartialMessages())
+		require.NoError(t, err)
+		topic2, err := ps2.Join(topicStr, pubsub.RequestPartialMessages())
+		require.NoError(t, err)
+
+		// Header validator that verifies the inclusion proof
+		headerValidator := func(header *ethpb.PartialDataColumnHeader) (reject bool, err error) {
+			if header == nil {
+				return false, fmt.Errorf("nil header")
+			}
+			if header.SignedBlockHeader == nil || header.SignedBlockHeader.Header == nil {
+				return true, fmt.Errorf("nil signed block header")
+			}
+			if len(header.KzgCommitments) == 0 {
+				return true, fmt.Errorf("empty kzg commitments")
+			}
+			// Verify inclusion proof
+			if err := peerdas.VerifyPartialDataColumnHeaderInclusionProof(header); err != nil {
+				return true, fmt.Errorf("invalid inclusion proof: %w", err)
+			}
+			t.Log("Header validation passed")
+			return false, nil
+		}
+
+		cellValidator := func(_ []blocks.CellProofBundle) error {
+			return nil
+		}
+
+		node1Complete := make(chan blocks.VerifiedRODataColumn, 1)
+		node2Complete := make(chan blocks.VerifiedRODataColumn, 1)
+
+		handler1 := func(topic string, col blocks.VerifiedRODataColumn) {
+			t.Logf("Node 1: Completed! Column has %d cells", len(col.Column))
+			node1Complete <- col
+		}
+
+		handler2 := func(topic string, col blocks.VerifiedRODataColumn) {
+			t.Logf("Node 2: Completed! Column has %d cells", len(col.Column))
+			node2Complete <- col
+		}
+
+		// Connect hosts
+		err = h1.Connect(context.Background(), peer.AddrInfo{
+			ID:    h2.ID(),
+			Addrs: h2.Addrs(),
+		})
+		require.NoError(t, err)
+		time.Sleep(300 * time.Millisecond)
+
+		// Subscribe to regular GossipSub (critical for partial message RPC exchange!)
+		sub1, err := topic1.Subscribe()
+		require.NoError(t, err)
+		defer sub1.Cancel()
+
+		sub2, err := topic2.Subscribe()
+		require.NoError(t, err)
+		defer sub2.Cancel()
+
+		err = broadcaster1.Subscribe(topic1, headerValidator, cellValidator, handler1)
+		require.NoError(t, err)
+		err = broadcaster2.Subscribe(topic2, headerValidator, cellValidator, handler2)
+		require.NoError(t, err)
+
+		// Wait for mesh to form
+		time.Sleep(2 * time.Second)
+
+		// Publish
+		t.Log("Publishing from Node 1")
+		err = broadcaster1.Publish(topicStr, pc1)
+		require.NoError(t, err)
+
+		time.Sleep(200 * time.Millisecond)
+
+		t.Log("Publishing from Node 2")
+		err = broadcaster2.Publish(topicStr, pc2)
+		require.NoError(t, err)
+
+		//  Wait for Completion
+		timeout := time.After(10 * time.Second)
+		var col1, col2 blocks.VerifiedRODataColumn
+		receivedCount := 0
+
+		for receivedCount < 2 {
+			select {
+			case col1 = <-node1Complete:
+				t.Log("Node 1 completed reconstruction")
+				receivedCount++
+			case col2 = <-node2Complete:
+				t.Log("Node 2 completed reconstruction")
+				receivedCount++
+			case <-timeout:
+				t.Fatalf("Timeout: Only %d/2 nodes completed", receivedCount)
+			}
+		}
+
+		// Verify both columns have all cells
+		assert.Equal(t, numCells, len(col1.Column), "Node 1 should have all cells")
+		assert.Equal(t, numCells, len(col2.Column), "Node 2 should have all cells")
+		assert.DeepSSZEqual(t, cells, col1.Column, "Node 1 cell mismatch")
+		assert.DeepSSZEqual(t, cells, col2.Column, "Node 2 cell mismatch")
+	})
+}

beacon-chain/p2p/partialdatacolumnbroadcaster/log.go

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

beacon-chain/p2p/partialdatacolumnbroadcaster/metrics.go

@@ -0,0 +1,18 @@
+package partialdatacolumnbroadcaster
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+)
+
+var (
+	partialMessageUsefulCellsTotal = promauto.NewCounterVec(prometheus.CounterOpts{
+		Name: "beacon_partial_message_useful_cells_total",
+		Help: "Number of useful cells received via a partial message",
+	}, []string{"column_index"})
+
+	partialMessageCellsReceivedTotal = promauto.NewCounterVec(prometheus.CounterOpts{
+		Name: "beacon_partial_message_cells_received_total",
+		Help: "Number of total cells received via a partial message",
+	}, []string{"column_index"})
+)

beacon-chain/p2p/partialdatacolumnbroadcaster/partial.go

@@ -0,0 +1,540 @@
+package partialdatacolumnbroadcaster
+
+import (
+	"bytes"
+	"log/slog"
+	"regexp"
+	"strconv"
+	"time"
+
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	"github.com/OffchainLabs/prysm/v7/internal/logrusadapter"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	"github.com/libp2p/go-libp2p-pubsub/partialmessages"
+	"github.com/libp2p/go-libp2p-pubsub/partialmessages/bitmap"
+	pubsub_pb "github.com/libp2p/go-libp2p-pubsub/pb"
+	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+)
+
+// TODOs:
+// different eager push strategies:
+// - no eager push
+// - full column eager push
+//   - With debouncing - some factor of RTT
+// - eager push missing cells
+
+const TTLInSlots = 3
+const maxConcurrentValidators = 128
+
+var dataColumnTopicRegex = regexp.MustCompile(`data_column_sidecar_(\d+)`)
+
+func extractColumnIndexFromTopic(topic string) (uint64, error) {
+	matches := dataColumnTopicRegex.FindStringSubmatch(topic)
+	if len(matches) < 2 {
+		return 0, errors.New("could not extract column index from topic")
+	}
+	return strconv.ParseUint(matches[1], 10, 64)
+}
+
+// HeaderValidator validates a PartialDataColumnHeader.
+// Returns (reject, err) where:
+//   - reject=true, err!=nil: REJECT - peer should be penalized
+//   - reject=false, err!=nil: IGNORE - don't penalize, just ignore
+//   - reject=false, err=nil: valid header
+type HeaderValidator func(header *ethpb.PartialDataColumnHeader) (reject bool, err error)
+type ColumnValidator func(cells []blocks.CellProofBundle) error
+
+type PartialColumnBroadcaster struct {
+	logger *logrus.Logger
+
+	ps   *pubsub.PubSub
+	stop chan struct{}
+
+	// map topic -> headerValidators
+	headerValidators map[string]HeaderValidator
+	// map topic -> Validator
+	validators map[string]ColumnValidator
+
+	// map topic -> handler
+	handlers map[string]SubHandler
+
+	// map topic -> *pubsub.Topic
+	topics map[string]*pubsub.Topic
+
+	concurrentValidatorSemaphore chan struct{}
+
+	// map topic -> map[groupID]PartialColumn
+	partialMsgStore map[string]map[string]*blocks.PartialDataColumn
+
+	groupTTL map[string]int8
+
+	// validHeaderCache caches validated headers by group ID (works across topics)
+	validHeaderCache map[string]*ethpb.PartialDataColumnHeader
+
+	incomingReq chan request
+}
+
+type requestKind uint8
+
+const (
+	requestKindPublish requestKind = iota
+	requestKindSubscribe
+	requestKindUnsubscribe
+	requestKindHandleIncomingRPC
+	requestKindCellsValidated
+)
+
+type request struct {
+	kind           requestKind
+	response       chan error
+	sub            subscribe
+	unsub          unsubscribe
+	publish        publish
+	incomingRPC    rpcWithFrom
+	cellsValidated *cellsValidated
+}
+
+type publish struct {
+	topic string
+	c     blocks.PartialDataColumn
+}
+
+type subscribe struct {
+	t               *pubsub.Topic
+	headerValidator HeaderValidator
+	validator       ColumnValidator
+	handler         SubHandler
+}
+
+type unsubscribe struct {
+	topic string
+}
+
+type rpcWithFrom struct {
+	*pubsub_pb.PartialMessagesExtension
+	from peer.ID
+}
+
+type cellsValidated struct {
+	validationTook time.Duration
+	topic          string
+	group          []byte
+	cellIndices    []uint64
+	cells          []blocks.CellProofBundle
+}
+
+func NewBroadcaster(logger *logrus.Logger) *PartialColumnBroadcaster {
+	return &PartialColumnBroadcaster{
+		validators:       make(map[string]ColumnValidator),
+		headerValidators: make(map[string]HeaderValidator),
+		handlers:         make(map[string]SubHandler),
+		topics:           make(map[string]*pubsub.Topic),
+		partialMsgStore:  make(map[string]map[string]*blocks.PartialDataColumn),
+		groupTTL:         make(map[string]int8),
+		validHeaderCache: make(map[string]*ethpb.PartialDataColumnHeader),
+		// GossipSub sends the messages to this channel. The buffer should be
+		// big enough to avoid dropping messages. We don't want to block the gossipsub event loop for this.
+		incomingReq: make(chan request, 128*16),
+		logger:      logger,
+
+		concurrentValidatorSemaphore: make(chan struct{}, maxConcurrentValidators),
+	}
+}
+
+// AppendPubSubOpts adds the necessary pubsub options to enable partial messages.
+func (p *PartialColumnBroadcaster) AppendPubSubOpts(opts []pubsub.Option) []pubsub.Option {
+	slogger := slog.New(logrusadapter.Handler{Logger: p.logger})
+	opts = append(opts,
+		pubsub.WithPartialMessagesExtension(&partialmessages.PartialMessagesExtension{
+			Logger: slogger,
+			MergePartsMetadata: func(topic string, left, right partialmessages.PartsMetadata) partialmessages.PartsMetadata {
+				merged, err := blocks.MergePartsMetadata(left, right)
+				if err != nil {
+					p.logger.Warn("Failed to merge bitfields", "err", err, "left", left, "right", right)
+					return left
+				}
+				return merged
+			},
+			ValidateRPC: func(from peer.ID, rpc *pubsub_pb.PartialMessagesExtension) error {
+				// TODO. Add some basic and fast sanity checks
+				return nil
+			},
+			OnIncomingRPC: func(from peer.ID, rpc *pubsub_pb.PartialMessagesExtension) error {
+				select {
+				case p.incomingReq <- request{
+					kind:        requestKindHandleIncomingRPC,
+					incomingRPC: rpcWithFrom{rpc, from},
+				}:
+				default:
+					p.logger.Warn("Dropping incoming partial RPC", "rpc", rpc)
+				}
+				return nil
+			},
+		}),
+		func(ps *pubsub.PubSub) error {
+			p.ps = ps
+			return nil
+		},
+	)
+	return opts
+}
+
+// Start starts the event loop of the PartialColumnBroadcaster. Should be called
+// within a goroutine (go p.Start())
+func (p *PartialColumnBroadcaster) Start() {
+	if p.stop != nil {
+		return
+	}
+	p.stop = make(chan struct{})
+	p.loop()
+}
+
+func (p *PartialColumnBroadcaster) loop() {
+	cleanup := time.NewTicker(time.Second * time.Duration(params.BeaconConfig().SecondsPerSlot))
+	defer cleanup.Stop()
+	for {
+		select {
+		case <-p.stop:
+			return
+		case <-cleanup.C:
+			for groupID, ttl := range p.groupTTL {
+				if ttl > 0 {
+					p.groupTTL[groupID] = ttl - 1
+					continue
+				}
+
+				delete(p.groupTTL, groupID)
+				delete(p.validHeaderCache, groupID)
+				for topic, msgStore := range p.partialMsgStore {
+					delete(msgStore, groupID)
+					if len(msgStore) == 0 {
+						delete(p.partialMsgStore, topic)
+					}
+				}
+			}
+		case req := <-p.incomingReq:
+			switch req.kind {
+			case requestKindPublish:
+				req.response <- p.publish(req.publish.topic, req.publish.c)
+			case requestKindSubscribe:
+				req.response <- p.subscribe(req.sub.t, req.sub.headerValidator, req.sub.validator, req.sub.handler)
+			case requestKindUnsubscribe:
+				req.response <- p.unsubscribe(req.unsub.topic)
+			case requestKindHandleIncomingRPC:
+				err := p.handleIncomingRPC(req.incomingRPC)
+				if err != nil {
+					p.logger.Error("Failed to handle incoming partial RPC", "err", err)
+				}
+			case requestKindCellsValidated:
+				err := p.handleCellsValidated(req.cellsValidated)
+				if err != nil {
+					p.logger.Error("Failed to handle cells validated", "err", err)
+				}
+			default:
+				p.logger.Error("Unknown request kind", "kind", req.kind)
+			}
+		}
+	}
+}
+
+func (p *PartialColumnBroadcaster) getDataColumn(topic string, group []byte) *blocks.PartialDataColumn {
+	topicStore, ok := p.partialMsgStore[topic]
+	if !ok {
+		return nil
+	}
+	msg, ok := topicStore[string(group)]
+	if !ok {
+		return nil
+	}
+	return msg
+}
+
+func (p *PartialColumnBroadcaster) handleIncomingRPC(rpcWithFrom rpcWithFrom) error {
+	if p.ps == nil {
+		return errors.New("pubsub not initialized")
+	}
+
+	hasMessage := len(rpcWithFrom.PartialMessage) > 0
+
+	var message ethpb.PartialDataColumnSidecar
+	if hasMessage {
+		err := message.UnmarshalSSZ(rpcWithFrom.PartialMessage)
+		if err != nil {
+			return errors.Wrap(err, "failed to unmarshal partial message data")
+		}
+	}
+
+	topicID := rpcWithFrom.GetTopicID()
+	groupID := rpcWithFrom.GroupID
+	ourDataColumn := p.getDataColumn(topicID, groupID)
+	var shouldRepublish bool
+
+	if ourDataColumn == nil && hasMessage {
+		var header *ethpb.PartialDataColumnHeader
+		// Check cache first for this group
+		if cachedHeader, ok := p.validHeaderCache[string(groupID)]; ok {
+			header = cachedHeader
+		} else {
+			// We haven't seen this group before. Check if we have a valid header.
+			if len(message.Header) == 0 {
+				p.logger.Debug("No partial column found and no header in message, ignoring")
+				return nil
+			}
+
+			header = message.Header[0]
+			headerValidator, ok := p.headerValidators[topicID]
+			if !ok || headerValidator == nil {
+				p.logger.Debug("No header validator registered for topic")
+				return nil
+			}
+
+			reject, err := headerValidator(header)
+			if err != nil {
+				p.logger.Debug("Header validation failed", "err", err, "reject", reject)
+				if reject {
+					// REJECT case: penalize the peer
+					_ = p.ps.PeerFeedback(topicID, rpcWithFrom.from, pubsub.PeerFeedbackInvalidMessage)
+				}
+				// Both REJECT and IGNORE: don't process further
+				return nil
+			}
+			// Cache the valid header
+			p.validHeaderCache[string(groupID)] = header
+
+			// TODO: We now have the information we need to call GetBlobsV3, we should do that to see what we have locally.
+		}
+
+		columnIndex, err := extractColumnIndexFromTopic(topicID)
+		if err != nil {
+			return err
+		}
+
+		newColumn, err := blocks.NewPartialDataColumn(
+			header.SignedBlockHeader,
+			columnIndex,
+			header.KzgCommitments,
+			header.KzgCommitmentsInclusionProof,
+		)
+		if err != nil {
+			p.logger.WithError(err).WithFields(logrus.Fields{
+				"topic":          topicID,
+				"columnIndex":    columnIndex,
+				"numCommitments": len(header.KzgCommitments),
+			}).Error("Failed to create partial data column from header")
+			return err
+		}
+
+		// Save to store
+		topicStore, ok := p.partialMsgStore[topicID]
+		if !ok {
+			topicStore = make(map[string]*blocks.PartialDataColumn)
+			p.partialMsgStore[topicID] = topicStore
+		}
+		topicStore[string(newColumn.GroupID())] = &newColumn
+		p.groupTTL[string(newColumn.GroupID())] = TTLInSlots
+
+		ourDataColumn = &newColumn
+		shouldRepublish = true
+	}
+
+	if ourDataColumn == nil {
+		// We don't have a partial column for this. Can happen if we got cells
+		// without a header.
+		return nil
+	}
+
+	logger := p.logger.WithFields(logrus.Fields{
+		"from":  rpcWithFrom.from,
+		"topic": topicID,
+		"group": groupID,
+	})
+
+	validator, validatorOK := p.validators[topicID]
+	if len(rpcWithFrom.PartialMessage) > 0 && validatorOK {
+		// TODO: is there any penalty we want to consider for giving us data we didn't request?
+		// Note that we need to be careful around race conditions and eager data.
+		// Also note that protobufs by design allow extra data that we don't parse.
+		// Marco's thoughts. No, we don't need to do anything else here.
+		cellIndices, cellsToVerify, err := ourDataColumn.CellsToVerifyFromPartialMessage(&message)
+		if err != nil {
+			return err
+		}
+		// Track cells received via partial message
+		if len(cellIndices) > 0 {
+			columnIndexStr := strconv.FormatUint(ourDataColumn.Index, 10)
+			partialMessageCellsReceivedTotal.WithLabelValues(columnIndexStr).Add(float64(len(cellIndices)))
+		}
+		if len(cellsToVerify) > 0 {
+			p.concurrentValidatorSemaphore <- struct{}{}
+			go func() {
+				defer func() {
+					<-p.concurrentValidatorSemaphore
+				}()
+				start := time.Now()
+				err := validator(cellsToVerify)
+				if err != nil {
+					logger.Error("failed to validate cells", "err", err)
+					_ = p.ps.PeerFeedback(topicID, rpcWithFrom.from, pubsub.PeerFeedbackInvalidMessage)
+					return
+				}
+				_ = p.ps.PeerFeedback(topicID, rpcWithFrom.from, pubsub.PeerFeedbackUsefulMessage)
+				p.incomingReq <- request{
+					kind: requestKindCellsValidated,
+					cellsValidated: &cellsValidated{
+						validationTook: time.Since(start),
+						topic:          topicID,
+						group:          groupID,
+						cells:          cellsToVerify,
+						cellIndices:    cellIndices,
+					},
+				}
+			}()
+		}
+	}
+
+	peerHas := bitmap.Bitmap(rpcWithFrom.PartsMetadata)
+	iHave := bitmap.Bitmap(ourDataColumn.PartsMetadata())
+	if !shouldRepublish && len(peerHas) > 0 && !bytes.Equal(peerHas, iHave) {
+		// Either we have something they don't or vice versa
+		shouldRepublish = true
+		logger.Debug("republishing due to parts metadata difference")
+	}
+
+	if shouldRepublish {
+		err := p.ps.PublishPartialMessage(topicID, ourDataColumn, partialmessages.PublishOptions{})
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (p *PartialColumnBroadcaster) handleCellsValidated(cells *cellsValidated) error {
+	ourDataColumn := p.getDataColumn(cells.topic, cells.group)
+	if ourDataColumn == nil {
+		return errors.New("data column not found for verified cells")
+	}
+	extended := ourDataColumn.ExtendFromVerfifiedCells(cells.cellIndices, cells.cells)
+	p.logger.Debug("Extended partial message", "duration", cells.validationTook, "extended", extended)
+
+	columnIndexStr := strconv.FormatUint(ourDataColumn.Index, 10)
+	if extended {
+		// Track useful cells (cells that extended our data)
+		partialMessageUsefulCellsTotal.WithLabelValues(columnIndexStr).Add(float64(len(cells.cells)))
+
+		// TODO: we could use the heuristic here that if this data was
+		// useful to us, it's likely useful to our peers and we should
+		// republish eagerly
+
+		if col, ok := ourDataColumn.Complete(p.logger); ok {
+			p.logger.Info("Completed partial column", "topic", cells.topic, "group", cells.group)
+			handler, handlerOK := p.handlers[cells.topic]
+
+			if handlerOK {
+				go handler(cells.topic, col)
+			}
+		} else {
+			p.logger.Info("Extended partial column", "topic", cells.topic, "group", cells.group)
+		}
+
+		err := p.ps.PublishPartialMessage(cells.topic, ourDataColumn, partialmessages.PublishOptions{})
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (p *PartialColumnBroadcaster) Stop() {
+	if p.stop != nil {
+		close(p.stop)
+		p.stop = nil
+	}
+}
+
+// Publish publishes the partial column.
+func (p *PartialColumnBroadcaster) Publish(topic string, c blocks.PartialDataColumn) error {
+	if p.ps == nil {
+		return errors.New("pubsub not initialized")
+	}
+	respCh := make(chan error)
+	p.incomingReq <- request{
+		kind:     requestKindPublish,
+		response: respCh,
+		publish: publish{
+			topic: topic,
+			c:     c,
+		},
+	}
+	return <-respCh
+}
+
+func (p *PartialColumnBroadcaster) publish(topic string, c blocks.PartialDataColumn) error {
+	topicStore, ok := p.partialMsgStore[topic]
+	if !ok {
+		topicStore = make(map[string]*blocks.PartialDataColumn)
+		p.partialMsgStore[topic] = topicStore
+	}
+	topicStore[string(c.GroupID())] = &c
+	p.groupTTL[string(c.GroupID())] = TTLInSlots
+
+	return p.ps.PublishPartialMessage(topic, &c, partialmessages.PublishOptions{})
+}
+
+type SubHandler func(topic string, col blocks.VerifiedRODataColumn)
+
+func (p *PartialColumnBroadcaster) Subscribe(t *pubsub.Topic, headerValidator HeaderValidator, validator ColumnValidator, handler SubHandler) error {
+	respCh := make(chan error)
+	p.incomingReq <- request{
+		kind: requestKindSubscribe,
+		sub: subscribe{
+			t:               t,
+			headerValidator: headerValidator,
+			validator:       validator,
+			handler:         handler,
+		},
+		response: respCh,
+	}
+	return <-respCh
+}
+func (p *PartialColumnBroadcaster) subscribe(t *pubsub.Topic, headerValidator HeaderValidator, validator ColumnValidator, handler SubHandler) error {
+	topic := t.String()
+	if _, ok := p.topics[topic]; ok {
+		return errors.New("already subscribed")
+	}
+
+	p.topics[topic] = t
+	p.headerValidators[topic] = headerValidator
+	p.validators[topic] = validator
+	p.handlers[topic] = handler
+	return nil
+}
+
+func (p *PartialColumnBroadcaster) Unsubscribe(topic string) error {
+	respCh := make(chan error)
+	p.incomingReq <- request{
+		kind: requestKindUnsubscribe,
+		unsub: unsubscribe{
+			topic: topic,
+		},
+		response: respCh,
+	}
+	return <-respCh
+}
+func (p *PartialColumnBroadcaster) unsubscribe(topic string) error {
+	t, ok := p.topics[topic]
+	if !ok {
+		return errors.New("topic not found")
+	}
+	delete(p.topics, topic)
+	delete(p.partialMsgStore, topic)
+	delete(p.headerValidators, topic)
+	delete(p.validators, topic)
+	delete(p.handlers, topic)
+
+	return t.Close()
+}

beacon-chain/p2p/peers/status_test.go

@@ -58,7 +58,7 @@ func TestPeerExplicitAdd(t *testing.T) {
 
 	resAddress, err := p.Address(id)
 	require.NoError(t, err)
-	assert.Equal(t, address, resAddress, "Unexpected address")
+	assert.Equal(t, address.Equal(resAddress), true, "Unexpected address")
 
 	resDirection, err := p.Direction(id)
 	require.NoError(t, err)
@@ -72,7 +72,7 @@ func TestPeerExplicitAdd(t *testing.T) {
 
 	resAddress2, err := p.Address(id)
 	require.NoError(t, err)
-	assert.Equal(t, address2, resAddress2, "Unexpected address")
+	assert.Equal(t, address2.Equal(resAddress2), true, "Unexpected address")
 
 	resDirection2, err := p.Direction(id)
 	require.NoError(t, err)

beacon-chain/p2p/pubsub.go

@@ -170,7 +170,7 @@ func (s *Service) pubsubOptions() []pubsub.Option {
 		pubsub.WithPeerScore(peerScoringParams(s.cfg.IPColocationWhitelist)),
 		pubsub.WithPeerScoreInspect(s.peerInspector, time.Minute),
 		pubsub.WithGossipSubParams(pubsubGossipParam()),
-		pubsub.WithRawTracer(gossipTracer{host: s.host}),
+		pubsub.WithRawTracer(&gossipTracer{host: s.host}),
 	}
 
 	if len(s.cfg.StaticPeers) > 0 {
@@ -181,6 +181,9 @@ func (s *Service) pubsubOptions() []pubsub.Option {
 		}
 		psOpts = append(psOpts, pubsub.WithDirectPeers(directPeersAddrInfos))
 	}
+	if s.partialColumnBroadcaster != nil {
+		psOpts = s.partialColumnBroadcaster.AppendPubSubOpts(psOpts)
+	}
 
 	return psOpts
 }

beacon-chain/p2p/pubsub_tracer.go

@@ -1,6 +1,8 @@
 package p2p
 
 import (
+	"sync"
+
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	"github.com/libp2p/go-libp2p/core/host"
 	"github.com/libp2p/go-libp2p/core/peer"
@@ -8,7 +10,7 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 )
 
-var _ = pubsub.RawTracer(gossipTracer{})
+var _ = pubsub.RawTracer(&gossipTracer{})
 
 // Initializes the values for the pubsub rpc action.
 type action int
@@ -23,85 +25,146 @@ const (
 // and broadcasted through gossipsub.
 type gossipTracer struct {
 	host host.Host
+
+	mu sync.Mutex
+	// map topic -> Set(peerID). Peer is in set if it supports partial messages.
+	partialMessagePeers map[string]map[peer.ID]struct{}
+	// map topic -> Set(peerID). Peer is in set if in the mesh.
+	meshPeers map[string]map[peer.ID]struct{}
 }
 
 // AddPeer .
-func (g gossipTracer) AddPeer(p peer.ID, proto protocol.ID) {
+func (g *gossipTracer) AddPeer(p peer.ID, proto protocol.ID) {
 	// no-op
 }
 
 // RemovePeer .
-func (g gossipTracer) RemovePeer(p peer.ID) {
-	// no-op
+func (g *gossipTracer) RemovePeer(p peer.ID) {
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	for _, peers := range g.partialMessagePeers {
+		delete(peers, p)
+	}
+	for topic, peers := range g.meshPeers {
+		if _, ok := peers[p]; ok {
+			delete(peers, p)
+			g.updateMeshPeersMetric(topic)
+		}
+	}
 }
 
 // Join .
-func (g gossipTracer) Join(topic string) {
+func (g *gossipTracer) Join(topic string) {
 	pubsubTopicsActive.WithLabelValues(topic).Set(1)
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	if g.partialMessagePeers == nil {
+		g.partialMessagePeers = make(map[string]map[peer.ID]struct{})
+	}
+	if g.partialMessagePeers[topic] == nil {
+		g.partialMessagePeers[topic] = make(map[peer.ID]struct{})
+	}
+
+	if g.meshPeers == nil {
+		g.meshPeers = make(map[string]map[peer.ID]struct{})
+	}
+	if g.meshPeers[topic] == nil {
+		g.meshPeers[topic] = make(map[peer.ID]struct{})
+	}
 }
 
 // Leave .
-func (g gossipTracer) Leave(topic string) {
+func (g *gossipTracer) Leave(topic string) {
 	pubsubTopicsActive.WithLabelValues(topic).Set(0)
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	delete(g.partialMessagePeers, topic)
+	delete(g.meshPeers, topic)
 }
 
 // Graft .
-func (g gossipTracer) Graft(p peer.ID, topic string) {
+func (g *gossipTracer) Graft(p peer.ID, topic string) {
 	pubsubTopicsGraft.WithLabelValues(topic).Inc()
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	if m, ok := g.meshPeers[topic]; ok {
+		m[p] = struct{}{}
+	}
+	g.updateMeshPeersMetric(topic)
 }
 
 // Prune .
-func (g gossipTracer) Prune(p peer.ID, topic string) {
+func (g *gossipTracer) Prune(p peer.ID, topic string) {
 	pubsubTopicsPrune.WithLabelValues(topic).Inc()
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	if m, ok := g.meshPeers[topic]; ok {
+		delete(m, p)
+	}
+	g.updateMeshPeersMetric(topic)
 }
 
 // ValidateMessage .
-func (g gossipTracer) ValidateMessage(msg *pubsub.Message) {
+func (g *gossipTracer) ValidateMessage(msg *pubsub.Message) {
 	pubsubMessageValidate.WithLabelValues(*msg.Topic).Inc()
 }
 
 // DeliverMessage .
-func (g gossipTracer) DeliverMessage(msg *pubsub.Message) {
+func (g *gossipTracer) DeliverMessage(msg *pubsub.Message) {
 	pubsubMessageDeliver.WithLabelValues(*msg.Topic).Inc()
 }
 
 // RejectMessage .
-func (g gossipTracer) RejectMessage(msg *pubsub.Message, reason string) {
+func (g *gossipTracer) RejectMessage(msg *pubsub.Message, reason string) {
 	pubsubMessageReject.WithLabelValues(*msg.Topic, reason).Inc()
 }
 
 // DuplicateMessage .
-func (g gossipTracer) DuplicateMessage(msg *pubsub.Message) {
+func (g *gossipTracer) DuplicateMessage(msg *pubsub.Message) {
 	pubsubMessageDuplicate.WithLabelValues(*msg.Topic).Inc()
 }
 
 // UndeliverableMessage .
-func (g gossipTracer) UndeliverableMessage(msg *pubsub.Message) {
+func (g *gossipTracer) UndeliverableMessage(msg *pubsub.Message) {
 	pubsubMessageUndeliverable.WithLabelValues(*msg.Topic).Inc()
 }
 
 // ThrottlePeer .
-func (g gossipTracer) ThrottlePeer(p peer.ID) {
+func (g *gossipTracer) ThrottlePeer(p peer.ID) {
 	agent := agentFromPid(p, g.host.Peerstore())
 	pubsubPeerThrottle.WithLabelValues(agent).Inc()
 }
 
 // RecvRPC .
-func (g gossipTracer) RecvRPC(rpc *pubsub.RPC) {
-	g.setMetricFromRPC(recv, pubsubRPCSubRecv, pubsubRPCPubRecv, pubsubRPCRecv, rpc)
+func (g *gossipTracer) RecvRPC(rpc *pubsub.RPC, from peer.ID) {
+	g.setMetricFromRPC(recv, pubsubRPCSubRecv, pubsubRPCPubRecv, pubsubRPCPubRecvSize, pubsubRPCRecv, rpc)
+
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	for _, sub := range rpc.Subscriptions {
+		m, ok := g.partialMessagePeers[sub.GetTopicid()]
+		if !ok {
+			continue
+		}
+		if sub.GetSubscribe() && sub.GetRequestsPartial() {
+			m[from] = struct{}{}
+		} else {
+			delete(m, from)
+		}
+	}
 }
 
 // SendRPC .
-func (g gossipTracer) SendRPC(rpc *pubsub.RPC, p peer.ID) {
-	g.setMetricFromRPC(send, pubsubRPCSubSent, pubsubRPCPubSent, pubsubRPCSent, rpc)
+func (g *gossipTracer) SendRPC(rpc *pubsub.RPC, p peer.ID) {
+	g.setMetricFromRPC(send, pubsubRPCSubSent, pubsubRPCPubSent, pubsubRPCPubSentSize, pubsubRPCSent, rpc)
 }
 
 // DropRPC .
-func (g gossipTracer) DropRPC(rpc *pubsub.RPC, p peer.ID) {
-	g.setMetricFromRPC(drop, pubsubRPCSubDrop, pubsubRPCPubDrop, pubsubRPCDrop, rpc)
+func (g *gossipTracer) DropRPC(rpc *pubsub.RPC, p peer.ID) {
+	g.setMetricFromRPC(drop, pubsubRPCSubDrop, pubsubRPCPubDrop, pubsubRPCPubDropSize, pubsubRPCDrop, rpc)
 }
 
-func (g gossipTracer) setMetricFromRPC(act action, subCtr prometheus.Counter, pubCtr, ctrlCtr *prometheus.CounterVec, rpc *pubsub.RPC) {
+func (g *gossipTracer) setMetricFromRPC(act action, subCtr prometheus.Counter, pubCtr, pubSizeCtr, ctrlCtr *prometheus.CounterVec, rpc *pubsub.RPC) {
 	subCtr.Add(float64(len(rpc.Subscriptions)))
 	if rpc.Control != nil {
 		ctrlCtr.WithLabelValues("graft").Add(float64(len(rpc.Control.Graft)))
@@ -110,12 +173,41 @@ func (g gossipTracer) setMetricFromRPC(act action, subCtr prometheus.Counter, pu
 		ctrlCtr.WithLabelValues("iwant").Add(float64(len(rpc.Control.Iwant)))
 		ctrlCtr.WithLabelValues("idontwant").Add(float64(len(rpc.Control.Idontwant)))
 	}
+	// For incoming messages from pubsub, we do not record metrics for them as these values
+	// could be junk.
+	if act == recv {
+		return
+	}
 	for _, msg := range rpc.Publish {
-		// For incoming messages from pubsub, we do not record metrics for them as these values
-		// could be junk.
-		if act == recv {
-			continue
-		}
-		pubCtr.WithLabelValues(*msg.Topic).Inc()
+		pubCtr.WithLabelValues(msg.GetTopic()).Inc()
+		pubSizeCtr.WithLabelValues(msg.GetTopic(), "false").Add(float64(msg.Size()))
+	}
+	if rpc.Partial != nil {
+		pubCtr.WithLabelValues(rpc.Partial.GetTopicID()).Inc()
+		pubSizeCtr.WithLabelValues(rpc.Partial.GetTopicID(), "true").Add(float64(rpc.Partial.Size()))
 	}
 }
+
+// updateMeshPeersMetric requires the caller to hold the state mutex
+func (g *gossipTracer) updateMeshPeersMetric(topic string) {
+	meshPeers, ok := g.meshPeers[topic]
+	if !ok {
+		return
+	}
+	partialPeers, ok := g.partialMessagePeers[topic]
+	if !ok {
+		return
+	}
+
+	var supportsPartial, doesNotSupportPartial float64
+	for p := range meshPeers {
+		if _, ok := partialPeers[p]; ok {
+			supportsPartial++
+		} else {
+			doesNotSupportPartial++
+		}
+	}
+
+	pubsubMeshPeers.WithLabelValues(topic, "true").Set(supportsPartial)
+	pubsubMeshPeers.WithLabelValues(topic, "false").Set(doesNotSupportPartial)
+}

beacon-chain/p2p/service.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/OffchainLabs/prysm/v7/async"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/encoder"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/partialdatacolumnbroadcaster"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/peers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/peers/scorers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/types"
@@ -77,6 +78,7 @@ type Service struct {
 	privKey                  *ecdsa.PrivateKey
 	metaData                 metadata.Metadata
 	pubsub                   *pubsub.PubSub
+	partialColumnBroadcaster *partialdatacolumnbroadcaster.PartialColumnBroadcaster
 	joinedTopics             map[string]*pubsub.Topic
 	joinedTopicsLock         sync.RWMutex
 	subnetsLock              map[uint64]*sync.RWMutex
@@ -147,6 +149,10 @@ func NewService(ctx context.Context, cfg *Config) (*Service, error) {
 		custodyInfoSet:        make(chan struct{}),
 	}
 
+	if cfg.PartialDataColumns {
+		s.partialColumnBroadcaster = partialdatacolumnbroadcaster.NewBroadcaster(log.Logger)
+	}
+
 	ipAddr := prysmnetwork.IPAddr()
 
 	opts, err := s.buildOptions(ipAddr, s.privKey)
@@ -305,6 +311,10 @@ func (s *Service) Start() {
 		logExternalDNSAddr(s.host.ID(), p2pHostDNS, p2pTCPPort)
 	}
 	go s.forkWatcher()
+
+	if s.partialColumnBroadcaster != nil {
+		go s.partialColumnBroadcaster.Start()
+	}
 }
 
 // Stop the p2p service and terminate all peer connections.
@@ -314,6 +324,10 @@ func (s *Service) Stop() error {
 	if s.dv5Listener != nil {
 		s.dv5Listener.Close()
 	}
+
+	if s.partialColumnBroadcaster != nil {
+		s.partialColumnBroadcaster.Stop()
+	}
 	return nil
 }
 
@@ -350,6 +364,10 @@ func (s *Service) PubSub() *pubsub.PubSub {
 	return s.pubsub
 }
 
+func (s *Service) PartialColumnBroadcaster() *partialdatacolumnbroadcaster.PartialColumnBroadcaster {
+	return s.partialColumnBroadcaster
+}
+
 // Host returns the currently running libp2p
 // host of the service.
 func (s *Service) Host() host.Host {

beacon-chain/p2p/testing/BUILD.bazel

@@ -21,6 +21,7 @@ go_library(
     deps = [
         "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/p2p/encoder:go_default_library",
+        "//beacon-chain/p2p/partialdatacolumnbroadcaster:go_default_library",
         "//beacon-chain/p2p/peers:go_default_library",
         "//beacon-chain/p2p/peers/scorers:go_default_library",
         "//config/fieldparams:go_default_library",

beacon-chain/p2p/testing/fuzz_p2p.go

@@ -4,6 +4,7 @@ import (
 	"context"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/encoder"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/partialdatacolumnbroadcaster"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/peers"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
@@ -108,6 +109,10 @@ func (*FakeP2P) PubSub() *pubsub.PubSub {
 	return nil
 }
 
+func (*FakeP2P) PartialColumnBroadcaster() *partialdatacolumnbroadcaster.PartialColumnBroadcaster {
+	return nil
+}
+
 // MetadataSeq -- fake.
 func (*FakeP2P) MetadataSeq() uint64 {
 	return 0
@@ -169,7 +174,7 @@ func (*FakeP2P) BroadcastLightClientFinalityUpdate(_ context.Context, _ interfac
 }
 
 // BroadcastDataColumnSidecar -- fake.
-func (*FakeP2P) BroadcastDataColumnSidecars(_ context.Context, _ []blocks.VerifiedRODataColumn) error {
+func (*FakeP2P) BroadcastDataColumnSidecars(_ context.Context, _ []blocks.VerifiedRODataColumn, _ []blocks.PartialDataColumn) error {
 	return nil
 }
 

beacon-chain/p2p/testing/mock_broadcaster.go

@@ -63,7 +63,7 @@ func (m *MockBroadcaster) BroadcastLightClientFinalityUpdate(_ context.Context,
 }
 
 // BroadcastDataColumnSidecar broadcasts a data column for mock.
-func (m *MockBroadcaster) BroadcastDataColumnSidecars(context.Context, []blocks.VerifiedRODataColumn) error {
+func (m *MockBroadcaster) BroadcastDataColumnSidecars(context.Context, []blocks.VerifiedRODataColumn, []blocks.PartialDataColumn) error {
 	m.BroadcastCalled.Store(true)
 	return nil
 }

beacon-chain/p2p/testing/p2p.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/encoder"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/partialdatacolumnbroadcaster"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/peers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/peers/scorers"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
@@ -242,7 +243,7 @@ func (p *TestP2P) BroadcastLightClientFinalityUpdate(_ context.Context, _ interf
 }
 
 // BroadcastDataColumnSidecar broadcasts a data column for mock.
-func (p *TestP2P) BroadcastDataColumnSidecars(context.Context, []blocks.VerifiedRODataColumn) error {
+func (p *TestP2P) BroadcastDataColumnSidecars(context.Context, []blocks.VerifiedRODataColumn, []blocks.PartialDataColumn) error {
 	p.BroadcastCalled.Store(true)
 	return nil
 }
@@ -308,6 +309,10 @@ func (p *TestP2P) PubSub() *pubsub.PubSub {
 	return p.pubsub
 }
 
+func (p *TestP2P) PartialColumnBroadcaster() *partialdatacolumnbroadcaster.PartialColumnBroadcaster {
+	return nil
+}
+
 // Disconnect from a peer.
 func (p *TestP2P) Disconnect(pid peer.ID) error {
 	return p.BHost.Network().ClosePeer(pid)

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

@@ -7,6 +7,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/OffchainLabs/go-bitfield"
 	builderapi "github.com/OffchainLabs/prysm/v7/api/client/builder"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/builder"
@@ -308,6 +309,7 @@ func (vs *Server) ProposeBeaconBlock(ctx context.Context, req *ethpb.GenericSign
 	}
 
 	rob, err := blocks.NewROBlockWithRoot(block, root)
+	var partialColumns []blocks.PartialDataColumn
 	if block.IsBlinded() {
 		block, blobSidecars, err = vs.handleBlindedBlock(ctx, block)
 		if errors.Is(err, builderapi.ErrBadGateway) {
@@ -315,7 +317,7 @@ func (vs *Server) ProposeBeaconBlock(ctx context.Context, req *ethpb.GenericSign
 			return &ethpb.ProposeResponse{BlockRoot: root[:]}, nil
 		}
 	} else if block.Version() >= version.Deneb {
-		blobSidecars, dataColumnSidecars, err = vs.handleUnblindedBlock(rob, req)
+		blobSidecars, dataColumnSidecars, partialColumns, err = vs.handleUnblindedBlock(rob, req)
 	}
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "%s: %v", "handle block failed", err)
@@ -335,7 +337,7 @@ func (vs *Server) ProposeBeaconBlock(ctx context.Context, req *ethpb.GenericSign
 
 	wg.Wait()
 
-	if err := vs.broadcastAndReceiveSidecars(ctx, block, root, blobSidecars, dataColumnSidecars); err != nil {
+	if err := vs.broadcastAndReceiveSidecars(ctx, block, root, blobSidecars, dataColumnSidecars, partialColumns); err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not broadcast/receive sidecars: %v", err)
 	}
 	if err := <-errChan; err != nil {
@@ -352,9 +354,10 @@ func (vs *Server) broadcastAndReceiveSidecars(
 	root [fieldparams.RootLength]byte,
 	blobSidecars []*ethpb.BlobSidecar,
 	dataColumnSidecars []blocks.RODataColumn,
+	partialColumns []blocks.PartialDataColumn,
 ) error {
 	if block.Version() >= version.Fulu {
-		if err := vs.broadcastAndReceiveDataColumns(ctx, dataColumnSidecars); err != nil {
+		if err := vs.broadcastAndReceiveDataColumns(ctx, dataColumnSidecars, partialColumns); err != nil {
 			return errors.Wrap(err, "broadcast and receive data columns")
 		}
 		return nil
@@ -403,34 +406,41 @@ func (vs *Server) handleBlindedBlock(ctx context.Context, block interfaces.Signe
 func (vs *Server) handleUnblindedBlock(
 	block blocks.ROBlock,
 	req *ethpb.GenericSignedBeaconBlock,
-) ([]*ethpb.BlobSidecar, []blocks.RODataColumn, error) {
+) ([]*ethpb.BlobSidecar, []blocks.RODataColumn, []blocks.PartialDataColumn, error) {
 	rawBlobs, proofs, err := blobsAndProofs(req)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 
 	if block.Version() >= version.Fulu {
 		// Compute cells and proofs from the blobs and cell proofs.
 		cellsPerBlob, proofsPerBlob, err := peerdas.ComputeCellsAndProofsFromFlat(rawBlobs, proofs)
 		if err != nil {
-			return nil, nil, errors.Wrap(err, "compute cells and proofs")
+			return nil, nil, nil, errors.Wrap(err, "compute cells and proofs")
 		}
 
 		// Construct data column sidecars from the signed block and cells and proofs.
 		roDataColumnSidecars, err := peerdas.DataColumnSidecars(cellsPerBlob, proofsPerBlob, peerdas.PopulateFromBlock(block))
 		if err != nil {
-			return nil, nil, errors.Wrap(err, "data column sidcars")
+			return nil, nil, nil, errors.Wrap(err, "data column sidcars")
 		}
 
-		return nil, roDataColumnSidecars, nil
+		included := bitfield.NewBitlist(uint64(len(cellsPerBlob)))
+		included = included.Not() // all bits set to 1
+		partialColumns, err := peerdas.PartialColumns(included, cellsPerBlob, proofsPerBlob, peerdas.PopulateFromBlock(block))
+		if err != nil {
+			return nil, nil, nil, errors.Wrap(err, "data column sidcars")
+		}
+
+		return nil, roDataColumnSidecars, partialColumns, nil
 	}
 
 	blobSidecars, err := BuildBlobSidecars(block, rawBlobs, proofs)
 	if err != nil {
-		return nil, nil, errors.Wrap(err, "build blob sidecars")
+		return nil, nil, nil, errors.Wrap(err, "build blob sidecars")
 	}
 
-	return blobSidecars, nil, nil
+	return blobSidecars, nil, nil, nil
 }
 
 // broadcastReceiveBlock broadcasts a block and handles its reception.
@@ -497,7 +507,7 @@ func (vs *Server) broadcastAndReceiveBlobs(ctx context.Context, sidecars []*ethp
 }
 
 // broadcastAndReceiveDataColumns handles the broadcasting and reception of data columns sidecars.
-func (vs *Server) broadcastAndReceiveDataColumns(ctx context.Context, roSidecars []blocks.RODataColumn) error {
+func (vs *Server) broadcastAndReceiveDataColumns(ctx context.Context, roSidecars []blocks.RODataColumn, partialColumns []blocks.PartialDataColumn) error {
 	// We built this block ourselves, so we can upgrade the read only data column sidecar into a verified one.
 	verifiedSidecars := make([]blocks.VerifiedRODataColumn, 0, len(roSidecars))
 	for _, sidecar := range roSidecars {
@@ -506,7 +516,7 @@ func (vs *Server) broadcastAndReceiveDataColumns(ctx context.Context, roSidecars
 	}
 
 	// Broadcast sidecars (non blocking).
-	if err := vs.P2P.BroadcastDataColumnSidecars(ctx, verifiedSidecars); err != nil {
+	if err := vs.P2P.BroadcastDataColumnSidecars(ctx, verifiedSidecars, partialColumns); err != nil {
 		return errors.Wrap(err, "broadcast data column sidecars")
 	}
 

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

@@ -46,20 +46,14 @@ func (b *BeaconState) BuilderPubkey(builderIndex primitives.BuilderIndex) ([fiel
 }
 
 // IsActiveBuilder returns true if the builder placement is finalized and it has not initiated exit.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// def is_active_builder(state: BeaconState, builder_index: BuilderIndex) -> bool:
 //
-//	<spec fn="is_active_builder" fork="gloas" hash="1a599fb2">
-//	def is_active_builder(state: BeaconState, builder_index: BuilderIndex) -> bool:
-//	    """
-//	    Check if the builder at ``builder_index`` is active for the given ``state``.
-//	    """
-//	    builder = state.builders[builder_index]
-//	    return (
-//	        # Placement in builder list is finalized
-//	        builder.deposit_epoch < state.finalized_checkpoint.epoch
-//	        # Has not initiated exit
-//	        and builder.withdrawable_epoch == FAR_FUTURE_EPOCH
-//	    )
-//	</spec>
+//	builder = state.builders[builder_index]
+//	return (
+//	    builder.deposit_epoch < state.finalized_checkpoint.epoch
+//	    and builder.withdrawable_epoch == FAR_FUTURE_EPOCH
+//	)
 func (b *BeaconState) IsActiveBuilder(builderIndex primitives.BuilderIndex) (bool, error) {
 	if b.version < version.Gloas {
 		return false, errNotSupported("IsActiveBuilder", b.version)
@@ -78,18 +72,15 @@ func (b *BeaconState) IsActiveBuilder(builderIndex primitives.BuilderIndex) (boo
 }
 
 // CanBuilderCoverBid returns true if the builder has enough balance to cover the given bid amount.
+// Spec v1.7.0-alpha.0 (pseudocode):
+// def can_builder_cover_bid(state: BeaconState, builder_index: BuilderIndex, bid_amount: Gwei) -> bool:
 //
-//	<spec fn="can_builder_cover_bid" fork="gloas" hash="9e3f2d7c">
-//	def can_builder_cover_bid(
-//	    state: BeaconState, builder_index: BuilderIndex, bid_amount: Gwei
-//	) -> bool:
-//	    builder_balance = state.builders[builder_index].balance
-//	    pending_withdrawals_amount = get_pending_balance_to_withdraw_for_builder(state, builder_index)
-//	    min_balance = MIN_DEPOSIT_AMOUNT + pending_withdrawals_amount
-//	    if builder_balance < min_balance:
-//	        return False
-//	    return builder_balance - min_balance >= bid_amount
-//	</spec>
+//	builder_balance = state.builders[builder_index].balance
+//	pending_withdrawals_amount = get_pending_balance_to_withdraw_for_builder(state, builder_index)
+//	min_balance = MIN_DEPOSIT_AMOUNT + pending_withdrawals_amount
+//	if builder_balance < min_balance:
+//	    return False
+//	return builder_balance - min_balance >= bid_amount
 func (b *BeaconState) CanBuilderCoverBid(builderIndex primitives.BuilderIndex, bidAmount primitives.Gwei) (bool, error) {
 	if b.version < version.Gloas {
 		return false, errNotSupported("CanBuilderCoverBid", b.version)

beacon-chain/sync/BUILD.bazel

@@ -58,6 +58,7 @@ go_library(
         "validate_bls_to_execution_change.go",
         "validate_data_column.go",
         "validate_light_client.go",
+        "validate_partial_header.go",
         "validate_proposer_slashing.go",
         "validate_sync_committee_message.go",
         "validate_sync_contribution_proof.go",
@@ -98,6 +99,7 @@ go_library(
         "//beacon-chain/operations/voluntaryexits:go_default_library",
         "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/p2p/encoder:go_default_library",
+        "//beacon-chain/p2p/partialdatacolumnbroadcaster:go_default_library",
         "//beacon-chain/p2p/peers:go_default_library",
         "//beacon-chain/p2p/types:go_default_library",
         "//beacon-chain/slasher/types:go_default_library",

beacon-chain/sync/batch_verifier.go

@@ -2,8 +2,10 @@ package sync
 
 import (
 	"context"
+	"iter"
 	"time"
 
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v7/crypto/bls"
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing"
@@ -19,9 +21,16 @@ type signatureVerifier struct {
 	resChan chan error
 }
 
+type errorWithSegment struct {
+	err error
+	// segment is only available if the batched verification failed
+	segment peerdas.CellProofBundleSegment
+}
+
 type kzgVerifier struct {
-	dataColumns []blocks.RODataColumn
-	resChan     chan error
+	sizeHint   int
+	cellProofs iter.Seq[blocks.CellProofBundle]
+	resChan    chan errorWithSegment
 }
 
 // A routine that runs in the background to perform batch

beacon-chain/sync/metrics.go

@@ -256,6 +256,16 @@ var (
 			Help: "Count the number of data column sidecars obtained via the execution layer.",
 		},
 	)
+
+	usefulFullColumnsReceivedTotal = promauto.NewCounterVec(prometheus.CounterOpts{
+		Name: "beacon_useful_full_columns_received_total",
+		Help: "Number of useful full columns (any cell being useful) received",
+	}, []string{"column_index"})
+
+	partialMessageColumnCompletionsTotal = promauto.NewCounterVec(prometheus.CounterOpts{
+		Name: "beacon_partial_message_column_completions_total",
+		Help: "How often the partial message first completed the column",
+	}, []string{"column_index"})
 )
 
 func (s *Service) updateMetrics() {

beacon-chain/sync/subscriber.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"reflect"
 	"runtime/debug"
+	"slices"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -14,11 +16,13 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/partialdatacolumnbroadcaster"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/peers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v7/cmd/beacon-chain/flags"
 	"github.com/OffchainLabs/prysm/v7/config/features"
 	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing"
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
@@ -61,6 +65,15 @@ type subscribeParameters struct {
 	// getSubnetsRequiringPeers is a function that returns all subnets that require peers to be found
 	// but for which no subscriptions are needed.
 	getSubnetsRequiringPeers func(currentSlot primitives.Slot) map[uint64]bool
+
+	partial *partialSubscribeParameters
+}
+
+type partialSubscribeParameters struct {
+	broadcaster    *partialdatacolumnbroadcaster.PartialColumnBroadcaster
+	validateHeader partialdatacolumnbroadcaster.HeaderValidator
+	validate       partialdatacolumnbroadcaster.ColumnValidator
+	handle         partialdatacolumnbroadcaster.SubHandler
 }
 
 // shortTopic is a less verbose version of topic strings used for logging.
@@ -320,6 +333,35 @@ func (s *Service) registerSubscribers(nse params.NetworkScheduleEntry) bool {
 	// New gossip topic in Fulu.
 	if params.BeaconConfig().FuluForkEpoch <= nse.Epoch {
 		s.spawn(func() {
+			var ps *partialSubscribeParameters
+			broadcaster := s.cfg.p2p.PartialColumnBroadcaster()
+			if broadcaster != nil {
+				ps = &partialSubscribeParameters{
+					broadcaster: broadcaster,
+					validateHeader: func(header *ethpb.PartialDataColumnHeader) (bool, error) {
+						return s.validatePartialDataColumnHeader(context.TODO(), header)
+					},
+					validate: func(cellsToVerify []blocks.CellProofBundle) error {
+						return peerdas.VerifyDataColumnsCellsKZGProofs(len(cellsToVerify), slices.Values(cellsToVerify))
+					},
+					handle: func(topic string, col blocks.VerifiedRODataColumn) {
+						ctx, cancel := context.WithTimeout(s.ctx, pubsubMessageTimeout)
+						defer cancel()
+
+						slot := col.SignedBlockHeader.Header.Slot
+						proposerIndex := col.SignedBlockHeader.Header.ProposerIndex
+						if !s.hasSeenDataColumnIndex(slot, proposerIndex, col.Index) {
+							s.setSeenDataColumnIndex(slot, proposerIndex, col.Index)
+							// This column was completed from a partial message.
+							partialMessageColumnCompletionsTotal.WithLabelValues(strconv.FormatUint(col.Index, 10)).Inc()
+						}
+						err := s.verifiedRODataColumnSubscriber(ctx, col)
+						if err != nil {
+							log.WithError(err).Error("Failed to handle verified RO data column subscriber")
+						}
+					},
+				}
+			}
 			s.subscribeWithParameters(subscribeParameters{
 				topicFormat:              p2p.DataColumnSubnetTopicFormat,
 				validate:                 s.validateDataColumn,
@@ -327,6 +369,7 @@ func (s *Service) registerSubscribers(nse params.NetworkScheduleEntry) bool {
 				nse:                      nse,
 				getSubnetsToJoin:         s.dataColumnSubnetIndices,
 				getSubnetsRequiringPeers: s.allDataColumnSubnets,
+				partial:                  ps,
 			})
 		})
 	}
@@ -365,11 +408,10 @@ func (s *Service) subscribe(topic string, validator wrappedVal, handle subHandle
 		// Impossible condition as it would mean topic does not exist.
 		panic(fmt.Sprintf("%s is not mapped to any message in GossipTopicMappings", topic)) // lint:nopanic -- Impossible condition.
 	}
-	s.subscribeWithBase(s.addDigestToTopic(topic, nse.ForkDigest), validator, handle)
+	s.subscribeWithBase(s.addDigestToTopic(topic, nse.ForkDigest)+s.cfg.p2p.Encoding().ProtocolSuffix(), validator, handle)
 }
 
 func (s *Service) subscribeWithBase(topic string, validator wrappedVal, handle subHandler) *pubsub.Subscription {
-	topic += s.cfg.p2p.Encoding().ProtocolSuffix()
 	log := log.WithField("topic", topic)
 
 	// Do not resubscribe already seen subscriptions.
@@ -532,7 +574,11 @@ func (s *Service) wrapAndReportValidation(topic string, v wrappedVal) (string, p
 func (s *Service) pruneNotWanted(t *subnetTracker, wantedSubnets map[uint64]bool) {
 	for _, subnet := range t.unwanted(wantedSubnets) {
 		t.cancelSubscription(subnet)
-		s.unSubscribeFromTopic(t.fullTopic(subnet, s.cfg.p2p.Encoding().ProtocolSuffix()))
+		topic := t.fullTopic(subnet, s.cfg.p2p.Encoding().ProtocolSuffix())
+		if t.partial != nil {
+			_ = t.partial.broadcaster.Unsubscribe(topic)
+		}
+		s.unSubscribeFromTopic(topic)
 	}
 }
 
@@ -579,9 +625,34 @@ func (s *Service) trySubscribeSubnets(t *subnetTracker) {
 	subnetsToJoin := t.getSubnetsToJoin(s.cfg.clock.CurrentSlot())
 	s.pruneNotWanted(t, subnetsToJoin)
 	for _, subnet := range t.missing(subnetsToJoin) {
-		// TODO: subscribeWithBase appends the protocol suffix, other methods don't. Make this consistent.
-		topic := t.fullTopic(subnet, "")
-		t.track(subnet, s.subscribeWithBase(topic, t.validate, t.handle))
+		topicStr := t.fullTopic(subnet, s.cfg.p2p.Encoding().ProtocolSuffix())
+		topicOpts := make([]pubsub.TopicOpt, 0, 2)
+
+		requestPartial := t.partial != nil
+
+		if requestPartial {
+			// TODO: do we want the ability to support partial messages without requesting them?
+			topicOpts = append(topicOpts, pubsub.RequestPartialMessages())
+		}
+
+		topic, err := s.cfg.p2p.JoinTopic(topicStr, topicOpts...)
+		if err != nil {
+			log.WithError(err).Error("Failed to join topic")
+			return
+		}
+
+		if requestPartial {
+			log.Info("Subscribing to partial columns on", topicStr)
+			err = t.partial.broadcaster.Subscribe(topic, t.partial.validateHeader, t.partial.validate, t.partial.handle)
+
+			if err != nil {
+				log.WithError(err).Error("Failed to subscribe to partial column")
+			}
+		}
+
+		// We still need to subscribe to the full columns as well as partial in
+		// case our peers don't support partial messages.
+		t.track(subnet, s.subscribeWithBase(topicStr, t.validate, t.handle))
 	}
 }
 

beacon-chain/sync/subscriber_beacon_blocks.go

@@ -11,6 +11,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/transition/interop"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p"
 	"github.com/OffchainLabs/prysm/v7/config/features"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
@@ -201,6 +202,16 @@ func (s *Service) processDataColumnSidecarsFromExecution(ctx context.Context, so
 			return nil, errors.Wrap(err, "column indices to sample")
 		}
 
+		// TODO: the deadline here was removed in https://github.com/OffchainLabs/prysm/pull/16155/files
+		// make sure that reintroducing it does not cause issues.
+		secondsPerHalfSlot := time.Duration(params.BeaconConfig().SecondsPerSlot/2) * time.Second
+		ctx, cancel := context.WithTimeout(ctx, secondsPerHalfSlot)
+		defer cancel()
+
+		digest, err := s.currentForkDigest()
+		if err != nil {
+			return nil, err
+		}
 		log := log.WithFields(logrus.Fields{
 			"root":          fmt.Sprintf("%#x", source.Root()),
 			"slot":          source.Slot(),
@@ -231,11 +242,30 @@ func (s *Service) processDataColumnSidecarsFromExecution(ctx context.Context, so
 			}
 
 			// Try to reconstruct data column constructedSidecars from the execution client.
-			constructedSidecars, err := s.cfg.executionReconstructor.ConstructDataColumnSidecars(ctx, source)
+			constructedSidecars, partialColumns, err := s.cfg.executionReconstructor.ConstructDataColumnSidecars(ctx, source)
 			if err != nil {
 				return nil, errors.Wrap(err, "reconstruct data column sidecars")
 			}
 
+			partialBroadcaster := s.cfg.p2p.PartialColumnBroadcaster()
+			if partialBroadcaster != nil {
+				log.WithField("len(partialColumns)", len(partialColumns)).Debug("Publishing partial columns")
+				for i := range uint64(len(partialColumns)) {
+					if !columnIndicesToSample[i] {
+						continue
+					}
+					subnet := peerdas.ComputeSubnetForDataColumnSidecar(i)
+					topic := fmt.Sprintf(p2p.DataColumnSubnetTopicFormat, digest, subnet) + s.cfg.p2p.Encoding().ProtocolSuffix()
+					// Publish the partial column. This is idempotent if we republish the same data twice.
+					// Note, the "partial column" may indeed be complete. We still
+					// should publish to help our peers.
+					err = partialBroadcaster.Publish(topic, partialColumns[i])
+					if err != nil {
+						log.WithError(err).Warn("Failed to publish partial column")
+					}
+				}
+			}
+
 			// No sidecars are retrieved from the EL, retry later
 			constructedCount := uint64(len(constructedSidecars))
 
@@ -307,7 +337,7 @@ func (s *Service) broadcastAndReceiveUnseenDataColumnSidecars(
 	}
 
 	// Broadcast all the data column sidecars we reconstructed but did not see via gossip (non blocking).
-	if err := s.cfg.p2p.BroadcastDataColumnSidecars(ctx, unseenSidecars); err != nil {
+	if err := s.cfg.p2p.BroadcastDataColumnSidecars(ctx, unseenSidecars, nil); err != nil {
 		return nil, errors.Wrap(err, "broadcast data column sidecars")
 	}
 

beacon-chain/sync/subscriber_data_column_sidecar.go

@@ -3,6 +3,7 @@ package sync
 import (
 	"context"
 	"fmt"
+	"strconv"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/feed"
 	opfeed "github.com/OffchainLabs/prysm/v7/beacon-chain/core/feed/operation"
@@ -24,6 +25,13 @@ func (s *Service) dataColumnSubscriber(ctx context.Context, msg proto.Message) e
 		return fmt.Errorf("message was not type blocks.VerifiedRODataColumn, type=%T", msg)
 	}
 
+	// Track useful full columns received via gossip (not previously seen)
+	slot := sidecar.SignedBlockHeader.Header.Slot
+	proposerIndex := sidecar.SignedBlockHeader.Header.ProposerIndex
+	if !s.hasSeenDataColumnIndex(slot, proposerIndex, sidecar.Index) {
+		usefulFullColumnsReceivedTotal.WithLabelValues(strconv.FormatUint(sidecar.Index, 10)).Inc()
+	}
+
 	if err := s.receiveDataColumnSidecar(ctx, sidecar); err != nil {
 		return wrapDataColumnError(sidecar, "receive data column sidecar", err)
 	}
@@ -57,6 +65,38 @@ func (s *Service) dataColumnSubscriber(ctx context.Context, msg proto.Message) e
 	return nil
 }
 
+func (s *Service) verifiedRODataColumnSubscriber(ctx context.Context, sidecar blocks.VerifiedRODataColumn) error {
+	log.WithField("slot", sidecar.Slot()).WithField("column", sidecar.Index).Info("Received data column sidecar")
+
+	if err := s.receiveDataColumnSidecar(ctx, sidecar); err != nil {
+		return errors.Wrap(err, "receive data column sidecar")
+	}
+
+	var wg errgroup.Group
+	wg.Go(func() error {
+		if err := s.processDataColumnSidecarsFromReconstruction(ctx, sidecar); err != nil {
+			return errors.Wrap(err, "process data column sidecars from reconstruction")
+		}
+
+		return nil
+	})
+
+	wg.Go(func() error {
+		// Broadcast our complete column for peers that don't use partial messages
+		if err := s.cfg.p2p.BroadcastDataColumnSidecars(ctx, []blocks.VerifiedRODataColumn{sidecar}, nil); err != nil {
+			return errors.Wrap(err, "process data column sidecars from execution")
+		}
+
+		return nil
+	})
+
+	if err := wg.Wait(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
 // receiveDataColumnSidecar receives a single data column sidecar: marks it as seen and saves it to the chain.
 // Do not loop over this function to receive multiple sidecars, use receiveDataColumnSidecars instead.
 func (s *Service) receiveDataColumnSidecar(ctx context.Context, sidecar blocks.VerifiedRODataColumn) error {

beacon-chain/sync/validate_data_column.go

@@ -71,6 +71,7 @@ func (s *Service) validateDataColumn(ctx context.Context, pid peer.ID, msg *pubs
 	roDataColumns := []blocks.RODataColumn{roDataColumn}
 
 	// Create the verifier.
+	// Question(marco): Do we want the multiple columns verifier? Is batching used only for kzg proofs?
 	verifier := s.newColumnsVerifier(roDataColumns, verification.GossipDataColumnSidecarRequirements)
 
 	// Start the verification process.

beacon-chain/sync/validate_partial_header.go

@@ -0,0 +1,143 @@
+package sync
+
+import (
+	"context"
+
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/time/slots"
+	"github.com/pkg/errors"
+)
+
+var (
+	// REJECT errors - peer should be penalized
+	errHeaderEmptyCommitments       = errors.New("header has no kzg commitments")
+	errHeaderParentInvalid          = errors.New("header parent invalid")
+	errHeaderSlotNotAfterParent     = errors.New("header slot not after parent")
+	errHeaderNotFinalizedDescendant = errors.New("header not finalized descendant")
+	errHeaderInvalidInclusionProof  = errors.New("invalid inclusion proof")
+	errHeaderInvalidSignature       = errors.New("invalid proposer signature")
+	errHeaderUnexpectedProposer     = errors.New("unexpected proposer index")
+
+	// IGNORE errors - don't penalize peer
+	errHeaderNil               = errors.New("nil header")
+	errHeaderFromFuture        = errors.New("header is from future slot")
+	errHeaderNotAboveFinalized = errors.New("header slot not above finalized")
+	errHeaderParentNotSeen     = errors.New("header parent not seen")
+)
+
+// validatePartialDataColumnHeader validates a PartialDataColumnHeader per the consensus spec.
+// Returns (reject, err) where reject=true means the peer should be penalized.
+// TODO: we should consolidate this with the existing DataColumn validation pipeline.
+func (s *Service) validatePartialDataColumnHeader(ctx context.Context, header *ethpb.PartialDataColumnHeader) (reject bool, err error) {
+	if header == nil || header.SignedBlockHeader == nil || header.SignedBlockHeader.Header == nil {
+		return false, errHeaderNil // IGNORE
+	}
+
+	blockHeader := header.SignedBlockHeader.Header
+	headerSlot := blockHeader.Slot
+	parentRoot := bytesutil.ToBytes32(blockHeader.ParentRoot)
+
+	// [REJECT] kzg_commitments list is non-empty
+	if len(header.KzgCommitments) == 0 {
+		return true, errHeaderEmptyCommitments
+	}
+
+	// [IGNORE] Not from future slot (with MAXIMUM_GOSSIP_CLOCK_DISPARITY allowance)
+	currentSlot := s.cfg.clock.CurrentSlot()
+	if headerSlot > currentSlot {
+		maxDisparity := params.BeaconConfig().MaximumGossipClockDisparityDuration()
+		slotStart, err := s.cfg.clock.SlotStart(headerSlot)
+		if err != nil {
+			return false, err
+		}
+		if s.cfg.clock.Now().Before(slotStart.Add(-maxDisparity)) {
+			return false, errHeaderFromFuture // IGNORE
+		}
+	}
+
+	// [IGNORE] Slot above finalized
+	finalizedCheckpoint := s.cfg.chain.FinalizedCheckpt()
+	startSlot, err := slots.EpochStart(finalizedCheckpoint.Epoch)
+	if err != nil {
+		return false, err
+	}
+	if headerSlot <= startSlot {
+		return false, errHeaderNotAboveFinalized // IGNORE
+	}
+
+	// [IGNORE] Parent has been seen
+	if !s.cfg.chain.HasBlock(ctx, parentRoot) {
+		return false, errHeaderParentNotSeen // IGNORE
+	}
+
+	// [REJECT] Parent passes validation (not a bad block)
+	if s.hasBadBlock(parentRoot) {
+		return true, errHeaderParentInvalid
+	}
+
+	// [REJECT] Header slot > parent slot
+	parentSlot, err := s.cfg.chain.RecentBlockSlot(parentRoot)
+	if err != nil {
+		return false, errors.Wrap(err, "get parent slot")
+	}
+	if headerSlot <= parentSlot {
+		return true, errHeaderSlotNotAfterParent
+	}
+
+	// [REJECT] Finalized checkpoint is ancestor (parent is in forkchoice)
+	if !s.cfg.chain.InForkchoice(parentRoot) {
+		return true, errHeaderNotFinalizedDescendant
+	}
+
+	// [REJECT] Inclusion proof valid
+	if err := peerdas.VerifyPartialDataColumnHeaderInclusionProof(header); err != nil {
+		return true, errHeaderInvalidInclusionProof
+	}
+
+	// [REJECT] Valid proposer signature
+	parentState, err := s.cfg.stateGen.StateByRoot(ctx, parentRoot)
+	if err != nil {
+		return false, errors.Wrap(err, "get parent state")
+	}
+
+	proposerIdx := blockHeader.ProposerIndex
+	proposer, err := parentState.ValidatorAtIndex(proposerIdx)
+	if err != nil {
+		return false, errors.Wrap(err, "get proposer")
+	}
+
+	domain, err := signing.Domain(
+		parentState.Fork(),
+		slots.ToEpoch(headerSlot),
+		params.BeaconConfig().DomainBeaconProposer,
+		parentState.GenesisValidatorsRoot(),
+	)
+	if err != nil {
+		return false, errors.Wrap(err, "get domain")
+	}
+
+	if err := signing.VerifyBlockHeaderSigningRoot(
+		blockHeader,
+		proposer.PublicKey,
+		header.SignedBlockHeader.Signature,
+		domain,
+	); err != nil {
+		return true, errHeaderInvalidSignature
+	}
+
+	// [REJECT] Expected proposer for slot
+	expectedProposer, err := helpers.BeaconProposerIndexAtSlot(ctx, parentState, headerSlot)
+	if err != nil {
+		return false, errors.Wrap(err, "compute expected proposer")
+	}
+	if expectedProposer != proposerIdx {
+		return true, errHeaderUnexpectedProposer
+	}
+
+	return false, nil // Valid header
+}

beacon-chain/verification/initializer.go

@@ -78,11 +78,21 @@ func (ini *Initializer) NewBlobVerifier(b blocks.ROBlob, reqs []Requirement) *RO
 // WARNING: The returned verifier is not thread-safe, and should not be used concurrently.
 func (ini *Initializer) NewDataColumnsVerifier(roDataColumns []blocks.RODataColumn, reqs []Requirement) *RODataColumnsVerifier {
 	return &RODataColumnsVerifier{
-		sharedResources:             ini.shared,
-		dataColumns:                 roDataColumns,
-		results:                     newResults(reqs...),
-		verifyDataColumnsCommitment: peerdas.VerifyDataColumnsSidecarKZGProofs,
-		stateByRoot:                 make(map[[fieldparams.RootLength]byte]state.BeaconState),
+		sharedResources: ini.shared,
+		dataColumns:     roDataColumns,
+		results:         newResults(reqs...),
+		verifyDataColumnsCommitment: func(rc []blocks.RODataColumn) error {
+			if len(rc) == 0 {
+				return nil
+			}
+			var sizeHint int
+			if len(rc) > 0 {
+				sizeHint = len(rc[0].Column)
+			}
+			sizeHint *= len(rc)
+			return peerdas.VerifyDataColumnsCellsKZGProofs(sizeHint, blocks.RODataColumnsToCellProofBundles(rc))
+		},
+		stateByRoot: make(map[[fieldparams.RootLength]byte]state.BeaconState),
 	}
 }
 

changelog/bastin_fix-genlogs-gitignore-bug.md

@@ -1,3 +0,0 @@
-### Fixed
-
-- Fixed a bug where `cmd/beacon-chain/execution` was being ignored by `hack/gen-logs.sh` due to a `.gitignore` rule.

changelog/bastin_fix-logging-issue.md

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

changelog/james-prysm_host-fallback-cleanup.md

@@ -1,11 +0,0 @@
-### Ignored 
-
-- moved finding healthy node logic to connection provider and other various cleanup on naming.
-
-### Changed
-
-- Improved node fallback logs.
-
-### Fixed
-
-- a potential race condition when switching hosts quickly and reconnecting to same host on an old connection.

changelog/jtraglia-improve-ethspecify-integration.md

@@ -1,3 +0,0 @@
-### Changed
-
-- Improved integrations with ethspecify so specrefs can be used throughout the codebase.

changelog/marco_add_partial_columns.md

@@ -0,0 +1,3 @@
+### Added
+
+- Add support for partial columns

changelog/potuz_forkchoice_unused_last_root.md

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

changelog/potuz_remove_unused_map.md

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

cmd/beacon-chain/execution/log.go

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

cmd/beacon-chain/flags/base.go

@@ -368,4 +368,9 @@ var (
 		Usage:  "Disables the engine_getBlobsV2 usage.",
 		Hidden: true,
 	}
+	// PartialDataColumns specifies the regex for enabling partial messages on datacolumns
+	PartialDataColumns = &cli.BoolFlag{
+		Name:  "partial-data-columns",
+		Usage: "Enable cell-level dissemination for PeerDAS data columns",
+	}
 )

cmd/beacon-chain/main.go

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

cmd/beacon-chain/usage.go

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

cmd/validator/main.go

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

consensus-types/blocks/BUILD.bazel

@@ -8,6 +8,8 @@ go_library(
         "get_payload.go",
         "getters.go",
         "kzg.go",
+        "log.go",
+        "partialdatacolumn.go",
         "proofs.go",
         "proto.go",
         "roblob.go",
@@ -36,8 +38,11 @@ go_library(
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/validator-client:go_default_library",
         "//runtime/version:go_default_library",
+        "@com_github_libp2p_go_libp2p_pubsub//partialmessages:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_fastssz//:go_default_library",
+        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )
@@ -49,6 +54,7 @@ go_test(
         "factory_test.go",
         "getters_test.go",
         "kzg_test.go",
+        "partialdatacolumn_invariants_test.go",
         "proofs_test.go",
         "proto_test.go",
         "roblob_test.go",
@@ -74,6 +80,9 @@ go_test(
         "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
+        "//testing/util:go_default_library",
+        "@com_github_libp2p_go_libp2p//core/peer:go_default_library",
+        "@com_github_libp2p_go_libp2p_pubsub//partialmessages:go_default_library",
         "@com_github_prysmaticlabs_fastssz//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
     ],

consensus-types/blocks/log.go

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

consensus-types/blocks/partialdatacolumn.go

@@ -0,0 +1,337 @@
+package blocks
+
+import (
+	"errors"
+
+	"github.com/OffchainLabs/go-bitfield"
+	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/libp2p/go-libp2p-pubsub/partialmessages"
+	"github.com/sirupsen/logrus"
+)
+
+type CellProofBundle struct {
+	ColumnIndex uint64
+	Commitment  []byte
+	Cell        []byte
+	Proof       []byte
+}
+
+type PartialDataColumn struct {
+	*ethpb.DataColumnSidecar
+	root    [fieldparams.RootLength]byte
+	groupID []byte
+
+	Included bitfield.Bitlist
+
+	// Parts we've received before we have any commitments to validate against.
+	// Happens when a peer eager pushes to us.
+	// TODO implement. For now, not bothering to handle the eager pushes.
+	// quarantine []*ethpb.PartialDataColumnSidecar
+}
+
+// const quarantineSize = 3
+
+// NewPartialDataColumn creates a new Partial Data Column for the given block.
+// It does not validate the inputs. The caller is responsible for validating the
+// block header and KZG Commitment Inclusion proof.
+func NewPartialDataColumn(
+	signedBlockHeader *ethpb.SignedBeaconBlockHeader,
+	columnIndex uint64,
+	kzgCommitments [][]byte,
+	kzgInclusionProof [][]byte,
+) (PartialDataColumn, error) {
+	root, err := signedBlockHeader.Header.HashTreeRoot()
+	if err != nil {
+		return PartialDataColumn{}, err
+	}
+
+	sidecar := &ethpb.DataColumnSidecar{
+		Index:                        columnIndex,
+		KzgCommitments:               kzgCommitments,
+		Column:                       make([][]byte, len(kzgCommitments)),
+		KzgProofs:                    make([][]byte, len(kzgCommitments)),
+		SignedBlockHeader:            signedBlockHeader,
+		KzgCommitmentsInclusionProof: kzgInclusionProof,
+	}
+
+	groupID := make([]byte, len(root)+1)
+	copy(groupID[1:], root[:])
+	// Version 0
+	groupID[0] = 0
+
+	c := PartialDataColumn{
+		DataColumnSidecar: sidecar,
+		root:              root,
+		groupID:           groupID,
+		Included:          bitfield.NewBitlist(uint64(len(sidecar.KzgCommitments))),
+	}
+	if len(c.Column) != len(c.KzgCommitments) {
+		return PartialDataColumn{}, errors.New("mismatch between number of cells and commitments")
+	}
+	if len(c.KzgProofs) != len(c.KzgCommitments) {
+		return PartialDataColumn{}, errors.New("mismatch between number of proofs and commitments")
+	}
+
+	for i := range len(c.KzgCommitments) {
+		if sidecar.Column[i] == nil {
+			continue
+		}
+		c.Included.SetBitAt(uint64(i), true)
+	}
+	return c, nil
+}
+
+func (p *PartialDataColumn) GroupID() []byte {
+	return p.groupID
+}
+func (p *PartialDataColumn) PartialMessageBytes(metadata partialmessages.PartsMetadata) ([]byte, error) {
+	numCommitments := p.Included.Len()
+	peerAvailable, peerRequests, isNewFormat := ParseMetadata(metadata, numCommitments)
+	if peerAvailable.Len() != numCommitments {
+		return nil, errors.New("metadata length does not match expected length")
+	}
+	if isNewFormat && peerRequests.Len() != numCommitments {
+		return nil, errors.New("metadata length does not match expected length")
+	}
+
+	// shouldSend returns true if we should send cell i to this peer.
+	shouldSend := func(i uint64) bool {
+		if !p.Included.BitAt(i) {
+			return false
+		}
+		if peerAvailable.BitAt(i) {
+			return false
+		}
+		if isNewFormat && !peerRequests.BitAt(i) {
+			return false
+		}
+		return true
+	}
+
+	var cellsToReturn int
+	for i := range numCommitments {
+		if shouldSend(i) {
+			cellsToReturn++
+		}
+	}
+	if cellsToReturn == 0 {
+		return nil, nil
+	}
+
+	included := bitfield.NewBitlist(numCommitments)
+	outMessage := ethpb.PartialDataColumnSidecar{
+		CellsPresentBitmap: included,
+		PartialColumn:      make([][]byte, 0, cellsToReturn),
+		KzgProofs:          make([][]byte, 0, cellsToReturn),
+	}
+	for i := range numCommitments {
+		if !shouldSend(i) {
+			continue
+		}
+		included.SetBitAt(i, true)
+		outMessage.PartialColumn = append(outMessage.PartialColumn, p.Column[i])
+		outMessage.KzgProofs = append(outMessage.KzgProofs, p.KzgProofs[i])
+	}
+
+	marshalled, err := outMessage.MarshalSSZ()
+	if err != nil {
+		return nil, err
+	}
+
+	return marshalled, nil
+}
+
+// TODO: This method will be removed after upgrading to the latest Gossipsub.
+func (p *PartialDataColumn) EagerPartialMessageBytes() ([]byte, partialmessages.PartsMetadata, error) {
+	// TODO: do we want to send this once per groupID per peer
+	// Eagerly push the PartialDataColumnHeader
+	outHeader := &ethpb.PartialDataColumnHeader{
+		KzgCommitments:               p.KzgCommitments,
+		SignedBlockHeader:            p.SignedBlockHeader,
+		KzgCommitmentsInclusionProof: p.KzgCommitmentsInclusionProof,
+	}
+	outMessage := &ethpb.PartialDataColumnSidecar{
+		CellsPresentBitmap: bitfield.NewBitlist(uint64(len(p.KzgCommitments))),
+		Header:             []*ethpb.PartialDataColumnHeader{outHeader},
+	}
+
+	marshalled, err := outMessage.MarshalSSZ()
+	if err != nil {
+		return nil, nil, err
+	}
+	// Empty bitlist since we aren't including any cells here
+	peersNextParts := partialmessages.PartsMetadata(bitfield.NewBitlist(uint64(len(p.KzgCommitments))))
+
+	return marshalled, peersNextParts, nil
+}
+
+func (p *PartialDataColumn) PartsMetadata() partialmessages.PartsMetadata {
+	n := p.Included.Len()
+	requests := bitfield.NewBitlist(n)
+	for i := range n {
+		requests.SetBitAt(i, true)
+	}
+	return combinedMetadata(p.Included, requests)
+}
+
+// ParseMetadata splits PartsMetadata into available and request bitlists.
+// Old format (len==N): returns (metadata, nil, false)
+// New format (len==2N): returns (first N bits, next N bits, true)
+func ParseMetadata(metadata partialmessages.PartsMetadata, numCommitments uint64) (available bitfield.Bitlist, requests bitfield.Bitlist, isNewFormat bool) {
+	bl := bitfield.Bitlist(metadata)
+	if bl.Len() == 2*numCommitments {
+		available = bitfield.NewBitlist(numCommitments)
+		requests = bitfield.NewBitlist(numCommitments)
+		for i := range numCommitments {
+			available.SetBitAt(i, bl.BitAt(i))
+			requests.SetBitAt(i, bl.BitAt(i+numCommitments))
+		}
+		return available, requests, true
+	}
+	return bl, nil, false
+}
+
+func combinedMetadata(available, requests bitfield.Bitlist) partialmessages.PartsMetadata {
+	n := available.Len()
+	combined := bitfield.NewBitlist(2 * n)
+	for i := range n {
+		combined.SetBitAt(i, available.BitAt(i))
+		combined.SetBitAt(i+n, requests.BitAt(i))
+	}
+	return partialmessages.PartsMetadata(combined)
+}
+
+// MergePartsMetadata merges two PartsMetadata values, handling old (N) and new (2N) formats.
+// If lengths differ, the old-format (N) is extended to new-format (2N) with all request bits set to 1.
+// TODO: This method will be removed after upgrading to the latest Gossipsub.
+func MergePartsMetadata(left, right partialmessages.PartsMetadata) (partialmessages.PartsMetadata, error) {
+	if len(left) == 0 {
+		return right, nil
+	}
+	if len(right) == 0 {
+		return left, nil
+	}
+	leftBl := bitfield.Bitlist(left)
+	rightBl := bitfield.Bitlist(right)
+	if leftBl.Len() != rightBl.Len() {
+		leftBl, rightBl = normalizeMetadataLengths(leftBl, rightBl)
+	}
+	merged, err := leftBl.Or(rightBl)
+	if err != nil {
+		return nil, err
+	}
+	return partialmessages.PartsMetadata(merged), nil
+}
+
+func normalizeMetadataLengths(left, right bitfield.Bitlist) (bitfield.Bitlist, bitfield.Bitlist) {
+	if left.Len() < right.Len() {
+		left = extendToNewFormat(left)
+	} else {
+		right = extendToNewFormat(right)
+	}
+	return left, right
+}
+
+func extendToNewFormat(bl bitfield.Bitlist) bitfield.Bitlist {
+	n := bl.Len()
+	extended := bitfield.NewBitlist(2 * n)
+	for i := range n {
+		extended.SetBitAt(i, bl.BitAt(i))
+		extended.SetBitAt(i+n, true)
+	}
+	return extended
+}
+
+// CellsToVerifyFromPartialMessage returns cells from the partial message that need to be verified.
+func (p *PartialDataColumn) CellsToVerifyFromPartialMessage(message *ethpb.PartialDataColumnSidecar) ([]uint64, []CellProofBundle, error) {
+	included := message.CellsPresentBitmap
+	if included.Len() == 0 {
+		return nil, nil, nil
+	}
+
+	// Some basic sanity checks
+	includedCells := included.Count()
+	if uint64(len(message.KzgProofs)) != includedCells {
+		return nil, nil, errors.New("invalid message. Missing KZG proofs")
+	}
+	if uint64(len(message.PartialColumn)) != includedCells {
+		return nil, nil, errors.New("invalid message. Missing cells")
+	}
+
+	ourIncludedList := p.Included
+	if included.Len() != ourIncludedList.Len() {
+		return nil, nil, errors.New("invalid message. Wrong bitmap length.")
+	}
+
+	cellIndices := make([]uint64, 0, includedCells)
+	cellsToVerify := make([]CellProofBundle, 0, includedCells)
+	// Filter out cells we already have
+	for i := range included.Len() {
+		if len(message.PartialColumn) == 0 {
+			break
+		}
+		if !included.BitAt(i) {
+			continue
+		}
+
+		if !ourIncludedList.BitAt(i) {
+			cellIndices = append(cellIndices, i)
+			cellsToVerify = append(cellsToVerify, CellProofBundle{
+				ColumnIndex: p.Index,
+				Cell:        message.PartialColumn[0],
+				Proof:       message.KzgProofs[0],
+				// Use the commitment from our datacolumn, indexed by i since we
+				// have all commitments.
+				Commitment: p.KzgCommitments[i],
+			})
+		}
+		message.PartialColumn = message.PartialColumn[1:]
+		message.KzgProofs = message.KzgProofs[1:]
+	}
+	return cellIndices, cellsToVerify, nil
+}
+
+// ExtendFromVerfifiedCells will extend this partial column with the provided verified cells
+func (p *PartialDataColumn) ExtendFromVerfifiedCell(cellIndex uint64, cell, proof []byte) bool {
+	if p.Included.BitAt(cellIndex) {
+		// We already have this cell
+		return false
+	}
+
+	p.Included.SetBitAt(cellIndex, true)
+	p.Column[cellIndex] = cell
+	p.KzgProofs[cellIndex] = proof
+	return true
+}
+
+// ExtendFromVerfifiedCells will extend this partial column with the provided verified cells
+func (p *PartialDataColumn) ExtendFromVerfifiedCells(cellIndices []uint64, cells []CellProofBundle) /* extended */ bool {
+	var extended bool
+	for i, bundle := range cells {
+		if bundle.ColumnIndex != p.Index {
+			// Invalid column index, shouldn't happen
+			return false
+		}
+		if p.ExtendFromVerfifiedCell(cellIndices[i], bundle.Cell, bundle.Proof) {
+			extended = true
+		}
+	}
+	return extended
+}
+
+func (p *PartialDataColumn) Complete(logger *logrus.Logger) (VerifiedRODataColumn, bool) {
+	if uint64(len(p.KzgCommitments)) != p.Included.Count() {
+		return VerifiedRODataColumn{}, false
+	}
+
+	rodc, err := NewRODataColumn(p.DataColumnSidecar)
+	if err != nil {
+		// We shouldn't get an error, as we check the hash root when creating
+		// the partial column
+		logger.Error("failed to create RODataColumn", "err", err)
+		return VerifiedRODataColumn{}, false
+	}
+
+	return NewVerifiedRODataColumn(rodc), true
+}

consensus-types/blocks/partialdatacolumn_invariants_test.go

@@ -0,0 +1,165 @@
+package blocks_test
+
+import (
+	"bytes"
+	"fmt"
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/testing/util"
+	"github.com/libp2p/go-libp2p-pubsub/partialmessages"
+	"github.com/libp2p/go-libp2p/core/peer"
+)
+
+type invariantChecker struct {
+	t *testing.T
+}
+
+var _ partialmessages.InvariantChecker[*blocks.PartialDataColumn] = (*invariantChecker)(nil)
+
+func (i *invariantChecker) MergePartsMetadata(left, right partialmessages.PartsMetadata) partialmessages.PartsMetadata {
+	merged, err := blocks.MergePartsMetadata(left, right)
+	if err != nil {
+		i.t.Fatal(err)
+	}
+	return merged
+}
+
+func (i *invariantChecker) SplitIntoParts(in *blocks.PartialDataColumn) ([]*blocks.PartialDataColumn, error) {
+	var parts []*blocks.PartialDataColumn
+	for idx := range in.Column {
+		if !in.Included.BitAt(uint64(idx)) {
+			continue
+		}
+		msg := i.EmptyMessage()
+		msg.Included.SetBitAt(uint64(idx), true)
+		msg.KzgCommitments = in.KzgCommitments
+		msg.Column[idx] = in.Column[idx]
+		msg.KzgProofs[idx] = in.KzgProofs[idx]
+		parts = append(parts, msg)
+	}
+	return parts, nil
+}
+
+func (i *invariantChecker) FullMessage() (*blocks.PartialDataColumn, error) {
+	blockRoot := []byte("test-block-root")
+	numCells := 128
+	commitments := make([][]byte, numCells)
+	cells := make([][]byte, numCells)
+	proofs := make([][]byte, numCells)
+
+	for i := range numCells {
+		for j := range commitments[i] {
+			commitments[i][j] = byte(i)
+		}
+		cells[i] = make([]byte, 2048)
+		cells[i] = fmt.Appendf(cells[i][:0], "cell %d", i)
+		proofs[i] = make([]byte, 48)
+		proofs[i] = fmt.Appendf(proofs[i][:0], "proof %d", i)
+	}
+
+	roDC, _ := util.CreateTestVerifiedRoDataColumnSidecars(i.t, []util.DataColumnParam{
+		{
+			BodyRoot:       blockRoot,
+			KzgCommitments: commitments,
+			Column:         cells,
+			KzgProofs:      proofs,
+		},
+	})
+
+	c, err := blocks.NewPartialDataColumn(roDC[0].DataColumnSidecar.SignedBlockHeader, roDC[0].Index, roDC[0].KzgCommitments, roDC[0].KzgCommitmentsInclusionProof)
+	return &c, err
+}
+
+func (i *invariantChecker) EmptyMessage() *blocks.PartialDataColumn {
+	blockRoot := []byte("test-block-root")
+	numCells := 128
+	commitments := make([][]byte, numCells)
+	cells := make([][]byte, numCells)
+	proofs := make([][]byte, numCells)
+	roDC, _ := util.CreateTestVerifiedRoDataColumnSidecars(i.t, []util.DataColumnParam{
+		{
+			BodyRoot:       blockRoot,
+			KzgCommitments: commitments,
+			Column:         cells,
+			KzgProofs:      proofs,
+		},
+	})
+	for i := range roDC[0].Column {
+		// Clear these fields since this is an empty message
+		roDC[0].Column[i] = nil
+		roDC[0].KzgProofs[i] = nil
+	}
+
+	pc, err := blocks.NewPartialDataColumn(roDC[0].DataColumnSidecar.SignedBlockHeader, roDC[0].Index, roDC[0].KzgCommitments, roDC[0].KzgCommitmentsInclusionProof)
+	if err != nil {
+		panic(err)
+	}
+	return &pc
+}
+
+func (i *invariantChecker) ExtendFromBytes(a *blocks.PartialDataColumn, data []byte) (*blocks.PartialDataColumn, error) {
+	var message ethpb.PartialDataColumnSidecar
+	err := message.UnmarshalSSZ(data)
+	if err != nil {
+		return nil, err
+	}
+	cellIndices, bundle, err := a.CellsToVerifyFromPartialMessage(&message)
+	if err != nil {
+		return nil, err
+	}
+	// No validation happening here. Copy-pasters beware!
+	_ = a.ExtendFromVerfifiedCells(cellIndices, bundle)
+	return a, nil
+}
+
+func (i *invariantChecker) ShouldRequest(a *blocks.PartialDataColumn, from peer.ID, partsMetadata []byte) bool {
+	numCommitments := uint64(len(a.KzgCommitments))
+	available, requests, isNew := blocks.ParseMetadata(partsMetadata, numCommitments)
+	for idx := range available.Len() {
+		peerHasAndWilling := available.BitAt(idx) && (!isNew || requests.BitAt(idx))
+		if peerHasAndWilling && !a.Included.BitAt(idx) {
+			return true
+		}
+	}
+	return false
+}
+
+func (i *invariantChecker) Equal(a, b *blocks.PartialDataColumn) bool {
+	if !bytes.Equal(a.GroupID(), b.GroupID()) {
+		return false
+	}
+	if !bytes.Equal(a.Included, b.Included) {
+		return false
+	}
+	if len(a.KzgCommitments) != len(b.KzgCommitments) {
+		return false
+	}
+	for i := range a.KzgCommitments {
+		if !bytes.Equal(a.KzgCommitments[i], b.KzgCommitments[i]) {
+			return false
+		}
+	}
+	if len(a.Column) != len(b.Column) {
+		return false
+	}
+	for i := range a.Column {
+		if !bytes.Equal(a.Column[i], b.Column[i]) {
+			return false
+		}
+	}
+	if len(a.KzgProofs) != len(b.KzgProofs) {
+		return false
+	}
+	for i := range a.KzgProofs {
+		if !bytes.Equal(a.KzgProofs[i], b.KzgProofs[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+func TestDataColumnInvariants(t *testing.T) {
+	partialmessages.TestPartialMessageInvariants(t, &invariantChecker{t})
+}

consensus-types/blocks/rodatacolumn.go

@@ -1,6 +1,8 @@
 package blocks
 
 import (
+	"iter"
+
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
@@ -85,3 +87,20 @@ type VerifiedRODataColumn struct {
 func NewVerifiedRODataColumn(roDataColumn RODataColumn) VerifiedRODataColumn {
 	return VerifiedRODataColumn{RODataColumn: roDataColumn}
 }
+
+func RODataColumnsToCellProofBundles(sidecars []RODataColumn) iter.Seq[CellProofBundle] {
+	return func(yield func(CellProofBundle) bool) {
+		for _, sidecar := range sidecars {
+			for i := range sidecar.Column {
+				if !yield(CellProofBundle{
+					ColumnIndex: sidecar.Index,
+					Commitment:  sidecar.KzgCommitments[i],
+					Cell:        sidecar.Column[i],
+					Proof:       sidecar.KzgProofs[i],
+				}) {
+					return
+				}
+			}
+		}
+	}
+}

deps.bzl

@@ -76,12 +76,6 @@ def prysm_deps():
         sum = "h1:eMwmnE/GDgah4HI848JfFxHt+iPb26b4zyfspmqY0/8=",
         version = "v1.2.1-0.20190218064605-e24eb225f156",
     )
-    go_repository(
-        name = "com_github_andreasbriese_bbloom",
-        importpath = "github.com/AndreasBriese/bbloom",
-        sum = "h1:cTp8I5+VIoKjsnZuH8vjyaysT/ses3EvZeaV/1UkF2M=",
-        version = "v0.0.0-20190825152654-46b345b51c96",
-    )
     go_repository(
         name = "com_github_andybalholm_brotli",
         importpath = "github.com/andybalholm/brotli",
@@ -376,12 +370,6 @@ def prysm_deps():
         sum = "h1:nCb6ZLdB7NRaqsm91JtQTAme2SKJzXVsdPIPkyJr1MU=",
         version = "v1.1.1",
     )
-    go_repository(
-        name = "com_github_cespare_xxhash",
-        importpath = "github.com/cespare/xxhash",
-        sum = "h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=",
-        version = "v1.1.0",
-    )
     go_repository(
         name = "com_github_cespare_xxhash_v2",
         importpath = "github.com/cespare/xxhash/v2",
@@ -406,12 +394,6 @@ def prysm_deps():
         sum = "h1:p3BQDXSxOhOG0P9z6/hGnII4LGiEPOYBhs8asl/fC04=",
         version = "v1.0.0",
     )
-    go_repository(
-        name = "com_github_cilium_ebpf",
-        importpath = "github.com/cilium/ebpf",
-        sum = "h1:64sn2K3UKw8NbP/blsixRpF3nXuyhz/VjRlRzvlBRu4=",
-        version = "v0.9.1",
-    )
     go_repository(
         name = "com_github_clbanning_x2j",
         importpath = "github.com/clbanning/x2j",
@@ -644,18 +626,6 @@ def prysm_deps():
         sum = "h1:SegyeYGcdi0jLLrpbCMoJxnUUn8GBXHsvr4rbzjuhfU=",
         version = "v1.8.2",
     )
-    go_repository(
-        name = "com_github_dgraph_io_badger",
-        importpath = "github.com/dgraph-io/badger",
-        sum = "h1:mNw0qs90GVgGGWylh0umH5iag1j6n/PeJtNvL6KY/x8=",
-        version = "v1.6.2",
-    )
-    go_repository(
-        name = "com_github_dgraph_io_ristretto",
-        importpath = "github.com/dgraph-io/ristretto",
-        sum = "h1:a5WaUrDa0qm0YrAAS1tUykT5El3kt62KNZZeMxQn3po=",
-        version = "v0.0.2",
-    )
     go_repository(
         name = "com_github_dgraph_io_ristretto_v2",
         importpath = "github.com/dgraph-io/ristretto/v2",
@@ -1634,20 +1604,8 @@ def prysm_deps():
     go_repository(
         name = "com_github_ipfs_go_datastore",
         importpath = "github.com/ipfs/go-datastore",
-        sum = "h1:JKyz+Gvz1QEZw0LsX1IBn+JFCJQH4SJVFtM4uWU0Myk=",
-        version = "v0.6.0",
-    )
-    go_repository(
-        name = "com_github_ipfs_go_ds_badger",
-        importpath = "github.com/ipfs/go-ds-badger",
-        sum = "h1:xREL3V0EH9S219kFFueOYJJTcjgNSZ2HY1iSvN7U1Ro=",
-        version = "v0.3.0",
-    )
-    go_repository(
-        name = "com_github_ipfs_go_ds_leveldb",
-        importpath = "github.com/ipfs/go-ds-leveldb",
-        sum = "h1:s++MEBbD3ZKc9/8/njrn4flZLnCuY9I79v94gBUNumo=",
-        version = "v0.5.0",
+        sum = "h1:Jy3wjqQR6sg/LhyY0NIePZC3Vux19nLtg7dx0TVqr6U=",
+        version = "v0.8.2",
     )
     go_repository(
         name = "com_github_ipfs_go_log_v2",
@@ -1674,12 +1632,6 @@ def prysm_deps():
         sum = "h1:zpb3ZH6wIE8Shj2sKS+khgRvf7T7RABoLk/+KKHggpk=",
         version = "v0.1.0",
     )
-    go_repository(
-        name = "com_github_jbenet_goprocess",
-        importpath = "github.com/jbenet/goprocess",
-        sum = "h1:DRGOFReOMqqDNXwW70QkacFW0YN9QnwLV0Vqk+3oU0o=",
-        version = "v0.1.4",
-    )
     go_repository(
         name = "com_github_jcmturner_gofork",
         importpath = "github.com/jcmturner/gofork",
@@ -1852,8 +1804,8 @@ def prysm_deps():
     go_repository(
         name = "com_github_klauspost_cpuid_v2",
         importpath = "github.com/klauspost/cpuid/v2",
-        sum = "h1:66ze0taIn2H33fBvCkXuv9BmCwDfafmiIVpKV9kKGuY=",
-        version = "v2.2.9",
+        sum = "h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=",
+        version = "v2.2.10",
     )
     go_repository(
         name = "com_github_klauspost_reedsolomon",
@@ -1876,8 +1828,8 @@ def prysm_deps():
     go_repository(
         name = "com_github_koron_go_ssdp",
         importpath = "github.com/koron/go-ssdp",
-        sum = "h1:E1iSMxIs4WqxTbIBLtmNBeOOC+1sCIXQeqTWVnpmwhk=",
-        version = "v0.0.5",
+        sum = "h1:Jb0h04599eq/CY7rB5YEqPS83HmRfHP2azkxMN2rFtU=",
+        version = "v0.0.6",
     )
     go_repository(
         name = "com_github_kr_fs",
@@ -1958,8 +1910,8 @@ def prysm_deps():
         ],
         build_file_proto_mode = "disable_global",
         importpath = "github.com/libp2p/go-libp2p",
-        sum = "h1:1Ur6rPCf3GR+g8jkrnaQaM0ha2IGespsnNlCqJLLALE=",
-        version = "v0.39.1",
+        sum = "h1:5Gtt8OrF8yiXmH+Mx4+/iBeFRMK1TY3a8OrEBDEqAvs=",
+        version = "v0.44.0",
     )
     go_repository(
         name = "com_github_libp2p_go_libp2p_asn_util",
@@ -1970,15 +1922,15 @@ def prysm_deps():
     go_repository(
         name = "com_github_libp2p_go_libp2p_mplex",
         importpath = "github.com/libp2p/go-libp2p-mplex",
-        sum = "h1:R58pDRAmuBXkYugbSSXR9wrTX3+1pFM1xP2bLuodIq8=",
-        version = "v0.9.0",
+        sum = "h1:0vwpLXRSfkTzshEjETIEgJaVxXvg+orbxYoIb3Ty5qM=",
+        version = "v0.11.0",
     )
     go_repository(
         name = "com_github_libp2p_go_libp2p_pubsub",
         build_file_proto_mode = "disable_global",
         importpath = "github.com/libp2p/go-libp2p-pubsub",
-        sum = "h1:nT5lFHPQOFJcp9CW8hpKtvbpQNdl2udJuzLQWbgRum8=",
-        version = "v0.14.2",
+        sum = "h1:dJcYvoeKRxO2DbwG8E3nlZHbEMaxnEzghBltmGel93U=",
+        version = "v0.15.1-0.20260127225230-d9e98cd10cf3",
     )
     go_repository(
         name = "com_github_libp2p_go_libp2p_testing",
@@ -2022,6 +1974,12 @@ def prysm_deps():
         sum = "h1:nrLh89LN/LEiqcFiqdKDRHjGstN300C1269K/EX0CPU=",
         version = "v4.0.2",
     )
+    go_repository(
+        name = "com_github_libp2p_go_yamux_v5",
+        importpath = "github.com/libp2p/go-yamux/v5",
+        sum = "h1:f0WoX/bEF2E8SbE4c/k1Mo+/9z0O4oC/hWEA+nfYRSg=",
+        version = "v5.0.1",
+    )
     go_repository(
         name = "com_github_libp2p_zeroconf_v2",
         importpath = "github.com/libp2p/zeroconf/v2",
@@ -2082,6 +2040,12 @@ def prysm_deps():
         sum = "h1:3l11YT8tm9MnwGFQ4kETwkzpAwY2Jt9lCrumCUW4+z4=",
         version = "v0.7.0",
     )
+    go_repository(
+        name = "com_github_marcopolo_simnet",
+        importpath = "github.com/marcopolo/simnet",
+        sum = "h1:rSMslhPz6q9IvJeFWDoMGxMIrlsbXau3NkuIXHGJxfg=",
+        version = "v0.0.1",
+    )
     go_repository(
         name = "com_github_marten_seemann_tcp",
         importpath = "github.com/marten-seemann/tcp",
@@ -2139,8 +2103,8 @@ def prysm_deps():
     go_repository(
         name = "com_github_miekg_dns",
         importpath = "github.com/miekg/dns",
-        sum = "h1:8M5aAw6OMZfFXTT7K5V0Eu5YiiL8l7nUAkyN6C9YwaY=",
-        version = "v1.1.63",
+        sum = "h1:FeZXOS3VCVsKnEAd+wBkjMC3D2K+ww66Cq3VnCINuJE=",
+        version = "v1.1.66",
     )
     go_repository(
         name = "com_github_mikioh_tcp",
@@ -2277,8 +2241,8 @@ def prysm_deps():
     go_repository(
         name = "com_github_multiformats_go_multiaddr",
         importpath = "github.com/multiformats/go-multiaddr",
-        sum = "h1:bfrHrJhrRuh/NXH5mCnemjpbGjzRw/b+tJFOD41g2tU=",
-        version = "v0.14.0",
+        sum = "h1:oGWEVKioVQcdIOBlYM8BH1rZDWOGJSqr9/BKl6zQ4qc=",
+        version = "v0.16.0",
     )
     go_repository(
         name = "com_github_multiformats_go_multiaddr_dns",
@@ -2304,8 +2268,8 @@ def prysm_deps():
             "gazelle:exclude gen.go",
         ],
         importpath = "github.com/multiformats/go-multicodec",
-        sum = "h1:pb/dlPnzee/Sxv/j4PmkDRxCOi3hXTz3IbPKOXWJkmg=",
-        version = "v0.9.0",
+        sum = "h1:x/Fuxr7ZuR4jJV4Os5g444F7xC4XmyUaT/FWtE+9Zjo=",
+        version = "v0.9.1",
     )
     go_repository(
         name = "com_github_multiformats_go_multihash",
@@ -2316,8 +2280,8 @@ def prysm_deps():
     go_repository(
         name = "com_github_multiformats_go_multistream",
         importpath = "github.com/multiformats/go-multistream",
-        sum = "h1:ZaHKbsL404720283o4c/IHQXiS6gb8qAN5EIJ4PN5EA=",
-        version = "v0.6.0",
+        sum = "h1:4aoX5v6T+yWmc2raBHsTvzmFhOI8WVOer28DeBBEYdQ=",
+        version = "v0.6.1",
     )
     go_repository(
         name = "com_github_multiformats_go_varint",
@@ -2400,8 +2364,8 @@ def prysm_deps():
     go_repository(
         name = "com_github_nxadm_tail",
         importpath = "github.com/nxadm/tail",
-        sum = "h1:8feyoE3OzPrcshW5/MJ4sGESc5cqmGkGCWlco4l0bqY=",
-        version = "v1.4.11",
+        sum = "h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78=",
+        version = "v1.4.4",
     )
     go_repository(
         name = "com_github_offchainlabs_hashtree",
@@ -2613,8 +2577,8 @@ def prysm_deps():
     go_repository(
         name = "com_github_pion_dtls_v3",
         importpath = "github.com/pion/dtls/v3",
-        sum = "h1:44CZekewMzfrn9pmGrj5BNnTMDCFwr+6sLH+cCuLM7U=",
-        version = "v3.0.4",
+        sum = "h1:7Hkd8WhAJNbRgq9RgdNh1aaWlZlGpYTzdqjy9x9sK2E=",
+        version = "v3.0.6",
     )
     go_repository(
         name = "com_github_pion_ice_v2",
@@ -2625,14 +2589,14 @@ def prysm_deps():
     go_repository(
         name = "com_github_pion_ice_v4",
         importpath = "github.com/pion/ice/v4",
-        sum = "h1:jmM9HwI9lfetQV/39uD0nY4y++XZNPhvzIPCb8EwxUM=",
-        version = "v4.0.6",
+        sum = "h1:P59w1iauC/wPk9PdY8Vjl4fOFL5B+USq1+xbDcN6gT4=",
+        version = "v4.0.10",
     )
     go_repository(
         name = "com_github_pion_interceptor",
         importpath = "github.com/pion/interceptor",
-        sum = "h1:aRA8Zpab/wE7/c0O3fh1PqY0AJI3fCSEM5lRWJVorwI=",
-        version = "v0.1.37",
+        sum = "h1:e0BjnPcGpr2CFQgKhrQisBU7V3GXK6wrfYrGYaU6Jq4=",
+        version = "v0.1.40",
     )
     go_repository(
         name = "com_github_pion_logging",
@@ -2667,26 +2631,26 @@ def prysm_deps():
     go_repository(
         name = "com_github_pion_rtp",
         importpath = "github.com/pion/rtp",
-        sum = "h1:17xjnY5WO5hgO6SD3/NTIUPvSFw/PbLsIJyz1r1yNIk=",
-        version = "v1.8.11",
+        sum = "h1:jhdO/3XhL/aKm/wARFVmvTfq0lC/CvN1xwYKmduly3c=",
+        version = "v1.8.19",
     )
     go_repository(
         name = "com_github_pion_sctp",
         importpath = "github.com/pion/sctp",
-        sum = "h1:qwtKvNK1Wc5tHMIYgTDJhfZk7vATGVHhXbUDfHbYwzA=",
-        version = "v1.8.35",
+        sum = "h1:PJma40vRHa3UTO3C4MyeJDQ+KIobVYRZQZ0Nt7SjQnE=",
+        version = "v1.8.39",
     )
     go_repository(
         name = "com_github_pion_sdp_v3",
         importpath = "github.com/pion/sdp/v3",
-        sum = "h1:6MChLE/1xYB+CjumMw+gZ9ufp2DPApuVSnDT8t5MIgA=",
-        version = "v3.0.10",
+        sum = "h1:uN3SS2b+QDZnWXgdr69SM8KB4EbcnPnPf2Laxhty/l4=",
+        version = "v3.0.13",
     )
     go_repository(
         name = "com_github_pion_srtp_v3",
         importpath = "github.com/pion/srtp/v3",
-        sum = "h1:2Z6vDVxzrX3UHEgrUyIGM4rRouoC7v+NiF1IHtp9B5M=",
-        version = "v3.0.4",
+        sum = "h1:E2gyj1f5X10sB/qILUGIkL4C2CqK269Xq167PbGCc/4=",
+        version = "v3.0.6",
     )
     go_repository(
         name = "com_github_pion_stun",
@@ -2727,14 +2691,14 @@ def prysm_deps():
     go_repository(
         name = "com_github_pion_turn_v4",
         importpath = "github.com/pion/turn/v4",
-        sum = "h1:qxplo3Rxa9Yg1xXDxxH8xaqcyGUtbHYw4QSCvmFWvhM=",
-        version = "v4.0.0",
+        sum = "h1:ZqgQ3+MjP32ug30xAbD6Mn+/K4Sxi3SdNOTFf+7mpps=",
+        version = "v4.0.2",
     )
     go_repository(
         name = "com_github_pion_webrtc_v4",
         importpath = "github.com/pion/webrtc/v4",
-        sum = "h1:T1ZmnT9qxIJIt4d8XoiMOBrTClGHDDXNg9e/fh018Qc=",
-        version = "v4.0.8",
+        sum = "h1:mpuUo/EJ1zMNKGE79fAdYNFZBX790KE7kQQpLMjjR54=",
+        version = "v4.1.2",
     )
     go_repository(
         name = "com_github_pkg_diff",
@@ -2793,26 +2757,26 @@ def prysm_deps():
     go_repository(
         name = "com_github_prometheus_client_golang",
         importpath = "github.com/prometheus/client_golang",
-        sum = "h1:cxppBPuYhUnsO6yo/aoRol4L7q7UFfdm+bR9r+8l63Y=",
-        version = "v1.20.5",
+        sum = "h1:rb93p9lokFEsctTys46VnV1kLCDpVZ0a/Y92Vm0Zc6Q=",
+        version = "v1.22.0",
     )
     go_repository(
         name = "com_github_prometheus_client_model",
         importpath = "github.com/prometheus/client_model",
-        sum = "h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=",
-        version = "v0.6.1",
+        sum = "h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk=",
+        version = "v0.6.2",
     )
     go_repository(
         name = "com_github_prometheus_common",
         importpath = "github.com/prometheus/common",
-        sum = "h1:xasJaQlnWAeyHdUBeGjXmutelfJHWMRr+Fg4QszZ2Io=",
-        version = "v0.62.0",
+        sum = "h1:pdZeA+g617P7oGv1CzdTzyeShxAGrTBsolKNOLQPGO4=",
+        version = "v0.64.0",
     )
     go_repository(
         name = "com_github_prometheus_procfs",
         importpath = "github.com/prometheus/procfs",
-        sum = "h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=",
-        version = "v0.15.1",
+        sum = "h1:hZ15bTNuirocR6u0JZ6BAHHmwS1p8B4P6MRqxtzMyRg=",
+        version = "v0.16.1",
     )
     go_repository(
         name = "com_github_prometheus_prom2json",
@@ -2884,14 +2848,14 @@ def prysm_deps():
             "gazelle:exclude tools.go",
         ],
         importpath = "github.com/quic-go/quic-go",
-        sum = "h1:x09Agz4ATTMEP3qb5P0MRxNZfd6O9wAyK3qwwqQZVQc=",
-        version = "v0.49.1-0.20250925085836-275c172fec2b",
+        sum = "h1:zccPQIqYCXDt5NmcEabyYvOnomjs8Tlwl7tISjJh9Mk=",
+        version = "v0.55.0",
     )
     go_repository(
         name = "com_github_quic_go_webtransport_go",
         importpath = "github.com/quic-go/webtransport-go",
-        sum = "h1:4WFk6u3sOT6pLa1kQ50ZVdm8BQFgJNA117cepZxtLIg=",
-        version = "v0.8.1-0.20241018022711-4ac2c9250e66",
+        sum = "h1:jgys+7/wm6JarGDrW+lD/r9BGqBAmqY/ssklE09bA70=",
+        version = "v0.9.0",
     )
     go_repository(
         name = "com_github_r3labs_sse_v2",
@@ -3377,8 +3341,8 @@ def prysm_deps():
     go_repository(
         name = "com_github_urfave_cli",
         importpath = "github.com/urfave/cli",
-        sum = "h1:gsqYFH8bb9ekPA12kRo0hfjngWQjkJPlN9R0N78BoUo=",
-        version = "v1.22.2",
+        sum = "h1:+mkCCcOFKPnCmVYVcURKps1Xe+3zP90gSYGNfRkjoIY=",
+        version = "v1.22.1",
     )
     go_repository(
         name = "com_github_urfave_cli_v2",
@@ -4298,8 +4262,8 @@ def prysm_deps():
     go_repository(
         name = "com_lukechampine_blake3",
         importpath = "lukechampine.com/blake3",
-        sum = "h1:sJ3XhFINmHSrYCgl958hscfIa3bw8x4DqMP3u1YvoYE=",
-        version = "v1.3.0",
+        sum = "h1:I3Smz7gso8w4/TunLKec6K2fn+kyKtDxr/xcQEN84Wg=",
+        version = "v1.4.1",
     )
     go_repository(
         name = "com_shuralyov_dmitri_app_changes",
@@ -4723,8 +4687,8 @@ def prysm_deps():
     go_repository(
         name = "org_golang_google_protobuf",
         importpath = "google.golang.org/protobuf",
-        sum = "h1:tPhr+woSbjfYvY6/GPufUoYizxw1cF/yFoxJ2fmpwlM=",
-        version = "v1.36.5",
+        sum = "h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=",
+        version = "v1.36.6",
     )
     go_repository(
         name = "org_golang_x_build",
@@ -4741,8 +4705,8 @@ def prysm_deps():
     go_repository(
         name = "org_golang_x_exp",
         importpath = "golang.org/x/exp",
-        sum = "h1:y5zboxd6LQAqYIhHnB48p0ByQ/GnQx2BE33L8BOHQkI=",
-        version = "v0.0.0-20250506013437-ce4c2cf36ca6",
+        sum = "h1:bsqhLWFR6G6xiQcb+JoGqdKdRU6WzPWmK8E0jxTjzo4=",
+        version = "v0.0.0-20250606033433-dcc06ee1d476",
     )
     go_repository(
         name = "org_golang_x_exp_typeparams",
@@ -4783,8 +4747,8 @@ def prysm_deps():
     go_repository(
         name = "org_golang_x_oauth2",
         importpath = "golang.org/x/oauth2",
-        sum = "h1:CY4y7XT9v0cRI9oupztF8AgiIu99L/ksR/Xp/6jrZ70=",
-        version = "v0.25.0",
+        sum = "h1:dnDm7JmhM45NNpd8FDDeLhK6FwqbOf4MLCM9zb1BOHI=",
+        version = "v0.30.0",
     )
     go_repository(
         name = "org_golang_x_perf",
@@ -4825,8 +4789,8 @@ def prysm_deps():
     go_repository(
         name = "org_golang_x_time",
         importpath = "golang.org/x/time",
-        sum = "h1:EsRrnYcQiGH+5FfbgvV4AP7qEZstoyrHB0DzarOQ4ZY=",
-        version = "v0.9.0",
+        sum = "h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE=",
+        version = "v0.12.0",
     )
     go_repository(
         name = "org_golang_x_tools",
@@ -4866,14 +4830,14 @@ def prysm_deps():
     go_repository(
         name = "org_uber_go_dig",
         importpath = "go.uber.org/dig",
-        sum = "h1:imUL1UiY0Mg4bqbFfsRQO5G4CGRBec/ZujWTvSVp3pw=",
-        version = "v1.18.0",
+        sum = "h1:BACLhebsYdpQ7IROQ1AGPjrXcP5dF80U3gKoFzbaq/4=",
+        version = "v1.19.0",
     )
     go_repository(
         name = "org_uber_go_fx",
         importpath = "go.uber.org/fx",
-        sum = "h1:lIr/gYWQGfTwGcSXWXu4vP5Ws6iqnNEIY+F/aFzCKTg=",
-        version = "v1.23.0",
+        sum = "h1:wE8mruvpg2kiiL1Vqd0CC+tr0/24XIB10Iwp2lLWzkg=",
+        version = "v1.24.0",
     )
     go_repository(
         name = "org_uber_go_goleak",